Add support for RISC V

Cargo.toml

@@ -9,6 +9,7 @@ homepage = "https://github.com/pnkfelix/cee-scape"
 documentation = "https://docs.rs/cee-scape/"
 repository = "https://github.com/pnkfelix/cee-scape"
 readme = "README.md"
+build = "build/main.rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

build/get_riscv64_consts.c

@@ -0,0 +1,9 @@
+#include <setjmp.h>
+
+#if defined __riscv_float_abi_double
+CEE_SCAPE_FLOAT_ABI_DOUBLE
+#endif
+
+#if defined __riscv_float_abi_soft
+CEE_SCAPE_FLOAT_ABI_SOFT
+#endif

build/main.rs

@@ -0,0 +1,62 @@
+use std::{fs::File, io::Write, path::PathBuf};
+
+fn main() {
+    if std::env::var("CARGO_FEATURE_TEST_C_INTEGRATION")
+        .ok()
+        .is_some()
+    {
+        cc::Build::new()
+            .file("src/test_c_integration.c")
+            .compile("test_c_integration");
+    } else {
+        panic!("did not see it");
+    }
+
+    if std::env::var("CARGO_FEATURE_USE_C_TO_INTERFACE_WITH_SETJMP")
+        .ok()
+        .is_some()
+    {
+        cc::Build::new()
+            .file("src/interop_via_c.c")
+            .compile("interop_via_c");
+    } else {
+    }
+
+    if cfg!(target_arch = "riscv64") {
+        generate_riscv64_consts();
+    }
+}
+
+fn generate_riscv64_consts() {
+    println!("cargo:rerun-if-changed=build/get_riscv64_consts.c");
+
+    let expanded = cc::Build::new().file("build/get_riscv64_consts.c").expand();
+    let expanded = String::from_utf8(expanded).unwrap();
+
+    let mut float_abi_double = false;
+    let mut float_abi_soft = false;
+    for line in expanded.lines() {
+        match line.trim() {
+            "CEE_SCAPE_FLOAT_ABI_DOUBLE" => float_abi_double = true,
+            "CEE_SCAPE_FLOAT_ABI_SOFT" => float_abi_soft = true,
+            _ => {}
+        }
+    }
+
+    let out_dir: PathBuf = std::env::var("OUT_DIR")
+        .expect("OUT_DIR env variable should be available")
+        .into();
+    println!("cargo::rustc-env=OUT_DIR={}", out_dir.display());
+
+    let mut riscv64_consts_file = File::create(out_dir.join("riscv64_consts.rs"))
+        .expect("unable to create riscv64_consts.rs");
+    writeln!(
+        riscv64_consts_file,
+        "const FLOAT_ABI_DOUBLE: bool = {float_abi_double};\n\
+        const FLOAT_ABI_SOFT: bool = {float_abi_soft};"
+    )
+    .expect("unable to write to riscv64_consts.rs");
+    riscv64_consts_file
+        .flush()
+        .expect("unable to write to riscv64_consts.rs");
+}

src/asm_based.rs

@@ -56,8 +56,8 @@
 
 use crate::{JmpBuf, JmpBufFields, JmpBufStruct};
 use crate::{SigJmpBuf, SigJmpBufFields, SigJmpBufStruct};
-use libc::c_int;
 use core::mem::MaybeUninit;
+use libc::c_int;
 
 #[cfg(target_arch = "x86_64")]
 macro_rules! maybesig_setjmp_asm {
@@ -118,6 +118,34 @@ macro_rules! maybesig_setjmp_asm {
     }
 }
 
