Opcode SHL

zkevm-circuits/src/evm_circuit.rs

@@ -491,6 +491,7 @@ pub mod test {
                 FixedTableTag::Range1024,
                 FixedTableTag::SignByte,
                 FixedTableTag::ResponsibleOpcode,
+                FixedTableTag::Pow2,
             ],
         )
     }

zkevm-circuits/src/evm_circuit/execution.rs

@@ -59,6 +59,7 @@ mod pc;
 mod pop;
 mod push;
 mod selfbalance;
+mod shl;
 mod signed_comparator;
 mod signextend;
 mod sload;
@@ -103,6 +104,7 @@ use pc::PcGadget;
 use pop::PopGadget;
 use push::PushGadget;
 use selfbalance::SelfbalanceGadget;
+use shl::ShlGadget;
 use signed_comparator::SignedComparatorGadget;
 use signextend::SignextendGadget;
 use sload::SloadGadget;
@@ -177,6 +179,7 @@ pub(crate) struct ExecutionConfig<F> {
     pop_gadget: PopGadget<F>,
     push_gadget: PushGadget<F>,
     selfbalance_gadget: SelfbalanceGadget<F>,
+    shl_gadget: ShlGadget<F>,
     signed_comparator_gadget: SignedComparatorGadget<F>,
     signextend_gadget: SignextendGadget<F>,
     sload_gadget: SloadGadget<F>,
@@ -366,6 +369,7 @@ impl<F: Field> ExecutionConfig<F> {
             pop_gadget: configure_gadget!(),
             push_gadget: configure_gadget!(),
             selfbalance_gadget: configure_gadget!(),
+            shl_gadget: configure_gadget!(),
             signed_comparator_gadget: configure_gadget!(),
             signextend_gadget: configure_gadget!(),
             sload_gadget: configure_gadget!(),
@@ -804,6 +808,7 @@ impl<F: Field> ExecutionConfig<F> {
             ExecutionState::BLOCKCTXU160 => assign_exec_step!(self.block_ctx_u160_gadget),
             ExecutionState::BLOCKCTXU256 => assign_exec_step!(self.block_ctx_u256_gadget),
             ExecutionState::SELFBALANCE => assign_exec_step!(self.selfbalance_gadget),
+            ExecutionState::SHL => assign_exec_step!(self.shl_gadget),
             ExecutionState::SIGNEXTEND => assign_exec_step!(self.signextend_gadget),
             ExecutionState::SLOAD => assign_exec_step!(self.sload_gadget),
             ExecutionState::SSTORE => assign_exec_step!(self.sstore_gadget),

zkevm-circuits/src/evm_circuit/execution/shl.rs

@@ -0,0 +1,128 @@
+use crate::{
+    evm_circuit::{
+        execution::ExecutionGadget,
+        step::ExecutionState,
+        util::{
+            common_gadget::SameContextGadget,
+            constraint_builder::{ConstraintBuilder, StepStateTransition, Transition::Delta},
+            math_gadget::ShlWordsGadget,
+            CachedRegion,
+        },
+        witness::{Block, Call, ExecStep, Transaction},
+    },
+    util::Expr,
+};
+use bus_mapping::evm::OpcodeId;
+use eth_types::Field;
+use halo2_proofs::plonk::Error;
+
+#[derive(Clone, Debug)]
+pub(crate) struct ShlGadget<F> {
+    same_context: SameContextGadget<F>,
+    shl_words: ShlWordsGadget<F>,
+}
+
+impl<F: Field> ExecutionGadget<F> for ShlGadget<F> {
+    const NAME: &'static str = "SHL";
+
+    const EXECUTION_STATE: ExecutionState = ExecutionState::SHL;
+
+    fn configure(cb: &mut ConstraintBuilder<F>) -> Self {
+        let opcode = cb.query_cell();
+
+        let a = cb.query_word();
+        let shift = cb.query_word();
+
+        cb.stack_pop(shift.expr());
+        cb.stack_pop(a.expr());
+        let shl_words = ShlWordsGadget::construct(cb, a, shift);
+        cb.stack_push(shl_words.b().expr());
+
+        let step_state_transition = StepStateTransition {
+            rw_counter: Delta(3.expr()),
+            program_counter: Delta(1.expr()),
+            stack_pointer: Delta(1.expr()),
+            gas_left: Delta(-OpcodeId::SHL.constant_gas_cost().expr()),
+            ..Default::default()
+        };
+        let same_context = SameContextGadget::construct(cb, opcode, step_state_transition);
+
+        Self {
+            same_context,
+            shl_words,
+        }
+    }
+
+    fn assign_exec_step(
+        &self,
+        region: &mut CachedRegion<'_, '_, F>,
+        offset: usize,
+        block: &Block<F>,
+        _: &Transaction,
+        _: &Call,
+        step: &ExecStep,
+    ) -> Result<(), Error> {
+        self.same_context.assign_exec_step(region, offset, step)?;
+        let indices = [step.rw_indices[0], step.rw_indices[1], step.rw_indices[2]];
+        let [shift, a, b] = indices.map(|idx| block.rws[idx].stack_value());
+        self.shl_words.assign(region, offset, a, shift, b)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::evm_circuit::test::rand_word;
+    use crate::test_util::run_test_circuits;
+    use eth_types::evm_types::OpcodeId;
+    use eth_types::{bytecode, Word};
+    use mock::TestContext;
+    use rand::Rng;
+
+    fn test_ok(opcode: OpcodeId, a: Word, shift: Word) {
+        let bytecode = bytecode! {
+            PUSH32(a)
+            PUSH32(shift)
+            #[start]
+            .write_op(opcode)
+            STOP
+        };
+        assert_eq!(
+            run_test_circuits(
+                TestContext::<2, 1>::simple_ctx_with_bytecode(bytecode).unwrap(),
+                None
+            ),
+            Ok(())
+        );
+    }
+
+    #[test]
+    fn shl_gadget_simple() {
+        test_ok(OpcodeId::SHL, Word::from(0xABCD) << 240, 8.into());
+        test_ok(OpcodeId::SHL, Word::from(0x1234) << 240, 7.into());
+        test_ok(OpcodeId::SHL, Word::from(0x8765) << 240, 17.into());
+        test_ok(OpcodeId::SHL, Word::from(0x4321) << 240, 0.into());
+    }
+
+    #[test]
+    fn shl_gadget_rand_normal_shift() {
+        let a = rand_word();
+        let mut rng = rand::thread_rng();
+        let shift = rng.gen_range(0..=255);
+        test_ok(OpcodeId::SHL, a, shift.into());
+    }
+
+    #[test]
+    fn shl_gadget_rand_overflow_shift() {
+        let a = rand_word();
+        let shift = Word::from_big_endian(&[255_u8; 32]);
+        test_ok(OpcodeId::SHL, a, shift);
+    }
+
+    // This case validates if the split is correct.
+    #[test]
+    fn shl_gadget_constant_shift() {
+        let a = rand_word();
+        test_ok(OpcodeId::SHL, a, 8.into());
+        test_ok(OpcodeId::SHL, a, 64.into());
+    }
+}

zkevm-circuits/src/evm_circuit/table.rs

@@ -42,6 +42,7 @@ pub enum FixedTableTag {
     BitwiseOr,
     BitwiseXor,
     ResponsibleOpcode,
+    Pow2,
 }
 
 impl FixedTableTag {
@@ -102,6 +103,14 @@ impl FixedTableTag {
                         })
                 }))
             }
+            Self::Pow2 => Box::new((0..65).map(move |value| {
+                [
+                    tag,
+                    F::from(value),
+                    F::from_u128(1_u128 << value),
+                    F::zero(),
+                ]
+            })),
         }
     }
 }