[DWARF] Add support for parsing/dumping section indices in location lists

[labath]

Summary

This does exactly what it says on the box. The only small gotcha is the
section index computation for offset_pair entries, which can use either
the base address section, or the section from the offset_pair entry.
This is to support both the cases where the base address is relocated
(points to the base of the CU, typically), and the case where the base
address is a constant (typically zero) and relocations are on the
offsets themselves.

[labath]

This patch doesn't change the dump format for the "raw" entries, but it creates a good opportunity to do that.

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

8–11

I thought this layout would make the verbose/regular dump differences more obvious, but it could be just confusing...

[aprantl]

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

8–11

If it *works* I think this is good. In the past I've encountered very unintuitive behavior when combining multiple --check-prefix options and -NEXT, but it looks like you are using it to the intended effect here.

[labath]

Thanks.

Do you have any opinion on what should be the format of "raw" debug loc entries? (a, b) ".sect", [a,b] ".sect", {a, b} ".sect", etc. ?

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

struct DWARFLocationEntry {
   uint8_t Kind;
 
   /// The first value of the location entry (if applicable).
   uint64_t Value0;
 
   /// The second value of the location entry (if applicable).
   uint64_t Value1;
 
+  /// The index of the section this entry is relative to (if applicable).
+  uint64_t SectionIndex;
+
   /// The location expression itself (if applicable).
   SmallVector<uint8_t, 4> Loc;
 };
 
 /// An abstract base class for various kinds of location tables (.debug_loc,
 /// .debug_loclists, and their dwo variants).
 class DWARFLocationTable {
 public:
virtual Error visitLocationList(
       function_ref<bool(const DWARFLocationEntry &)> Callback) const = 0;
 
   /// Dump the location list at the given \p Offset. The function returns true
   /// iff it has successfully reched the end of the list. This means that one
   /// can attempt to parse another list after the current one (\p Offset will be
   /// updated to point past the end of the current list).
   bool dumpLocationList(uint64_t *Offset, raw_ostream &OS,
                         Optional<object::SectionedAddress> BaseAddr,
-                        const MCRegisterInfo *MRI, DWARFUnit *U,
-                        DIDumpOptions DumpOpts, unsigned Indent) const;
+                        const MCRegisterInfo *MRI, const DWARFObject &Obj,
+                        DWARFUnit *U, DIDumpOptions DumpOpts,
+                        unsigned Indent) const;
 
   Error visitAbsoluteLocationList(
       uint64_t Offset, Optional<object::SectionedAddress> BaseAddr,
       std::function<Optional<object::SectionedAddress>(uint32_t)> LookupAddr,
       function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const;
 
 protected:
   DWARFDataExtractor Data;
 
   virtual void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
-                            unsigned Indent) const = 0;
+                            unsigned Indent, DIDumpOptions DumpOpts,
+                            const DWARFObject &Obj) const = 0;
 };
 
 class DWARFDebugLoc final : public DWARFLocationTable {
 public:
   /// A list of locations that contain one variable.
   struct LocationList {
     /// The beginning offset where this location list is stored in the debug_loc
     /// section.
private:
   /// the locations in which the variable is stored.
   LocationLists Locations;
 
 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,
+  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo,
+            const DWARFObject &Obj, 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;
+                    unsigned Indent, DIDumpOptions DumpOpts,
+                    const DWARFObject &Obj) const override;
 };
 
 class DWARFDebugLoclists final : public DWARFLocationTable {
 public:
   DWARFDebugLoclists(DWARFDataExtractor Data, uint16_t Version)
       : DWARFLocationTable(std::move(Data)), Version(Version) {}
 
   Error visitLocationList(
       uint64_t *Offset,
       function_ref<bool(const DWARFLocationEntry &)> Callback) const override;
 
   /// Dump all location lists within the given range.
   void dumpRange(uint64_t StartOffset, uint64_t Size, raw_ostream &OS,
-                 const MCRegisterInfo *MRI, DIDumpOptions DumpOpts);
+                 const MCRegisterInfo *MRI, const DWARFObject &Obj,
+                 DIDumpOptions DumpOpts);
 
 protected:
   void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
-                    unsigned Indent) const override;
+                    unsigned Indent, DIDumpOptions DumpOpts,
+                    const DWARFObject &Obj) const override;
 
 private:
   uint16_t Version;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
       Rnglists.dump(OS, LookupPooledAddress, DumpOpts);
     }
   }
 }
 
 static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
                                 DWARFDataExtractor Data,
                                 const MCRegisterInfo *MRI,
