Implementing Shift instructions

programs/rol.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"rol.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    add	1, r0, r1
+    add 4, r0, r2
+    rol r1, r2, r3
+    sstore r0, r3
+    ret
+.func_end0:
+    .note.GNU-stack
+    .rodata

programs/rol_conditional_eq.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"rol_conditional_eq.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    add	1, r0, r1
+    add 4, r0, r2
+    rol.eq r1, r2, r3
+    sstore r0, r3
+    ret
+.func_end0:
+    .note.GNU-stack
+    .rodata

programs/rol_sets_eq_flag.zasm

@@ -0,0 +1,16 @@
+	.text
+	.file	"rol_sets_eq_flag.zasm"
+	.globl	__entry
+__entry:
+
+.func_begin0:
+	; EQ is set if the result is zero
+	add	0, r0, r1
+	add	0, r0, r2
+	rol! r1, r2, r1
+	sstore	r0, r1
+	ret
+
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/rol_stack.zasm

@@ -0,0 +1,17 @@
+	.text
+	.file	"rol_stack.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	; grow stack
+	add 1, r0, stack+=[2]
+	; set stack value
+	add 1, r0, stack[0]
+	add	4, r0, r2
+	; left rotation
+	rol stack[0], r2, r3
+	sstore r0, r3
+	ret
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/ror.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"ror.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    add	16, r0, r1
+    add 4, r0, r2
+    ror r1, r2, r3
+    sstore r0, r3
+    ret
+.func_end0:
+    .note.GNU-stack
+    .rodata

programs/ror_conditional_eq.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"ror_conditional_eq.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    add	16, r0, r1
+    add 4, r0, r2
+    ror.eq r1, r2, r3
+    sstore r0, r3
+    ret
+.func_end0:
+    .note.GNU-stack
+    .rodata

programs/ror_sets_eq_flag.zasm

@@ -0,0 +1,16 @@
+	.text
+	.file	"ror_sets_eq_flag.zasm"
+	.globl	__entry
+__entry:
+
+.func_begin0:
+	; EQ is set if the result is zero
+	add	0, r0, r1
+	add	0, r0, r2
+	ror! r1, r2, r1
+	sstore	r0, r1
+	ret
+
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/ror_stack.zasm

@@ -0,0 +1,17 @@
+	.text
+	.file	"ror_stack.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	; grow stack
+	add 1, r0, stack+=[2]
+	; set stack value
+	add 16, r0, stack[0]
+	add	4, r0, r2
+	; right rotation
+	ror stack[0], r2, r3
+	sstore r0, r3
+	ret
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/shl.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"shl.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    add	1, r0, r1
+    add 2, r0, r2
+    shl r1, r2, r3
+    sstore r0, r3
+    ret
+.func_end0:
+    .note.GNU-stack
+    .rodata

programs/shl_conditional_eq.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"shl_conditional_eq.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	add	4, r0, r1
+	add 1, r0, r2
+	shl.eq r1, r2, r3
+	sstore r0, r3
+	ret
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/shl_sets_eq_flag.zasm

@@ -0,0 +1,16 @@
+	.text
+	.file	"shl_sets_eq_flag.zasm"
+	.globl	__entry
+__entry:
+
+.func_begin0:
+	; EQ is set if the result is zero
+	add	0, r0, r1
+	add	0, r0, r2
+	shl! r1, r2, r1
+	sstore	r0, r1
+	ret
+
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/shl_stack.zasm

@@ -0,0 +1,17 @@
+	.text
+	.file	"shl_stack.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	; grow stack
+	add 1, r0, stack+=[2]
+	; set stack value
+	add 4, r0, stack[0]
+	add	2, r0, r2
+	; shift left
+	shl stack[0], r2, r3
+	sstore r0, r3
+	ret
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/shr.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"shr.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	add	8, r0, r1
+	add 2, r0, r2
+	shr r1, r2, r3
+	sstore r0, r3
+	ret
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/shr_conditional_eq.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"shr_conditional_eq.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	add	8, r0, r1
+	add 2, r0, r2
+	shr.eq r1, r2, r3
+	sstore r0, r3
+	ret
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/shr_sets_eq_flag.zasm

@@ -0,0 +1,16 @@
+	.text
+	.file	"shr_sets_eq_flag.zasm"
+	.globl	__entry
+__entry:
+
+.func_begin0:
+	; EQ is set if the result is zero
+	add	0, r0, r1
+	add	0, r0, r2
+	shr! r1, r2, r1
+	sstore	r0, r1
+	ret
+
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/shr_stack.zasm

@@ -0,0 +1,17 @@
+	.text
+	.file	"shr_stack.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    ; grow stack
+    add 1, r0, stack+=[2]
+    ; set stack value
+    add 4, r0, stack[0]
+    add	2, r0, r2
+    ; shift right
+    shr stack[0], r2, r3
+    sstore r0, r3
+    ret
+.func_end0:
+    .note.GNU-stack
+    .rodata

