Index: lldb/source/Expression/DWARFExpression.cpp =================================================================== --- lldb/source/Expression/DWARFExpression.cpp +++ lldb/source/Expression/DWARFExpression.cpp @@ -69,9 +69,21 @@ void DWARFExpression::DumpLocation(Stream *s, lldb::DescriptionLevel level, ABI *abi) const { + auto *MCRegInfo = abi ? &abi->GetMCRegisterInfo() : nullptr; + auto GetRegName = [&MCRegInfo](uint64_t DwarfRegNum, + bool IsEH) -> llvm::StringRef { + if (!MCRegInfo) + return {}; + if (std::optional LLVMRegNum = + MCRegInfo->getLLVMRegNum(DwarfRegNum, IsEH)) + if (const char *RegName = MCRegInfo->getName(*LLVMRegNum)) + return llvm::StringRef(RegName); + return {}; + }; + llvm::DIDumpOptions DumpOpts; + DumpOpts.GetNameForDWARFReg = GetRegName; llvm::DWARFExpression(m_data.GetAsLLVM(), m_data.GetAddressByteSize()) - .print(s->AsRawOstream(), llvm::DIDumpOptions(), - abi ? &abi->GetMCRegisterInfo() : nullptr, nullptr); + .print(s->AsRawOstream(), DumpOpts, nullptr); } RegisterKind DWARFExpression::GetRegisterKind() const { return m_reg_kind; } Index: lldb/source/Symbol/UnwindPlan.cpp =================================================================== --- lldb/source/Symbol/UnwindPlan.cpp +++ lldb/source/Symbol/UnwindPlan.cpp @@ -84,7 +84,7 @@ llvm::DataExtractor data(expr, order_and_width->first == eByteOrderLittle, order_and_width->second); llvm::DWARFExpression(data, order_and_width->second, llvm::dwarf::DWARF32) - .print(s.AsRawOstream(), llvm::DIDumpOptions(), nullptr, nullptr); + .print(s.AsRawOstream(), llvm::DIDumpOptions(), nullptr); } else s.PutCString("dwarf-expr"); } Index: lldb/unittests/Symbol/PostfixExpressionTest.cpp =================================================================== --- lldb/unittests/Symbol/PostfixExpressionTest.cpp +++ lldb/unittests/Symbol/PostfixExpressionTest.cpp @@ -159,7 +159,7 @@ std::string result; llvm::raw_string_ostream os(result); llvm::DWARFExpression(extractor, addr_size, llvm::dwarf::DWARF32) - .print(os, llvm::DIDumpOptions(), nullptr, nullptr); + .print(os, llvm::DIDumpOptions(), nullptr); return std::move(os.str()); } Index: lldb/unittests/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpressionTests.cpp =================================================================== --- lldb/unittests/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpressionTests.cpp +++ lldb/unittests/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpressionTests.cpp @@ -40,7 +40,7 @@ std::string result; llvm::raw_string_ostream os(result); llvm::DWARFExpression(extractor, /*AddressSize=*/4, llvm::dwarf::DWARF32) - .print(os, llvm::DIDumpOptions(), nullptr, nullptr); + .print(os, llvm::DIDumpOptions(), nullptr); // actual check ASSERT_EQ(expected_dwarf_expression, os.str()); Index: llvm/include/llvm/DebugInfo/DIContext.h =================================================================== --- llvm/include/llvm/DebugInfo/DIContext.h +++ llvm/include/llvm/DebugInfo/DIContext.h @@ -199,6 +199,9 @@ bool SummarizeTypes = false; bool Verbose = false; bool DisplayRawContents = false; + bool IsEH = false; + std::function + GetNameForDWARFReg; /// Return default option set for printing a single DIE without children. static DIDumpOptions getForSingleDIE() { Index: llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h =================================================================== --- llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h +++ llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h @@ -27,7 +27,6 @@ namespace llvm { -class MCRegisterInfo; class MemoryBuffer; class AppleAcceleratorTable; class DWARFCompileUnit; @@ -81,9 +80,6 @@ std::weak_ptr DWP; bool CheckedForDWP = false; std::string DWPName; - - std::unique_ptr RegInfo; - std::function RecoverableErrorHandler = WithColor::defaultErrorHandler; std::function WarningHandler = WithColor::defaultWarningHandler; @@ -408,8 +404,6 @@ std::shared_ptr getDWOContext(StringRef AbsolutePath); - const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); } - function_ref getRecoverableErrorHandler() { return RecoverableErrorHandler; } @@ -435,11 +429,6 @@ std::function WarningHandler = WithColor::defaultWarningHandler); - /// Loads register info for the architecture of the provided object file. - /// Improves readability of dumped DWARF expressions. Requires the caller to - /// have initialized the relevant target descriptions. - Error loadRegisterInfo(const object::ObjectFile &Obj); - /// Get address size from CUs. /// TODO: refactor compile_units() to make this const. uint8_t getCUAddrSize(); Index: llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h =================================================================== --- llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h +++ llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h @@ -164,7 +164,7 @@ /// instead of from .debug_frame. This is needed for register number /// conversion because some register numbers differ between the two sections /// for certain architectures like x86. - void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const; + void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const; bool operator==(const UnwindLocation &RHS) const; }; @@ -222,7 +222,7 @@ /// instead of from .debug_frame. This is needed for register number /// conversion because some register numbers differ between the two sections /// for certain architectures like x86. - void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const; + void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const; /// Returns true if we have any register locations in this object. bool hasLocations() const { return !Locations.empty(); } @@ -303,7 +303,7 @@ /// /// \param IndentLevel specify the indent level as an integer. The UnwindRow /// will be output to the stream preceded by 2 * IndentLevel number of spaces. - void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH, + void dump(raw_ostream &OS, DIDumpOptions DumpOpts, unsigned IndentLevel = 0) const; }; @@ -348,7 +348,7 @@ /// /// \param IndentLevel specify the indent level as an integer. The UnwindRow /// will be output to the stream preceded by 2 * IndentLevel number of spaces. - void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH, + void dump(raw_ostream &OS, DIDumpOptions DumpOpts, unsigned IndentLevel = 0) const; /// Create an UnwindTable from a Common Information Entry (CIE). @@ -454,8 +454,8 @@ /// where a problem occurred in case an error is returned. Error parse(DWARFDataExtractor Data, uint64_t *Offset, uint64_t EndOffset); - void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI, - bool IsEH, unsigned IndentLevel = 1) const; + void dump(raw_ostream &OS, DIDumpOptions DumpOpts, + unsigned IndentLevel = 1) const; void addInstruction(const Instruction &I) { Instructions.push_back(I); } @@ -523,7 +523,6 @@ /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand. void printOperand(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *MRI, bool IsEH, const Instruction &Instr, unsigned OperandIdx, uint64_t Operand) const; }; @@ -548,8 +547,7 @@ CFIProgram &cfis() { return CFIs; } /// Dump the instructions in this CFI fragment - virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *MRI, bool IsEH) const = 0; + virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const = 0; protected: const FrameKind Kind; @@ -605,8 +603,7 @@ uint32_t getLSDAPointerEncoding() const { return LSDAPointerEncoding; } - void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI, - bool IsEH) const override; + void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const override; private: /// The following fields are defined in section 6.4.1 of the DWARF standard v4 @@ -645,8 +642,7 @@ uint64_t getAddressRange() const { return AddressRange; } std::optional getLSDAAddress() const { return LSDAAddress; } - void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI, - bool IsEH) const override; + void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const override; static bool classof(const FrameEntry *FE) { return FE->getKind() == FK_FDE; } @@ -688,7 +684,7 @@ ~DWARFDebugFrame(); /// Dump the section data into the given stream. - void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI, + void dump(raw_ostream &OS, DIDumpOptions DumpOpts, std::optional Offset) const; /// Parse the section from raw data. \p Data is assumed to contain the whole Index: llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h =================================================================== --- llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h +++ llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h @@ -66,9 +66,8 @@ /// updated to point past the end of the current list). bool dumpLocationList(uint64_t *Offset, raw_ostream &OS, std::optional BaseAddr, - const MCRegisterInfo *MRI, const DWARFObject &Obj, - DWARFUnit *U, DIDumpOptions DumpOpts, - unsigned Indent) const; + const DWARFObject &Obj, DWARFUnit *U, + DIDumpOptions DumpOpts, unsigned Indent) const; Error visitAbsoluteLocationList( uint64_t Offset, std::optional BaseAddr, @@ -109,8 +108,7 @@ : DWARFLocationTable(std::move(Data)) {} /// Print the location lists found within the debug_loc section. - void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo, - const DWARFObject &Obj, DIDumpOptions DumpOpts, + void dump(raw_ostream &OS, const DWARFObject &Obj, DIDumpOptions DumpOpts, std::optional Offset) const; Error visitLocationList( @@ -134,8 +132,7 @@ /// Dump all location lists within the given range. void dumpRange(uint64_t StartOffset, uint64_t Size, raw_ostream &OS, - const MCRegisterInfo *MRI, const DWARFObject &Obj, - DIDumpOptions DumpOpts); + const DWARFObject &Obj, DIDumpOptions DumpOpts); protected: void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS, Index: llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h =================================================================== --- llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h +++ llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h @@ -93,8 +93,7 @@ uint64_t getEndOffset() const { return EndOffset; } bool isError() const { return Error; } bool print(raw_ostream &OS, DIDumpOptions DumpOpts, - const DWARFExpression *Expr, const MCRegisterInfo *RegInfo, - DWARFUnit *U, bool isEH) const; + const DWARFExpression *Expr, DWARFUnit *U) const; /// Verify \p Op. Does not affect the return of \a isError(). static bool verify(const Operation &Op, DWARFUnit *U); @@ -147,15 +146,16 @@ iterator begin() const { return iterator(this, 0); } iterator end() const { return iterator(this, Data.getData().size()); } - void print(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *RegInfo, DWARFUnit *U, + void print(raw_ostream &OS, DIDumpOptions DumpOpts, DWARFUnit *U, bool IsEH = false) const; /// Print the expression in a format intended to be compact and useful to a /// user, but not perfectly unambiguous, or capable of representing every /// valid DWARF expression. Returns true if the expression was sucessfully /// printed. - bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo); + bool printCompact(raw_ostream &OS, + std::function + GetNameForDWARFReg = nullptr); bool verify(DWARFUnit *U); @@ -165,8 +165,7 @@ static bool prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS, DIDumpOptions DumpOpts, uint8_t Opcode, - const uint64_t Operands[2], - const MCRegisterInfo *MRI, bool isEH); + const uint64_t Operands[2]); private: DataExtractor Data; Index: llvm/lib/DebugInfo/DWARF/CMakeLists.txt =================================================================== --- llvm/lib/DebugInfo/DWARF/CMakeLists.txt +++ llvm/lib/DebugInfo/DWARF/CMakeLists.txt @@ -36,6 +36,5 @@ LINK_COMPONENTS BinaryFormat Object - MC Support ) Index: llvm/lib/DebugInfo/DWARF/DWARFContext.cpp =================================================================== --- llvm/lib/DebugInfo/DWARF/DWARFContext.cpp +++ llvm/lib/DebugInfo/DWARF/DWARFContext.cpp @@ -38,7 +38,6 @@ #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h" #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h" #include "llvm/DebugInfo/DWARF/DWARFVerifier.h" -#include "llvm/MC/MCRegisterInfo.h" #include "llvm/MC/TargetRegistry.h" #include "llvm/Object/Decompressor.h" #include "llvm/Object/MachO.h" @@ -309,9 +308,7 @@ } static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts, - DWARFDataExtractor Data, - const MCRegisterInfo *MRI, - const DWARFObject &Obj, + DWARFDataExtractor Data, const DWARFObject &Obj, std::optional DumpOffset) { uint64_t Offset = 0; @@ -330,13 +327,13 @@ if (DumpOffset) { if (DumpOffset >= Offset && DumpOffset < EndOffset) { Offset = *DumpOffset; - Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, MRI, Obj, + Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, Obj, nullptr, DumpOpts, /*Indent=*/0); OS << "\n"; return; } } else { - Loc.dumpRange(Offset, EndOffset - Offset, OS, MRI, Obj, DumpOpts); + Loc.dumpRange(Offset, EndOffset - Offset, OS, Obj, DumpOpts); } Offset = EndOffset; } @@ -424,21 +421,21 @@ if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc, DObj->getLocSection().Data)) { - getDebugLoc()->dump(OS, getRegisterInfo(), *DObj, LLDumpOpts, *Off); + getDebugLoc()->dump(OS, *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(), *DObj, *Off); + dumpLoclistsSection(OS, LLDumpOpts, Data, *DObj, *Off); } if (const auto *Off = shouldDump(ExplicitDWO, ".debug_loclists.dwo", DIDT_ID_DebugLoclists, DObj->getLoclistsDWOSection().Data)) { DWARFDataExtractor Data(*DObj, DObj->getLoclistsDWOSection(), isLittleEndian(), 0); - dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off); + dumpLoclistsSection(OS, LLDumpOpts, Data, *DObj, *Off); } if (const auto *Off = @@ -450,12 +447,12 @@ if (*Off) { uint64_t Offset = **Off; Loc.dumpLocationList(&Offset, OS, - /*BaseAddr=*/std::nullopt, getRegisterInfo(), *DObj, - nullptr, LLDumpOpts, /*Indent=*/0); + /*BaseAddr=*/std::nullopt, *DObj, nullptr, + LLDumpOpts, + /*Indent=*/0); OS << "\n"; } else { - Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(), *DObj, - LLDumpOpts); + Loc.dumpRange(0, Data.getData().size(), OS, *DObj, LLDumpOpts); } } @@ -463,7 +460,7 @@ shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame, DObj->getFrameSection().Data)) { if (Expected DF = getDebugFrame()) - (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off); + (*DF)->dump(OS, DumpOpts, *Off); else RecoverableErrorHandler(DF.takeError()); } @@ -472,7 +469,7 @@ shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame, DObj->getEHFrameSection().Data)) { if (Expected DF = getEHFrame()) - (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off); + (*DF)->dump(OS, DumpOpts, *Off); else RecoverableErrorHandler(DF.takeError()); } @@ -2020,23 +2017,6 @@ std::move(DObj), "", RecoverableErrorHandler, WarningHandler); } -Error DWARFContext::loadRegisterInfo(const object::ObjectFile &Obj) { - // Detect the architecture from the object file. We usually don't need OS - // info to lookup a target and create register info. - Triple TT; - TT.setArch(Triple::ArchType(Obj.getArch())); - TT.setVendor(Triple::UnknownVendor); - TT.setOS(Triple::UnknownOS); - std::string TargetLookupError; - const Target *TheTarget = - TargetRegistry::lookupTarget(TT.str(), TargetLookupError); - if (!TargetLookupError.empty()) - return createStringError(errc::invalid_argument, - TargetLookupError.c_str()); - RegInfo.reset(TheTarget->createMCRegInfo(TT.str())); - return Error::success(); -} - uint8_t DWARFContext::getCUAddrSize() { // In theory, different compile units may have different address byte // sizes, but for simplicity we just use the address byte size of the Index: llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp =================================================================== --- llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp +++ llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp @@ -13,7 +13,6 @@ #include "llvm/BinaryFormat/Dwarf.h" #include "llvm/DebugInfo/DIContext.h" #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h" -#include "llvm/MC/MCRegisterInfo.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/DataExtractor.h" #include "llvm/Support/Errc.h" @@ -29,14 +28,13 @@ using namespace llvm; using namespace dwarf; -static void printRegister(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH, +static void printRegister(raw_ostream &OS, DIDumpOptions DumpOpts, unsigned RegNum) { - if (MRI) { - if (std::optional LLVMRegNum = MRI->getLLVMRegNum(RegNum, IsEH)) { - if (const char *RegName = MRI->getName(*LLVMRegNum)) { - OS << RegName; - return; - } + if (DumpOpts.GetNameForDWARFReg) { + auto RegName = DumpOpts.GetNameForDWARFReg(RegNum, DumpOpts.IsEH); + if (!RegName.empty()) { + OS << RegName; + return; } } OS << "reg" << RegNum; @@ -80,8 +78,7 @@ return {Expr, true}; } -void UnwindLocation::dump(raw_ostream &OS, const MCRegisterInfo *MRI, - bool IsEH) const { +void UnwindLocation::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const { if (Dereference) OS << '['; switch (Kind) { @@ -103,7 +100,7 @@ OS << Offset; break; case RegPlusOffset: - printRegister(OS, MRI, IsEH, RegNum); + printRegister(OS, DumpOpts, RegNum); if (Offset == 0 && !AddrSpace) break; if (Offset >= 0) @@ -112,9 +109,10 @@ if (AddrSpace) OS << " in addrspace" << *AddrSpace; break; - case DWARFExpr: - Expr->print(OS, DIDumpOptions(), MRI, nullptr, IsEH); + case DWARFExpr: { + Expr->print(OS, DumpOpts, nullptr); break; + } case Constant: OS << Offset; break; @@ -125,7 +123,8 @@ raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindLocation &UL) { - UL.dump(OS, nullptr, false); + auto DumpOpts = DIDumpOptions(); + UL.dump(OS, DumpOpts); return OS; } @@ -150,53 +149,55 @@ return false; } -void RegisterLocations::dump(raw_ostream &OS, const MCRegisterInfo *MRI, - bool IsEH) const { +void RegisterLocations::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const { bool First = true; for (const auto &RegLocPair : Locations) { if (First) First = false; else OS << ", "; - printRegister(OS, MRI, IsEH, RegLocPair.first); + printRegister(OS, DumpOpts, RegLocPair.first); OS << '='; - RegLocPair.second.dump(OS, MRI, IsEH); + RegLocPair.second.dump(OS, DumpOpts); } } raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const RegisterLocations &RL) { - RL.dump(OS, nullptr, false); + auto DumpOpts = DIDumpOptions(); + RL.dump(OS, DumpOpts); return OS; } -void UnwindRow::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH, +void UnwindRow::dump(raw_ostream &OS, DIDumpOptions DumpOpts, unsigned IndentLevel) const { OS.indent(2 * IndentLevel); if (hasAddress()) OS << format("0x%" PRIx64 ": ", *Address); OS << "CFA="; - CFAValue.dump(OS, MRI, IsEH); + CFAValue.dump(OS, DumpOpts); if (RegLocs.hasLocations()) { OS << ": "; - RegLocs.dump(OS, MRI, IsEH); + RegLocs.dump(OS, DumpOpts); } OS << "\n"; } raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindRow &Row) { - Row.dump(OS, nullptr, false, 0); + auto DumpOpts = DIDumpOptions(); + Row.dump(OS, DumpOpts, 0); return OS; } -void UnwindTable::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH, +void UnwindTable::dump(raw_ostream &OS, DIDumpOptions DumpOpts, unsigned IndentLevel) const { for (const UnwindRow &Row : Rows) - Row.dump(OS, MRI, IsEH, IndentLevel); + Row.dump(OS, DumpOpts, IndentLevel); } raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindTable &Rows) { - Rows.dump(OS, nullptr, false, 0); + auto DumpOpts = DIDumpOptions(); + Rows.dump(OS, DumpOpts, 0); return OS; } @@ -853,7 +854,6 @@ /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand. void CFIProgram::printOperand(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *MRI, bool IsEH, const Instruction &Instr, unsigned OperandIdx, uint64_t Operand) const { assert(OperandIdx < MaxOperands); @@ -901,7 +901,7 @@ break; case OT_Register: OS << ' '; - printRegister(OS, MRI, IsEH, Operand); + printRegister(OS, DumpOpts, Operand); break; case OT_AddressSpace: OS << format(" in addrspace%" PRId64, Operand); @@ -909,20 +909,19 @@ case OT_Expression: assert(Instr.Expression && "missing DWARFExpression object"); OS << " "; - Instr.Expression->print(OS, DumpOpts, MRI, nullptr, IsEH); + Instr.Expression->print(OS, DumpOpts, nullptr); break; } } void CFIProgram::dump(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *MRI, bool IsEH, unsigned IndentLevel) const { for (const auto &Instr : Instructions) { uint8_t Opcode = Instr.Opcode; OS.indent(2 * IndentLevel); OS << callFrameString(Opcode) << ":"; for (unsigned i = 0; i < Instr.Ops.size(); ++i) - printOperand(OS, DumpOpts, MRI, IsEH, Instr, i, Instr.Ops[i]); + printOperand(OS, DumpOpts, Instr, i, Instr.Ops[i]); OS << '\n'; } } @@ -939,21 +938,20 @@ return DW_CIE_ID; } -void CIE::dump(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *MRI, bool IsEH) const { +void CIE::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const { // A CIE with a zero length is a terminator entry in the .eh_frame section. - if (IsEH && Length == 0) { + if (DumpOpts.IsEH && Length == 0) { OS << format("%08" PRIx64, Offset) << " ZERO terminator\n"; return; } OS << format("%08" PRIx64, Offset) << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length) - << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8, - getCIEId(IsDWARF64, IsEH)) + << format(" %0*" PRIx64, IsDWARF64 && !DumpOpts.IsEH ? 16 : 8, + getCIEId(IsDWARF64, DumpOpts.IsEH)) << " CIE\n" << " Format: " << FormatString(IsDWARF64) << "\n"; - if (IsEH && Version != 1) + if (DumpOpts.IsEH && Version != 1) OS << "WARNING: unsupported CIE version\n"; OS << format(" Version: %d\n", Version) << " Augmentation: \"" << Augmentation << "\"\n"; @@ -974,11 +972,11 @@ OS << "\n"; } OS << "\n"; - CFIs.dump(OS, DumpOpts, MRI, IsEH); + CFIs.dump(OS, DumpOpts); OS << "\n"; if (Expected RowsOrErr = UnwindTable::create(this)) - RowsOrErr->dump(OS, MRI, IsEH, 1); + RowsOrErr->dump(OS, DumpOpts, 1); else { DumpOpts.RecoverableErrorHandler(joinErrors( createStringError(errc::invalid_argument, @@ -988,11 +986,10 @@ OS << "\n"; } -void FDE::dump(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *MRI, bool IsEH) const { +void FDE::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const { OS << format("%08" PRIx64, Offset) << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length) - << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8, CIEPointer) + << format(" %0*" PRIx64, IsDWARF64 && !DumpOpts.IsEH ? 16 : 8, CIEPointer) << " FDE cie="; if (LinkedCIE) OS << format("%08" PRIx64, LinkedCIE->getOffset()); @@ -1003,11 +1000,11 @@ OS << " Format: " << FormatString(IsDWARF64) << "\n"; if (LSDAAddress) OS << format(" LSDA Address: %016" PRIx64 "\n", *LSDAAddress); - CFIs.dump(OS, DumpOpts, MRI, IsEH); + CFIs.dump(OS, DumpOpts); OS << "\n"; if (Expected RowsOrErr = UnwindTable::create(this)) - RowsOrErr->dump(OS, MRI, IsEH, 1); + RowsOrErr->dump(OS, DumpOpts, 1); else { DumpOpts.RecoverableErrorHandler(joinErrors( createStringError(errc::invalid_argument, @@ -1242,15 +1239,15 @@ } void DWARFDebugFrame::dump(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *MRI, std::optional Offset) const { + DumpOpts.IsEH = IsEH; if (Offset) { if (auto *Entry = getEntryAtOffset(*Offset)) - Entry->dump(OS, DumpOpts, MRI, IsEH); + Entry->dump(OS, DumpOpts); return; } OS << "\n"; for (const auto &Entry : Entries) - Entry->dump(OS, DumpOpts, MRI, IsEH); + Entry->dump(OS, DumpOpts); } Index: llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp =================================================================== --- llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp +++ llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp @@ -111,20 +111,19 @@ static void dumpExpression(raw_ostream &OS, DIDumpOptions DumpOpts, ArrayRef Data, bool IsLittleEndian, - unsigned AddressSize, const MCRegisterInfo *MRI, - DWARFUnit *U) { + unsigned AddressSize, DWARFUnit *U) { DWARFDataExtractor Extractor(Data, IsLittleEndian, AddressSize); // Note. We do not pass any format to DWARFExpression, even if the // corresponding unit is known. For now, there is only one operation, // DW_OP_call_ref, which depends on the format; it is rarely used, and // is unexpected in location tables. - DWARFExpression(Extractor, AddressSize).print(OS, DumpOpts, MRI, U); + DWARFExpression(Extractor, AddressSize).print(OS, DumpOpts, U); } bool DWARFLocationTable::dumpLocationList( uint64_t *Offset, raw_ostream &OS, std::optional BaseAddr, - const MCRegisterInfo *MRI, const DWARFObject &Obj, DWARFUnit *U, - DIDumpOptions DumpOpts, unsigned Indent) const { + const DWARFObject &Obj, DWARFUnit *U, DIDumpOptions DumpOpts, + unsigned Indent) const { DWARFLocationInterpreter Interp( BaseAddr, [U](uint32_t Index) -> std::optional { if (U) @@ -157,7 +156,7 @@ E.Kind != dwarf::DW_LLE_end_of_list) { OS << ": "; dumpExpression(OS, DumpOpts, E.Loc, Data.isLittleEndian(), - Data.getAddressSize(), MRI, U); + Data.getAddressSize(), U); } return true; }); @@ -183,13 +182,13 @@ }); } -void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI, - const DWARFObject &Obj, DIDumpOptions DumpOpts, +void DWARFDebugLoc::dump(raw_ostream &OS, const DWARFObject &Obj, + DIDumpOptions DumpOpts, std::optional DumpOffset) const { auto BaseAddr = std::nullopt; unsigned Indent = 12; if (DumpOffset) { - dumpLocationList(&*DumpOffset, OS, BaseAddr, MRI, Obj, nullptr, DumpOpts, + dumpLocationList(&*DumpOffset, OS, BaseAddr, Obj, nullptr, DumpOpts, Indent); } else { uint64_t Offset = 0; @@ -199,7 +198,7 @@ OS << Separator; Separator = "\n"; - CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, Obj, nullptr, + CanContinue = dumpLocationList(&Offset, OS, BaseAddr, Obj, nullptr, DumpOpts, Indent); OS << '\n'; } @@ -386,8 +385,7 @@ } void DWARFDebugLoclists::dumpRange(uint64_t StartOffset, uint64_t Size, - raw_ostream &OS, const MCRegisterInfo *MRI, - const DWARFObject &Obj, + raw_ostream &OS, const DWARFObject &Obj, DIDumpOptions DumpOpts) { if (!Data.isValidOffsetForDataOfSize(StartOffset, Size)) { OS << "Invalid dump range\n"; @@ -400,8 +398,8 @@ OS << Separator; Separator = "\n"; - CanContinue = dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, MRI, - Obj, nullptr, DumpOpts, /*Indent=*/12); + CanContinue = dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, Obj, + nullptr, DumpOpts, /*Indent=*/12); OS << '\n'; } } Index: llvm/lib/DebugInfo/DWARF/DWARFDie.cpp =================================================================== --- llvm/lib/DebugInfo/DWARF/DWARFDie.cpp +++ llvm/lib/DebugInfo/DWARF/DWARFDie.cpp @@ -74,7 +74,6 @@ assert(FormValue.isFormClass(DWARFFormValue::FC_SectionOffset) && "bad FORM for location list"); DWARFContext &Ctx = U->getContext(); - const MCRegisterInfo *MRI = Ctx.getRegisterInfo(); uint64_t Offset = *FormValue.getAsSectionOffset(); if (FormValue.getForm() == DW_FORM_loclistx) { @@ -85,9 +84,8 @@ else return; } - U->getLocationTable().dumpLocationList(&Offset, OS, U->getBaseAddress(), MRI, - Ctx.getDWARFObj(), U, DumpOpts, - Indent); + U->getLocationTable().dumpLocationList( + &Offset, OS, U->getBaseAddress(), Ctx.getDWARFObj(), U, DumpOpts, Indent); } static void dumpLocationExpr(raw_ostream &OS, const DWARFFormValue &FormValue, @@ -97,12 +95,11 @@ FormValue.isFormClass(DWARFFormValue::FC_Exprloc)) && "bad FORM for location expression"); DWARFContext &Ctx = U->getContext(); - const MCRegisterInfo *MRI = Ctx.getRegisterInfo(); ArrayRef Expr = *FormValue.getAsBlock(); DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()), Ctx.isLittleEndian(), 0); DWARFExpression(Data, U->getAddressByteSize(), U->getFormParams().Format) - .print(OS, DumpOpts, MRI, U); + .print(OS, DumpOpts, U); } static DWARFDie resolveReferencedType(DWARFDie D, DWARFFormValue F) { Index: llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp =================================================================== --- llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp +++ llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp @@ -8,7 +8,6 @@ #include "llvm/DebugInfo/DWARF/DWARFExpression.h" #include "llvm/DebugInfo/DWARF/DWARFUnit.h" -#include "llvm/MC/MCRegisterInfo.h" #include "llvm/Support/Format.h" #include #include @@ -225,10 +224,11 @@ } } -bool DWARFExpression::prettyPrintRegisterOp( - DWARFUnit *U, raw_ostream &OS, DIDumpOptions DumpOpts, uint8_t Opcode, - const uint64_t Operands[2], const MCRegisterInfo *MRI, bool isEH) { - if (!MRI) +bool DWARFExpression::prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS, + DIDumpOptions DumpOpts, + uint8_t Opcode, + const uint64_t Operands[2]) { + if (!DumpOpts.GetNameForDWARFReg) return false; uint64_t DwarfRegNum; @@ -242,19 +242,17 @@ else DwarfRegNum = Opcode - DW_OP_reg0; - if (std::optional LLVMRegNum = - MRI->getLLVMRegNum(DwarfRegNum, isEH)) { - if (const char *RegName = MRI->getName(*LLVMRegNum)) { - if ((Opcode >= DW_OP_breg0 && Opcode <= DW_OP_breg31) || - Opcode == DW_OP_bregx) - OS << format(" %s%+" PRId64, RegName, Operands[OpNum]); - else - OS << ' ' << RegName; - - if (Opcode == DW_OP_regval_type) - prettyPrintBaseTypeRef(U, OS, DumpOpts, Operands, 1); - return true; - } + auto RegName = DumpOpts.GetNameForDWARFReg(DwarfRegNum, DumpOpts.IsEH); + if (!RegName.empty()) { + if ((Opcode >= DW_OP_breg0 && Opcode <= DW_OP_breg31) || + Opcode == DW_OP_bregx) + OS << ' ' << RegName << format("%+" PRId64, Operands[OpNum]); + else + OS << ' ' << RegName.data(); + + if (Opcode == DW_OP_regval_type) + prettyPrintBaseTypeRef(U, OS, DumpOpts, Operands, 1); + return true; } return false; @@ -262,8 +260,7 @@ bool DWARFExpression::Operation::print(raw_ostream &OS, DIDumpOptions DumpOpts, const DWARFExpression *Expr, - const MCRegisterInfo *RegInfo, - DWARFUnit *U, bool isEH) const { + DWARFUnit *U) const { if (Error) { OS << ""; return false; @@ -277,7 +274,7 @@ (Opcode >= DW_OP_reg0 && Opcode <= DW_OP_reg31) || Opcode == DW_OP_bregx || Opcode == DW_OP_regx || Opcode == DW_OP_regval_type) - if (prettyPrintRegisterOp(U, OS, DumpOpts, Opcode, Operands, RegInfo, isEH)) + if (prettyPrintRegisterOp(U, OS, DumpOpts, Opcode, Operands)) return true; for (unsigned Operand = 0; Operand < 2; ++Operand) { @@ -323,15 +320,15 @@ } void DWARFExpression::print(raw_ostream &OS, DIDumpOptions DumpOpts, - const MCRegisterInfo *RegInfo, DWARFUnit *U, - bool IsEH) const { + DWARFUnit *U, bool IsEH) const { uint32_t EntryValExprSize = 0; uint64_t EntryValStartOffset = 0; if (Data.getData().empty()) OS << ""; for (auto &Op : *this) { - if (!Op.print(OS, DumpOpts, this, RegInfo, U, IsEH)) { + DumpOpts.IsEH = IsEH; + if (!Op.print(OS, DumpOpts, this, U)) { uint64_t FailOffset = Op.getEndOffset(); while (FailOffset < Data.getData().size()) OS << format(" %02x", Data.getU8(&FailOffset)); @@ -402,9 +399,11 @@ PrintedExpr(ExprKind K = Address) : Kind(K) {} }; -static bool printCompactDWARFExpr(raw_ostream &OS, DWARFExpression::iterator I, - const DWARFExpression::iterator E, - const MCRegisterInfo &MRI) { +static bool printCompactDWARFExpr( + raw_ostream &OS, DWARFExpression::iterator I, + const DWARFExpression::iterator E, + std::function GetNameForDWARFReg = + nullptr) { SmallVector Stack; while (I != E) { @@ -415,27 +414,21 @@ // DW_OP_regx: A register, with the register num given as an operand. // Printed as the plain register name. uint64_t DwarfRegNum = Op.getRawOperand(0); - std::optional LLVMRegNum = - MRI.getLLVMRegNum(DwarfRegNum, false); - if (!LLVMRegNum) { - OS << ""; + auto RegName = GetNameForDWARFReg(DwarfRegNum, false); + if (RegName.empty()) return false; - } raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String); - S << MRI.getName(*LLVMRegNum); + S << RegName; break; } case dwarf::DW_OP_bregx: { int DwarfRegNum = Op.getRawOperand(0); int64_t Offset = Op.getRawOperand(1); - std::optional LLVMRegNum = - MRI.getLLVMRegNum(DwarfRegNum, false); - if (!LLVMRegNum) { - OS << ""; + auto RegName = GetNameForDWARFReg(DwarfRegNum, false); + if (RegName.empty()) return false; - } raw_svector_ostream S(Stack.emplace_back().String); - S << MRI.getName(*LLVMRegNum); + S << RegName; if (Offset) S << format("%+" PRId64, Offset); break; @@ -449,7 +442,7 @@ ++I; raw_svector_ostream S(Stack.emplace_back().String); S << "entry("; - printCompactDWARFExpr(S, I, SubExprEnd, MRI); + printCompactDWARFExpr(S, I, SubExprEnd, GetNameForDWARFReg); S << ")"; I = SubExprEnd; continue; @@ -466,26 +459,20 @@ // DW_OP_reg: A register, with the register num implied by the // opcode. Printed as the plain register name. uint64_t DwarfRegNum = Opcode - dwarf::DW_OP_reg0; - std::optional LLVMRegNum = - MRI.getLLVMRegNum(DwarfRegNum, false); - if (!LLVMRegNum) { - OS << ""; + auto RegName = GetNameForDWARFReg(DwarfRegNum, false); + if (RegName.empty()) return false; - } raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String); - S << MRI.getName(*LLVMRegNum); + S << RegName; } else if (Opcode >= dwarf::DW_OP_breg0 && Opcode <= dwarf::DW_OP_breg31) { int DwarfRegNum = Opcode - dwarf::DW_OP_breg0; int64_t Offset = Op.getRawOperand(0); - std::optional LLVMRegNum = - MRI.getLLVMRegNum(DwarfRegNum, false); - if (!LLVMRegNum) { - OS << ""; + auto RegName = GetNameForDWARFReg(DwarfRegNum, false); + if (RegName.empty()) return false; - } raw_svector_ostream S(Stack.emplace_back().String); - S << MRI.getName(*LLVMRegNum); + S << RegName; if (Offset) S << format("%+" PRId64, Offset); } else { @@ -510,8 +497,10 @@ return true; } -bool DWARFExpression::printCompact(raw_ostream &OS, const MCRegisterInfo &MRI) { - return printCompactDWARFExpr(OS, begin(), end(), MRI); +bool DWARFExpression::printCompact( + raw_ostream &OS, + std::function GetNameForDWARFReg) { + return printCompactDWARFExpr(OS, begin(), end(), GetNameForDWARFReg); } bool DWARFExpression::operator==(const DWARFExpression &RHS) const { Index: llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp =================================================================== --- llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp +++ llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp @@ -770,9 +770,19 @@ std::string string; raw_string_ostream Stream(string); DIDumpOptions DumpOpts; + auto *MCRegInfo = MRI.get(); + auto GetRegName = [&MCRegInfo](uint64_t DwarfRegNum, bool IsEH) -> StringRef { + if (!MCRegInfo) + return {}; + if (std::optional LLVMRegNum = + MCRegInfo->getLLVMRegNum(DwarfRegNum, IsEH)) + if (const char *RegName = MCRegInfo->getName(*LLVMRegNum)) + return StringRef(RegName); + return {}; + }; + DumpOpts.GetNameForDWARFReg = GetRegName; DWARFExpression::prettyPrintRegisterOp(/*U=*/nullptr, Stream, DumpOpts, - Opcode, Operands, MRI.get(), - /*isEH=*/false); + Opcode, Operands); return Stream.str(); } Index: llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp =================================================================== --- llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp +++ llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp @@ -18,6 +18,8 @@ #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h" #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h" #include "llvm/DebugInfo/DWARF/DWARFContext.h" +#include "llvm/MC/MCRegisterInfo.h" +#include "llvm/MC/TargetRegistry.h" #include "llvm/Object/Archive.h" #include "llvm/Object/MachOUniversal.h" #include "llvm/Object/ObjectFile.h" @@ -340,9 +342,11 @@ const Twine &, raw_ostream &)>; /// Print only DIEs that have a certain name. -static bool filterByName(const StringSet<> &Names, DWARFDie Die, - StringRef NameRef, raw_ostream &OS) { +static bool filterByName( + const StringSet<> &Names, DWARFDie Die, StringRef NameRef, raw_ostream &OS, + std::function GetNameForDWARFReg) { DIDumpOptions DumpOpts = getDumpOpts(Die.getDwarfUnit()->getContext()); + DumpOpts.GetNameForDWARFReg = GetNameForDWARFReg; std::string Name = (IgnoreCase && !UseRegex) ? NameRef.lower() : NameRef.str(); if (UseRegex) { @@ -368,17 +372,18 @@ } /// Print only DIEs that have a certain name. -static void filterByName(const StringSet<> &Names, - DWARFContext::unit_iterator_range CUs, - raw_ostream &OS) { +static void filterByName( + const StringSet<> &Names, DWARFContext::unit_iterator_range CUs, + raw_ostream &OS, + std::function GetNameForDWARFReg) { for (const auto &CU : CUs) for (const auto &Entry : CU->dies()) { DWARFDie Die = {CU.get(), &Entry}; if (const char *Name = Die.getName(DINameKind::ShortName)) - if (filterByName(Names, Die, Name, OS)) + if (filterByName(Names, Die, Name, OS, GetNameForDWARFReg)) continue; if (const char *Name = Die.getName(DINameKind::LinkageName)) - filterByName(Names, Die, Name, OS); + filterByName(Names, Die, Name, OS, GetNameForDWARFReg); } } @@ -422,8 +427,9 @@ } /// Print only DIEs that have a certain name. -static void filterByAccelName(ArrayRef Names, DWARFContext &DICtx, - raw_ostream &OS) { +static void filterByAccelName( + ArrayRef Names, DWARFContext &DICtx, raw_ostream &OS, + std::function GetNameForDWARFReg) { SmallVector Dies; for (const auto &Name : Names) { getDies(DICtx, DICtx.getAppleNames(), Name, Dies); @@ -435,6 +441,7 @@ Dies.erase(std::unique(Dies.begin(), Dies.end()), Dies.end()); DIDumpOptions DumpOpts = getDumpOpts(DICtx); + DumpOpts.GetNameForDWARFReg = GetNameForDWARFReg; for (DWARFDie Die : Dies) Die.dump(OS, 0, DumpOpts); } @@ -551,10 +558,41 @@ return Result; } +static std::unique_ptr +createRegInfo(const object::ObjectFile &Obj) { + std::unique_ptr MCRegInfo; + Triple TT; + TT.setArch(Triple::ArchType(Obj.getArch())); + TT.setVendor(Triple::UnknownVendor); + TT.setOS(Triple::UnknownOS); + std::string TargetLookupError; + const Target *TheTarget = + TargetRegistry::lookupTarget(TT.str(), TargetLookupError); + if (!TargetLookupError.empty()) + return nullptr; + MCRegInfo.reset(TheTarget->createMCRegInfo(TT.str())); + return MCRegInfo; +} + static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx, const Twine &Filename, raw_ostream &OS) { - logAllUnhandledErrors(DICtx.loadRegisterInfo(Obj), errs(), - Filename.str() + ": "); + + auto MCRegInfo = createRegInfo(Obj); + if (!MCRegInfo) + logAllUnhandledErrors(createStringError(inconvertibleErrorCode(), + "Error in creating MCRegInfo"), + errs(), Filename.str() + ": "); + + auto GetRegName = [&MCRegInfo](uint64_t DwarfRegNum, bool IsEH) -> StringRef { + if (!MCRegInfo) + return {}; + if (std::optional LLVMRegNum = + MCRegInfo->getLLVMRegNum(DwarfRegNum, IsEH)) + if (const char *RegName = MCRegInfo->getName(*LLVMRegNum)) + return StringRef(RegName); + return {}; + }; + // The UUID dump already contains all the same information. if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All) OS << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n'; @@ -569,19 +607,21 @@ for (auto name : Name) Names.insert((IgnoreCase && !UseRegex) ? StringRef(name).lower() : name); - filterByName(Names, DICtx.normal_units(), OS); - filterByName(Names, DICtx.dwo_units(), OS); + filterByName(Names, DICtx.normal_units(), OS, GetRegName); + filterByName(Names, DICtx.dwo_units(), OS, GetRegName); return true; } // Handle the --find option and lower it to --debug-info=. if (!Find.empty()) { - filterByAccelName(Find, DICtx, OS); + filterByAccelName(Find, DICtx, OS, GetRegName); return true; } // Dump the complete DWARF structure. - DICtx.dump(OS, getDumpOpts(DICtx), DumpOffsets); + auto DumpOpts = getDumpOpts(DICtx); + DumpOpts.GetNameForDWARFReg = GetRegName; + DICtx.dump(OS, DumpOpts, DumpOffsets); return true; } Index: llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp =================================================================== --- llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp +++ llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp @@ -286,7 +286,6 @@ if (!DICtx) return createStringError(std::errc::invalid_argument, "unable to create DWARF context"); - logAllUnhandledErrors(DICtx->loadRegisterInfo(Obj), OS, "DwarfTransformer: "); // Make a DWARF transformer object and populate the ranges of the code // so we don't end up adding invalid functions to GSYM data. Index: llvm/tools/llvm-objdump/SourcePrinter.h =================================================================== --- llvm/tools/llvm-objdump/SourcePrinter.h +++ llvm/tools/llvm-objdump/SourcePrinter.h @@ -13,6 +13,7 @@ #include "llvm/ADT/StringSet.h" #include "llvm/DebugInfo/DWARF/DWARFContext.h" #include "llvm/DebugInfo/Symbolize/Symbolize.h" +#include "llvm/MC/MCRegisterInfo.h" #include "llvm/MC/MCSubtargetInfo.h" #include "llvm/Support/FormattedStream.h" #include Index: llvm/tools/llvm-objdump/SourcePrinter.cpp =================================================================== --- llvm/tools/llvm-objdump/SourcePrinter.cpp +++ llvm/tools/llvm-objdump/SourcePrinter.cpp @@ -42,7 +42,17 @@ DataExtractor Data({LocExpr.Expr.data(), LocExpr.Expr.size()}, Unit->getContext().isLittleEndian(), 0); DWARFExpression Expression(Data, Unit->getAddressByteSize()); - Expression.printCompact(OS, MRI); + + auto GetRegName = [&MRI, &OS](uint64_t DwarfRegNum, bool IsEH) -> StringRef { + if (std::optional LLVMRegNum = + MRI.getLLVMRegNum(DwarfRegNum, IsEH)) + if (const char *RegName = MRI.getName(*LLVMRegNum)) + return StringRef(RegName); + OS << ""; + return {}; + }; + + Expression.printCompact(OS, GetRegName); } void LiveVariablePrinter::addVariable(DWARFDie FuncDie, DWARFDie VarDie) { Index: llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h =================================================================== --- llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h +++ llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h @@ -226,8 +226,9 @@ W.getOStream() << "\n"; W.startLine() << "Program:\n"; W.indent(); - Entry.cfis().dump(W.getOStream(), DIDumpOptions(), nullptr, - W.getIndentLevel()); + auto DumpOpts = DIDumpOptions(); + DumpOpts.IsEH = true; + Entry.cfis().dump(W.getOStream(), DumpOpts, W.getIndentLevel()); W.unindent(); W.unindent(); W.getOStream() << "\n"; Index: llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp =================================================================== --- llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp +++ llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp @@ -41,7 +41,9 @@ StringRef ExpectedFirstLine) { std::string Output; raw_string_ostream OS(Output); - TestCIE.dump(OS, DIDumpOptions(), /*MRI=*/nullptr, IsEH); + auto DumpOpts = DIDumpOptions(); + DumpOpts.IsEH = IsEH; + TestCIE.dump(OS, DumpOpts); OS.flush(); StringRef FirstLine = StringRef(Output).split('\n').first; EXPECT_EQ(FirstLine, ExpectedFirstLine); @@ -51,7 +53,9 @@ StringRef ExpectedFirstLine) { std::string Output; raw_string_ostream OS(Output); - TestFDE.dump(OS, DIDumpOptions(), /*MRI=*/nullptr, IsEH); + auto DumpOpts = DIDumpOptions(); + DumpOpts.IsEH = IsEH; + TestFDE.dump(OS, DumpOpts); OS.flush(); StringRef FirstLine = StringRef(Output).split('\n').first; EXPECT_EQ(FirstLine, ExpectedFirstLine); Index: llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp =================================================================== --- llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp +++ llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp @@ -60,7 +60,17 @@ raw_string_ostream OS(Result); DataExtractor DE(ExprData, true, 8); DWARFExpression Expr(DE, 8); - Expr.printCompact(OS, *MRI); + + auto GetRegName = [&](uint64_t DwarfRegNum, bool IsEH) -> StringRef { + if (std::optional LLVMRegNum = + this->MRI->getLLVMRegNum(DwarfRegNum, IsEH)) + if (const char *RegName = this->MRI->getName(*LLVMRegNum)) + return llvm::StringRef(RegName); + OS << ""; + return {}; + }; + + Expr.printCompact(OS, GetRegName); EXPECT_EQ(OS.str(), Expected); }