+                                const DWARFObject &Obj,
                                 Optional<uint64_t> DumpOffset) {
   uint64_t Offset = 0;
 
   while (Data.isValidOffset(Offset)) {
     DWARFListTableHeader Header(".debug_loclists", "locations");
     if (Error E = Header.extract(Data, &Offset)) {
       WithColor::error() << toString(std::move(E)) << '\n';
       return;
     }
 
     Header.dump(OS, DumpOpts);
 
     uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
     Data.setAddressSize(Header.getAddrSize());
     DWARFDebugLoclists Loc(Data, Header.getVersion());
     if (DumpOffset) {
       if (DumpOffset >= Offset && DumpOffset < EndOffset) {
         Offset = *DumpOffset;
-        Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, nullptr,
+        Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, Obj, nullptr,
                              DumpOpts, /*Indent=*/0);
         OS << "\n";
         return;
       }
     } else {
-      Loc.dumpRange(Offset, EndOffset - Offset, OS, MRI, DumpOpts);
+      Loc.dumpRange(Offset, EndOffset - Offset, OS, MRI, Obj, DumpOpts);
     }
     Offset = EndOffset;
   }
 }
 
 void DWARFContext::dump(
     raw_ostream &OS, DIDumpOptions DumpOpts,
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
void DWARFContext::dump(
   }
 
   DIDumpOptions LLDumpOpts = DumpOpts;
   if (LLDumpOpts.Verbose)
     LLDumpOpts.DisplayRawContents = true;
 
   if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
                                    DObj->getLocSection().Data)) {
-    getDebugLoc()->dump(OS, getRegisterInfo(), LLDumpOpts, *Off);
+    getDebugLoc()->dump(OS, getRegisterInfo(), *DObj, LLDumpOpts, *Off);
   }
   if (const auto *Off =
           shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
                      DObj->getLoclistsSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
                             0);
-    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *Off);
+    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
   }
   if (const auto *Off =
           shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                      DObj->getLocDWOSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
                             4);
     DWARFDebugLoclists Loc(Data, /*Version=*/4);
     if (*Off) {
       uint64_t Offset = **Off;
       Loc.dumpLocationList(&Offset, OS,
-                           /*BaseAddr=*/None, getRegisterInfo(), nullptr,
+                           /*BaseAddr=*/None, getRegisterInfo(), *DObj, nullptr,
                            LLDumpOpts, /*Indent=*/0);
       OS << "\n";
     } else {
-      Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(),
+      Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(), *DObj,
                     LLDumpOpts);
     }
   }
 
   if (const auto *Off = shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
                                    DObj->getFrameSection().Data))
     getDebugFrame()->dump(OS, getRegisterInfo(), *Off);
 

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

case dwarf::DW_LLE_startx_length: {
     Optional<SectionedAddress> LowPC = LookupAddr(E.Value0);
     if (!LowPC)
       return createResolverError(E.Value0, E.Kind);
     return DWARFLocationExpression{DWARFAddressRange{LowPC->Address,
                                                      LowPC->Address + E.Value1,
                                                      LowPC->SectionIndex},
                                    E.Loc};
   }
-  case dwarf::DW_LLE_offset_pair:
+  case dwarf::DW_LLE_offset_pair: {
     if (!Base) {
       return createStringError(
           inconvertibleErrorCode(),
           "Unable to resolve DW_LLE_offset_pair: base address unknown");
     }
-    return DWARFLocationExpression{DWARFAddressRange{Base->Address + E.Value0,
-                                                     Base->Address + E.Value1,
-                                                     Base->SectionIndex},
-                                   E.Loc};
+    DWARFAddressRange Range{Base->Address + E.Value0, Base->Address + E.Value1,
+                            Base->SectionIndex};
+    if (Range.SectionIndex == SectionedAddress::UndefSection)
+      Range.SectionIndex = E.SectionIndex;
+    return DWARFLocationExpression{Range, E.Loc};
+  }
   case dwarf::DW_LLE_base_address:
