Mul and div opcodes

programs/add_sets_overflow.zasm → programs/add/add_sets_overflow.zasm

@@ -1,5 +1,5 @@
 	.text
-	.file	"add_sets_overflow.zasm"
+	.file	"mul_sets_overflow.zasm"
 	.globl	__entry
 __entry:
 

programs/div/div_quotient.zasm → programs/div/div.zasm

@@ -1,5 +1,5 @@
 	.text
-	.file	"div_quotient.zasm"
+	.file	"div.zasm"
 	.globl	__entry
 __entry:
 .func_begin0:

programs/div/div_codepage.zasm

@@ -0,0 +1,20 @@
+	.text
+	.file	"div_codepage.zasm"
+	.globl	__entry
+
+.rodata
+datavar:
+ .cell 42
+ .cell 3
+.text
+
+__entry:
+.func_begin0:
+	add 3, r0, r1
+	div	@datavar[0], r1, r3, r4
+	sstore	r0, r0
+	ret
+.func_end0:
+
+	.note.GNU-stack
+	.rodata

programs/div/div_remainder.zasm → programs/div/div_conditional.zasm

@@ -1,12 +1,12 @@
 	.text
-	.file	"div_remainder.zasm"
+	.file	"div.zasm"
 	.globl	__entry
 __entry:
 .func_begin0:
 	add	25, r0, r1
 	add	6, r0, r2
 	div r1, r2, r3, r4
-	sstore r0, r4
+	sstore r0, r3
 	ret
 .func_end0:
 

programs/div/div_conditional_gt.zasm

@@ -0,0 +1,16 @@
+	.text
+	.file	"div_conditional_gt.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	add 1, r0, r3
+	add 1, r0, r4
+	add	42, r0, r1
+	add 3, r0, r2
+	div.gt r1, r2, r3, r4
+	sstore r0, r3
+	ret
+.func_end0:
+
+	.note.GNU-stack
+	.rodata

programs/div/div_set_eq_flag.zasm

@@ -0,0 +1,15 @@
+	.text
+	.file	"div_set_eq_flag.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    ; EQ is set if the quotient is not zero
+	add	25, r0, r1
+	add	6, r0, r2
+	div! r1, r2, r3, r4
+	sstore r0, r3
+	ret
+.func_end0:
+
+	.note.GNU-stack
+	.rodata

programs/div/div_set_gt_flag.zasm

@@ -0,0 +1,15 @@
+	.text
+	.file	"div_set_gt_flag.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    ; GT is set if the reminder is not zero.
+	add	25, r0, r1
+	add	6, r0, r2
+	div! r1, r2, r3, r4
+	sstore r0, r3
+	ret
+.func_end0:
+
+	.note.GNU-stack
+	.rodata

programs/div/div_stack.zasm

@@ -0,0 +1,19 @@
+	.text
+	.file	"div_stack.zasm"
+	.globl	__entry
+__entry:
+
+.func_begin0:
+    add 3, r0, r2
+    ; grow stack
+	add 1, r0, stack+=[1]
+    ; set stack values
+    add 42, r0, stack=[0]
+    ; divide stack of absolute index 0
+    div stack=[0],r2, r3, r4
+	sstore	r0, r0
+	ret
+
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/div/div_zero.zasm

@@ -5,7 +5,7 @@ __entry:
 .func_begin0:
 	add	1, r0, r1
 	div r1, r0, r3, r4
-	sstore r0, r3
+	sstore r0, r0
 	ret
 .func_end0:
 

programs/mul/mul.zasm

@@ -6,8 +6,8 @@ __entry:
 	add	3, r0, r1
 	add 2, r0, r2
 	mul r1, r2, r1, r0
-	mul 1, r1, r1, r0
-	sstore r0, r1
+	mul 1, r1, r3, r4
+	sstore r0, r3
 	ret
 .func_end0:
 

programs/mul/mul_big.zasm

@@ -0,0 +1,13 @@
+	.text
+	.file	"mul_big.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+    ; test sets r1 = 2**(256) - 1, r2 = 2**(256)
+    mul r1, r2, r3, r4
+	sstore r0, r1
+	ret
+.func_end0:
+
+	.note.GNU-stack
+	.rodata

programs/mul/mul_codepage.zasm

@@ -0,0 +1,21 @@
+	.text
+	.file	"mul_codepage.zasm"
+	.globl	__entry
+
+.rodata
+datavar:
+ .cell 42
+ .cell 3
+.text
+
+__entry:
+.func_begin0:
+	add 1, r0, r1
+	mul	@datavar[0], r1, r1, r0
+	mul @datavar[1], r1, r1, r0
+	sstore	r0, r1
+	ret
+.func_end0:
+
+	.note.GNU-stack
+	.rodata

