DWARFDebugLoclists: Add an api to get the location lists of a DWARF unit

[labath]

Summary

This avoid the need to duplicate the location lists searching logic in
various users. The "inline location list dumping" code (which is the
only user actually updated to handle DWARF v5 location lists) is
switched to this method. After adding v4 location list support, I'll
switch other users too.

[JDevlieghere]

LGTM

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 #include "llvm/Support/DataExtractor.h"
class DWARFUnit {
   DWARFContext &Context;
   /// Section containing this DWARFUnit.
   const DWARFSection &InfoSection;
 
   DWARFUnitHeader Header;
   const DWARFDebugAbbrev *Abbrev;
   const DWARFSection *RangeSection;
   uint64_t RangeSectionBase;
-  /// We either keep track of the location list section or its data, depending
-  /// on whether we are handling a split DWARF section or not.
-  union {
-    const DWARFSection *LocSection;
-    StringRef LocSectionData;
-  };
+
+  /// Section containing the location lists of this unit used for non-split
+  /// DWARF<=v4 units.
+
+  /// Location table of this unit. Used for DWARF v5 and DWO units.
+  std::unique_ptr<DWARFLocationTable> LocTable;
+
   const DWARFSection &LineSection;
   StringRef StringSection;
   const DWARFSection &StringOffsetSection;
   const DWARFSection *AddrOffsetSection;
   uint32_t AddrOffsetSectionBase = 0;
   bool isLittleEndian;
   bool IsDWO;
   const DWARFUnitVector &UnitVector;
DWARFUnit(DWARFContext &Context, const DWARFSection &Section,
             const DWARFUnitVector &UnitVector);
 
   virtual ~DWARFUnit();
 
   bool isDWOUnit() const { return IsDWO; }
   DWARFContext& getContext() const { return Context; }
   const DWARFSection &getInfoSection() const { return InfoSection; }
   const DWARFSection *getLocSection() const { return LocSection; }
-  StringRef getLocSectionData() const { return LocSectionData; }
   uint64_t getOffset() const { return Header.getOffset(); }
   const dwarf::FormParams &getFormParams() const {
     return Header.getFormParams();
   }
   uint16_t getVersion() const { return Header.getVersion(); }
   uint8_t getAddressByteSize() const { return Header.getAddressByteSize(); }
   uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); }
   uint8_t getDwarfOffsetByteSize() const {
public:
   Optional<uint64_t> getStringOffsetSectionItem(uint32_t Index) const;
 
   DWARFDataExtractor getDebugInfoExtractor() const;
 
   DataExtractor getStringExtractor() const {
     return DataExtractor(StringSection, false, 0);
   }
 
+  const DWARFLocationTable *getLocationTable() { return LocTable.get(); }
+
   /// Extract the range list referenced by this compile unit from the
   /// .debug_ranges section. If the extraction is unsuccessful, an error
   /// is returned. Successful extraction requires that the compile unit
   /// has already been extracted.
   Error extractRangeList(uint64_t RangeListOffset,
                          DWARFDebugRangeList &RangeList) const;
   void clear();
 

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||
     DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()),
                        Ctx.isLittleEndian(), 0);
     DWARFExpression(Data, U->getVersion(), U->getAddressByteSize())
         .print(OS, MRI, U);
     return;
   }
 
   if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
+    auto LLDumpOpts = DumpOpts;
+    LLDumpOpts.Verbose = false;
+
     uint64_t Offset = *FormValue.getAsSectionOffset();
     uint64_t BaseAddr = 0;
     if (Optional<object::SectionedAddress> BA = U->getBaseAddress())
       BaseAddr = BA->Address;
-    auto LLDumpOpts = DumpOpts;
-    LLDumpOpts.Verbose = false;
 
