[llvm-dwarfdump] - Print section name and index when dumping .debug_info ranges

Teaches llvm-dwarfdump to print section index and name of range
when it dumps .debug_info.

Differential revision: https://reviews.llvm.org/D36313

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@310915 91177308-0d34-0410-b5e6-96231b3b80d8
(cherry picked from commit 03937ca)

Author: George Rimar

include/llvm/DebugInfo/DWARF/DWARFObject.h

@@ -27,6 +27,7 @@ class DWARFObject {
 public:
   virtual ~DWARFObject() = default;
   virtual StringRef getFileName() const { llvm_unreachable("unimplemented"); }
+  virtual const object::ObjectFile *getFile() const { return nullptr; }
   virtual bool isLittleEndian() const = 0;
   virtual uint8_t getAddressSize() const { llvm_unreachable("unimplemented"); }
   virtual const DWARFSection &getInfoSection() const { return Dummy; }

lib/DebugInfo/DWARF/DWARFContext.cpp

@@ -941,6 +941,7 @@ class DWARFObjInMemory final : public DWARFObject {
   bool IsLittleEndian;
   uint8_t AddressSize;
   StringRef FileName;
+  const object::ObjectFile *Obj = nullptr;
 
   using TypeSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
                                    std::map<object::SectionRef, unsigned>>;
@@ -1059,7 +1060,8 @@ class DWARFObjInMemory final : public DWARFObject {
   DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
                    function_ref<ErrorPolicy(Error)> HandleError)
       : IsLittleEndian(Obj.isLittleEndian()),
-        AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()) {
+        AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
+        Obj(&Obj) {
 
     for (const SectionRef &Section : Obj.sections()) {
       StringRef Name;
@@ -1196,6 +1198,8 @@ class DWARFObjInMemory final : public DWARFObject {
     return AI->second;
   }
 
+  const object::ObjectFile *getFile() const override { return Obj; }
+
   bool isLittleEndian() const override { return IsLittleEndian; }
   StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; }
   const DWARFSection &getLineDWOSection() const override {

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

@@ -33,20 +33,22 @@ bool DWARFDebugRangeList::extract(const DWARFDataExtractor &data,
     return false;
   Offset = *offset_ptr;
   while (true) {
-    RangeListEntry entry;
+    RangeListEntry Entry;
+    Entry.SectionIndex = -1ULL;
+
     uint32_t prev_offset = *offset_ptr;
-    entry.StartAddress =
-        data.getRelocatedAddress(offset_ptr, &entry.SectionIndex);
-    entry.EndAddress = data.getRelocatedAddress(offset_ptr);
+    Entry.StartAddress = data.getRelocatedAddress(offset_ptr);
+    Entry.EndAddress =
+        data.getRelocatedAddress(offset_ptr, &Entry.SectionIndex);
 
     // Check that both values were extracted correctly.
     if (*offset_ptr != prev_offset + 2 * AddressSize) {
       clear();
       return false;
     }
-    if (entry.isEndOfListEntry())
+    if (Entry.isEndOfListEntry())
       break;
-    Entries.push_back(entry);
+    Entries.push_back(Entry);
   }
   return true;
 }

lib/DebugInfo/DWARF/DWARFDie.cpp

@@ -19,6 +19,7 @@
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
@@ -32,6 +33,7 @@
 
 using namespace llvm;
 using namespace dwarf;
+using namespace object;
 using namespace syntax;
 
 static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) {
@@ -52,17 +54,42 @@ static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) {
   OS << ")";
 }
 
-static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges,
-                       unsigned AddressSize, unsigned Indent) {
-  if (Ranges.empty())
-    return;
-  
-  for (const auto &Range: Ranges) {
+static void dumpRanges(const DWARFObject &Obj, raw_ostream &OS,
+                       const DWARFAddressRangesVector &Ranges,
+                       unsigned AddressSize, unsigned Indent,
+                       const DIDumpOptions &DumpOpts) {
+  StringMap<unsigned> SectionAmountMap;
+  std::vector<StringRef> SectionNames;
+  if (Obj.getFile() && !DumpOpts.Brief) {
+    for (const SectionRef &Section : Obj.getFile()->sections()) {
+      StringRef Name;
+      if (Section.getName(Name))
+        Name = "<error>";
+
+      ++SectionAmountMap[Name];
+      SectionNames.push_back(Name);
+    }
+  }
+
+  for (size_t I = 0; I < Ranges.size(); ++I) {
+    const DWARFAddressRange &R = Ranges[I];
+
     OS << '\n';
     OS.indent(Indent);
-    OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
-                 AddressSize*2, Range.LowPC,
-                 AddressSize*2, Range.HighPC);
+    OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")", AddressSize * 2,
+                 R.LowPC, AddressSize * 2, R.HighPC);
+
+    if (SectionNames.empty() || R.SectionIndex == -1ULL)
+      continue;
+
+    StringRef Name = R.SectionIndex < SectionNames.size()
+                         ? SectionNames[R.SectionIndex]
+                         : "<error>";
+    OS << format(" \"%s\"", Name.str().c_str());
+
+    // Print section index if there is more than one section with this name.
+    if (SectionAmountMap[Name] > 1)
+      OS << format(" [%u]", R.SectionIndex);
   }
 }
 
@@ -171,10 +198,11 @@ static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
     if (Optional<uint64_t> OptVal = formValue.getAsUnsignedConstant())
       dumpApplePropertyAttribute(OS, *OptVal);
   } else if (Attr == DW_AT_ranges) {
-    dumpRanges(OS, Die.getAddressRanges(), U->getAddressByteSize(),
-               sizeof(BaseIndent)+Indent+4);
+    const DWARFObject &Obj = Die.getDwarfUnit()->getContext().getDWARFObj();
+    dumpRanges(Obj, OS, Die.getAddressRanges(), U->getAddressByteSize(),
+               sizeof(BaseIndent) + Indent + 4, DumpOpts);
   }
-  
+
   OS << ")\n";
 }
 