-    Base = SectionedAddress{E.Value0, SectionedAddress::UndefSection};
+    Base = SectionedAddress{E.Value0, E.SectionIndex};
     return None;
   case dwarf::DW_LLE_start_length:
     return DWARFLocationExpression{
-        DWARFAddressRange{E.Value0, E.Value0 + E.Value1,
-                          SectionedAddress::UndefSection},
+        DWARFAddressRange{E.Value0, E.Value0 + E.Value1, E.SectionIndex},
         E.Loc};
   default:
     llvm_unreachable("unreachable locations list kind");
   }
 }
 
 // When directly dumping the .debug_loc without a compile unit, we have to guess
 // at the DWARF version. This only affects DW_OP_call_ref, which is a rare
 // expression that LLVM doesn't produce. Guessing the wrong version means we
 // won't be able to pretty print expressions in DWARF2 binaries produced by
 // non-LLVM tools.
 static void dumpExpression(raw_ostream &OS, ArrayRef<uint8_t> Data,
                            bool IsLittleEndian, unsigned AddressSize,
                            const MCRegisterInfo *MRI, DWARFUnit *U) {
   DWARFDataExtractor Extractor(toStringRef(Data), IsLittleEndian, AddressSize);
   DWARFExpression(Extractor, dwarf::DWARF_VERSION, AddressSize).print(OS, MRI, U);
 }
 
 bool DWARFLocationTable::dumpLocationList(uint64_t *Offset, raw_ostream &OS,
                                           Optional<SectionedAddress> BaseAddr,
                                           const MCRegisterInfo *MRI,
-                                          DWARFUnit *U, DIDumpOptions DumpOpts,
+                                          const DWARFObject &Obj, DWARFUnit *U,
+                                          DIDumpOptions DumpOpts,
                                           unsigned Indent) const {
   DWARFLocationInterpreter Interp(
       BaseAddr, [U](uint32_t Index) -> Optional<SectionedAddress> {
         if (U)
           return U->getAddrOffsetSectionItem(Index);
         return None;
       });
   OS << format("0x%8.8" PRIx64 ": ", *Offset);
   Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
     Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E);
     if (!Loc || DumpOpts.DisplayRawContents)
