[SOL] sbf: implement static-syscalls target feature

Expose static-syscalls as a rust target-feature so it can be used with
conditional compilation and implement sol_log_(), abort() and sol_alloc_free_()
as static syscalls.

This bumps src/llvm-project to pull the corresponding LLVM change.

Author: alessandrod

compiler/rustc_target/src/target_features.rs

@@ -327,6 +327,9 @@ const WASM_ALLOWED_FEATURES: &[(&str, Stability)] = &[
 
 const BPF_ALLOWED_FEATURES: &[(&str, Stability)] = &[("alu32", Unstable(sym::bpf_target_feature))];
 
+const SBF_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] =
+    &[("alu32", Unstable(sym::sbf_target_feature)), ("static-syscalls", Unstable(sym::sbf_target_feature))];
+
 const CSKY_ALLOWED_FEATURES: &[(&str, Stability)] = &[
     // tidy-alphabetical-start
     ("10e60", Unstable(sym::csky_target_feature)),

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

@@ -32,6 +32,15 @@ unsafe impl GlobalAlloc for System {
     //     // 0 as *mut u8
     // }
 }
+
+#[cfg(not(target_feature = "static-syscalls"))]
 extern "C" {
     fn sol_alloc_free_(size: u64, ptr: u64) -> *mut u8;
 }
+
+#[cfg(target_feature = "static-syscalls")]
+fn sol_alloc_free_(size: u64, ptr: u64) -> *mut u8 {
+    let syscall: extern "C" fn(u64, u64) -> *mut u8 =
+        unsafe { core::mem::transmute(2213547663u64) }; // murmur32 hash of "sol_alloc_free_"
+    syscall(size, ptr)
+}

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

@@ -29,9 +29,9 @@ pub mod os;
 pub mod path;
 pub mod pipe;
 pub mod process;
+pub mod stdio;
 pub mod thread;
 pub mod time;
-pub mod stdio;
 
 #[path = "../unix/os_str.rs"]
 pub mod os_str;
@@ -42,31 +42,50 @@ pub mod rwlock;
 pub mod thread_local_dtor;
 pub mod thread_local_key;
 
+#[cfg(not(target_feature = "static-syscalls"))]
 extern "C" {
     fn abort() -> !;
     #[allow(improper_ctypes)]
     fn custom_panic(info: &core::panic::PanicInfo<'_>);
     fn sol_log_(message: *const u8, length: u64);
 }
 
+#[cfg(target_feature = "static-syscalls")]
+unsafe extern "C" fn abort() -> ! {
+    let syscall: extern "C" fn() -> ! = core::mem::transmute(3069975057u64); // murmur32 hash of "abort"
+    syscall()
+}
+
+#[cfg(target_feature = "static-syscalls")]
+unsafe extern "C" fn sol_log_(message: *const u8, length: u64) {
+    let syscall: extern "C" fn(*const u8, u64) = core::mem::transmute(544561597u64); // murmur32 hash of "sol_log_"
+    syscall(message, length)
+}
+
 pub fn sol_log(message: &[u8]) {
     unsafe {
         sol_log_(message.as_ptr(), message.len() as u64);
     }
 }
 
 pub fn panic(info: &core::panic::PanicInfo<'_>) -> ! {
-    unsafe { custom_panic(info); }
-    unsafe { abort(); }
+    unsafe {
+        #[cfg(not(target_feature = "static-syscalls"))]
+        custom_panic(info);
+
+        #[cfg(target_feature = "static-syscalls")]
+        sol_log(info.to_string().as_bytes());
+
+        abort();
+    }
 }
 
 pub fn unsupported<T>() -> crate::io::Result<T> {
     Err(unsupported_err())
 }
 
 pub fn unsupported_err() -> crate::io::Error {
-    crate::io::Error::new(crate::io::ErrorKind::Other,
-                   "operation not supported on SBF yet")
+    crate::io::Error::new(crate::io::ErrorKind::Other, "operation not supported on SBF yet")
 }
 
 pub fn decode_error_kind(_code: i32) -> crate::io::ErrorKind {
@@ -84,7 +103,7 @@ pub unsafe fn strlen(mut s: *const c_char) -> usize {
         n += 1;
         s = s.offset(1);
     }
-    return n
+    return n;
 }
 
 pub fn abort_internal() -> ! {