First iteration of wasmer-reborn

lib/compiler/src/compiler.rs

@@ -0,0 +1,70 @@
+//! This module mainly outputs the `Compiler` trait that custom
+//! compilers will need to implement.
+
+use crate::config::Target;
+use crate::errors::CompileError;
+use crate::function::{Compilation, CompiledFunction};
+use crate::std::vec::Vec;
+use crate::FunctionBodyData;
+use crate::ModuleTranslationState;
+use wasm_common::entity::PrimaryMap;
+use wasm_common::{DefinedFuncIndex, Features, FuncType, MemoryIndex, TableIndex};
+use wasmer_runtime::Module;
+use wasmer_runtime::{MemoryPlan, TablePlan};
+use wasmparser::{validate, OperatorValidatorConfig, ValidatingParserConfig};
+
+/// An implementation of a Compiler from parsed WebAssembly module to Compiled native code.
+pub trait Compiler {
+    /// Gets the target associated with this compiler
+    fn target(&self) -> Target;
+
+    /// Gets the WebAssembly features for this Compiler
+    fn features(&self) -> Features;
+
+    /// Validates a module.
+    ///
+    /// It returns the a succesful Result in case is valid, `CompileError` in case is not.
+    fn validate_module<'data>(&self, data: &'data [u8]) -> Result<(), CompileError> {
+        let features = self.features();
+        let config = ValidatingParserConfig {
+            operator_config: OperatorValidatorConfig {
+                enable_threads: features.threads,
+                enable_reference_types: features.reference_types,
+                enable_bulk_memory: features.bulk_memory,
+                enable_simd: features.simd,
+                enable_multi_value: features.multi_value,
+            },
+        };
+        validate(data, Some(config)).map_err(|e| CompileError::Validate(format!("{}", e)))
+    }
+
+    /// Compiles a parsed module.
+    ///
+    /// It returns the `Compilation` result (with a list of `CompiledFunction`)
+    /// or a `CompileError`.
+    fn compile_module<'data, 'module>(
+        &self,
+        module: &'module Module,
+        module_translation: &ModuleTranslationState,
+        // The list of function bodies
+        function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>,
+        // The plans for the module memories (imported and local)
+        memory_plans: PrimaryMap<MemoryIndex, MemoryPlan>,
+        // The plans for the module tables (imported and local)
+        table_plans: PrimaryMap<TableIndex, TablePlan>,
+    ) -> Result<Compilation, CompileError>;
+
+    /// Compile the trampolines to call a function defined in
+    /// a Wasm module.
+    ///
+    /// This allows us to call easily Wasm functions, such as:
+    ///
+    /// ```ignore
+    /// let func = instance.exports.func("my_func");
+    /// func.call(&[Value::I32(1)]);
+    /// ```
+    fn compile_wasm_trampolines(
+        &self,
+        signatures: &[FuncType],
+    ) -> Result<Vec<CompiledFunction>, CompileError>;
+}