test: add test for mem::intrinsics::store_sw

Author: greenhat

codegen/masm/src/tests.rs

@@ -208,6 +208,10 @@ impl TestByEmulationHarness {
     pub fn step_over(&mut self) -> Result<EmulatorEvent, EmulationError> {
         self.emulator.step_over()
     }
+
+    fn reset(&mut self) {
+        self.emulator.reset();
+    }
 }
 
 #[test]
@@ -453,6 +457,75 @@ fn i32_checked_neg() {
     harness.invoke(neg, &[min]).expect("execution failed");
 }
 
+#[test]
+fn codegen_mem_store_sw() {
+    const MEMORY_SIZE_BYTES: u32 = 1048576 * 10;
+    const MEMORY_SIZE_VM_WORDS: u32 = MEMORY_SIZE_BYTES / 16;
+    let mut harness = TestByEmulationHarness::with_emulator_config(
+        MEMORY_SIZE_VM_WORDS as usize,
+        Emulator::DEFAULT_HEAP_START as usize,
+        Emulator::DEFAULT_LOCALS_START as usize,
+        true,
+    );
+    let mut builder = ProgramBuilder::new(&harness.context.session.diagnostics);
+    let mut mb = builder.module("test");
+    let id = {
+        let mut fb = mb
+            .function(
+                "store_load_sw",
+                Signature::new(
+                    [AbiParam::new(Type::U32), AbiParam::new(Type::U32)],
+                    [AbiParam::new(Type::U32)],
+                ),
+            )
+            .expect("unexpected symbol conflict");
+        let entry = fb.current_block();
+        let (ptr_u32, value) = {
+            let args = fb.block_params(entry);
+            (args[0], args[1])
+        };
+        let ptr = fb.ins().inttoptr(ptr_u32, Type::Ptr(Type::U32.into()), SourceSpan::UNKNOWN);
+        fb.ins().store(ptr, value, SourceSpan::UNKNOWN);
+        let loaded_value = fb.ins().load(ptr, SourceSpan::UNKNOWN);
+        fb.ins().ret(Some(loaded_value), SourceSpan::UNKNOWN);
+        fb.build().expect("unexpected error building function")
+    };
+
+    mb.build().expect("unexpected error constructing test module");
+
+    let program = builder.with_entrypoint(id).link().expect("failed to link program");
+
+    let mut compiler = MasmCompiler::new(&harness.context.session);
+    let program = compiler.compile(program).expect("compilation failed").freeze();
+
+    eprintln!("{}", program);
+
+    let mut test = |ptr: u32, value: u32| {
+        eprintln!("---------------------------------");
+        eprintln!("testing ptr: {ptr}, value: {value}");
+        eprintln!("---------------------------------");
+        let mut stack = harness
+            .execute_program(program.clone(), &[Felt::new(ptr as u64), Felt::new(value as u64)])
+            .expect("execution failed");
+        assert_eq!(stack.len(), 1);
+        assert_eq!(
+            stack.pop(),
+            Some(Felt::new(value as u64)),
+            "failed stor_sw->load_sw at ptr: {ptr}"
+        );
+        harness.reset();
+    };
+
+    // TODO: on ptr % 4 == 0 load_sw always returns 0
+    // test(0, 999);
+    // test(8, 999);
+    test(1, 42);
+    test(25, u32::MAX);
+    // assert in replace_element fails
+    test(64, 42);
+    test(MEMORY_SIZE_BYTES - 4, u32::MAX);
+}
+
 macro_rules! proptest_unary_numeric_op {
     ($ty_name:ident :: $op:ident, $ty:ty => $ret:ty, $rust_op:ident) => {
         proptest_unary_numeric_op_impl!($ty_name :: $op, $ty => $ret, $rust_op, 0..$ty_name::MAX);