Add caching. (#134)

* Allow a module to have a different signature registry than the process-specific

* Add core ability to build compiled code caches

* Remove timing printouts

* Serialize/Deserialize memories to reduce copies

* Work more on api

* Relocate local functions relatively before external functions

* Fix incorrect definition in test

* merge errors caused by merge

* Fix emscripten compile

* Fix review comments

lib/clif-backend/src/lib.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "cache")]
+mod cache;
 mod call;
 mod func_env;
 mod libcalls;
@@ -12,11 +14,23 @@ use cranelift_codegen::{
     settings::{self, Configurable},
 };
 use target_lexicon::Triple;
+#[cfg(feature = "cache")]
+use wasmer_runtime_core::{
+    backend::sys::Memory,
+    cache::{Cache, Error as CacheError},
+    module::ModuleInfo,
+};
 use wasmer_runtime_core::{
     backend::{Compiler, Token},
     error::{CompileError, CompileResult},
     module::ModuleInner,
 };
+#[cfg(feature = "cache")]
+#[macro_use]
+extern crate serde_derive;
+#[cfg(feature = "cache")]
+extern crate serde;
+
 use wasmparser::{self, WasmDecoder};
 
 pub struct CraneliftCompiler {}
@@ -28,7 +42,7 @@ impl CraneliftCompiler {
 }
 
 impl Compiler for CraneliftCompiler {
-    // Compiles wasm binary to a wasmer module.
+    /// Compiles wasm binary to a wasmer module.
     fn compile(&self, wasm: &[u8], _: Token) -> CompileResult<ModuleInner> {
         validate(wasm)?;
 
@@ -36,10 +50,48 @@ impl Compiler for CraneliftCompiler {
 
         let mut module = module::Module::empty();
         let module_env = module_env::ModuleEnv::new(&mut module, &*isa);
+
         let func_bodies = module_env.translate(wasm)?;
 
         module.compile(&*isa, func_bodies)
     }
+
+    /// Create a wasmer Module from an already-compiled cache.
+    #[cfg(feature = "cache")]
+    unsafe fn from_cache(&self, cache: Cache, _: Token) -> Result<ModuleInner, CacheError> {
+        module::Module::from_cache(cache)
+    }
+
+    #[cfg(feature = "cache")]
+    fn compile_to_backend_cache_data(
+        &self,
+        wasm: &[u8],
+        _: Token,
+    ) -> CompileResult<(Box<ModuleInfo>, Vec<u8>, Memory)> {
+        validate(wasm)?;
+
+        let isa = get_isa();
+
+        let mut module = module::Module::empty();
+        let module_env = module_env::ModuleEnv::new(&mut module, &*isa);
+
+        let func_bodies = module_env.translate(wasm)?;
+
+        let (info, backend_cache, compiled_code) = module
+            .compile_to_backend_cache(&*isa, func_bodies)
+            .map_err(|e| CompileError::InternalError {
+                msg: format!("{:?}", e),
+            })?;
+
+        let buffer =
+            backend_cache
+                .into_backend_data()
+                .map_err(|e| CompileError::InternalError {
+                    msg: format!("{:?}", e),
+                })?;
+
+        Ok((Box::new(info), buffer, compiled_code))
+    }
 }
 
 fn get_isa() -> Box<isa::TargetIsa> {