Fix UEFI compilation for cranelift-jit

Author: RossComputerGuy

Cargo.lock

@@ -21,7 +21,7 @@ cranelift-entity = { workspace = true }
 cranelift-control = { workspace = true }
 wasmtime-unwinder = { workspace = true, optional = true, features = ["cranelift"] }
 anyhow = { workspace = true }
-region = "3.0.2"
+region = { git = "https://github.com/RossComputerGuy/region-rs", branch = "fix/uefi" }
 libc = { workspace = true }
 target-lexicon = { workspace = true }
 memmap2 = { version = "0.2.1", optional = true }

cranelift/jit/Cargo.toml

@@ -88,7 +88,13 @@ impl JITBuilder {
         libcall_names: Box<dyn Fn(ir::LibCall) -> String + Send + Sync>,
     ) -> Self {
         let symbols = HashMap::new();
+
+        #[cfg(not(target_os = "uefi"))]
         let lookup_symbols = vec![Box::new(lookup_with_dlsym) as Box<_>];
+
+        #[cfg(target_os = "uefi")]
+        let lookup_symbols = vec![];
+
         Self {
             isa,
             symbols,
@@ -656,7 +662,7 @@ impl Module for JITModule {
     }
 }
 
-#[cfg(not(windows))]
+#[cfg(all(not(windows), not(target_os = "uefi")))]
 fn lookup_with_dlsym(name: &str) -> Option<*const u8> {
     let c_str = CString::new(name).unwrap();
     let c_str_ptr = c_str.as_ptr();

cranelift/jit/src/backend.rs

@@ -11,9 +11,10 @@ mod compiled_blob;
 mod memory;
 
 pub use crate::backend::{JITBuilder, JITModule};
-pub use crate::memory::{
-    ArenaMemoryProvider, BranchProtection, JITMemoryProvider, SystemMemoryProvider,
-};
+pub use crate::memory::{BranchProtection, JITMemoryProvider, SystemMemoryProvider};
+
+#[cfg(not(target_os = "uefi"))]
+pub use crate::memory::ArenaMemoryProvider;
 
 /// Version number of this crate.
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");

cranelift/jit/src/lib.rs

@@ -39,6 +39,7 @@ impl Segment {
     }
 
     fn set_rw(&mut self) {
+        #[cfg(not(target_os = "uefi"))]
         unsafe {
             region::protect(self.ptr, self.len, region::Protection::READ_WRITE)
                 .expect("unable to change memory protection for jit memory segment");
@@ -56,6 +57,7 @@ impl Segment {
             super::set_readable_and_executable(self.ptr, self.len, branch_protection)
                 .expect("unable to set memory protection for jit memory segment");
         } else {
+            #[cfg(not(target_os = "uefi"))]
             unsafe {
                 region::protect(self.ptr, self.len, self.target_prot)
                     .expect("unable to change memory protection for jit memory segment");
@@ -93,6 +95,7 @@ impl Segment {
 /// Note: Memory will be leaked by default unless
 /// [`JITMemoryProvider::free_memory`] is called to ensure function pointers
 /// remain valid for the remainder of the program's life.
+#[cfg(not(target_os = "uefi"))]
 pub struct ArenaMemoryProvider {
     alloc: ManuallyDrop<Option<region::Allocation>>,
     ptr: *mut u8,
@@ -101,8 +104,10 @@ pub struct ArenaMemoryProvider {
     segments: Vec<Segment>,
 }
 
+#[cfg(not(target_os = "uefi"))]
 unsafe impl Send for ArenaMemoryProvider {}
 
+#[cfg(not(target_os = "uefi"))]
 impl ArenaMemoryProvider {
     /// Create a new memory region with the given size.
     pub fn new_with_size(reserve_size: usize) -> Result<Self, region::Error> {
@@ -206,6 +211,7 @@ impl ArenaMemoryProvider {
     }
 }
 
+#[cfg(not(target_os = "uefi"))]
 impl Drop for ArenaMemoryProvider {
     fn drop(&mut self) {
         if self.ptr == ptr::null_mut() {
@@ -220,6 +226,7 @@ impl Drop for ArenaMemoryProvider {
     }
 }
 
+#[cfg(not(target_os = "uefi"))]
 impl JITMemoryProvider for ArenaMemoryProvider {
     fn allocate(&mut self, size: usize, align: u64, kind: JITMemoryKind) -> io::Result<*mut u8> {
         self.allocate_inner(

cranelift/jit/src/memory/arena.rs

@@ -4,6 +4,7 @@ use std::io;
 mod arena;
 mod system;
 
+#[cfg(not(target_os = "uefi"))]
 pub use arena::ArenaMemoryProvider;
 pub use system::SystemMemoryProvider;
 
@@ -56,6 +57,7 @@ pub(crate) fn set_readable_and_executable(
             .expect("Failed cache clear")
     };
 
+    #[cfg(not(target_os = "uefi"))]
     unsafe {
         region::protect(ptr, len, region::Protection::READ_EXECUTE).map_err(|e| {
             ModuleError::Backend(

cranelift/jit/src/memory/mod.rs

@@ -1,6 +1,10 @@
 use cranelift_module::{ModuleError, ModuleResult};
 
-#[cfg(all(not(target_os = "windows"), feature = "selinux-fix"))]
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "uefi"),
+    feature = "selinux-fix"
+))]
 use memmap2::MmapMut;
 
 #[cfg(not(any(feature = "selinux-fix", windows)))]
@@ -94,7 +98,11 @@ impl PtrLen {
 }
 
 // `MMapMut` from `cfg(feature = "selinux-fix")` already deallocates properly.
-#[cfg(all(not(target_os = "windows"), not(feature = "selinux-fix")))]
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "uefi"),
+    not(feature = "selinux-fix")
+))]
 impl Drop for PtrLen {
     fn drop(&mut self) {
         if !self.ptr.is_null() {
@@ -182,6 +190,7 @@ impl Memory {
     }
 
     /// Set all memory allocated in this `Memory` up to now as readonly.
+    #[cfg(not(target_os = "uefi"))]
     pub(crate) fn set_readonly(&mut self) -> ModuleResult<()> {
         self.finish_current();
 
@@ -258,6 +267,7 @@ impl JITMemoryProvider for SystemMemoryProvider {
     }
 
     fn finalize(&mut self, branch_protection: BranchProtection) -> ModuleResult<()> {
+        #[cfg(not(target_os = "uefi"))]
         self.readonly.set_readonly()?;
         self.code.set_readable_and_executable(branch_protection)
     }