feat: add Succinct target, impl stdlib functionality

Author: nhtyy

compiler/rustc_target/src/spec/mod.rs

@@ -1954,6 +1954,7 @@ supported_targets! {
 
     ("riscv32i-unknown-none-elf", riscv32i_unknown_none_elf),
     ("riscv32im-risc0-zkvm-elf", riscv32im_risc0_zkvm_elf),
+    ("riscv32im-succinct-zkvm-elf", riscv32im_succinct_zkvm_elf),
     ("riscv32im-unknown-none-elf", riscv32im_unknown_none_elf),
     ("riscv32ima-unknown-none-elf", riscv32ima_unknown_none_elf),
     ("riscv32imc-unknown-none-elf", riscv32imc_unknown_none_elf),

compiler/rustc_target/src/spec/targets/riscv32im_succinct_zkvm_elf.rs

@@ -0,0 +1,42 @@
+use crate::spec::{
+    Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+};
+
+pub(crate) fn target() -> Target {
+    Target {
+        data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(),
+        llvm_target: "riscv32".into(),
+        metadata: TargetMetadata {
+            description: Some("Succinct's zero-knowledge Virtual Machine (RV32IM ISA)".into()),
+            tier: Some(3),
+            host_tools: Some(false),
+            std: Some(true),
+        },
+        pointer_width: 32,
+        arch: "riscv32".into(),
+
+        options: TargetOptions {
+            os: "succinct-zkvm".into(),
+            vendor: "succinct".into(),
+            linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
+            linker: Some("rust-lld".into()),
+            cpu: "generic-rv32".into(),
+
+            // The zkvm is singlethreaded and all operations are atomic.
+            // The std-lib is compiled with lowered atomicsa and the default Succinct build tools
+            // enforce this on programs.
+            max_atomic_width: Some(64),
+            atomic_cas: true,
+
+            features: "+m".into(),
+            llvm_abiname: "ilp32".into(),
+            executables: true,
+            panic_strategy: PanicStrategy::Abort,
+            relocation_model: RelocModel::Static,
+            emit_debug_gdb_scripts: false,
+            eh_frame_header: false,
+            singlethread: true,
+            ..Default::default()
+        },
+    }
+}

library/panic_abort/Cargo.toml

@@ -19,3 +19,10 @@ compiler_builtins = "0.1.0"
 
 [target.'cfg(not(all(windows, target_env = "msvc")))'.dependencies]
 libc = { version = "0.2", default-features = false }
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = [
+    'cfg(bootstrap)',
+    'cfg(target_os, values("succinct-zkvm"))'
+]

library/panic_abort/src/lib.rs

@@ -20,7 +20,7 @@
 #[cfg(target_os = "android")]
 mod android;
 
-#[cfg(target_os = "zkvm")]
+#[cfg(any(target_os = "zkvm", target_os = "succinct-zkvm"))]
 mod zkvm;
 
 use core::any::Any;
@@ -40,7 +40,7 @@ pub unsafe fn __rust_start_panic(_payload: &mut dyn PanicPayload) -> u32 {
     unsafe {
         android::android_set_abort_message(_payload);
     }
-    #[cfg(target_os = "zkvm")]
+    #[cfg(any(target_os = "zkvm", target_os = "succinct-zkvm"))]
     unsafe {
         zkvm::zkvm_set_abort_message(_payload);
     }

library/std/Cargo.toml

@@ -163,4 +163,6 @@ check-cfg = [
     # and to the `backtrace` crate which messes-up with Cargo list
     # of declared features, we therefor expect any feature cfg
     'cfg(feature, values(any()))',
+    'cfg(target_os, values("succinct-zkvm"))'
 ]
+

library/std/build.rs

@@ -59,9 +59,9 @@ fn main() {
         || target_os == "uefi"
         || target_os == "teeos"
         || target_os == "zkvm"
+        || target_os == "succinct-zkvm"
         || target_os == "rtems"
         || target_os == "nuttx"
-
         // See src/bootstrap/src/core/build_steps/synthetic_targets.rs
         || env::var("RUSTC_BOOTSTRAP_SYNTHETIC_TARGET").is_ok()
     {

library/std/src/sys/alloc/mod.rs

@@ -88,7 +88,7 @@ cfg_if::cfg_if! {
         mod wasm;
     } else if #[cfg(target_os = "xous")] {
         mod xous;
-    } else if #[cfg(target_os = "zkvm")] {
+    } else if #[cfg(any(target_os = "zkvm", target_os = "succinct-zkvm"))] {
         mod zkvm;
     }
 }

library/std/src/sys/pal/mod.rs

