Experimental Native Compilation Refactor

lib/api/Cargo.toml

@@ -21,7 +21,7 @@ wasmer-engine = { path = "../engine", version = "1.0.2" }
 wasmer-engine-jit = { path = "../engine-jit", version = "1.0.2", optional = true }
 wasmer-engine-native = { path = "../engine-native", version = "1.0.2", optional = true }
 wasmer-types = { path = "../types", version = "1.0.2" }
-indexmap = { version = "1.4", features = ["serde-1"] }
+indexmap = { version = "1.6", features = ["serde-1"] }
 cfg-if = "0.1"
 wat = { version = "1.0", optional = true }
 thiserror = "1.0"

lib/cli/src/commands/create_exe.rs

@@ -71,9 +71,9 @@ impl CreateExe {
         env::set_current_dir(&working_dir)?;
 
         #[cfg(not(windows))]
-        let wasm_object_path = PathBuf::from("wasm.o");
+        let wasm_object_path = PathBuf::from("wasm.a");
         #[cfg(windows)]
-        let wasm_object_path = PathBuf::from("wasm.obj");
+        let wasm_object_path = PathBuf::from("wasm.a");
 
         let wasm_module_path = starting_cd.join(&self.path);
 
@@ -284,23 +284,42 @@ impl LinkCode {
         } else {
             command
         };
+
         // Add libraries required per platform.
         // We need userenv, sockets (Ws2_32), advapi32 for some system calls and bcrypt for random numbers.
         #[cfg(windows)]
         let command = command
+            .arg("-Wl,--whole-archive")
             .arg("-luserenv")
             .arg("-lWs2_32")
             .arg("-ladvapi32")
             .arg("-lbcrypt");
         // On unix we need dlopen-related symbols, libmath for a few things, and pthreads.
+
+        cfg_if::cfg_if! {
+            if #[cfg(target_os = "macos")] {
+                let command = command.arg("-Wl,-all_load");
+            }
+            else if #[cfg(unix)] {
+                let command = command.arg("-Wl,--whole-archive");
+            }
+            else if #[cfg(windows)] {
+                let command = command.arg("-Wl,--whole-archive");
+            }
+        }
+
         #[cfg(not(windows))]
         let command = command.arg("-ldl").arg("-lm").arg("-pthread");
         let link_aganist_extra_libs = self
             .additional_libraries
             .iter()
             .map(|lib| format!("-l{}", lib));
