summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h4
-rw-r--r--llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h56
-rw-r--r--llvm/lib/DebugInfo/DWARF/DWARFContext.cpp47
-rw-r--r--llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp150
-rw-r--r--llvm/lib/DebugInfo/DWARF/DWARFDie.cpp46
-rw-r--r--llvm/test/CodeGen/X86/debug-loclists.ll18
-rw-r--r--llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-error-cases2.s4
-rw-r--r--llvm/test/DebugInfo/X86/dwarfdump-debug-loclists.test10
-rw-r--r--llvm/test/DebugInfo/X86/fission-ranges.ll34
-rw-r--r--llvm/test/DebugInfo/X86/stack-value-piece.ll4
-rw-r--r--llvm/test/tools/llvm-dwarfdump/X86/debug_loclists_startx_length.s4
11 files changed, 184 insertions, 193 deletions
diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h
index fae163622ed..2dec107d145 100644
--- a/llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h
+++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h
@@ -75,7 +75,6 @@ class DWARFContext : public DIContext {
DWARFUnitVector DWOUnits;
std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
- std::unique_ptr<DWARFDebugLoclists> LocDWO;
/// The maximum DWARF version of all units.
unsigned MaxVersion = 0;
@@ -260,9 +259,6 @@ public:
/// Get a pointer to the parsed dwo abbreviations object.
const DWARFDebugAbbrev *getDebugAbbrevDWO();
- /// Get a pointer to the parsed DebugLoc object.
- const DWARFDebugLoclists *getDebugLocDWO();
-
/// Get a pointer to the parsed DebugAranges object.
const DWARFDebugAranges *getDebugAranges();
diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
index d5956a7613a..25b77131774 100644
--- a/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
+++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
@@ -76,6 +76,9 @@ public:
class DWARFDebugLoclists {
public:
+ // Unconstructible.
+ DWARFDebugLoclists() = delete;
+
struct Entry {
uint8_t Kind;
uint64_t Offset;
@@ -87,35 +90,30 @@ public:
DIDumpOptions DumpOpts, unsigned Indent, size_t MaxEncodingStringLength) const;
};
- struct LocationList {
- uint64_t Offset;
- SmallVector<Entry, 2> Entries;
- void dump(raw_ostream &OS, uint64_t BaseAddr, bool IsLittleEndian,
- unsigned AddressSize, const MCRegisterInfo *RegInfo,
- DWARFUnit *U, DIDumpOptions DumpOpts, unsigned Indent) const;
- };
-
-private:
- using LocationLists = SmallVector<LocationList, 4>;
-
- LocationLists Locations;
-
- unsigned AddressSize;
-
- bool IsLittleEndian;
-
-public:
- void parse(const DWARFDataExtractor &data, uint64_t Offset,
- uint64_t EndOffset, uint16_t Version);
- void dump(raw_ostream &OS, uint64_t BaseAddr, const MCRegisterInfo *RegInfo,
- DIDumpOptions DumpOpts, Optional<uint64_t> Offset) const;
-
- /// Return the location list at the given offset or nullptr.
- LocationList const *getLocationListAtOffset(uint64_t Offset) const;
-
- static Expected<LocationList>
- parseOneLocationList(const DWARFDataExtractor &Data, uint64_t *Offset,
- unsigned Version);
+ /// Call the user-provided callback for each entry (including the end-of-list
+ /// entry) in the location list starting at \p Offset. The callback can return
+ /// false to terminate the iteration early. Returns an error if it was unable
+ /// to parse the entire location list correctly. Upon successful termination
+ /// \p Offset will be updated point past the end of the list.
+ static Error visitLocationList(const DWARFDataExtractor &Data,
+ uint64_t *Offset, uint16_t Version,
+ llvm::function_ref<bool(const Entry &)> F);
+
+ /// 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).
+ static bool dumpLocationList(const DWARFDataExtractor &Data, uint64_t *Offset,
+ uint16_t Version, raw_ostream &OS,
+ uint64_t BaseAddr, const MCRegisterInfo *MRI,
+ DWARFUnit *U, DIDumpOptions DumpOpts,
+ unsigned Indent);
+
+ /// Dump all location lists within the given range.
+ static void dumpRange(const DWARFDataExtractor &Data, uint64_t StartOffset,
+ uint64_t Size, uint16_t Version, raw_ostream &OS,
+ uint64_t BaseAddr, const MCRegisterInfo *MRI,
+ DIDumpOptions DumpOpts);
};
} // end namespace llvm
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFContext.cpp b/llvm/lib/DebugInfo/DWARF/DWARFContext.cpp
index c5766b4440d..e13b3836b13 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFContext.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFContext.cpp
@@ -300,11 +300,21 @@ static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
Header.dump(OS, DumpOpts);
- DWARFDebugLoclists Loclists;
uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
Data.setAddressSize(Header.getAddrSize());
- Loclists.parse(Data, Offset, EndOffset, Header.getVersion());
- Loclists.dump(OS, 0, MRI, DumpOpts, DumpOffset);
+ if (DumpOffset) {
+ if (DumpOffset >= Offset && DumpOffset < EndOffset) {
+ Offset = *DumpOffset;
+ DWARFDebugLoclists::dumpLocationList(Data, &Offset, Header.getVersion(),
+ OS, /*BaseAddr=*/0, MRI, nullptr,
+ DumpOpts, /*Indent=*/0);
+ OS << "\n";
+ return;
+ }
+ } else {
+ DWARFDebugLoclists::dumpRange(Data, Offset, EndOffset - Offset,
+ Header.getVersion(), OS, 0, MRI, DumpOpts);
+ }
Offset = EndOffset;
}
}
@@ -393,7 +403,19 @@ void DWARFContext::dump(
if (const auto *Off =
shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
DObj->getLocDWOSection().Data)) {
- getDebugLocDWO()->dump(OS, 0, getRegisterInfo(), DumpOpts, *Off);
+ DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
+ 4);
+ if (*Off) {
+ uint64_t Offset = **Off;
+ DWARFDebugLoclists::dumpLocationList(Data, &Offset, /*Version=*/4, OS,
+ /*BaseAddr=*/0, getRegisterInfo(),
+ nullptr, DumpOpts, /*Indent=*/0);
+ OS << "\n";
+ } else {
+ DWARFDebugLoclists::dumpRange(Data, 0, Data.getData().size(),
+ /*Version=*/4, OS, /*BaseAddr=*/0,
+ getRegisterInfo(), DumpOpts);
+ }
}
if (const auto *Off = shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
@@ -724,23 +746,6 @@ const DWARFDebugLoc *DWARFContext::getDebugLoc() {
return Loc.get();
}
-const DWARFDebugLoclists *DWARFContext::getDebugLocDWO() {
- if (LocDWO)
- return LocDWO.get();
-
- LocDWO.reset(new DWARFDebugLoclists());
- // Assume all compile units have the same address byte size.
- // FIXME: We don't need AddressSize for split DWARF since relocatable
- // addresses cannot appear there. At the moment DWARFExpression requires it.
- DWARFDataExtractor LocData(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
- 4);
- // Use version 4. DWO does not support the DWARF v5 .debug_loclists yet and
- // that means we are parsing the new style .debug_loc (pre-standatized version
- // of the .debug_loclists).
- LocDWO->parse(LocData, 0, LocData.getData().size(), 4 /* Version */);
- return LocDWO.get();
-}
-
const DWARFDebugAranges *DWARFContext::getDebugAranges() {
if (Aranges)
return Aranges.get();
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
index 032feb9088c..e0faaed035d 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
@@ -139,19 +139,19 @@ void DWARFDebugLoc::parse(const DWARFDataExtractor &data) {
}
}
-Expected<DWARFDebugLoclists::LocationList>
-DWARFDebugLoclists::parseOneLocationList(const DWARFDataExtractor &Data,
- uint64_t *Offset, unsigned Version) {
- LocationList LL;
- LL.Offset = *Offset;
- DataExtractor::Cursor C(*Offset);
+Error DWARFDebugLoclists::visitLocationList(
+ const DWARFDataExtractor &Data, uint64_t *Offset, uint16_t Version,
+ llvm::function_ref<bool(const Entry &)> F) {
- // dwarf::DW_LLE_end_of_list_entry is 0 and indicates the end of the list.
- while (auto Kind = Data.getU8(C)) {
+ DataExtractor::Cursor C(*Offset);
+ bool Continue = true;
+ while (Continue) {
Entry E;
- E.Kind = Kind;
- E.Offset = C.tell() - 1;
- switch (Kind) {
+ E.Offset = C.tell();
+ E.Kind = Data.getU8(C);
+ switch (E.Kind) {
+ case dwarf::DW_LLE_end_of_list:
+ break;
case dwarf::DW_LLE_base_addressx:
E.Value0 = Data.getULEB128(C);
break;
@@ -164,10 +164,6 @@ DWARFDebugLoclists::parseOneLocationList(const DWARFDataExtractor &Data,
else
E.Value1 = Data.getULEB128(C);
break;
- case dwarf::DW_LLE_start_length:
- E.Value0 = Data.getRelocatedAddress(C);
- E.Value1 = Data.getULEB128(C);
- break;
case dwarf::DW_LLE_offset_pair:
E.Value0 = Data.getULEB128(C);
E.Value1 = Data.getULEB128(C);
@@ -175,53 +171,62 @@ DWARFDebugLoclists::parseOneLocationList(const DWARFDataExtractor &Data,
case dwarf::DW_LLE_base_address:
E.Value0 = Data.getRelocatedAddress(C);
break;
+ case dwarf::DW_LLE_start_length:
+ E.Value0 = Data.getRelocatedAddress(C);
+ 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,
- "LLE of kind %x not supported", (int)Kind);
+ "LLE of kind %x not supported", (int)E.Kind);
}
- if (Kind != dwarf::DW_LLE_base_address &&
- Kind != dwarf::DW_LLE_base_addressx) {
+ if (E.Kind != dwarf::DW_LLE_base_address &&
+ E.Kind != dwarf::DW_LLE_base_addressx &&
+ E.Kind != dwarf::DW_LLE_end_of_list) {
unsigned Bytes = Version >= 5 ? Data.getULEB128(C) : Data.getU16(C);
// A single location description describing the location of the object...
Data.getU8(C, E.Loc, Bytes);
}
- LL.Entries.push_back(std::move(E));
+ if (!C)
+ return C.takeError();
+ Continue = F(E) && E.Kind != dwarf::DW_LLE_end_of_list;
}
- if (Error Err = C.takeError())
- return std::move(Err);
- Entry E;
- E.Kind = dwarf::DW_LLE_end_of_list;
- E.Offset = C.tell() - 1;
- LL.Entries.push_back(E);
*Offset = C.tell();
- return LL;
+ return Error::success();
}
-void DWARFDebugLoclists::parse(const DWARFDataExtractor &data, uint64_t Offset,
- uint64_t EndOffset, uint16_t Version) {
- IsLittleEndian = data.isLittleEndian();
- AddressSize = data.getAddressSize();
-
- while (Offset < EndOffset) {
- if (auto LL = parseOneLocationList(data, &Offset, Version))
- Locations.push_back(std::move(*LL));
- else {
- logAllUnhandledErrors(LL.takeError(), WithColor::error());
- return;
- }
+bool DWARFDebugLoclists::dumpLocationList(const DWARFDataExtractor &Data,
+ uint64_t *Offset, uint16_t Version,
+ raw_ostream &OS, uint64_t BaseAddr,
+ const MCRegisterInfo *MRI,
+ DWARFUnit *U, DIDumpOptions DumpOpts,
+ unsigned Indent) {
+ size_t MaxEncodingStringLength = 0;
+ if (DumpOpts.Verbose) {
+#define HANDLE_DW_LLE(ID, NAME) \
+ MaxEncodingStringLength = std::max(MaxEncodingStringLength, \
+ dwarf::LocListEncodingString(ID).size());
+#include "llvm/BinaryFormat/Dwarf.def"
}
-}
-DWARFDebugLoclists::LocationList const *
-DWARFDebugLoclists::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;
+ OS << format("0x%8.8" PRIx64 ": ", *Offset);
+ Error E = visitLocationList(Data, Offset, Version, [&](const Entry &E) {
+ E.dump(OS, BaseAddr, Data.isLittleEndian(), Data.getAddressSize(), MRI, U,
+ DumpOpts, Indent, MaxEncodingStringLength);
+ return true;
+ });
+ if (E) {
+ OS << "\n";
+ OS.indent(Indent);
+ OS << "error: " << toString(std::move(E));
+ return false;
+ }
+ return true;
}
void DWARFDebugLoclists::Entry::dump(raw_ostream &OS, uint64_t &BaseAddr,
@@ -297,44 +302,25 @@ void DWARFDebugLoclists::Entry::dump(raw_ostream &OS, uint64_t &BaseAddr,
dumpExpression(OS, Loc, IsLittleEndian, AddressSize, MRI, U);
}
-void DWARFDebugLoclists::LocationList::dump(raw_ostream &OS, uint64_t BaseAddr,
- bool IsLittleEndian,
- unsigned AddressSize,
- const MCRegisterInfo *MRI,
- DWARFUnit *U,
- DIDumpOptions DumpOpts,
- unsigned Indent) const {
- size_t MaxEncodingStringLength = 0;
- if (DumpOpts.Verbose)
- for (const auto &Entry : Entries)
- MaxEncodingStringLength =
- std::max(MaxEncodingStringLength,
- dwarf::LocListEncodingString(Entry.Kind).size());
-
- for (const Entry &E : Entries)
- E.dump(OS, BaseAddr, IsLittleEndian, AddressSize, MRI, U, DumpOpts, Indent,
- MaxEncodingStringLength);
-}
-
-void DWARFDebugLoclists::dump(raw_ostream &OS, uint64_t BaseAddr,
- const MCRegisterInfo *MRI, DIDumpOptions DumpOpts,
- Optional<uint64_t> Offset) const {
- auto DumpLocationList = [&](const LocationList &L) {
- OS << format("0x%8.8" PRIx64 ": ", L.Offset);
- L.dump(OS, BaseAddr, IsLittleEndian, AddressSize, MRI, nullptr, DumpOpts,
- /*Indent=*/12);
- OS << "\n";
- };
- if (Offset) {
- if (auto *L = getLocationListAtOffset(*Offset))
- DumpLocationList(*L);
+void DWARFDebugLoclists::dumpRange(const DWARFDataExtractor &Data,
+ uint64_t StartOffset, uint64_t Size,
+ uint16_t Version, raw_ostream &OS,
+ uint64_t BaseAddr, const MCRegisterInfo *MRI,
+ DIDumpOptions DumpOpts) {
+ if (!Data.isValidOffsetForDataOfSize(StartOffset, Size)) {
+ OS << "Invalid dump range\n";
return;
}
-
- for (const LocationList &L : Locations) {
- DumpLocationList(L);
- if (&L != &Locations.back())
- OS << '\n';
+ uint64_t Offset = StartOffset;
+ StringRef Separator;
+ bool CanContinue = true;
+ while (CanContinue && Offset < StartOffset + Size) {
+ OS << Separator;
+ Separator = "\n";
+
+ CanContinue = dumpLocationList(Data, &Offset, Version, OS, BaseAddr, MRI,
+ nullptr, DumpOpts, /*Indent=*/12);
+ OS << '\n';
}
}
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp
index f278a7a205e..ebc8cc565f3 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp
@@ -91,30 +91,32 @@ static void dumpLocation(raw_ostream &OS, DWARFFormValue &FormValue,
return;
}
- FormValue.dump(OS, DumpOpts);
- const auto &DumpLL = [&](auto ExpectedLL) {
- if (ExpectedLL) {
- uint64_t BaseAddr = 0;
- if (Optional<object::SectionedAddress> BA = U->getBaseAddress())
- BaseAddr = BA->Address;
- auto LLDumpOpts = DumpOpts;
- LLDumpOpts.Verbose = false;
- ExpectedLL->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(ExpectedLL.takeError()));
- }
- };
if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
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());
- DumpLL(DebugLoc.parseOneLocationList(Data, &Offset));
+
+ 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;
}
@@ -131,10 +133,14 @@ static void dumpLocation(raw_ostream &OS, DWARFFormValue &FormValue,
// 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.
- DumpLL(DWARFDebugLoclists::parseOneLocationList(
- Data, &Offset, UseLocLists ? U->getVersion() : 4));
+ DWARFDebugLoclists::dumpLocationList(
+ Data, &Offset, UseLocLists ? U->getVersion() : 4, OS, BaseAddr, MRI,
+ U, LLDumpOpts, Indent);
}
+ return;
}
+
+ FormValue.dump(OS, DumpOpts);
}
/// Dump the name encoded in the type tag.
diff --git a/llvm/test/CodeGen/X86/debug-loclists.ll b/llvm/test/CodeGen/X86/debug-loclists.ll
index 2b72f677b0d..7746826f30f 100644
--- a/llvm/test/CodeGen/X86/debug-loclists.ll
+++ b/llvm/test/CodeGen/X86/debug-loclists.ll
@@ -28,28 +28,28 @@
; the function, and the one that doesn't.
; CHECK-NEXT: 0x0000000c:
-; CHECK-NEXT: DW_LLE_base_addressx(0x0000000000000000)
-; CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000000, 0x0000000000000003)
+; CHECK-NEXT: DW_LLE_base_addressx (0x0000000000000000)
+; CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000000, 0x0000000000000003)
; CHECK-NEXT: => [0x0000000000000000, 0x0000000000000003): DW_OP_consts +3, DW_OP_stack_value
-; CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000003, 0x0000000000000004)
+; CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000003, 0x0000000000000004)
; CHECK-NEXT: => [0x0000000000000003, 0x0000000000000004): DW_OP_consts +4, DW_OP_stack_value
-; CHECK-NEXT: DW_LLE_end_of_list ()
+; CHECK-NEXT: DW_LLE_end_of_list ()
; Show that startx_length can be used when the address range starts at the start of the function.
; CHECK: 0x0000001d:
-; CHECK-NEXT: DW_LLE_startx_length(0x0000000000000000, 0x0000000000000003)
+; CHECK-NEXT: DW_LLE_startx_length (0x0000000000000000, 0x0000000000000003)
; CHECK-NEXT: => Addr idx 0 (w/ length 3): DW_OP_consts +5, DW_OP_stack_value
-; CHECK-NEXT: DW_LLE_end_of_list ()
+; CHECK-NEXT: DW_LLE_end_of_list ()
; And use a base address when the range doesn't start at an existing/useful
; address in the pool.
; CHECK: 0x00000025:
-; CHECK-NEXT: DW_LLE_base_addressx(0x0000000000000000)
-; CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000003, 0x0000000000000004)
+; CHECK-NEXT: DW_LLE_base_addressx (0x0000000000000000)
+; CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000003, 0x0000000000000004)
; CHECK-NEXT: => [0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX
-; CHECK-NEXT: DW_LLE_end_of_list ()
+; CHECK-NEXT: DW_LLE_end_of_list ()
; Built with clang -O3 -ffunction-sections from source:
;
diff --git a/llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-error-cases2.s b/llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-error-cases2.s
index 47307e2d113..48ae8d4db75 100644
--- a/llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-error-cases2.s
+++ b/llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-error-cases2.s
@@ -8,11 +8,11 @@
# CHECK: DW_AT_name ("x1")
# CHECK-NEXT: DW_AT_location (0xdeadbeef
-# CHECK-NEXT: error extracting location list: unexpected end of data)
+# CHECK-NEXT: error: unexpected end of data)
# CHECK: DW_AT_name ("x2")
# CHECK-NEXT: DW_AT_location (0x00000025
-# CHECK-NEXT: error extracting location list: unexpected end of data)
+# CHECK-NEXT: error: unexpected end of data)
.type f,@function
diff --git a/llvm/test/DebugInfo/X86/dwarfdump-debug-loclists.test b/llvm/test/DebugInfo/X86/dwarfdump-debug-loclists.test
index 783d4b84fbf..a427e03c231 100644
--- a/llvm/test/DebugInfo/X86/dwarfdump-debug-loclists.test
+++ b/llvm/test/DebugInfo/X86/dwarfdump-debug-loclists.test
@@ -11,14 +11,14 @@
# CHECK: .debug_loclists contents:
# CHECK-NEXT: 0x00000000: locations list header: length = 0x0000002c, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
# CHECK-NEXT: 0x0000000c:
-# CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000000, 0x0000000000000010)
+# CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000000, 0x0000000000000010)
# CHECK-NEXT: => [0x0000000000000000, 0x0000000000000010): DW_OP_breg5 RDI+0
-# CHECK-NEXT: DW_LLE_base_address(0x0000000000000500)
-# CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000030, 0x0000000000000040)
+# CHECK-NEXT: DW_LLE_base_address (0x0000000000000500)
+# CHECK-NEXT: DW_LLE_offset_pair (0x0000000000000030, 0x0000000000000040)
# CHECK-NEXT: => [0x0000000000000530, 0x0000000000000540): DW_OP_breg6 RBP-8, DW_OP_deref
-# CHECK-NEXT: DW_LLE_start_length(0x0000000000000700, 0x0000000000000010)
+# CHECK-NEXT: DW_LLE_start_length (0x0000000000000700, 0x0000000000000010)
# CHECK-NEXT: => [0x0000000000000700, 0x0000000000000710): DW_OP_breg5 RDI+0
-# CHECK-NEXT: DW_LLE_end_of_list ()
+# CHECK-NEXT: DW_LLE_end_of_list ()
.section .debug_str,"MS",@progbits,1
.asciz "stub"
diff --git a/llvm/test/DebugInfo/X86/fission-ranges.ll b/llvm/test/DebugInfo/X86/fission-ranges.ll
index 3f9e447f630..8f72ee116f5 100644
--- a/llvm/test/DebugInfo/X86/fission-ranges.ll
+++ b/llvm/test/DebugInfo/X86/fission-ranges.ll
@@ -32,10 +32,10 @@
; CHECK: DW_TAG_formal_parameter
; CHECK-NEXT: DW_AT_const_value [DW_FORM_sdata] (1)
; CHECK-NEXT: DW_AT_name {{.*}} "p")
-; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[A:0x[0-9a-z]*]]
-; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[E:0x[0-9a-z]*]]
-; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[B:0x[0-9a-z]*]]
-; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[D:0x[0-9a-z]*]]
+; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[A:0x[0-9a-z]*]]:
+; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[E:0x[0-9a-z]*]]:
+; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[B:0x[0-9a-z]*]]:
+; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[D:0x[0-9a-z]*]]:
; CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
; CHECK-NOT: .debug_loc contents:
; CHECK-NOT: Beginning address offset
@@ -45,31 +45,31 @@
; if they've changed due to a bugfix, change in register allocation, etc.
; CHECK: [[A]]:
-; CHECK-NEXT: DW_LLE_startx_length(0x00000002, 0x0000000f)
+; CHECK-NEXT: DW_LLE_startx_length (0x00000002, 0x0000000f)
; CHECK-NEXT: => Addr idx 2 (w/ length 15): DW_OP_consts +0, DW_OP_stack_value
-; CHECK-NEXT: DW_LLE_startx_length(0x00000003, 0x0000000f)
+; CHECK-NEXT: DW_LLE_startx_length (0x00000003, 0x0000000f)
; CHECK-NEXT: => Addr idx 3 (w/ length 15): DW_OP_reg0 RAX
-; CHECK-NEXT: DW_LLE_startx_length(0x00000004, 0x00000012)
+; CHECK-NEXT: DW_LLE_startx_length (0x00000004, 0x00000012)
; CHECK-NEXT: => Addr idx 4 (w/ length 18): DW_OP_breg7 RSP-8
-; CHECK-NEXT: DW_LLE_end_of_list ()
+; CHECK-NEXT: DW_LLE_end_of_list ()
; CHECK: [[E]]:
-; CHECK-NEXT: DW_LLE_startx_length(0x00000005, 0x00000009)
+; CHECK-NEXT: DW_LLE_startx_length (0x00000005, 0x00000009)
; CHECK-NEXT: => Addr idx 5 (w/ length 9): DW_OP_reg0 RAX
-; CHECK-NEXT: DW_LLE_startx_length(0x00000006, 0x00000062)
+; CHECK-NEXT: DW_LLE_startx_length (0x00000006, 0x00000062)
; CHECK-NEXT: => Addr idx 6 (w/ length 98): DW_OP_breg7 RSP-44
-; CHECK-NEXT: DW_LLE_end_of_list ()
+; CHECK-NEXT: DW_LLE_end_of_list ()
; CHECK: [[B]]:
-; CHECK-NEXT: DW_LLE_startx_length(0x00000007, 0x0000000f)
+; CHECK-NEXT: DW_LLE_startx_length (0x00000007, 0x0000000f)
; CHECK-NEXT: => Addr idx 7 (w/ length 15): DW_OP_reg0 RAX
-; CHECK-NEXT: DW_LLE_startx_length(0x00000008, 0x00000042)
+; CHECK-NEXT: DW_LLE_startx_length (0x00000008, 0x00000042)
; CHECK-NEXT: => Addr idx 8 (w/ length 66): DW_OP_breg7 RSP-32
-; CHECK-NEXT: DW_LLE_end_of_list ()
+; CHECK-NEXT: DW_LLE_end_of_list ()
; CHECK: [[D]]:
-; CHECK-NEXT: DW_LLE_startx_length(0x00000009, 0x0000000f)
+; CHECK-NEXT: DW_LLE_startx_length (0x00000009, 0x0000000f)
; CHECK-NEXT: => Addr idx 9 (w/ length 15): DW_OP_reg0 RAX
-; CHECK-NEXT: DW_LLE_startx_length(0x0000000a, 0x0000002a)
+; CHECK-NEXT: DW_LLE_startx_length (0x0000000a, 0x0000002a)
; CHECK-NEXT: => Addr idx 10 (w/ length 42): DW_OP_breg7 RSP-20
-; CHECK-NEXT: DW_LLE_end_of_list ()
+; CHECK-NEXT: DW_LLE_end_of_list ()
; Make sure we don't produce any relocations in any .dwo section (though in particular, debug_info.dwo)
; HDR-NOT: .rela.{{.*}}.dwo
diff --git a/llvm/test/DebugInfo/X86/stack-value-piece.ll b/llvm/test/DebugInfo/X86/stack-value-piece.ll
index 6b6795c3489..78fec0ed4e7 100644
--- a/llvm/test/DebugInfo/X86/stack-value-piece.ll
+++ b/llvm/test/DebugInfo/X86/stack-value-piece.ll
@@ -18,14 +18,14 @@
; CHECK: DW_TAG_subprogram
; CHECK: DW_AT_name {{.*}} "i"
; CHECK: DW_TAG_variable
-; CHECK-NEXT: DW_AT_location {{.*}} ([[I:.*]]
+; CHECK-NEXT: DW_AT_location {{.*}} ([[I:0x[0-9a-f]+]]
; CHECK-NEXT: [{{.*}}, {{.*}}): DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
; CHECK-NEXT: DW_AT_name {{.*}} "r"
;
; CHECK: DW_TAG_subprogram
; CHECK: DW_AT_name {{.*}} "f"
; CHECK: DW_TAG_variable
-; CHECK-NEXT: DW_AT_location {{.*}} ([[F:.*]]
+; CHECK-NEXT: DW_AT_location {{.*}} ([[F:0x[0-9a-f]+]]
; CHECK-NEXT: [{{.*}}, {{.*}}): DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
; CHECK-NEXT: [{{.*}}, {{.*}}): DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
; CHECK-NEXT: DW_AT_name {{.*}} "r"
diff --git a/llvm/test/tools/llvm-dwarfdump/X86/debug_loclists_startx_length.s b/llvm/test/tools/llvm-dwarfdump/X86/debug_loclists_startx_length.s
index 75fd43f6056..25e883381c1 100644
--- a/llvm/test/tools/llvm-dwarfdump/X86/debug_loclists_startx_length.s
+++ b/llvm/test/tools/llvm-dwarfdump/X86/debug_loclists_startx_length.s
@@ -8,9 +8,9 @@
# CHECK: .debug_loclists contents:
# CHECK-NEXT: 0x00000000: locations list header: length = 0x0000000e, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
# CHECK-NEXT: 0x0000000c:
-# CHECK-NEXT: DW_LLE_startx_length(0x0000000000000001, 0x0000000000000010)
+# CHECK-NEXT: DW_LLE_startx_length (0x0000000000000001, 0x0000000000000010)
# CHECK-NEXT: => Addr idx 1 (w/ length 16): DW_OP_reg5 RDI
-# CHECK-NEXT: DW_LLE_end_of_list ()
+# CHECK-NEXT: DW_LLE_end_of_list ()
.section .debug_loclists,"",@progbits
.long .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0
OpenPOWER on IntegriCloud