+#[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
+macro_rules! maybesig_setjmp_asm {
+    ($sigsetjmp:ident, $jbuf_ptr:ident, $ifsig_savemask:ident, $closure_env_ptr:ident, $c2r:ident, $ret:ident) => {
+        core::arch::asm!(
+            // savemask, if needed, is already in a1
+            "mv a0, s3",     // move saved jbuf_ptr to sigsetjmp param position. (savemask is already in position)
+            "jalr 0({tmp})", // fills in jbuf; future longjmp calls go here.
+            "bnez a0, 1f",   // if return value non-zero, skip the callback invocation
+                             // (and if return value non-zero, we cannot assume register state has been restored!)
+            "mv a0, s3",     // move saved jmp buf into callback's arg position
+            "mv a1, s2",     // move saved closure env into callback's arg position
+            "jalr 0(s4)",    // invoke the callback
+            "1:",            // at this point, a0 carries the return value (from either outcome)
+            // we let compiler pick this register since we don't need to preseve
+            // it across the first call.
+            tmp = in(reg) $sigsetjmp,
+            in("a1") $ifsig_savemask, // savemask arg position for sigsetjmp
+            out("a0") $ret, // the output will be stored here.
+            // [s2,s3,s4] are all callee-save registers for the normal sigsetjmp return.
+            // we will have them to reference.
+            in("s2") $closure_env_ptr,
+            in("s3") $jbuf_ptr,
+            in("s4") $c2r,
+            clobber_abi("C"), // clobber abi reflects call effects, including {x1,x5,x6,x7}...
+        );
+    }
+}
+
 /// Covers the usual use case for setjmp: it invokes the callback, and the code
 /// of the callback can use longjmp to exit early from the call_with_setjmp.
 #[inline(never)] // see https://github.com/pnkfelix/cee-scape/issues/14

src/cee_based.rs

@@ -2,11 +2,18 @@ use crate::{JmpBuf, JmpBufFields};
 use crate::{SigJmpBuf, SigJmpBufFields};
 use libc::{c_int, c_void};
 
-#[link(name = "interop_via_c", kind="static")]
+#[link(name = "interop_via_c", kind = "static")]
 extern "C" {
-    fn call_closure_with_setjmp(closure_env_ptr: *mut c_void, closure_code: extern "C" fn(jbuf: *const JmpBufFields, env_ptr: *mut c_void) -> c_int) -> c_int;
+    fn call_closure_with_setjmp(
+        closure_env_ptr: *mut c_void,
+        closure_code: extern "C" fn(jbuf: *const JmpBufFields, env_ptr: *mut c_void) -> c_int,
+    ) -> c_int;
 
-    fn call_closure_with_sigsetjmp(savemask: c_int, closure_env_ptr: *mut c_void, closure_code: extern "C" fn(jbuf: *const SigJmpBufFields, env_ptr: *mut c_void) -> c_int) -> c_int;
+    fn call_closure_with_sigsetjmp(
+        savemask: c_int,
+        closure_env_ptr: *mut c_void,
+        closure_code: extern "C" fn(jbuf: *const SigJmpBufFields, env_ptr: *mut c_void) -> c_int,
+    ) -> c_int;
 }
 
 /// Covers the usual use case for setjmp: it invokes the callback, and the code
@@ -76,6 +83,10 @@ where
         // Therefore, we need to forget about our own ownership of the callback now.
         core::mem::forget(callback);
 
-        call_closure_with_sigsetjmp(savemask, closure_env_ptr as *mut c_void, call_from_c_to_rust::<F>)
+        call_closure_with_sigsetjmp(
+            savemask,
+            closure_env_ptr as *mut c_void,
+            call_from_c_to_rust::<F>,
+        )
     }
 }

src/glibc_compat.rs

@@ -1,10 +1,16 @@
 use core::marker::PhantomData;
 
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+const JMP_BUF_SIZE: usize = 8;
+
+#[cfg(target_arch = "riscv64")]
+const JMP_BUF_SIZE: usize = 14 /* pc + regs + sp */ + crate::riscv64::floating_point_registers();
+
 /// `JmpBufFields` are the accessible fields when viewed via a JmpBuf pointer.
 /// But also: You shouldn't be poking at these!
 #[repr(C)]
 pub struct JmpBufFields {
-    _buf: [u64; 8],
+    _buf: [u64; JMP_BUF_SIZE],
     _neither_send_nor_sync: PhantomData<*const u8>,
 }
 

src/lib.rs

