Rename the wasmtime::runtime::vm::Instance::module method to env_module

crates/wasmtime/src/runtime/memory.rs

@@ -1013,7 +1013,7 @@ impl SharedMemory {
     ) -> Self {
         #[cfg_attr(not(feature = "threads"), allow(unused_variables, unreachable_code))]
         crate::runtime::vm::Instance::from_vmctx(wasmtime_export.vmctx, |handle| {
-            let memory_index = handle.module().memory_index(wasmtime_export.index);
+            let memory_index = handle.env_module().memory_index(wasmtime_export.index);
             let page_size = handle.memory_page_size(memory_index);
             debug_assert!(page_size.is_power_of_two());
             let page_size_log2 = u8::try_from(page_size.ilog2()).unwrap();

crates/wasmtime/src/runtime/store.rs

@@ -572,7 +572,7 @@ impl<T> Store<T> {
             let shim = ModuleRuntimeInfo::bare(module);
             let allocator = OnDemandInstanceAllocator::default();
             allocator
-                .validate_module(shim.module(), shim.offsets())
+                .validate_module(shim.env_module(), shim.offsets())
                 .unwrap();
             let mut instance = unsafe {
                 allocator

crates/wasmtime/src/runtime/trampoline/memory.rs

@@ -204,7 +204,7 @@ unsafe impl InstanceAllocatorImpl for SingleMemoryInstance<'_> {
     ) -> Result<(MemoryAllocationIndex, Memory)> {
         #[cfg(debug_assertions)]
         {
-            let module = request.runtime_info.module();
+            let module = request.runtime_info.env_module();
             let offsets = request.runtime_info.offsets();
             self.validate_module_impl(module, offsets)
                 .expect("should have already validated the module before allocating memory");

crates/wasmtime/src/runtime/vm.rs

@@ -217,7 +217,7 @@ impl ModuleRuntimeInfo {
     }
 
     /// The underlying Module.
-    pub(crate) fn module(&self) -> &Arc<wasmtime_environ::Module> {
+    pub(crate) fn env_module(&self) -> &Arc<wasmtime_environ::Module> {
         match self {
             ModuleRuntimeInfo::Module(m) => m.env_module(),
             ModuleRuntimeInfo::Bare(b) => &b.module,

crates/wasmtime/src/runtime/vm/debug_builtins.rs

@@ -11,7 +11,7 @@ static mut VMCTX_AND_MEMORY: (*mut VMContext, usize) = (std::ptr::null_mut(), 0)
 pub unsafe extern "C" fn resolve_vmctx_memory(ptr: usize) -> *const u8 {
     Instance::from_vmctx(VMCTX_AND_MEMORY.0, |handle| {
         assert!(
-            VMCTX_AND_MEMORY.1 < handle.module().memory_plans.len(),
+            VMCTX_AND_MEMORY.1 < handle.env_module().memory_plans.len(),
             "memory index for debugger is out of bounds"
         );
         let index = MemoryIndex::new(VMCTX_AND_MEMORY.1);
@@ -29,7 +29,7 @@ pub unsafe extern "C" fn resolve_vmctx_memory_ptr(p: *const u32) -> *const u8 {
     );
     Instance::from_vmctx(VMCTX_AND_MEMORY.0, |handle| {
         assert!(
-            VMCTX_AND_MEMORY.1 < handle.module().memory_plans.len(),
+            VMCTX_AND_MEMORY.1 < handle.env_module().memory_plans.len(),
             "memory index for debugger is out of bounds"
         );
         let index = MemoryIndex::new(VMCTX_AND_MEMORY.1);

crates/wasmtime/src/runtime/vm/instance.rs

@@ -172,7 +172,7 @@ impl Instance {
         }
         let ptr = ptr.cast::<Instance>();
 
-        let module = req.runtime_info.module();
+        let module = req.runtime_info.env_module();
         let dropped_elements = EntitySet::with_capacity(module.passive_elements.len());
         let dropped_data = EntitySet::with_capacity(module.passive_data_map.len());
 
@@ -259,8 +259,8 @@ impl Instance {
             .cast()
     }
 
-    pub(crate) fn module(&self) -> &Arc<Module> {
-        self.runtime_info.module()
+    pub(crate) fn env_module(&self) -> &Arc<Module> {
+        self.runtime_info.env_module()
     }
 
     /// Translate a module-level interned type index into an engine-level
@@ -314,7 +314,7 @@ impl Instance {
 
     /// Get a locally defined or imported memory.
     pub(crate) fn get_memory(&self, index: MemoryIndex) -> VMMemoryDefinition {
-        if let Some(defined_index) = self.module().defined_memory_index(index) {
+        if let Some(defined_index) = self.env_module().defined_memory_index(index) {
             self.memory(defined_index)
         } else {
             let import = self.imported_memory(index);
@@ -325,7 +325,7 @@ impl Instance {
     /// Get a locally defined or imported memory.
     #[cfg(feature = "threads")]
     pub(crate) fn get_runtime_memory(&mut self, index: MemoryIndex) -> &mut Memory {
-        if let Some(defined_index) = self.module().defined_memory_index(index) {
+        if let Some(defined_index) = self.env_module().defined_memory_index(index) {
             unsafe { &mut *self.get_defined_memory(defined_index) }
         } else {
             let import = self.imported_memory(index);
@@ -367,7 +367,7 @@ impl Instance {
         &mut self,
         index: GlobalIndex,
     ) -> *mut VMGlobalDefinition {
-        if let Some(index) = self.module().defined_global_index(index) {
+        if let Some(index) = self.env_module().defined_global_index(index) {
             self.global_ptr(index)
         } else {
             self.imported_global(index).from
@@ -384,14 +384,14 @@ impl Instance {
     pub fn all_globals<'a>(
         &'a mut self,
     ) -> impl ExactSizeIterator<Item = (GlobalIndex, ExportGlobal)> + 'a {
-        let module = self.module().clone();
+        let module = self.env_module().clone();
         module.globals.keys().map(move |idx| {
             (
                 idx,
                 ExportGlobal {
                     definition: self.defined_or_imported_global_ptr(idx),
                     vmctx: self.vmctx(),
-                    global: self.module().globals[idx],
+                    global: self.env_module().globals[idx],
                 },
             )
         })
@@ -401,7 +401,7 @@ impl Instance {
     pub fn defined_globals<'a>(
         &'a mut self,
     ) -> impl ExactSizeIterator<Item = (DefinedGlobalIndex, ExportGlobal)> + 'a {
-        let module = self.module().clone();
+        let module = self.env_module().clone();
         module
             .globals
             .keys()
@@ -411,7 +411,7 @@ impl Instance {
                 let global = ExportGlobal {
                     definition: self.global_ptr(def_idx),
                     vmctx: self.vmctx(),
-                    global: self.module().globals[global_idx],
+                    global: self.env_module().globals[global_idx],
                 };
                 (def_idx, global)
             })
@@ -531,23 +531,23 @@ impl Instance {
     }
 
     fn get_exported_table(&mut self, index: TableIndex) -> ExportTable {
-        let (definition, vmctx) = if let Some(def_index) = self.module().defined_table_index(index)
-        {
-            (self.table_ptr(def_index), self.vmctx())
-        } else {
-            let import = self.imported_table(index);
-            (import.from, import.vmctx)
-        };
+        let (definition, vmctx) =
+            if let Some(def_index) = self.env_module().defined_table_index(index) {
+                (self.table_ptr(def_index), self.vmctx())
+            } else {
+                let import = self.imported_table(index);
+                (import.from, import.vmctx)
+            };
         ExportTable {
             definition,
             vmctx,
-            table: self.module().table_plans[index].clone(),
+            table: self.env_module().table_plans[index].clone(),
         }
     }
 
     fn get_exported_memory(&mut self, index: MemoryIndex) -> ExportMemory {
         let (definition, vmctx, def_index) =
-            if let Some(def_index) = self.module().defined_memory_index(index) {
+            if let Some(def_index) = self.env_module().defined_memory_index(index) {
                 (self.memory_ptr(def_index), self.vmctx(), def_index)
             } else {
                 let import = self.imported_memory(index);
@@ -556,20 +556,20 @@ impl Instance {
         ExportMemory {
             definition,
             vmctx,
-            memory: self.module().memory_plans[index].clone(),
+            memory: self.env_module().memory_plans[index].clone(),
             index: def_index,
         }
     }
 
     fn get_exported_global(&mut self, index: GlobalIndex) -> ExportGlobal {
         ExportGlobal {
-            definition: if let Some(def_index) = self.module().defined_global_index(index) {
+            definition: if let Some(def_index) = self.env_module().defined_global_index(index) {
                 self.global_ptr(def_index)
             } else {
                 self.imported_global(index).from
             },
             vmctx: self.vmctx(),
-            global: self.module().globals[index],
+            global: self.env_module().globals[index],
         }
     }
 
@@ -579,7 +579,7 @@ impl Instance {
     /// are export names, and the values are export declarations which can be
     /// resolved `lookup_by_declaration`.
     pub fn exports(&self) -> wasmparser::collections::index_map::Iter<String, EntityIndex> {
-        self.module().exports.iter()
+        self.env_module().exports.iter()
     }
 
     /// Return a reference to the custom state attached to this instance.
@@ -603,7 +603,7 @@ impl Instance {
 
     /// Get the given memory's page size, in bytes.
     pub(crate) fn memory_page_size(&self, index: MemoryIndex) -> usize {
-        usize::try_from(self.module().memory_plans[index].memory.page_size()).unwrap()
+        usize::try_from(self.env_module().memory_plans[index].memory.page_size()).unwrap()
     }
 
     /// Grow memory by the specified amount of pages.
@@ -616,7 +616,7 @@ impl Instance {
         index: MemoryIndex,
         delta: u64,
     ) -> Result<Option<usize>, Error> {
-        match self.module().defined_memory_index(index) {
+        match self.env_module().defined_memory_index(index) {
             Some(idx) => self.defined_memory_grow(idx, delta),
             None => {
                 let import = self.imported_memory(index);
@@ -721,7 +721,7 @@ impl Instance {
             *base.add(sig.index())
         };
 
-        let func_ref = if let Some(def_index) = self.module().defined_func_index(index) {
+        let func_ref = if let Some(def_index) = self.env_module().defined_func_index(index) {
             VMFuncRef {
                 array_call: self
                     .runtime_info
@@ -786,7 +786,7 @@ impl Instance {
             // expensive, so it's better for instantiation performance
             // if we don't have to track "is-initialized" state at
             // all!
-            let func = &self.module().functions[index];
+            let func = &self.env_module().functions[index];
             let sig = func.signature;
             let func_ref: *mut VMFuncRef = self
                 .vmctx_plus_offset_mut::<VMFuncRef>(self.offsets().vmctx_func_ref(func.func_ref));
@@ -814,7 +814,7 @@ impl Instance {
         // TODO: this `clone()` shouldn't be necessary but is used for now to
         // inform `rustc` that the lifetime of the elements here are
         // disconnected from the lifetime of `self`.
-        let module = self.module().clone();
+        let module = self.env_module().clone();
 
         // NB: fall back to an expressions-based list of elements which doesn't
         // have static type information (as opposed to `Functions`) since we
@@ -846,7 +846,7 @@ impl Instance {
         let table = unsafe { &mut *self.get_table(table_index) };
         let src = usize::try_from(src).map_err(|_| Trap::TableOutOfBounds)?;
         let len = usize::try_from(len).map_err(|_| Trap::TableOutOfBounds)?;
-        let module = self.module().clone();
+        let module = self.env_module().clone();
 
         match elements {
             TableSegmentElements::Functions(funcs) => {
@@ -1015,7 +1015,7 @@ impl Instance {
         src: u32,
         len: u32,
     ) -> Result<(), Trap> {
-        let range = match self.module().passive_data_map.get(&data_index).cloned() {
+        let range = match self.env_module().passive_data_map.get(&data_index).cloned() {
             Some(range) if !self.dropped_data.contains(data_index) => range,
             _ => 0..0,
         };
@@ -1117,7 +1117,7 @@ impl Instance {
                 // determine the function that is going to be initialized. Note
                 // that `i` may be outside the limits of the static
                 // initialization so it's a fallible `get` instead of an index.
-                let module = self.module();
+                let module = self.env_module();
                 let precomputed = match &module.table_initialization.initial_values[idx] {
                     TableInitialValue::Null { precomputed } => precomputed,
                     TableInitialValue::Expr(_) => unreachable!(),
@@ -1155,7 +1155,7 @@ impl Instance {
         index: TableIndex,
         f: impl FnOnce(DefinedTableIndex, &mut Instance) -> R,
     ) -> R {
-        if let Some(defined_table_index) = self.module().defined_table_index(index) {
+        if let Some(defined_table_index) = self.env_module().defined_table_index(index) {
             f(defined_table_index, self)
         } else {
             let import = self.imported_table(index);
@@ -1181,7 +1181,7 @@ impl Instance {
         store: StorePtr,
         imports: Imports,
     ) {
-        assert!(ptr::eq(module, self.module().as_ref()));
+        assert!(ptr::eq(module, self.env_module().as_ref()));
 
         *self.vmctx_plus_offset_mut(offsets.ptr.vmctx_magic()) = VMCONTEXT_MAGIC;
         self.set_callee(None);
@@ -1328,7 +1328,7 @@ impl InstanceHandle {
 
     /// Return a reference to a module.
     pub fn module(&self) -> &Arc<Module> {
-        self.instance().module()
+        self.instance().env_module()
     }
 
     /// Lookup a function by index.
@@ -1387,7 +1387,7 @@ impl InstanceHandle {
         index: DefinedTableIndex,
         range: impl Iterator<Item = u64>,
     ) -> *mut Table {
-        let index = self.instance().module().table_index(index);
+        let index = self.instance().env_module().table_index(index);
         self.instance_mut().get_table_with_lazy_init(index, range)
     }
 

crates/wasmtime/src/runtime/vm/instance/allocator.rs

@@ -372,7 +372,7 @@ pub trait InstanceAllocator: InstanceAllocatorImpl {
         &self,
         mut request: InstanceAllocationRequest,
     ) -> Result<InstanceHandle> {
-        let module = request.runtime_info.module();
+        let module = request.runtime_info.env_module();
 
         #[cfg(debug_assertions)]
         InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
@@ -438,7 +438,7 @@ pub trait InstanceAllocator: InstanceAllocatorImpl {
         request: &mut InstanceAllocationRequest,
         memories: &mut PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
     ) -> Result<()> {
-        let module = request.runtime_info.module();
+        let module = request.runtime_info.env_module();
 
         #[cfg(debug_assertions)]
         InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
@@ -490,7 +490,7 @@ pub trait InstanceAllocator: InstanceAllocatorImpl {
         request: &mut InstanceAllocationRequest,
         tables: &mut PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
     ) -> Result<()> {
-        let module = request.runtime_info.module();
+        let module = request.runtime_info.env_module();
 
         #[cfg(debug_assertions)]
         InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
@@ -636,7 +636,7 @@ fn get_memory_init_start(
     let mut context = ConstEvalContext::new(instance, module);
     let mut const_evaluator = ConstExprEvaluator::default();
     unsafe { const_evaluator.eval(&mut context, &init.offset) }.map(|v| {
-        match instance.module().memory_plans[init.memory_index]
+        match instance.env_module().memory_plans[init.memory_index]
             .memory
             .idx_type
         {
@@ -706,7 +706,10 @@ fn initialize_memories(instance: &mut Instance, module: &Module) -> Result<()> {
             let val = unsafe { self.const_evaluator.eval(&mut context, expr) }
                 .expect("const expression should be valid");
             Some(
-                match self.instance.module().memory_plans[memory].memory.idx_type {
+                match self.instance.env_module().memory_plans[memory]
+                    .memory
+                    .idx_type
+                {
                     wasmtime_environ::IndexType::I32 => val.get_u32().into(),
                     wasmtime_environ::IndexType::I64 => val.get_u64(),
                 },