programs/mul/mul_conditional_gt.zasm

@@ -0,0 +1,14 @@
+	.text
+	.file	"mul_conditional_gt.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	add	3, r0, r1
+	add 14, r0, r2
+	mul.gt r1, r2, r3, r4
+	sstore r0, r3
+	ret
+.func_end0:
+
+	.note.GNU-stack
+	.rodata

programs/mul/mul_sets_overflow.zasm

@@ -0,0 +1,14 @@
+	.text
+	.file	"add_sets_overflow.zasm"
+	.globl	__entry
+__entry:
+
+.func_begin0:
+    ; test sets r1 = 2**(256) - 1, r2 = 2**(256) - 1
+    mul! r1, r2, r3, r4
+	sstore	r0, r1
+	ret
+
+.func_end0:
+	.note.GNU-stack
+	.rodata

programs/mul/mul_stack.zasm

@@ -0,0 +1,22 @@
+	.text
+	.file	"mul_stack.zasm"
+	.globl	__entry
+__entry:
+
+.func_begin0:
+    add 1, r0, r2
+    ; grow stack
+	add 1, r0, stack+=[2]
+    ; set stack values
+    add 2, r0, stack=[0]
+	add 3, r0, stack=[1]
+    ; multiply by stack of absolute index 0
+    mul stack=[0],r2, r1, r0
+    ; pop stack and multiply by the topmost value
+    mul stack-=[2],r1, r1, r0
+	sstore	r0, r1
+	ret
+
+.func_end0:
+	.note.GNU-stack
+	.rodata

src/address_operands.rs

@@ -72,25 +72,57 @@ pub fn address_operands_read(vm: &mut VMState, opcode: &Opcode) -> (U256, U256)
         }
     }
 }
