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.

For testing the `ToMidenRepr` array of felts are now little-endian.  The
`FromMidenRepr` is still a big-endian array of felts, as per the stack.

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             # []

midenc-debug/src/exec/trace.rs

@@ -193,13 +193,13 @@ impl ExecutionTrace {
             2 => {
                 let lo = self.read_memory_element_in_context(ptr.addr, ctx, clk)?;
                 let hi = self.read_memory_element_in_context(ptr.addr + 1, ctx, clk)?;
-                Some(T::from_felts(&[lo, hi]))
+                Some(T::from_felts(&[hi, lo]))
             }
             3 => {
                 let lo_l = self.read_memory_element_in_context(ptr.addr, ctx, clk)?;
                 let lo_h = self.read_memory_element_in_context(ptr.addr + 1, ctx, clk)?;
                 let hi_l = self.read_memory_element_in_context(ptr.addr + 2, ctx, clk)?;
-                Some(T::from_felts(&[lo_l, lo_h, hi_l]))
+                Some(T::from_felts(&[hi_l, lo_h, lo_l]))
             }
             n => {
                 assert_ne!(n, 0);

midenc-debug/src/felt.rs

@@ -68,7 +68,7 @@ pub trait ToMidenRepr {
     /// Push this value on the given operand stack using [Self::to_felts] representation
     fn push_to_operand_stack(&self, stack: &mut Vec<RawFelt>) {
         let felts = self.to_felts();
-        for felt in felts.into_iter().rev() {
+        for felt in felts.into_iter() {
             stack.push(felt);
         }
     }
@@ -400,7 +400,7 @@ impl ToMidenRepr for u64 {
         let bytes = self.to_be_bytes();
         let hi = u32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
         let lo = u32::from_be_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]);
-        smallvec![RawFelt::new(hi as u64), RawFelt::new(lo as u64)]
+        smallvec![RawFelt::new(lo as u64), RawFelt::new(hi as u64)]
     }
 }
 
@@ -466,9 +466,7 @@ impl ToMidenRepr for u128 {
         let lo_l =
             RawFelt::new(u32::from_be_bytes([bytes[12], bytes[13], bytes[14], bytes[15]]) as u64);
 
-        // The 64-bit limbs are little endian, (lo, hi), but the 32-bit limbs of those 64-bit
-        // values are big endian, (lo_h, lo_l) and (hi_h, hi_l).
-        smallvec![lo_h, lo_l, hi_h, hi_l]
+        smallvec![hi_l, hi_h, lo_l, lo_h]
     }
 }
 

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:?}"),
@@ -121,12 +121,15 @@ fn load_dw() {
         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})");
+
+                prop_assert_eq!(lo, value & 0xffffffff);
+                prop_assert_eq!(hi, value >> 32);
+
                 let 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 \
@@ -145,14 +148,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 +217,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 +286,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 +361,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 +505,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 +727,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 +829,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 +918,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);