Description: use older versions of wasm-tools crates
 This essentially reverts upstream git commit 7c96aa1.
Author: Jonas Smedegaard <dr@jones.dk>
Bug-Debian: https://bugs.debian.org/1095699
Forwarded: not-needed
Last-Update: 2025-11-14
---
This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
--- a/crates/cranelift/src/func_environ.rs
+++ b/crates/cranelift/src/func_environ.rs
@@ -17,7 +17,7 @@
 use cranelift_frontend::Variable;
 use smallvec::SmallVec;
 use std::mem;
-use wasmparser::{Operator, WasmFeatures};
+use wasmparser::Operator;
 use wasmtime_environ::{
     BuiltinFunctionIndex, DataIndex, ElemIndex, EngineOrModuleTypeIndex, FuncIndex, GlobalIndex,
     IndexType, Memory, MemoryIndex, Module, ModuleInternedTypeIndex, ModuleTranslation,
@@ -1317,7 +1317,6 @@
     /// Do an indirect call through the given funcref table.
     pub fn indirect_call(
         mut self,
-        features: &WasmFeatures,
         table_index: TableIndex,
         ty_index: TypeIndex,
         sig_ref: ir::SigRef,
@@ -1325,7 +1324,6 @@
         call_args: &[ir::Value],
     ) -> WasmResult<Option<ir::Inst>> {
         let (code_ptr, callee_vmctx) = match self.check_and_load_code_and_callee_vmctx(
-            features,
             table_index,
             ty_index,
             callee,
@@ -1341,7 +1339,6 @@
 
     fn check_and_load_code_and_callee_vmctx(
         &mut self,
-        features: &WasmFeatures,
         table_index: TableIndex,
         ty_index: TypeIndex,
         callee: ir::Value,
@@ -1356,8 +1353,7 @@
         );
 
         // If necessary, check the signature.
-        let check =
-            self.check_indirect_call_type_signature(features, table_index, ty_index, funcref_ptr);
+        let check = self.check_indirect_call_type_signature(table_index, ty_index, funcref_ptr);
 
         let trap_code = match check {
             // `funcref_ptr` is checked at runtime that its type matches,
@@ -1391,7 +1387,6 @@
 
     fn check_indirect_call_type_signature(
         &mut self,
-        features: &WasmFeatures,
         table_index: TableIndex,
         ty_index: TypeIndex,
         funcref_ptr: ir::Value,
@@ -1423,40 +1418,33 @@
                     };
                 }
 
-                if features.gc() {
-                    // If we are in the Wasm GC world, then we need to perform
-                    // an actual subtype check at runtime. Fall through to below
-                    // to do that.
-                } else {
-                    // Otherwise if the types don't match then either (a) this
-                    // is a null pointer or (b) it's a pointer with the wrong
-                    // type. Figure out which and trap here.
-                    //
-                    // If it's possible to have a null here then try to load the
-                    // type information. If that fails due to the function being
-                    // a null pointer, then this was a call to null. Otherwise
-                    // if it succeeds then we know it won't match, so trap
-                    // anyway.
-                    if table.ref_type.nullable {
-                        if self.env.signals_based_traps() {
-                            let mem_flags = ir::MemFlags::trusted().with_readonly();
-                            self.builder.ins().load(
-                                sig_id_type,
-                                mem_flags.with_trap_code(Some(crate::TRAP_INDIRECT_CALL_TO_NULL)),
-                                funcref_ptr,
-                                i32::from(self.env.offsets.ptr.vm_func_ref_type_index()),
-                            );
-                        } else {
-                            self.env.trapz(
-                                self.builder,
-                                funcref_ptr,
-                                crate::TRAP_INDIRECT_CALL_TO_NULL,
-                            );
-                        }
+                // Otherwise if the types don't match then either (a) this is a
+                // null pointer or (b) it's a pointer with the wrong type.
+                // Figure out which and trap here.
+                //
+                // If it's possible to have a null here then try to load the
+                // type information. If that fails due to the function being a
+                // null pointer, then this was a call to null. Otherwise if it
+                // succeeds then we know it won't match, so trap anyway.
+                if table.ref_type.nullable {
+                    if self.env.signals_based_traps() {
+                        let mem_flags = ir::MemFlags::trusted().with_readonly();
+                        self.builder.ins().load(
+                            sig_id_type,
+                            mem_flags.with_trap_code(Some(crate::TRAP_INDIRECT_CALL_TO_NULL)),
+                            funcref_ptr,
+                            i32::from(self.env.offsets.ptr.vm_func_ref_type_index()),
+                        );
+                    } else {
+                        self.env.trapz(
+                            self.builder,
+                            funcref_ptr,
+                            crate::TRAP_INDIRECT_CALL_TO_NULL,
+                        );
                     }
-                    self.env.trap(self.builder, crate::TRAP_BAD_SIGNATURE);
-                    return CheckIndirectCallTypeSignature::StaticTrap;
                 }
+                self.env.trap(self.builder, crate::TRAP_BAD_SIGNATURE);
+                return CheckIndirectCallTypeSignature::StaticTrap;
             }
 
             // Tables of `nofunc` can only be inhabited by null, so go ahead and
@@ -1508,25 +1496,12 @@
             self.env
                 .load_funcref_type_index(&mut self.builder.cursor(), mem_flags, funcref_ptr);
 
-        // Check that they match: in the case of Wasm GC, this means doing a
-        // full subtype check. Otherwise, we do a simple equality check.
-        let matches = if features.gc() {
-            #[cfg(feature = "gc")]
-            {
-                self.env
-                    .is_subtype(self.builder, callee_sig_id, caller_sig_id)
-            }
-            #[cfg(not(feature = "gc"))]
-            {
-                unreachable!()
-            }
-        } else {
-            self.builder
-                .ins()
-                .icmp(IntCC::Equal, callee_sig_id, caller_sig_id)
-        };
-        self.env
-            .trapz(self.builder, matches, crate::TRAP_BAD_SIGNATURE);
+        // Check that they match.
+        let cmp = self
+            .builder
+            .ins()
+            .icmp(IntCC::Equal, callee_sig_id, caller_sig_id);
+        self.env.trapz(self.builder, cmp, crate::TRAP_BAD_SIGNATURE);
         CheckIndirectCallTypeSignature::Runtime
     }
 
@@ -2596,21 +2571,13 @@
     fn translate_call_indirect(
         &mut self,
         builder: &mut FunctionBuilder,
-        features: &WasmFeatures,
         table_index: TableIndex,
         ty_index: TypeIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
         call_args: &[ir::Value],
     ) -> WasmResult<Option<ir::Inst>> {
-        Call::new(builder, self).indirect_call(
-            features,
-            table_index,
-            ty_index,
-            sig_ref,
-            callee,
-            call_args,
-        )
+        Call::new(builder, self).indirect_call(table_index, ty_index, sig_ref, callee, call_args)
     }
 
     fn translate_call(
@@ -2647,7 +2614,6 @@
     fn translate_return_call_indirect(
         &mut self,
         builder: &mut FunctionBuilder,
-        features: &WasmFeatures,
         table_index: TableIndex,
         ty_index: TypeIndex,
         sig_ref: ir::SigRef,
@@ -2655,7 +2621,6 @@
         call_args: &[ir::Value],
     ) -> WasmResult<()> {
         Call::new_tail(builder, self).indirect_call(
-            features,
             table_index,
             ty_index,
             sig_ref,
--- a/crates/cranelift/src/translate/code_translator.rs
+++ b/crates/cranelift/src/translate/code_translator.rs
@@ -649,7 +649,6 @@
 
             let call = environ.translate_call_indirect(
                 builder,
-                validator.features(),
                 TableIndex::from_u32(*table_index),
                 TypeIndex::from_u32(*type_index),
                 sigref,
@@ -717,7 +716,6 @@
 
             environ.translate_return_call_indirect(
                 builder,
-                validator.features(),
                 TableIndex::from_u32(*table_index),
                 TypeIndex::from_u32(*type_index),
                 sigref,
--- a/crates/cranelift/src/translate/environ/spec.rs
+++ b/crates/cranelift/src/translate/environ/spec.rs
@@ -15,7 +15,7 @@
 use cranelift_entity::PrimaryMap;
 use cranelift_frontend::FunctionBuilder;
 use smallvec::SmallVec;
-use wasmparser::{Operator, WasmFeatures};
+use wasmparser::Operator;
 use wasmtime_environ::{
     DataIndex, ElemIndex, FuncIndex, GlobalIndex, MemoryIndex, TableIndex, Tunables, TypeConvert,
     TypeIndex, WasmHeapType, WasmRefType, WasmResult,
@@ -199,7 +199,6 @@
     fn translate_call_indirect(
         &mut self,
         builder: &mut FunctionBuilder,
-        features: &WasmFeatures,
         table_index: TableIndex,
         sig_index: TypeIndex,
         sig_ref: ir::SigRef,
@@ -239,7 +238,6 @@
     fn translate_return_call_indirect(
         &mut self,
         builder: &mut FunctionBuilder,
-        features: &WasmFeatures,
         table_index: TableIndex,
         sig_index: TypeIndex,
         sig_ref: ir::SigRef,
--- a/crates/wasmtime/src/runtime/vm/libcalls.rs
+++ b/crates/wasmtime/src/runtime/vm/libcalls.rs
@@ -1022,14 +1022,11 @@
     let actual = VMSharedTypeIndex::from_u32(actual_engine_type);
     let expected = VMSharedTypeIndex::from_u32(expected_engine_type);
 
-    let is_subtype: bool = store
+    store
         .engine()
         .signatures()
         .is_subtype(actual, expected)
-        .into();
-
-    log::trace!("is_subtype(actual={actual:?}, expected={expected:?}) -> {is_subtype}",);
-    is_subtype
+        .into()
 }
 
 // Implementation of `memory.atomic.notify` for locally defined memories.
--- a/tests/wast.rs
+++ b/tests/wast.rs
@@ -60,6 +60,15 @@
                     trials.push(trial);
                 }
             }
+            if unsupported_gc_tests.iter().any(|i| test.ends_with(i)) {
+                return true;
+            }
+        }
+
+        // Implementation of the GC proposal is a work-in-progress, this is
+        // a list of all currently known-to-fail tests.
+        if part == "gc" {
+            return unsupported_gc_tests.iter().any(|i| test.ends_with(i));
         }
     }
 
--- a/crates/wast-util/src/lib.rs
+++ b/crates/wast-util/src/lib.rs
@@ -407,6 +407,8 @@
             }
         }
 
+        let unsupported_gc_tests = ["type-subtyping.wast"];
+
         for part in self.path.iter() {
             // Not implemented in Wasmtime yet
             if part == "exception-handling" {