generate precise traps in component adapters (#12215)

* generate precise traps in component adapters

Previously, we generated a generic `unreachable` instruction for each trap in a
fused adapter, plus some metadata to recover the specific kind of trap.
However, that metadata was never hooked up to anything, so we only got a generic
`unreachable` message at runtime.

This commit removes the metadata tracking and instead simply calls a host
intrinsic, passing the trap code as a parameter.  This is somewhate pessimal
compared with what we had before, but improves ergonomics and allows us to avoid
forking as many tests from the component-model repo.

If performance becomes an issue, we can easily add an option to skip the host
call and only emit an `unreachable` instruction as before.

Note that I've removed forked versions of three tests in favor of their upstream
equivalents.

Fixes #11683

* update `strings.rs` tests

* bless disas tests

Author: dicej

crates/cranelift/src/compiler/component.rs

@@ -171,7 +171,7 @@ impl<'a> TrampolineCompiler<'a> {
                     WasmArgs::InRegisters,
                     |me, params| {
                         let code = wasmtime_environ::Trap::AlwaysTrapAdapter as u8;
-                        params.push(me.builder.ins().iconst(ir::types::I8, i64::from(code)));
+                        params.push(me.builder.ins().iconst(ir::types::I32, i64::from(code)));
                     },
                 );
             }
@@ -740,6 +740,14 @@ impl<'a> TrampolineCompiler<'a> {
                     |_, _| {},
                 );
             }
