pull in PR 3612

lib/api/src/js/function_env.rs

@@ -124,6 +124,17 @@ impl<T: Send + 'static> FunctionEnvMut<'_, T> {
             func_env: self.func_env.clone(),
         }
     }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        let data = self.func_env.as_mut(&mut self.store_mut) as *mut T;
+        // telling the borrow check to close his eyes here
+        // this is still relatively safe to do as func_env are
+        // stored in a specific vec of Store, separate from the other objects
+        // and not really directly accessible with the StoreMut
+        let data = unsafe { &mut *data };
+        (data, self.store_mut.as_store_mut())
+    }
 }
 
 impl<T> AsStoreRef for FunctionEnvMut<'_, T> {

lib/api/src/sys/externals/global.rs

@@ -1,11 +1,13 @@
+use std::ptr::NonNull;
+
 use crate::sys::exports::{ExportError, Exportable};
 use crate::sys::externals::Extern;
 use crate::sys::store::{AsStoreMut, AsStoreRef};
 use crate::sys::value::Value;
 use crate::sys::GlobalType;
 use crate::sys::Mutability;
 use crate::sys::RuntimeError;
-use wasmer_vm::{InternalStoreHandle, StoreHandle, VMExtern, VMGlobal};
+use wasmer_vm::{InternalStoreHandle, StoreHandle, VMExtern, VMGlobal, VMGlobalDefinition};
 
 /// A WebAssembly `global` instance.
 ///
@@ -110,13 +112,9 @@ impl Global {
     /// ```
     pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
         unsafe {
-            let raw = self
-                .handle
-                .get(store.as_store_ref().objects())
-                .vmglobal()
-                .as_ref()
-                .val;
-            let ty = self.handle.get(store.as_store_ref().objects()).ty().ty;
+            let global = self.handle.get(store.as_store_ref().objects());
+            let raw = global.vmglobal().as_ref().val;
+            let ty = global.ty().ty;
             Value::from_raw(store, ty, raw)
         }
     }
@@ -168,22 +166,20 @@ impl Global {
                 "cross-`Context` values are not supported",
             ));
         }
-        if self.ty(store).mutability != Mutability::Var {
+        let global = self.handle.get_mut(store.objects_mut());
+        if global.ty().mutability != Mutability::Var {
             return Err(RuntimeError::new("Attempted to set an immutable global"));
         }
-        if val.ty() != self.ty(store).ty {
+        if val.ty() != global.ty().ty {
             return Err(RuntimeError::new(format!(
                 "Attempted to operate on a global of type {expected} as a global of type {found}",
-                expected = self.ty(store).ty,
+                expected = global.ty().ty,
                 found = val.ty(),
             )));
         }
         unsafe {
-            self.handle
-                .get_mut(store.objects_mut())
-                .vmglobal()
-                .as_mut()
-                .val = val.as_raw(store);
+            let mut dest = global.vmglobal();
+            dest.as_mut().val = val.as_raw(store);
         }
         Ok(())
     }
@@ -207,6 +203,11 @@ impl Global {
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
         VMExtern::Global(self.handle.internal_handle())
     }
+
+    /// Gets the underlying VM pointer
+    pub unsafe fn vmglobal(&self, store: &mut impl AsStoreMut) -> NonNull<VMGlobalDefinition> {
+        self.handle.get_mut(store.objects_mut()).vmglobal()
+    }
 }
 
 impl std::cmp::PartialEq for Global {

lib/api/src/sys/function_env.rs

@@ -117,6 +117,18 @@ impl<T: Send + 'static> FunctionEnvMut<'_, T> {
             func_env: self.func_env.clone(),
         }
     }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        let data = self.func_env.as_mut(&mut self.store_mut) as *mut T;
+        // telling the borrow check to close his eyes here
+
+        // this is still relatively safe to do as func_env are
+        // stored in a specific vec of Store, separate from the other objects
+        // and not really directly accessible with the StoreMut
+        let data = unsafe { &mut *data };
+        (data, self.store_mut.as_store_mut())
+    }
 }
 
 impl<T> AsStoreRef for FunctionEnvMut<'_, T> {

lib/api/src/sys/module.rs

@@ -432,7 +432,7 @@ impl Module {
     /// # }
     /// ```
     pub fn set_name(&mut self, name: &str) -> bool {
-        Arc::get_mut(&mut self.module_info).map_or(false, |mut module_info| {
+        Arc::get_mut(&mut self.module_info).map_or(false, |module_info| {
             module_info.name = Some(name.to_string());
             true
         })

lib/compiler-llvm/src/compiler.rs

@@ -264,7 +264,7 @@ impl Compiler for LLVMCompiler {
                 for (section_index, custom_section) in compiled_function.custom_sections.iter() {
                     // TODO: remove this call to clone()
                     let mut custom_section = custom_section.clone();
-                    for mut reloc in &mut custom_section.relocations {
+                    for reloc in &mut custom_section.relocations {
                         if let RelocationTarget::CustomSection(index) = reloc.reloc_target {
                             reloc.reloc_target = RelocationTarget::CustomSection(
                                 SectionIndex::from_u32(first_section + index.as_u32()),
@@ -276,7 +276,7 @@ impl Compiler for LLVMCompiler {
                         .contains(&section_index)
                     {
                         let offset = frame_section_bytes.len() as u32;
-                        for mut reloc in &mut custom_section.relocations {
+                        for reloc in &mut custom_section.relocations {
                             reloc.offset += offset;
                         }
                         frame_section_bytes.extend_from_slice(custom_section.bytes.as_slice());
@@ -291,7 +291,7 @@ impl Compiler for LLVMCompiler {
                         module_custom_sections.push(custom_section);
                     }
                 }
-                for mut reloc in &mut compiled_function.compiled_function.relocations {
+                for reloc in &mut compiled_function.compiled_function.relocations {
                     if let RelocationTarget::CustomSection(index) = reloc.reloc_target {
                         reloc.reloc_target = RelocationTarget::CustomSection(
                             SectionIndex::from_u32(first_section + index.as_u32()),

lib/compiler-singlepass/src/codegen.rs

@@ -2989,7 +2989,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 self.release_locations_value(stack_depth)?;
                 self.value_stack.truncate(stack_depth);
                 self.fp_stack.truncate(fp_depth);
-                let mut frame = &mut self.control_stack.last_mut().unwrap();
+                let frame = &mut self.control_stack.last_mut().unwrap();
 
                 match frame.if_else {
                     IfElseState::If(label) => {