-      dumpRawEntry(E, OS, Indent);
+      dumpRawEntry(E, OS, Indent, DumpOpts, Obj);
     if (Loc && *Loc) {
       OS << "\n";
       OS.indent(Indent);
       if (DumpOpts.DisplayRawContents)
         OS << "          => ";
 
       DIDumpOptions RangeDumpOpts(DumpOpts);
       RangeDumpOpts.DisplayRawContents = false;
-      const DWARFObject *Obj = nullptr;
-      if (U)
-        Obj = &U->getContext().getDWARFObj();
-      Loc.get()->Range->dump(OS, Data.getAddressSize(), RangeDumpOpts, Obj);
+      Loc.get()->Range->dump(OS, Data.getAddressSize(), RangeDumpOpts, &Obj);
     }
     if (!Loc)
       consumeError(Loc.takeError());
 
     if (E.Kind != dwarf::DW_LLE_base_address &&
         E.Kind != dwarf::DW_LLE_base_addressx &&
         E.Kind != dwarf::DW_LLE_end_of_list) {
       OS << ": ";
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,
+                         const DWARFObject &Obj, DIDumpOptions DumpOpts,
                          Optional<uint64_t> DumpOffset) const {
   auto BaseAddr = None;
   unsigned Indent = 12;
   if (DumpOffset) {
-    dumpLocationList(&*DumpOffset, OS, BaseAddr, MRI, nullptr, DumpOpts,
+    dumpLocationList(&*DumpOffset, OS, BaseAddr, MRI, Obj, nullptr, DumpOpts,
                      Indent);
   } else {
     uint64_t Offset = 0;
     StringRef Separator;
     bool CanContinue = true;
     while (CanContinue && Data.isValidOffset(Offset)) {
       OS << Separator;
       Separator = "\n";
 
-      CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, nullptr,
+      CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, Obj, nullptr,
                                      DumpOpts, Indent);
       OS << '\n';
     }
   }
 }
 
 Error DWARFDebugLoc::visitLocationList(
     uint64_t *Offset,
     function_ref<bool(const DWARFLocationEntry &)> Callback) const {
   DataExtractor::Cursor C(*Offset);
   while (true) {
+    uint64_t SectionIndex;
     uint64_t Value0 = Data.getRelocatedAddress(C);
-    uint64_t Value1 = Data.getRelocatedAddress(C);
+    uint64_t Value1 = Data.getRelocatedAddress(C, &SectionIndex);
 
     DWARFLocationEntry E;
 
     // The end of any given location list is marked by an end of list entry,
     // which consists of a 0 for the beginning address offset and a 0 for the
     // ending address offset. A beginning offset of 0xff...f marks the base
     // address selection entry.
     if (Value0 == 0 && Value1 == 0) {
       E.Kind = dwarf::DW_LLE_end_of_list;
     } else if (Value0 == (Data.getAddressSize() == 4 ? -1U : -1ULL)) {
       E.Kind = dwarf::DW_LLE_base_address;
       E.Value0 = Value1;
+      E.SectionIndex = SectionIndex;
     } else {
       E.Kind = dwarf::DW_LLE_offset_pair;
       E.Value0 = Value0;
       E.Value1 = Value1;
+      E.SectionIndex = SectionIndex;
       unsigned Bytes = Data.getU16(C);
       // A single location description describing the location of the object...
       Data.getU8(C, E.Loc, Bytes);
     }
 
     if (!C)
       return C.takeError();
     if (!Callback(E) || E.Kind == dwarf::DW_LLE_end_of_list)
while (Offset < Data.getData().size()) {
     else {
       logAllUnhandledErrors(LL.takeError(), WithColor::error());
       break;
     }
   }
 }
 
 void DWARFDebugLoc::dumpRawEntry(const DWARFLocationEntry &Entry,
-                                 raw_ostream &OS, unsigned Indent) const {
+                                 raw_ostream &OS, unsigned Indent,
+                                 DIDumpOptions DumpOpts,
+                                 const DWARFObject &Obj) const {
   uint64_t Value0, Value1;
   switch (Entry.Kind) {
   case dwarf::DW_LLE_base_address:
     Value0 = Data.getAddressSize() == 4 ? -1U : -1ULL;
     Value1 = Entry.Value0;
     break;
   case dwarf::DW_LLE_offset_pair:
     Value0 = Entry.Value0;
     Value1 = Entry.Value1;
     break;
   case dwarf::DW_LLE_end_of_list:
     Value0 = Value1 = 0;
     return;
   default:
     llvm_unreachable("Not possible in DWARF4!");
   }
   OS << '\n';
   OS.indent(Indent);
   OS << '(' << format_hex(Value0, 2 + Data.getAddressSize() * 2) << ", "
      << format_hex(Value1, 2 + Data.getAddressSize() * 2) << ')';
+  DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, Entry.SectionIndex);
 }
 
 Error DWARFDebugLoclists::visitLocationList(
     uint64_t *Offset, function_ref<bool(const DWARFLocationEntry &)> F) const {
 
   DataExtractor::Cursor C(*Offset);
   bool Continue = true;
   while (Continue) {
case dwarf::DW_LLE_startx_length:
       if (Version < 5)
         E.Value1 = Data.getU32(C);
       else
         E.Value1 = Data.getULEB128(C);
       break;
     case dwarf::DW_LLE_offset_pair:
       E.Value0 = Data.getULEB128(C);
       E.Value1 = Data.getULEB128(C);
+      E.SectionIndex = SectionedAddress::UndefSection;
       break;
     case dwarf::DW_LLE_base_address:
-      E.Value0 = Data.getRelocatedAddress(C);
+      E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex);
       break;
     case dwarf::DW_LLE_start_length:
-      E.Value0 = Data.getRelocatedAddress(C);
+      E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex);
       E.Value1 = Data.getULEB128(C);
       break;
     case dwarf::DW_LLE_startx_endx:
     case dwarf::DW_LLE_default_location:
     case dwarf::DW_LLE_start_end:
     default:
       cantFail(C.takeError());
       return createStringError(errc::illegal_byte_sequence,
if (!C)
       return C.takeError();
     Continue = F(E) && E.Kind != dwarf::DW_LLE_end_of_list;
   }
   *Offset = C.tell();
   return Error::success();
 }
 
 void DWARFDebugLoclists::dumpRawEntry(const DWARFLocationEntry &Entry,
-                                      raw_ostream &OS, unsigned Indent) const {
+                                      raw_ostream &OS, unsigned Indent,
+                                      DIDumpOptions DumpOpts,
+                                      const DWARFObject &Obj) const {
   size_t MaxEncodingStringLength = 0;
 #define HANDLE_DW_LLE(ID, NAME)                                                \
   MaxEncodingStringLength = std::max(MaxEncodingStringLength,                  \
                                      dwarf::LocListEncodingString(ID).size());
 #include "llvm/BinaryFormat/Dwarf.def"
 
   OS << "\n";
   OS.indent(Indent);
#include "llvm/BinaryFormat/Dwarf.def"
   case dwarf::DW_LLE_base_addressx:
   case dwarf::DW_LLE_base_address:
     OS << format_hex(Entry.Value0, FieldSize);
     break;
   case dwarf::DW_LLE_end_of_list:
     break;
   }
   OS << ')';
