[dwarfdump] Add support for -debug-loc=OFFSET

[JDevlieghere]

Summary

This patch adds support for passing an OFFSET to -debug-loc.

[dblaikie]

That test case looks really long... - could it be a bit more terse?

Also is there a reasonable chance to modify the APIs here so only the loc contribution that's being dumped is parsed, rather than parsing them all and dumping one of them?

[aprantl]

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

55 ↗

(On Diff #116549)

This looks like a good opportunity to add an API that uses std:lower_bound to quickly find an entry at an offset. (cf. DWARFDebugFrame::getEntryAtOffset(uint64_t Offset)).

We will need this anyway.

[JDevlieghere]

• Feedback Adrian and Dave

[JDevlieghere]

In D38237#880163, @dblaikie wrote:

That test case looks really long... - could it be a bit more terse?

I've updated the test with the most minimal thing I could come up with, but let me know if you have an idea to further reduce it.

Also is there a reasonable chance to modify the APIs here so only the loc contribution that's being dumped is parsed, rather than parsing them all and dumping one of them?

I have some code that uses parseOneLocationList(DataExtractor Data, unsigned *Offset) to do this. This is a good solution for valid offsets, but not so much for invalid offsets as it is incremented based on the previously parsed amount of bytes. I have a few concerns about this though:

• We currently prints errors when we can't parse the section. Would we display them conditionally? (e.g. during regular parsing but not during parsing for dumping)
• I don't know how likely this scenario is, but what if an invalid offset causes the data to be accidentally parsable?

If we move forward with this approach, I'd recommend doing it in in a separate differential as it will mostly build on top of the changes in this patch. (I'm thinking about the tests, the changes in dump method, and we could even keep the current approach as fallback)

[aprantl]

In D38237#881042, @JDevlieghere wrote:

I have some code that uses parseOneLocationList(DataExtractor Data, unsigned *Offset) to do this. This is a good solution for valid offsets, but not so much for invalid offsets as it is incremented based on the previously parsed amount of bytes. I have a few concerns about this though:

• We currently prints errors when we can't parse the section. Would we display them conditionally? (e.g. during regular parsing but not during parsing for dumping)
• I don't know how likely this scenario is, but what if an invalid offset causes the data to be accidentally parsable?

If we move forward with this approach, I'd recommend doing it in in a separate differential as it will mostly build on top of the changes in this patch. (I'm thinking about the tests, the changes in dump method, and we could even keep the current approach as fallback)

I support doing the lazy API in a follow-up commit. More fine-grained commits is always preferable, it makes reviews easier and usually yields better test coverage.
As for errors:

• When it is easily possible to determine that no entry exists at the give offset, we should not print anything.
• Otherwise, we probably should suppress errors when dumping with DumpOffsets[<section>] != None. Why? Because someone might call llvm-dwarfdump --debug-info=0x000abcd fat_macho.o and I think it is reasonable to dump DIEs in each slice that has something at the given offset and be silent in all others.

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

private:
   LocationLists Locations;
 
   unsigned AddressSize;
 
   bool IsLittleEndian;
 
 public:
   /// Print the location lists found within the debug_loc section.
-  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo) const;
+  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo,
+            Optional<uint64_t> Offset) const;
 
   /// Parse the debug_loc section accessible via the 'data' parameter using the
   /// address size also given in 'data' to interpret the address ranges.
   void parse(const DWARFDataExtractor &data);
-  
+  /// Return the location list at the given offset or nullptr.
+  LocationList const *getLocationListAtOffset(uint64_t Offset) const;
+
   Optional<LocationList> parseOneLocationList(DWARFDataExtractor Data,
                                               uint32_t *Offset);
 };
 
 class DWARFDebugLocDWO {
 public:
   struct Entry {
     uint64_t Start;
private:
   LocationLists Locations;
 
   unsigned AddressSize;
 
   bool IsLittleEndian;
 
 public:
   void parse(DataExtractor data);
-  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo) const;
+  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo,
+            Optional<uint64_t> Offset) const;
+
+  /// Return the location list at the given offset or nullptr.
+  LocationList const *getLocationListAtOffset(uint64_t Offset) const;
 
   static Optional<LocationList> parseOneLocationList(DataExtractor Data,
                                                      uint32_t *Offset);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp

if ((DumpType & DIDT_DebugTypes)) {
     if (Explicit || getNumTypeUnits())
       dumpDebugType(".debug_types", type_unit_sections());
     if (ExplicitDWO || getNumDWOTypeUnits())
       dumpDebugType(".debug_types.dwo", dwo_type_unit_sections());
   }
 
   if (shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
                  DObj->getLocSection().Data)) {
-    getDebugLoc()->dump(OS, getRegisterInfo());
+    getDebugLoc()->dump(OS, getRegisterInfo(), DumpOffset);
   }
   if (shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                  DObj->getLocDWOSection().Data)) {
-    getDebugLocDWO()->dump(OS, getRegisterInfo());
+    getDebugLocDWO()->dump(OS, getRegisterInfo(), DumpOffset);
   }
 
   if (shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
                  DObj->getDebugFrameSection()))
     getDebugFrame()->dump(OS, DumpOffset);
 
   if (shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
                  DObj->getEHFrameSection()))

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

for (const Entry &E : Entries) {
     OS.indent(Indent);
     OS << format("0x%016" PRIx64, E.Begin) << " - "
        << format("0x%016" PRIx64, E.End) << ": ";
 
     dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI);
   }
 }
 
-void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI) const {
-  for (const LocationList &L : Locations) {
+DWARFDebugLoc::LocationList const *
+DWARFDebugLoc::getLocationListAtOffset(uint64_t Offset) const {
+  auto It = std::lower_bound(
+      Locations.begin(), Locations.end(), Offset,
+      [](const LocationList &L, uint64_t Offset) { return L.Offset < Offset; });
+  if (It != Locations.end() && It->Offset == Offset)
+    return &(*It);
+  return nullptr;
+}
+
+void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+                         Optional<uint64_t> Offset) const {
+  auto DumpLocationList = [&](const LocationList &L) {
     OS << format("0x%8.8x: ", L.Offset);
     L.dump(OS, IsLittleEndian, AddressSize, MRI, 12);
     OS << "\n\n";
+  };
+
+  if (Offset) {
+    if (auto *L = getLocationListAtOffset(*Offset))
+      DumpLocationList(*L);
+    return;
+  }
+
+  for (const LocationList &L : Locations) {
+    DumpLocationList(L);
   }
 }
 
 Optional<DWARFDebugLoc::LocationList>
 DWARFDebugLoc::parseOneLocationList(DWARFDataExtractor Data, unsigned *Offset) {
   LocationList LL;
   LL.Offset = *Offset;
 
void DWARFDebugLocDWO::parse(DataExtractor data) {
   while (data.isValidOffset(Offset)) {
     if (auto LL = parseOneLocationList(data, &Offset))
       Locations.push_back(std::move(*LL));
     else
       return;
   }
 }
 
+DWARFDebugLocDWO::LocationList const *
+DWARFDebugLocDWO::getLocationListAtOffset(uint64_t Offset) const {
+  auto It = std::lower_bound(
+      Locations.begin(), Locations.end(), Offset,
+      [](const LocationList &L, uint64_t Offset) { return L.Offset < Offset; });
+  if (It != Locations.end() && It->Offset == Offset)
+    return &(*It);
+  return nullptr;
+}
+
 void DWARFDebugLocDWO::LocationList::dump(raw_ostream &OS, bool IsLittleEndian,
                                           unsigned AddressSize,
                                           const MCRegisterInfo *MRI,
                                           unsigned Indent) const {
   for (const Entry &E : Entries) {
     OS << '\n';
     OS.indent(Indent);
     OS << "Addr idx " << E.Start << " (w/ length " << E.Length << "): ";
     dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI);
   }
 }
 
-void DWARFDebugLocDWO::dump(raw_ostream &OS, const MCRegisterInfo *MRI) const {
-  for (const LocationList &L : Locations) {
+void DWARFDebugLocDWO::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+                            Optional<uint64_t> Offset) const {
+  auto DumpLocationList = [&](const LocationList &L) {
     OS << format("0x%8.8x: ", L.Offset);
     L.dump(OS, IsLittleEndian, AddressSize, MRI, /*Indent=*/12);
     OS << "\n\n";
+  };
+
+  if (Offset) {
+    if (auto *L = getLocationListAtOffset(*Offset))
+      DumpLocationList(*L);
+    return;
+  }
+
+  for (const LocationList &L : Locations) {
+    DumpLocationList(L);
   }
 }

llvm/trunk/test/tools/llvm-dwarfdump/X86/debug_loc_offset.test

+RUN: llvm-mc %S/debugloc.s -filetype obj -triple x86_64-linux-elf -o - \
+RUN: | llvm-dwarfdump --debug-loc=0 - \
+RUN: | FileCheck %s --check-prefix=CHECK-A
+
+# CHECK-A: .debug_loc contents:
+# CHECK-A: 0x00000000:
+# CHECK-A-NEXT: 0x0000000000000000 - 0x0000000000000003: DW_OP_reg5 RDI
+# CHECK-A-NEXT: 0x0000000000000003 - 0x0000000000000004: DW_OP_reg0 RAX
+
+RUN: llvm-mc %S/debugloc.s -filetype obj -triple x86_64-linux-elf -o - \
+RUN: | llvm-dwarfdump --debug-loc=0x36 - \
+RUN: | FileCheck %s --check-prefix=CHECK-B
+
+# CHECK-B: .debug_loc contents:
+# CHECK-B: 0x00000036:
+# CHECK-B-NEXT: 0x0000000000000010 - 0x0000000000000013: DW_OP_reg5 RDI
+# CHECK-B-NEXT: 0x0000000000000013 - 0x0000000000000014: DW_OP_reg0 RAX

llvm/trunk/test/tools/llvm-dwarfdump/X86/debugloc.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64-linux-elf -o - \
+# RUN: | llvm-dwarfdump --debug-loc - \
+# RUN: | FileCheck %s
+
+# CHECK: .debug_loc contents:
+
+# CHECK: 0x00000000:
+# CHECK-NEXT: 0x0000000000000000 - 0x0000000000000003: DW_OP_reg5 RDI
+# CHECK-NEXT: 0x0000000000000003 - 0x0000000000000004: DW_OP_reg0 RAX
+
+# CHECK: 0x00000036:
+# CHECK-NEXT: 0x0000000000000010 - 0x0000000000000013: DW_OP_reg5 RDI
+# CHECK-NEXT: 0x0000000000000013 - 0x0000000000000014: DW_OP_reg0 RAX
+
+# Source:
+#   int* foo(int* i) { return i; }
+#   int* bar(int* i) { return i; }
+# Compile with:
+#   clang -g -O3 test.c -S -o debugloc.s
+
+  .text
+  .file "test.c"
+  .globl  foo
+  .align  16, 0x90
+  .type foo,@function
+foo:                                    # @foo
+.Lfunc_begin0:
+  .file 1 "test.c"
+  .loc  1 1 0                   # test.c:1:0
+  .cfi_startproc
+# BB#0:
+  #DEBUG_VALUE: foo:i <- %RDI
+  .loc  1 2 3 prologue_end      # test.c:2:3
+  movq  %rdi, %rax
+.Ltmp0:
+  #DEBUG_VALUE: foo:i <- %RAX
+  retq
+.Ltmp1:
+.Lfunc_end0:
+  .size foo, .Lfunc_end0-foo
+  .cfi_endproc
+
+  .globl  bar
+  .align  16, 0x90
+  .type bar,@function
+bar:                                    # @bar
+.Lfunc_begin1:
+  .loc  1 5 0                   # test.c:5:0
+  .cfi_startproc
+# BB#0:
+  #DEBUG_VALUE: bar:i <- %RDI
+  .loc  1 6 3 prologue_end      # test.c:6:3
+  movq  %rdi, %rax
+.Ltmp2:
+  #DEBUG_VALUE: bar:i <- %RAX
+  retq
+.Ltmp3:
+.Lfunc_end1:
+  .size bar, .Lfunc_end1-bar
+  .cfi_endproc
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)" # string offset=0
+.Linfo_string1:
+  .asciz  "test.c"                # string offset=54
+.Linfo_string2:
+  .asciz  "/tmp"                  # string offset=61
+.Linfo_string3:
+  .asciz  "foo"                   # string offset=66
+.Linfo_string4:
+  .asciz  "int"                   # string offset=70
+.Linfo_string5:
+  .asciz  "bar"                   # string offset=74
+.Linfo_string6:
+  .asciz  "i"                     # string offset=78
+  .section  .debug_loc,"",@progbits
+.Ldebug_loc0:
+  .quad .Lfunc_begin0-.Lfunc_begin0
+  .quad .Ltmp0-.Lfunc_begin0
+  .short  1                       # Loc expr size
+  .byte 85                      # DW_OP_reg5
+  .quad .Ltmp0-.Lfunc_begin0
+  .quad .Lfunc_end0-.Lfunc_begin0
+  .short  1                       # Loc expr size
+  .byte 80                      # DW_OP_reg0
+  .quad 0
+  .quad 0
+.Ldebug_loc1:
+  .quad .Lfunc_begin1-.Lfunc_begin0
+  .quad .Ltmp2-.Lfunc_begin0
+  .short  1                       # Loc expr size
+  .byte 85                      # DW_OP_reg5
+  .quad .Ltmp2-.Lfunc_begin0
+  .quad .Lfunc_end1-.Lfunc_begin0
+  .short  1                       # Loc expr size
+  .byte 80                      # DW_OP_reg0
+  .quad 0
+  .quad 0
+  .section  .debug_abbrev,"",@progbits
+.Lsection_abbrev:
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 37                      # DW_AT_producer
+  .byte 14                      # DW_FORM_strp
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 27                      # DW_AT_comp_dir
+  .byte 14                      # DW_FORM_strp
+  .ascii  "\341\177"              # DW_AT_APPLE_optimized
+  .byte 25                      # DW_FORM_flag_present
+  .byte 17                      # DW_AT_low_pc
+  .byte 1                       # DW_FORM_addr
+  .byte 18                      # DW_AT_high_pc
+  .byte 6                       # DW_FORM_data4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 2                       # Abbreviation Code
+  .byte 46                      # DW_TAG_subprogram
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 17                      # DW_AT_low_pc
+  .byte 1                       # DW_FORM_addr
+  .byte 18                      # DW_AT_high_pc
+  .byte 6                       # DW_FORM_data4
+  .ascii  "\347\177"              # DW_AT_APPLE_omit_frame_ptr
+  .byte 25                      # DW_FORM_flag_present
+  .byte 64                      # DW_AT_frame_base
+  .byte 24                      # DW_FORM_exprloc
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 39                      # DW_AT_prototyped
+  .byte 25                      # DW_FORM_flag_present
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 63                      # DW_AT_external
+  .byte 25                      # DW_FORM_flag_present
+  .ascii  "\341\177"              # DW_AT_APPLE_optimized
+  .byte 25                      # DW_FORM_flag_present
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 3                       # Abbreviation Code
+  .byte 5                       # DW_TAG_formal_parameter
+  .byte 0                       # DW_CHILDREN_no
+  .byte 2                       # DW_AT_location
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 4                       # Abbreviation Code
+  .byte 15                      # DW_TAG_pointer_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 5                       # Abbreviation Code
+  .byte 36                      # DW_TAG_base_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 62                      # DW_AT_encoding
+  .byte 11                      # DW_FORM_data1
+  .byte 11                      # DW_AT_byte_size
+  .byte 11                      # DW_FORM_data1
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lsection_info:
+.Lcu_begin0:
+  .long 133                     # Length of Unit
+  .short  4                       # DWARF version number
+  .long .Lsection_abbrev        # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] 0xb:0x7e DW_TAG_compile_unit
+  .long .Linfo_string0          # DW_AT_producer
+  .short  12                      # DW_AT_language
+  .long .Linfo_string1          # DW_AT_name
+  .long .Lline_table_start0     # DW_AT_stmt_list
+  .long .Linfo_string2          # DW_AT_comp_dir
+                                        # DW_AT_APPLE_optimized
+  .quad .Lfunc_begin0           # DW_AT_low_pc
+  .long .Lfunc_end1-.Lfunc_begin0 # DW_AT_high_pc
+  .byte 2                       # Abbrev [2] 0x2a:0x29 DW_TAG_subprogram
+  .quad .Lfunc_begin0           # DW_AT_low_pc
+  .long .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
+                                        # DW_AT_APPLE_omit_frame_ptr
+  .byte 1                       # DW_AT_frame_base
+  .byte 87
+  .long .Linfo_string3          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 1                       # DW_AT_decl_line
+                                        # DW_AT_prototyped
+  .long 124                     # DW_AT_type
+                                        # DW_AT_external
+                                        # DW_AT_APPLE_optimized
+  .byte 3                       # Abbrev [3] 0x43:0xf DW_TAG_formal_parameter
+  .long .Ldebug_loc0            # DW_AT_location
+  .long .Linfo_string6          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 1                       # DW_AT_decl_line
+  .long 124                     # DW_AT_type
+  .byte 0                       # End Of Children Mark
+  .byte 2                       # Abbrev [2] 0x53:0x29 DW_TAG_subprogram
+  .quad .Lfunc_begin1           # DW_AT_low_pc
+  .long .Lfunc_end1-.Lfunc_begin1 # DW_AT_high_pc
+                                        # DW_AT_APPLE_omit_frame_ptr
+  .byte 1                       # DW_AT_frame_base
+  .byte 87
+  .long .Linfo_string5          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 5                       # DW_AT_decl_line
+                                        # DW_AT_prototyped
+  .long 124                     # DW_AT_type
+                                        # DW_AT_external
+                                        # DW_AT_APPLE_optimized
+  .byte 3                       # Abbrev [3] 0x6c:0xf DW_TAG_formal_parameter
+  .long .Ldebug_loc1            # DW_AT_location
+  .long .Linfo_string6          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 5                       # DW_AT_decl_line
+  .long 124                     # DW_AT_type
+  .byte 0                       # End Of Children Mark
+  .byte 4                       # Abbrev [4] 0x7c:0x5 DW_TAG_pointer_type
+  .long 129                     # DW_AT_type
+  .byte 5                       # Abbrev [5] 0x81:0x7 DW_TAG_base_type
+  .long .Linfo_string4          # DW_AT_name
+  .byte 5                       # DW_AT_encoding
+  .byte 4                       # DW_AT_byte_size
+  .byte 0                       # End Of Children Mark
+  .section  .debug_ranges,"",@progbits
+.Ldebug_range:
+  .section  .debug_macinfo,"",@progbits
+  .byte 0                       # End Of Macro List Mark
+  .section  .debug_pubnames,"",@progbits
+  .long .LpubNames_end0-.LpubNames_begin0 # Length of Public Names Info
+.LpubNames_begin0:
+  .short  2                       # DWARF Version
+  .long .Lcu_begin0             # Offset of Compilation Unit Info
+  .long 137                     # Compilation Unit Length
+  .long 42                      # DIE offset
+  .asciz  "foo"                   # External Name
+  .long 83                      # DIE offset
+  .asciz  "bar"                   # External Name
+  .long 0                       # End Mark
+.LpubNames_end0:
+  .section  .debug_pubtypes,"",@progbits
+  .long .LpubTypes_end0-.LpubTypes_begin0 # Length of Public Types Info
+.LpubTypes_begin0:
+  .short  2                       # DWARF Version
+  .long .Lcu_begin0             # Offset of Compilation Unit Info
+  .long 137                     # Compilation Unit Length
+  .long 129                     # DIE offset
+  .asciz  "int"                   # External Name
+  .long 0                       # End Mark
+.LpubTypes_end0:
+
+  .ident  "clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)"
+  .section  ".note.GNU-stack","",@progbits
+  .section  .debug_line,"",@progbits
+.Lline_table_start0: