Try #1099:

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## **[Unreleased]**
 
+- [#1099](https://github.com/wasmerio/wasmer/pull/1099) Remove `backend::Backend` from `wasmer_runtime_core`
 - [#1097](https://github.com/wasmerio/wasmer/pull/1097) Move inline breakpoint outside of runtime backend
 - [#1095](https://github.com/wasmerio/wasmer/pull/1095) Update to cranelift 0.52.
 - [#1092](https://github.com/wasmerio/wasmer/pull/1092) Add `get_utf8_string_with_nul` to `WasmPtr` to read nul-terminated strings from memory.

Cargo.toml

@@ -86,19 +86,16 @@ extra-debug = ["wasmer-clif-backend/debug", "wasmer-runtime-core/debug"]
 fast-tests = []
 backend-cranelift = [
     "wasmer-clif-backend",
-    "wasmer-runtime-core/backend-cranelift",
     "wasmer-runtime/cranelift",
     "wasmer-middleware-common-tests/clif",
 ]
 backend-llvm = [
     "wasmer-llvm-backend",
-    "wasmer-runtime-core/backend-llvm",
     "wasmer-runtime/llvm",
     "wasmer-middleware-common-tests/llvm",
 ]
 backend-singlepass = [
     "wasmer-singlepass-backend",
-    "wasmer-runtime-core/backend-singlepass",
     "wasmer-runtime/singlepass",
     "wasmer-middleware-common-tests/singlepass",
 ]

Makefile

@@ -222,38 +222,9 @@ check: check-bench
 	# as default, and test a minimal set of features with only one backend
 	# at a time.
 	cargo check --manifest-path lib/runtime/Cargo.toml
-	# Check some of the cases where deterministic execution could matter
-	cargo check --manifest-path lib/runtime/Cargo.toml --features "deterministic-execution"
-	cargo check --manifest-path lib/runtime/Cargo.toml --no-default-features \
-		--features=default-backend-singlepass,deterministic-execution
-	cargo check --manifest-path lib/runtime/Cargo.toml --no-default-features \
-		--features=default-backend-llvm,deterministic-execution
-	cargo check --release --manifest-path lib/runtime/Cargo.toml
 
 	$(RUNTIME_CHECK) \
-		--features=cranelift,cache,debug,llvm,singlepass,default-backend-singlepass
-	$(RUNTIME_CHECK) --release \
-		--features=cranelift,cache,llvm,singlepass,default-backend-singlepass
-	$(RUNTIME_CHECK) \
-		--features=cranelift,cache,debug,llvm,singlepass,default-backend-cranelift
-	$(RUNTIME_CHECK) --release \
-		--features=cranelift,cache,llvm,singlepass,default-backend-cranelift
-	$(RUNTIME_CHECK) \
-		--features=cranelift,cache,debug,llvm,singlepass,default-backend-llvm
-	$(RUNTIME_CHECK) --release \
-		--features=cranelift,cache,llvm,singlepass,default-backend-llvm
-	$(RUNTIME_CHECK) \
-		--features=singlepass,default-backend-singlepass,debug
-	$(RUNTIME_CHECK) --release \
-		--features=singlepass,default-backend-singlepass
-	$(RUNTIME_CHECK) \
-		--features=cranelift,default-backend-cranelift,debug
-	$(RUNTIME_CHECK) --release \
-		--features=cranelift,default-backend-cranelift
-	$(RUNTIME_CHECK) \
-		--features=llvm,default-backend-llvm,debug
-	$(RUNTIME_CHECK) --release \
-		--features=llvm,default-backend-llvm
+		--features=default-backend-singlepass,singlepass,cranelift,llvm,cache,debug,deterministic-execution
 
 # Release
 release:

lib/clif-backend/src/code.rs

@@ -18,7 +18,7 @@ use std::mem;
 use std::sync::{Arc, RwLock};
 use wasmer_runtime_core::error::CompileError;
 use wasmer_runtime_core::{
-    backend::{Backend, CacheGen, Token},
+    backend::{CacheGen, Token},
     cache::{Artifact, Error as CacheError},
     codegen::*,
     memory::MemoryType,
@@ -58,8 +58,8 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
         unimplemented!("cross compilation is not available for clif backend")
     }
 
-    fn backend_id() -> Backend {
-        Backend::Cranelift
+    fn backend_id() -> String {
+        "cranelift".to_string()
     }
 
     fn check_precondition(&mut self, _module_info: &ModuleInfo) -> Result<(), CodegenError> {

lib/llvm-backend/src/code.rs

@@ -32,7 +32,7 @@ use std::{
 };
 
 use wasmer_runtime_core::{
-    backend::{Backend, CacheGen, CompilerConfig, Token},
+    backend::{CacheGen, CompilerConfig, Token},
     cache::{Artifact, Error as CacheError},
     codegen::*,
     memory::MemoryType,
@@ -8721,8 +8721,8 @@ impl<'ctx> ModuleCodeGenerator<LLVMFunctionCodeGenerator<'ctx>, LLVMBackend, Cod
         }
     }
 
-    fn backend_id() -> Backend {
-        Backend::LLVM
+    fn backend_id() -> String {
+        "llvm".to_string()
     }
 
     fn check_precondition(&mut self, _module_info: &ModuleInfo) -> Result<(), CodegenError> {

lib/middleware-common-tests/Cargo.toml

@@ -10,12 +10,12 @@ publish = false
 [dependencies]
 wasmer-runtime-core = { path = "../runtime-core", version = "0.12.0" }
 wasmer-middleware-common = { path = "../middleware-common", version = "0.12.0" }
-wasmer-clif-backend = { path = "../clif-backend", version = "0.12.0" }
+wasmer-clif-backend = { path = "../clif-backend", version = "0.12.0", optional = true }
 wasmer-llvm-backend = { path = "../llvm-backend", version = "0.12.0", features = ["test"], optional = true }
 wasmer-singlepass-backend = { path = "../singlepass-backend", version = "0.12.0", optional = true }
 
 [features]
-clif = []
+clif = ["wasmer-clif-backend"]
 llvm = ["wasmer-llvm-backend"]
 singlepass = ["wasmer-singlepass-backend"]
 

lib/middleware-common-tests/src/lib.rs

@@ -3,47 +3,33 @@ mod tests {
     use wabt::wat2wasm;
 
     use wasmer_middleware_common::metering::*;
-    use wasmer_runtime_core::backend::RunnableModule;
+    use wasmer_runtime_core::codegen::ModuleCodeGenerator;
     use wasmer_runtime_core::codegen::{MiddlewareChain, StreamingCompiler};
     use wasmer_runtime_core::fault::{pop_code_version, push_code_version};
     use wasmer_runtime_core::state::CodeVersion;
-    use wasmer_runtime_core::{
-        backend::{Backend, Compiler},
-        compile_with, imports, Func,
-    };
+    use wasmer_runtime_core::{backend::Compiler, compile_with, imports, Func};
 
     #[cfg(feature = "llvm")]
-    fn get_compiler(limit: u64) -> (impl Compiler, Backend) {
-        use wasmer_llvm_backend::ModuleCodeGenerator as LLVMMCG;
-        let c: StreamingCompiler<LLVMMCG, _, _, _, _> = StreamingCompiler::new(move || {
-            let mut chain = MiddlewareChain::new();
-            chain.push(Metering::new(limit));
-            chain
-        });
-        (c, Backend::LLVM)
-    }
+    use wasmer_llvm_backend::ModuleCodeGenerator as MCG;
 
     #[cfg(feature = "singlepass")]
-    fn get_compiler(limit: u64) -> (impl Compiler, Backend) {
-        use wasmer_singlepass_backend::ModuleCodeGenerator as SinglePassMCG;
-        let c: StreamingCompiler<SinglePassMCG, _, _, _, _> = StreamingCompiler::new(move || {
+    use wasmer_singlepass_backend::ModuleCodeGenerator as MCG;
+
+    #[cfg(feature = "clif")]
+    compile_error!("cranelift does not implement metering yet");
+
+    fn get_compiler(limit: u64) -> impl Compiler {
+        let c: StreamingCompiler<MCG, _, _, _, _> = StreamingCompiler::new(move || {
             let mut chain = MiddlewareChain::new();
             chain.push(Metering::new(limit));
             chain
         });
-        (c, Backend::Singlepass)
+        c
     }
 
     #[cfg(not(any(feature = "llvm", feature = "clif", feature = "singlepass")))]
     compile_error!("compiler not specified, activate a compiler via features");
 
-    #[cfg(feature = "clif")]
-    fn get_compiler(_limit: u64) -> (impl Compiler, Backend) {
-        compile_error!("cranelift does not implement metering");
-        use wasmer_clif_backend::CraneliftCompiler;
-        (CraneliftCompiler::new(), Backend::Cranelift)
-    }
-
     // Assemblyscript
     // export function add_to(x: i32, y: i32): i32 {
     //    for(var i = 0; i < x; i++){
@@ -109,7 +95,7 @@ mod tests {
 
         let limit = 100u64;
 
-        let (compiler, backend_id) = get_compiler(limit);
+        let compiler = get_compiler(limit);
         let module = compile_with(&wasm_binary, &compiler).unwrap();
 
         let import_object = imports! {};
@@ -124,8 +110,8 @@ mod tests {
                 baseline: true,
                 msm: msm,
                 base: instance.module.runnable_module.get_code().unwrap().as_ptr() as usize,
+                backend: MCG::backend_id(),
                 runnable_module: instance.module.runnable_module.clone(),
-                backend: backend_id,
             });
             true
         } else {
@@ -151,7 +137,7 @@ mod tests {
 
         let limit = 100u64;
 
-        let (compiler, backend_id) = get_compiler(limit);
+        let compiler = get_compiler(limit);
         let module = compile_with(&wasm_binary, &compiler).unwrap();
 
         let import_object = imports! {};
@@ -166,7 +152,7 @@ mod tests {
                 baseline: true,
                 msm: msm,
                 base: instance.module.runnable_module.get_code().unwrap().as_ptr() as usize,
-                backend: backend_id,
+                backend: MCG::backend_id(),
                 runnable_module: instance.module.runnable_module.clone(),
             });
             true

lib/runtime-core/Cargo.toml

@@ -52,7 +52,7 @@ cc = "1.0"
 [features]
 debug = []
 trace = ["debug"]
-# backend flags used in conditional compilation of Backend::variants
+# backend flags no longer used
 "backend-cranelift" = []
 "backend-singlepass" = []
 "backend-llvm" = []

lib/runtime-core/src/backend.rs

@@ -22,60 +22,6 @@ pub mod sys {
 }
 pub use crate::sig_registry::SigRegistry;
 
-/// Enum used to select which compiler should be used to generate code.
-#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum Backend {
-    Cranelift,
-    Singlepass,
-    LLVM,
-    Auto,
-}
-
-impl Backend {
-    /// Get a list of the currently enabled (via feature flag) backends.
-    pub fn variants() -> &'static [&'static str] {
-        &[
-            #[cfg(feature = "backend-cranelift")]
-            "cranelift",
-            #[cfg(feature = "backend-singlepass")]
-            "singlepass",
-            #[cfg(feature = "backend-llvm")]
-            "llvm",
-            "auto",
-        ]
-    }
-
-    /// Stable string representation of the backend.
-    /// It can be used as part of a cache key, for example.
-    pub fn to_string(&self) -> &'static str {
-        match self {
-            Backend::Cranelift => "cranelift",
-            Backend::Singlepass => "singlepass",
-            Backend::LLVM => "llvm",
-            Backend::Auto => "auto",
-        }
-    }
-}
-
-impl Default for Backend {
-    fn default() -> Self {
-        Backend::Cranelift
-    }
-}
-
-impl std::str::FromStr for Backend {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Backend, String> {
-        match s.to_lowercase().as_str() {
-            "singlepass" => Ok(Backend::Singlepass),
-            "cranelift" => Ok(Backend::Cranelift),
-            "llvm" => Ok(Backend::LLVM),
-            "auto" => Ok(Backend::Auto),
-            _ => Err(format!("The backend {} doesn't exist", s)),
-        }
-    }
-}
-
 /// The target architecture for code generation.
 #[derive(Copy, Clone, Debug)]
 pub enum Architecture {
@@ -104,22 +50,6 @@ pub struct InlineBreakpoint {
     pub ty: InlineBreakpointType,
 }
 
-#[cfg(test)]
-mod backend_test {
-    use super::*;
-    use std::str::FromStr;
-
-    #[test]
-    fn str_repr_matches() {
-        // if this test breaks, think hard about why it's breaking
-        // can we avoid having these be different?
-
-        for &backend in &[Backend::Cranelift, Backend::LLVM, Backend::Singlepass] {
-            assert_eq!(backend, Backend::from_str(backend.to_string()).unwrap());
-        }
-    }
-}
-
 /// This type cannot be constructed from
 /// outside the runtime crate.
 pub struct Token {

lib/runtime-core/src/cache.rs

@@ -2,13 +2,9 @@
 //! serializing compiled wasm code to a binary format.  The binary format can be persisted,
 //! and loaded to allow skipping compilation and fast startup.
 
-use crate::{
-    backend::Backend,
-    module::{Module, ModuleInfo},
-    sys::Memory,
-};
+use crate::{module::ModuleInfo, sys::Memory};
 use blake2b_simd::blake2bp;
-use std::{fmt, io, mem, slice};
+use std::{io, mem, slice};
 
 /// Indicates the invalid type of invalid cache file
 #[derive(Debug)]
@@ -35,7 +31,7 @@ pub enum Error {
     /// The cached binary has been invalidated.
     InvalidatedCache,
     /// The current backend does not support caching.
-    UnsupportedBackend(Backend),
+    UnsupportedBackend(String),
 }
 
 impl From<io::Error> for Error {
@@ -246,24 +242,6 @@ impl Artifact {
     }
 }
 
-/// A generic cache for storing and loading compiled wasm modules.
-///
-/// The `wasmer-runtime` supplies a naive `FileSystemCache` api.
-pub trait Cache {
-    /// Error type to return when load error occurs
-    type LoadError: fmt::Debug;
-    /// Error type to return when store error occurs
-    type StoreError: fmt::Debug;
-
-    /// loads a module using the default `Backend`
-    fn load(&self, key: WasmHash) -> Result<Module, Self::LoadError>;
-    /// loads a cached module using a specific `Backend`
-    fn load_with_backend(&self, key: WasmHash, backend: Backend)
-        -> Result<Module, Self::LoadError>;
-    /// Store a module into the cache with the given key
-    fn store(&mut self, key: WasmHash, module: Module) -> Result<(), Self::StoreError>;
-}
-
 /// A unique ID generated from the version of Wasmer for use with cache versioning
 pub const WASMER_VERSION_HASH: &'static str =
     include_str!(concat!(env!("OUT_DIR"), "/wasmer_version_hash.txt"));