Allow compiling debug-builtins in no_std environment to enable gdb jit

- Make jit-debug crate #![no_std] when `std` feature is not enabled
- Make gdb_jit_int module build in no_std environment
- Use std when perf_jitdebug is enabled because the perf_jitdebug module
  does not run in no_std environment
- Change debug-builtins feature to only enable gdb_jit_int
- The perf_jitdebug feature is enabled in profiling mode only

Signed-off-by: Doru Blânzeanu <[email protected]>

Author: dblnz

crates/jit-debug/Cargo.toml

@@ -26,5 +26,6 @@ wasmtime-versioned-export-macros = { workspace = true }
 rustix = { workspace = true, features = ["mm", "time"], optional = true }
 
 [features]
+std = []
 gdb_jit_int = []
-perf_jitdump = ["rustix", "object"]
+perf_jitdump = ["rustix", "object", "std"]

crates/jit-debug/src/gdb_jit_int.rs

@@ -2,9 +2,12 @@
 //! the __jit_debug_register_code() and __jit_debug_descriptor to register
 //! or unregister generated object images with debuggers.
 
-use std::pin::Pin;
-use std::ptr;
-use std::sync::Mutex;
+#[cfg(not(feature = "std"))]
+use alloc::{boxed::Box, vec::Vec};
+#[cfg(not(feature = "std"))]
+use core::{pin::Pin, ptr};
+#[cfg(feature = "std")]
+use std::{boxed::Box, pin::Pin, ptr, vec::Vec};
 use wasmtime_versioned_export_macros::versioned_link;
 
 #[repr(C)]
@@ -33,13 +36,63 @@ unsafe extern "C" {
     fn __jit_debug_register_code();
 }
 