@@ -58,7 +58,7 @@ cfg_if::cfg_if! {
     } else if #[cfg(target_os = "teeos")] {
         mod teeos;
         pub use self::teeos::*;
-    } else if #[cfg(target_os = "zkvm")] {
+    } else if #[cfg(any(target_os = "zkvm", target_os = "succinct-zkvm"))] {
         mod zkvm;
         pub use self::zkvm::*;
     } else {

library/std/src/sys/pal/zkvm/abi.rs

@@ -1,11 +1,6 @@
-//! ABI definitions for symbols exported by risc0-zkvm-platform.
-
-// Included here so we don't have to depend on risc0-zkvm-platform.
-//
-// FIXME: Should we move this to the "libc" crate?  It seems like other
-// architectures put a lot of this kind of stuff there.  But there's
-// currently no risc0 fork of the libc crate, so we'd either have to
-// fork it or upstream it.
+//! ABI definitions for symbols exported by <_>-zkvm targets.
+//! 
+//! Ideally, these should be the minimum viable symbols to support the std-lib.
 
 #![allow(dead_code)]
 pub const DIGEST_WORDS: usize = 8;
@@ -15,9 +10,12 @@ pub mod fileno {
     pub const STDIN: u32 = 0;
     pub const STDOUT: u32 = 1;
     pub const STDERR: u32 = 2;
+
+    #[cfg(target_vendor = "risc0")]
     pub const JOURNAL: u32 = 3;
 }
 
+#[cfg(target_vendor = "risc0")]
 unsafe extern "C" {
     // Wrappers around syscalls provided by risc0-zkvm-platform:
     pub fn sys_halt();
@@ -53,3 +51,27 @@ unsafe extern "C" {
     pub fn sys_alloc_words(nwords: usize) -> *mut u32;
     pub fn sys_alloc_aligned(nwords: usize, align: usize) -> *mut u8;
 }
+
+#[cfg(target_os = "succinct-zkvm")]
+unsafe extern "C" {
+    pub fn sys_halt();
+    pub fn sys_rand(recv_buf: *mut u8, words: usize);
+    pub fn sys_panic(msg_ptr: *const u8, len: usize) -> !;
+    pub fn sys_write(fd: u32, write_buf: *const u8, nbytes: usize);
+    pub fn sys_getenv(
+        recv_buf: *mut u32,
+        words: usize,
+        varname: *const u8,
+        varname_len: usize,
+    ) -> usize;
+    pub fn sys_argv(out_words: *mut u32, out_nwords: usize, arg_index: usize) -> usize;
+    pub fn sys_alloc_aligned(nwords: usize, align: usize) -> *mut u8;
+}
+
+#[cfg(target_os = "succinct-zkvm")]
+// Note: sys_read is not implemented for succinct.
+// However, it is a function used in the standard library, so we need to
+// implement it.
+pub unsafe extern "C" fn sys_read(_: u32, _: *mut u8, _: usize) -> usize {
+    panic!("sys_read not implemented for succinct");
+}

library/std/src/sys/pal/zkvm/args.rs

@@ -1,23 +1,34 @@
-use super::{WORD_SIZE, abi};
 use crate::ffi::OsString;
 use crate::fmt;
-use crate::sys::os_str;
-use crate::sys_common::FromInner;
+
+#[cfg(target_vendor = "risc0")]
+use {
+    super::{WORD_SIZE, abi},
+    crate::sys_common::FromInner,
+    crate::sys::os_str,
+};
 
 pub struct Args {
     i_forward: usize,
     i_back: usize,
     count: usize,
 }
 
+#[cfg(target_vendor = "risc0")]
 pub fn args() -> Args {
     let count = unsafe { abi::sys_argc() };
     Args { i_forward: 0, i_back: 0, count }
 }
 
+#[cfg(target_os = "succinct-zkvm")]
+pub fn args() -> Args {
+    panic!("args not implemented for succinct");
+}
+
 impl Args {
     /// Use sys_argv to get the arg at the requested index. Does not check that i is less than argc
     /// and will not return if the index is out of bounds.
+    #[cfg(target_vendor = "risc0")]
     fn argv(i: usize) -> OsString {
         let arg_len = unsafe { abi::sys_argv(crate::ptr::null_mut(), 0, i) };
 
@@ -36,6 +47,11 @@ impl Args {
             unsafe { crate::slice::from_raw_parts(words.cast() as *const u8, arg_len) };
         OsString::from_inner(os_str::Buf { inner: arg_bytes.to_vec() })
     }
+
+    #[cfg(target_os = "succinct-zkvm")]
+    fn argv(_: usize) -> OsString {
+        panic!("argv not implemented for succinct");
+    }
 }
 
 impl fmt::Debug for Args {