void DWARFExpression::DumpLocation(Stream *s, lldb::DescriptionLevel level,
ABI *abi) const {
llvm::DWARFExpression(m_data.GetAsLLVM(), m_data.GetAddressByteSize())
- .print(s->AsRawOstream(), llvm::DIDumpOptions(),
- abi ? &abi->GetMCRegisterInfo() : nullptr, nullptr);
+ .print(s->AsRawOstream(), llvm::DIDumpOptions(), nullptr);
}
RegisterKind DWARFExpression::GetRegisterKind() const { return m_reg_kind; }
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");
}
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());
}
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());
bool SummarizeTypes = false;
bool Verbose = false;
bool DisplayRawContents = false;
+ bool IsEH = false;
+ std::function<llvm::StringRef(uint64_t DwarfRegNum, bool IsEH)>
+ GetNameForDWARFReg;
/// Return default option set for printing a single DIE without children.
static DIDumpOptions getForSingleDIE() {
namespace llvm {
-class MCRegisterInfo;
class MemoryBuffer;
class AppleAcceleratorTable;
class DWARFCompileUnit;
std::weak_ptr<DWOFile> DWP;
bool CheckedForDWP = false;
std::string DWPName;
-
- std::unique_ptr<MCRegisterInfo> RegInfo;
-
std::function<void(Error)> RecoverableErrorHandler =
WithColor::defaultErrorHandler;
std::function<void(Error)> WarningHandler = WithColor::defaultWarningHandler;
std::shared_ptr<DWARFContext> getDWOContext(StringRef AbsolutePath);
- const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); }
-
function_ref<void(Error)> getRecoverableErrorHandler() {
return RecoverableErrorHandler;
}
std::function<void(Error)> 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();
/// 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;
};
/// 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(); }
///
/// \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;
};
///
/// \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).
/// 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); }
/// 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;
};
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;
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
uint64_t getAddressRange() const { return AddressRange; }
std::optional<uint64_t> 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; }
~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<uint64_t> Offset) const;
/// Parse the section from raw data. \p Data is assumed to contain the whole
/// updated to point past the end of the current list).
bool dumpLocationList(uint64_t *Offset, raw_ostream &OS,
std::optional<object::SectionedAddress> 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<object::SectionedAddress> BaseAddr,
: 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<uint64_t> Offset) const;
Error visitLocationList(
/// 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,
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);
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<StringRef(uint64_t RegNum, bool IsEH)>
+ GetNameForDWARFReg = nullptr);
bool verify(DWARFUnit *U);
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;
LINK_COMPONENTS
BinaryFormat
Object
- MC
Support
)
#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"
}
static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
- DWARFDataExtractor Data,
- const MCRegisterInfo *MRI,
- const DWARFObject &Obj,
+ DWARFDataExtractor Data, const DWARFObject &Obj,
std::optional<uint64_t> DumpOffset) {
uint64_t Offset = 0;
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;
}
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 =
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);
}
}
shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
DObj->getFrameSection().Data)) {
if (Expected<const DWARFDebugFrame *> DF = getDebugFrame())
- (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off);
+ (*DF)->dump(OS, DumpOpts, *Off);
else
RecoverableErrorHandler(DF.takeError());
}
shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
DObj->getEHFrameSection().Data)) {
if (Expected<const DWARFDebugFrame *> DF = getEHFrame())
- (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off);
+ (*DF)->dump(OS, DumpOpts, *Off);
else
RecoverableErrorHandler(DF.takeError());
}
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
#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"
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<unsigned> 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;
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) {
OS << Offset;
break;
case RegPlusOffset:
- printRegister(OS, MRI, IsEH, RegNum);
+ printRegister(OS, DumpOpts, RegNum);
if (Offset == 0 && !AddrSpace)
break;
if (Offset >= 0)
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;
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;
}
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;
}
/// 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);
break;
case OT_Register:
OS << ' ';
- printRegister(OS, MRI, IsEH, Operand);
+ printRegister(OS, DumpOpts, Operand);
break;
case OT_AddressSpace:
OS << format(" in addrspace%" PRId64, Operand);
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';
}
}
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";
OS << "\n";
}
OS << "\n";
- CFIs.dump(OS, DumpOpts, MRI, IsEH);
+ CFIs.dump(OS, DumpOpts);
OS << "\n";
if (Expected<UnwindTable> RowsOrErr = UnwindTable::create(this))
- RowsOrErr->dump(OS, MRI, IsEH, 1);
+ RowsOrErr->dump(OS, DumpOpts, 1);
else {
DumpOpts.RecoverableErrorHandler(joinErrors(
createStringError(errc::invalid_argument,
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());
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<UnwindTable> RowsOrErr = UnwindTable::create(this))
- RowsOrErr->dump(OS, MRI, IsEH, 1);
+ RowsOrErr->dump(OS, DumpOpts, 1);
else {
DumpOpts.RecoverableErrorHandler(joinErrors(
createStringError(errc::invalid_argument,
}
void DWARFDebugFrame::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
- const MCRegisterInfo *MRI,
std::optional<uint64_t> 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);
}
static void dumpExpression(raw_ostream &OS, DIDumpOptions DumpOpts,
ArrayRef<uint8_t> 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<SectionedAddress> 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<SectionedAddress> {
if (U)
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;
});
});
}
-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<uint64_t> 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;
OS << Separator;
Separator = "\n";
- CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, Obj, nullptr,
+ CanContinue = dumpLocationList(&Offset, OS, BaseAddr, Obj, nullptr,
DumpOpts, Indent);
OS << '\n';
}
}
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";
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';
}
}
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) {
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,
FormValue.isFormClass(DWARFFormValue::FC_Exprloc)) &&
"bad FORM for location expression");
DWARFContext &Ctx = U->getContext();
- const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
ArrayRef<uint8_t> 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) {
#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
-#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/Support/Format.h"
#include <cassert>
#include <cstdint>
}
}
-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;
else
DwarfRegNum = Opcode - DW_OP_reg0;
- if (std::optional<unsigned> 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;
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 << "<decoding error>";
return false;
(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) {
}
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 << "<empty>";
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));
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<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg =
+ nullptr) {
SmallVector<PrintedExpr, 4> Stack;
while (I != E) {
// 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<unsigned> LLVMRegNum =
- MRI.getLLVMRegNum(DwarfRegNum, false);
- if (!LLVMRegNum) {
- OS << "<unknown register " << DwarfRegNum << ">";
+ 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<unsigned> LLVMRegNum =
- MRI.getLLVMRegNum(DwarfRegNum, false);
- if (!LLVMRegNum) {
- OS << "<unknown register " << DwarfRegNum << ">";
+ 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;
++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;
// DW_OP_reg<N>: 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<unsigned> LLVMRegNum =
- MRI.getLLVMRegNum(DwarfRegNum, false);
- if (!LLVMRegNum) {
- OS << "<unknown register " << DwarfRegNum << ">";
+ 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<unsigned> LLVMRegNum =
- MRI.getLLVMRegNum(DwarfRegNum, false);
- if (!LLVMRegNum) {
- OS << "<unknown register " << DwarfRegNum << ">";
+ 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 {
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<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg) {
+ return printCompactDWARFExpr(OS, begin(), end(), GetNameForDWARFReg);
}
bool DWARFExpression::operator==(const DWARFExpression &RHS) const {
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<unsigned> 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();
}
#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"
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<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg) {
DIDumpOptions DumpOpts = getDumpOpts(Die.getDwarfUnit()->getContext());
+ DumpOpts.GetNameForDWARFReg = GetNameForDWARFReg;
std::string Name =
(IgnoreCase && !UseRegex) ? NameRef.lower() : NameRef.str();
if (UseRegex) {
}
/// 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<StringRef(uint64_t RegNum, bool IsEH)> 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);
}
}
}
/// Print only DIEs that have a certain name.
-static void filterByAccelName(ArrayRef<std::string> Names, DWARFContext &DICtx,
- raw_ostream &OS) {
+static void filterByAccelName(
+ ArrayRef<std::string> Names, DWARFContext &DICtx, raw_ostream &OS,
+ std::function<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg) {
SmallVector<DWARFDie, 4> Dies;
for (const auto &Name : Names) {
getDies(DICtx, DICtx.getAppleNames(), Name, Dies);
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);
}
return Result;
}
+static std::unique_ptr<MCRegisterInfo>
+createRegInfo(const object::ObjectFile &Obj) {
+ std::unique_ptr<MCRegisterInfo> 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<unsigned> 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';
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=<offset>.
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;
}
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.
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<unsigned> LLVMRegNum =
+ MRI.getLLVMRegNum(DwarfRegNum, IsEH))
+ if (const char *RegName = MRI.getName(*LLVMRegNum))
+ return StringRef(RegName);
+ OS << "<unknown register " << DwarfRegNum << ">";
+ return {};
+ };
+
+ Expression.printCompact(OS, GetRegName);
}
void LiveVariablePrinter::addVariable(DWARFDie FuncDie, DWARFDie VarDie) {
#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 <unordered_map>
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";
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);
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);
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<unsigned> LLVMRegNum =
+ this->MRI->getLLVMRegNum(DwarfRegNum, IsEH))
+ if (const char *RegName = this->MRI->getName(*LLVMRegNum))
+ return llvm::StringRef(RegName);
+ OS << "<unknown register " << DwarfRegNum << ">";
+ return {};
+ };
+
+ Expr.printCompact(OS, GetRegName);
EXPECT_EQ(OS.str(), Expected);
}
projects / platform / upstream / llvm.git / commitdiff