[DWARFVerifier] Use the new location list api

[labath]

Summary

Instead of going to the debug_loc section directly, use new
DWARFDie::getLocations instead. This means that the code will now
automatically support debug_loclists sections.

This is the last usage of the old debug_loc methods, and they can now be
removed.

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

 public:
   DWARFDebugLoc(DWARFDataExtractor Data)
       : DWARFLocationTable(std::move(Data)) {}
 
   /// Print the location lists found within the debug_loc section.
   void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo, DIDumpOptions DumpOpts,
             Optional<uint64_t> Offset) const;
 
-  /// Parse the debug_loc section.
-  void parse();
-
-  /// Return the location list at the given offset or nullptr.
-  LocationList const *getLocationListAtOffset(uint64_t Offset) const;
-
   Error visitLocationList(
       uint64_t *Offset,
       function_ref<bool(const DWARFLocationEntry &)> Callback) const override;
 
-  Expected<LocationList> parseOneLocationList(uint64_t *Offset);
-
 protected:
   void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
                     unsigned Indent) const override;
 };
 
 class DWARFDebugLoclists final : public DWARFLocationTable {
 public:
   DWARFDebugLoclists(DWARFDataExtractor Data, uint16_t Version)

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

const DWARFDebugLoc *DWARFContext::getDebugLoc() {
 
   // Assume all units have the same address byte size.
   auto LocData =
       getNumCompileUnits()
           ? DWARFDataExtractor(*DObj, DObj->getLocSection(), isLittleEndian(),
                                getUnitAtIndex(0)->getAddressByteSize())
           : DWARFDataExtractor("", isLittleEndian(), 0);
   Loc.reset(new DWARFDebugLoc(std::move(LocData)));
-  Loc->parse();
   return Loc.get();
 }
 
 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
   if (Aranges)
     return Aranges.get();
 
   Aranges.reset(new DWARFDebugAranges());

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

return visitLocationList(&Offset, [&](const DWARFLocationEntry &E) {
     if (!Loc)
       return Callback(Loc.takeError());
     if (*Loc)
       return Callback(**Loc);
     return true;
   });
 }
 
-DWARFDebugLoc::LocationList const *
-DWARFDebugLoc::getLocationListAtOffset(uint64_t Offset) const {
-  auto It = partition_point(
-      Locations, [=](const LocationList &L) { return L.Offset < Offset; });
-  if (It != Locations.end() && It->Offset == Offset)
-    return &(*It);
-  return nullptr;
-}
-
 void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
                          DIDumpOptions DumpOpts,
                          Optional<uint64_t> DumpOffset) const {
   auto BaseAddr = None;
   unsigned Indent = 12;
   if (DumpOffset) {
     dumpLocationList(&*DumpOffset, OS, BaseAddr, MRI, nullptr, DumpOpts,
                      Indent);
if (!C)
       return C.takeError();
     if (!Callback(E) || E.Kind == dwarf::DW_LLE_end_of_list)
       break;
   }
   *Offset = C.tell();
   return Error::success();
 }
 