@@ -178,10 +178,12 @@
 
 use libc::c_int;
 
-#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+#[cfg(target_os = "linux")]
 mod glibc_compat;
-#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
+#[cfg(target_os = "macos")]
 mod macos_compat;
+#[cfg(target_arch = "riscv64")]
+mod riscv64;
 #[cfg(target_os = "linux")]
 use glibc_compat as struct_defs;
 #[cfg(target_os = "macos")]
@@ -190,8 +192,6 @@ use macos_compat as struct_defs;
 pub use crate::struct_defs::{JmpBufFields, JmpBufStruct};
 pub use crate::struct_defs::{SigJmpBufFields, SigJmpBufStruct};
 
-
-
 /// This is the type of the first argument that is fed to longjmp.
 pub type JmpBuf = *const JmpBufFields;
 
@@ -399,8 +399,8 @@ mod tests {
 
 #[cfg(test)]
 mod tests_of_drop_interaction {
-    use std::sync::atomic::{AtomicUsize, Ordering};
     use super::{call_with_setjmp, call_with_sigsetjmp};
+    use std::sync::atomic::{AtomicUsize, Ordering};
     struct IncrementOnDrop(&'static str, &'static AtomicUsize);
     impl IncrementOnDrop {
         fn new(name: &'static str, state: &'static AtomicUsize) -> Self {
@@ -424,15 +424,21 @@ mod tests_of_drop_interaction {
             let _own_it = iod;
             0
         });
-        println!("callback done, drop counter: {}", STATE.load(Ordering::Relaxed));
+        println!(
+            "callback done, drop counter: {}",
+            STATE.load(Ordering::Relaxed)
+        );
         assert_eq!(STATE.load(Ordering::Relaxed), 1);
         let iod = IncrementOnDrop::new("iod", &STATE);
         call_with_setjmp(move |_env| {
             println!("at callback 2 start: {}", iod.1.load(Ordering::Relaxed));
             let _own_it = iod;
             0
         });
-        println!("callback done, drop counter: {}", STATE.load(Ordering::Relaxed));
+        println!(
+            "callback done, drop counter: {}",
+            STATE.load(Ordering::Relaxed)
+        );
         assert_eq!(STATE.load(Ordering::Relaxed), 2);
     }
 
@@ -445,15 +451,21 @@ mod tests_of_drop_interaction {
             let _own_it = iod;
             0
         });
-        println!("callback done, drop counter: {}", STATE.load(Ordering::Relaxed));
+        println!(
+            "callback done, drop counter: {}",
+            STATE.load(Ordering::Relaxed)
+        );
         assert_eq!(STATE.load(Ordering::Relaxed), 1);
         let iod = IncrementOnDrop::new("iod", &STATE);
         call_with_sigsetjmp(true, move |_env| {
             println!("at callback 4 start: {}", iod.1.load(Ordering::Relaxed));
             let _own_it = iod;
             0
         });
-        println!("callback done, drop counter: {}", STATE.load(Ordering::Relaxed));
+        println!(
+            "callback done, drop counter: {}",
+            STATE.load(Ordering::Relaxed)
+        );
         assert_eq!(STATE.load(Ordering::Relaxed), 2);
     }
 
@@ -475,7 +487,10 @@ mod tests_of_drop_interaction {
             let _own_it = iod;
             unsafe { longjmp(env1, 4) }
         });
-        println!("callback done, drop counter: {}", STATE.load(Ordering::Relaxed));
+        println!(
+            "callback done, drop counter: {}",
+            STATE.load(Ordering::Relaxed)
+        );
         assert_eq!(STATE.load(Ordering::Relaxed), 0);
     }
 }

src/riscv64.rs

@@ -0,0 +1,11 @@
+include!(concat!(env!("OUT_DIR"), "/riscv64_consts.rs"));
+
+pub const fn floating_point_registers() -> usize {
+    if FLOAT_ABI_DOUBLE {
+        12
+    } else if !FLOAT_ABI_SOFT {
+        panic!("unsupported number of floating point registers");
+    } else {
+        0
+    }
+}