+            Trampoline::Trap => {
+                self.translate_libcall(
+                    host::trap,
+                    TrapSentinel::Falsy,
+                    WasmArgs::InRegisters,
+                    |_, _| {},
+                );
+            }
             Trampoline::ContextGet { instance, slot } => {
                 self.translate_libcall(
                     host::context_get,

crates/environ/src/component.rs

@@ -203,7 +203,7 @@ macro_rules! foreach_builtin_component_function {
             #[cfg(feature = "component-model-async")]
             thread_yield_to(vmctx: vmctx, caller_instance: u32, cancellable: u8, thread_idx: u32) -> u32;
 
-            trap(vmctx: vmctx, code: u8) -> bool;
+            trap(vmctx: vmctx, code: u32) -> bool;
 
             utf8_to_utf8(vmctx: vmctx, src: ptr_u8, len: size, dst: ptr_u8) -> bool;
             utf16_to_utf16(vmctx: vmctx, src: ptr_u16, len: size, dst: ptr_u16) -> bool;

crates/environ/src/component/dfg.rs

@@ -476,6 +476,7 @@ pub enum Trampoline {
     StreamTransfer,
     ErrorContextTransfer,
     CheckBlocking,
+    Trap,
     ContextGet {
         instance: RuntimeComponentInstanceIndex,
         slot: u32,
@@ -1156,6 +1157,7 @@ impl LinearizeDfg<'_> {
             Trampoline::StreamTransfer => info::Trampoline::StreamTransfer,
             Trampoline::ErrorContextTransfer => info::Trampoline::ErrorContextTransfer,
             Trampoline::CheckBlocking => info::Trampoline::CheckBlocking,
+            Trampoline::Trap => info::Trampoline::Trap,
             Trampoline::ContextGet { instance, slot } => info::Trampoline::ContextGet {
                 instance: *instance,
                 slot: *slot,

crates/environ/src/component/info.rs

@@ -1109,6 +1109,10 @@ pub enum Trampoline {
     /// async-typed function may be called via a sync lower.
     CheckBlocking,
 
+    /// An intrinsic used by FACT-generated modules to trap with a specified
+    /// code.
+    Trap,
+
     /// Intrinsic used to implement the `context.get` component model builtin.
     ///
     /// The payload here represents that this is accessing the Nth slot of local
@@ -1239,6 +1243,7 @@ impl Trampoline {
             StreamTransfer => format!("stream-transfer"),
             ErrorContextTransfer => format!("error-context-transfer"),
             CheckBlocking => format!("check-blocking"),
+            Trap => format!("trap"),
             ContextGet { .. } => format!("context-get"),
             ContextSet { .. } => format!("context-set"),
             ThreadIndex => format!("thread-index"),

crates/environ/src/component/translate/adapt.rs

@@ -346,6 +346,7 @@ fn fact_import_to_core_def(
             simple_intrinsic(dfg::Trampoline::ErrorContextTransfer)
         }
         fact::Import::CheckBlocking => simple_intrinsic(dfg::Trampoline::CheckBlocking),
+        fact::Import::Trap => simple_intrinsic(dfg::Trampoline::Trap),
     }
 }
 

crates/environ/src/fact.rs

@@ -26,15 +26,13 @@ use crate::component::{
 use crate::fact::transcode::Transcoder;
 use crate::{EntityRef, FuncIndex, GlobalIndex, MemoryIndex, PrimaryMap};
 use crate::{ModuleInternedTypeIndex, prelude::*};
-use std::borrow::Cow;
 use std::collections::HashMap;
 use wasm_encoder::*;
 
 mod core_types;
 mod signature;
 mod trampoline;
 mod transcode;
-mod traps;
 
 /// Fixed parameter types for the `prepare_call` built-in function.
 ///
@@ -92,6 +90,8 @@ pub struct Module<'a> {
 
     imported_check_blocking: Option<FuncIndex>,
 
+    imported_trap: Option<FuncIndex>,
+
     // Current status of index spaces from the imports generated so far.
     imported_funcs: PrimaryMap<FuncIndex, Option<CoreDef>>,
     imported_memories: PrimaryMap<MemoryIndex, CoreDef>,
@@ -263,6 +263,7 @@ impl<'a> Module<'a> {
             imported_stream_transfer: None,
             imported_error_context_transfer: None,
             imported_check_blocking: None,
+            imported_trap: None,
             exports: Vec::new(),
         }
     }
@@ -727,6 +728,17 @@ impl<'a> Module<'a> {
         )
     }
 
+    fn import_trap(&mut self) -> FuncIndex {
+        self.import_simple(
+            "runtime",
+            "trap",
+            &[ValType::I32],
+            &[],
+            Import::Trap,
+            |me| &mut me.imported_trap,
+        )
+    }
+
     fn translate_helper(&mut self, helper: Helper) -> FunctionId {
         *self.helper_funcs.entry(helper).or_insert_with(|| {
             // Generate a fresh `Function` with a unique id for what we're about to
@@ -765,9 +777,7 @@ impl<'a> Module<'a> {
         // With all functions numbered the fragments of the body of each
         // function can be assigned into one final adapter function.
         let mut code = CodeSection::new();
-        let mut traps = traps::TrapSection::default();
-        for (id, func) in self.funcs.iter() {
-            let mut func_traps = Vec::new();
+        for (_, func) in self.funcs.iter() {
             let mut body = Vec::new();
 
             // Encode all locals used for this function
@@ -783,12 +793,8 @@ impl<'a> Module<'a> {
             // here to the final function index.
             for chunk in func.body.iter() {
                 match chunk {
-                    Body::Raw(code, traps) => {
-                        let start = body.len();
+                    Body::Raw(code) => {
                         body.extend_from_slice(code);
-                        for (offset, trap) in traps {
-                            func_traps.push((start + offset, *trap));
-                        }
                     }
                     Body::Call(id) => {
                         Instruction::Call(id_to_index[*id].as_u32()).encode(&mut body);
@@ -799,23 +805,14 @@ impl<'a> Module<'a> {
                 }
             }
             code.raw(&body);
-            traps.append(id_to_index[id].as_u32(), func_traps);
         }
 
-        let traps = traps.finish();
-
         let mut result = wasm_encoder::Module::new();
         result.section(&self.core_types.section);
         result.section(&self.core_imports);
         result.section(&funcs);
         result.section(&exports);
         result.section(&code);
-        if self.debug {
-            result.section(&CustomSection {
-                name: "wasmtime-trampoline-traps".into(),
-                data: Cow::Borrowed(&traps),
-            });
-        }
         result.finish()
     }
 
@@ -888,6 +885,8 @@ pub enum Import {
     /// An intrinsic used by FACT-generated modules to check whether an
     /// async-typed function may be called via a sync lower.
     CheckBlocking,
+    /// An intrinsic for trapping the instance with a specific trap code.
+    Trap,
 }
 
 impl Options {
@@ -954,8 +953,6 @@ struct Function {
 ///
 /// 1. First a `Raw` variant is used to contain general instructions for the
 ///    wasm function. This is populated by `Compiler::instruction` primarily.
-///    This also comes with a list of traps. and the byte offset within the
-///    first vector of where the trap information applies to.
 ///
 /// 2. A `Call` instruction variant for a `FunctionId` where the final
 ///    `FuncIndex` isn't known until emission time.
@@ -971,7 +968,7 @@ struct Function {
 /// easier to represent. A 5-byte leb may be more efficient at compile-time if
 /// necessary, however.
 enum Body {
-    Raw(Vec<u8>, Vec<(usize, traps::Trap)>),
+    Raw(Vec<u8>),
     Call(FunctionId),
     RefFunc(FunctionId),
 }