[DWARF] Fix "simulated" DWARF (#10681)

* Add a test

Relying on the implementation detail of LLVM
not adding DWARF for module-level inline asm
is a bit ugly, but it is simpler than twisting
the "build system" we now have for C to build
an intermediate object without "-g".

* Fix simulated DWARF

We need to record the correct ranges for the CU and include
an offset zero entry in the line table, otherwise LLDB won't
class our functions as "having debug info".

Author: SingleAccretion

crates/cranelift/src/debug/transform/simulate.rs

@@ -69,24 +69,32 @@ fn generate_line_info(
 
     for (symbol, map) in maps {
         let base_addr = map.offset;
-        out_program.begin_sequence(Some(write::Address::Symbol { symbol, addend: 0 }));
+        out_program.begin_sequence(Some(write::Address::Symbol {
+            symbol,
+            addend: base_addr as i64,
+        }));
+
+        // Always emit a row for offset zero - debuggers expect this.
+        out_program.row().address_offset = 0;
+        out_program.row().file = file_index;
+        out_program.row().line = 0; // Special line number for non-user code.
+        out_program.row().discriminator = 1;
+        out_program.row().is_statement = true;
+        out_program.generate_row();
+
+        let mut is_prologue_end = true;
         for addr_map in map.addresses.iter() {
             let address_offset = (addr_map.generated - base_addr) as u64;
             out_program.row().address_offset = address_offset;
-            out_program.row().op_index = 0;
-            out_program.row().file = file_index;
             let wasm_offset = w.code_section_offset + addr_map.wasm;
             out_program.row().line = wasm_offset;
-            out_program.row().column = 0;
             out_program.row().discriminator = 1;
-            out_program.row().is_statement = true;
-            out_program.row().basic_block = false;
-            out_program.row().prologue_end = false;
-            out_program.row().epilogue_begin = false;
-            out_program.row().isa = 0;
+            out_program.row().prologue_end = is_prologue_end;
             out_program.generate_row();
+
+            is_prologue_end = false;
         }
-        let end_addr = (map.offset + map.len - 1) as u64;
+        let end_addr = (base_addr + map.len - 1) as u64;
         out_program.end_sequence(end_addr);
     }
 
@@ -345,6 +353,7 @@ pub fn generate_simulated_dwarf(
     };
 
     let wasm_types = add_wasm_types(unit, root_id, out_strings);
+    let mut unit_ranges = vec![];
     for (module, index) in compilation.indexes().collect::<Vec<_>>() {
         let (symbol, _) = compilation.function(module, index);
         if translated.contains(&symbol) {
@@ -353,21 +362,22 @@ pub fn generate_simulated_dwarf(
 
         let addr_tr = &addr_tr[module];
         let map = &addr_tr.map()[index];
-        let start = map.offset as u64;
-        let end = start + map.len as u64;
         let die_id = unit.add(root_id, gimli::DW_TAG_subprogram);
         let die = unit.get_mut(die_id);
-        die.set(
-            gimli::DW_AT_low_pc,
-            write::AttributeValue::Address(write::Address::Symbol {
-                symbol,
-                addend: start as i64,
-            }),
-        );
+        let low_pc = write::Address::Symbol {
+            symbol,
+            addend: map.offset as i64,
+        };
+        let code_length = map.len as u64;
+        die.set(gimli::DW_AT_low_pc, write::AttributeValue::Address(low_pc));
         die.set(
             gimli::DW_AT_high_pc,
-            write::AttributeValue::Udata(end - start),
+            write::AttributeValue::Udata(code_length),
         );
+        unit_ranges.push(write::Range::StartLength {
+            begin: low_pc,
+            length: code_length,
+        });
 
         let translation = &compilation.translations[module];
         let func_index = translation.module.func_index(index);
@@ -412,6 +422,11 @@ pub fn generate_simulated_dwarf(
             isa,
         )?;
     }
+    let unit_ranges_id = unit.ranges.add(write::RangeList(unit_ranges));
+    unit.get_mut(root_id).set(
+        gimli::DW_AT_ranges,
+        write::AttributeValue::RangeListRef(unit_ranges_id),
+    );
 
     Ok(())
 }

crates/test-programs/src/bin/dwarf_generic.cpp

@@ -63,10 +63,26 @@ int TestInstanceMethod() {
   return 0;
 }
 
+__asm("FunctionWithoutWasmDWARF:\n"
+      ".global	FunctionWithoutWasmDWARF\n"
+      ".functype	FunctionWithoutWasmDWARF (i32, i32) -> (i32)\n"
+      "local.get	0\n"
+      "local.get	1\n"
+      "i32.div_u\n"
+      "end_function\n");
+extern "C" int FunctionWithoutWasmDWARF(int a, int b);
+
+int TestFunctionWithoutWasmDWARF() {
+  debug_break();
+  int x = FunctionWithoutWasmDWARF(9, 10);
+  return x == 0 ? 0 : 4;
+}
+
 int main() {
   int exitCode = 0;
   exitCode += TestClassDefinitionSpreadAcrossCompileUnits();
   exitCode += TestInheritance();
   exitCode += TestInstanceMethod();
+  exitCode += TestFunctionWithoutWasmDWARF();
   return exitCode;
 }

tests/all/debug/lldb.rs

@@ -206,6 +206,12 @@ c
 p __this->BaseValue + __this->DerivedValue
 c
 p __this->BaseValue + __this->DerivedValue
+c
+f
+n
+s
+v var0
+v var1
 c"#,
     )?;
 
@@ -227,6 +233,9 @@ check: stop reason = breakpoint 1.1
 check: 7
 check: stop reason = breakpoint 1.1
 check: 8
+check: stop reason = breakpoint 1.1
+check: 9
+check: 10
 check: exited with status = 0
 "#,
     )?;