Re-land "[dwarfdump] Add -lookup option"

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

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

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@316619 91177308-0d34-0410-b5e6-96231b3b80d8

Author: JDevlieghere

include/llvm/DebugInfo/DIContext.h

@@ -17,6 +17,7 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
@@ -26,8 +27,6 @@
 
 namespace llvm {
 
-class raw_ostream;
-
 /// A format-neutral container for source line information.
 struct DILineInfo {
   std::string FileName;
@@ -46,15 +45,30 @@ struct DILineInfo {
            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);
   }
+
+  explicit 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>;

include/llvm/DebugInfo/DWARF/DWARFContext.h

@@ -257,6 +257,18 @@ class DWARFContext : public DIContext {
   /// 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;
+    explicit 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,

include/llvm/DebugInfo/DWARF/DWARFUnit.h

@@ -338,6 +338,11 @@ class DWARFUnit {
 
   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.
@@ -421,11 +426,6 @@ class DWARFUnit {
   /// 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

lib/DebugInfo/DWARF/DWARFContext.cpp

@@ -48,7 +48,6 @@
 #include <cstdint>
 #include <map>
 #include <string>
-#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -723,6 +722,35 @@ DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
   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,

lib/DebugInfo/DWARF/DWARFUnit.cpp

@@ -440,7 +440,7 @@ DWARFDie DWARFUnit::getSibling(const DWARFDebugInfoEntry *Die) {
   // 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) {