Change the memory representation of 64-bit, dual-limbed values to be little-endian.

In memory the low (least significant) 32-bit limb is now loaded or
stored from/to `addr` and the high 32-bit limb from/to `addr+1`.  On the
stack the limb order is still big-endian.

Author: otrho

codegen/masm/intrinsics/mem.masm

@@ -317,22 +317,21 @@ export.load_dw # [addr, offset]
     # if the pointer is naturally aligned..
     if.true
         # drop offset
-        swap.1 drop            # [addr]
-        # load second element
-        dup.0 push.1 u32overflowing_add assertz # [addr + 1, addr]
-        mem_load               # [e1, addr]
-        # load first element
-        swap.1 mem_load        # [e0, e1]
+        swap.1 drop                              # [addr]
+
+        dup.0 mem_load                           # [lo, addr]
+        swap.1 push.1 u32overflowing_add assertz # [addr + 1, lo]
+        mem_load                                 # [hi, lo]
     else
         # unaligned; an unaligned double-word spans three elements
         #
         # convert offset from bytes to bits
         swap.1 push.8 u32wrapping_mul swap.1              # [addr, bit_offset]
 
         # load the three elements containing the double-word on the stack
-        dup.0 push.2 u32overflowing_add assertz mem_load  # [e2, addr, bit_offset]
-        dup.1 push.1 add mem_load                         # [e1, e2, addr, bit_offset]
-        movup.2 mem_load                                  # [e0, e1, e2, bit_offset]
+        dup.0 mem_load                                    # [lo, addr, bit_offset]
+        dup.1 push.1 u32overflowing_add assertz mem_load  # [mid, lo, addr, bit_offset]
+        dup.2 push.2 u32overflowing_add assertz mem_load  # [hi, mid, lo, addr, bit_offset]
 
         # re-align it, and we're done
         exec.realign_dw
@@ -447,8 +446,8 @@ export.store_dw # [addr, offset, value_hi, value_lo]
     if.true  # [addr, offset, value_hi, value_lo]
         # drop byte offset
         swap.1 drop   # [addr, value_hi, value_lo]
-        swap.1 dup.1  # [addr, value_hi, addr, value_lo]
-        mem_store     # [addr, value_lo]
+        movup.2 dup.1 # [addr, value_lo, addr, value_hi]
+        mem_store     # [addr, value_hi]
         push.1 u32overflowing_add assertz # [addr + 1, value_lo]
         mem_store
     else     # [addr, offset, value_hi, value_lo]
@@ -459,34 +458,37 @@ export.store_dw # [addr, offset, value_hi, value_lo]
 
         movdn.3        # [bit_offset, value_hi, value_lo, addr]
         dup.0 movdn.4  # [bit_offset, value_hi, value_lo, addr, bit_offset]
-        movdn.2        # [value_hi, value_lo, bit_offset, addr, bit_offset]
-        exec.offset_dw # [chunk_lo, chunk_mid, chunk_hi, addr, bit_offset]
+        movdn.2 swap.1 # [value_lo, value_hi, bit_offset, addr, bit_offset]
+
+        # NOTE: we call offset_dw with args in reverse order for which it is documented, but the
+        # hi/mid/lo distinction is arbirtrary.
+        exec.offset_dw # [chunk_hi, chunk_mid, chunk_lo, addr, bit_offset]
 
         # compute the bit shift
-        push.32 movup.5 sub           # [32 - bit_offset, lo, mid, hi, addr]
+        push.32 movup.5 sub           # [32 - bit_offset, hi, mid, lo, addr]
 
         # compute the masks
-        push.4294967295 swap.1 u32shr # [mask_hi, lo, mid, hi, addr]
-        dup.0 u32not                  # [mask_lo, mask_hi, lo, mid, hi, addr]
+        push.4294967295 swap.1 u32shr # [mask_lo, hi, mid, lo, addr]
+        dup.0 u32not                  # [mask_hi, mask_lo, hi, mid, lo, addr]
 
         # combine the bits of the lo and hi chunks with their corresponding elements, so that we
         # do not overwrite memory that is out of bounds of the actual value being stored.
         #
