fix: add memcpy to toolchain

Author: pjabbarzade

Cargo.lock

@@ -169,6 +169,8 @@ openvm-ecc-sw-macros = { path = "extensions/ecc/sw-macros", default-features = f
 openvm-pairing-circuit = { path = "extensions/pairing/circuit", default-features = false }
 openvm-pairing-transpiler = { path = "extensions/pairing/transpiler", default-features = false }
 openvm-pairing-guest = { path = "extensions/pairing/guest", default-features = false }
+openvm-memcpy-circuit = { path = "extensions/memcpy/circuit", default-features = false }
+openvm-memcpy-transpiler = { path = "extensions/memcpy/transpiler", default-features = false }
 openvm-verify-stark = { path = "guest-libs/verify_stark", default-features = false }
 
 # Benchmarking

Cargo.toml

@@ -24,6 +24,8 @@ openvm-pairing-guest.workspace = true
 openvm-pairing-transpiler.workspace = true
 openvm-keccak256-circuit.workspace = true
 openvm-keccak256-transpiler.workspace = true
+openvm-memcpy-circuit.workspace = true
+openvm-memcpy-transpiler.workspace = true
 openvm-rv32im-circuit.workspace = true
 openvm-rv32im-transpiler.workspace = true
 openvm-sha256-circuit.workspace = true

benchmarks/execute/Cargo.toml

@@ -28,6 +28,8 @@ use openvm_ecc_circuit::{EccCpuProverExt, WeierstrassExtension, WeierstrassExten
 use openvm_ecc_transpiler::EccTranspilerExtension;
 use openvm_keccak256_circuit::{Keccak256, Keccak256CpuProverExt, Keccak256Executor};
 use openvm_keccak256_transpiler::Keccak256TranspilerExtension;
+use openvm_memcpy_circuit::{Memcpy, MemcpyCpuProverExt, MemcpyExecutor};
+use openvm_memcpy_transpiler::MemcpyTranspilerExtension;
 use openvm_native_circuit::{NativeConfig, NativeCpuBuilder, NATIVE_MAX_TRACE_HEIGHTS};
 use openvm_pairing_circuit::{
     PairingCurve, PairingExtension, PairingExtensionExecutor, PairingProverExt,
@@ -94,6 +96,8 @@ pub struct ExecuteConfig {
     #[extension]
     pub keccak: Keccak256,
     #[extension]
+    pub memcpy: Memcpy,
+    #[extension]
     pub sha256: Sha256,
     #[extension]
     pub modular: ModularExtension,
@@ -115,6 +119,7 @@ impl Default for ExecuteConfig {
             io: Rv32Io,
             bigint: Int256::default(),
             keccak: Keccak256,
+            memcpy: Memcpy,
             sha256: Sha256,
             modular: ModularExtension::new(vec![
                 bn_config.modulus.clone(),
@@ -175,6 +180,7 @@ where
             &config.keccak,
             inventory,
         )?;
+        VmProverExtension::<E, _, _>::extend_prover(&MemcpyCpuProverExt, &config.memcpy, inventory)?;
         VmProverExtension::<E, _, _>::extend_prover(&Sha2CpuProverExt, &config.sha256, inventory)?;
         VmProverExtension::<E, _, _>::extend_prover(
             &AlgebraCpuProverExt,
@@ -203,6 +209,7 @@ fn create_default_transpiler() -> Transpiler<BabyBear> {
         .with_extension(Rv32MTranspilerExtension)
         .with_extension(Int256TranspilerExtension)
         .with_extension(Keccak256TranspilerExtension)
+        .with_extension(MemcpyTranspilerExtension)
         .with_extension(Sha256TranspilerExtension)
         .with_extension(ModularTranspilerExtension)
         .with_extension(Fp2TranspilerExtension)

benchmarks/execute/benches/execute.rs

@@ -18,6 +18,8 @@ openvm-ecc-circuit = { workspace = true }
 openvm-ecc-transpiler = { workspace = true }
 openvm-keccak256-circuit = { workspace = true }
 openvm-keccak256-transpiler = { workspace = true }
+openvm-memcpy-circuit = { workspace = true }
+openvm-memcpy-transpiler = { workspace = true }
 openvm-sha256-circuit = { workspace = true }
 openvm-sha256-transpiler = { workspace = true }
 openvm-pairing-circuit = { workspace = true }

crates/sdk/Cargo.toml

@@ -33,6 +33,8 @@ use openvm_rv32im_circuit::{
 use openvm_rv32im_transpiler::{
     Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
 };
+use openvm_memcpy_circuit::{Memcpy, MemcpyCpuProverExt, MemcpyExecutor};
+use openvm_memcpy_transpiler::MemcpyTranspilerExtension;
 use openvm_sha256_circuit::{Sha256, Sha256Executor, Sha2CpuProverExt};
 use openvm_sha256_transpiler::Sha256TranspilerExtension;
 use openvm_stark_backend::{
@@ -63,6 +65,7 @@ pub struct SdkVmConfig {
     pub rv32i: Option<UnitStruct>,
     pub io: Option<UnitStruct>,
     pub keccak: Option<UnitStruct>,
+    pub memcpy: Option<UnitStruct>,
     pub sha256: Option<UnitStruct>,
     pub native: Option<UnitStruct>,
     pub castf: Option<UnitStruct>,
@@ -100,6 +103,7 @@ impl SdkVmConfig {
             .rv32m(Default::default())
             .io(Default::default())
             .keccak(Default::default())
+            .memcpy(Default::default())
             .sha256(Default::default())
             .bigint(Default::default())
             .modular(ModularExtension::new(vec![
@@ -181,6 +185,9 @@ impl TranspilerConfig<F> for SdkVmConfig {
         if self.keccak.is_some() {
             transpiler = transpiler.with_extension(Keccak256TranspilerExtension);
         }
+        if self.memcpy.is_some() {
+            transpiler = transpiler.with_extension(MemcpyTranspilerExtension);
+        }
         if self.sha256.is_some() {
             transpiler = transpiler.with_extension(Sha256TranspilerExtension);
         }
@@ -251,6 +258,7 @@ impl SdkVmConfig {
         let rv32i = config.rv32i.map(|_| Rv32I);
         let io = config.io.map(|_| Rv32Io);
         let keccak = config.keccak.map(|_| Keccak256);
+        let memcpy = config.memcpy.map(|_| Memcpy);
         let sha256 = config.sha256.map(|_| Sha256);
         let native = config.native.map(|_| Native);
         let castf = config.castf.map(|_| CastFExtension);
@@ -266,6 +274,7 @@ impl SdkVmConfig {
             rv32i,
             io,
             keccak,
+            memcpy,
             sha256,
             native,
             castf,
@@ -297,6 +306,8 @@ pub struct SdkVmConfigInner {
     pub io: Option<Rv32Io>,
     #[extension(executor = "Keccak256Executor")]
     pub keccak: Option<Keccak256>,
+    #[extension(executor = "MemcpyExecutor")]
+    pub memcpy: Option<Memcpy>,
     #[extension(executor = "Sha256Executor")]
     pub sha256: Option<Sha256>,
     #[extension(executor = "NativeExecutor<F>")]
@@ -374,6 +385,9 @@ where
         if let Some(keccak) = &config.keccak {
             VmProverExtension::<E, _, _>::extend_prover(&Keccak256CpuProverExt, keccak, inventory)?;
         }
+        if let Some(memcpy) = &config.memcpy {
+            VmProverExtension::<E, _, _>::extend_prover(&MemcpyCpuProverExt, memcpy, inventory)?;
+        }
         if let Some(sha256) = &config.sha256 {
             VmProverExtension::<E, _, _>::extend_prover(&Sha2CpuProverExt, sha256, inventory)?;
         }
@@ -485,6 +499,12 @@ impl From<Keccak256> for UnitStruct {
     }
 }
 
+impl From<Memcpy> for UnitStruct {
+    fn from(_: Memcpy) -> Self {
+        UnitStruct {}
+    }
+}
+
 impl From<Sha256> for UnitStruct {
     fn from(_: Sha256) -> Self {
         UnitStruct {}
@@ -511,6 +531,7 @@ struct SdkVmConfigWithDefaultDeser {
     pub rv32i: Option<UnitStruct>,
     pub io: Option<UnitStruct>,
     pub keccak: Option<UnitStruct>,
+    pub memcpy: Option<UnitStruct>,
     pub sha256: Option<UnitStruct>,
     pub native: Option<UnitStruct>,
     pub castf: Option<UnitStruct>,
@@ -530,6 +551,7 @@ impl From<SdkVmConfigWithDefaultDeser> for SdkVmConfig {
             rv32i: config.rv32i,
             io: config.io,
             keccak: config.keccak,
+            memcpy: config.memcpy,
             sha256: config.sha256,
             native: config.native,
             castf: config.castf,

crates/sdk/src/config/global.rs

@@ -205,6 +205,11 @@
 	.attribute	4, 16
 	.attribute	5, "rv32im"
 	.file	"musl_memcpy.c"
+
+	# Define memcpy_loop macro for custom instruction (U-type)
+	.macro memcpy_loop shift
+		.word 0x72000000 | (\shift << 12)  # opcode 0x72 + shift in immediate field (bits 12-31)
+	.endm
 	.globl	memcpy
 	.p2align	2
 	.type	memcpy,@function

crates/toolchain/openvm/src/memcpy.s

@@ -311,7 +311,7 @@ pub type MemcpyLoopChip<F> = VmChipWrapper<F, MemcpyLoopFiller>;
 #[derive(AlignedBytesBorrow, Clone)]
 #[repr(C)]
 struct MemcpyLoopPreCompute {
-    a: u8,
+    c: u8,
 }
 
 impl<F, RA> PreflightExecutor<F, RA> for MemcpyLoopExecutor
@@ -328,9 +328,9 @@ where
         state: VmStateMut<F, TracingMemory, RA>,
         instruction: &Instruction<F>,
     ) -> Result<(), ExecutionError> {
-        let Instruction { opcode, a, .. } = instruction;
+        let Instruction { opcode, c, .. } = instruction;
         debug_assert_eq!(*opcode, Rv32MemcpyOpcode::MEMCPY_LOOP.global_opcode());
-        let shift = a.as_canonical_u32() as u8;
+        let shift = c.as_canonical_u32() as u8;
         debug_assert!([0, 1, 2, 3].contains(&shift));
         let mut record = state.ctx.alloc(EmptyMultiRowLayout::default());
 
@@ -600,7 +600,7 @@ unsafe fn execute_e12_impl<F: PrimeField32, CTX: E1ExecutionCtx>(
     pre_compute: &MemcpyLoopPreCompute,
     vm_state: &mut VmExecState<F, GuestMemory, CTX>,
 ) {
-    let shift = pre_compute.a;
+    let shift = pre_compute.c;
     let (dest, source) = if shift == 0 {
         (
             vm_state.vm_read::<u8, 4>(RV32_REGISTER_AS, A3_REGISTER_PTR as u32),
@@ -700,12 +700,12 @@ impl MemcpyLoopExecutor {
         inst: &Instruction<F>,
         data: &mut MemcpyLoopPreCompute,
     ) -> Result<(), StaticProgramError> {
-        let Instruction { opcode, a, .. } = inst;
-        let a_u32 = a.as_canonical_u32();
-        if ![0, 1, 2, 3].contains(&a_u32) {
+        let Instruction { opcode, c, .. } = inst;
+        let c_u32 = c.as_canonical_u32();
+        if ![0, 1, 2, 3].contains(&c_u32) {
             return Err(StaticProgramError::InvalidInstruction(pc));
         }
-        *data = MemcpyLoopPreCompute { a: a_u32 as u8 };
+        *data = MemcpyLoopPreCompute { c: c_u32 as u8 };
         assert_eq!(*opcode, Rv32MemcpyOpcode::MEMCPY_LOOP.global_opcode());
         Ok(())
     }