[dwarfdump] Dump DW_AT_ranges values inline in the debug_info dump.

[friss]

Summary

The output looks like that:

DW_AT_ranges [FORM_data4]    (0x00000000
   [0x00000001000024a0 - 0x00000001000024c2)
   [0x0000000100002505 - 0x000000010000268b)
   End)

[friss]

ping

[dblaikie]

Oops, sorry, forgot to mash the 'send' button...

lib/DebugInfo/DWARFDebugInfoEntry.cpp

154 ↗

(On Diff #14675)

What's the failure mode if DW_AT_ranges isn't an index, or is not a correct index? (outside the range of ranges, etc)

test/DebugInfo/dwarfdump-ranges.test

16 ↗

(On Diff #14675)

I'd probably skip the "End" word and just put ")" on the end of the previous line - given the consistent ending, line length, etc, it should be pretty obvious.

But I'm open to other ideas.

What does Darwin's dwarfdump formatting for this look like?

[friss]

lib/DebugInfo/DWARFDebugInfoEntry.cpp

154 ↗

(On Diff #14675)

Depends on the case. Something really wrong will get you a empty range list thus you'll get the same output as before (this is all handled in getAddressRanges and the helpers it calls). A random index pointing into the range list section will dump... random values, but I guess that's expected.

test/DebugInfo/dwarfdump-ranges.test

16 ↗

(On Diff #14675)

The End is there only to match Darwin's dwarfdump. I can drop it if you prefer.

[dblaikie]

OK - looks good (yeah, looked through the range list extraction code - it appears to do the right thing and provide an empty range list if the specified offset is outside the range section, etc)

I'd vote weakly in favor of dropping the "End)" line and just putting the ')' at the end of the preceeding line:

DW_AT_ranges [FORM_data4]    (0x00000000
   [0x00000001000024a0 - 0x00000001000024c2)
   [0x0000000100002505 - 0x000000010000268b))

[friss]

Closed by commit rL220466 (authored by @friss).

llvm/trunk/lib/DebugInfo/DWARFDebugInfoEntry.cpp

else
       OS << format("DW_APPLE_PROPERTY_0x%" PRIx64, Bit);
     if (!(Val ^= Bit))
       break;
     OS << ", ";
   } while (true);
   OS << ")";
 }
 
+static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges,
+                       unsigned AddressSize, unsigned Indent) {
+  if (Ranges.empty())
+    return;
+
+  for (const auto &Range: Ranges) {
+    OS << '\n';
+    OS.indent(Indent);
+    OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
+                 AddressSize*2, Range.first,
+                 AddressSize*2, Range.second);
+  }
+}
+
 void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
                                                DWARFUnit *u,
                                                uint32_t *offset_ptr,
                                                uint16_t attr, uint16_t form,
                                                unsigned indent) const {
-  OS << "            ";
+  const char BaseIndent[] = "            ";
+  OS << BaseIndent;
   OS.indent(indent+2);
   const char *attrString = AttributeString(attr);
   if (attrString)
     OS << attrString;
   else
     OS << format("DW_AT_Unknown_%x", attr);
   const char *formString = FormEncodingString(form);
   if (formString)
if ((attr == DW_AT_specification || attr == DW_AT_abstract_origin) &&
     uint32_t Ref = formValue.getAsReference(u).getValue();
     DWARFDebugInfoEntryMinimal DIE;
     if (const DWARFUnit *RefU = findUnitAndExtractFast(DIE, u, &Ref))
       if (const char *Ref = DIE.getName(RefU, DINameKind::LinkageName))
         OS << " \"" << Ref << '\"';
   } else if (attr == DW_AT_APPLE_property_attribute) {
     if (Optional<uint64_t> OptVal = formValue.getAsUnsignedConstant())
       dumpApplePropertyAttribute(OS, *OptVal);
+  } else if (attr == DW_AT_ranges) {
+    dumpRanges(OS, getAddressRanges(u), u->getAddressByteSize(),
+               sizeof(BaseIndent)+indent+4);
   }
 
   OS << ")\n";
 }
 
 bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit *U,
                                              uint32_t *OffsetPtr) {
   Offset = *OffsetPtr;

llvm/trunk/test/DebugInfo/Inputs/gmlt.ll

 ; REQUIRES: object-emission
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s
 
 ; Generated from the following source compiled with clang++ -gmlt:
 ; void f1() {}
 ; void __attribute__((section("__TEXT,__bar"))) f2() {}
 ; void __attribute__((always_inline)) f3() { f1(); }
 ; void f4() { f3(); }
 
 ; Check that
 ;  * -gmlt includes no DW_TAG_subprograms for subprograms without inlined
 ;    subroutines.
 ;  * yet still produces DW_AT_ranges and a range list in debug_ranges that
 ;    describes those subprograms
 
 ; CHECK: DW_TAG_compile_unit
-; CHECK:   DW_AT_ranges [DW_FORM_sec_offset] (0x00000000)
+; CHECK:   DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
 ; CHECK-NOT: {{DW_TAG|NULL}}
 
 ; Omitting the subprograms without inlined subroutines is not possible
 ; currently on Darwin as dsymutil will drop the whole CU if it has no subprograms
 ; (which happens with this optimization if there are no inlined subroutines).
 
 ; DARWIN:  DW_TAG_subprogram
 ; DARWIN-NOT: DW_TAG

llvm/trunk/test/DebugInfo/X86/fission-ranges.ll

 ; CHECK-NEXT: DW_AT_GNU_addr_base [DW_FORM_sec_offset]                   (0x00000000)
 
 
 ; CHECK: .debug_info.dwo contents:
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[A:0x[0-9a-z]*]])
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[E:0x[0-9a-z]*]])
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[B:0x[0-9a-z]*]])
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[D:0x[0-9a-z]*]])
-; CHECK: DW_AT_ranges [DW_FORM_sec_offset]   (0x00000000)
+; CHECK: DW_AT_ranges [DW_FORM_sec_offset]   (0x00000000
 ; CHECK: .debug_loc contents:
 ; CHECK-NOT: Beginning address offset
 ; CHECK: .debug_loc.dwo contents:
 
 ; Don't assume these locations are entirely correct - feel free to update them
 ; if they've changed due to a bugfix, change in register allocation, etc.
 
 ; CHECK: [[A]]: Beginning address index: 2

llvm/trunk/test/DebugInfo/dwarfdump-ranges.test

 RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test4.elf-x86-64 | FileCheck %s
 
+CHECK: .debug_info contents:
+CHECK: DW_TAG_compile_unit
+CHECK-NOT: TAG
+CHECK:  DW_AT_ranges [DW_FORM_data4]      (0x00000000
+CHECK-NEXT:          [0x000000000000062c - 0x0000000000000637)
+CHECK-NEXT:          [0x0000000000000637 - 0x000000000000063d))
+
+CHECK: DW_TAG_compile_unit
+CHECK-NOT: TAG
+CHECK:  DW_AT_ranges [DW_FORM_data4]      (0x00000030
+CHECK-NEXT:          [0x0000000000000640 - 0x000000000000064b)
+CHECK-NEXT:          [0x0000000000000637 - 0x000000000000063d))
+
+
 CHECK:      .debug_ranges contents:
 CHECK-NEXT: 00000000 000000000000062c 0000000000000637
 CHECK-NEXT: 00000000 0000000000000637 000000000000063d
 CHECK-NEXT: 00000000 <End of list>
 CHECK-NEXT: 00000030 0000000000000640 000000000000064b
 CHECK-NEXT: 00000030 0000000000000637 000000000000063d
 CHECK-NEXT: 00000030 <End of list>
 

llvm/trunk/test/MC/ARM/dwarf-asm-multiple-sections.s

 // DWARF:         DW_AT_name      DW_FORM_string
 // DWARF:         DW_AT_comp_dir  DW_FORM_string
 // DWARF:         DW_AT_producer  DW_FORM_string
 // DWARF:         DW_AT_language  DW_FORM_data2
 
 // DWARF: .debug_info contents:
 // DWARF: 0x{{[0-9a-f]+}}: DW_TAG_compile_unit [1]
 // CHECK-NOT-DWARF: DW_TAG_
-// DWARF: DW_AT_ranges [DW_FORM_data4]      (0x00000000)
+// DWARF: DW_AT_ranges [DW_FORM_data4]      (0x00000000
 
 // DWARF: 0x{{[0-9a-f]+}}:   DW_TAG_label [2] *
 // DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("a")
 
 // DWARF: 0x{{[0-9a-f]+}}:   DW_TAG_label [2] *
 // DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("b")