Support building pico guest program with stock rust compiler. Add compilation and execution unit tests.

WiP. Works but needs cleanup

Author: rodiazet

Cargo.lock

@@ -6,7 +6,9 @@ rust-version.workspace = true
 license.workspace = true
 
 [dependencies]
+anyhow.workspace = true
 bincode.workspace = true
+cargo_metadata.workspace = true
 serde.workspace = true
 thiserror.workspace = true
 

crates/ere-pico/Cargo.toml

@@ -0,0 +1,101 @@
+use std::fs;
+use crate::error::PicoError;
+use std::path::Path;
+use std::process::Command;
+use cargo_metadata::MetadataCommand;
+
+static CARGO_ENCODED_RUSTFLAGS_SEPARATOR: &str = "\x1f";
+
+pub fn compile_pico_program_stock_rust(
+    guest_directory: &Path,
+    toolchain: &String,
+) -> Result<Vec<u8>, PicoError> {
+
+    let metadata = MetadataCommand::new().current_dir(guest_directory).exec()?;
+    let package = metadata
+        .root_package()
+        .ok_or_else(|| PicoError::MissingPackageName {
+            path: guest_directory.to_path_buf(),
+        })?;
+
+    let target_name = "riscv32ima-unknown-none-elf";
+    let plus_toolchain = format!("+{}", toolchain);
+
+    let args = [
+        plus_toolchain.as_str(),
+        "build",
+        "--target",
+        target_name,
+        "--release",
+        // For bare metal we have to build core and alloc
+        "-Zbuild-std=core,alloc",
+    ];
+
+    let rust_flags = [
+        "-C",
+        "passes=lower-atomic", // Only for rustc > 1.81
+        "-C",
+        // Start of the code section
+        "link-arg=-Ttext=0x00201000",
+        "-C",
+        // The lowest memory location that will be used when your program is loaded
+        "link-arg=--image-base=0x00200800",
+        "-C",
+        "panic=abort",
+        "--cfg",
+        "getrandom_backend=\"custom\"",
+        "-C",
+        "llvm-args=-misched-prera-direction=bottomup",
+        "-C",
+        "llvm-args=-misched-postra-direction=bottomup",
+    ];
+
+    let encoded_rust_flags = rust_flags
+        .into_iter()
+        .collect::<Vec<_>>()
+        .join(CARGO_ENCODED_RUSTFLAGS_SEPARATOR);
+
+    let result = Command::new("cargo")
+        .current_dir(guest_directory)
+        .env("CARGO_ENCODED_RUSTFLAGS", &encoded_rust_flags)
+        .args(args)
+        .stdout(std::process::Stdio::inherit())
+        .stderr(std::process::Stdio::inherit())
+        .status()
+        .map_err(|source| PicoError::BuildFailure {
+            source: source.into(),
+            crate_path: guest_directory.to_path_buf()
+        });
+
+    if result.is_err() {
+        return Err(result.err().unwrap());
+    }
+
+    let elf_path =
+        guest_directory
+            .join("target")
+            .join(target_name)
+            .join("release")
+            .join(&package.name);
+
+    fs::read(&elf_path).map_err(|e| PicoError::ReadFile {
+        path: elf_path,
+        source: e,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use test_utils::host::testing_guest_directory;
+    use crate::compile_stock_rust::compile_pico_program_stock_rust;
+
+    #[test]
+    fn test_stock_compiler_impl() {
+        let guest_directory = testing_guest_directory(
+            "pico",
+            "stock_nightly_no_std");
+        let elf = compile_pico_program_stock_rust(&guest_directory, &"nightly".to_string());
+        assert!(!elf.is_err(), "jolt compilation failed");
+        assert!(!elf.unwrap().is_empty(), "ELF bytes should not be empty.");
+    }
+}

crates/ere-pico/src/compile_stock_rust.rs

@@ -33,4 +33,20 @@ pub enum PicoError {
         #[source]
         source: io::Error,
     },
+    #[error("Pico build failure for {crate_path} failed: {source}")]
+    BuildFailure {
+        #[source]
+        source: anyhow::Error,
+        crate_path: PathBuf,
+    },
+    #[error("Could not find `[package].name` in guest Cargo.toml at {path}")]
+    MissingPackageName { path: PathBuf },
+    #[error("Failed to read file at {path}: {source}")]
+    ReadFile {
+        path: PathBuf,
+        #[source]
+        source: std::io::Error,
+    },
+    #[error("`cargo metadata` failed: {0}")]
+    MetadataCommand(#[from] cargo_metadata::Error),
 }

crates/ere-pico/src/error.rs

@@ -3,11 +3,14 @@
 use pico_sdk::client::DefaultProverClient;
 use pico_vm::emulator::stdin::EmulatorStdinBuilder;
 use serde::de::DeserializeOwned;
-use std::{io::Read, path::Path, process::Command, time::Instant};
+use std::{env, io::Read, path::Path, process::Command, time::Instant};
 use zkvm_interface::{
     Compiler, Input, InputItem, ProgramExecutionReport, ProgramProvingReport, Proof,
     ProverResourceType, PublicValues, zkVM, zkVMError,
 };
+use compile_stock_rust::compile_pico_program_stock_rust;
+
+mod compile_stock_rust;
 
 include!(concat!(env!("OUT_DIR"), "/name_and_sdk_version.rs"));
 mod error;
@@ -21,38 +24,48 @@ impl Compiler for PICO_TARGET {
 
     type Program = Vec<u8>;
 
-    fn compile(&self, guest_path: &Path) -> Result<Self::Program, Self::Error> {
-        // 1. Check guest path
-        if !guest_path.exists() {
-            return Err(PicoError::PathNotFound(guest_path.to_path_buf()));
+    fn compile(&self, guest_directory: &Path) -> Result<Self::Program, Self::Error> {
+        let toolchain =
+            env::var("ERE_GUEST_TOOLCHAIN").unwrap_or_else(|_error| "risc0".into());
+        match toolchain.as_str() {
+            "risc0" => Ok(compile_pico_program(guest_directory)?),
+            _ => Ok(compile_pico_program_stock_rust(guest_directory, &toolchain)?),
         }
+    }
+}
 
-        // 2. Run `cargo pico build`
-        let status = Command::new("cargo")
-            .current_dir(guest_path)
-            .env("RUST_LOG", "info")
-            .args(["pico", "build"])
-            .status()?; // From<io::Error> → Spawn
-
-        if !status.success() {
-            return Err(PicoError::CargoFailed { status });
-        }
+fn compile_pico_program(guest_directory: &Path) -> Result<Vec<u8>, PicoError>
+{
+    // 1. Check guest path
+    if !guest_directory.exists() {
+        return Err(PicoError::PathNotFound(guest_directory.to_path_buf()));
+    }
 
-        // 3. Locate the ELF file
-        let elf_path = guest_path.join("elf/riscv32im-pico-zkvm-elf");
+    // 2. Run `cargo pico build`
+    let status = Command::new("cargo")
+        .current_dir(guest_directory)
+        .env("RUST_LOG", "info")
+        .args(["pico", "build"])
+        .status()?; // From<io::Error> → Spawn
 
-        if !elf_path.exists() {
-            return Err(PicoError::ElfNotFound(elf_path));
-        }
+    if !status.success() {
+        return Err(PicoError::CargoFailed { status });
+    }
 
-        // 4. Read the ELF file
-        let elf_bytes = std::fs::read(&elf_path).map_err(|e| PicoError::ReadElf {
-            path: elf_path,
-            source: e,
-        })?;
+    // 3. Locate the ELF file
+    let elf_path = guest_directory.join("elf/riscv32im-pico-zkvm-elf");
 
-        Ok(elf_bytes)
+    if !elf_path.exists() {
+        return Err(PicoError::ElfNotFound(elf_path));
     }
+
+    // 4. Read the ELF file
+    let elf_bytes = std::fs::read(&elf_path).map_err(|e| PicoError::ReadElf {
+        path: elf_path,
+        source: e,
+    })?;
+
+    Ok(elf_bytes)
 }
 
 pub struct ErePico {
@@ -194,6 +207,14 @@ mod tests {
         assert_eq!(io.deserialize_outputs(&zkvm, &public_values), io.outputs());
     }
 
+    #[test]
+    fn test_execute_nightly() {
+        let guest_directory = testing_guest_directory("pico", "stock_nightly_no_std");
+        let program = compile_pico_program_stock_rust(&guest_directory, &"nightly".to_string()).unwrap();
+        let zkvm = ErePico::new(program, ProverResourceType::Cpu);
+        run_zkvm_execute(&zkvm, &Input::new());
+    }
+
     #[test]
     fn test_execute_invalid_inputs() {
         let program = basic_program();

crates/ere-pico/src/lib.rs

@@ -0,0 +1,7 @@
+[package]
+name = "addition_no_std"
+edition = "2021"
+
+[dependencies]
+
+[workspace]

tests/pico/stock_nightly_no_std/Cargo.toml

@@ -0,0 +1,26 @@
+#![no_std]
+#![no_main]
+extern crate alloc;
+
+use alloc::vec::Vec;
+use core::sync::atomic::Ordering;
+use core::sync::atomic::AtomicU16;
+
+mod pico_rt;
+
+fn main() {
+    let a: AtomicU16 = core::hint::black_box(AtomicU16::new(5));
+    let b: AtomicU16 = core::hint::black_box(AtomicU16::new(7));
+
+    if a.load(Ordering::SeqCst) + b.load(Ordering::SeqCst) != 12 {
+        panic!("Something went wrong!");
+    }
+
+    let mut v: Vec<AtomicU16> = Vec::new();
+    v.push(AtomicU16::new(5));
+    v.push(AtomicU16::new(7));
+
+    if v[0].load(Ordering::SeqCst) + v[1].load(Ordering::SeqCst) != 12 {
+        panic!("Something went wrong!");
+    }
+}