-    if (!U->isDWOUnit() && !U->getLocSection()->Data.empty()) {
-      DWARFDebugLoc DebugLoc;
-      DWARFDataExtractor Data(Obj, *U->getLocSection(), Ctx.isLittleEndian(),
-                              Obj.getAddressSize());
+    if (const DWARFLocationTable *LT = U->getLocationTable()) {
+      LT->dumpLocationList(&Offset, OS, BaseAddr, MRI, U, LLDumpOpts, Indent);
+      return;
+    }
+
 
-      FormValue.dump(OS, DumpOpts);
-      OS << ": ";
 
-      if (Expected<DWARFDebugLoc::LocationList> LL =
-              DebugLoc.parseOneLocationList(Data, &Offset)) {
-        LL->dump(OS, BaseAddr, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI,
-                 U, LLDumpOpts, Indent);
-      } else {
-        OS << '\n';
-        OS.indent(Indent);
-        OS << formatv("error extracting location list: {0}",
-                      fmt_consume(LL.takeError()));
-      }
-      return;
-    }
+      LL->dump(OS, BaseAddr, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, U,
+               LLDumpOpts, Indent);
 
-    bool UseLocLists = !U->isDWOUnit();
-    auto Data =
-        UseLocLists
-            ? DWARFDataExtractor(Obj, Obj.getLoclistsSection(),
-                                 Ctx.isLittleEndian(), Obj.getAddressSize())
-            : DWARFDataExtractor(U->getLocSectionData(), Ctx.isLittleEndian(),
-                                 Obj.getAddressSize());
-
-    if (!Data.getData().empty()) {
-      // Old-style location list were used in DWARF v4 (.debug_loc.dwo section).
-      // Modern locations list (.debug_loclists) are used starting from v5.
-      // Ideally we should take the version from the .debug_loclists section
-      // header, but using CU's version for simplicity.
-      DWARFDebugLoclists(Data, UseLocLists ? U->getVersion() : 4)
-          .dumpLocationList(&Offset, OS, BaseAddr, MRI, U, LLDumpOpts, Indent);
-    }
-    return;
-  }
-
   FormValue.dump(OS, DumpOpts);
 }
 
 /// Dump the name encoded in the type tag.
 static void dumpTypeTagName(raw_ostream &OS, dwarf::Tag T) {
   StringRef TagStr = TagString(T);
   if (!TagStr.startswith("DW_TAG_") || !TagStr.endswith("_type"))
     return;

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
                      StringRef SS, const DWARFSection &SOS,
                      const DWARFSection *AOS, const DWARFSection &LS, bool LE,
                      bool IsDWO, const DWARFUnitVector &UnitVector)
     : Context(DC), InfoSection(Section), Header(Header), Abbrev(DA),
       RangeSection(RS), LocSection(LocSection), LineSection(LS),
       StringSection(SS), StringOffsetSection(SOS), AddrOffsetSection(AOS),
       isLittleEndian(LE), IsDWO(IsDWO), UnitVector(UnitVector) {
   clear();
-  // For split DWARF we only need to keep track of the location list section's
-  // data (no relocations), and if we are reading a package file, we need to
-  // adjust the location list data based on the index entries.
   if (IsDWO) {
-    LocSectionData = LocSection->Data;
+    // If we are reading a package file, we need to adjust the location list
+    // data based on the index entries.
+    StringRef Data = LocSection->Data;
     if (auto *IndexEntry = Header.getIndexEntry())
       if (const auto *C = IndexEntry->getOffset(DW_SECT_LOC))
-        LocSectionData = LocSectionData.substr(C->Offset, C->Length);
+        Data = Data.substr(C->Offset, C->Length);
+    LocTable = std::make_unique<DWARFDebugLoclists>(
+        DWARFDataExtractor(Data, isLittleEndian, getAddressByteSize()),
+        Header.getVersion());
+  } else if (Header.getVersion() >= 5) {
+    LocTable = std::make_unique<DWARFDebugLoclists>(
+        DWARFDataExtractor(Context.getDWARFObj(),
+                           Context.getDWARFObj().getLoclistsSection(),
+                           isLittleEndian, getAddressByteSize()),
+        Header.getVersion());
   }
 }
 
 DWARFUnit::~DWARFUnit() = default;
 
 DWARFDataExtractor DWARFUnit::getDebugInfoExtractor() const {
   return DWARFDataExtractor(Context.getDWARFObj(), InfoSection, isLittleEndian,
                             getAddressByteSize());