Expose some more internals publicly

misc/wasmtime-py/src/import.rs

@@ -5,7 +5,6 @@ extern crate alloc;
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict, PyTuple};
 
-use crate::code_memory::CodeMemory;
 use crate::function::Function;
 use crate::memory::Memory;
 use crate::value::{read_value_from, write_value_to};
@@ -18,6 +17,7 @@ use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use cranelift_wasm::{DefinedFuncIndex, FuncIndex};
 use target_lexicon::HOST;
 use wasmtime_environ::{Export, Module};
+use wasmtime_jit::CodeMemory;
 use wasmtime_runtime::{Imports, InstanceHandle, VMContext, VMFunctionBody};
 
 use alloc::rc::Rc;

misc/wasmtime-py/src/lib.rs

@@ -11,7 +11,6 @@ use core::cell::RefCell;
 use std::rc::Rc;
 use wasmtime_interface_types::ModuleData;
 
-mod code_memory;
 mod function;
 mod import;
 mod instance;

wasmtime-api/src/trampoline/func.rs

@@ -1,7 +1,6 @@
 //! Support for a calling of an imported function.
 
 use crate::r#ref::HostRef;
-use crate::trampoline::code_memory::CodeMemory;
 use cranelift_codegen::ir::types;
 use cranelift_codegen::ir::{InstBuilder, StackSlotData, StackSlotKind, TrapCode};
 use cranelift_codegen::Context;
@@ -12,6 +11,7 @@ use cranelift_wasm::{DefinedFuncIndex, FuncIndex};
 //use target_lexicon::HOST;
 use failure::Error;
 use wasmtime_environ::{Export, Module};
+use wasmtime_jit::CodeMemory;
 use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody};
 
 use alloc::boxed::Box;

wasmtime-api/src/trampoline/mod.rs

@@ -1,6 +1,5 @@
 //! Utility module to create trampolines in/out WebAssembly module.
 
-mod code_memory;
 mod create_handle;
 mod func;
 mod global;

wasmtime-jit/src/code_memory.rs

@@ -8,7 +8,7 @@ use region;
 use wasmtime_runtime::{Mmap, VMFunctionBody};
 
 /// Memory manager for executable code.
-pub(crate) struct CodeMemory {
+pub struct CodeMemory {
     current: Mmap,
     mmaps: Vec<Mmap>,
     position: usize,

wasmtime-jit/src/context.rs

@@ -1,8 +1,8 @@
 use crate::action::{get, inspect_memory, invoke};
 use crate::HashMap;
 use crate::{
-    instantiate, ActionError, ActionOutcome, CompilationStrategy, Compiler, InstanceHandle,
-    Namespace, RuntimeValue, SetupError,
+    instantiate, ActionError, ActionOutcome, CompilationStrategy, CompiledModule, Compiler,
+    InstanceHandle, Namespace, RuntimeValue, SetupError,
 };
 use alloc::boxed::Box;
 use alloc::rc::Rc;
@@ -160,6 +160,20 @@ impl Context {
         Ok(instance)
     }
 
+    /// Compile a module.
+    pub fn compile_module(&mut self, data: &[u8]) -> Result<CompiledModule, SetupError> {
+        self.validate(&data).map_err(SetupError::Validate)?;
+        let debug_info = self.debug_info();
+
+        CompiledModule::new(
+            &mut *self.compiler,
+            data,
+            &mut self.namespace,
+            Rc::clone(&self.global_exports),
+            debug_info,
+        )
+    }
+
     /// If `name` isn't None, register it for the given instance.
     pub fn optionally_name_instance(&mut self, name: Option<String>, instance: InstanceHandle) {
         if let Some(name) = name {

wasmtime-jit/src/instantiate.rs

@@ -223,6 +223,16 @@ impl CompiledModule {
             Box::new(()),
         )
     }
+
+    /// Return a reference-counting pointer to a module.
+    pub fn module(&self) -> Rc<Module> {
+        self.module.clone()
+    }
+
+    /// Return a reference to a module.
+    pub fn module_ref(&self) -> &Module {
+        &self.module
+    }
 }
 
 /// Similar to `DataInitializer`, but owns its own copy of the data rather

wasmtime-jit/src/lib.rs

@@ -44,6 +44,7 @@ mod resolver;
 mod target_tunables;
 
 pub use crate::action::{ActionError, ActionOutcome, RuntimeValue};
+pub use crate::code_memory::CodeMemory;
 pub use crate::compiler::{CompilationStrategy, Compiler};
 pub use crate::context::{Context, ContextError, Features, UnknownInstance};
 pub use crate::instantiate::{instantiate, CompiledModule, SetupError};