chore: execution runs without runtime errors; failing at verification stages

Author: Maillew

benchmarks/guest/fibonacci/Cargo.toml

@@ -7,4 +7,5 @@ edition.workspace = true
 openvm = { workspace = true, features = ["std"] }
 
 [features]
-default = []
+default = ["custom-memcpy"]
+custom-memcpy = []

benchmarks/guest/fibonacci/src/main.rs

@@ -2,34 +2,45 @@ use core::ptr;
 
 openvm::entry!(main);
 
-/// Moves all the elements of `src` into `dst`, leaving `src` empty.
-#[no_mangle]
-pub fn append<T>(dst: &mut [T], src: &mut [T], shift: usize) {
+// Explicitly use the C memcpy function to ensure we're using custom memcpy
+extern "C" {
+    // in rust, u8 is 1 byte of memory
+    fn memcpy(dst: *mut u8, src: *const u8, n: usize) -> *mut u8;
+}
+
+/// Test function that explicitly calls memcpy to verify custom implementation
+pub fn test_custom_memcpy(dst: &mut [u8], src: &[u8], shift: usize) {
     let src_len = src.len();
     let dst_len = dst.len();
 
+    // Bounds checking
+    if shift + src_len > dst_len {
+        return; // Just return on bounds error
+    }
+
     unsafe {
-        // The call to add is always safe because `Vec` will never
-        // allocate more than `isize::MAX` bytes.
-        let dst_ptr = dst.as_mut_ptr().wrapping_add(shift);
+        let dst_ptr = dst.as_mut_ptr().add(shift);
         let src_ptr = src.as_ptr();
-        println!("dst_ptr: {:?}", dst_ptr);
-        println!("src_ptr: {:?}", src_ptr);
-        println!("src_len: {:?}", src_len);
-
-        // The two regions cannot overlap because mutable references do
-        // not alias, and two different vectors cannot own the same
-        // memory.
-        ptr::copy_nonoverlapping(src_ptr, dst_ptr, src_len);
+
+        // This will definitely use our custom memcpy implementation
+        memcpy(dst_ptr, src_ptr, src_len);
     }
 }
 
 pub fn main() {
     let mut a: [u8; 1000] = [1; 1000];
+    for i in 0..1000 {
+        a[i] = 1 as u8;
+    }
     let mut b: [u8; 500] = [2; 500];
+    for i in 0..500 {
+        b[i] = 2 as u8;
+    }
+
+    let shift: usize = 3;
 
-    let shift: usize = 0;
-    append(&mut a, &mut b, shift);
+    // Test the custom memcpy
+    test_custom_memcpy(&mut a, &b, shift);
 
     for i in 0..1000 {
         if i < shift || i >= shift + b.len() {
@@ -42,3 +53,7 @@ pub fn main() {
     println!("a: {:?}", a);
     println!("b: {:?}", b);
 }
+/*
+ok what lolll
+memcpy works (??)
+*/

crates/toolchain/openvm/Cargo.toml

@@ -28,13 +28,15 @@ num-bigint.workspace = true
 chrono = { version = "0.4", default-features = false, features = ["serde"] }
 
 [features]
-default = ["getrandom-unsupported"]
+default = ["getrandom-unsupported", "custom-memcpy"]
 # Defines a custom getrandom backend that always errors. This feature should be enabled if you are sure getrandom is never used but it is pulled in as a compilation dependency.
 getrandom-unsupported = ["dep:getrandom", "dep:getrandom-v02"]
 # The zkVM uses a bump-pointer heap allocator by default which does not free
 # memory. This will use a slower linked-list heap allocator to reclaim memory.
 heap-embedded-alloc = ["openvm-platform/heap-embedded-alloc"]
 std = ["serde/std", "openvm-platform/std"]
+# Enable custom memcpy implementation with specialized instructions
+custom-memcpy = []
 
 [package.metadata.cargo-shear]
 ignored = ["openvm-custom-insn", "getrandom"]

extensions/memcpy/circuit/Cargo.toml

@@ -22,3 +22,7 @@ derive_more = { workspace = true, features = ["from"] }
 serde.workspace = true
 strum = { workspace = true }
 tracing.workspace = true
+
+[features]
+default = ["custom-memcpy"]
+custom-memcpy = []

extensions/memcpy/circuit/src/iteration.rs

@@ -93,6 +93,7 @@ impl<F: Field> BaseAirWithPublicValues<F> for MemcpyIterAir {}
 impl<F: Field> PartitionedBaseAir<F> for MemcpyIterAir {}
 
 impl<AB: InteractionBuilder> Air<AB> for MemcpyIterAir {
+    // assertions for AIR constraints
     fn eval(&self, builder: &mut AB) {
         let main = builder.main();
         let (prev, local) = (main.row_slice(0), main.row_slice(1));
@@ -377,6 +378,8 @@ impl<'a> CustomBorrow<'a, MemcpyIterRecordMut<'a>, MemcpyIterLayout> for [u8] {
     unsafe fn extract_layout(&self) -> MemcpyIterLayout {
         let header: &MemcpyIterRecordHeader = self.borrow();
         let num_rows = ((header.len - header.shift as u32) >> 4) as usize + 1;
+        MultiRowLayout::new(MemcpyIterMetadata { num_rows });
+        let num_rows = ((header.len - header.shift as u32) >> 4) as usize + 1;
         MultiRowLayout::new(MemcpyIterMetadata { num_rows })
     }
 }
@@ -420,7 +423,7 @@ where
     ) -> Result<(), ExecutionError> {
         let Instruction { opcode, c, .. } = instruction;
         debug_assert_eq!(*opcode, Rv32MemcpyOpcode::MEMCPY_LOOP.global_opcode());
-        let shift = c.as_canonical_u32() as u8;
+        let shift = c.as_canonical_u32() as u8; // written into c slot
         debug_assert!([0, 1, 2, 3].contains(&shift));
 
         let mut dest = read_rv32_register(
@@ -440,17 +443,25 @@ where
             } as u32,
         );
         let mut len = read_rv32_register(state.memory.data(), A2_REGISTER_PTR as u32);
+        debug_assert!(
+            shift == 0 || (dest % 4 == 0),
+            "dest must be 4-byte aligned in MEMCPY_LOOP"
+        );
+        debug_assert!(len >= shift as u32);
 
         // Create a record sized to the exact number of 16-byte iterations (header + iterations)
         // This calculation must match extract_layout and fill_trace
 
-        // FIX 1: prevent underflow when len < shift
-        let effective_len = len.saturating_sub(shift as u32);
+        let effective_len = len.saturating_sub(shift as u32); // n >= 16 + shift
         let num_iters = (effective_len >> 4) as usize;
-        eprintln!("num_iters = {:?}", num_iters);
-        // eprintln!("state.pc = {:?}", state.pc);
-        // eprintln!("state.memory.timestamp = {:?}", state.memory.timestamp);
-        // eprintln!("state.memory.data() = {:?}", state.memory.data());
+        // eprintln!(
+        //     "PREFLIGHT: len={}, shift={}, effective_len={}, num_iters={}, allocated_rows={}",
+        //     len,
+        //     shift,
+        //     effective_len,
+        //     num_iters,
+        //     num_iters + 1
+        // );
         let record: MemcpyIterRecordMut<'_> =
             state.ctx.alloc(MultiRowLayout::new(MemcpyIterMetadata {
                 //allocating based on number of rows needed
@@ -464,15 +475,16 @@ where
         record.inner.dest = dest;
         record.inner.source = source;
         record.inner.len = len;
-        eprintln!(
-            "shift = {:?}, len = {:?}, source = {:?}, source%16 = {:?}, dest = {:?}, dest%16 = {:?}",  
-            shift, len, source, source % 16, dest, dest % 16
-        );
+        // eprintln!(
+        //     "shift = {:?}, len = {:?}, source = {:?}, source%16 = {:?}, dest = {:?}, dest%16 = {:?}",
+        //     shift, len, source, source % 16, dest, dest % 16
+        // );
 
         // Fill record.var for the first row of iteration trace
         // FIX 2: read source-4 (the word ending at s[-1]); zero if out-of-bounds.
         if shift != 0 {
             if source >= 4 {
+                // read the previous word from memory
                 record.var[0].data[3] = tracing_read(
                     state.memory,
                     RV32_MEMORY_AS,
@@ -494,13 +506,14 @@ where
                     source + 4 * i as u32,
                     &mut record.var[idx].read_aux[i].prev_timestamp,
                 );
+                //use shifted data, to construct the write data for each given word
                 let write_data: [u8; MEMCPY_LOOP_NUM_LIMBS] = array::from_fn(|j| {
                     if j < shift as usize {
                         if i > 0 {
-                            // First s bytes come from previous 4-byte word tail
+                            // First s bytes come from previous 4-byte word tail, take from previous word, in our 16 byte chunk
                             record.var[idx].data[i - 1][j + (4 - shift as usize)]
                         } else {
-                            // For i == 0, take from previous chunk's last word tail
+                            // For i == 0, take from previous chunk's last word tail; otherwise, take last word of previous chunk
                             record.var[idx - 1].data[3][j + (4 - shift as usize)]
                         }
                     } else {
@@ -570,7 +583,7 @@ where
         debug_assert_eq!(record.inner.len, u32::from_le_bytes(len_data));
 
         *state.pc = state.pc.wrapping_add(DEFAULT_PC_STEP);
-
+        eprintln!("PREFLIGHT: done");
         Ok(())
     }
 }
@@ -936,6 +949,7 @@ unsafe fn execute_e12_impl<F: PrimeField32, CTX: ExecutionCtxTrait>(
 ) -> u32 {
     let shift = pre_compute.c;
     let mut height = 1;
+    eprintln!("RUNTIME: Starting with height={}, shift={}", height, shift);
     // Read dest and source from registers
     let (dest, source) = if shift == 0 {
         (
@@ -955,6 +969,11 @@ unsafe fn execute_e12_impl<F: PrimeField32, CTX: ExecutionCtxTrait>(
     let mut source = u32::from_le_bytes(source) - 12 * (shift != 0) as u32;
     let mut len = u32::from_le_bytes(len);
 
+    eprintln!(
+        "RUNTIME: Initial values: dest={}, source={}, len={}",
+        dest, source, len
+    );
+
     // Check address ranges are valid
     debug_assert!(dest < (1 << POINTER_MAX_BITS));
     debug_assert!((source - 4 * (shift != 0) as u32) < (1 << POINTER_MAX_BITS));
@@ -994,28 +1013,8 @@ unsafe fn execute_e12_impl<F: PrimeField32, CTX: ExecutionCtxTrait>(
         height += 1;
     }
 
-    // Handle remaining bytes (len in [0, 15]) so that total `copy_len == original len`.
-    if len > 0 {
-        let remaining_words = ((len + 3) >> 2) as usize;
-        for i in 0..remaining_words.min(4) {
-            let data = vm_state.vm_read::<u8, 4>(RV32_MEMORY_AS, source + 4 * i as u32);
-            let write_data: [u8; 4] = array::from_fn(|j| {
-                if j < shift as usize {
-                    prev_data[j + (4 - shift as usize)]
-                } else {
-                    data[j - shift as usize]
-                }
-            });
-            vm_state.vm_write(RV32_MEMORY_AS, dest + 4 * i as u32, &write_data);
-            prev_data = data;
-        }
-        // Advance pointers to reflect bytes written
-        let advanced = (remaining_words as u32) << 2;
-        source += advanced;
-        dest += advanced;
-        len = 0;
-        height += 1;
-    }
+    // Note: remaining bytes (len in [0, 15]) are handled by surrounding code,
+    // not by this executor. The height calculation must match the trace exactly.
 
     // Write the result back to memory
     if shift == 0 {
@@ -1046,6 +1045,7 @@ unsafe fn execute_e12_impl<F: PrimeField32, CTX: ExecutionCtxTrait>(
 
     *vm_state.pc_mut() = vm_state.pc().wrapping_add(DEFAULT_PC_STEP);
     *vm_state.instret_mut() = vm_state.instret() + 1;
+    eprintln!("RUNTIME: Returning height={}", height);
     height
 }
 

extensions/memcpy/circuit/src/loops.rs

@@ -60,6 +60,10 @@ pub struct MemcpyLoopCols<T> {
     pub write_aux: [MemoryBaseAuxCols<T>; 3],
     pub source_minus_twelve_carry: T,
     pub to_source_minus_twelve_carry: T,
+    // When true, indicates we should saturate (clamp) source-12 to 0 (zero-padding case)
+    pub is_source_small: T,
+    // When true, indicates we should saturate (clamp) to_source-12 to 0 (zero-padding case)
+    pub is_to_source_small: T,
 }
 
 pub const NUM_MEMCPY_LOOP_COLS: usize = size_of::<MemcpyLoopCols<u8>>();
@@ -124,6 +128,8 @@ impl<AB: InteractionBuilder> Air<AB> for MemcpyLoopAir {
         local.shift.iter().for_each(|x| builder.assert_bool(*x));
         builder.assert_bool(local.source_minus_twelve_carry);
         builder.assert_bool(local.to_source_minus_twelve_carry);
+        builder.assert_bool(local.is_source_small);
+        builder.assert_bool(local.is_to_source_small);
 
         let mut shift_zero_when = builder.when(is_shift_zero.clone());
         shift_zero_when.assert_zero(local.source_minus_twelve_carry);
@@ -184,6 +190,8 @@ impl<AB: InteractionBuilder> Air<AB> for MemcpyLoopAir {
         // dest, to_dest, source - 12 * is_shift_non_zero, to_source - 12 * is_shift_non_zero
         let dest_u16_limbs = u8_word_to_u16(local.dest);
         let to_dest_u16_limbs = u8_word_to_u16(local.to_dest);
+        // Limb computation for (source - 12 * is_shift_non_zero), with zero-padding when low limb < 12
+        // If is_source_small is true, we clamp subtraction to 0 by setting carry appropriately.
         let source_u16_limbs = [
             local.source[0]
                 + local.source[1] * AB::F::from_canonical_u32(1 << MEMCPY_LOOP_LIMB_BITS)
@@ -356,17 +364,19 @@ impl MemcpyLoopChip {
         let to_source = source + num_copies;
 
         let word_to_u16 = |data: u32| [data & 0x0ffff, data >> 16];
-        debug_assert!(source >= 12 * (shift != 0) as u32);
-        debug_assert!(to_source >= 12 * (shift != 0) as u32);
+
+        // Relax: allow small sources; zero-pad semantics like iteration.rs
         debug_assert!(dest % 4 == 0);
         debug_assert!(to_dest % 4 == 0);
         debug_assert!(source % 4 == 0);
         debug_assert!(to_source % 4 == 0);
+        let safe_source = source.saturating_sub(12 * (shift != 0) as u32);
+        let safe_to_source = to_source.saturating_sub(12 * (shift != 0) as u32);
         let range_check_data = [
             word_to_u16(dest),
-            word_to_u16(source - 12 * (shift != 0) as u32),
+            word_to_u16(safe_source),
             word_to_u16(to_dest),
-            word_to_u16(to_source - 12 * (shift != 0) as u32),
+            word_to_u16(safe_to_source),
         ];
 
         range_check_data.iter().for_each(|data| {
@@ -437,19 +447,19 @@ impl MemcpyLoopChip {
             cols.source_minus_twelve_carry = F::from_bool((record.source & 0x0ffff) < 12);
             cols.to_source_minus_twelve_carry = F::from_bool((to_source & 0x0ffff) < 12);
 
-            // tracing::info!("timestamp: {:?}, pc: {:?}, dest: {:?}, source: {:?}, len: {:?}, shift: {:?}, is_valid: {:?}, to_timestamp: {:?}, to_dest: {:?}, to_source: {:?}, to_len: {:?}, write_aux: {:?}", 
-            //                 cols.from_state.timestamp.as_canonical_u32(), 
-            //                 cols.from_state.pc.as_canonical_u32(), 
-            //                 u32::from_le_bytes(cols.dest.map(|x| x.as_canonical_u32() as u8)), 
-            //                 u32::from_le_bytes(cols.source.map(|x| x.as_canonical_u32() as u8)), 
-            //                 u32::from_le_bytes(cols.len.map(|x| x.as_canonical_u32() as u8)), 
-            //                 cols.shift[1].as_canonical_u32() * 2 + cols.shift[0].as_canonical_u32(), 
-            //                 cols.is_valid.as_canonical_u32(), 
-            //                 cols.to_timestamp.as_canonical_u32(), 
-            //                 u32::from_le_bytes(cols.to_dest.map(|x| x.as_canonical_u32() as u8)), 
-            //                 u32::from_le_bytes(cols.to_source.map(|x| x.as_canonical_u32() as u8)), 
-            //                 cols.to_len.as_canonical_u32(), 
-            //                 cols.write_aux.map(|x| x.prev_timestamp.as_canonical_u32()).to_vec());
+            tracing::info!("timestamp: {:?}, pc: {:?}, dest: {:?}, source: {:?}, len: {:?}, shift: {:?}, is_valid: {:?}, to_timestamp: {:?}, to_dest: {:?}, to_source: {:?}, to_len: {:?}, write_aux: {:?}",
+                            cols.from_state.timestamp.as_canonical_u32(),
+                            cols.from_state.pc.as_canonical_u32(),
+                            u32::from_le_bytes(cols.dest.map(|x| x.as_canonical_u32() as u8)),
+                            u32::from_le_bytes(cols.source.map(|x| x.as_canonical_u32() as u8)),
+                            u32::from_le_bytes(cols.len.map(|x| x.as_canonical_u32() as u8)),
+                            cols.shift[1].as_canonical_u32() * 2 + cols.shift[0].as_canonical_u32(),
+                            cols.is_valid.as_canonical_u32(),
+                            cols.to_timestamp.as_canonical_u32(),
+                            u32::from_le_bytes(cols.to_dest.map(|x| x.as_canonical_u32() as u8)),
+                            u32::from_le_bytes(cols.to_source.map(|x| x.as_canonical_u32() as u8)),
+                            cols.to_len.as_canonical_u32(),
+                            cols.write_aux.map(|x| x.prev_timestamp.as_canonical_u32()).to_vec());
         }
         RowMajorMatrix::new(rows, NUM_MEMCPY_LOOP_COLS)
     }

extensions/memcpy/tests/Cargo.toml

@@ -24,5 +24,6 @@ test-case.workspace = true
 tracing.workspace = true
 
 [features]
-default = ["parallel"]
+default = ["parallel", "custom-memcpy"]
 parallel = ["openvm-circuit/parallel"]
+custom-memcpy = []