Let lr be initialized when the machine is initialized

.github/workflows/develop.yml

@@ -149,7 +149,7 @@ jobs:
           cd ckb-vm-test-suite
           cd binary && cargo build --release --target=aarch64-unknown-linux-gnu && cd ..
           cd ..
-          docker run --rm -v `pwd`:/code -t arm64v8/rust bash -c "RISCV=/dummy /code/ckb-vm-test-suite/test.sh --prebuilt-prefix aarch64-unknown-linux-gnu"
+          docker run --rm -v `pwd`:/code -t --platform linux/arm64 arm64v8/rust bash -c "RISCV=/dummy /code/ckb-vm-test-suite/test.sh --prebuilt-prefix aarch64-unknown-linux-gnu"
 
   macos-x86-ci-asm:
     runs-on: macos-latest

definitions/src/asm.rs

@@ -132,23 +132,14 @@ impl AsmCoreMachine {
         assert_eq!(memory_size % (1 << MEMORY_FRAME_SHIFTS), 0);
         let mut machine = unsafe {
             let layout = Layout::new::<AsmCoreMachine>();
-            let raw_allocation = alloc(layout) as *mut AsmCoreMachine;
+            let raw_allocation = alloc_zeroed(layout) as *mut AsmCoreMachine;
             Box::from_raw(raw_allocation)
         };
-        machine.registers = [0; RISCV_GENERAL_REGISTER_NUMBER];
-        machine.pc = 0;
-        machine.next_pc = 0;
-        machine.running = 0;
-        machine.cycles = 0;
         machine.max_cycles = max_cycles;
         if cfg!(feature = "enable-chaos-mode-by-default") {
             machine.chaos_mode = 1;
-        } else {
-            machine.chaos_mode = 0;
         }
-        machine.chaos_seed = 0;
-        machine.reset_signal = 0;
-        machine.error_arg0 = 0;
+        machine.load_reservation_address = u64::MAX;
         machine.version = version;
         machine.isa = isa;
 

tests/programs/_build_all_native.sh

@@ -53,6 +53,7 @@ riscv64-unknown-elf-as -o rorw_in_end_of_aot_block.o rorw_in_end_of_aot_block.S
 sh rvc_pageend.sh
 # TODO: sbinvi_aot_load_imm_bug
 riscv64-unknown-elf-as -o sc_after_sc.o sc_after_sc.S && riscv64-unknown-elf-ld -T sc_after_sc.lds -o sc_after_sc sc_after_sc.o && rm sc_after_sc.o
+riscv64-unknown-elf-as -o sc_only.o sc_only.S && riscv64-unknown-elf-ld -T sc_only.lds -o sc_only sc_only.o && rm sc_only.o
 # SKIP: simple
 riscv64-unknown-elf-gcc -o simple64 simple.c
 riscv64-unknown-elf-as -o sp_alignment_test.o sp_alignment_test.S && riscv64-unknown-elf-ld -o sp_alignment_test sp_alignment_test.o && rm sp_alignment_test.o

tests/programs/sc_only.S

@@ -0,0 +1,16 @@
+.global _start
+_start:
+    la a0, n0         # a0 holds address of memory location n0
+    sc.d a3, a2, (a0)
+    beqz a3, fail     # sc.d must fail
+done:
+    li a0, 0
+    li a7, 93
+    ecall
+fail:
+    li a0, 1
+    li a7, 93
+    ecall
+.section .data
+n0:
+    .dword 4      # Initialize to 4

tests/programs/sc_only.lds

@@ -0,0 +1,7 @@
+SECTIONS
+{
+. = 0x100b0;
+.text : { *(.text) }
+. = 0x11000;
+.data : { *(.data) }
+}

tests/test_a_extension.rs

@@ -35,6 +35,22 @@ pub fn test_sc_after_sc() {
     }
 }
 
+#[test]
+pub fn test_sc_only() {
+    let mut machine = machine_build::int_v2_imacb("tests/programs/sc_only");
+    let ret = machine.run();
+    assert!(ret.is_ok());
+    assert_eq!(ret.unwrap(), 0);
+
+    #[cfg(has_asm)]
+    {
+        let mut machine_asm = machine_build::asm_v2_imacb("tests/programs/sc_only");
+        let ret_asm = machine_asm.run();
+        assert!(ret_asm.is_ok());
+        assert_eq!(ret_asm.unwrap(), 0);
+    }
+}
+
 #[test]
 pub fn test_amo_compare() {
     let mut machine = machine_build::int_v2_imacb("tests/programs/amo_compare");