[dwarfdump] Add -lookup option

[JDevlieghere]

Summary

Add the option to lookup an address in the debug information and print
out the file, function, block and line table details, as well as the relevant
DIEs.

This mirrors the functionality from dwarfdump classic.

[aprantl]

include/llvm/DebugInfo/DIContext.h

61

return *this != DILineInfo(); ?

include/llvm/DebugInfo/DWARF/DWARFContext.h

262

use a struct with named fields for better readability?

I assume this doesn't make sense as an optional because either of the fields may be not available and all are nullable. Yes, that seems ok.

include/llvm/DebugInfo/DWARF/DWARFUnit.h

332

remove getSubroutineForAddress -.

lib/DebugInfo/DWARF/DWARFContext.cpp

748

Worklist.insert(Worklist.end(), DIE.children_begin(), DIE.children_end())?

hmm... this maybe looks worse actually.

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

247

repeat the desc int the doxygen comment so it is more clear what the function is supposed to do?

263

should this code live in a DILineInfo::dump() function?

276

extra {}

[JDevlieghere]

• CR comments Adrian

[JDevlieghere]

include/llvm/DebugInfo/DWARF/DWARFUnit.h

332

Note to self: reflow comment

[aprantl]

Thanks! (Minor nitpick + future work inside :-)

include/llvm/DebugInfo/DIContext.h

64

optimization opportunity: this and the fact that we initialize the std::string with "<invalid>" seems kind of expensive. Perhaps switch to StringRef and handle the empty string in dump()?

lib/DebugInfo/DWARF/DWARFContext.cpp

748

extra {}

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

264

extra {}

[JDevlieghere]

include/llvm/DebugInfo/DIContext.h

64

What exactly o you want to switch to StringRef? Do you mean storing an empty string and having a getter that returns it as a StringRef or "<invalid>" if it's empty?

[aprantl]

Instead of storing a std::string containing a copy of filename and dir, we might be able to just use a StringRef and share the storage for the payload.

[dblaikie]

llvm/trunk/include/llvm/DebugInfo/DIContext.h

60 ↗

