fix(dwarf): attempt to fix emitting dwarf symbols for debugging

radu-matei · radu-matei · commit 9840c7211bc4 · 2026-02-25T23:54:54.000+01:00
Signed-off-by: Radu Matei &lt;radu@fermyon.com&gt;
diff --git a/cranelift/codegen/src/machinst/abi.rs b/cranelift/codegen/src/machinst/abi.rs
@@ -1548,6 +1548,11 @@ impl<M: ABIMachineSpec> Callee<M> {
         &self.sized_stackslots
     }
 
+    /// The keys of all sized stack slots for debuginfo purposes.
+    pub fn sized_stackslot_keys(&self) -> &SecondaryMap<StackSlot, Option<StackSlotKey>> {
+        &self.sized_stackslot_keys
+    }
+
     /// The offsets of all dynamic stack slots (not spill slots) for debuginfo purposes.
     pub fn dynamic_stackslot_offsets(&self) -> &PrimaryMap<DynamicStackSlot, u32> {
         &self.dynamic_stackslots
diff --git a/cranelift/codegen/src/machinst/vcode.rs b/cranelift/codegen/src/machinst/vcode.rs
@@ -1234,15 +1234,23 @@ impl<I: VCodeInst> VCode<I> {
         inst_offsets: &[CodeOffset],
         func_body_len: u32,
     ) -> ValueLabelsRanges {
+        let mut value_labels_ranges: ValueLabelsRanges = HashMap::new();
+
+        // Add synthetic full-body entries from the debug-locals stack
+        // slot before processing regalloc2 output so that the
+        // regalloc2-based (narrower but potentially register-based)
+        // entries are appended after and can take precedence in the
+        // DWARF transform's range intersection logic.
+        self.add_debug_locals_slot_ranges(&mut value_labels_ranges, func_body_len);
+
         if self.debug_value_labels.is_empty() {
-            return ValueLabelsRanges::default();
+            return value_labels_ranges;
         }
 
         if trace_log_enabled!() {
             self.log_value_labels_ranges(regalloc, inst_offsets);
         }
 
-        let mut value_labels_ranges: ValueLabelsRanges = HashMap::new();
         for &(label, from, to, alloc) in &regalloc.debug_locations {
             let label = ValueLabel::from_u32(label);
             let ranges = value_labels_ranges.entry(label).or_insert_with(|| vec![]);
@@ -1313,6 +1321,67 @@ impl<I: VCodeInst> VCode<I> {
         value_labels_ranges
     }
 
+    /// If a sized stack slot is marked with the debug-locals sentinel
+    /// key, add a full-body `ValueLocRange` for each Wasm local (and
+    /// for the vmctx pointer stored after all locals) so that DWARF
+    /// expressions can always find values at known CFA-relative offsets.
+    fn add_debug_locals_slot_ranges(
+        &self,
+        value_labels_ranges: &mut ValueLabelsRanges,
+        func_body_len: u32,
+    ) {
+        const DEBUG_LOCALS_KEY_SENTINEL: u64 = 0xDEBF_DEAD_0000_0000;
+        const VMCTX_LABEL: u32 = 0xffff_fffe;
+        let offsets = self.abi.sized_stackslot_offsets();
+        let keys = self.abi.sized_stackslot_keys();
+        for (slot, slot_offset) in offsets {
+            let Some(key) = keys[slot] else { continue };
+            let bits = key.bits();
+            if bits & 0xFFFF_FFFF_0000_0000 != DEBUG_LOCALS_KEY_SENTINEL {
+                continue;
+            }
+            let num_locals = (bits & 0xFFFF_FFFF) as u32;
+            let slot_base = *slot_offset as i64;
+            let slot_base_to_caller_sp =
+                self.abi.slot_base_to_caller_sp_offset() as i64;
+            let caller_sp_to_cfa =
+                crate::isa::unwind::systemv::caller_sp_to_cfa_offset() as i64;
+            let cfa_to_slot_base =
+                -(slot_base_to_caller_sp + caller_sp_to_cfa) + slot_base;
+
+            for i in 0..num_locals {
+                let label = ValueLabel::from_u32(i);
+                let per_local_offset = (i as i64) * 16;
+                let cfa_offset = cfa_to_slot_base + per_local_offset;
+                let loc = LabelValueLoc::CFAOffset(cfa_offset);
+
+                let ranges = value_labels_ranges
+                    .entry(label)
+                    .or_insert_with(|| vec![]);
+                ranges.push(ValueLocRange {
+                    loc,
+                    start: 0,
+                    end: func_body_len,
+                });
+            }
+
+            // Also add a synthetic range for vmctx (frame base / memory
+            // deref), stored at offset num_locals * 16 in the slot.
+            let vmctx_label = ValueLabel::from_u32(VMCTX_LABEL);
+            let vmctx_offset = (num_locals as i64) * 16;
+            let vmctx_cfa = cfa_to_slot_base + vmctx_offset;
+            let vmctx_loc = LabelValueLoc::CFAOffset(vmctx_cfa);
+            let ranges = value_labels_ranges
+                .entry(vmctx_label)
+                .or_insert_with(|| vec![]);
+            ranges.push(ValueLocRange {
+                loc: vmctx_loc,
+                start: 0,
+                end: func_body_len,
+            });
+        }
+    }
+
     fn log_value_labels_ranges(&self, regalloc: &regalloc2::Output, inst_offsets: &[CodeOffset]) {
         debug_assert!(trace_log_enabled!());
 
diff --git a/crates/cranelift/src/func_environ.rs b/crates/cranelift/src/func_environ.rs
@@ -216,6 +216,16 @@ pub struct FuncEnvironment<'module_environment> {
     /// The stack-slot used for exposing Wasm state via debug
     /// instrumentation, if any, and the builder containing its metadata.
     pub(crate) state_slot: Option<(ir::StackSlot, FrameStateSlotBuilder)>,
+
+    /// Stack slot for pinning Wasm local values when native debug info is
+    /// enabled. Stores to this slot at function exits keep the register
+    /// allocator from discarding local values that are needed for DWARF
+    /// location expressions.
+    debug_locals_slot: Option<ir::StackSlot>,
+
+    /// Total number of Wasm locals (parameters + declared locals) for
+    /// debug local pinning.
+    num_wasm_locals: u32,
 }
 
 impl<'module_environment> FuncEnvironment<'module_environment> {
@@ -277,6 +287,9 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             stack_switching_values_buffer: None,
 
             state_slot: None,
+
+            debug_locals_slot: None,
+            num_wasm_locals: 0,
         }
     }
 
@@ -1239,6 +1252,64 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         }
     }
 
