Merge remote-tracking branch 'upstream/main'

alexcrichton · alexcrichton · commit 853f1f8d37be · 2025-06-06T09:56:53.000-07:00
diff --git a/cranelift/assembler-x64/meta/src/instructions/avg.rs b/cranelift/assembler-x64/meta/src/instructions/avg.rs
@@ -10,7 +10,5 @@ pub fn list() -> Vec<Inst> {
         // AVX versions
         inst("vpavgb", fmt("B", [w(xmm1), r(xmm2), r(xmm_m128)]), vex(L128)._66()._0f().op(0xE0), _64b | compat | avx),
         inst("vpavgw", fmt("B", [w(xmm1), r(xmm2), r(xmm_m128)]), vex(L128)._66()._0f().op(0xE3), _64b | compat | avx),
-
-
     ]
 }
diff --git a/cranelift/assembler-x64/meta/src/instructions/div.rs b/cranelift/assembler-x64/meta/src/instructions/div.rs
@@ -1,5 +1,5 @@
-use crate::dsl::{Feature::*, Inst, Location::*, VexLength::*, align};
-use crate::dsl::{fmt, implicit, inst, r, rex, rw, vex};
+use crate::dsl::{Feature::*, Inst, Location::*, VexLength::*};
+use crate::dsl::{align, fmt, implicit, inst, r, rex, rw, vex};
 
 #[rustfmt::skip] // Keeps instructions on a single line.
 pub fn list() -> Vec<Inst> {
@@ -19,7 +19,7 @@ pub fn list() -> Vec<Inst> {
         inst("divsd", fmt("A", [rw(xmm1), r(xmm_m64)]), rex([0xF2, 0xF, 0x5E]).r(), _64b | compat | sse2),
         inst("vdivps", fmt("B", [rw(xmm1), r(xmm2), r(xmm_m128)]), vex(L128)._0f().op(0x5E).r(), _64b | compat | avx),
         inst("vdivpd", fmt("B", [rw(xmm1), r(xmm2), r(xmm_m128)]), vex(L128)._66()._0f().op(0x5E).r(), _64b | compat | avx),
-        inst("vdivss", fmt("B", [rw(xmm1), r(xmm2), r(xmm_m32)]), vex(L128)._f3()._0f().op(0x5E).r(), _64b | compat | avx),
-        inst("vdivsd", fmt("B", [rw(xmm1), r(xmm2), r(xmm_m64)]), vex(L128)._f2()._0f().op(0x5E).r(), _64b | compat | avx),
+        inst("vdivss", fmt("B", [rw(xmm1), r(xmm2), r(xmm_m32)]), vex(LIG)._f3()._0f().op(0x5E).r(), _64b | compat | avx),
+        inst("vdivsd", fmt("B", [rw(xmm1), r(xmm2), r(xmm_m64)]), vex(LIG)._f2()._0f().op(0x5E).r(), _64b | compat | avx),
     ]
 }
diff --git a/cranelift/assembler-x64/meta/src/instructions/round.rs b/cranelift/assembler-x64/meta/src/instructions/round.rs
@@ -14,6 +14,5 @@ pub fn list() -> Vec<Inst> {
         inst("vroundps", fmt("RMI", [w(xmm1), r(xmm_m128), r(imm8)]), vex(L128)._66()._0f3a().ib().op(0x08), _64b | compat | avx),
         inst("vroundsd", fmt("RVMI", [w(xmm1), r(xmm2), r(xmm_m64), r(imm8)]), vex(LIG)._66()._0f3a().ib().op(0x0b), _64b | compat | avx),
         inst("vroundss", fmt("RVMI", [w(xmm1), r(xmm2), r(xmm_m32), r(imm8)]), vex(LIG)._66()._0f3a().ib().op(0x0a), _64b | compat | avx),
-
-        ]
+   ]
 }