(On Diff #117545)

This should be explicit (implicit bool conversion operators are problematic - can easily convert to int, etc)

60 ↗

(On Diff #117545)

I probably wouldn't bother with the () around '*this'.

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

265 ↗

(On Diff #117545)

explicit

llvm/trunk/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

297–302 ↗

(On Diff #117545)

What if the subprogram DIE is nested within namespaces? (GCC doesn't do this (put subprogram definitions at nested namespace scope), but LLVM does) I'd expect dumping just the subprogram to dump the parent scopes in some way? (namespaces, classes, other functions, etc - maybe all abbreviated to just their name?)

include/llvm/DebugInfo/DIContext.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DICONTEXT_H
 #define LLVM_DEBUGINFO_DICONTEXT_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 
 namespace llvm {
 
-class raw_ostream;
-
 /// A format-neutral container for source line information.
 struct DILineInfo {
   std::string FileName;
   std::string FunctionName;
   uint32_t Line = 0;
   uint32_t Column = 0;
   uint32_t StartLine = 0;
 
   // DWARF-specific.
   uint32_t Discriminator = 0;
 
   DILineInfo() : FileName("<invalid>"), FunctionName("<invalid>") {}
 
   bool operator==(const DILineInfo &RHS) const {
     return Line == RHS.Line && Column == RHS.Column &&
            FileName == RHS.FileName && FunctionName == RHS.FunctionName &&
            StartLine == RHS.StartLine && Discriminator == RHS.Discriminator;
   }
+
   bool operator!=(const DILineInfo &RHS) const {
     return !(*this == RHS);
   }
+
   bool operator<(const DILineInfo &RHS) const {
     return std::tie(FileName, FunctionName, Line, Column, StartLine,
                     Discriminator) <
            std::tie(RHS.FileName, RHS.FunctionName, RHS.Line, RHS.Column,
                     RHS.StartLine, RHS.Discriminator);
   }
+
+  operator bool() const { return (*this) != DILineInfo(); }
+
+  void dump(raw_ostream &OS) {
+    OS << "Line info: ";
+    if (FileName != "<invalid>")
+      OS << "file '" << FileName << "', ";
+    if (FunctionName != "<invalid>")
+      OS << "function '" << FunctionName << "', ";
+    OS << "line " << Line << ", ";
+    OS << "column " << Column << ", ";
+    OS << "start line " << StartLine << '\n';
+  }
 };
 
 using DILineInfoTable = SmallVector<std::pair<uint64_t, DILineInfo>, 16>;
 
 /// A format-neutral container for inlined code description.
 class DIInliningInfo {
   SmallVector<DILineInfo, 4> Frames;
 

include/llvm/DebugInfo/DWARF/DWARFContext.h

public:
   const DWARFAcceleratorTable &getAppleNamespaces();
 
   /// Get a reference to the parsed accelerator table object.
   const DWARFAcceleratorTable &getAppleObjC();
 
   /// Get a pointer to a parsed line table corresponding to a compile unit.
   const DWARFDebugLine::LineTable *getLineTableForUnit(DWARFUnit *cu);
 
+  /// Wraps the returned DIEs for a given address.
+  struct DIEsForAddress {
+    DWARFCompileUnit *CompileUnit = nullptr;
+    DWARFDie FunctionDIE;
+    DWARFDie BlockDIE;
+    operator bool() const { return CompileUnit != nullptr; }
+  };
+
+  /// Get the compilation unit, the function DIE and lexical block DIE for the
+  /// given address where applicable.
+  DIEsForAddress getDIEsForAddress(uint64_t Address);
+
   DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
   DILineInfoTable getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
   DIInliningInfo getInliningInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
 
   bool isLittleEndian() const { return DObj->isLittleEndian(); }

include/llvm/DebugInfo/DWARF/DWARFUnit.h

DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {
     return DWARFDie(this, &DieArray[0]);
   }
 
   const char *getCompilationDir();
   Optional<uint64_t> getDWOId();
 
   void collectAddressRanges(DWARFAddressRangesVector &CURanges);
 
+  /// Returns subprogram DIE with address range
+  /// encompassing the provided address. The pointer is alive as long as parsed
+  /// compile unit DIEs are not cleared.
+  DWARFDie getSubroutineForAddress(uint64_t Address);
+
   /// getInlinedChainForAddress - fetches inlined chain for a given address.
   /// Returns empty chain if there is no subprogram containing address. The
   /// chain is valid as long as parsed compile unit DIEs are not cleared.
   void getInlinedChainForAddress(uint64_t Address,
                                  SmallVectorImpl<DWARFDie> &InlinedChain);
 
   /// getUnitSection - Return the DWARFUnitSection containing this unit.
   const DWARFUnitSectionBase &getUnitSection() const { return UnitSection; }
void extractDIEsToVector(bool AppendCUDie, bool AppendNonCUDIEs,
                            std::vector<DWARFDebugInfoEntry> &DIEs) const;
 
   /// clearDIEs - Clear parsed DIEs to keep memory usage low.
   void clearDIEs(bool KeepCUDie);
 
   /// parseDWO - Parses .dwo file for current compile unit. Returns true if
   /// it was actually constructed.
   bool parseDWO();
-
-  /// getSubroutineForAddress - Returns subprogram DIE with address range
-  /// encompassing the provided address. The pointer is alive as long as parsed
-  /// compile unit DIEs are not cleared.
-  DWARFDie getSubroutineForAddress(uint64_t Address);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFUNIT_H

lib/DebugInfo/DWARF/DWARFContext.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <string>
-#include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 using namespace object;
 
 #define DEBUG_TYPE "dwarf"

 
 DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
   // First, get the offset of the compile unit.
   uint32_t CUOffset = getDebugAranges()->findAddress(Address);
   // Retrieve the compile unit.
   return getCompileUnitForOffset(CUOffset);
 }
 
+DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address) {
+
+  DIEsForAddress Result;
+
+  DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
+  if (!CU)
+    return Result;
+
+  Result.CompileUnit = CU;
+  Result.FunctionDIE = CU->getSubroutineForAddress(Address);
+
+  std::vector<DWARFDie> Worklist;
+  Worklist.push_back(Result.FunctionDIE);
+  while (!Worklist.empty()) {
+    DWARFDie DIE = Worklist.back();
+    Worklist.pop_back();
+
+    if (DIE.getTag() == DW_TAG_lexical_block &&
+        DIE.addressRangeContainsAddress(Address)) {
+      Result.BlockDIE = DIE;
+      break;
+    }
+
+    for (auto Child : DIE) {
+      Worklist.push_back(Child);
+    }
+  }
+
+  return Result;
+}
+
 static bool getFunctionNameAndStartLineForAddress(DWARFCompileUnit *CU,
                                                   uint64_t Address,
                                                   FunctionNameKind Kind,
                                                   std::string &FunctionName,
                                                   uint32_t &StartLine) {
   // The address may correspond to instruction in some inlined function,
   // so we have to build the chain of inlined functions and take the
   // name of the topmost function in it.

lib/DebugInfo/DWARF/DWARFUnit.cpp

if (!Die)
     return DWARFDie();
   uint32_t Depth = Die->getDepth();
   // Unit DIEs always have a depth of zero and never have siblings.
   if (Depth == 0)
     return DWARFDie();
   // NULL DIEs don't have siblings.
   if (Die->getAbbreviationDeclarationPtr() == nullptr)
     return DWARFDie();
-  
   // Find the next DIE whose depth is the same as the Die's depth.
   for (size_t I = getDIEIndex(Die) + 1, EndIdx = DieArray.size(); I < EndIdx;
        ++I) {
     if (DieArray[I].getDepth() == Depth)
       return DWARFDie(this, &DieArray[I]);
   }
   return DWARFDie();
 }
 
 const DWARFAbbreviationDeclarationSet *DWARFUnit::getAbbreviations() const {
   if (!Abbrevs)
     Abbrevs = Abbrev->getAbbreviationDeclarationSet(AbbrOffset);
   return Abbrevs;
 }

test/tools/llvm-dwarfdump/X86/lookup.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
+# RUN:   | llvm-dwarfdump -lookup=0x6a6f6e6173 - | \
+# RUN: FileCheck %s --check-prefix=EMPTY --allow-empty
+# EMPTY: {{^$}}
+
+# RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
+# RUN:   | llvm-dwarfdump -lookup=0x4 - | \
+# RUN: FileCheck %s -check-prefixes=CHECK,LEX,A
+
+# RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
+# RUN:   | llvm-dwarfdump -lookup=0xb - | \
+# RUN: FileCheck %s -check-prefixes=CHECK,LEX,B
+
+# RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
+# RUN:   | llvm-dwarfdump -lookup=0x14 - | \
+# RUN: FileCheck %s -check-prefixes=CHECK,C
+
+# CHECK: Compile Unit: length = 0x00000060 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000064)
+
+# CHECK: DW_TAG_compile_unit
+# CHECK:   DW_AT_name        ("foo.c")
+# CHECK:   DW_AT_stmt_list   (0x00000000)
+# CHECK:   DW_AT_low_pc      (0x0000000000000000)
+# CHECK:   DW_AT_high_pc     (0x00000016)
+
+# CHECK: DW_TAG_subprogram
+# CHECK:     DW_AT_low_pc    (0x0000000000000000)
+# CHECK:     DW_AT_high_pc   (0x00000016)
+# CHECK:     DW_AT_name      ("foo")
+
+# LEX: DW_TAG_lexical_block
+# LEX:       DW_AT_low_pc  (0x0000000000000004)
+# LEX:       DW_AT_high_pc (0x00000010)
+
+# A: Line info: file 'foo.c', line 3, column 9, start line 1
+# B: Line info: file 'foo.c', line 4, column 6, start line 1
+# C: Line info: file 'foo.c', line 6, column 1, start line 1
+
+  .section  __TEXT,__text,regular,pure_instructions
+  .macosx_version_min 10, 13
+  .globl  _foo                    ## -- Begin function foo
+  .p2align  4, 0x90
+_foo:                                   ## @foo
+Lfunc_begin0:
+  .file 1 "foo.c"
+  .loc  1 1 0                   ## foo.c:1:0
+  .cfi_startproc
+## BB#0:                                ## %entry
+  pushq %rbp
+Lcfi0:
+  .cfi_def_cfa_offset 16
+Lcfi1:
+  .cfi_offset %rbp, -16
+  movq  %rsp, %rbp
+Lcfi2:
+  .cfi_def_cfa_register %rbp
+Ltmp0:
+  .loc  1 3 9 prologue_end      ## foo.c:3:9
+  movl  $1, -4(%rbp)
+  .loc  1 4 6                   ## foo.c:4:6
+  movl  -4(%rbp), %eax
+  addl  $1, %eax
+  movl  %eax, -4(%rbp)
+Ltmp1:
+  .loc  1 6 1                   ## foo.c:6:1
+  popq  %rbp
+  retq
+Ltmp2:
+Lfunc_end0:
+  .cfi_endproc
+                                        ## -- End function
+  .section  __DWARF,__debug_str,regular,debug
+Linfo_string:
+  .asciz  "clang version 6.0.0 (trunk 314509) (llvm/trunk 314517)" ## string offset=0
+  .asciz  "foo.c"                 ## string offset=55
+  .asciz  "/private/tmp"          ## string offset=61
+  .asciz  "foo"                   ## string offset=74
+  .asciz  "i"                     ## string offset=78
+  .asciz  "int"                   ## string offset=80
+  .section  __DWARF,__debug_abbrev,regular,debug
+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
+  .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
+  .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 63                      ## DW_AT_external
+  .byte 25                      ## DW_FORM_flag_present
+  .byte 0                       ## EOM(1)
+  .byte 0                       ## EOM(2)
+  .byte 3                       ## Abbreviation Code
+  .byte 11                      ## DW_TAG_lexical_block
+  .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
+  .byte 0                       ## EOM(1)
+  .byte 0                       ## EOM(2)
+  .byte 4                       ## Abbreviation Code
+  .byte 52                      ## DW_TAG_variable
+  .byte 0                       ## DW_CHILDREN_no
+  .byte 2                       ## DW_AT_location
+  .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 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  __DWARF,__debug_info,regular,debug
+Lsection_info:
+Lcu_begin0:
+  .long 96                      ## Length of Unit
+  .short  4                       ## DWARF version number
+Lset0 = Lsection_abbrev-Lsection_abbrev ## Offset Into Abbrev. Section
+  .long Lset0
+  .byte 8                       ## Address Size (in bytes)
+  .byte 1                       ## Abbrev [1] 0xb:0x59 DW_TAG_compile_unit
+  .long 0                       ## DW_AT_producer
+  .short  12                      ## DW_AT_language
+  .long 55                      ## DW_AT_name
+Lset1 = Lline_table_start0-Lsection_line ## DW_AT_stmt_list
+  .long Lset1
+  .long 61                      ## DW_AT_comp_dir
+  .quad Lfunc_begin0            ## DW_AT_low_pc
+Lset2 = Lfunc_end0-Lfunc_begin0         ## DW_AT_high_pc
+  .long Lset2
+  .byte 2                       ## Abbrev [2] 0x2a:0x32 DW_TAG_subprogram
+  .quad Lfunc_begin0            ## DW_AT_low_pc
+Lset3 = Lfunc_end0-Lfunc_begin0         ## DW_AT_high_pc
+  .long Lset3
+  .byte 1                       ## DW_AT_frame_base
+  .byte 86
+  .long 74                      ## DW_AT_name
+  .byte 1                       ## DW_AT_decl_file
+  .byte 1                       ## DW_AT_decl_line
+                                        ## DW_AT_external
+  .byte 3                       ## Abbrev [3] 0x3f:0x1c DW_TAG_lexical_block
+  .quad Ltmp0                   ## DW_AT_low_pc
+Lset4 = Ltmp1-Ltmp0                     ## DW_AT_high_pc
+  .long Lset4
+  .byte 4                       ## Abbrev [4] 0x4c:0xe DW_TAG_variable
+  .byte 2                       ## DW_AT_location
+  .byte 145
+  .byte 124
+  .long 78                      ## DW_AT_name
+  .byte 1                       ## DW_AT_decl_file
+  .byte 3                       ## DW_AT_decl_line
+  .long 92                      ## DW_AT_type
+  .byte 0                       ## End Of Children Mark
+  .byte 0                       ## End Of Children Mark
+  .byte 5                       ## Abbrev [5] 0x5c:0x7 DW_TAG_base_type
+  .long 80                      ## DW_AT_name
+  .byte 5                       ## DW_AT_encoding
+  .byte 4                       ## DW_AT_byte_size
+  .byte 0                       ## End Of Children Mark
+  .section  __DWARF,__debug_ranges,regular,debug
+Ldebug_range:
+  .section  __DWARF,__debug_macinfo,regular,debug
+Ldebug_macinfo:
+Lcu_macro_begin0:
+  .byte 0                       ## End Of Macro List Mark
+  .section  __DWARF,__apple_names,regular,debug
+Lnames_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 1                       ## Header Hash Count
+  .long 12                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 1                       ## HeaderData Atom Count
+  .short  1                       ## DW_ATOM_die_offset
+  .short  6                       ## DW_FORM_data4
+  .long 0                       ## Bucket 0
+  .long 193491849               ## Hash in Bucket 0
+  .long LNames0-Lnames_begin    ## Offset in Bucket 0
+LNames0:
+  .long 74                      ## foo
+  .long 1                       ## Num DIEs
+  .long 42
+  .long 0
+  .section  __DWARF,__apple_objc,regular,debug
+Lobjc_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 0                       ## Header Hash Count
+  .long 12                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 1                       ## HeaderData Atom Count
+  .short  1                       ## DW_ATOM_die_offset
+  .short  6                       ## DW_FORM_data4
+  .long -1                      ## Bucket 0
+  .section  __DWARF,__apple_namespac,regular,debug
+Lnamespac_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 0                       ## Header Hash Count
+  .long 12                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 1                       ## HeaderData Atom Count
+  .short  1                       ## DW_ATOM_die_offset
+  .short  6                       ## DW_FORM_data4
+  .long -1                      ## Bucket 0
+  .section  __DWARF,__apple_types,regular,debug
+Ltypes_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 1                       ## Header Hash Count
+  .long 20                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 3                       ## HeaderData Atom Count
+  .short  1                       ## DW_ATOM_die_offset
+  .short  6                       ## DW_FORM_data4
+  .short  3                       ## DW_ATOM_die_tag
+  .short  5                       ## DW_FORM_data2
+  .short  4                       ## DW_ATOM_type_flags
+  .short  11                      ## DW_FORM_data1
+  .long 0                       ## Bucket 0
+  .long 193495088               ## Hash in Bucket 0
+  .long Ltypes0-Ltypes_begin    ## Offset in Bucket 0
+Ltypes0:
+  .long 80                      ## int
+  .long 1                       ## Num DIEs
+  .long 92
+  .short  36
+  .byte 0
+  .long 0
+
+.subsections_via_symbols
+  .section  __DWARF,__debug_line,regular,debug
+Lsection_line:
+Lline_table_start0:

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

ArchFilters("arch",
                 cat(DwarfDumpCategory));
 static list<std::string>
     Find("find",
          desc("Search for the exact match for <name> in the accelerator tables "
               "and print the matching debug information entries."),
          value_desc("name"), cat(DwarfDumpCategory));
 static alias FindAlias("f", desc("Alias for -find"), aliasopt(Find));
 
+static opt<uint64_t>
+    Lookup("lookup",
+           desc("Lookup <address> in the debug information and print out any"
+                "available file, function, block and line table details."),
+           value_desc("address"), cat(DwarfDumpCategory));
+
 static opt<bool> DumpUUID("uuid", desc("Show the UUID for each architecture"),
                           cat(DwarfDumpCategory));
 static alias DumpUUIDAlias("u", desc("Alias for -uuid"), aliasopt(DumpUUID));
 static opt<std::string>
     OutputFilename("out-file", cl::init(""),
-                   cl::desc("Redirect output to the specified file"),
-                   cl::value_desc("filename"));
+                   cl::desc("Redirect output to <filename>"),
+                   cl::value_desc("filename"), cat(DwarfDumpCategory));
 static alias OutputFilenameAlias("o", desc("Alias for -out-file"),
-                                 aliasopt(OutputFilename),
-                                 cat(DwarfDumpCategory));
+                                 aliasopt(OutputFilename));
 static opt<bool>
     ShowChildren("show-children",
                  desc("Show a debug info entry's children when selectively "
                       "printing with the =<offset> option"),
                  cat(DwarfDumpCategory));
 static alias ShowChildrenAlias("c", desc("Alias for -show-children"),
                                aliasopt(ShowChildren));
 static opt<bool>
     ShowParents("show-parents",
                 desc("Show a debug info entry's parents when selectively "
                      "printing with the =<offset> option"),
                 cat(DwarfDumpCategory));
 static alias ShowParentsAlias("p", desc("Alias for -show-parents"),
                               aliasopt(ShowParents));
 static opt<unsigned> RecurseDepth(
     "recurse-depth",
     desc("Only recurse to a depth of N when displaying debug info entries."),
     cat(DwarfDumpCategory), init(-1U), value_desc("N"));
 static alias RecurseDepthAlias("r", desc("Alias for -recurse-depth"),
                                aliasopt(RecurseDepth));
-  
 static opt<bool>
     SummarizeTypes("summarize-types",
                    desc("Abbreviate the description of type unit entries"),
                    cat(DwarfDumpCategory));
 static opt<bool> Verify("verify", desc("Verify the DWARF debug info"),
                         cat(DwarfDumpCategory));
 static opt<bool> Quiet("quiet", desc("Use with -verify to not emit to STDOUT."),
                        cat(DwarfDumpCategory));
if (auto *MachO = dyn_cast<MachOObjectFile>(&Obj)) {
     }
   }
   return false;
 }
 
 using HandlerFn = std::function<bool(ObjectFile &, DWARFContext &DICtx, Twine,
                                      raw_ostream &)>;
 
+/// Handle the --lookup option and dump the DIEs and line info for the given
+/// address.
+static bool lookup(DWARFContext &DICtx, uint64_t Address, raw_ostream &OS) {
+  auto DIEsForAddr = DICtx.getDIEsForAddress(Lookup);
+
+  if (!DIEsForAddr)
+    return false;
+
+  DIDumpOptions DumpOpts = getDumpOpts();
+  DumpOpts.RecurseDepth = 0;
+  DIEsForAddr.CompileUnit->dump(OS, DumpOpts);
+  if (DIEsForAddr.FunctionDIE) {
+    DIEsForAddr.FunctionDIE.dump(OS, 2, DumpOpts);
+    if (DIEsForAddr.BlockDIE)
+      DIEsForAddr.BlockDIE.dump(OS, 4, DumpOpts);
+  }
+
+  if (DILineInfo LineInfo = DICtx.getLineInfoForAddress(Lookup)) {
+    LineInfo.dump(OS);
+  }
+
+  return true;
+}
+
 static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx, Twine Filename,
                            raw_ostream &OS) {
   logAllUnhandledErrors(DICtx.loadRegisterInfo(Obj), errs(),
                         Filename.str() + ": ");
+  // Handle the --lookup option.
+  if (Lookup)
+    return lookup(DICtx, Lookup, OS);
 
   // Handle the --find option and lower it to --debug-info=<offset>.
   if (!Find.empty()) {
     DumpOffsets[DIDT_ID_DebugInfo] = [&]() -> llvm::Optional<uint64_t> {
       for (auto Name : Find) {
         auto find = [&](const DWARFAcceleratorTable &Accel)
             -> llvm::Optional<uint64_t> {
           for (auto Entry : Accel.equal_range(Name))
DumpOffsets[DIDT_ID_DebugInfo] = [&]() -> llvm::Optional<uint64_t> {
           return DumpOffsets[DIDT_ID_DebugInfo] = *Offset;
       }
       return None;
     }();
     // Early exit if --find was specified but the current file doesn't have it.
     if (!DumpOffsets[DIDT_ID_DebugInfo])
       return true;
   }
-  
   // The UUID dump already contains all the same information.
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
     OS << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 
   // Dump the complete DWARF structure.
   DICtx.dump(OS, getDumpOpts(), DumpOffsets);
   return true;
 }