-        # 1. load e2 (lo)
+        # 1. load e2 (hi)
         dup.5 push.2 u32overflowing_add assertz mem_load
-        # 2. mask e2 (lo)
-        u32and                       # [e2_masked, mask_hi, lo, mid, hi, addr]
-        # 3. load e0 (hi)
-        dup.5 mem_load               # [e0, e2_masked, mask_hi, lo, mid, hi, addr]
-        # 4. mask e0 (hi)
-        movup.2 u32and               # [e0_masked, e2_masked, lo, mid, hi, addr]
-        # 5. combine e2 & lo
-        movdn.2 u32or                # [e2', e0_masked, mid, hi, addr]
+        # 2. mask e2 (hi)
+        u32and                       # [e2_masked, mask_lo, hi, mid, lo, addr]
+        # 3. load e0 (lo)
+        dup.5 mem_load               # [e0, e2_masked, mask_lo, hi, mid, lo, addr]
+        # 4. mask e0 (lo)
+        movup.2 u32and               # [e0_masked, e2_masked, hi, mid, lo, addr]
+        # 5. combine e2 & hi
+        movdn.2 u32or                # [e2', e0_masked, mid, lo, addr]
         # 6. store e2
-        dup.4 add.2 mem_store        # [e0_masked, mid, hi, addr]
+        dup.4 add.2 mem_store        # [e0_masked, mid, lo, addr]
         # 7. store e1 (mid)
-        swap.1 dup.3 add.1 mem_store # [e0_masked, hi, addr]
-        # 8. combine e0 & hi
+        swap.1 dup.3 add.1 mem_store # [e0_masked, lo, addr]
+        # 8. combine e0 & lo
         u32or                        # [e0', addr]
         # 9. store e0
         swap.1 mem_store             # []

tests/integration/src/codegen/intrinsics/mem.rs

@@ -70,14 +70,14 @@ fn load_sw() {
                 Ok(())
             })?;
 