-/// The process controls access to the __jit_debug_descriptor by itself --
-/// the GDB/LLDB accesses this structure and its data at the process startup
-/// and when paused in __jit_debug_register_code.
-///
-/// The GDB_REGISTRATION lock is needed for GdbJitImageRegistration to protect
-/// access to the __jit_debug_descriptor within this process.
-static GDB_REGISTRATION: Mutex<()> = Mutex::new(());
+#[cfg(feature = "std")]
+mod gdb_registration {
+    use std::sync::Mutex;
+
+    /// The process controls access to the __jit_debug_descriptor by itself --
+    /// the GDB/LLDB accesses this structure and its data at the process startup
+    /// and when paused in __jit_debug_register_code.
+    ///
+    /// The GDB_REGISTRATION lock is needed for GdbJitImageRegistration to protect
+    /// access to the __jit_debug_descriptor within this process.
+    pub static GDB_REGISTRATION: Mutex<()> = Mutex::new(());
+
+    /// The lock guard for the GDB registration lock.
+    /// The field is not used directly, but it is needed to ensure that the lock
+    /// is held until the `LockGuard` is dropped.
+    #[allow(
+        dead_code,
+        reason = "field used to hold the lock until the end of the scope"
+    )]
+    pub struct LockGuard<'a>(std::sync::MutexGuard<'a, ()>);
+
+    pub fn lock() -> LockGuard<'static> {
+        LockGuard(GDB_REGISTRATION.lock().unwrap())
+    }
+}
+
+#[cfg(not(feature = "std"))]
+mod gdb_registration {
+    use core::sync::atomic::{AtomicBool, Ordering};
+
+    /// In no_std mode, we use an atomic boolean to control access to the
+    /// __jit_debug_descriptor. This is a simple lock mechanism.
+    pub static GDB_REGISTRATION: AtomicBool = AtomicBool::new(false);
+
+    /// The lock guard for the GDB registration lock.
+    pub struct LockGuard;
+
+    /// When the `LockGuard` is dropped, it releases the lock by setting
+    /// `GDB_REGISTRATION` to false.
+    impl Drop for LockGuard {
+        fn drop(&mut self) {
+            GDB_REGISTRATION.store(false, Ordering::Release);
+        }
+    }
+
+    /// Locks the GDB registration lock. If the lock is already held, it panics
+    pub fn lock() -> LockGuard {
+        // Try to acquire the lock. If already held, panic as per PR feedback.
+        if GDB_REGISTRATION
+            .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+            .is_err()
+        {
+            panic!("GDB JIT registration lock contention detected in no_std mode");
+        }
+        LockGuard
+    }
+}
 
 /// Registration for JIT image
 pub struct GdbJitImageRegistration {
@@ -87,7 +140,7 @@ unsafe impl Sync for GdbJitImageRegistration {}
 
 unsafe fn register_gdb_jit_image(entry: *mut JITCodeEntry) {
     unsafe {
-        let _lock = GDB_REGISTRATION.lock().unwrap();
+        let _lock = gdb_registration::lock();
         let desc = &mut *wasmtime_jit_debug_descriptor();
 
         // Add it to the linked list in the JIT descriptor.
@@ -109,7 +162,7 @@ unsafe fn register_gdb_jit_image(entry: *mut JITCodeEntry) {
 
 unsafe fn unregister_gdb_jit_image(entry: *mut JITCodeEntry) {
     unsafe {
-        let _lock = GDB_REGISTRATION.lock().unwrap();
+        let _lock = gdb_registration::lock();
         let desc = &mut *wasmtime_jit_debug_descriptor();
 
         // Remove the code entry corresponding to the code from the linked list.

crates/jit-debug/src/lib.rs

@@ -4,6 +4,12 @@
 //! > you're interested in using this feel free to file an issue on the
 //! > Wasmtime repository to start a discussion about doing so, but otherwise
 //! > be aware that your usage of this crate is not supported.
+#![no_std]
+
+#[cfg(all(feature = "gdb_jit_int", not(feature = "std")))]
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
 
 #[cfg(feature = "gdb_jit_int")]
 pub mod gdb_jit_int;

crates/jit-debug/src/perf_jitdump.rs

@@ -16,6 +16,8 @@ use std::io;
 use std::io::Write;
 use std::path::Path;
 use std::ptr;
+use std::string::String;
+use std::vec::Vec;
 use std::{mem, process};
 
 /// Defines jitdump record types

crates/wasmtime/Cargo.toml

@@ -19,7 +19,7 @@ all-features = true
 [dependencies]
 wasmtime-asm-macros = { workspace = true, optional = true }
 wasmtime-environ = { workspace = true }
-wasmtime-jit-debug = { workspace = true, features = ["gdb_jit_int", "perf_jitdump"], optional = true }
+wasmtime-jit-debug = { workspace = true, features = [], optional = true }
 wasmtime-jit-icache-coherence = { workspace = true, optional = true }
 wasmtime-cache = { workspace = true, optional = true }
 wasmtime-fiber = { workspace = true, optional = true }
@@ -139,6 +139,8 @@ default = [
   'addr2line',
   'coredump',
   'debug-builtins',
+  'wasmtime-jit-debug/perf_jitdump',
+  'wasmtime-jit-debug/std',
   'runtime',
   'component-model',
   'threads',
@@ -175,12 +177,14 @@ incremental-cache = ["wasmtime-cranelift?/incremental-cache", "std"]
 # Enables support for profiling guest modules.
 profiling = [
   "dep:fxprof-processed-profile",
-  "dep:wasmtime-jit-debug",
   "dep:ittapi",
   "dep:rustix",
   "rustix/thread",
   "dep:serde_json",
   "std",
+  "wasmtime-jit-debug/gdb_jit_int",
+  "wasmtime-jit-debug/perf_jitdump",
+  "wasmtime-jit-debug/std",
 ]
 
 # Enables parallel compilation of WebAssembly code.
@@ -243,7 +247,9 @@ coredump = ["dep:wasm-encoder", "runtime", "std"]
 
 # Export some symbols from the final binary to assist in debugging
 # Cranelift-generated code with native debuggers like GDB and LLDB.
-debug-builtins = ["dep:wasmtime-jit-debug", "std"]
+debug-builtins = [
+  "wasmtime-jit-debug/gdb_jit_int",
+]
 
 # Enable support for executing compiled Wasm modules.
 runtime = [

crates/wasmtime/build.rs

@@ -27,10 +27,10 @@ fn main() {
     custom_cfg("has_virtual_memory", has_virtual_memory);
     custom_cfg("has_host_compiler_backend", has_host_compiler_backend);
 
-    // If this OS isn't supported or if Cranelift doesn't support the host then
-    // there's no need to build these helpers.
+    // If this OS isn't supported and no debug-builtins or if Cranelift doesn't support
+    // the host or there's no need to build these helpers.
     #[cfg(feature = "runtime")]
-    if supported_os && has_host_compiler_backend {
+    if has_host_compiler_backend && (supported_os || cfg!(feature = "debug-builtins")) {
         build_c_helpers();
     }
 

crates/wasmtime/src/engine.rs

@@ -109,7 +109,7 @@ impl Engine {
             #[cfg(has_native_signals)]
             crate::runtime::vm::init_traps(config.macos_use_mach_ports);
             if !cfg!(miri) {
-                #[cfg(all(has_host_compiler_backend, feature = "debug-builtins"))]
+                #[cfg(feature = "debug-builtins")]
                 crate::runtime::vm::debug_builtins::init();
             }
         }

crates/wasmtime/src/runtime/vm/debug_builtins.rs

@@ -14,7 +14,7 @@ static mut VMCTX_AND_MEMORY: (NonNull<VMContext>, usize) = (NonNull::dangling(),
 #[versioned_export]
 pub unsafe extern "C" fn resolve_vmctx_memory_ptr(p: *const u32) -> *const u8 {
     unsafe {
-        let ptr = std::ptr::read(p);
+        let ptr = core::ptr::read(p);
         assert!(
             VMCTX_AND_MEMORY.0 != NonNull::dangling(),
             "must call `__vmctx->set()` before resolving Wasm pointers"