+  switch (Entry.Kind) {
+  case dwarf::DW_LLE_start_length:
+  case dwarf::DW_LLE_base_address:
+    DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, Entry.SectionIndex);
+    break;
+  default:
+    break;
+  }
 }
 
 void DWARFDebugLoclists::dumpRange(uint64_t StartOffset, uint64_t Size,
                                    raw_ostream &OS, const MCRegisterInfo *MRI,
+                                   const DWARFObject &Obj,
                                    DIDumpOptions DumpOpts) {
   if (!Data.isValidOffsetForDataOfSize(StartOffset, Size))  {
     OS << "Invalid dump range\n";
     return;
   }
   uint64_t Offset = StartOffset;
   StringRef Separator;
   bool CanContinue = true;
   while (CanContinue && Offset < StartOffset + Size) {
     OS << Separator;
     Separator = "\n";
 
-    CanContinue = dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, nullptr,
-                                   DumpOpts, /*Indent=*/12);
+    CanContinue = dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, Obj,
+                                   nullptr, DumpOpts, /*Indent=*/12);
     OS << '\n';
   }
 }

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
     if (FormValue.getForm() == DW_FORM_loclistx) {
       FormValue.dump(OS, DumpOpts);
       if (auto LoclistOffset = U->getLoclistOffset(Offset))
         Offset = *LoclistOffset + U->getLocSectionBase();
       else
         return;
     }
     U->getLocationTable().dumpLocationList(&Offset, OS, U->getBaseAddress(),
-                                           MRI, U, DumpOpts, Indent);
+                                           MRI, Ctx.getDWARFObj(), U, DumpOpts,
+                                           Indent);
     return;
   }
 
   FormValue.dump(OS, DumpOpts);
 }
 
 /// Dump the name encoded in the type tag.
 static void dumpTypeTagName(raw_ostream &OS, dwarf::Tag T) {

llvm/test/DebugInfo/X86/dwarfdump-debug-loc-simple.test

 RUN: llvm-dwarfdump -v %p/../Inputs/dwarfdump-test-loc-list-32bit.elf.o | FileCheck %s
 Note: the input file was generated from Inputs/dwarfdump-test-loc-list-32bit.elf.cpp
 
 CHECK: .debug_info
 CHECK: DW_AT_name{{.*}}"f"
 CHECK: DW_AT_location{{.*}}([[F_LOC:0x[0-9a-f]*]]
-CHECK-NEXT:    [0x00000000, 0x00000023): DW_OP_reg1 ECX
-CHECK-NEXT:    [0x00000023, 0x0000005d): DW_OP_breg5 EBP-16)
+CHECK-NEXT:    [0x00000000, 0x00000023) ".text": DW_OP_reg1 ECX
+CHECK-NEXT:    [0x00000023, 0x0000005d) ".text": DW_OP_breg5 EBP-16)
 CHECK: DW_AT_name{{.*}}"g"
 CHECK: DW_AT_location{{.*}}([[G_LOC:0x[0-9a-f]*]]
-CHECK-NEXT:    [0x00000000, 0x00000020): DW_OP_reg0 EAX
-CHECK-NEXT:    [0x00000020, 0x0000005d): DW_OP_breg5 EBP-12)
+CHECK-NEXT:    [0x00000000, 0x00000020) ".text": DW_OP_reg0 EAX
+CHECK-NEXT:    [0x00000020, 0x0000005d) ".text": DW_OP_breg5 EBP-12)
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: [[F_LOC]]:
 this is actually the wrong location due to PR14763, but that doesn't matter for
 the purposes of testing dwarfdump
-CHECK-NEXT:             (0x00000000, 0x00000023): DW_OP_reg1 ECX
-CHECK-NEXT:             (0x00000023, 0x0000005d): DW_OP_breg5 EBP-16
+CHECK-NEXT:             (0x00000000, 0x00000023) ".text": DW_OP_reg1 ECX
+CHECK-NEXT:             (0x00000023, 0x0000005d) ".text": DW_OP_breg5 EBP-16
 CHECK: [[G_LOC]]:
-CHECK-NEXT:             (0x00000000, 0x00000020): DW_OP_reg0 EAX
-CHECK-NEXT:             (0x00000020, 0x0000005d): DW_OP_breg5 EBP-12
+CHECK-NEXT:             (0x00000000, 0x00000020) ".text": DW_OP_reg0 EAX
+CHECK-NEXT:             (0x00000020, 0x0000005d) ".text": DW_OP_breg5 EBP-12

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

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t
-# RUN: llvm-dwarfdump %t | FileCheck %s
+# RUN: llvm-dwarfdump -debug-info -debug-loclists %t \
+# RUN:   | FileCheck %s --check-prefix=REGULAR --check-prefix=BOTH
+# RUN: llvm-dwarfdump -debug-info -debug-loclists --verbose %t \
+# RUN:   | FileCheck %s --check-prefix=VERBOSE --check-prefix=BOTH
 
 
-# CHECK:          DW_AT_location        (0x0000000c
-# CHECK-NEXT:        [0x0000000000000000, 0x0000000000000001): DW_OP_reg0 RAX
-# CHECK-NEXT:        [0x0000000000000001, 0x0000000000000002): DW_OP_reg1 RDX
-# CHECK-NEXT:        [0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX
-# CHECK-NEXT:        [0x0000000000000003, 0x0000000000000004): DW_OP_reg3 RBX
-# CHECK-NEXT:        DW_LLE_startx_length (0x000000000000dead, 0x0000000000000001): DW_OP_reg4 RSI)
+# BOTH:          DW_AT_location {{.*}}(0x0000000c
+
+# REGULAR-NEXT:      [0x0000000000000000, 0x0000000000000001): DW_OP_reg0 RAX
+# VERBOSE-NEXT:      [0x0000000000000000, 0x0000000000000001) ".text": DW_OP_reg0 RAX
+
+# REGULAR-NEXT:      [0x0000000000000001, 0x0000000000000002): DW_OP_reg1 RDX
+# VERBOSE-NEXT:      [0x0000000000000001, 0x0000000000000002) ".text": DW_OP_reg1 RDX
+
+# REGULAR-NEXT:      [0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX
+# VERBOSE-NEXT:      [0x0000000000000002, 0x0000000000000003) ".text": DW_OP_reg2 RCX
+
+# REGULAR-NEXT:      [0x0000000000000003, 0x0000000000000004): DW_OP_reg3 RBX
+# VERBOSE-NEXT:      [0x0000000000000003, 0x0000000000000004) ".text": DW_OP_reg3 RBX
+
+# BOTH-NEXT:      DW_LLE_startx_length (0x000000000000dead, 0x0000000000000001): DW_OP_reg4 RSI)
+
+# BOTH: locations list header: length = 0x00000034, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# BOTH-NEXT: 0x0000000c:
+# BOTH-NEXT:     DW_LLE_startx_length   (0x0000000000000000, 0x0000000000000001): DW_OP_reg0 RAX
+# BOTH-NEXT:     DW_LLE_offset_pair     (0x0000000000000001, 0x0000000000000002): DW_OP_reg1 RDX
+
+# REGULAR-NEXT:  [0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX
+# VERBOSE-NEXT:  DW_LLE_start_length    (0x0000000000000002, 0x0000000000000001) ".text"
+# VERBOSE-NEXT:            => [0x0000000000000002, 0x0000000000000003) ".text": DW_OP_reg2 RCX
+
+# VERBOSE-NEXT:  DW_LLE_base_address    (0x0000000000000003) ".text"
+
+# REGULAR-NEXT:  [0x0000000000000003, 0x0000000000000004): DW_OP_reg3 RBX
+# VERBOSE-NEXT:  DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000001)
+# VERBOSE-NEXT:            => [0x0000000000000003, 0x0000000000000004) ".text": DW_OP_reg3 RBX
+
+# BOTH-NEXT:     DW_LLE_startx_length   (0x000000000000dead, 0x0000000000000001): DW_OP_reg4 RSI
+
+# VERBOSE-NEXT:  DW_LLE_end_of_list     ()
 
 
         .text
 f:                                      # @f
 .Lf0:
         nop
 .Lf1:
         nop