-        prop_assert_eq!(output, value);
+        prop_assert_eq!(output, value, "expected 0x{:x}; found 0x{:x}", value, output,);
 
         Ok(())
     });
 
     match res {
-        Err(TestError::Fail(_, value)) => {
-            panic!("Found minimal(shrinked) failing case: {value:?}");
+        Err(TestError::Fail(reason, value)) => {
+            panic!("FAILURE: {}\nMinimal failing case: {value:?}", reason.message());
         }
         Ok(_) => (),
         _ => panic!("Unexpected test result: {res:?}"),
@@ -111,28 +111,35 @@ fn load_dw() {
     let config = proptest::test_runner::Config::with_cases(10);
     let res = TestRunner::new(config).run(&any::<u64>(), move |value| {
         // Write `value` to the start of the 17th page (1 page after the 16 pages reserved for the
-        // Rust stack)
+        // Rust stack).  Felts must be written in little endian order.
         let value_felts = value.to_felts();
         let initializers = [Initializer::MemoryFelts {
             addr: write_to / 4,
-            felts: Cow::Borrowed(value_felts.as_slice()),
+            felts: Cow::Borrowed(&[value_felts[1], value_felts[0]]),
         }];
 
         let args = [Felt::new(write_to as u64)];
         let output =
             eval_package::<u64, _, _>(&package, initializers, &args, context.session(), |trace| {
-                let hi =
-                    trace.read_memory_element(write_to / 4).unwrap_or_default().as_int() as u32;
-                let lo = trace.read_memory_element((write_to / 4) + 1).unwrap_or_default().as_int()
-                    as u32;
+                let lo = trace.read_memory_element(write_to / 4).unwrap_or_default().as_int();
+                let hi = trace.read_memory_element((write_to / 4) + 1).unwrap_or_default().as_int();
+
                 log::trace!(target: "executor", "hi = {hi} ({hi:0x})");
                 log::trace!(target: "executor", "lo = {lo} ({lo:0x})");
-                let stored = trace.read_from_rust_memory::<u64>(write_to).ok_or_else(|| {
+
+                prop_assert_eq!(lo, value & 0xffffffff);
+                prop_assert_eq!(hi, value >> 32);
+
+                let mut stored = trace.read_from_rust_memory::<u64>(write_to).ok_or_else(|| {
                     TestCaseError::fail(format!(
                         "expected {value} to have been written to byte address {write_to}, but \
                          read from that address failed"
                     ))
                 })?;
+
+                // read_from_rust_memory() still reads in big-endian limbs.
+                stored = ((stored >> 32) & 0xffffffff) | (stored << 32);
+
                 prop_assert_eq!(
                     stored,
                     value,
@@ -145,14 +152,14 @@ fn load_dw() {
                 Ok(())
             })?;
 
-        prop_assert_eq!(output, value);
+        prop_assert_eq!(output, value, "expected 0x{:x}; found 0x{:x}", value, output,);
 
         Ok(())
     });
 
     match res {
-        Err(TestError::Fail(_, value)) => {
-            panic!("Found minimal(shrinked) failing case: {value:?}");
+        Err(TestError::Fail(reason, value)) => {
+            panic!("FAILURE: {}\nMinimal failing case: {value:?}", reason.message());
         }
         Ok(_) => (),
         _ => panic!("Unexpected test result: {res:?}"),
@@ -214,14 +221,14 @@ fn load_u8() {
                 Ok(())
             })?;
 
-        prop_assert_eq!(output, value);
+        prop_assert_eq!(output, value, "expected 0x{:x}; found 0x{:x}", value, output,);
 
         Ok(())
     });
 
     match res {
-        Err(TestError::Fail(_, value)) => {
-            panic!("Found minimal(shrinked) failing case: {value:?}");
+        Err(TestError::Fail(reason, value)) => {
+            panic!("FAILURE: {}\nMinimal failing case: {value:?}", reason.message());
         }
         Ok(_) => (),
         _ => panic!("Unexpected test result: {res:?}"),
@@ -283,14 +290,14 @@ fn load_u16() {
                 Ok(())
             })?;
 
-        prop_assert_eq!(output, value);
+        prop_assert_eq!(output, value, "expected 0x{:x}; found 0x{:x}", value, output,);
 
         Ok(())
     });
 
     match res {
-        Err(TestError::Fail(_, value)) => {
-            panic!("Found minimal(shrinked) failing case: {value:?}");
+        Err(TestError::Fail(reason, value)) => {
+            panic!("FAILURE: {}\nMinimal failing case: {value:?}", reason.message());
         }
         Ok(_) => (),
         _ => panic!("Unexpected test result: {res:?}"),
@@ -358,14 +365,14 @@ fn load_bool() {
             },
         )?;
 
-        prop_assert_eq!(output, value);
+        prop_assert_eq!(output, value, "expected {}; found {}", output, value);
 
         Ok(())
     });
 
     match res {
-        Err(TestError::Fail(_, value)) => {
-            panic!("Found minimal(shrinked) failing case: {value:?}");
+        Err(TestError::Fail(reason, value)) => {
+            panic!("FAILURE: {}\nMinimal failing case: {value:?}", reason.message());
         }
         Ok(_) => (),
         _ => panic!("Unexpected test result: {res:?}"),
@@ -502,8 +509,8 @@ fn store_u16() {
     );
 
     match res {
-        Err(TestError::Fail(_, value)) => {
-            panic!("Found minimal(shrinked) failing case: {value:?}");
+        Err(TestError::Fail(reason, value)) => {
+            panic!("FAILURE: {}\nMinimal failing case: {value:?}", reason.message());
         }
         Ok(_) => (),
         _ => panic!("Unexpected test result: {res:?}"),
@@ -724,8 +731,8 @@ fn store_u8() {
     );
 
     match res {
-        Err(TestError::Fail(_, value)) => {
-            panic!("Found minimal(shrinked) failing case: {value:?}");
+        Err(TestError::Fail(reason, value)) => {
+            panic!("FAILURE: {}\nMinimal failing case: {value:?}", reason.message());
         }
         Ok(_) => (),
         _ => panic!("Unexpected test result: {res:?}"),
@@ -826,10 +833,8 @@ fn store_unaligned_u64() {
     // Use the start of the 17th page (1 page after the 16 pages reserved for the Rust stack)
     let write_to = 17 * 2u32.pow(16);
 
-    // STORE_DW writes the high 32bit word to address and low 32bit word to address+1.
-    //   So a .store() of 0xddccbbaa_cdabffee writes 0xddccbbaa to addr and 0xcdabffee to addr+1.
-    //   Which in turn will be little-endian bytes [ AA BB CC DD EE FF AB CD ] at addr.
-    let write_val = 0xddccbbaa_cdabffee_u64;
+    // Value which in turn will be little-endian bytes [ AA BB CC DD EE FF AB CD ] at addr.
+    let write_val = 0xcdabffee_ddccbbaa_u64;
 
     // Generate a `test` module with `main` function that stores to a u32 offset.
     let signature = Signature::new(
@@ -917,6 +922,12 @@ fn store_unaligned_u64() {
         assert_eq!(output, 1);
     };
 
+    // Overwrite    01 02 03 04 05 06 07 08-11 12 13 14 15 16 17 18
+    //   with bytes aa bb cc dd ee ff ab cd at offset 0:
+    //   Expect     aa bb cc dd ee ff ab cd 11 12 13 14 15 16 17 18
+    //   or         0xccbbaa01, 0xabffeedd, 0x141312cd, 0x18171615
+    run_test(0, 0xddccbbaa, 0xcdabffee, 0x14131211, 0x18171615);
+
     // Overwrite    01 02 03 04 05 06 07 08-11 12 13 14 15 16 17 18
     //   with bytes    aa bb cc dd ee ff ab cd at offset 1:
     //   Expect     01 aa bb cc dd ee ff ab cd 12 13 14 15 16 17 18

tests/integration/src/rust_masm_tests/instructions.rs

@@ -87,13 +87,6 @@ macro_rules! test_wide_bin_op {
                     let rs_out = a $op b;
                     dbg!(&rs_out);
 
-                    // Moves the little-endian 32bit limbs [A, B, C, D] to [D, C, B, A].
-                    let rs_out = ((rs_out >> 32) & 0xffffffff_00000000_00000000)
-                        | ((rs_out & 0xffffffff_00000000_00000000) << 32)
-                        | ((rs_out & 0xffffffff_00000000) >> 32)
-                        | ((rs_out & 0xffffffff) << 32);
-                    let rs_out_bytes = rs_out.to_le_bytes();
-
                     // Write the operation result to 20 * PAGE_SIZE.
                     let out_addr = 20u32 * 65536;
 
@@ -104,11 +97,14 @@ macro_rules! test_wide_bin_op {
                     dbg!(&args);
 
                     eval_package::<Felt, _, _>(&package, None, &args, &test.session, |trace| {
-                        let vm_out: [u8; 16] =
+                        let vm_out_bytes: [u8; 16] =
                             trace.read_from_rust_memory(out_addr).expect("output was not written");
-                        dbg!(&vm_out);
+                        dbg!(&vm_out_bytes);
+
+                        let rs_out_bytes = rs_out.to_le_bytes();
                         dbg!(&rs_out_bytes);
-                        prop_assert_eq!(&rs_out_bytes, &vm_out, "VM output mismatch");
+
+                        prop_assert_eq!(&rs_out_bytes, &vm_out_bytes, "VM output mismatch");
                         Ok(())
                     })?;
 
@@ -253,6 +249,9 @@ test_int_op!(add, +, i8, 0..=i8::MAX/2, 0..=i8::MAX/2);
 // const WK1234: i128 = 79228162551157825753847955460000;
 // const WC1234: i128 = 7922816255115782575384795546000;
 //
+// const WK1234H: i128 = 0x00001000_00002000_00003000_00004000;
+// const WC1234H: i128 = 0x00000100_00000200_00000300_00000400;
+//
 // test_wide_bin_op!(xxx, x, i128, i128, WK1234..=WK1234, WC1234..=WC1234);
 
 test_wide_bin_op!(add, +, u128, u128, 0..=u128::MAX/2, 0..=u128::MAX/2);