test/DebugInfo/X86/dwarfdump-ranges-unrelocated.s

@@ -1,12 +1,28 @@
 # RUN: llvm-mc -triple x86_64-pc-linux -filetype=obj %s -o %t
 # RUN: llvm-dwarfdump %t | FileCheck %s
 
+# CHECK: .debug_info contents:
+# CHECK: DW_TAG_compile_unit
+# CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
+# CHECK-NEXT:  [0x0000000000000000 - 0x0000000000000001) ".text.foo1"
+# CHECK-NEXT:  [0x0000000000000000 - 0x0000000000000002) ".text.foo2" [4]
+# CHECK-NEXT:  [0x0000000000000000 - 0x0000000000000003) ".text.foo2" [5])
+
 # CHECK: .debug_ranges contents:
 # CHECK:   00000000 0000000000000000 0000000000000001
 # CHECK:   00000000 0000000000000000 0000000000000002
+# CHECK:   00000000 0000000000000000 0000000000000003
 # CHECK:   00000000 <End of list>
 
-## Asm code for testcase is a reduced output from next invocation and source:
+# RUN: llvm-dwarfdump -brief=true %t | FileCheck %s --check-prefix=BRIEF
+# BRIEF: DW_TAG_compile_unit
+# BRIEF: DW_AT_ranges         (0x00000000
+# BRIEF-NEXT:  [0x0000000000000000 - 0x0000000000000001)
+# BRIEF-NEXT:  [0x0000000000000000 - 0x0000000000000002)
+# BRIEF-NEXT:  [0x0000000000000000 - 0x0000000000000003))
+
+## Asm code for testcase is a reduced and modified output from next
+## invocation and source:
 # clang test.cpp -S -o test.s -gmlt -ffunction-sections
 # test.cpp:
 #   void foo1() { }  
@@ -17,12 +33,19 @@
  nop
 .Lfunc_end0:
 
-.section .text.foo2,"ax",@progbits
+.section .text.foo2,"ax",@progbits, unique, 1
 .Lfunc_begin1:
  nop
  nop
 .Lfunc_end1:
 
+.section .text.foo2,"ax",@progbits, unique, 2
+.Lfunc_begin2:
+ nop
+ nop
+ nop
+.Lfunc_end2:
+
 .section .debug_abbrev,"",@progbits
 .byte 1                       # Abbreviation Code
 .byte 17                      # DW_TAG_compile_unit
@@ -66,5 +89,7 @@
 .quad .Lfunc_end0
 .quad .Lfunc_begin1
 .quad .Lfunc_end1
+.quad .Lfunc_begin2
+.quad .Lfunc_end2
 .quad 0
 .quad 0