Actually unmap the code after it's done being used

lib/llvm-backend/src/backend.rs

@@ -1,5 +1,6 @@
 use crate::intrinsics::Intrinsics;
 use inkwell::{
+    memory_buffer::MemoryBuffer,
     module::Module,
     targets::{CodeModel, FileType, InitializationConfig, RelocMode, Target, TargetMachine},
     OptimizationLevel,
@@ -25,6 +26,7 @@ struct LLVMModule {
     _private: [u8; 0],
 }
 
+#[allow(non_camel_case_types, dead_code)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(C)]
 enum MemProtect {
@@ -34,6 +36,7 @@ enum MemProtect {
     READ_EXECUTE,
 }
 
+#[allow(non_camel_case_types, dead_code)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(C)]
 enum LLVMResult {
@@ -54,12 +57,13 @@ struct Callbacks {
 }
 
 extern "C" {
-    fn object_load(
+    fn module_load(
         mem_ptr: *const u8,
         mem_size: usize,
-        callbacks: *const Callbacks,
+        callbacks: Callbacks,
         module_out: &mut *mut LLVMModule,
     ) -> LLVMResult;
+    fn module_delete(module: *mut LLVMModule);
     fn get_func_symbol(module: *mut LLVMModule, name: *const c_char) -> *const vm::Func;
 }
 
@@ -74,11 +78,11 @@ fn get_callbacks() -> Callbacks {
         ptr_out: &mut *mut u8,
         size_out: &mut usize,
     ) -> LLVMResult {
-        println!("size: {}", size);
+        let size = round_up_to_page_size(size);
         let ptr = unsafe {
             mmap(
                 ptr::null_mut(),
-                round_up_to_page_size(size),
+                size,
                 match protect {
                     MemProtect::NONE => PROT_NONE,
                     MemProtect::READ => PROT_READ,
@@ -99,7 +103,6 @@ fn get_callbacks() -> Callbacks {
     }
 
     extern "C" fn protect_memory(ptr: *mut u8, size: usize, protect: MemProtect) -> LLVMResult {
-        println!("protect memory: {:p}:{} -> {:?}", ptr, size, protect);
         let res = unsafe {
             mprotect(
                 ptr as _,
@@ -121,7 +124,6 @@ fn get_callbacks() -> Callbacks {
     }
 
     extern "C" fn dealloc_memory(ptr: *mut u8, size: usize) -> LLVMResult {
-        println!("dealloc_memory");
         let res = unsafe { munmap(ptr as _, round_up_to_page_size(size)) };
 
         if res == 0 {
@@ -148,6 +150,8 @@ unsafe impl Sync for LLVMBackend {}
 
 pub struct LLVMBackend {
     module: *mut LLVMModule,
+    #[allow(dead_code)]
+    memory_buffer: MemoryBuffer,
 }
 
 impl LLVMBackend {
@@ -182,10 +186,10 @@ impl LLVMBackend {
         let mut module: *mut LLVMModule = ptr::null_mut();
 
         let res = unsafe {
-            object_load(
+            module_load(
                 mem_buf_slice.as_ptr(),
                 mem_buf_slice.len(),
-                &callbacks,
+                callbacks,
                 &mut module,
             )
         };
@@ -194,7 +198,10 @@ impl LLVMBackend {
             panic!("failed to load object")
         }
 
-        Self { module }
+        Self {
+            module,
+            memory_buffer,
+        }
     }
 
     pub fn get_func(
@@ -209,20 +216,19 @@ impl LLVMBackend {
             format!("fn{}", index)
         };
 
-        println!("name: {}", name);
-
         let c_str = CString::new(name).ok()?;
-
         let ptr = unsafe { get_func_symbol(self.module, c_str.as_ptr()) };
 
-        unsafe {
-            disass_ptr(ptr as _, 0x20, 4);
-        }
-
         NonNull::new(ptr as _)
     }
 }
 
+impl Drop for LLVMBackend {
+    fn drop(&mut self) {
+        unsafe { module_delete(self.module) }
+    }
+}
+
 impl FuncResolver for LLVMBackend {
     fn get(
         &self,

lib/llvm-backend/src/code.rs

@@ -1,7 +1,7 @@
 use inkwell::{
     builder::Builder,
     context::Context,
-    module::Module,
+    module::{Linkage, Module},
     passes::PassManager,
     types::{BasicType, BasicTypeEnum, FunctionType, PointerType},
     values::{BasicValue, FunctionValue, PhiValue, PointerValue},
@@ -10,7 +10,7 @@ use inkwell::{
 use smallvec::SmallVec;
 use wasmer_runtime_core::{
     memory::MemoryType,
-    module::ModuleInfo,
+    module::{ExportIndex, ModuleInfo},
     structures::{Map, SliceMap, TypedIndex},
     types::{
         FuncIndex, FuncSig, GlobalIndex, LocalFuncIndex, LocalOrImport, MemoryIndex, SigIndex,
@@ -80,7 +80,7 @@ pub fn parse_function_bodies(
             module.add_function(
                 &format!("fn{}", func_index.index()),
                 signatures[sig_index],
-                None,
+                Some(Linkage::External),
             )
         })
         .collect();
@@ -106,6 +106,7 @@ pub fn parse_function_bodies(
     }
 
     let pass_manager = PassManager::create_for_module();
+    pass_manager.add_function_inlining_pass();
     pass_manager.add_promote_memory_to_register_pass();
     pass_manager.add_cfg_simplification_pass();
     pass_manager.add_instruction_combining_pass();
@@ -113,13 +114,11 @@ pub fn parse_function_bodies(
     // pass_manager.add_merged_load_store_motion_pass();
     // pass_manager.add_sccp_pass();
     pass_manager.add_gvn_pass();
-    pass_manager.add_new_gvn_pass();
+    // pass_manager.add_new_gvn_pass();
     pass_manager.add_aggressive_dce_pass();
-    pass_manager.add_verifier_pass();
+    // pass_manager.add_verifier_pass();
     pass_manager.run_on_module(&module);
 
-    println!("{}", module.print_to_string().to_string());
-
     Ok((module, intrinsics))
 }
 
@@ -1791,7 +1790,6 @@ fn parse_function(
                 state.push1(result.try_as_basic_value().left().unwrap());
             }
             op @ _ => {
-                println!("{}", module.print_to_string().to_string());
                 unimplemented!("{:?}", op);
             }
         }