-Expected<DWARFDebugLoc::LocationList>
-DWARFDebugLoc::parseOneLocationList(uint64_t *Offset) {
-  LocationList LL;
-  LL.Offset = *Offset;
-
-  Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
-    LL.Entries.push_back(E);
-    return true;
-  });
-  if (E)
-    return std::move(E);
-  return std::move(LL);
-}
-
-void DWARFDebugLoc::parse() {
-  uint64_t Offset = 0;
-  while (Offset < Data.getData().size()) {
-    if (auto LL = parseOneLocationList(&Offset))
-      Locations.push_back(std::move(*LL));
-    else {
-      logAllUnhandledErrors(LL.takeError(), WithColor::error());
-      break;
-    }
-  }
-}
-
 void DWARFDebugLoc::dumpRawEntry(const DWARFLocationEntry &Entry,
                                  raw_ostream &OS, unsigned Indent) const {
   uint64_t Value0, Value1;
   switch (Entry.Kind) {
   case dwarf::DW_LLE_base_address:
     Value0 = Data.getAddressSize() == 4 ? -1U : -1ULL;
     Value1 = Entry.Value0;
     break;

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
       if (*SectionOffset >= DObj.getLineSection().Data.size())
         ReportError("DW_AT_stmt_list offset is beyond .debug_line bounds: " +
                     llvm::formatv("{0:x8}", *SectionOffset));
       break;
     }
     ReportError("DIE has invalid DW_AT_stmt_list encoding:");
     break;
   case DW_AT_location: {
-    auto VerifyLocationExpr = [&](ArrayRef<uint8_t> D) {
+    if (Expected<std::vector<DWARFLocationExpression>> Loc =
+            Die.getLocations(DW_AT_location)) {
       DWARFUnit *U = Die.getDwarfUnit();
-      DataExtractor Data(toStringRef(D), DCtx.isLittleEndian(), 0);
+      for (const auto &Entry : *Loc) {
+        DataExtractor Data(toStringRef(Entry.Expr), DCtx.isLittleEndian(), 0);
         DWARFExpression Expression(Data, U->getVersion(),
                                    U->getAddressByteSize());
-      bool Error = llvm::any_of(Expression, [](DWARFExpression::Operation &Op) {
+        bool Error = any_of(Expression, [](DWARFExpression::Operation &Op) {
           return Op.isError();
         });
         if (Error || !Expression.verify(U))
           ReportError("DIE contains invalid DWARF expression:");
-    };
-    if (Optional<ArrayRef<uint8_t>> Expr = AttrValue.Value.getAsBlock()) {
-      // Verify inlined location.
-      VerifyLocationExpr(*Expr);
-    } else if (auto LocOffset = AttrValue.Value.getAsSectionOffset()) {
-      // Verify location list.
-      if (auto DebugLoc = DCtx.getDebugLoc())
-        if (auto LocList = DebugLoc->getLocationListAtOffset(*LocOffset))
-          for (const auto &Entry : LocList->Entries)
-            VerifyLocationExpr(Entry.Loc);
       }
+    } else
+      ReportError(toString(Loc.takeError()));
     break;
   }
   case DW_AT_specification:
   case DW_AT_abstract_origin: {
     if (auto ReferencedDie = Die.getAttributeValueAsReferencedDie(Attr)) {
       auto DieTag = Die.getTag();
       auto RefTag = ReferencedDie.getTag();
       if (DieTag == RefTag)
handleAllErrors(EntryOr.takeError(),
                                    NI.getUnitOffset(), NTE.getIndex(), Str,
                                    Info.message());
                     ++NumErrors;
                   });
   return NumErrors;
 }
 
 static bool isVariableIndexable(const DWARFDie &Die, DWARFContext &DCtx) {
-  Optional<DWARFFormValue> Location = Die.findRecursively(DW_AT_location);
-  if (!Location)
+  Expected<std::vector<DWARFLocationExpression>> Loc =
+      Die.getLocations(DW_AT_location);
+  if (!Loc) {
+    consumeError(Loc.takeError());
     return false;
-
-  auto ContainsInterestingOperators = [&](ArrayRef<uint8_t> D) {
-    DWARFUnit *U = Die.getDwarfUnit();
-    DataExtractor Data(toStringRef(D), DCtx.isLittleEndian(), U->getAddressByteSize());
+  }
+  for (const auto &Entry : *Loc) {
+    DataExtractor Data(toStringRef(Entry.Expr), DCtx.isLittleEndian(),
+                       U->getAddressByteSize());
     DWARFExpression Expression(Data, U->getVersion(), U->getAddressByteSize());
-    return any_of(Expression, [](DWARFExpression::Operation &Op) {
+    bool IsInteresting = any_of(Expression, [](DWARFExpression::Operation &Op) {
       return !Op.isError() && (Op.getCode() == DW_OP_addr ||
                                Op.getCode() == DW_OP_form_tls_address ||
                                Op.getCode() == DW_OP_GNU_push_tls_address);
     });
-  };
-
-  if (Optional<ArrayRef<uint8_t>> Expr = Location->getAsBlock()) {
-    // Inlined location.
-    if (ContainsInterestingOperators(*Expr))
-      return true;
-  } else if (Optional<uint64_t> Offset = Location->getAsSectionOffset()) {
-    // Location list.
-    if (const DWARFDebugLoc *DebugLoc = DCtx.getDebugLoc()) {
-      if (const DWARFDebugLoc::LocationList *LocList =
-              DebugLoc->getLocationListAtOffset(*Offset)) {
-        if (any_of(LocList->Entries, [&](const DWARFLocationEntry &E) {
-              return ContainsInterestingOperators(E.Loc);
-            }))
-          return true;
-      }
-    }
-  }
+    if (IsInteresting)
   return false;
 }
 
 unsigned DWARFVerifier::verifyNameIndexCompleteness(
     const DWARFDie &Die, const DWARFDebugNames::NameIndex &NI) {
 
   // First check, if the Die should be indexed. The code follows the DWARF v5
   // wording as closely as possible.

llvm/test/tools/llvm-dwarfdump/X86/debug-names-verify-completeness.s

.Lloc0_end:
         .quad   0
 
         .section        .debug_abbrev,"",@progbits
         .byte   1                       # Abbreviation Code
         .byte   17                      # DW_TAG_compile_unit
         .byte   1                       # DW_CHILDREN_yes
         .byte   37                      # DW_AT_producer
         .byte   8                       # DW_FORM_string
+        .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   52                      # DW_TAG_variable
         .byte   0                       # DW_CHILDREN_no
         .byte   3                       # DW_AT_name
         .byte   8                       # DW_FORM_string
.Lloc0_end:
         .byte   8                       # DW_FORM_string
         .byte   82                      # DW_AT_entry_pc
         .byte   1                       # DW_FORM_addr
         .byte   0                       # EOM(1)
         .byte   0                       # EOM(2)
 
         .byte   0                       # EOM(3)
         .section        .debug_info,"",@progbits
+
 .Lcu_begin0:
         .long   .Lcu_end0-.Lcu_start0   # Length of Unit
 .Lcu_start0:
         .short  4                       # DWARF version number
         .long   .debug_abbrev           # Offset Into Abbrev. Section
         .byte   8                       # Address Size (in bytes)
         .byte   1                       # Abbrev [1] DW_TAG_compile_unit
         .asciz  "hand-written DWARF"    # DW_AT_producer
+        .quad   0x0                     # DW_AT_low_pc
+        .long   0x100                   # DW_AT_high_pc
 
         .byte   4                       # Abbrev [4] DW_TAG_namespace
         .asciz  "namesp"                # DW_AT_name
         .byte   2                       # Abbrev [2] DW_TAG_variable
         .asciz  "var_block_addr"        # DW_AT_name
         .byte   9                       # DW_AT_location
         .byte   3                       # DW_OP_addr
         .quad   0x47