diff --git a/cranelift/codegen/src/legalizer/mod.rs b/cranelift/codegen/src/legalizer/mod.rs
@@ -55,8 +55,6 @@ pub fn simple_legalize(func: &mut ir::Function, isa: &dyn TargetIsa) {
     trace!("Pre-legalization function:\n{}", func.display());
 
     let mut pos = FuncCursor::new(func);
-    let func_begin = pos.position();
-    pos.set_position(func_begin);
     while let Some(_block) = pos.next_block() {
         let mut prev_pos = pos.position();
         while let Some(inst) = pos.next_inst() {
diff --git a/cranelift/codegen/src/opts/icmp.isle b/cranelift/codegen/src/opts/icmp.isle
@@ -288,5 +288,5 @@
       (slt ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
 
 
-(rule (simplify (eq cty x (bxor bty x y))) (subsume (eq cty y (iconst_u bty 0))))
-(rule (simplify (ne cty x (bxor bty x y))) (subsume (ne cty y (iconst_u bty 0))))
+(rule (simplify (eq cty x (bxor (ty_int bty) x y))) (subsume (eq cty y (iconst_u bty 0))))
+(rule (simplify (ne cty x (bxor (ty_int bty) x y))) (subsume (ne cty y (iconst_u bty 0))))
diff --git a/cranelift/filetests/filetests/egraph/icmp.clif b/cranelift/filetests/filetests/egraph/icmp.clif
@@ -201,3 +201,25 @@ block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v1, v4  ; v4 = 0
 ;     return v5
 ; }
+
+function %issue_10929_no_crash_on_icmp_vectors() -> i32x4 {
+  const0 = 0x40ad3fb47cb16076c8cb1fdd8189d40f
+
+block0():
+  v1 = vconst.i32x4 const0
+  v2 = bxor_not v1, v1
+  v3 = icmp.i32x4 ne v1, v2
+  return v3
+}
+
+; function %issue_10929_no_crash_on_icmp_vectors() -> i32x4 fast {
+;     const0 = 0x40ad3fb47cb16076c8cb1fdd8189d40f
+;
+; block0:
+;     v1 = vconst.i32x4 const0
+;     v4 = bnot v1  ; v1 = const0
+;     v2 = bxor v1, v4  ; v1 = const0
+;     v3 = icmp ne v1, v2  ; v1 = const0
+;     return v3
+; }
+
diff --git a/crates/environ/src/trap_encoding.rs b/crates/environ/src/trap_encoding.rs
@@ -99,10 +99,6 @@ pub enum Trap {
     /// Attempt to resume a continuation twice.
     ContinuationAlreadyConsumed,
 
-    /// FIXME(frank-emrich) Only used for stack switching debugging code, to be
-    /// removed from final upstreamed code.
-    DeleteMeDebugAssertion,
-
     /// A Pulley opcode was executed at runtime when the opcode was disabled at
     /// compile time.
     DisabledOpcode,
@@ -150,7 +146,6 @@ impl Trap {
             NoAsyncResult
             UnhandledTag
             ContinuationAlreadyConsumed
-            DeleteMeDebugAssertion
             DisabledOpcode
             AsyncDeadlock
         }
@@ -186,7 +181,6 @@ impl fmt::Display for Trap {
             NoAsyncResult => "async-lifted export failed to produce a result",
             UnhandledTag => "unhandled tag",
             ContinuationAlreadyConsumed => "continuation already consumed",
-            DeleteMeDebugAssertion => "triggered debug assertion",
             DisabledOpcode => "pulley opcode disabled at compile time was executed",
             AsyncDeadlock => "deadlock detected: event loop cannot make further progress",
         };
diff --git a/crates/wasmtime/src/runtime/component/instance.rs b/crates/wasmtime/src/runtime/component/instance.rs
@@ -53,12 +53,7 @@ const _: () = {
 
 impl Instance {
     /// Creates a raw `Instance` from the internal identifiers within the store.
-    ///
-    /// # Safety
-    ///
-    /// The safety of this function relies on `id` belonging to the instance
-    /// within `store`.
-    pub(crate) unsafe fn from_wasmtime(store: &StoreOpaque, id: ComponentInstanceId) -> Instance {
+    pub(crate) fn from_wasmtime(store: &StoreOpaque, id: ComponentInstanceId) -> Instance {
         Instance {
             id: StoreComponentInstanceId::new(store.id(), id),
         }
@@ -1003,10 +998,7 @@ impl<T: 'static> InstancePre<T> {
                 .decrement_component_instance_count();
             e
         })?;
-        // SAFETY: `from_wasmtime` requires that `id` belongs to the store
-        // provided, and it was just inserted above so the condition should be
-        // satisfied.
-        let instance = unsafe { Instance::from_wasmtime(store.0, instantiator.id) };
+        let instance = Instance::from_wasmtime(store.0, instantiator.id);
         store.0.push_component_instance(instance);
         Ok(instance)
     }
diff --git a/crates/wasmtime/src/runtime/externals/global.rs b/crates/wasmtime/src/runtime/externals/global.rs
@@ -305,7 +305,7 @@ impl Global {
         match self.kind {
             VMGlobalKind::Instance(index) => {
                 let instance = InstanceId::from_u32(self.instance);
-                let module = store.instance(instance).module();
+                let module = store.instance(instance).env_module();
                 let index = module.global_index(index);
                 &module.globals[index]
             }
@@ -363,7 +363,7 @@ impl Global {
         match self.kind {
             VMGlobalKind::Instance(index) => {
                 let instance = InstanceId::from_u32(self.instance);
-                store.instance(instance).instance().global_ptr(index)
+                store.instance(instance).global_ptr(index)
             }
             VMGlobalKind::Host(index) => unsafe {
                 NonNull::from(&mut store.host_globals()[index].get().as_mut().global)
diff --git a/crates/wasmtime/src/runtime/instance.rs b/crates/wasmtime/src/runtime/instance.rs
@@ -1,7 +1,7 @@
 use crate::linker::{Definition, DefinitionType};
 use crate::prelude::*;
 use crate::runtime::vm::{
-    Imports, ModuleRuntimeInfo, VMFuncRef, VMFunctionImport, VMGlobalImport, VMMemoryImport,
+    self, Imports, ModuleRuntimeInfo, VMFuncRef, VMFunctionImport, VMGlobalImport, VMMemoryImport,
     VMOpaqueContext, VMTableImport, VMTagImport,
 };
 use crate::store::{AllocateInstanceKind, InstanceId, StoreInstanceId, StoreOpaque};
@@ -321,10 +321,8 @@ impl Instance {
             .engine()
             .features()
             .contains(WasmFeatures::BULK_MEMORY);
-        store
-            .instance(id)
-            .clone()
-            .initialize(store, compiled_module.module(), bulk_memory)?;
+
+        vm::initialize_instance(store, id, compiled_module.module(), bulk_memory)?;
 
         Ok((instance, compiled_module.module().start_func))
     }
@@ -338,7 +336,7 @@ impl Instance {
     fn start_raw<T>(&self, store: &mut StoreContextMut<'_, T>, start: FuncIndex) -> Result<()> {
         // If a start function is present, invoke it. Make sure we use all the
         // trap-handling configuration in `store` as well.
-        let instance = &mut store.0[self.id];
+        let instance = self.id.get_mut(store.0);
         let f = instance.get_exported_func(start);
         let caller_vmctx = instance.vmctx();
         unsafe {
diff --git a/crates/wasmtime/src/runtime/memory.rs b/crates/wasmtime/src/runtime/memory.rs
@@ -658,7 +658,7 @@ impl Memory {
     }
 
     fn wasmtime_memory(&self, store: &mut StoreOpaque) -> *mut crate::runtime::vm::Memory {
-        store[self.instance].get_defined_memory(self.index)
+        self.instance.get_mut(store).get_defined_memory(self.index)
     }
 
     pub(crate) unsafe fn from_wasmtime_memory(
diff --git a/crates/wasmtime/src/runtime/store.rs b/crates/wasmtime/src/runtime/store.rs
@@ -100,6 +100,7 @@ use core::marker;
 use core::mem::{self, ManuallyDrop};
 use core::num::NonZeroU64;
 use core::ops::{Deref, DerefMut};
+use core::pin::Pin;
 use core::ptr::NonNull;
 use wasmtime_environ::{DefinedGlobalIndex, DefinedTableIndex, EntityRef, PrimaryMap, TripleExt};
 
@@ -1256,12 +1257,22 @@ impl StoreOpaque {
         }
     }
 
-    pub fn instance(&self, id: InstanceId) -> &InstanceHandle {
-        &self.instances[id].handle
+    /// Accessor from `InstanceId` to `&vm::Instance`.
+    ///
+    /// Note that if you have a `StoreInstanceId` you should use
+    /// `StoreInstanceId::get` instead. This assumes that `id` has been
+    /// validated to already belong to this store.
+    pub fn instance(&self, id: InstanceId) -> &vm::Instance {
+        self.instances[id].handle.get()
     }
 
-    pub fn instance_mut(&mut self, id: InstanceId) -> &mut InstanceHandle {
-        &mut self.instances[id].handle
+    /// Accessor from `InstanceId` to `Pin<&mut vm::Instance>`.
+    ///
+    /// Note that if you have a `StoreInstanceId` you should use
+    /// `StoreInstanceId::get_mut` instead. This assumes that `id` has been
+    /// validated to already belong to this store.
+    pub fn instance_mut(&mut self, id: InstanceId) -> Pin<&mut vm::Instance> {
+        self.instances[id].handle.get_mut()
     }
 
     /// Get all instances (ignoring dummy instances) within this store.
@@ -1290,7 +1301,7 @@ impl StoreOpaque {
         let mems = self
             .instances
             .iter_mut()
-            .flat_map(|(_, instance)| instance.handle.instance().defined_memories())
+            .flat_map(|(_, instance)| instance.handle.get().defined_memories())
             .collect::<Vec<_>>();
         mems.into_iter()
             .map(|memory| unsafe { Memory::from_wasmtime_memory(memory, self) })
@@ -1303,7 +1314,7 @@ impl StoreOpaque {
         // dummy instances) and getting each of their defined memories.
         for id in self.instances.keys() {
             let instance = StoreInstanceId::new(self.id(), id);
-            for table in 0..self.instance(id).module().num_defined_tables() {
+            for table in 0..self.instance(id).env_module().num_defined_tables() {
                 let table = DefinedTableIndex::new(table);
                 f(self, Table::from_raw(instance, table));
             }
@@ -1320,7 +1331,7 @@ impl StoreOpaque {
 
         // Then enumerate all instances' defined globals.
         for id in self.instances.keys() {
-            for index in 0..self.instance(id).module().num_defined_globals() {
+            for index in 0..self.instance(id).env_module().num_defined_globals() {
                 let index = DefinedGlobalIndex::new(index);
                 let global = Global::new_instance(self, id, index);
                 f(self, global);
@@ -1814,7 +1825,7 @@ impl StoreOpaque {
         // a quicker lookup.
         let mut fault = None;
         for (_, instance) in self.instances.iter() {
-            if let Some(f) = instance.handle.wasm_fault(addr) {
+            if let Some(f) = instance.handle.get().wasm_fault(addr) {
                 assert!(fault.is_none());
                 fault = Some(f);
             }
diff --git a/crates/wasmtime/src/runtime/store/data.rs b/crates/wasmtime/src/runtime/store/data.rs
@@ -3,6 +3,7 @@ use crate::store::StoreOpaque;
 use crate::{StoreContext, StoreContextMut};
 use core::num::NonZeroU64;
 use core::ops::{Index, IndexMut};
+use core::pin::Pin;
 
 // This is defined here, in a private submodule, so we can explicitly reexport
 // it only as `pub(crate)`. This avoids a ton of
@@ -229,22 +230,33 @@ impl StoreInstanceId {
     pub(crate) fn instance(&self) -> InstanceId {
         self.instance
     }
+
+    /// Looks up the `vm::Instance` within `store` that this id points to.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` does not belong to `store`.
+    pub(crate) fn get<'a>(&self, store: &'a StoreOpaque) -> &'a vm::Instance {
+        self.assert_belongs_to(store.id());
+        store.instance(self.instance)
+    }
+
+    /// Mutable version of `get` above.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` does not belong to `store`.
+    pub(crate) fn get_mut<'a>(&self, store: &'a mut StoreOpaque) -> Pin<&'a mut vm::Instance> {
+        self.assert_belongs_to(store.id());
+        store.instance_mut(self.instance)
+    }
 }
 
 impl Index<StoreInstanceId> for StoreOpaque {
     type Output = vm::Instance;
 
     #[inline]
     fn index(&self, id: StoreInstanceId) -> &Self::Output {
-        id.assert_belongs_to(self.id());
-        self.instance(id.instance).instance()
-    }
-}
-
-impl IndexMut<StoreInstanceId> for StoreOpaque {
-    #[inline]
-    fn index_mut(&mut self, id: StoreInstanceId) -> &mut Self::Output {
-        id.assert_belongs_to(self.id());
-        self.instance_mut(id.instance).instance_mut()
+        id.get(self)
     }
 }
diff --git a/crates/wasmtime/src/runtime/vm.rs b/crates/wasmtime/src/runtime/vm.rs
@@ -93,7 +93,7 @@ pub use crate::runtime::vm::imports::Imports;
 pub use crate::runtime::vm::instance::{
     GcHeapAllocationIndex, Instance, InstanceAllocationRequest, InstanceAllocator,
     InstanceAllocatorImpl, InstanceAndStore, InstanceHandle, MemoryAllocationIndex,
-    OnDemandInstanceAllocator, StorePtr, TableAllocationIndex,
+    OnDemandInstanceAllocator, StorePtr, TableAllocationIndex, initialize_instance,
 };
 #[cfg(feature = "pooling-allocator")]
 pub use crate::runtime::vm::instance::{
diff --git a/crates/wasmtime/src/runtime/vm/component.rs b/crates/wasmtime/src/runtime/vm/component.rs
@@ -820,9 +820,9 @@ impl ComponentInstance {
             // during that phase so the actual instantiation of an `InstancePre`
             // skips all string lookups. This should probably only be
             // investigated if this becomes a performance issue though.
-            ExportItem::Name(name) => instance.module().exports[name],
+            ExportItem::Name(name) => instance.env_module().exports[name],
         };
-        instance.instance().get_export_by_index(idx)
+        instance.get_export_by_index(idx)
     }
 
     /// Looks up the value used for `import` at runtime.
diff --git a/crates/wasmtime/src/runtime/vm/const_expr.rs b/crates/wasmtime/src/runtime/vm/const_expr.rs
diff --git a/crates/wasmtime/src/runtime/vm/instance.rs b/crates/wasmtime/src/runtime/vm/instance.rs
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator.rs b/crates/wasmtime/src/runtime/vm/instance/allocator.rs
diff --git a/crates/wasmtime/src/runtime/vm/libcalls.rs b/crates/wasmtime/src/runtime/vm/libcalls.rs
diff --git a/crates/wasmtime/src/runtime/vm/stack_switching.rs b/crates/wasmtime/src/runtime/vm/stack_switching.rs
diff --git a/tests/disas/issue-10929-v128-icmp-egraphs.wat b/tests/disas/issue-10929-v128-icmp-egraphs.wat

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,5 @@ pub fn list() -> Vec<Inst> {`
`10`	`10`	`// AVX versions`
`11`	`11`	`inst("vpavgb", fmt("B", [w(xmm1), r(xmm2), r(xmm_m128)]), vex(L128)._66()._0f().op(0xE0), _64b \| compat \| avx),`
`12`	`12`	`inst("vpavgw", fmt("B", [w(xmm1), r(xmm2), r(xmm_m128)]), vex(L128)._66()._0f().op(0xE3), _64b \| compat \| avx),`
`13`		`-`
`14`		`-`
`15`	`13`	`]`
`16`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,5 @@ pub fn list() -> Vec<Inst> {`
`14`	`14`	`inst("vroundps", fmt("RMI", [w(xmm1), r(xmm_m128), r(imm8)]), vex(L128)._66()._0f3a().ib().op(0x08), _64b \| compat \| avx),`
`15`	`15`	`inst("vroundsd", fmt("RVMI", [w(xmm1), r(xmm2), r(xmm_m64), r(imm8)]), vex(LIG)._66()._0f3a().ib().op(0x0b), _64b \| compat \| avx),`
`16`	`16`	`inst("vroundss", fmt("RVMI", [w(xmm1), r(xmm2), r(xmm_m32), r(imm8)]), vex(LIG)._66()._0f3a().ib().op(0x0a), _64b \| compat \| avx),`
`17`		`-`
`18`		`- ]`
	`17`	`+ ]`
`19`	`18`	`}`