src/lib.rs

@@ -12,6 +12,7 @@ use op_handlers::ptr_add::_ptr_add;
 use op_handlers::ptr_pack::_ptr_pack;
 use op_handlers::ptr_shrink::_ptr_shrink;
 use op_handlers::ptr_sub::_ptr_sub;
+use op_handlers::shift::_shift;
 use op_handlers::sub::_sub;
 pub use opcode::Opcode;
 use state::VMState;
@@ -67,7 +68,14 @@ pub fn run_program_with_custom_state(bin_path: &str, mut vm: VMState) -> (U256,
                 Variant::Div(_) => _div(&mut vm, &opcode),
                 Variant::Jump(_) => todo!(),
                 Variant::Context(_) => todo!(),
-                Variant::Shift(_) => todo!(),
+                Variant::Shift(_) => _shift(
+                    &mut vm,
+                    &opcode,
+                    match opcode.variant {
+                        Variant::Shift(shift_type) => shift_type,
+                        _ => unreachable!(),
+                    },
+                ),
                 Variant::Binop(_) => todo!(),
                 Variant::Ptr(ptr_variant) => match ptr_variant {
                     PtrOpcode::Add => _ptr_add(&mut vm, &opcode),

src/op_handlers/mod.rs

@@ -5,4 +5,5 @@ pub mod ptr_add;
 pub mod ptr_pack;
 pub mod ptr_shrink;
 pub mod ptr_sub;
+pub mod shift;
 pub mod sub;

src/op_handlers/shift.rs

@@ -0,0 +1,73 @@
+use crate::address_operands::{address_operands_read, address_operands_store};
+use crate::value::TaggedValue;
+use crate::{opcode::Opcode, state::VMState};
+use zkevm_opcode_defs::ShiftOpcode;
+
+fn _shl(vm: &mut VMState, opcode: &Opcode) {
+    let (src0_t, src1_t) = address_operands_read(vm, opcode);
+    let (src0, src1) = (src0_t.value, src1_t.value);
+    let shift = src1.low_u32() % 256;
+    let res = src0 << shift;
+    if opcode.alters_vm_flags {
+        // Eq is set if result == 0
+        vm.flag_eq |= res.is_zero();
+        // other flags are reset
+        vm.flag_lt_of = false;
+        vm.flag_gt = false;
+    }
+    address_operands_store(vm, opcode, TaggedValue::new_raw_integer(res));
+}
+
+fn _shr(vm: &mut VMState, opcode: &Opcode) {
+    let (src0_t, src1_t) = address_operands_read(vm, opcode);
+    let (src0, src1) = (src0_t.value, src1_t.value);
+    let shift = src1.low_u32() % 256;
+    let res = src0 >> shift;
+    if opcode.alters_vm_flags {
+        // Eq is set if result == 0
+        vm.flag_eq |= res.is_zero();
+        // other flags are reset
+        vm.flag_lt_of = false;
+        vm.flag_gt = false;
+    }
+    address_operands_store(vm, opcode, TaggedValue::new_raw_integer(res));
+}
+
+fn _rol(vm: &mut VMState, opcode: &Opcode) {
+    let (src0_t, src1_t) = address_operands_read(vm, opcode);
+    let (src0, src1) = (src0_t.value, src1_t.value);
+    let shift = src1.low_u32() % 256;
+    let result = (src0 << shift) | (src0 >> (256 - shift));
+    if opcode.alters_vm_flags {
+        // Eq is set if result == 0
+        vm.flag_eq |= result.is_zero();
+        // other flags are reset
+        vm.flag_lt_of = false;
+        vm.flag_gt = false;
+    }
+    address_operands_store(vm, opcode, TaggedValue::new_raw_integer(result));
+}
+
+fn _ror(vm: &mut VMState, opcode: &Opcode) {
+    let (src0_t, src1_t) = address_operands_read(vm, opcode);
+    let (src0, src1) = (src0_t.value, src1_t.value);
+    let shift = src1.low_u32() % 256;
+    let result = (src0 >> shift) | (src0 << (256 - shift));
+    if opcode.alters_vm_flags {
+        // Eq is set if result == 0
+        vm.flag_eq |= result.is_zero();
+        // other flags are reset
+        vm.flag_lt_of = false;
+        vm.flag_gt = false;
+    }
+    address_operands_store(vm, opcode, TaggedValue::new_raw_integer(result));
+}
+
+pub fn _shift(vm: &mut VMState, opcode: &Opcode, shift_type: ShiftOpcode) {
+    match shift_type {
+        ShiftOpcode::Shl => _shl(vm, opcode),
+        ShiftOpcode::Shr => _shr(vm, opcode),
+        ShiftOpcode::Rol => _rol(vm, opcode),
+        ShiftOpcode::Ror => _ror(vm, opcode),
+    }
+}