Update to new APIs on Cranelift side.

cfallin · cfallin · commit 374ff4e13183 · 2025-10-06T13:02:32.000-07:00
diff --git a/crates/cranelift/src/compiled_function.rs b/crates/cranelift/src/compiled_function.rs
@@ -3,7 +3,9 @@ use cranelift_codegen::{
     Final, MachBufferFinalized, MachBufferFrameLayout, MachSrcLoc, ValueLabelsRanges, ir,
     isa::unwind::CfaUnwindInfo, isa::unwind::UnwindInfo,
 };
-use wasmtime_environ::{FilePos, InstructionAddressMap, PrimaryMap, TrapInformation};
+use wasmtime_environ::{
+    FilePos, FrameStateSlotBuilder, InstructionAddressMap, PrimaryMap, TrapInformation,
+};
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 /// Metadata to translate from binary offsets back to the original
@@ -61,6 +63,8 @@ pub struct CompiledFunction {
     /// The metadata for the compiled function, including unwind information
     /// the function address map.
     metadata: CompiledFunctionMetadata,
+    /// Debug metadata for the top-level function's state slot.
+    pub debug_slot_descriptor: Option<FrameStateSlotBuilder>,
 }
 
 impl CompiledFunction {
@@ -77,6 +81,7 @@ impl CompiledFunction {
             name_map,
             alignment,
             metadata: Default::default(),
+            debug_slot_descriptor: None,
         }
     }
 
diff --git a/crates/cranelift/src/compiler.rs b/crates/cranelift/src/compiler.rs
@@ -34,10 +34,10 @@ use wasmparser::{FuncValidatorAllocations, FunctionBody};
 use wasmtime_environ::obj::{ELF_WASMTIME_EXCEPTIONS, ELF_WASMTIME_FRAMES};
 use wasmtime_environ::{
     Abi, AddressMapSection, BuiltinFunctionIndex, CacheStore, CompileError, CompiledFunctionBody,
-    DefinedFuncIndex, FlagValue, FrameInstPos, FrameStackShape, FrameTableBuilder, FuncKey,
-    FunctionBodyData, FunctionLoc, HostCall, InliningCompiler, ModuleTranslation,
-    ModuleTypesBuilder, PtrSize, StackMapSection, StaticModuleIndex, TrapEncodingBuilder,
-    TrapSentinel, TripleExt, Tunables, VMOffsets, WasmFuncType, WasmValType,
+    DefinedFuncIndex, FlagValue, FrameInstPos, FrameStackShape, FrameStateSlotBuilder,
+    FrameTableBuilder, FuncKey, FunctionBodyData, FunctionLoc, HostCall, InliningCompiler,
+    ModuleTranslation, ModuleTypesBuilder, PtrSize, StackMapSection, StaticModuleIndex,
+    TrapEncodingBuilder, TrapSentinel, TripleExt, Tunables, VMOffsets, WasmFuncType, WasmValType,
 };
 use wasmtime_unwinder::ExceptionTableBuilder;
 
@@ -56,6 +56,7 @@ struct CompilerContext {
     codegen_context: Context,
     incremental_cache_ctx: Option<IncrementalCacheContext>,
     validator_allocations: FuncValidatorAllocations,
+    debug_slot_descriptor: Option<FrameStateSlotBuilder>,
     abi: Option<Abi>,
 }
 
@@ -66,6 +67,7 @@ impl Default for CompilerContext {
             codegen_context: Context::new(),
             incremental_cache_ctx: None,
             validator_allocations: Default::default(),
+            debug_slot_descriptor: None,
             abi: None,
         }
     }
@@ -329,13 +331,19 @@ impl wasmtime_environ::Compiler for Compiler {
                 .map_err(|e| CompileError::Codegen(e.to_string()))?;
         }
 
+        let needs_gc_heap = func_env.needs_gc_heap();
+
+        if let Some((_, slot_builder)) = func_env.state_slot {
+            compiler.cx.debug_slot_descriptor = Some(slot_builder);
+        }
+
         let timing = cranelift_codegen::timing::take_current();
         log::debug!("`{symbol}` translated to CLIF in {:?}", timing.total());
         log::trace!("`{symbol}` timing info\n{timing}");
 
         Ok(CompiledFunctionBody {
             code: box_dyn_any_compiler_context(Some(compiler.cx)),
-            needs_gc_heap: func_env.needs_gc_heap(),
+            needs_gc_heap,
         })
     }
 