-        let command = command.args(link_aganist_extra_libs);
-        let output = command.arg("-o").arg(&self.output_path).output()?;
+        let command = command
+            .args(link_aganist_extra_libs)
+            .arg("-o")
+            .arg(&self.output_path);
+        println!("COMMAND: {:?}", command);
+        let output = command.output()?;
 
         if !output.status.success() {
             bail!(

lib/compiler-llvm/src/compiler.rs

@@ -1,20 +1,17 @@
 use crate::config::LLVM;
+use crate::object_file::get_frame_info;
 use crate::trampoline::FuncTrampoline;
 use crate::translator::FuncTranslator;
-use crate::CompiledKind;
-use inkwell::context::Context;
-use inkwell::memory_buffer::MemoryBuffer;
-use inkwell::module::{Linkage, Module};
 use inkwell::targets::FileType;
-use inkwell::DLLStorageClass;
 use loupe::MemoryUsage;
 use rayon::iter::ParallelBridge;
-use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
+use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
 use std::sync::Arc;
 use wasmer_compiler::{
-    Compilation, CompileError, CompileModuleInfo, Compiler, CustomSection, CustomSectionProtection,
-    Dwarf, FunctionBodyData, ModuleMiddleware, ModuleTranslationState, RelocationTarget,
-    SectionBody, SectionIndex, Symbol, SymbolRegistry, Target,
+    Compilation, CompileError, CompileModuleInfo, CompiledFunctionFrameInfo, Compiler,
+    CustomSection, CustomSectionProtection, Dwarf, ExperimentalNativeCompilation, FunctionBodyData,
+    ModuleMiddleware, ModuleTranslationState, RelocationTarget, SectionBody, SectionIndex, Symbol,
+    SymbolRegistry, Target,
 };
 use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::{FunctionIndex, LocalFunctionIndex, SignatureIndex};
@@ -80,110 +77,94 @@ impl LLVMCompiler {
         module_translation: &ModuleTranslationState,
         function_body_inputs: &PrimaryMap<LocalFunctionIndex, FunctionBodyData<'data>>,
         symbol_registry: &dyn SymbolRegistry,
-        wasmer_metadata: &[u8],
-    ) -> Result<Vec<u8>, CompileError> {
-        let target_machine = self.config().target_machine(target);
-        let ctx = Context::create();
-
+    ) -> Result<ExperimentalNativeCompilation, CompileError> {
         // TODO: https:/github.com/rayon-rs/rayon/issues/822
 
-        let merged_bitcode = function_body_inputs.into_iter().par_bridge().map_init(
-            || {
-                let target_machine = self.config().target_machine(target);
-                FuncTranslator::new(target_machine)
-            },
-            |func_translator, (i, input)| {
-                let module = func_translator.translate_to_module(
-                    &compile_info.module,
-                    module_translation,
-                    &i,
-                    input,
-                    self.config(),
-                    &compile_info.memory_styles,
-                    &compile_info.table_styles,
-                    symbol_registry,
-                )?;
-                Ok(module.write_bitcode_to_memory().as_slice().to_vec())
-            },
-        );
+        let function_bodies_and_frame_infos = function_body_inputs
+            .into_iter()
+            .par_bridge()
+            .map_init(
+                || {
+                    let target_machine = self.config().target_machine(target);
+                    FuncTranslator::new(target_machine)
+                },
+                |func_translator, (i, input)| {
+                    let module = func_translator.translate_to_module(
+                        &compile_info.module,
+                        module_translation,
+                        &i,
+                        input,
+                        self.config(),
+                        &compile_info.memory_styles,
+                        &compile_info.table_styles,
+                        symbol_registry,
+                    )?;
+                    let memory_buffer = func_translator
+                        .target_machine
+                        .write_to_memory_buffer(&module, FileType::Object)
+                        .unwrap();
+                    let memory_buffer = memory_buffer.as_slice().to_vec();
+                    let frame_info = get_frame_info(&memory_buffer)?;
+                    Ok((memory_buffer, frame_info))
+                },
+            )
+            .collect::<Result<Vec<_>, CompileError>>()?;
+
+        let (function_bodies, frame_infos): (Vec<Vec<u8>>, Vec<CompiledFunctionFrameInfo>) =
+            function_bodies_and_frame_infos.into_iter().unzip();
+        let function_bodies = function_bodies.into_iter().par_bridge().map(|b| Ok(b));
 
-        let trampolines_bitcode = compile_info.module.signatures.iter().par_bridge().map_init(
+        let frame_infos = frame_infos
+            .into_iter()
+            .collect::<PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo>>();
+        let trampolines = compile_info.module.signatures.iter().par_bridge().map_init(
             || {
                 let target_machine = self.config().target_machine(target);
                 FuncTrampoline::new(target_machine)
             },
             |func_trampoline, (i, sig)| {
-                let name = symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(i));
+                let symbol = Symbol::FunctionCallTrampoline(i);
+                let name = symbol_registry.symbol_to_name(symbol);
                 let module = func_trampoline.trampoline_to_module(sig, self.config(), &name)?;
-                Ok(module.write_bitcode_to_memory().as_slice().to_vec())
+                let memory_buffer = func_trampoline
+                    .target_machine
+                    .write_to_memory_buffer(&module, FileType::Object)
+                    .unwrap();
+                Ok(memory_buffer.as_slice().to_vec())
             },
         );
 
-        let dynamic_trampolines_bitcode =
-            compile_info.module.functions.iter().par_bridge().map_init(
-                || {
-                    let target_machine = self.config().target_machine(target);
-                    (
-                        FuncTrampoline::new(target_machine),
-                        &compile_info.module.signatures,
-                    )
-                },
-                |(func_trampoline, signatures), (i, sig)| {
-                    let sig = &signatures[*sig];
-                    let name = symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(i));
-                    let module =
-                        func_trampoline.dynamic_trampoline_to_module(sig, self.config(), &name)?;
-                    Ok(module.write_bitcode_to_memory().as_slice().to_vec())
-                },
-            );
-
-        let merged_bitcode = merged_bitcode
-            .chain(trampolines_bitcode)
-            .chain(dynamic_trampolines_bitcode)
-            .collect::<Result<Vec<_>, CompileError>>()?
-            .into_par_iter()
-            .reduce_with(|bc1, bc2| {
-                let ctx = Context::create();
-                let membuf = MemoryBuffer::create_from_memory_range(&bc1, "");
-                let m1 = Module::parse_bitcode_from_buffer(&membuf, &ctx).unwrap();
-                let membuf = MemoryBuffer::create_from_memory_range(&bc2, "");
-                let m2 = Module::parse_bitcode_from_buffer(&membuf, &ctx).unwrap();
-                m1.link_in_module(m2).unwrap();
-                m1.write_bitcode_to_memory().as_slice().to_vec()
-            });
-        let merged_module = if let Some(bc) = merged_bitcode {
-            let membuf = MemoryBuffer::create_from_memory_range(&bc, "");
-            Module::parse_bitcode_from_buffer(&membuf, &ctx).unwrap()
-        } else {
-            ctx.create_module("")
-        };
-
-        let i8_ty = ctx.i8_type();
-        let metadata_init = i8_ty.const_array(
-            wasmer_metadata
-                .iter()
-                .map(|v| i8_ty.const_int(*v as u64, false))
-                .collect::<Vec<_>>()
-                .as_slice(),
+        let dynamic_trampolines = compile_info.module.functions.iter().par_bridge().map_init(
+            || {
+                let target_machine = self.config().target_machine(target);
+                (
+                    FuncTrampoline::new(target_machine),
+                    &compile_info.module.signatures,
+                )
+            },
+            |(func_trampoline, signatures), (i, sig)| {
+                let sig = &signatures[*sig];
+                let symbol = Symbol::DynamicFunctionTrampoline(i);
+                let name = symbol_registry.symbol_to_name(symbol);
+                let module =
+                    func_trampoline.dynamic_trampoline_to_module(sig, self.config(), &name)?;
+                let memory_buffer = func_trampoline
+                    .target_machine
+                    .write_to_memory_buffer(&module, FileType::Object)
+                    .unwrap();
+                Ok(memory_buffer.as_slice().to_vec())
+            },
         );
-        let metadata_gv =
-            merged_module.add_global(metadata_init.get_type(), None, "WASMER_METADATA");
-        metadata_gv.set_initializer(&metadata_init);
-        metadata_gv.set_linkage(Linkage::DLLExport);
-        metadata_gv.set_dll_storage_class(DLLStorageClass::Export);
-
-        if self.config().enable_verifier {
-            merged_module.verify().unwrap();
-        }
 
-        let memory_buffer = target_machine
-            .write_to_memory_buffer(&merged_module, FileType::Object)
-            .unwrap();
-        if let Some(ref callbacks) = self.config.callbacks {
-            callbacks.obj_memory_buffer(&CompiledKind::Module, &memory_buffer);
-        }
+        let object_files = function_bodies
+            .chain(trampolines)
+            .chain(dynamic_trampolines)
+            .collect::<Result<Vec<_>, CompileError>>()?;
 
-        Ok(memory_buffer.as_slice().to_vec())
+        Ok(ExperimentalNativeCompilation {
+            object_files,
+            frame_infos,
+        })
     }
 }
 
@@ -201,16 +182,13 @@ impl Compiler for LLVMCompiler {
         // The list of function bodies
         function_body_inputs: &PrimaryMap<LocalFunctionIndex, FunctionBodyData<'data>>,
         symbol_registry: &dyn SymbolRegistry,
-        // The metadata to inject into the wasmer_metadata section of the object file.
-        wasmer_metadata: &[u8],
-    ) -> Option<Result<Vec<u8>, CompileError>> {
+    ) -> Option<Result<ExperimentalNativeCompilation, CompileError>> {
         Some(self.compile_native_object(
             target,
             compile_info,
             module_translation,
             function_body_inputs,
             symbol_registry,
-            wasmer_metadata,
         ))
     }
 

lib/compiler-llvm/src/object_file.rs

@@ -4,6 +4,7 @@ use std::collections::{HashMap, HashSet};
 use std::convert::TryInto;
 use std::num::TryFromIntError;
 
+use crate::translator::FUNCTION_SECTION_NAME;
 use wasmer_compiler::{
     CompileError, CompiledFunctionFrameInfo, CustomSection, CustomSectionProtection,
     CustomSections, FunctionAddressMap, FunctionBody, InstructionAddressMap, Relocation,
@@ -20,12 +21,48 @@ fn map_object_err(error: object::read::Error) -> CompileError {
     CompileError::Codegen(format!("error parsing object file: {}", error))
 }
 
+fn map_object_err(error: object::read::Error) -> CompileError {
+    CompileError::Codegen(format!("error parsing object file: {}", error))
+}
+
 pub struct CompiledFunction {
     pub compiled_function: wasmer_compiler::CompiledFunction,
     pub custom_sections: CustomSections,
     pub eh_frame_section_indices: Vec<SectionIndex>,
 }
 
+pub fn get_function_body_size(data: &[u8]) -> Result<u64, CompileError> {
+    use object::{Object, ObjectSection};
+
+    let in_object = object::File::parse(&data).map_err(map_object_err)?;
+    let section = in_object.section_by_name(FUNCTION_SECTION_NAME);
+    match section {
+        Some(section) => Ok(section.size()),
+        None => Ok(0),
+    }
+}
+
+/// Get the frame information from an object file.
+pub fn get_frame_info(contents: &[u8]) -> Result<CompiledFunctionFrameInfo, CompileError> {
+    let function_length = get_function_body_size(contents)? as usize;
+    let address_map = FunctionAddressMap {
+        instructions: vec![InstructionAddressMap {
+            srcloc: SourceLoc::default(),
+            code_offset: 0,
+            code_len: function_length,
+        }],
+        start_srcloc: SourceLoc::default(),
+        end_srcloc: SourceLoc::default(),
+        body_offset: 0,
+        body_len: function_length,
+    };
+
+    Ok(CompiledFunctionFrameInfo {
+        address_map,
+        traps: vec![],
+    })
+}
+
 pub fn load_object_file<F>(
     contents: &[u8],
     root_section: &str,

lib/compiler-llvm/src/trampoline/wasm.rs

@@ -19,7 +19,7 @@ use wasmer_types::{FunctionType, LocalFunctionIndex};
 
 pub struct FuncTrampoline {
     ctx: Context,
-    target_machine: TargetMachine,
+    pub(crate) target_machine: TargetMachine,
     abi: Box<dyn Abi>,
 }