Starting integration.

lib/dynasm-backend/src/lib.rs

@@ -10,3 +10,75 @@ mod codegen;
 mod codegen_x64;
 mod parse;
 mod stack;
+
+use std::ptr::NonNull;
+use wasmer_runtime_core::{
+    backend::{Backend, Compiler, FuncResolver, ProtectedCaller, Token, UserTrapper},
+    error::{CompileError, CompileResult, RuntimeResult},
+    module::{ModuleInfo, ModuleInner, StringTable},
+    structures::{Map, TypedIndex},
+    types::{
+        FuncIndex, FuncSig, GlobalIndex, LocalFuncIndex, MemoryIndex, SigIndex, TableIndex, Type,
+        Value,
+    },
+    vm::{self, ImportBacking},
+};
+
+struct Placeholder;
+
+impl FuncResolver for Placeholder {
+    fn get(
+        &self,
+        _module: &ModuleInner,
+        _local_func_index: LocalFuncIndex,
+    ) -> Option<NonNull<vm::Func>> {
+        None
+    }
+}
+
+impl ProtectedCaller for Placeholder {
+    fn call(
+        &self,
+        _module: &ModuleInner,
+        _func_index: FuncIndex,
+        _params: &[Value],
+        _import_backing: &ImportBacking,
+        _vmctx: *mut vm::Ctx,
+        _: Token,
+    ) -> RuntimeResult<Vec<Value>> {
+        Ok(vec![])
+    }
+
+    fn get_early_trapper(&self) -> Box<dyn UserTrapper> {
+        pub struct Trapper;
+
+        impl UserTrapper for Trapper {
+            unsafe fn do_early_trap(&self, msg: String) -> ! {
+                panic!("{}", msg);
+            }
+        }
+
+        Box::new(Trapper)
+    }
+}
+
+pub struct SinglePassCompiler {}
+
+impl Compiler for SinglePassCompiler {
+    fn compile(&self, wasm: &[u8], _: Token) -> CompileResult<ModuleInner> {
+        let mut mcg = codegen_x64::X64ModuleCodeGenerator::new();
+        let info = match parse::read_module(wasm, Backend::Dynasm, &mut mcg) {
+            Ok(x) => x,
+            Err(e) => {
+                return Err(CompileError::InternalError {
+                    msg: format!("{:?}", e),
+                })
+            }
+        };
+        Ok(ModuleInner {
+            func_resolver: Box::new(Placeholder),
+            protected_caller: Box::new(Placeholder),
+            info: info,
+        })
+    }
+}

lib/dynasm-backend/src/parse.rs

@@ -41,7 +41,7 @@ impl From<CodegenError> for LoadError {
 pub fn read_module<MCG: ModuleCodeGenerator<FCG>, FCG: FunctionCodeGenerator>(
     wasm: &[u8],
     backend: Backend,
-    mut mcg: MCG,
+    mcg: &mut MCG,
 ) -> Result<ModuleInfo, LoadError> {
     let mut info = ModuleInfo {
         memories: Map::new(),
@@ -72,6 +72,7 @@ pub fn read_module<MCG: ModuleCodeGenerator<FCG>, FCG: FunctionCodeGenerator>(
 
     loop {
         if reader.eof() {
+            mcg.finalize()?;
             return Ok(info);
         }
 
@@ -269,12 +270,14 @@ pub fn read_module<MCG: ModuleCodeGenerator<FCG>, FCG: FunctionCodeGenerator>(
                 for i in 0..code_reader.get_count() {
                     let item = code_reader.read()?;
                     let mut fcg = mcg.next_function()?;
-                    for param in info
+                    let sig = info
                         .signatures
                         .get(*info.func_assoc.get(FuncIndex::new(i as usize)).unwrap())
-                        .unwrap()
-                        .params()
-                    {
+                        .unwrap();
+                    for ret in sig.returns() {
+                        fcg.feed_return(type_to_wp_type(*ret))?;
+                    }
+                    for param in sig.params() {
                         fcg.feed_param(type_to_wp_type(*param))?;
                     }
                     for local in item.get_locals_reader()? {