@@ -561,12 +569,12 @@ impl wasmtime_environ::Compiler for Compiler {
     fn append_code(
         &self,
         obj: &mut Object<'static>,
-        funcs: &[(String, Box<dyn Any + Send + Sync>)],
+        funcs: &[(String, FuncKey, Box<dyn Any + Send + Sync>)],
         resolve_reloc: &dyn Fn(usize, FuncKey) -> usize,
     ) -> Result<Vec<(SymbolId, FunctionLoc)>> {
         log::trace!(
             "appending functions to object file: {:#?}",
-            funcs.iter().map(|(sym, _)| sym).collect::<Vec<_>>()
+            funcs.iter().map(|(sym, _, _)| sym).collect::<Vec<_>>()
         );
 
         let mut builder =
@@ -580,8 +588,24 @@ impl wasmtime_environ::Compiler for Compiler {
         let mut exception_tables = ExceptionTableBuilder::default();
         let mut frame_tables = FrameTableBuilder::default();
 
+        let mut frame_descriptors = HashMap::new();
+        if self.tunables.debug_instrumentation {
+            for (_, key, func) in funcs {
+                debug_assert!(!func.is::<Option<CompilerContext>>());
+                debug_assert!(func.is::<CompiledFunction>());
+                let func = func.downcast_ref::<CompiledFunction>().unwrap();
+                frame_descriptors.insert(
+                    *key,
+                    func.debug_slot_descriptor
+                        .as_ref()
+                        .map(|builder| builder.serialize())
+                        .unwrap_or_else(|| vec![]),
+                );
+            }
+        }
+
         let mut ret = Vec::with_capacity(funcs.len());
-        for (i, (sym, func)) in funcs.iter().enumerate() {
+        for (i, (sym, _key, func)) in funcs.iter().enumerate() {
             debug_assert!(!func.is::<Option<CompilerContext>>());
             debug_assert!(func.is::<CompiledFunction>());
             let func = func.downcast_ref::<CompiledFunction>().unwrap();
@@ -614,6 +638,7 @@ impl wasmtime_environ::Compiler for Compiler {
                     range.clone(),
                     func.buffer.debug_tags(),
                     frame_layout,
+                    &frame_descriptors,
                 )?;
             }
             builder.append_padding(self.linkopts.padding_between_functions);
@@ -1405,6 +1430,10 @@ impl FunctionCompiler<'_> {
             }
         }
 
+        if let Some(builder) = self.cx.debug_slot_descriptor.take() {
+            compiled_function.debug_slot_descriptor = Some(builder);
+        }
+
         if body_and_tunables
             .map(|(_, t)| t.generate_native_debuginfo)
             .unwrap_or(false)
@@ -1477,8 +1506,9 @@ fn clif_to_env_frame_tables<'a>(
     range: Range<u64>,
     tag_sites: impl Iterator<Item = MachBufferDebugTagList<'a>>,
     frame_layout: &MachBufferFrameLayout,
+    frame_descriptors: &HashMap<FuncKey, Vec<u8>>,
 ) -> anyhow::Result<()> {
-    let mut frame_descriptors = HashMap::new();
+    let mut frame_descriptor_indices = HashMap::new();
     for tag_site in tag_sites {
         // Split into frames; each has three debug tags.
         let mut frames = vec![];
@@ -1492,11 +1522,18 @@ fn clif_to_env_frame_tables<'a>(
                 panic!("Invalid tags");
             };
 
-            let frame_descriptor = *frame_descriptors.entry(slot).or_insert_with(|| {
+            let func_key = frame_layout.stackslots[slot]
+                .key
+                .expect("Key must be present on stackslot used as state slot")
+                .bits();
+            let func_key = FuncKey::from_raw_u64(func_key);
+            let frame_descriptor = *frame_descriptor_indices.entry(slot).or_insert_with(|| {
                 let slot_to_fp_offset =
                     frame_layout.frame_to_fp_offset - frame_layout.stackslots[slot].offset;
-                let descriptor = frame_layout.stackslots[slot].descriptor.clone();
-                builder.add_frame_descriptor(slot_to_fp_offset, descriptor)
+                let descriptor = frame_descriptors
+                    .get(&func_key)
+                    .expect("frame descriptor not present for FuncKey");
+                builder.add_frame_descriptor(slot_to_fp_offset, &descriptor)
             });
 
             frames.push((
diff --git a/crates/cranelift/src/func_environ.rs b/crates/cranelift/src/func_environ.rs
@@ -1197,12 +1197,14 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
 
             // Initially zero-size and with no descriptor; we will fill in
             // this info once we're done with the function body.
-            let slot = builder.func.create_sized_stack_slot(ir::StackSlotData::new(
-                ir::StackSlotKind::ExplicitSlot,
-                0,
-                0,
-                vec![],
-            ));
+            let slot = builder
+                .func
+                .create_sized_stack_slot(ir::StackSlotData::new_with_key(
+                    ir::StackSlotKind::ExplicitSlot,
+                    0,
+                    0,
+                    ir::StackSlotKey::new(self.key.into_raw_u64()),
+                ));
 
             self.state_slot = Some((slot, frame_builder));
         }
@@ -1287,21 +1289,8 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         }
     }
 
-    fn set_debug_tags(
-        &self,
-        builder: &mut FunctionBuilder,
-        stack: &FuncTranslationStacks,
-        srcloc: ir::SourceLoc,
-    ) {
-        if self.state_slot.is_some() {
-            let tags = self.debug_tags(stack, srcloc);
-            builder.set_debug_tags(tags);
-        }
-    }
-
     fn finish_debug_metadata(&self, builder: &mut FunctionBuilder) {
         if let Some((slot, b)) = &self.state_slot {
-            builder.func.sized_stack_slots[*slot].descriptor = b.serialize();
             builder.func.sized_stack_slots[*slot].size = b.size();
         }
     }
@@ -1335,7 +1324,9 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         srcloc: ir::SourceLoc,
     ) -> WasmResult<()> {
         if stack.reachable() {
-            self.set_debug_tags(builder, stack, srcloc);
+            let inst = builder.ins().sequence_point();
+            let tags = self.debug_tags(stack, srcloc);
+            builder.func.debug_tags.set(inst, tags);
         }
         Ok(())
     }
diff --git a/crates/environ/src/compile/frame_table.rs b/crates/environ/src/compile/frame_table.rs
@@ -231,10 +231,10 @@ impl FrameTableBuilder {
     pub fn add_frame_descriptor(
         &mut self,
         slot_to_fp_offset: u32,
-        data: Vec<u8>,
+        data: &[u8],
     ) -> FrameTableDescriptorIndex {
         let start = u32::try_from(self.frame_descriptor_data.len()).unwrap();
-        self.frame_descriptor_data.extend(data);
+        self.frame_descriptor_data.extend(data.iter().cloned());
         let end = u32::try_from(self.frame_descriptor_data.len()).unwrap();
 
         let index = FrameTableDescriptorIndex(
diff --git a/crates/environ/src/compile/mod.rs b/crates/environ/src/compile/mod.rs
@@ -330,7 +330,7 @@ pub trait Compiler: Send + Sync {
     fn append_code(
         &self,
         obj: &mut Object<'static>,
-        funcs: &[(String, Box<dyn Any + Send + Sync>)],
+        funcs: &[(String, FuncKey, Box<dyn Any + Send + Sync>)],
         resolve_reloc: &dyn Fn(usize, FuncKey) -> usize,
     ) -> Result<Vec<(SymbolId, FunctionLoc)>>;
 
diff --git a/crates/environ/src/key.rs b/crates/environ/src/key.rs
@@ -392,6 +392,25 @@ impl FuncKey {
         }
     }
 
+    /// Create a key from a raw packed `u64` representation.
+    ///
+    /// Should only be given a value produced by `into_raw_u64()`.
+    ///
+    /// Panics when given an invalid value.
+    pub fn from_raw_u64(value: u64) -> Self {
+        let hi = u32::try_from(value >> 32).unwrap();
+        let lo = u32::try_from(value & 0xffff_ffff).unwrap();
+        FuncKey::from_raw_parts(hi, lo)
+    }
+
+    /// Produce a packed `u64` representation of this key.
+    ///
+    /// May be used with `from_raw_64()` to reconstruct this key.
+    pub fn into_raw_u64(&self) -> u64 {
+        let (hi, lo) = self.into_raw_parts();
+        (u64::from(hi) << 32) | u64::from(lo)
+    }
+
     /// Unwrap a `FuncKey::DefinedWasmFunction` or else panic.
     pub fn unwrap_defined_wasm_function(self) -> (StaticModuleIndex, DefinedFuncIndex) {
         match self {
diff --git a/crates/wasmtime/src/compile.rs b/crates/wasmtime/src/compile.rs
@@ -890,7 +890,7 @@ impl UnlinkedCompileOutputs<'_> {
             needs_gc_heap |= output.function.needs_gc_heap;
 
             let index = compiled_funcs.len();
-            compiled_funcs.push((output.symbol, output.function.code));
+            compiled_funcs.push((output.symbol, output.key, output.function.code));
 
             if output.start_srcloc != FilePos::none() {
                 indices
@@ -913,9 +913,9 @@ impl UnlinkedCompileOutputs<'_> {
 struct PreLinkOutput {
     /// Whether or not any of these functions require a GC heap
     needs_gc_heap: bool,
-    /// The flattened list of (symbol name, compiled function) pairs, as they
-    /// will be laid out in the object file.
-    compiled_funcs: Vec<(String, Box<dyn Any + Send + Sync>)>,
+    /// The flattened list of (symbol name, FuncKey, compiled
+    /// function) pairs, as they will be laid out in the object file.
+    compiled_funcs: Vec<(String, FuncKey, Box<dyn Any + Send + Sync>)>,
     /// The `FunctionIndices` mapping our function keys to indices in that flat
     /// list.
     indices: FunctionIndices,
@@ -937,7 +937,7 @@ impl FunctionIndices {
         self,
         mut obj: object::write::Object<'static>,
         engine: &'a Engine,
-        compiled_funcs: Vec<(String, Box<dyn Any + Send + Sync>)>,
+        compiled_funcs: Vec<(String, FuncKey, Box<dyn Any + Send + Sync>)>,
         translations: PrimaryMap<StaticModuleIndex, ModuleTranslation<'_>>,
         dwarf_package_bytes: Option<&[u8]>,
     ) -> Result<(wasmtime_environ::ObjectBuilder<'a>, Artifacts)> {
@@ -966,7 +966,7 @@ impl FunctionIndices {
                 &|module, func| {
                     let i = self.indices[&FuncKey::DefinedWasmFunction(module, func)];
                     let (symbol, _) = symbol_ids_and_locs[i];
-                    let (_, compiled_func) = &compiled_funcs[i];
+                    let (_, _, compiled_func) = &compiled_funcs[i];
                     (symbol, &**compiled_func)
                 },
                 dwarf_package_bytes,
diff --git a/crates/winch/src/compiler.rs b/crates/winch/src/compiler.rs
@@ -189,7 +189,7 @@ impl wasmtime_environ::Compiler for Compiler {
     fn append_code(
         &self,
         obj: &mut Object<'static>,
-        funcs: &[(String, Box<dyn Any + Send + Sync>)],
+        funcs: &[(String, FuncKey, Box<dyn Any + Send + Sync>)],
         resolve_reloc: &dyn Fn(usize, wasmtime_environ::FuncKey) -> usize,
     ) -> Result<Vec<(SymbolId, FunctionLoc)>> {
         self.trampolines.append_code(obj, funcs, resolve_reloc)
@@ -334,7 +334,7 @@ impl wasmtime_environ::Compiler for NoInlineCompiler {
     fn append_code(
         &self,
         obj: &mut Object<'static>,
-        funcs: &[(String, Box<dyn Any + Send + Sync>)],
+        funcs: &[(String, FuncKey, Box<dyn Any + Send + Sync>)],
         resolve_reloc: &dyn Fn(usize, FuncKey) -> usize,
     ) -> Result<Vec<(SymbolId, FunctionLoc)>> {
         self.0.append_code(obj, funcs, resolve_reloc)
