pass compiler_config along to other backends

lib/dynasm-backend/src/lib.rs

@@ -25,7 +25,7 @@ mod stack;
 use crate::codegen::{CodegenError, ModuleCodeGenerator};
 use crate::parse::LoadError;
 use wasmer_runtime_core::{
-    backend::{sys::Memory, Backend, CacheGen, Compiler, Token},
+    backend::{sys::Memory, Backend, CacheGen, Compiler, CompilerConfig, Token},
     cache::{Artifact, Error as CacheError},
     error::{CompileError, CompileResult},
     module::{ModuleInfo, ModuleInner},
@@ -51,9 +51,14 @@ impl SinglePassCompiler {
 }
 
 impl Compiler for SinglePassCompiler {
-    fn compile(&self, wasm: &[u8], _: Token) -> CompileResult<ModuleInner> {
+    fn compile(
+        &self,
+        wasm: &[u8],
+        compiler_config: CompilerConfig,
+        _: Token,
+    ) -> CompileResult<ModuleInner> {
         let mut mcg = codegen_x64::X64ModuleCodeGenerator::new();
-        let info = parse::read_module(wasm, Backend::Dynasm, &mut mcg)?;
+        let info = parse::read_module(wasm, Backend::Dynasm, &mut mcg, &compiler_config)?;
         let (ec, resolver) = mcg.finalize(&info)?;
         Ok(ModuleInner {
             cache_gen: Box::new(Placeholder),

lib/dynasm-backend/src/parse.rs

@@ -70,6 +70,7 @@ pub fn read_module<
     wasm: &[u8],
     backend: Backend,
     mcg: &mut MCG,
+    compiler_config: &CompilerConfig,
 ) -> Result<ModuleInfo, LoadError> {
     validate(wasm)?;
     let mut info = ModuleInfo {
@@ -95,6 +96,8 @@ pub fn read_module<
 
         namespace_table: StringTable::new(),
         name_table: StringTable::new(),
+
+        em_symbol_map: compiler_config.symbol_map.clone(),
     };
 
     let mut reader = ModuleReader::new(wasm)?;

lib/llvm-backend/src/lib.rs

@@ -6,7 +6,7 @@ use inkwell::{
     OptimizationLevel,
 };
 use wasmer_runtime_core::{
-    backend::{Compiler, Token},
+    backend::{Compiler, CompilerConfig, Token},
     cache::{Artifact, Error as CacheError},
     error::CompileError,
     module::ModuleInner,
@@ -32,10 +32,15 @@ impl LLVMCompiler {
 }
 
 impl Compiler for LLVMCompiler {
-    fn compile(&self, wasm: &[u8], _: Token) -> Result<ModuleInner, CompileError> {
+    fn compile(
+        &self,
+        wasm: &[u8],
+        compiler_config: CompilerConfig,
+        _: Token,
+    ) -> Result<ModuleInner, CompileError> {
         validate(wasm)?;
 
-        let (info, code_reader) = read_info::read_module(wasm).unwrap();
+        let (info, code_reader) = read_info::read_module(wasm, &compiler_config).unwrap();
         let (module, intrinsics) = code::parse_function_bodies(&info, code_reader).unwrap();
 
         let (backend, protected_caller) = backend::LLVMBackend::new(module, intrinsics);

lib/llvm-backend/src/read_info.rs

@@ -1,5 +1,5 @@
 use wasmer_runtime_core::{
-    backend::Backend,
+    backend::{Backend, CompilerConfig},
     module::{
         DataInitializer, ExportIndex, ImportName, ModuleInfo, StringTable, StringTableBuilder,
         TableInitializer,
@@ -18,7 +18,10 @@ use wasmparser::{
     SectionCode, Type as WpType,
 };
 
-pub fn read_module(wasm: &[u8]) -> Result<(ModuleInfo, CodeSectionReader), BinaryReaderError> {
+pub fn read_module(
+    wasm: &[u8],
+    compiler_config: &CompilerConfig,
+) -> Result<(ModuleInfo, CodeSectionReader), BinaryReaderError> {
     let mut info = ModuleInfo {
         memories: Map::new(),
         globals: Map::new(),
@@ -42,6 +45,8 @@ pub fn read_module(wasm: &[u8]) -> Result<(ModuleInfo, CodeSectionReader), Binar
 
         namespace_table: StringTable::new(),
         name_table: StringTable::new(),
+
+        em_symbol_map: compiler_config.symbol_map.clone(),
     };
 
     let mut reader = ModuleReader::new(wasm)?;