fp6 test passes

evm/src/cpu/kernel/asm/fields/fp12_mul.asm

@@ -90,7 +90,7 @@ post_mul_1:
     // stack:            g , in0, g'  , f', in0, in1, out  {36: sh(f'g'), 42: f'g'}
     %swap_fp6_hole
     // stack:            g', in0, g   , f', in0, in1, out  {36: sh(f'g'), 42: f'g'}
-    dup_fp6_7
+    %dup_fp6_7
     // stack:          g,g', in0, g   , f', in0, in1, out  {36: sh(f'g'), 42: f'g'}
     %add_fp6
     // stack:          g+g', in0, g   , f', in0, in1, out  {36: sh(f'g'), 42: f'g'}
@@ -132,7 +132,7 @@ post_mul_3:
     // stack:          f'g'+fg, (f+f')(g+g'), fg, in1, out  {36: sh(f'g'), 42: f'g', 48: fg}
     %subr_fp6
     // stack:       (f+f')(g+g') - (f'g'+fg), fg, in1, out  {36: sh(f'g'), 42: f'g', 48: fg}   
-    DUP14  add_const(6) 
+    DUP14  %add_const(6) 
     // stack: out', (f+f')(g+g') - (f'g'+fg), fg, in1, out  {36: sh(f'g'), 42: f'g', 48: fg}   
     %store_fp6
     // stack:                                 fg, in1, out  {36: sh(f'g'), 42: f'g', 48: fg}

evm/src/cpu/kernel/asm/fields/fp6_mul.asm

@@ -1,5 +1,8 @@
 // cost: 156
 global mul_fp6:
+    /// initial stack: c0, c0_, c1, c1_, c2, c2_, d0, d0_, d1, d1_, d2, d2_, retdest
+    /// final   stack: e0, e0_, e1, e1_, e2, e2_
+
     /// C = C0 + C1t + C2t^2 
     ///   = (c0 + c0_i) + (c1 + c1_i)t + (c2 + c2_i)t^2
     ///
@@ -7,10 +10,7 @@ global mul_fp6:
     ///   = (d0 + d0_i) + (d1 + d1_i)t + (d2 + d2_i)t^2
     ///
     /// E = E0 + E1t + E2t^2 = CD
-    ///
-    /// initial stack: c0, c0_, c1, c1_, c2, c2_, d0, d0_, d1, d1_, d2, d2_
-    /// final   stack: e0, e0_, e1, e1_, e2, e2_
-
+    
     /// E0 = C0D0 + i9(C1D2 + C2D1)
     ///
     /// C0D0 = (c0d0 - c0_d0_) + (c0d0_ + c0_d0)i
@@ -77,6 +77,7 @@ global mul_fp6:
     // stack: c0d2  + c1d1  + c2d0, c0_d2_ + c1_d1_ + c2_d0_
     SUBFP254
     SWAP12
+
     // E0, E0_
     // make CDX_ = c1d2_ + c1_d2 + c2d1_ + c2_d1
     DUP1
@@ -144,6 +145,7 @@ global mul_fp6:
     ADDFP254
     // stack:              9CDX_ + CDX + C0D0_
     SWAP11
+
     // E1, E1_
     // make C2D2_ = c2d2_ + c2_d2
     DUP14
@@ -240,4 +242,4 @@ global mul_fp6:
     MULFP254
     ADDFP254
     SWAP6
-    JUMP
+    JUMP

evm/src/cpu/kernel/tests/fields.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use ethereum_types::U256;
 use rand::{thread_rng, Rng};
+use std::str::FromStr;
 
 use crate::cpu::kernel::aggregator::combined_kernel;
 use crate::cpu::kernel::interpreter::run_with_kernel;
@@ -123,25 +124,61 @@ fn gen_fp6() -> [[u32; 2]; 3] {
 }
 
 fn as_stack(xs: Vec<u32>) -> Vec<U256> {
-    xs.iter().map(|&x| U256::from(x) % P254).rev().collect()
+    xs.iter().map(|&x| U256::from(x)).rev().collect()
 }
 
+// fn make_initial_stack(f0: [[u32; 2]; 3], f1: [[u32; 2]; 3], g0: [[u32; 2]; 3], g1: [[u32; 2]; 3]) -> Vec<U256> {
+//     let f0: Vec<u32> = f0.into_iter().flatten().collect();
+//     let f1: Vec<u32> = f1.into_iter().flatten().collect();
+//     let g0: Vec<u32> = g0.into_iter().flatten().collect();
+//     let g1: Vec<u32> = g1.into_iter().flatten().collect();
+
+//     // let mut input: Vec<u32> = vec![0];
+    
+//     // vec![vec![0], f0, vec![6], f1, vec![12], g0, vec![18], g1, vec![12,24,0,24]]
+//     // let input: Vec<u32> = [vec![[0]], f0, [[6]], f1, [[12]], g0, [[18]], g1, [[12, 24, 0, 24]]].into_iter().flatten().flatten().flatten().collect();
+//     as_stack(input)
+// }
+
 #[test]
-fn test_fp12() -> Result<()> {
-    let f = [gen_fp6(), gen_fp6()];
-    let g = [gen_fp6(), gen_fp6()];
-    let input: Vec<u32> = [f, g].into_iter().flatten().flatten().flatten().collect();
-    let output: Vec<u32> = mul_fp12(f, g).into_iter().flatten().flatten().collect();
+fn test_fp6() -> Result<()> {
+    let c = gen_fp6();
+    let d = gen_fp6();
+    
+    let mut input: Vec<u32> = [c, d].into_iter().flatten().flatten().collect();
+    input.push(0xdeadbeef);
 
     let kernel = combined_kernel();
-    let initial_offset = kernel.global_labels["test_mul_Fp12"];
+    let initial_offset = kernel.global_labels["mul_fp6"];
     let initial_stack: Vec<U256> = as_stack(input);
     let final_stack: Vec<U256> = run_with_kernel(&kernel, initial_offset, initial_stack)?
         .stack()
         .to_vec();
 
+    let output: Vec<u32> = mul_fp6(c, d).into_iter().flatten().collect();
     let expected = as_stack(output);
+    
     assert_eq!(final_stack, expected);
 
     Ok(())
 }
+// fn test_fp12() -> Result<()> {
+//     let f0 = gen_fp6();
+//     let f1 = gen_fp6();
+//     let g0 = gen_fp6();
+//     let g1 = gen_fp6();
+
+//     let output: Vec<u32> = mul_fp12([f0, f1], [g0, g1]).into_iter().flatten().flatten().collect();
+
+//     let kernel = combined_kernel();
+//     let initial_offset = kernel.global_labels["test_mul_Fp12"];
+//     let initial_stack: Vec<U256> = make_initial_stack(f0,f1,g0,g1);
+//     let final_stack: Vec<U256> = run_with_kernel(&kernel, initial_offset, initial_stack)?
+//         .stack()
+//         .to_vec();
+
+//     let expected = as_stack(output);
+//     assert_eq!(final_stack, expected);
+
+//     Ok(())
+// }