-fn only_reg_write(vm: &mut VMState, opcode: &Opcode, res: U256) {
-    vm.set_register(opcode.dst0_index, res);
+
+/// The first operand is used most of the times
+/// the second operand is used only for div and mul
+enum OutputOperandPosition {
+    First,
+    Second,
 }
 
-fn reg_and_imm_write(vm: &mut VMState, opcode: &Opcode) -> U256 {
-    let dst0 = vm.get_register(opcode.dst0_index);
-    let offset = opcode.imm1;
+fn only_reg_write(
+    vm: &mut VMState,
+    opcode: &Opcode,
+    output_op_pos: OutputOperandPosition,
+    res: U256,
+) {
+    match output_op_pos {
+        OutputOperandPosition::First => vm.set_register(opcode.dst0_index, res),
+        OutputOperandPosition::Second => vm.set_register(opcode.dst1_index, res),
+    }
+}
 
-    dst0 + U256::from(offset)
+fn reg_and_imm_write(
+    vm: &mut VMState,
+    output_op_pos: OutputOperandPosition,
+    opcode: &Opcode,
+) -> U256 {
+    match output_op_pos {
+        OutputOperandPosition::First => {
+            let dst0 = vm.get_register(opcode.dst0_index);
+            let offset = opcode.imm1;
+            let res = dst0 + U256::from(offset);
+            vm.set_register(opcode.dst0_index, res);
+            res
+        }
+        OutputOperandPosition::Second => {
+            let dst1 = vm.get_register(opcode.dst1_index);
+            let offset = opcode.imm1;
+            let res = dst1 + U256::from(offset);
+            vm.set_register(opcode.dst1_index, res);
+            res
+        }
+    }
 }
 
-pub fn address_operands_store(vm: &mut VMState, opcode: &Opcode, res: U256) {
+pub fn address_operands_store(vm: &mut VMState, opcode: &Opcode, res: (U256, Option<U256>)) {
     match opcode.dst0_operand_type {
         Operand::RegOnly => {
-            only_reg_write(vm, opcode, res);
+            only_reg_write(vm, opcode, OutputOperandPosition::First, res.0);
         }
         Operand::RegOrImm(variant) => match variant {
             RegOrImmFlags::UseRegOnly => {
-                only_reg_write(vm, opcode, res);
+                only_reg_write(vm, opcode, OutputOperandPosition::First, res.0);
             }
             RegOrImmFlags::UseImm16Only => {
                 panic!("dest cannot be imm16 only");
@@ -99,38 +131,38 @@ pub fn address_operands_store(vm: &mut VMState, opcode: &Opcode, res: U256) {
         Operand::Full(variant) => {
             match variant {
                 ImmMemHandlerFlags::UseRegOnly => {
-                    only_reg_write(vm, opcode, res);
+                    only_reg_write(vm, opcode, OutputOperandPosition::First, res.0);
                 }
                 ImmMemHandlerFlags::UseStackWithPushPop => {
                     // stack+=[src0 + offset] + src1
-                    let src0 = reg_and_imm_write(vm, opcode);
+                    let src0 = reg_and_imm_write(vm, OutputOperandPosition::First, opcode);
                     vm.current_frame.stack.fill_with_zeros(src0 + 1);
                     vm.current_frame.stack.store_with_offset(
                         1,
                         TaggedValue {
-                            value: res,
+                            value: res.0,
                             is_pointer: false,
                         },
                     );
                 }
                 ImmMemHandlerFlags::UseStackWithOffset => {
                     // stack[src0 + offset] + src1
-                    let src0 = reg_and_imm_write(vm, opcode);
+                    let src0 = reg_and_imm_write(vm, OutputOperandPosition::First, opcode);
                     vm.current_frame.stack.store_with_offset(
                         src0.as_usize(),
                         TaggedValue {
-                            value: res,
+                            value: res.0,
                             is_pointer: false,
                         },
                     );
                 }
                 ImmMemHandlerFlags::UseAbsoluteOnStack => {
                     // stack=[src0 + offset] + src1
-                    let src0 = reg_and_imm_write(vm, opcode);
+                    let src0 = reg_and_imm_write(vm, OutputOperandPosition::First, opcode);
                     vm.current_frame.stack.store_absolute(
                         src0.as_usize(),
                         TaggedValue {
-                            value: res,
+                            value: res.0,
                             is_pointer: false,
                         },
                     );
@@ -144,4 +176,8 @@ pub fn address_operands_store(vm: &mut VMState, opcode: &Opcode, res: U256) {
             }
         }
     }
+    if let Some(res) = res.1 {
+        // Second operand can only be a register
+        only_reg_write(vm, opcode, OutputOperandPosition::Second, res);
+    }
 }

src/lib.rs

@@ -53,9 +53,9 @@ pub fn run_program_with_custom_state(bin_path: &str, mut vm: VMState) -> (U256,
                 Variant::Add(_) => {
                     _add(&mut vm, &opcode);
                 }
-                Variant::Sub(_) => _sub(&mut vm, opcode),
-                Variant::Mul(_) => _mul(&mut vm, opcode),
-                Variant::Div(_) => _div(&mut vm, opcode),
+                Variant::Sub(_) => _sub(&mut vm, &opcode),
+                Variant::Mul(_) => _mul(&mut vm, &opcode),
+                Variant::Div(_) => _div(&mut vm, &opcode),
                 Variant::Jump(_) => todo!(),
                 Variant::Context(_) => todo!(),
                 Variant::Shift(_) => todo!(),

src/op_handlers/add.rs

@@ -27,5 +27,5 @@ pub fn _add(vm: &mut VMState, opcode: &Opcode) {
         // Gt is set if both of lt_of and eq are cleared.
         vm.flag_gt |= !vm.flag_lt_of && !vm.flag_eq;
     }
-    address_operands_store(vm, opcode, res);
+    address_operands_store(vm, opcode, (res, None));
 }

src/op_handlers/div.rs

@@ -1,8 +1,17 @@
-use crate::address_operands::address_operands_read;
+use crate::address_operands::{address_operands_read, address_operands_store};
 use crate::{opcode::Opcode, state::VMState};
 
-pub fn _div(vm: &mut VMState, opcode: Opcode) {
-    let (src0, src1) = address_operands_read(vm, &opcode);
-    vm.set_register(opcode.dst0_index, src0 / src1);
-    vm.set_register(opcode.dst1_index, src0 % src1);
+pub fn _div(vm: &mut VMState, opcode: &Opcode) {
+    let (src0, src1) = address_operands_read(vm, opcode);
+    let (quotient, remainder) = src0.div_mod(src1);
+    if opcode.alters_vm_flags {
+        // Lt overflow is cleared
+        vm.flag_lt_of = false;
+        // Eq is set if quotient is not zero
+        vm.flag_eq = !quotient.is_zero();
+        // Gt is set if the remainder is not zero
+        vm.flag_gt = !remainder.is_zero();
+    }
+
+    address_operands_store(vm, opcode, (quotient, Some(remainder)));
 }