fixes and updates

evm/src/cpu/kernel/asm/sha2.asm

@@ -7,15 +7,12 @@ global sha2_store:
     // stack: addr=0, num_bytes, num_bytes, x[0], x[1], ..., x[num_bytes - 1], retdest
     %mstore_kernel_general
     // stack: num_bytes, x[0], x[1], ..., x[num_bytes - 1], retdest
-    dup1
-    // stack: num_bytes, num_bytes, x[0], x[1], ..., x[num_bytes - 1], retdest
     push 1
     // stack: addr=1, counter=num_bytes, x[0], x[1], x[2], ... , x[num_bytes-1], retdest
 sha2_store_loop:
     JUMPDEST
     // stack: addr, counter, x[num_bytes-counter], ... , x[num_bytes-1], retdest
     dup1
-    STOP
     // stack: addr, addr, counter, x[num_bytes-counter], ... , x[num_bytes-1], retdest
     swap3
     // stack: x[num_bytes-counter], addr, counter, addr,  ... , x[num_bytes-1], retdest
@@ -23,11 +20,13 @@ sha2_store_loop:
     // stack: addr, x[num_bytes-counter], counter, addr,  ... , x[num_bytes-1], retdest
     %mstore_kernel_general
     // stack: counter, addr,  ... , x[num_bytes-1], retdest
-    dup1
     %decrement
     // stack: counter-1, addr,  ... , x[num_bytes-1], retdest
+    dup1
+    // stack: counter-1, counter-1, addr,  ... , x[num_bytes-1], retdest
     iszero
     %jumpi(sha2_store_end)
+    // stack: counter-1, addr,  ... , x[num_bytes-1], retdest
     swap1
     // stack: addr, counter-1,  ... , x[num_bytes-1], retdest
     %increment
@@ -37,12 +36,40 @@ sha2_store_end:
     JUMPDEST
     // stack: counter=0, addr, retdest
     %pop2
-    STOP
-    JUMP
-sha2_stop:
-    JUMPDEST
-    STOP
+    // stack: retdest
+    //JUMP
+    %jump(sha2_pad)
 
+global test_sha2_read:
+    JUMPDEST
+    // stack: retdest
+    push 0
+    // stack: 0, retdest
+    %mload_kernel_general
+    // stack: counter=num_bytes, retdest
+test_sha2_read_loop:
+    JUMPDEST
+    // stack: counter, retdest, [stack]
+    dup1
+    // stack: addr=counter, counter, retdest, [stack]
+    %mload_kernel_general
+    // stack: value, counter, retdest, [stack]
+    swap2
+    // stack: retdest, counter, value, [stack]
+    swap1
+    // stack: counter, retdest, value, [stack]
+    %decrement
+    // stack: counter-1, retdest, value, [stack]
+    dup1
+    iszero
+    %jumpi(test_sha2_read_end)
+    %jump(test_sha2_read_loop)
+test_sha2_read_end:
+    // stack: counter=0, retdest, [stack]
+    JUMPDEST
+    pop
+    // stack: retdest, [stack]
+    JUMP
 
 // Precodition: input is in memory, starting at 0 of kernel general segment, of the form
 //              num_bytes, x[0], x[1], ..., x[num_bytes - 1]

evm/src/cpu/kernel/interpreter.rs

@@ -74,6 +74,9 @@ pub struct Interpreter<'a> {
     pub(crate) memory: InterpreterMemory,
     pub(crate) generation_state: GenerationState<F>,
     prover_inputs_map: &'a HashMap<usize, ProverInputFn>,
+    /// Non-deterministic prover inputs, stored backwards so that popping the last item gives the
+    /// next prover input.
+    prover_inputs: Vec<U256>,
     pub(crate) halt_offsets: Vec<usize>,
     running: bool,
 }
@@ -435,8 +438,14 @@ impl<'a> Interpreter<'a> {
 
     fn run_shl(&mut self) {
         let shift = self.pop();
-        let x = self.pop();
-        self.push(x << shift);
+        let value = self.pop();
+        self.push(value << shift);
+    }
+
+    fn run_shr(&mut self) {
+        let shift = self.pop();
+        let value = self.pop();
+        self.push(value >> shift);
     }
 
     fn run_shr(&mut self) {

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

@@ -12,6 +12,8 @@ use crate::cpu::kernel::interpreter::run;
 fn test_sha2_store() -> Result<()> {
     let kernel = combined_kernel();
     let sha2_store = kernel.global_labels["sha2_store"];
+    // let test_sha2_read = kernel.global_labels["test_sha2_read"];
+
     let mut rng = thread_rng();
     let num_bytes = rng.gen_range(1..17);
     let mut bytes: Vec<U256> = Vec::with_capacity(num_bytes);
@@ -26,13 +28,22 @@ fn test_sha2_store() -> Result<()> {
     dbg!(num_bytes);
     dbg!(bytes.clone());
 
-    let mut initial_stack = vec![U256::from(num_bytes)];
-    initial_stack.extend(bytes);
-    initial_stack.push(U256::from_str("0xdeadbeef").unwrap());
-    initial_stack.reverse();
-    dbg!(initial_stack.clone());
-    let stack_with_kernel = run(&kernel.code, sha2_store, initial_stack)?.stack;
-    dbg!(stack_with_kernel);
+    let mut store_initial_stack = vec![U256::from(num_bytes)];
+    store_initial_stack.extend(bytes);
+    store_initial_stack.push(U256::from_str("0xdeadbeef").unwrap());
+    store_initial_stack.reverse();
+    dbg!(store_initial_stack.clone());
+    
+    let after_storing = run(&kernel.code, sha2_store, store_initial_stack)?;
+    let stack_after_storing = after_storing.stack;
+    dbg!(stack_after_storing.clone());
+    let memory_after_storing = after_storing.memory;
+    dbg!(memory_after_storing);
+
+
+    // let load_initial_stack = vec![U256::from_str("0xdeadbeef").unwrap()];
+    // let stack_after_loading = run(&kernel.code, test_sha2_read, load_initial_stack)?.stack;
+    // dbg!(stack_after_loading);
 
     // let expected_stack = todo!();
     // assert_eq!(stack_with_kernel, expected_stack);