+    /// Sentinel in the high 32 bits of the StackSlotKey that marks a
+    /// slot as holding pinned Wasm locals for native DWARF debug info.
+    /// The low 32 bits encode the number of locals. Each local `i`
+    /// occupies bytes `[i*16 .. (i+1)*16)` in the slot, and the
+    /// vmctx pointer is stored at `[num_locals*16 .. (num_locals+1)*16)`.
+    pub(crate) const DEBUG_LOCALS_KEY_SENTINEL: u64 = 0xDEBF_DEAD_0000_0000;
+
+    /// Create a stack slot for pinning Wasm local values when native debug
+    /// info is enabled. On every `local.set`/`local.tee` (and at
+    /// initialization), the value is stored to this slot so that DWARF
+    /// location expressions can always find it at a known stack offset.
+    /// An extra 16-byte entry at the end holds the vmctx pointer (frame
+    /// base), which is needed to dereference Wasm linear memory.
+    pub(crate) fn create_debug_locals_slot(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        num_locals: u32,
+    ) {
+        if !self.tunables.debug_native || num_locals == 0 {
+            return;
+        }
+        self.num_wasm_locals = num_locals;
+        let slot_size = (num_locals + 1) * 16;
+        let key = ir::StackSlotKey::new(Self::DEBUG_LOCALS_KEY_SENTINEL | num_locals as u64);
+        let slot = builder.create_sized_stack_slot(ir::StackSlotData::new_with_key(
+            ir::StackSlotKind::ExplicitSlot,
+            slot_size,
+            0,
+            key,
+        ));
+        self.debug_locals_slot = Some(slot);
+    }
+
+    /// Store a value for a local in the debug locals slot, if present.
+    pub(crate) fn debug_locals_slot_local_set(
+        &self,
+        builder: &mut FunctionBuilder,
+        local: u32,
+        value: ir::Value,
+    ) {
+        if let Some(slot) = self.debug_locals_slot {
+            let offset = (local as i32) * 16;
+            builder.ins().stack_store(value, slot, offset);
+        }
+    }
+
+    /// Store the vmctx pointer in the debug locals slot (after all locals).
+    pub(crate) fn debug_locals_slot_store_vmctx(
+        &mut self,
+        builder: &mut FunctionBuilder,
+    ) {
+        if let Some(slot) = self.debug_locals_slot {
+            let vmctx = self.vmctx_val(&mut builder.cursor());
+            let offset = (self.num_wasm_locals as i32) * 16;
+            builder.ins().stack_store(vmctx, slot, offset);
+        }
+    }
+
     /// Update the state slot layout with a new layout given a local.
     pub(crate) fn add_state_slot_local(
         &mut self,
diff --git a/crates/cranelift/src/translate/code_translator.rs b/crates/cranelift/src/translate/code_translator.rs
@@ -164,6 +164,7 @@ pub fn translate_operator(
             let label = ValueLabel::from_u32(*local_index);
             builder.set_val_label(val, label);
             environ.state_slot_local_set(builder, *local_index, val);
+            environ.debug_locals_slot_local_set(builder, *local_index, val);
         }
         Operator::LocalTee { local_index } => {
             let mut val = environ.stacks.peek1();
@@ -178,6 +179,7 @@ pub fn translate_operator(
             let label = ValueLabel::from_u32(*local_index);
             builder.set_val_label(val, label);
             environ.state_slot_local_set(builder, *local_index, val);
+            environ.debug_locals_slot_local_set(builder, *local_index, val);
         }
         /********************************** Globals ****************************************
          *  `get_global` and `set_global` are handled by the environment.
diff --git a/crates/cranelift/src/translate/func_translator.rs b/crates/cranelift/src/translate/func_translator.rs
@@ -11,7 +11,7 @@ use crate::translate::translation_utils::get_vmctx_value_label;
 use cranelift_codegen::entity::EntityRef;
 use cranelift_codegen::ir::{self, Block, InstBuilder, ValueLabel};
 use cranelift_codegen::timing;
-use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
+use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
 use wasmparser::{BinaryReader, FuncValidator, FunctionBody, OperatorsReader, WasmModuleResources};
 use wasmtime_environ::{TypeConvert, WasmResult};
 
@@ -89,7 +89,14 @@ impl FuncTranslator {
             .stacks
             .initialize(&builder.func.signature, exit_block);
 
-        parse_local_decls(&mut reader, &mut builder, num_params, environ, validator)?;
+        let total_locals =
+            parse_local_decls(&mut reader, &mut builder, num_params, environ, validator)?;
+        environ.create_debug_locals_slot(&mut builder, total_locals as u32);
+        for i in 0..total_locals as u32 {
+            let val = builder.use_var(Variable::from_u32(i));
+            environ.debug_locals_slot_local_set(&mut builder, i, val);
+        }
+        environ.debug_locals_slot_store_vmctx(&mut builder);
         parse_function_body(validator, reader, &mut builder, environ)?;
 
         builder.finalize();
@@ -145,7 +152,7 @@ fn parse_local_decls(
     num_params: usize,
     environ: &mut FuncEnvironment<'_>,
     validator: &mut FuncValidator<impl WasmModuleResources>,
-) -> WasmResult<()> {
+) -> WasmResult<usize> {
     let mut next_local = num_params;
     let local_count = reader.read_var_u32()?;
 
@@ -158,7 +165,7 @@ fn parse_local_decls(
         declare_locals(builder, count, ty, &mut next_local, environ)?;
     }
 
-    Ok(())
+    Ok(next_local)
 }
 
 /// Declare `count` local variables of the same type, starting from `next_local`.
