diff options
Diffstat (limited to 'contrib/llvm/tools/llvm-readobj')
18 files changed, 3019 insertions, 1467 deletions
diff --git a/contrib/llvm/tools/llvm-readobj/ARMAttributeParser.cpp b/contrib/llvm/tools/llvm-readobj/ARMAttributeParser.cpp index 688d349..877dd71 100644 --- a/contrib/llvm/tools/llvm-readobj/ARMAttributeParser.cpp +++ b/contrib/llvm/tools/llvm-readobj/ARMAttributeParser.cpp @@ -8,10 +8,10 @@ //===----------------------------------------------------------------------===// #include "ARMAttributeParser.h" -#include "StreamWriter.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Support/LEB128.h" +#include "llvm/Support/ScopedPrinter.h" using namespace llvm; using namespace llvm::ARMBuildAttrs; @@ -63,6 +63,7 @@ ARMAttributeParser::DisplayRoutines[] = { ATTRIBUTE_HANDLER(ABI_FP_16bit_format), ATTRIBUTE_HANDLER(MPextension_use), ATTRIBUTE_HANDLER(DIV_use), + ATTRIBUTE_HANDLER(DSP_extension), ATTRIBUTE_HANDLER(T2EE_use), ATTRIBUTE_HANDLER(Virtualization_use), ATTRIBUTE_HANDLER(nodefaults) @@ -340,7 +341,7 @@ void ARMAttributeParser::ABI_align_needed(AttrType Tag, const uint8_t *Data, if (Value < array_lengthof(Strings)) Description = std::string(Strings[Value]); else if (Value <= 12) - Description = std::string("8-byte alignment, ") + utostr(1 << Value) + Description = std::string("8-byte alignment, ") + utostr(1ULL << Value) + std::string("-byte extended alignment"); else Description = "Invalid"; @@ -361,8 +362,8 @@ void ARMAttributeParser::ABI_align_preserved(AttrType Tag, const uint8_t *Data, if (Value < array_lengthof(Strings)) Description = std::string(Strings[Value]); else if (Value <= 12) - Description = std::string("8-byte stack alignment, ") + utostr(1 << Value) - + std::string("-byte data alignment"); + Description = std::string("8-byte stack alignment, ") + + utostr(1ULL << Value) + std::string("-byte data alignment"); else Description = "Invalid"; @@ -517,6 +518,16 @@ void ARMAttributeParser::DIV_use(AttrType Tag, const uint8_t *Data, PrintAttribute(Tag, Value, ValueDesc); } +void ARMAttributeParser::DSP_extension(AttrType Tag, const uint8_t *Data, + uint32_t &Offset) { + static const char *const Strings[] = { "Not Permitted", "Permitted" }; + + uint64_t Value = ParseInteger(Data, Offset); + StringRef ValueDesc = + (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr; + PrintAttribute(Tag, Value, ValueDesc); +} + void ARMAttributeParser::T2EE_use(AttrType Tag, const uint8_t *Data, uint32_t &Offset) { static const char *const Strings[] = { "Not Permitted", "Permitted" }; diff --git a/contrib/llvm/tools/llvm-readobj/ARMAttributeParser.h b/contrib/llvm/tools/llvm-readobj/ARMAttributeParser.h index f924c83..6936b70 100644 --- a/contrib/llvm/tools/llvm-readobj/ARMAttributeParser.h +++ b/contrib/llvm/tools/llvm-readobj/ARMAttributeParser.h @@ -10,14 +10,14 @@ #ifndef LLVM_TOOLS_LLVM_READOBJ_ARMATTRIBUTEPARSER_H #define LLVM_TOOLS_LLVM_READOBJ_ARMATTRIBUTEPARSER_H -#include "StreamWriter.h" #include "llvm/Support/ARMBuildAttributes.h" +#include "llvm/Support/ScopedPrinter.h" namespace llvm { class StringRef; class ARMAttributeParser { - StreamWriter &SW; + ScopedPrinter &SW; struct DisplayHandler { ARMBuildAttrs::AttrType Attribute; @@ -100,6 +100,8 @@ class ARMAttributeParser { uint32_t &Offset); void DIV_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data, uint32_t &Offset); + void DSP_extension(ARMBuildAttrs::AttrType Tag, const uint8_t *Data, + uint32_t &Offset); void T2EE_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data, uint32_t &Offset); void Virtualization_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data, @@ -113,7 +115,7 @@ class ARMAttributeParser { SmallVectorImpl<uint8_t> &IndexList); void ParseSubsection(const uint8_t *Data, uint32_t Length); public: - ARMAttributeParser(StreamWriter &SW) : SW(SW) {} + ARMAttributeParser(ScopedPrinter &SW) : SW(SW) {} void Parse(ArrayRef<uint8_t> Section); }; diff --git a/contrib/llvm/tools/llvm-readobj/ARMEHABIPrinter.h b/contrib/llvm/tools/llvm-readobj/ARMEHABIPrinter.h index beb5fd4..59c9b71 100644 --- a/contrib/llvm/tools/llvm-readobj/ARMEHABIPrinter.h +++ b/contrib/llvm/tools/llvm-readobj/ARMEHABIPrinter.h @@ -11,7 +11,7 @@ #define LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H #include "Error.h" -#include "StreamWriter.h" +#include "llvm-readobj.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Object/ELF.h" #include "llvm/Object/ELFTypes.h" @@ -19,6 +19,7 @@ #include "llvm/Support/Debug.h" #include "llvm/Support/Endian.h" #include "llvm/Support/Format.h" +#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/type_traits.h" namespace llvm { @@ -26,7 +27,7 @@ namespace ARM { namespace EHABI { class OpcodeDecoder { - StreamWriter &SW; + ScopedPrinter &SW; raw_ostream &OS; struct RingEntry { @@ -63,7 +64,7 @@ class OpcodeDecoder { void PrintRegisters(uint32_t Mask, StringRef Prefix); public: - OpcodeDecoder(StreamWriter &SW) : SW(SW), OS(SW.getOStream()) {} + OpcodeDecoder(ScopedPrinter &SW) : SW(SW), OS(SW.getOStream()) {} void Decode(const uint8_t *Opcodes, off_t Offset, size_t Length); }; @@ -310,7 +311,7 @@ class PrinterContext { typedef typename object::ELFFile<ET>::Elf_Rel Elf_Rel; typedef typename object::ELFFile<ET>::Elf_Word Elf_Word; - StreamWriter &SW; + ScopedPrinter &SW; const object::ELFFile<ET> *ELF; const Elf_Shdr *Symtab; ArrayRef<Elf_Word> ShndxTable; @@ -334,7 +335,7 @@ class PrinterContext { void PrintOpcodes(const uint8_t *Entry, size_t Length, off_t Offset) const; public: - PrinterContext(StreamWriter &SW, const object::ELFFile<ET> *ELF, + PrinterContext(ScopedPrinter &SW, const object::ELFFile<ET> *ELF, const Elf_Shdr *Symtab) : SW(SW), ELF(ELF), Symtab(Symtab) {} @@ -354,8 +355,15 @@ PrinterContext<ET>::FunctionAtAddress(unsigned Section, for (const Elf_Sym &Sym : ELF->symbols(Symtab)) if (Sym.st_shndx == Section && Sym.st_value == Address && - Sym.getType() == ELF::STT_FUNC) - return Sym.getName(StrTable); + Sym.getType() == ELF::STT_FUNC) { + auto NameOrErr = Sym.getName(StrTable); + if (!NameOrErr) { + // TODO: Actually report errors helpfully. + consumeError(NameOrErr.takeError()); + return readobj_error::unknown_symbol; + } + return *NameOrErr; + } return readobj_error::unknown_symbol; } diff --git a/contrib/llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp b/contrib/llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp index 650955d..1a033b1 100644 --- a/contrib/llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp +++ b/contrib/llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp @@ -198,12 +198,15 @@ Decoder::getSectionContaining(const COFFObjectFile &COFF, uint64_t VA) { ErrorOr<object::SymbolRef> Decoder::getSymbol(const COFFObjectFile &COFF, uint64_t VA, bool FunctionOnly) { for (const auto &Symbol : COFF.symbols()) { - if (FunctionOnly && Symbol.getType() != SymbolRef::ST_Function) + Expected<SymbolRef::Type> Type = Symbol.getType(); + if (!Type) + return errorToErrorCode(Type.takeError()); + if (FunctionOnly && *Type != SymbolRef::ST_Function) continue; - ErrorOr<uint64_t> Address = Symbol.getAddress(); - if (std::error_code EC = Address.getError()) - return EC; + Expected<uint64_t> Address = Symbol.getAddress(); + if (!Address) + return errorToErrorCode(Address.takeError()); if (*Address == VA) return Symbol; } @@ -247,7 +250,7 @@ bool Decoder::opcode_10Lxxxxx(const uint8_t *OC, unsigned &Offset, printRegisters(std::make_pair(RegisterMask, 0)); OS << '\n'; - ++Offset, ++Offset; + Offset += 2; return false; } @@ -320,7 +323,7 @@ bool Decoder::opcode_111010xx(const uint8_t *OC, unsigned &Offset, static_cast<const char *>(Prologue ? "sub" : "add"), Imm); - ++Offset, ++Offset; + Offset += 2; return false; } @@ -334,7 +337,7 @@ bool Decoder::opcode_1110110L(const uint8_t *OC, unsigned &Offset, printRegisters(std::make_pair(GPRMask, 0)); OS << '\n'; - ++Offset, ++Offset; + Offset += 2; return false; } @@ -350,7 +353,7 @@ bool Decoder::opcode_11101110(const uint8_t *OC, unsigned &Offset, << format("0x%02x 0x%02x ; microsoft-specific (type: %u)\n", OC[Offset + 0], OC[Offset + 1], OC[Offset + 1] & 0x0f); - ++Offset, ++Offset; + Offset += 2; return false; } @@ -366,7 +369,7 @@ bool Decoder::opcode_11101111(const uint8_t *OC, unsigned &Offset, << format("0x%02x 0x%02x ; ldr.w lr, [sp], #%u\n", OC[Offset + 0], OC[Offset + 1], OC[Offset + 1] << 2); - ++Offset, ++Offset; + Offset += 2; return false; } @@ -381,7 +384,7 @@ bool Decoder::opcode_11110101(const uint8_t *OC, unsigned &Offset, printRegisters(std::make_pair(0, VFPMask)); OS << '\n'; - ++Offset, ++Offset; + Offset += 2; return false; } @@ -396,7 +399,7 @@ bool Decoder::opcode_11110110(const uint8_t *OC, unsigned &Offset, printRegisters(std::make_pair(0, VFPMask)); OS << '\n'; - ++Offset, ++Offset; + Offset += 2; return false; } @@ -409,7 +412,7 @@ bool Decoder::opcode_11110111(const uint8_t *OC, unsigned &Offset, static_cast<const char *>(Prologue ? "sub" : "add"), Imm); - ++Offset, ++Offset, ++Offset; + Offset += 3; return false; } @@ -424,7 +427,7 @@ bool Decoder::opcode_11111000(const uint8_t *OC, unsigned &Offset, OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], OC[Offset + 3], static_cast<const char *>(Prologue ? "sub" : "add"), Imm); - ++Offset, ++Offset, ++Offset, ++Offset; + Offset += 4; return false; } @@ -437,7 +440,7 @@ bool Decoder::opcode_11111001(const uint8_t *OC, unsigned &Offset, OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], static_cast<const char *>(Prologue ? "sub" : "add"), Imm); - ++Offset, ++Offset, ++Offset; + Offset += 3; return false; } @@ -452,7 +455,7 @@ bool Decoder::opcode_11111010(const uint8_t *OC, unsigned &Offset, OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], OC[Offset + 3], static_cast<const char *>(Prologue ? "sub" : "add"), Imm); - ++Offset, ++Offset, ++Offset, ++Offset; + Offset += 4; return false; } @@ -567,9 +570,14 @@ bool Decoder::dumpXDataRecord(const COFFObjectFile &COFF, if (!Symbol) Symbol = getSymbol(COFF, Address, /*FunctionOnly=*/true); - ErrorOr<StringRef> Name = Symbol->getName(); - if (std::error_code EC = Name.getError()) - report_fatal_error(EC.message()); + Expected<StringRef> Name = Symbol->getName(); + if (!Name) { + std::string Buf; + llvm::raw_string_ostream OS(Buf); + logAllUnhandledErrors(Name.takeError(), OS, ""); + OS.flush(); + report_fatal_error(Buf); + } ListScope EHS(SW, "ExceptionHandler"); SW.printString("Routine", formatSymbol(*Name, Address)); @@ -601,13 +609,23 @@ bool Decoder::dumpUnpackedEntry(const COFFObjectFile &COFF, StringRef FunctionName; uint64_t FunctionAddress; if (Function) { - ErrorOr<StringRef> FunctionNameOrErr = Function->getName(); - if (std::error_code EC = FunctionNameOrErr.getError()) - report_fatal_error(EC.message()); + Expected<StringRef> FunctionNameOrErr = Function->getName(); + if (!FunctionNameOrErr) { + std::string Buf; + llvm::raw_string_ostream OS(Buf); + logAllUnhandledErrors(FunctionNameOrErr.takeError(), OS, ""); + OS.flush(); + report_fatal_error(Buf); + } FunctionName = *FunctionNameOrErr; - ErrorOr<uint64_t> FunctionAddressOrErr = Function->getAddress(); - if (std::error_code EC = FunctionAddressOrErr.getError()) - report_fatal_error(EC.message()); + Expected<uint64_t> FunctionAddressOrErr = Function->getAddress(); + if (!FunctionAddressOrErr) { + std::string Buf; + llvm::raw_string_ostream OS(Buf); + logAllUnhandledErrors(FunctionAddressOrErr.takeError(), OS, ""); + OS.flush(); + report_fatal_error(Buf); + } FunctionAddress = *FunctionAddressOrErr; } else { const pe32_header *PEHeader; @@ -619,20 +637,33 @@ bool Decoder::dumpUnpackedEntry(const COFFObjectFile &COFF, SW.printString("Function", formatSymbol(FunctionName, FunctionAddress)); if (XDataRecord) { - ErrorOr<StringRef> Name = XDataRecord->getName(); - if (std::error_code EC = Name.getError()) - report_fatal_error(EC.message()); + Expected<StringRef> Name = XDataRecord->getName(); + if (!Name) { + std::string Buf; + llvm::raw_string_ostream OS(Buf); + logAllUnhandledErrors(Name.takeError(), OS, ""); + OS.flush(); + report_fatal_error(Buf); + } - ErrorOr<uint64_t> AddressOrErr = XDataRecord->getAddress(); - if (std::error_code EC = AddressOrErr.getError()) - report_fatal_error(EC.message()); + Expected<uint64_t> AddressOrErr = XDataRecord->getAddress(); + if (!AddressOrErr) { + std::string Buf; + llvm::raw_string_ostream OS(Buf); + logAllUnhandledErrors(AddressOrErr.takeError(), OS, ""); + OS.flush(); + report_fatal_error(Buf); + } uint64_t Address = *AddressOrErr; SW.printString("ExceptionRecord", formatSymbol(*Name, Address)); - ErrorOr<section_iterator> SIOrErr = XDataRecord->getSection(); - if (!SIOrErr) + Expected<section_iterator> SIOrErr = XDataRecord->getSection(); + if (!SIOrErr) { + // TODO: Actually report errors helpfully. + consumeError(SIOrErr.takeError()); return false; + } section_iterator SI = *SIOrErr; return dumpXDataRecord(COFF, *SI, FunctionAddress, Address); @@ -668,11 +699,23 @@ bool Decoder::dumpPackedEntry(const object::COFFObjectFile &COFF, StringRef FunctionName; uint64_t FunctionAddress; if (Function) { - ErrorOr<StringRef> FunctionNameOrErr = Function->getName(); - if (std::error_code EC = FunctionNameOrErr.getError()) - report_fatal_error(EC.message()); + Expected<StringRef> FunctionNameOrErr = Function->getName(); + if (!FunctionNameOrErr) { + std::string Buf; + llvm::raw_string_ostream OS(Buf); + logAllUnhandledErrors(FunctionNameOrErr.takeError(), OS, ""); + OS.flush(); + report_fatal_error(Buf); + } FunctionName = *FunctionNameOrErr; - ErrorOr<uint64_t> FunctionAddressOrErr = Function->getAddress(); + Expected<uint64_t> FunctionAddressOrErr = Function->getAddress(); + if (!FunctionAddressOrErr) { + std::string Buf; + llvm::raw_string_ostream OS(Buf); + logAllUnhandledErrors(FunctionAddressOrErr.takeError(), OS, ""); + OS.flush(); + report_fatal_error(Buf); + } FunctionAddress = *FunctionAddressOrErr; } else { const pe32_header *PEHeader; diff --git a/contrib/llvm/tools/llvm-readobj/ARMWinEHPrinter.h b/contrib/llvm/tools/llvm-readobj/ARMWinEHPrinter.h index 274ef11..95f5217 100644 --- a/contrib/llvm/tools/llvm-readobj/ARMWinEHPrinter.h +++ b/contrib/llvm/tools/llvm-readobj/ARMWinEHPrinter.h @@ -10,9 +10,9 @@ #ifndef LLVM_TOOLS_LLVM_READOBJ_ARMWINEHPRINTER_H #define LLVM_TOOLS_LLVM_READOBJ_ARMWINEHPRINTER_H -#include "StreamWriter.h" #include "llvm/Object/COFF.h" #include "llvm/Support/ErrorOr.h" +#include "llvm/Support/ScopedPrinter.h" namespace llvm { namespace ARM { @@ -22,7 +22,7 @@ class RuntimeFunction; class Decoder { static const size_t PDataEntrySize; - StreamWriter &SW; + ScopedPrinter &SW; raw_ostream &OS; struct RingEntry { @@ -107,7 +107,7 @@ class Decoder { const object::SectionRef Section); public: - Decoder(StreamWriter &SW) : SW(SW), OS(SW.getOStream()) {} + Decoder(ScopedPrinter &SW) : SW(SW), OS(SW.getOStream()) {} std::error_code dumpProcedureData(const object::COFFObjectFile &COFF); }; } diff --git a/contrib/llvm/tools/llvm-readobj/COFFDumper.cpp b/contrib/llvm/tools/llvm-readobj/COFFDumper.cpp index d44da0d..348f5b4 100644 --- a/contrib/llvm/tools/llvm-readobj/COFFDumper.cpp +++ b/contrib/llvm/tools/llvm-readobj/COFFDumper.cpp @@ -12,16 +12,28 @@ /// //===----------------------------------------------------------------------===// -#include "llvm-readobj.h" #include "ARMWinEHPrinter.h" +#include "CodeView.h" #include "Error.h" #include "ObjDumper.h" #include "StackMapPrinter.h" -#include "StreamWriter.h" #include "Win64EHDumper.h" +#include "llvm-readobj.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" +#include "llvm/DebugInfo/CodeView/ByteStream.h" +#include "llvm/DebugInfo/CodeView/CodeView.h" +#include "llvm/DebugInfo/CodeView/Line.h" +#include "llvm/DebugInfo/CodeView/MemoryTypeTableBuilder.h" +#include "llvm/DebugInfo/CodeView/RecordSerialization.h" +#include "llvm/DebugInfo/CodeView/SymbolDumpDelegate.h" +#include "llvm/DebugInfo/CodeView/SymbolDumper.h" +#include "llvm/DebugInfo/CodeView/SymbolRecord.h" +#include "llvm/DebugInfo/CodeView/TypeDumper.h" +#include "llvm/DebugInfo/CodeView/TypeIndex.h" +#include "llvm/DebugInfo/CodeView/TypeRecord.h" +#include "llvm/DebugInfo/CodeView/TypeStreamMerger.h" #include "llvm/Object/COFF.h" #include "llvm/Object/ObjectFile.h" #include "llvm/Support/COFF.h" @@ -29,6 +41,7 @@ #include "llvm/Support/Compiler.h" #include "llvm/Support/DataExtractor.h" #include "llvm/Support/Format.h" +#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/SourceMgr.h" #include "llvm/Support/Win64EH.h" #include "llvm/Support/raw_ostream.h" @@ -39,16 +52,18 @@ using namespace llvm; using namespace llvm::object; +using namespace llvm::codeview; +using namespace llvm::support; using namespace llvm::Win64EH; namespace { class COFFDumper : public ObjDumper { public: - COFFDumper(const llvm::object::COFFObjectFile *Obj, StreamWriter& Writer) - : ObjDumper(Writer) - , Obj(Obj) { - } + friend class COFFObjectDumpDelegate; + COFFDumper(const llvm::object::COFFObjectFile *Obj, ScopedPrinter &Writer) + : ObjDumper(Writer), Obj(Obj), + CVTD(&Writer, opts::CodeViewSubsectionBytes) {} void printFileHeaders() override; void printSections() override; @@ -60,11 +75,15 @@ public: void printCOFFExports() override; void printCOFFDirectives() override; void printCOFFBaseReloc() override; + void printCOFFDebugDirectory() override; void printCodeViewDebugInfo() override; + void + mergeCodeViewTypes(llvm::codeview::MemoryTypeTableBuilder &CVTypes) override; void printStackMap() const override; private: void printSymbol(const SymbolRef &Sym); - void printRelocation(const SectionRef &Section, const RelocationRef &Reloc); + void printRelocation(const SectionRef &Section, const RelocationRef &Reloc, + uint64_t Bias = 0); void printDataDirectory(uint32_t Index, const std::string &FieldName); void printDOSHeader(const dos_header *DH); @@ -72,11 +91,33 @@ private: void printBaseOfDataField(const pe32_header *Hdr); void printBaseOfDataField(const pe32plus_header *Hdr); - void printCodeViewSection(const SectionRef &Section); + void printCodeViewSymbolSection(StringRef SectionName, const SectionRef &Section); + void printCodeViewTypeSection(StringRef SectionName, const SectionRef &Section); + StringRef getTypeName(TypeIndex Ty); + StringRef getFileNameForFileOffset(uint32_t FileOffset); + void printFileNameForOffset(StringRef Label, uint32_t FileOffset); + void printTypeIndex(StringRef FieldName, TypeIndex TI) { + // Forward to CVTypeDumper for simplicity. + CVTD.printTypeIndex(FieldName, TI); + } void printCodeViewSymbolsSubsection(StringRef Subsection, const SectionRef &Section, - uint32_t Offset); + StringRef SectionContents); + + void printCodeViewFileChecksums(StringRef Subsection); + + void printCodeViewInlineeLines(StringRef Subsection); + + void printRelocatedField(StringRef Label, const coff_section *Sec, + uint32_t RelocOffset, uint32_t Offset, + StringRef *RelocSym = nullptr); + + void printBinaryBlockWithRelocs(StringRef Label, const SectionRef &Sec, + StringRef SectionContents, StringRef Block); + + /// Given a .debug$S section, find the string table and file checksum table. + void initializeFileAndStringTables(StringRef Data); void cacheRelocations(); @@ -84,6 +125,9 @@ private: SymbolRef &Sym); std::error_code resolveSymbolName(const coff_section *Section, uint64_t Offset, StringRef &Name); + std::error_code resolveSymbolName(const coff_section *Section, + StringRef SectionContents, + const void *RelocPtr, StringRef &Name); void printImportedSymbols(iterator_range<imported_symbol_iterator> Range); void printDelayImportedSymbols( const DelayImportDirectoryEntryRef &I, @@ -94,17 +138,56 @@ private: const llvm::object::COFFObjectFile *Obj; bool RelocCached = false; RelocMapTy RelocMap; - StringRef CVFileIndexToStringOffsetTable; + StringRef CVFileChecksumTable; StringRef CVStringTable; + + CVTypeDumper CVTD; }; -} // namespace +class COFFObjectDumpDelegate : public SymbolDumpDelegate { +public: + COFFObjectDumpDelegate(COFFDumper &CD, const SectionRef &SR, + const COFFObjectFile *Obj, StringRef SectionContents) + : CD(CD), SR(SR), SectionContents(SectionContents) { + Sec = Obj->getCOFFSection(SR); + } + + uint32_t getRecordOffset(ArrayRef<uint8_t> Record) override { + return Record.data() - SectionContents.bytes_begin(); + } + + void printRelocatedField(StringRef Label, uint32_t RelocOffset, + uint32_t Offset, StringRef *RelocSym) override { + CD.printRelocatedField(Label, Sec, RelocOffset, Offset, RelocSym); + } + + void printBinaryBlockWithRelocs(StringRef Label, + ArrayRef<uint8_t> Block) override { + StringRef SBlock(reinterpret_cast<const char *>(Block.data()), + Block.size()); + if (opts::CodeViewSubsectionBytes) + CD.printBinaryBlockWithRelocs(Label, SR, SectionContents, SBlock); + } + + StringRef getFileNameForFileOffset(uint32_t FileOffset) override { + return CD.getFileNameForFileOffset(FileOffset); + } + + StringRef getStringTable() override { return CD.CVStringTable; } + +private: + COFFDumper &CD; + const SectionRef &SR; + const coff_section *Sec; + StringRef SectionContents; +}; +} // end namespace namespace llvm { std::error_code createCOFFDumper(const object::ObjectFile *Obj, - StreamWriter &Writer, + ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result) { const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(Obj); if (!COFFObj) @@ -122,15 +205,19 @@ std::error_code COFFDumper::resolveSymbol(const coff_section *Section, uint64_t Offset, SymbolRef &Sym) { cacheRelocations(); const auto &Relocations = RelocMap[Section]; + auto SymI = Obj->symbol_end(); for (const auto &Relocation : Relocations) { uint64_t RelocationOffset = Relocation.getOffset(); if (RelocationOffset == Offset) { - Sym = *Relocation.getSymbol(); - return readobj_error::success; + SymI = Relocation.getSymbol(); + break; } } - return readobj_error::unknown_symbol; + if (SymI == Obj->symbol_end()) + return readobj_error::unknown_symbol; + Sym = *SymI; + return readobj_error::success; } // Given a section and an offset into this section the function returns the name @@ -141,13 +228,62 @@ std::error_code COFFDumper::resolveSymbolName(const coff_section *Section, SymbolRef Symbol; if (std::error_code EC = resolveSymbol(Section, Offset, Symbol)) return EC; - ErrorOr<StringRef> NameOrErr = Symbol.getName(); - if (std::error_code EC = NameOrErr.getError()) - return EC; + Expected<StringRef> NameOrErr = Symbol.getName(); + if (!NameOrErr) + return errorToErrorCode(NameOrErr.takeError()); Name = *NameOrErr; return std::error_code(); } +// Helper for when you have a pointer to real data and you want to know about +// relocations against it. +std::error_code COFFDumper::resolveSymbolName(const coff_section *Section, + StringRef SectionContents, + const void *RelocPtr, + StringRef &Name) { + assert(SectionContents.data() < RelocPtr && + RelocPtr < SectionContents.data() + SectionContents.size() && + "pointer to relocated object is not in section"); + uint64_t Offset = ptrdiff_t(reinterpret_cast<const char *>(RelocPtr) - + SectionContents.data()); + return resolveSymbolName(Section, Offset, Name); +} + +void COFFDumper::printRelocatedField(StringRef Label, const coff_section *Sec, + uint32_t RelocOffset, uint32_t Offset, + StringRef *RelocSym) { + StringRef SymStorage; + StringRef &Symbol = RelocSym ? *RelocSym : SymStorage; + if (!resolveSymbolName(Sec, RelocOffset, Symbol)) + W.printSymbolOffset(Label, Symbol, Offset); + else + W.printHex(Label, RelocOffset); +} + +void COFFDumper::printBinaryBlockWithRelocs(StringRef Label, + const SectionRef &Sec, + StringRef SectionContents, + StringRef Block) { + W.printBinaryBlock(Label, Block); + + assert(SectionContents.begin() < Block.begin() && + SectionContents.end() >= Block.end() && + "Block is not contained in SectionContents"); + uint64_t OffsetStart = Block.data() - SectionContents.data(); + uint64_t OffsetEnd = OffsetStart + Block.size(); + + W.flush(); + cacheRelocations(); + ListScope D(W, "BlockRelocations"); + const coff_section *Section = Obj->getCOFFSection(Sec); + const auto &Relocations = RelocMap[Section]; + for (const auto &Relocation : Relocations) { + uint64_t RelocationOffset = Relocation.getOffset(); + if (OffsetStart <= RelocationOffset && RelocationOffset < OffsetEnd) + printRelocation(Sec, Relocation, OffsetStart); + } +} + static const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = { LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_UNKNOWN ), LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AM33 ), @@ -324,6 +460,26 @@ static const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = { { "Newest" , COFF::IMAGE_COMDAT_SELECT_NEWEST } }; +static const EnumEntry<COFF::DebugType> ImageDebugType[] = { + { "Unknown" , COFF::IMAGE_DEBUG_TYPE_UNKNOWN }, + { "COFF" , COFF::IMAGE_DEBUG_TYPE_COFF }, + { "CodeView" , COFF::IMAGE_DEBUG_TYPE_CODEVIEW }, + { "FPO" , COFF::IMAGE_DEBUG_TYPE_FPO }, + { "Misc" , COFF::IMAGE_DEBUG_TYPE_MISC }, + { "Exception" , COFF::IMAGE_DEBUG_TYPE_EXCEPTION }, + { "Fixup" , COFF::IMAGE_DEBUG_TYPE_FIXUP }, + { "OmapToSrc" , COFF::IMAGE_DEBUG_TYPE_OMAP_TO_SRC }, + { "OmapFromSrc", COFF::IMAGE_DEBUG_TYPE_OMAP_FROM_SRC }, + { "Borland" , COFF::IMAGE_DEBUG_TYPE_BORLAND }, + { "Reserved10" , COFF::IMAGE_DEBUG_TYPE_RESERVED10 }, + { "CLSID" , COFF::IMAGE_DEBUG_TYPE_CLSID }, + { "VCFeature" , COFF::IMAGE_DEBUG_TYPE_VC_FEATURE }, + { "POGO" , COFF::IMAGE_DEBUG_TYPE_POGO }, + { "ILTCG" , COFF::IMAGE_DEBUG_TYPE_ILTCG }, + { "MPX" , COFF::IMAGE_DEBUG_TYPE_MPX }, + { "Repro" , COFF::IMAGE_DEBUG_TYPE_REPRO }, +}; + static const EnumEntry<COFF::WeakExternalCharacteristics> WeakExternalCharacteristics[] = { { "NoLibrary", COFF::IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY }, @@ -331,6 +487,35 @@ WeakExternalCharacteristics[] = { { "Alias" , COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS } }; +static const EnumEntry<uint32_t> SubSectionTypes[] = { + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Symbols), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Lines), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, StringTable), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FileChecksums), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FrameData), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, InlineeLines), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CrossScopeImports), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CrossScopeExports), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, ILLines), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FuncMDTokenMap), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, TypeMDTokenMap), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, MergedAssemblyInput), + LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CoffSymbolRVA), +}; + +static const EnumEntry<uint32_t> FrameDataFlags[] = { + LLVM_READOBJ_ENUM_ENT(FrameData, HasSEH), + LLVM_READOBJ_ENUM_ENT(FrameData, HasEH), + LLVM_READOBJ_ENUM_ENT(FrameData, IsFunctionStart), +}; + +static const EnumEntry<uint8_t> FileChecksumKindNames[] = { + LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, None), + LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, MD5), + LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA1), + LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA256), +}; + template <typename T> static std::error_code getSymbolAuxData(const COFFObjectFile *Obj, COFFSymbolRef Symbol, @@ -463,8 +648,42 @@ void COFFDumper::printPEHeader(const PEHeader *Hdr) { "DelayImportDescriptor", "CLRRuntimeHeader", "Reserved" }; - for (uint32_t i = 0; i < Hdr->NumberOfRvaAndSize; ++i) { + for (uint32_t i = 0; i < Hdr->NumberOfRvaAndSize; ++i) printDataDirectory(i, directory[i]); + } +} + +void COFFDumper::printCOFFDebugDirectory() { + ListScope LS(W, "DebugDirectory"); + for (const debug_directory &D : Obj->debug_directories()) { + char FormattedTime[20] = {}; + time_t TDS = D.TimeDateStamp; + strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS)); + DictScope S(W, "DebugEntry"); + W.printHex("Characteristics", D.Characteristics); + W.printHex("TimeDateStamp", FormattedTime, D.TimeDateStamp); + W.printHex("MajorVersion", D.MajorVersion); + W.printHex("MinorVersion", D.MinorVersion); + W.printEnum("Type", D.Type, makeArrayRef(ImageDebugType)); + W.printHex("SizeOfData", D.SizeOfData); + W.printHex("AddressOfRawData", D.AddressOfRawData); + W.printHex("PointerToRawData", D.PointerToRawData); + if (D.Type == COFF::IMAGE_DEBUG_TYPE_CODEVIEW) { + const debug_pdb_info *PDBInfo; + StringRef PDBFileName; + error(Obj->getDebugPDBInfo(&D, PDBInfo, PDBFileName)); + DictScope PDBScope(W, "PDBInfo"); + W.printHex("PDBSignature", PDBInfo->Signature); + W.printBinary("PDBGUID", makeArrayRef(PDBInfo->Guid)); + W.printNumber("PDBAge", PDBInfo->Age); + W.printString("PDBFileName", PDBFileName); + } else { + // FIXME: Type values of 12 and 13 are commonly observed but are not in + // the documented type enum. Figure out what they mean. + ArrayRef<uint8_t> RawData; + error( + Obj->getRvaAndSizeAsBytes(D.AddressOfRawData, D.SizeOfData, RawData)); + W.printBinaryBlock("RawData", RawData); } } } @@ -476,111 +695,180 @@ void COFFDumper::printBaseOfDataField(const pe32_header *Hdr) { void COFFDumper::printBaseOfDataField(const pe32plus_header *) {} void COFFDumper::printCodeViewDebugInfo() { + // Print types first to build CVUDTNames, then print symbols. + for (const SectionRef &S : Obj->sections()) { + StringRef SectionName; + error(S.getName(SectionName)); + if (SectionName == ".debug$T") + printCodeViewTypeSection(SectionName, S); + } for (const SectionRef &S : Obj->sections()) { - StringRef SecName; - error(S.getName(SecName)); - if (SecName == ".debug$S") - printCodeViewSection(S); + StringRef SectionName; + error(S.getName(SectionName)); + if (SectionName == ".debug$S") + printCodeViewSymbolSection(SectionName, S); } } -void COFFDumper::printCodeViewSection(const SectionRef &Section) { - StringRef Data; - error(Section.getContents(Data)); +void COFFDumper::initializeFileAndStringTables(StringRef Data) { + while (!Data.empty() && (CVFileChecksumTable.data() == nullptr || + CVStringTable.data() == nullptr)) { + // The section consists of a number of subsection in the following format: + // |SubSectionType|SubSectionSize|Contents...| + uint32_t SubType, SubSectionSize; + error(consume(Data, SubType)); + error(consume(Data, SubSectionSize)); + if (SubSectionSize > Data.size()) + return error(object_error::parse_failed); + switch (ModuleSubstreamKind(SubType)) { + case ModuleSubstreamKind::FileChecksums: + CVFileChecksumTable = Data.substr(0, SubSectionSize); + break; + case ModuleSubstreamKind::StringTable: + CVStringTable = Data.substr(0, SubSectionSize); + break; + default: + break; + } + uint32_t PaddedSize = alignTo(SubSectionSize, 4); + if (PaddedSize > Data.size()) + error(object_error::parse_failed); + Data = Data.drop_front(PaddedSize); + } +} + +void COFFDumper::printCodeViewSymbolSection(StringRef SectionName, + const SectionRef &Section) { + StringRef SectionContents; + error(Section.getContents(SectionContents)); + StringRef Data = SectionContents; SmallVector<StringRef, 10> FunctionNames; StringMap<StringRef> FunctionLineTables; ListScope D(W, "CodeViewDebugInfo"); - { - // FIXME: Add more offset correctness checks. - DataExtractor DE(Data, true, 4); - uint32_t Offset = 0, - Magic = DE.getU32(&Offset); - W.printHex("Magic", Magic); - if (Magic != COFF::DEBUG_SECTION_MAGIC) { - error(object_error::parse_failed); - return; - } + // Print the section to allow correlation with printSections. + W.printNumber("Section", SectionName, Obj->getSectionID(Section)); + + uint32_t Magic; + error(consume(Data, Magic)); + W.printHex("Magic", Magic); + if (Magic != COFF::DEBUG_SECTION_MAGIC) + return error(object_error::parse_failed); + + initializeFileAndStringTables(Data); + + // TODO: Convert this over to using ModuleSubstreamVisitor. + while (!Data.empty()) { + // The section consists of a number of subsection in the following format: + // |SubSectionType|SubSectionSize|Contents...| + uint32_t SubType, SubSectionSize; + error(consume(Data, SubType)); + error(consume(Data, SubSectionSize)); + + ListScope S(W, "Subsection"); + W.printEnum("SubSectionType", SubType, makeArrayRef(SubSectionTypes)); + W.printHex("SubSectionSize", SubSectionSize); + + // Get the contents of the subsection. + if (SubSectionSize > Data.size()) + return error(object_error::parse_failed); + StringRef Contents = Data.substr(0, SubSectionSize); + + // Add SubSectionSize to the current offset and align that offset to find + // the next subsection. + size_t SectionOffset = Data.data() - SectionContents.data(); + size_t NextOffset = SectionOffset + SubSectionSize; + NextOffset = alignTo(NextOffset, 4); + if (NextOffset > SectionContents.size()) + return error(object_error::parse_failed); + Data = SectionContents.drop_front(NextOffset); + + // Optionally print the subsection bytes in case our parsing gets confused + // later. + if (opts::CodeViewSubsectionBytes) + printBinaryBlockWithRelocs("SubSectionContents", Section, SectionContents, + Contents); + + switch (ModuleSubstreamKind(SubType)) { + case ModuleSubstreamKind::Symbols: + printCodeViewSymbolsSubsection(Contents, Section, SectionContents); + break; + + case ModuleSubstreamKind::InlineeLines: + printCodeViewInlineeLines(Contents); + break; + + case ModuleSubstreamKind::FileChecksums: + printCodeViewFileChecksums(Contents); + break; - bool Finished = false; - while (DE.isValidOffset(Offset) && !Finished) { - // The section consists of a number of subsection in the following format: - // |Type|PayloadSize|Payload...| - uint32_t SubSectionType = DE.getU32(&Offset), - PayloadSize = DE.getU32(&Offset); - ListScope S(W, "Subsection"); - W.printHex("Type", SubSectionType); - W.printHex("PayloadSize", PayloadSize); - if (PayloadSize > Data.size() - Offset) { + case ModuleSubstreamKind::Lines: { + // Holds a PC to file:line table. Some data to parse this subsection is + // stored in the other subsections, so just check sanity and store the + // pointers for deferred processing. + + if (SubSectionSize < 12) { + // There should be at least three words to store two function + // relocations and size of the code. error(object_error::parse_failed); return; } - StringRef Contents = Data.substr(Offset, PayloadSize); - if (opts::CodeViewSubsectionBytes) { - // Print the raw contents to simplify debugging if anything goes wrong - // afterwards. - W.printBinaryBlock("Contents", Contents); + StringRef LinkageName; + error(resolveSymbolName(Obj->getCOFFSection(Section), SectionOffset, + LinkageName)); + W.printString("LinkageName", LinkageName); + if (FunctionLineTables.count(LinkageName) != 0) { + // Saw debug info for this function already? + error(object_error::parse_failed); + return; } - switch (SubSectionType) { - case COFF::DEBUG_SYMBOL_SUBSECTION: - printCodeViewSymbolsSubsection(Contents, Section, Offset); - break; - case COFF::DEBUG_LINE_TABLE_SUBSECTION: { - // Holds a PC to file:line table. Some data to parse this subsection is - // stored in the other subsections, so just check sanity and store the - // pointers for deferred processing. - - if (PayloadSize < 12) { - // There should be at least three words to store two function - // relocations and size of the code. - error(object_error::parse_failed); - return; - } - - StringRef LinkageName; - error(resolveSymbolName(Obj->getCOFFSection(Section), Offset, - LinkageName)); - W.printString("LinkageName", LinkageName); - if (FunctionLineTables.count(LinkageName) != 0) { - // Saw debug info for this function already? + FunctionLineTables[LinkageName] = Contents; + FunctionNames.push_back(LinkageName); + break; + } + case ModuleSubstreamKind::FrameData: { + // First four bytes is a relocation against the function. + const uint32_t *CodePtr; + error(consumeObject(Contents, CodePtr)); + StringRef LinkageName; + error(resolveSymbolName(Obj->getCOFFSection(Section), SectionContents, + CodePtr, LinkageName)); + W.printString("LinkageName", LinkageName); + + // To find the active frame description, search this array for the + // smallest PC range that includes the current PC. + while (!Contents.empty()) { + const FrameData *FD; + error(consumeObject(Contents, FD)); + + if (FD->FrameFunc >= CVStringTable.size()) error(object_error::parse_failed); - return; - } - FunctionLineTables[LinkageName] = Contents; - FunctionNames.push_back(LinkageName); - break; + StringRef FrameFunc = + CVStringTable.drop_front(FD->FrameFunc).split('\0').first; + + DictScope S(W, "FrameData"); + W.printHex("RvaStart", FD->RvaStart); + W.printHex("CodeSize", FD->CodeSize); + W.printHex("LocalSize", FD->LocalSize); + W.printHex("ParamsSize", FD->ParamsSize); + W.printHex("MaxStackSize", FD->MaxStackSize); + W.printString("FrameFunc", FrameFunc); + W.printHex("PrologSize", FD->PrologSize); + W.printHex("SavedRegsSize", FD->SavedRegsSize); + W.printFlags("Flags", FD->Flags, makeArrayRef(FrameDataFlags)); } - case COFF::DEBUG_STRING_TABLE_SUBSECTION: - if (PayloadSize == 0 || CVStringTable.data() != nullptr || - Contents.back() != '\0') { - // Empty or duplicate or non-null-terminated subsection. - error(object_error::parse_failed); - return; - } - CVStringTable = Contents; - break; - case COFF::DEBUG_INDEX_SUBSECTION: - // Holds the translation table from file indices - // to offsets in the string table. - - if (PayloadSize == 0 || - CVFileIndexToStringOffsetTable.data() != nullptr) { - // Empty or duplicate subsection. - error(object_error::parse_failed); - return; - } - CVFileIndexToStringOffsetTable = Contents; - break; - } - Offset += PayloadSize; + break; + } - // Align the reading pointer by 4. - Offset += (-Offset) % 4; + // Do nothing for unrecognized subsections. + default: + break; } + W.flush(); } // Dump the line tables now that we've read all the subsections and know all @@ -594,8 +882,7 @@ void COFFDumper::printCodeViewSection(const SectionRef &Section) { uint32_t Offset = 6; // Skip relocations. uint16_t Flags = DE.getU16(&Offset); W.printHex("Flags", Flags); - bool HasColumnInformation = - Flags & COFF::DEBUG_LINE_TABLES_HAVE_COLUMN_RECORDS; + bool HasColumnInformation = Flags & codeview::LineFlags::HaveColumns; uint32_t FunctionSize = DE.getU32(&Offset); W.printHex("CodeSize", FunctionSize); while (DE.isValidOffset(Offset)) { @@ -615,28 +902,8 @@ void COFFDumper::printCodeViewSection(const SectionRef &Section) { return; } - uint32_t FilenameOffset; - { - DataExtractor SDE(CVFileIndexToStringOffsetTable, true, 4); - uint32_t OffsetInSDE = OffsetInIndex; - if (!SDE.isValidOffset(OffsetInSDE)) { - error(object_error::parse_failed); - return; - } - FilenameOffset = SDE.getU32(&OffsetInSDE); - } - - if (FilenameOffset == 0 || FilenameOffset + 1 >= CVStringTable.size() || - CVStringTable.data()[FilenameOffset - 1] != '\0') { - // Each string in an F3 subsection should be preceded by a null - // character. - error(object_error::parse_failed); - return; - } - - StringRef Filename(CVStringTable.data() + FilenameOffset); ListScope S(W, "FilenameSegment"); - W.printString("Filename", Filename); + printFileNameForOffset("Filename", OffsetInIndex); for (unsigned LineIdx = 0; LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) { // Then go the (PC, LineNumber) pairs. The line number is stored in the @@ -649,14 +916,15 @@ void COFFDumper::printCodeViewSection(const SectionRef &Section) { char Buffer[32]; format("+0x%X", PC).snprint(Buffer, 32); ListScope PCScope(W, Buffer); - uint32_t LineNumberStart = LineData & COFF::CVL_MaxLineNumber; - uint32_t LineNumberEndDelta = - (LineData >> COFF::CVL_LineNumberStartBits) & - COFF::CVL_LineNumberEndDeltaMask; - bool IsStatement = LineData & COFF::CVL_IsStatement; - W.printNumber("LineNumberStart", LineNumberStart); - W.printNumber("LineNumberEndDelta", LineNumberEndDelta); - W.printBoolean("IsStatement", IsStatement); + LineInfo LI(LineData); + if (LI.isAlwaysStepInto()) + W.printString("StepInto", StringRef("Always")); + else if (LI.isNeverStepInto()) + W.printString("StepInto", StringRef("Never")); + else + W.printNumber("LineNumberStart", LI.getStartLine()); + W.printNumber("LineNumberEndDelta", LI.getLineDelta()); + W.printBoolean("IsStatement", LI.isStatement()); if (HasColumnInformation && ColumnDE.isValidOffsetForDataOfSize(ColumnOffset, 4)) { uint16_t ColStart = ColumnDE.getU16(&ColumnOffset); @@ -678,85 +946,156 @@ void COFFDumper::printCodeViewSection(const SectionRef &Section) { void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection, const SectionRef &Section, - uint32_t OffsetInSection) { - if (Subsection.size() == 0) { + StringRef SectionContents) { + ArrayRef<uint8_t> BinaryData(Subsection.bytes_begin(), + Subsection.bytes_end()); + auto CODD = llvm::make_unique<COFFObjectDumpDelegate>(*this, Section, Obj, + SectionContents); + + CVSymbolDumper CVSD(W, CVTD, std::move(CODD), opts::CodeViewSubsectionBytes); + ByteStream<> Stream(BinaryData); + CVSymbolArray Symbols; + StreamReader Reader(Stream); + if (auto EC = Reader.readArray(Symbols, Reader.getLength())) { + consumeError(std::move(EC)); + W.flush(); + error(object_error::parse_failed); + } + + if (!CVSD.dump(Symbols)) { + W.flush(); error(object_error::parse_failed); - return; } - DataExtractor DE(Subsection, true, 4); - uint32_t Offset = 0; - - // Function-level subsections have "procedure start" and "procedure end" - // commands that should come in pairs and surround relevant info. - bool InFunctionScope = false; - while (DE.isValidOffset(Offset)) { - // Read subsection segments one by one. - uint16_t Size = DE.getU16(&Offset); - // The section size includes the size of the type identifier. - if (Size < 2 || !DE.isValidOffsetForDataOfSize(Offset, Size)) { + W.flush(); +} + +void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) { + StringRef Data = Subsection; + while (!Data.empty()) { + DictScope S(W, "FileChecksum"); + const FileChecksum *FC; + error(consumeObject(Data, FC)); + if (FC->FileNameOffset >= CVStringTable.size()) error(object_error::parse_failed); - return; - } - Size -= 2; - uint16_t Type = DE.getU16(&Offset); - switch (Type) { - case COFF::DEBUG_SYMBOL_TYPE_PROC_START: { - DictScope S(W, "ProcStart"); - if (InFunctionScope || Size < 36) { - error(object_error::parse_failed); - return; - } - InFunctionScope = true; - - // We're currently interested in a limited subset of fields in this - // segment, just ignore the rest of the fields for now. - uint8_t Unused[12]; - DE.getU8(&Offset, Unused, 12); - uint32_t CodeSize = DE.getU32(&Offset); - DE.getU8(&Offset, Unused, 12); - StringRef SectionName; - error(resolveSymbolName(Obj->getCOFFSection(Section), - OffsetInSection + Offset, SectionName)); - Offset += 4; - DE.getU8(&Offset, Unused, 3); - StringRef DisplayName = DE.getCStr(&Offset); - if (!DE.isValidOffset(Offset)) { - error(object_error::parse_failed); - return; - } - W.printString("DisplayName", DisplayName); - W.printString("Section", SectionName); - W.printHex("CodeSize", CodeSize); + StringRef Filename = + CVStringTable.drop_front(FC->FileNameOffset).split('\0').first; + W.printHex("Filename", Filename, FC->FileNameOffset); + W.printHex("ChecksumSize", FC->ChecksumSize); + W.printEnum("ChecksumKind", uint8_t(FC->ChecksumKind), + makeArrayRef(FileChecksumKindNames)); + if (FC->ChecksumSize >= Data.size()) + error(object_error::parse_failed); + StringRef ChecksumBytes = Data.substr(0, FC->ChecksumSize); + W.printBinary("ChecksumBytes", ChecksumBytes); + unsigned PaddedSize = alignTo(FC->ChecksumSize + sizeof(FileChecksum), 4) - + sizeof(FileChecksum); + if (PaddedSize > Data.size()) + error(object_error::parse_failed); + Data = Data.drop_front(PaddedSize); + } +} - break; - } - case COFF::DEBUG_SYMBOL_TYPE_PROC_END: { - W.startLine() << "ProcEnd\n"; - if (!InFunctionScope || Size > 0) { - error(object_error::parse_failed); - return; +void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) { + StringRef Data = Subsection; + uint32_t Signature; + error(consume(Data, Signature)); + bool HasExtraFiles = Signature == unsigned(InlineeLinesSignature::ExtraFiles); + + while (!Data.empty()) { + const InlineeSourceLine *ISL; + error(consumeObject(Data, ISL)); + DictScope S(W, "InlineeSourceLine"); + printTypeIndex("Inlinee", ISL->Inlinee); + printFileNameForOffset("FileID", ISL->FileID); + W.printNumber("SourceLineNum", ISL->SourceLineNum); + + if (HasExtraFiles) { + uint32_t ExtraFileCount; + error(consume(Data, ExtraFileCount)); + W.printNumber("ExtraFileCount", ExtraFileCount); + ListScope ExtraFiles(W, "ExtraFiles"); + for (unsigned I = 0; I < ExtraFileCount; ++I) { + uint32_t FileID; + error(consume(Data, FileID)); + printFileNameForOffset("FileID", FileID); } - InFunctionScope = false; - break; } - default: { - if (opts::CodeViewSubsectionBytes) { - ListScope S(W, "Record"); - W.printHex("Size", Size); - W.printHex("Type", Type); - - StringRef Contents = DE.getData().substr(Offset, Size); - W.printBinaryBlock("Contents", Contents); + } +} + +StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) { + // The file checksum subsection should precede all references to it. + if (!CVFileChecksumTable.data() || !CVStringTable.data()) + error(object_error::parse_failed); + // Check if the file checksum table offset is valid. + if (FileOffset >= CVFileChecksumTable.size()) + error(object_error::parse_failed); + + // The string table offset comes first before the file checksum. + StringRef Data = CVFileChecksumTable.drop_front(FileOffset); + uint32_t StringOffset; + error(consume(Data, StringOffset)); + + // Check if the string table offset is valid. + if (StringOffset >= CVStringTable.size()) + error(object_error::parse_failed); + + // Return the null-terminated string. + return CVStringTable.drop_front(StringOffset).split('\0').first; +} + +void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) { + W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset); +} + +void COFFDumper::mergeCodeViewTypes(MemoryTypeTableBuilder &CVTypes) { + for (const SectionRef &S : Obj->sections()) { + StringRef SectionName; + error(S.getName(SectionName)); + if (SectionName == ".debug$T") { + StringRef Data; + error(S.getContents(Data)); + uint32_t Magic; + error(consume(Data, Magic)); + if (Magic != 4) + error(object_error::parse_failed); + ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(Data.data()), + Data.size()); + ByteStream<> Stream(Bytes); + CVTypeArray Types; + StreamReader Reader(Stream); + if (auto EC = Reader.readArray(Types, Reader.getLength())) { + consumeError(std::move(EC)); + W.flush(); + error(object_error::parse_failed); } - Offset += Size; - break; - } + if (!mergeTypeStreams(CVTypes, Types)) + return error(object_error::parse_failed); } } +} - if (InFunctionScope) - error(object_error::parse_failed); +void COFFDumper::printCodeViewTypeSection(StringRef SectionName, + const SectionRef &Section) { + ListScope D(W, "CodeViewTypes"); + W.printNumber("Section", SectionName, Obj->getSectionID(Section)); + + StringRef Data; + error(Section.getContents(Data)); + if (opts::CodeViewSubsectionBytes) + W.printBinaryBlock("Data", Data); + + uint32_t Magic; + error(consume(Data, Magic)); + W.printHex("Magic", Magic); + if (Magic != COFF::DEBUG_SECTION_MAGIC) + return error(object_error::parse_failed); + + if (auto EC = CVTD.dump({Data.bytes_begin(), Data.bytes_end()})) { + W.flush(); + error(llvm::errorToErrorCode(std::move(EC))); + } } void COFFDumper::printSections() { @@ -838,16 +1177,16 @@ void COFFDumper::printRelocations() { } void COFFDumper::printRelocation(const SectionRef &Section, - const RelocationRef &Reloc) { - uint64_t Offset = Reloc.getOffset(); + const RelocationRef &Reloc, uint64_t Bias) { + uint64_t Offset = Reloc.getOffset() - Bias; uint64_t RelocType = Reloc.getType(); SmallString<32> RelocName; StringRef SymbolName; Reloc.getTypeName(RelocName); symbol_iterator Symbol = Reloc.getSymbol(); if (Symbol != Obj->symbol_end()) { - ErrorOr<StringRef> SymbolNameOrErr = Symbol->getName(); - error(SymbolNameOrErr.getError()); + Expected<StringRef> SymbolNameOrErr = Symbol->getName(); + error(errorToErrorCode(SymbolNameOrErr.takeError())); SymbolName = *SymbolNameOrErr; } @@ -1190,3 +1529,18 @@ void COFFDumper::printStackMap() const { prettyPrintStackMap(llvm::outs(), StackMapV1Parser<support::big>(StackMapContentsArray)); } + +void llvm::dumpCodeViewMergedTypes( + ScopedPrinter &Writer, llvm::codeview::MemoryTypeTableBuilder &CVTypes) { + // Flatten it first, then run our dumper on it. + ListScope S(Writer, "MergedTypeStream"); + SmallString<0> Buf; + CVTypes.ForEachRecord([&](TypeIndex TI, StringRef Record) { + Buf.append(Record.begin(), Record.end()); + }); + CVTypeDumper CVTD(&Writer, opts::CodeViewSubsectionBytes); + if (auto EC = CVTD.dump({Buf.str().bytes_begin(), Buf.str().bytes_end()})) { + Writer.flush(); + error(llvm::errorToErrorCode(std::move(EC))); + } +} diff --git a/contrib/llvm/tools/llvm-readobj/CodeView.h b/contrib/llvm/tools/llvm-readobj/CodeView.h new file mode 100644 index 0000000..cf71396 --- /dev/null +++ b/contrib/llvm/tools/llvm-readobj/CodeView.h @@ -0,0 +1,54 @@ +//===-- CodeView.h - On-disk record types for CodeView ----------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// \brief This file provides data structures useful for consuming on-disk +/// CodeView. It is based on information published by Microsoft at +/// https://github.com/Microsoft/microsoft-pdb/. +/// +//===----------------------------------------------------------------------===// + +// FIXME: Find a home for this in include/llvm/DebugInfo/CodeView/. + +#ifndef LLVM_READOBJ_CODEVIEW_H +#define LLVM_READOBJ_CODEVIEW_H + +#include "llvm/DebugInfo/CodeView/CodeView.h" +#include "llvm/DebugInfo/CodeView/TypeIndex.h" +#include "llvm/Support/Endian.h" + +namespace llvm { +namespace codeview { + +using llvm::support::ulittle16_t; +using llvm::support::ulittle32_t; + +/// Data in the the SUBSEC_FRAMEDATA subection. +struct FrameData { + ulittle32_t RvaStart; + ulittle32_t CodeSize; + ulittle32_t LocalSize; + ulittle32_t ParamsSize; + ulittle32_t MaxStackSize; + ulittle32_t FrameFunc; + ulittle16_t PrologSize; + ulittle16_t SavedRegsSize; + ulittle32_t Flags; + enum : uint32_t { + HasSEH = 1 << 0, + HasEH = 1 << 1, + IsFunctionStart = 1 << 2, + }; +}; + + +} // namespace codeview +} // namespace llvm + +#endif // LLVM_READOBJ_CODEVIEW_H diff --git a/contrib/llvm/tools/llvm-readobj/ELFDumper.cpp b/contrib/llvm/tools/llvm-readobj/ELFDumper.cpp index be84f3c..06fbe8d 100644 --- a/contrib/llvm/tools/llvm-readobj/ELFDumper.cpp +++ b/contrib/llvm/tools/llvm-readobj/ELFDumper.cpp @@ -12,13 +12,12 @@ /// //===----------------------------------------------------------------------===// -#include "llvm-readobj.h" #include "ARMAttributeParser.h" #include "ARMEHABIPrinter.h" #include "Error.h" #include "ObjDumper.h" #include "StackMapPrinter.h" -#include "StreamWriter.h" +#include "llvm-readobj.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" @@ -26,8 +25,10 @@ #include "llvm/Support/ARMBuildAttributes.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Format.h" +#include "llvm/Support/FormattedStream.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/MipsABIFlags.h" +#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/raw_ostream.h" using namespace llvm; @@ -37,12 +38,66 @@ using namespace ELF; #define LLVM_READOBJ_ENUM_CASE(ns, enum) \ case ns::enum: return #enum; +#define ENUM_ENT(enum, altName) \ + { #enum, altName, ELF::enum } + +#define ENUM_ENT_1(enum) \ + { #enum, #enum, ELF::enum } + +#define LLVM_READOBJ_PHDR_ENUM(ns, enum) \ + case ns::enum: \ + return std::string(#enum).substr(3); + +#define TYPEDEF_ELF_TYPES(ELFT) \ + typedef ELFFile<ELFT> ELFO; \ + typedef typename ELFO::Elf_Shdr Elf_Shdr; \ + typedef typename ELFO::Elf_Sym Elf_Sym; \ + typedef typename ELFO::Elf_Dyn Elf_Dyn; \ + typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range; \ + typedef typename ELFO::Elf_Rel Elf_Rel; \ + typedef typename ELFO::Elf_Rela Elf_Rela; \ + typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range; \ + typedef typename ELFO::Elf_Phdr Elf_Phdr; \ + typedef typename ELFO::Elf_Half Elf_Half; \ + typedef typename ELFO::Elf_Ehdr Elf_Ehdr; \ + typedef typename ELFO::Elf_Word Elf_Word; \ + typedef typename ELFO::Elf_Hash Elf_Hash; \ + typedef typename ELFO::Elf_GnuHash Elf_GnuHash; \ + typedef typename ELFO::uintX_t uintX_t; + namespace { +template <class ELFT> class DumpStyle; + +/// Represents a contiguous uniform range in the file. We cannot just create a +/// range directly because when creating one of these from the .dynamic table +/// the size, entity size and virtual address are different entries in arbitrary +/// order (DT_REL, DT_RELSZ, DT_RELENT for example). +struct DynRegionInfo { + DynRegionInfo() : Addr(nullptr), Size(0), EntSize(0) {} + DynRegionInfo(const void *A, uint64_t S, uint64_t ES) + : Addr(A), Size(S), EntSize(ES) {} + /// \brief Address in current address space. + const void *Addr; + /// \brief Size in bytes of the region. + uint64_t Size; + /// \brief Size of each entity in the region. + uint64_t EntSize; + + template <typename Type> ArrayRef<Type> getAsArrayRef() const { + const Type *Start = reinterpret_cast<const Type *>(Addr); + if (!Start) + return {Start, Start}; + if (EntSize != sizeof(Type) || Size % EntSize) + reportError("Invalid entity size"); + return {Start, Start + (Size / EntSize)}; + } +}; + template<typename ELFT> class ELFDumper : public ObjDumper { public: - ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer); + ELFDumper(const ELFFile<ELFT> *Obj, ScopedPrinter &Writer); void printFileHeaders() override; void printSections() override; @@ -59,22 +114,29 @@ public: void printGnuHashTable() override; void printLoadName() override; void printVersionInfo() override; + void printGroupSections() override; void printAttributes() override; void printMipsPLTGOT() override; void printMipsABIFlags() override; void printMipsReginfo() override; + void printMipsOptions() override; void printStackMap() const override; + void printHashHistogram() override; + private: + std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle; typedef ELFFile<ELFT> ELFO; typedef typename ELFO::Elf_Shdr Elf_Shdr; typedef typename ELFO::Elf_Sym Elf_Sym; + typedef typename ELFO::Elf_Sym_Range Elf_Sym_Range; typedef typename ELFO::Elf_Dyn Elf_Dyn; typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range; typedef typename ELFO::Elf_Rel Elf_Rel; typedef typename ELFO::Elf_Rela Elf_Rela; + typedef typename ELFO::Elf_Rel_Range Elf_Rel_Range; typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range; typedef typename ELFO::Elf_Phdr Elf_Phdr; typedef typename ELFO::Elf_Half Elf_Half; @@ -89,55 +151,44 @@ private: typedef typename ELFO::Elf_Verdef Elf_Verdef; typedef typename ELFO::Elf_Verdaux Elf_Verdaux; - /// \brief Represents a region described by entries in the .dynamic table. - struct DynRegionInfo { - DynRegionInfo() : Addr(nullptr), Size(0), EntSize(0) {} - /// \brief Address in current address space. - const void *Addr; - /// \brief Size in bytes of the region. - uintX_t Size; - /// \brief Size of each entity in the region. - uintX_t EntSize; - }; + DynRegionInfo checkDRI(DynRegionInfo DRI) { + if (DRI.Addr < Obj->base() || + (const uint8_t *)DRI.Addr + DRI.Size > Obj->base() + Obj->getBufSize()) + error(llvm::object::object_error::parse_failed); + return DRI; + } + + DynRegionInfo createDRIFrom(const Elf_Phdr *P, uintX_t EntSize) { + return checkDRI({Obj->base() + P->p_offset, P->p_filesz, EntSize}); + } - void printSymbolsHelper(bool IsDynamic); - void printSymbol(const Elf_Sym *Symbol, const Elf_Shdr *SymTab, - StringRef StrTable, bool IsDynamic); + DynRegionInfo createDRIFrom(const Elf_Shdr *S) { + return checkDRI({Obj->base() + S->sh_offset, S->sh_size, S->sh_entsize}); + } + + void parseDynamicTable(ArrayRef<const Elf_Phdr *> LoadSegments); - void printRelocations(const Elf_Shdr *Sec); - void printRelocation(Elf_Rela Rel, const Elf_Shdr *SymTab); void printValue(uint64_t Type, uint64_t Value); - const Elf_Rela *dyn_rela_begin() const; - const Elf_Rela *dyn_rela_end() const; - Elf_Rela_Range dyn_relas() const; StringRef getDynamicString(uint64_t Offset) const; - const Elf_Dyn *dynamic_table_begin() const { - ErrorOr<const Elf_Dyn *> Ret = Obj->dynamic_table_begin(DynamicProgHeader); - error(Ret.getError()); - return *Ret; - } - const Elf_Dyn *dynamic_table_end() const { - ErrorOr<const Elf_Dyn *> Ret = Obj->dynamic_table_end(DynamicProgHeader); - error(Ret.getError()); - return *Ret; - } StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb, - bool &IsDefault); - void LoadVersionMap(); + bool &IsDefault) const; + void LoadVersionMap() const; void LoadVersionNeeds(const Elf_Shdr *ec) const; void LoadVersionDefs(const Elf_Shdr *sec) const; const ELFO *Obj; + DynRegionInfo DynRelRegion; DynRegionInfo DynRelaRegion; - const Elf_Phdr *DynamicProgHeader = nullptr; + DynRegionInfo DynPLTRelRegion; + DynRegionInfo DynSymRegion; + DynRegionInfo DynamicTable; StringRef DynamicStringTable; - const Elf_Sym *DynSymStart = nullptr; StringRef SOName; const Elf_Hash *HashTable = nullptr; const Elf_GnuHash *GnuHashTable = nullptr; - const Elf_Shdr *DotDynSymSec = nullptr; const Elf_Shdr *DotSymtabSec = nullptr; + StringRef DynSymtabName; ArrayRef<Elf_Word> ShndxTable; const Elf_Shdr *dot_gnu_version_sec = nullptr; // .gnu.version @@ -169,40 +220,176 @@ private: public: Elf_Dyn_Range dynamic_table() const { - ErrorOr<Elf_Dyn_Range> Ret = Obj->dynamic_table(DynamicProgHeader); - error(Ret.getError()); - return *Ret; + return DynamicTable.getAsArrayRef<Elf_Dyn>(); + } + + Elf_Sym_Range dynamic_symbols() const { + return DynSymRegion.getAsArrayRef<Elf_Sym>(); } + Elf_Rel_Range dyn_rels() const; + Elf_Rela_Range dyn_relas() const; std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable, - bool IsDynamic); - const Elf_Shdr *getDotDynSymSec() const { return DotDynSymSec; } + bool IsDynamic) const; + + void printSymbolsHelper(bool IsDynamic) const; const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; } - ArrayRef<Elf_Word> getShndxTable() { return ShndxTable; } + ArrayRef<Elf_Word> getShndxTable() const { return ShndxTable; } + StringRef getDynamicStringTable() const { return DynamicStringTable; } + const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; } + const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; } + const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; } + const Elf_Hash *getHashTable() const { return HashTable; } + const Elf_GnuHash *getGnuHashTable() const { return GnuHashTable; } }; -template <class T> T errorOrDefault(ErrorOr<T> Val, T Default = T()) { - if (!Val) { - error(Val.getError()); - return Default; +template <class ELFT> +void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const { + StringRef StrTable, SymtabName; + size_t Entries = 0; + Elf_Sym_Range Syms(nullptr, nullptr); + if (IsDynamic) { + StrTable = DynamicStringTable; + Syms = dynamic_symbols(); + SymtabName = DynSymtabName; + if (DynSymRegion.Addr) + Entries = DynSymRegion.Size / DynSymRegion.EntSize; + } else { + if (!DotSymtabSec) + return; + StrTable = unwrapOrError(Obj->getStringTableForSymtab(*DotSymtabSec)); + Syms = Obj->symbols(DotSymtabSec); + SymtabName = unwrapOrError(Obj->getSectionName(DotSymtabSec)); + Entries = DotSymtabSec->getEntityCount(); + } + if (Syms.begin() == Syms.end()) + return; + ELFDumperStyle->printSymtabMessage(Obj, SymtabName, Entries); + for (const auto &Sym : Syms) + ELFDumperStyle->printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic); +} + +template <typename ELFT> class DumpStyle { +public: + using Elf_Shdr = typename ELFFile<ELFT>::Elf_Shdr; + using Elf_Sym = typename ELFFile<ELFT>::Elf_Sym; + + DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {} + virtual ~DumpStyle() {} + virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0; + virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0; + virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0; + virtual void printSections(const ELFFile<ELFT> *Obj) = 0; + virtual void printSymbols(const ELFFile<ELFT> *Obj) = 0; + virtual void printDynamicSymbols(const ELFFile<ELFT> *Obj) = 0; + virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0; + virtual void printSymtabMessage(const ELFFile<ELFT> *obj, StringRef Name, + size_t Offset) { + return; } + virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol, + const Elf_Sym *FirstSym, StringRef StrTable, + bool IsDynamic) = 0; + virtual void printProgramHeaders(const ELFFile<ELFT> *Obj) = 0; + virtual void printHashHistogram(const ELFFile<ELFT> *Obj) = 0; + const ELFDumper<ELFT> *dumper() const { return Dumper; } +private: + const ELFDumper<ELFT> *Dumper; +}; + +template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> { + formatted_raw_ostream OS; +public: + TYPEDEF_ELF_TYPES(ELFT) + GNUStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper) + : DumpStyle<ELFT>(Dumper), OS(W.getOStream()) {} + void printFileHeaders(const ELFO *Obj) override; + void printGroupSections(const ELFFile<ELFT> *Obj) override; + void printRelocations(const ELFO *Obj) override; + void printSections(const ELFO *Obj) override; + void printSymbols(const ELFO *Obj) override; + void printDynamicSymbols(const ELFO *Obj) override; + void printDynamicRelocations(const ELFO *Obj) override; + virtual void printSymtabMessage(const ELFO *Obj, StringRef Name, + size_t Offset) override; + void printProgramHeaders(const ELFO *Obj) override; + void printHashHistogram(const ELFFile<ELFT> *Obj) override; + +private: + struct Field { + StringRef Str; + unsigned Column; + Field(StringRef S, unsigned Col) : Str(S), Column(Col) {} + Field(unsigned Col) : Str(""), Column(Col) {} + }; + + template <typename T, typename TEnum> + std::string printEnum(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) { + for (const auto &EnumItem : EnumValues) + if (EnumItem.Value == Value) + return EnumItem.AltName; + return to_hexString(Value, false); + } + + formatted_raw_ostream &printField(struct Field F) { + if (F.Column != 0) + OS.PadToColumn(F.Column); + OS << F.Str; + OS.flush(); + return OS; + } + void printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab, + const Elf_Rela &R, bool IsRela); + void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First, + StringRef StrTable, bool IsDynamic) override; + std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol, + const Elf_Sym *FirstSym); + void printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela); + bool checkTLSSections(const Elf_Phdr &Phdr, const Elf_Shdr &Sec); + bool checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec); + bool checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec); + bool checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec); +}; + +template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> { +public: + TYPEDEF_ELF_TYPES(ELFT) + LLVMStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper) + : DumpStyle<ELFT>(Dumper), W(W) {} + + void printFileHeaders(const ELFO *Obj) override; + void printGroupSections(const ELFFile<ELFT> *Obj) override; + void printRelocations(const ELFO *Obj) override; + void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj); + void printSections(const ELFO *Obj) override; + void printSymbols(const ELFO *Obj) override; + void printDynamicSymbols(const ELFO *Obj) override; + void printDynamicRelocations(const ELFO *Obj) override; + void printProgramHeaders(const ELFO *Obj) override; + void printHashHistogram(const ELFFile<ELFT> *Obj) override; + +private: + void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab); + void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel); + void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First, + StringRef StrTable, bool IsDynamic) override; + ScopedPrinter &W; +}; - return *Val; -} } // namespace namespace llvm { template <class ELFT> static std::error_code createELFDumper(const ELFFile<ELFT> *Obj, - StreamWriter &Writer, + ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result) { Result.reset(new ELFDumper<ELFT>(Obj, Writer)); return readobj_error::success; } std::error_code createELFDumper(const object::ObjectFile *Obj, - StreamWriter &Writer, + ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result) { // Little-endian 32-bit if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj)) @@ -284,9 +471,9 @@ void ELFDumper<ELFT>::LoadVersionDefs(const Elf_Shdr *sec) const { } } -template <class ELFT> void ELFDumper<ELFT>::LoadVersionMap() { +template <class ELFT> void ELFDumper<ELFT>::LoadVersionMap() const { // If there is no dynamic symtab or version table, there is nothing to do. - if (!DynSymStart || !dot_gnu_version_sec) + if (!DynSymRegion.Addr || !dot_gnu_version_sec) return; // Has the VersionMap already been loaded? @@ -305,99 +492,157 @@ template <class ELFT> void ELFDumper<ELFT>::LoadVersionMap() { LoadVersionNeeds(dot_gnu_version_r_sec); } - template <typename ELFO, class ELFT> -static void printVersionSymbolSection(ELFDumper<ELFT> *Dumper, - const ELFO *Obj, +static void printVersionSymbolSection(ELFDumper<ELFT> *Dumper, const ELFO *Obj, const typename ELFO::Elf_Shdr *Sec, - StreamWriter &W) { + ScopedPrinter &W) { DictScope SS(W, "Version symbols"); if (!Sec) return; - StringRef Name = errorOrDefault(Obj->getSectionName(Sec)); + StringRef Name = unwrapOrError(Obj->getSectionName(Sec)); W.printNumber("Section Name", Name, Sec->sh_name); W.printHex("Address", Sec->sh_addr); W.printHex("Offset", Sec->sh_offset); W.printNumber("Link", Sec->sh_link); - const typename ELFO::Elf_Shdr *DynSymSec = Dumper->getDotDynSymSec(); const uint8_t *P = (const uint8_t *)Obj->base() + Sec->sh_offset; - ErrorOr<StringRef> StrTableOrErr = - Obj->getStringTableForSymtab(*DynSymSec); - error(StrTableOrErr.getError()); + StringRef StrTable = Dumper->getDynamicStringTable(); // Same number of entries in the dynamic symbol table (DT_SYMTAB). ListScope Syms(W, "Symbols"); - for (const typename ELFO::Elf_Sym &Sym : Obj->symbols(DynSymSec)) { + for (const typename ELFO::Elf_Sym &Sym : Dumper->dynamic_symbols()) { DictScope S(W, "Symbol"); std::string FullSymbolName = - Dumper->getFullSymbolName(&Sym, *StrTableOrErr, true /* IsDynamic */); + Dumper->getFullSymbolName(&Sym, StrTable, true /* IsDynamic */); W.printNumber("Version", *P); W.printString("Name", FullSymbolName); P += sizeof(typename ELFO::Elf_Half); } } +static const EnumEntry<unsigned> SymVersionFlags[] = { + {"Base", "BASE", VER_FLG_BASE}, + {"Weak", "WEAK", VER_FLG_WEAK}, + {"Info", "INFO", VER_FLG_INFO}}; + template <typename ELFO, class ELFT> static void printVersionDefinitionSection(ELFDumper<ELFT> *Dumper, const ELFO *Obj, const typename ELFO::Elf_Shdr *Sec, - StreamWriter &W) { - DictScope SD(W, "Version definition"); + ScopedPrinter &W) { + typedef typename ELFO::Elf_Verdef VerDef; + typedef typename ELFO::Elf_Verdaux VerdAux; + + DictScope SD(W, "SHT_GNU_verdef"); if (!Sec) return; - StringRef Name = errorOrDefault(Obj->getSectionName(Sec)); - W.printNumber("Section Name", Name, Sec->sh_name); - W.printHex("Address", Sec->sh_addr); - W.printHex("Offset", Sec->sh_offset); - W.printNumber("Link", Sec->sh_link); - unsigned verdef_entries = 0; // The number of entries in the section SHT_GNU_verdef // is determined by DT_VERDEFNUM tag. + unsigned VerDefsNum = 0; for (const typename ELFO::Elf_Dyn &Dyn : Dumper->dynamic_table()) { if (Dyn.d_tag == DT_VERDEFNUM) - verdef_entries = Dyn.d_un.d_val; + VerDefsNum = Dyn.d_un.d_val; } const uint8_t *SecStartAddress = (const uint8_t *)Obj->base() + Sec->sh_offset; const uint8_t *SecEndAddress = SecStartAddress + Sec->sh_size; const uint8_t *P = SecStartAddress; - ErrorOr<const typename ELFO::Elf_Shdr *> StrTabOrErr = - Obj->getSection(Sec->sh_link); - error(StrTabOrErr.getError()); + const typename ELFO::Elf_Shdr *StrTab = + unwrapOrError(Obj->getSection(Sec->sh_link)); - ListScope Entries(W, "Entries"); - for (unsigned i = 0; i < verdef_entries; ++i) { - if (P + sizeof(typename ELFO::Elf_Verdef) > SecEndAddress) + while (VerDefsNum--) { + if (P + sizeof(VerDef) > SecEndAddress) report_fatal_error("invalid offset in the section"); - auto *VD = reinterpret_cast<const typename ELFO::Elf_Verdef *>(P); - DictScope Entry(W, "Entry"); - W.printHex("Offset", (uintptr_t)P - (uintptr_t)SecStartAddress); - W.printNumber("Rev", VD->vd_version); - // FIXME: print something more readable. - W.printNumber("Flags", VD->vd_flags); + + auto *VD = reinterpret_cast<const VerDef *>(P); + DictScope Def(W, "Definition"); + W.printNumber("Version", VD->vd_version); + W.printEnum("Flags", VD->vd_flags, makeArrayRef(SymVersionFlags)); W.printNumber("Index", VD->vd_ndx); - W.printNumber("Cnt", VD->vd_cnt); - W.printString("Name", StringRef((const char *)(Obj->base() + - (*StrTabOrErr)->sh_offset + - VD->getAux()->vda_name))); + W.printNumber("Hash", VD->vd_hash); + W.printString("Name", + StringRef((const char *)(Obj->base() + StrTab->sh_offset + + VD->getAux()->vda_name))); + if (!VD->vd_cnt) + report_fatal_error("at least one definition string must exist"); + if (VD->vd_cnt > 2) + report_fatal_error("more than one predecessor is not expected"); + + if (VD->vd_cnt == 2) { + const uint8_t *PAux = P + VD->vd_aux + VD->getAux()->vda_next; + const VerdAux *Aux = reinterpret_cast<const VerdAux *>(PAux); + W.printString("Predecessor", + StringRef((const char *)(Obj->base() + StrTab->sh_offset + + Aux->vda_name))); + } + P += VD->vd_next; } } +template <typename ELFO, class ELFT> +static void printVersionDependencySection(ELFDumper<ELFT> *Dumper, + const ELFO *Obj, + const typename ELFO::Elf_Shdr *Sec, + ScopedPrinter &W) { + typedef typename ELFO::Elf_Verneed VerNeed; + typedef typename ELFO::Elf_Vernaux VernAux; + + DictScope SD(W, "SHT_GNU_verneed"); + if (!Sec) + return; + + unsigned VerNeedNum = 0; + for (const typename ELFO::Elf_Dyn &Dyn : Dumper->dynamic_table()) + if (Dyn.d_tag == DT_VERNEEDNUM) + VerNeedNum = Dyn.d_un.d_val; + + const uint8_t *SecData = (const uint8_t *)Obj->base() + Sec->sh_offset; + const typename ELFO::Elf_Shdr *StrTab = + unwrapOrError(Obj->getSection(Sec->sh_link)); + + const uint8_t *P = SecData; + for (unsigned I = 0; I < VerNeedNum; ++I) { + const VerNeed *Need = reinterpret_cast<const VerNeed *>(P); + DictScope Entry(W, "Dependency"); + W.printNumber("Version", Need->vn_version); + W.printNumber("Count", Need->vn_cnt); + W.printString("FileName", + StringRef((const char *)(Obj->base() + StrTab->sh_offset + + Need->vn_file))); + + const uint8_t *PAux = P + Need->vn_aux; + for (unsigned J = 0; J < Need->vn_cnt; ++J) { + const VernAux *Aux = reinterpret_cast<const VernAux *>(PAux); + DictScope Entry(W, "Entry"); + W.printNumber("Hash", Aux->vna_hash); + W.printEnum("Flags", Aux->vna_flags, makeArrayRef(SymVersionFlags)); + W.printNumber("Index", Aux->vna_other); + W.printString("Name", + StringRef((const char *)(Obj->base() + StrTab->sh_offset + + Aux->vna_name))); + PAux += Aux->vna_next; + } + P += Need->vn_next; + } +} + template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() { // Dump version symbol section. printVersionSymbolSection(this, Obj, dot_gnu_version_sec, W); // Dump version definition section. printVersionDefinitionSection(this, Obj, dot_gnu_version_d_sec, W); + + // Dump version dependency section. + printVersionDependencySection(this, Obj, dot_gnu_version_r_sec, W); } template <typename ELFT> StringRef ELFDumper<ELFT>::getSymbolVersion(StringRef StrTab, const Elf_Sym *symb, - bool &IsDefault) { + bool &IsDefault) const { // This is a dynamic symbol. Look in the GNU symbol version table. if (!dot_gnu_version_sec) { // No version table. @@ -407,7 +652,7 @@ StringRef ELFDumper<ELFT>::getSymbolVersion(StringRef StrTab, // Determine the position in the symbol table of this entry. size_t entry_index = (reinterpret_cast<uintptr_t>(symb) - - reinterpret_cast<uintptr_t>(DynSymStart)) / + reinterpret_cast<uintptr_t>(DynSymRegion.Addr)) / sizeof(Elf_Sym); // Get the corresponding version index entry @@ -446,8 +691,8 @@ StringRef ELFDumper<ELFT>::getSymbolVersion(StringRef StrTab, template <typename ELFT> std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable, - bool IsDynamic) { - StringRef SymbolName = errorOrDefault(Symbol->getName(StrTable)); + bool IsDynamic) const { + StringRef SymbolName = unwrapOrError(Symbol->getName(StrTable)); if (!IsDynamic) return SymbolName; @@ -463,7 +708,7 @@ std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol, template <typename ELFO> static void getSectionNameIndex(const ELFO &Obj, const typename ELFO::Elf_Sym *Symbol, - const typename ELFO::Elf_Shdr *SymTab, + const typename ELFO::Elf_Sym *FirstSym, ArrayRef<typename ELFO::Elf_Word> ShndxTable, StringRef &SectionName, unsigned &SectionIndex) { SectionIndex = Symbol->st_shndx; @@ -482,18 +727,18 @@ getSectionNameIndex(const ELFO &Obj, const typename ELFO::Elf_Sym *Symbol, else { if (SectionIndex == SHN_XINDEX) SectionIndex = - Obj.getExtendedSymbolTableIndex(Symbol, SymTab, ShndxTable); - ErrorOr<const typename ELFO::Elf_Shdr *> Sec = Obj.getSection(SectionIndex); - error(Sec.getError()); - SectionName = errorOrDefault(Obj.getSectionName(*Sec)); + Obj.getExtendedSymbolTableIndex(Symbol, FirstSym, ShndxTable); + const typename ELFO::Elf_Shdr *Sec = + unwrapOrError(Obj.getSection(SectionIndex)); + SectionName = unwrapOrError(Obj.getSectionName(Sec)); } } template <class ELFO> -static const typename ELFO::Elf_Shdr *findSectionByAddress(const ELFO *Obj, - uint64_t Addr) { +static const typename ELFO::Elf_Shdr * +findNotEmptySectionByAddress(const ELFO *Obj, uint64_t Addr) { for (const auto &Shdr : Obj->sections()) - if (Shdr.sh_addr == Addr) + if (Shdr.sh_addr == Addr && Shdr.sh_size > 0) return &Shdr; return nullptr; } @@ -502,233 +747,239 @@ template <class ELFO> static const typename ELFO::Elf_Shdr *findSectionByName(const ELFO &Obj, StringRef Name) { for (const auto &Shdr : Obj.sections()) { - if (Name == errorOrDefault(Obj.getSectionName(&Shdr))) + if (Name == unwrapOrError(Obj.getSectionName(&Shdr))) return &Shdr; } return nullptr; } static const EnumEntry<unsigned> ElfClass[] = { - { "None", ELF::ELFCLASSNONE }, - { "32-bit", ELF::ELFCLASS32 }, - { "64-bit", ELF::ELFCLASS64 }, + {"None", "none", ELF::ELFCLASSNONE}, + {"32-bit", "ELF32", ELF::ELFCLASS32}, + {"64-bit", "ELF64", ELF::ELFCLASS64}, }; static const EnumEntry<unsigned> ElfDataEncoding[] = { - { "None", ELF::ELFDATANONE }, - { "LittleEndian", ELF::ELFDATA2LSB }, - { "BigEndian", ELF::ELFDATA2MSB }, + {"None", "none", ELF::ELFDATANONE}, + {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB}, + {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB}, }; static const EnumEntry<unsigned> ElfObjectFileType[] = { - { "None", ELF::ET_NONE }, - { "Relocatable", ELF::ET_REL }, - { "Executable", ELF::ET_EXEC }, - { "SharedObject", ELF::ET_DYN }, - { "Core", ELF::ET_CORE }, + {"None", "NONE (none)", ELF::ET_NONE}, + {"Relocatable", "REL (Relocatable file)", ELF::ET_REL}, + {"Executable", "EXEC (Executable file)", ELF::ET_EXEC}, + {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN}, + {"Core", "CORE (Core file)", ELF::ET_CORE}, }; static const EnumEntry<unsigned> ElfOSABI[] = { - { "SystemV", ELF::ELFOSABI_NONE }, - { "HPUX", ELF::ELFOSABI_HPUX }, - { "NetBSD", ELF::ELFOSABI_NETBSD }, - { "GNU/Linux", ELF::ELFOSABI_LINUX }, - { "GNU/Hurd", ELF::ELFOSABI_HURD }, - { "Solaris", ELF::ELFOSABI_SOLARIS }, - { "AIX", ELF::ELFOSABI_AIX }, - { "IRIX", ELF::ELFOSABI_IRIX }, - { "FreeBSD", ELF::ELFOSABI_FREEBSD }, - { "TRU64", ELF::ELFOSABI_TRU64 }, - { "Modesto", ELF::ELFOSABI_MODESTO }, - { "OpenBSD", ELF::ELFOSABI_OPENBSD }, - { "OpenVMS", ELF::ELFOSABI_OPENVMS }, - { "NSK", ELF::ELFOSABI_NSK }, - { "AROS", ELF::ELFOSABI_AROS }, - { "FenixOS", ELF::ELFOSABI_FENIXOS }, - { "CloudABI", ELF::ELFOSABI_CLOUDABI }, - { "C6000_ELFABI", ELF::ELFOSABI_C6000_ELFABI }, - { "C6000_LINUX" , ELF::ELFOSABI_C6000_LINUX }, - { "ARM", ELF::ELFOSABI_ARM }, - { "Standalone" , ELF::ELFOSABI_STANDALONE } + {"SystemV", "UNIX - System V", ELF::ELFOSABI_NONE}, + {"HPUX", "UNIX - HP-UX", ELF::ELFOSABI_HPUX}, + {"NetBSD", "UNIX - NetBSD", ELF::ELFOSABI_NETBSD}, + {"GNU/Linux", "UNIX - GNU", ELF::ELFOSABI_LINUX}, + {"GNU/Hurd", "GNU/Hurd", ELF::ELFOSABI_HURD}, + {"Solaris", "UNIX - Solaris", ELF::ELFOSABI_SOLARIS}, + {"AIX", "UNIX - AIX", ELF::ELFOSABI_AIX}, + {"IRIX", "UNIX - IRIX", ELF::ELFOSABI_IRIX}, + {"FreeBSD", "UNIX - FreeBSD", ELF::ELFOSABI_FREEBSD}, + {"TRU64", "UNIX - TRU64", ELF::ELFOSABI_TRU64}, + {"Modesto", "Novell - Modesto", ELF::ELFOSABI_MODESTO}, + {"OpenBSD", "UNIX - OpenBSD", ELF::ELFOSABI_OPENBSD}, + {"OpenVMS", "VMS - OpenVMS", ELF::ELFOSABI_OPENVMS}, + {"NSK", "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK}, + {"AROS", "AROS", ELF::ELFOSABI_AROS}, + {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS}, + {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI}, + {"C6000_ELFABI", "Bare-metal C6000", ELF::ELFOSABI_C6000_ELFABI}, + {"C6000_LINUX", "Linux C6000", ELF::ELFOSABI_C6000_LINUX}, + {"ARM", "ARM", ELF::ELFOSABI_ARM}, + {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE} }; static const EnumEntry<unsigned> ElfMachineType[] = { - LLVM_READOBJ_ENUM_ENT(ELF, EM_NONE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_M32 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_386 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_68K ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_88K ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_IAMCU ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_860 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_S370 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_RS3_LE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PARISC ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_VPP500 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC32PLUS ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_960 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC64 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_S390 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SPU ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_V800 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_FR20 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_RH32 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_RCE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ARM ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ALPHA ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SH ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARCV9 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TRICORE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300H ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_H8S ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_500 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_IA_64 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_X ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_COLDFIRE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC12 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MMA ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PCP ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_NCPU ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_NDR1 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_STARCORE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ME16 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ST100 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TINYJ ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_X86_64 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PDSP ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP10 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP11 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_FX66 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ST9PLUS ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ST7 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC16 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC11 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC08 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC05 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SVX ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ST19 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_VAX ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CRIS ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_JAVELIN ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_FIREPATH ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ZSP ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MMIX ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_HUANY ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PRISM ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_FR30 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_D10V ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_D30V ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_V850 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_M32R ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10300 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10200 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_PJ ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_OPENRISC ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_XTENSA ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TMM_GPP ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_NS32K ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TPC ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SNP1K ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ST200 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_IP2K ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MAX ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CR ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_F2MC16 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MSP430 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_BLACKFIN ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C33 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SEP ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ARCA ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_UNICORE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_EXCESS ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_DXP ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ALTERA_NIOS2 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CRX ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_XGATE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_C166 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_M16C ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_DSPIC30F ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CE ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_M32C ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TSK3000 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_RS08 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SHARC ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG2 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SCORE7 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_DSP24 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE3 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_LATTICEMICO32), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C17 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C6000 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C2000 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C5500 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MMDSP_PLUS ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CYPRESS_M8C ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_R32C ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TRIMEDIA ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_HEXAGON ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_8051 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_STXP7X ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_NDS32 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1X ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MAXQ30 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_XIMO16 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MANIK ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CRAYNV2 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_RX ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_METAG ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_MCST_ELBRUS ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG16 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CR16 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ETPU ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_SLE9X ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_L10M ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_K10M ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_AARCH64 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR32 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_STM8 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TILE64 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEPRO ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CUDA ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEGX ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_CLOUDSHIELD ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_1ST ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_2ND ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT2 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_OPEN8 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_RL78 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE5 ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_78KOR ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_56800EX ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_AMDGPU ), - LLVM_READOBJ_ENUM_ENT(ELF, EM_WEBASSEMBLY ), + ENUM_ENT(EM_NONE, "None"), + ENUM_ENT(EM_M32, "WE32100"), + ENUM_ENT(EM_SPARC, "Sparc"), + ENUM_ENT(EM_386, "Intel 80386"), + ENUM_ENT(EM_68K, "MC68000"), + ENUM_ENT(EM_88K, "MC88000"), + ENUM_ENT(EM_IAMCU, "EM_IAMCU"), + ENUM_ENT(EM_860, "Intel 80860"), + ENUM_ENT(EM_MIPS, "MIPS R3000"), + ENUM_ENT(EM_S370, "IBM System/370"), + ENUM_ENT(EM_MIPS_RS3_LE, "MIPS R3000 little-endian"), + ENUM_ENT(EM_PARISC, "HPPA"), + ENUM_ENT(EM_VPP500, "Fujitsu VPP500"), + ENUM_ENT(EM_SPARC32PLUS, "Sparc v8+"), + ENUM_ENT(EM_960, "Intel 80960"), + ENUM_ENT(EM_PPC, "PowerPC"), + ENUM_ENT(EM_PPC64, "PowerPC64"), + ENUM_ENT(EM_S390, "IBM S/390"), + ENUM_ENT(EM_SPU, "SPU"), + ENUM_ENT(EM_V800, "NEC V800 series"), + ENUM_ENT(EM_FR20, "Fujistsu FR20"), + ENUM_ENT(EM_RH32, "TRW RH-32"), + ENUM_ENT(EM_RCE, "Motorola RCE"), + ENUM_ENT(EM_ARM, "ARM"), + ENUM_ENT(EM_ALPHA, "EM_ALPHA"), + ENUM_ENT(EM_SH, "Hitachi SH"), + ENUM_ENT(EM_SPARCV9, "Sparc v9"), + ENUM_ENT(EM_TRICORE, "Siemens Tricore"), + ENUM_ENT(EM_ARC, "ARC"), + ENUM_ENT(EM_H8_300, "Hitachi H8/300"), + ENUM_ENT(EM_H8_300H, "Hitachi H8/300H"), + ENUM_ENT(EM_H8S, "Hitachi H8S"), + ENUM_ENT(EM_H8_500, "Hitachi H8/500"), + ENUM_ENT(EM_IA_64, "Intel IA-64"), + ENUM_ENT(EM_MIPS_X, "Stanford MIPS-X"), + ENUM_ENT(EM_COLDFIRE, "Motorola Coldfire"), + ENUM_ENT(EM_68HC12, "Motorola MC68HC12 Microcontroller"), + ENUM_ENT(EM_MMA, "Fujitsu Multimedia Accelerator"), + ENUM_ENT(EM_PCP, "Siemens PCP"), + ENUM_ENT(EM_NCPU, "Sony nCPU embedded RISC processor"), + ENUM_ENT(EM_NDR1, "Denso NDR1 microprocesspr"), + ENUM_ENT(EM_STARCORE, "Motorola Star*Core processor"), + ENUM_ENT(EM_ME16, "Toyota ME16 processor"), + ENUM_ENT(EM_ST100, "STMicroelectronics ST100 processor"), + ENUM_ENT(EM_TINYJ, "Advanced Logic Corp. TinyJ embedded processor"), + ENUM_ENT(EM_X86_64, "Advanced Micro Devices X86-64"), + ENUM_ENT(EM_PDSP, "Sony DSP processor"), + ENUM_ENT(EM_PDP10, "Digital Equipment Corp. PDP-10"), + ENUM_ENT(EM_PDP11, "Digital Equipment Corp. PDP-11"), + ENUM_ENT(EM_FX66, "Siemens FX66 microcontroller"), + ENUM_ENT(EM_ST9PLUS, "STMicroelectronics ST9+ 8/16 bit microcontroller"), + ENUM_ENT(EM_ST7, "STMicroelectronics ST7 8-bit microcontroller"), + ENUM_ENT(EM_68HC16, "Motorola MC68HC16 Microcontroller"), + ENUM_ENT(EM_68HC11, "Motorola MC68HC11 Microcontroller"), + ENUM_ENT(EM_68HC08, "Motorola MC68HC08 Microcontroller"), + ENUM_ENT(EM_68HC05, "Motorola MC68HC05 Microcontroller"), + ENUM_ENT(EM_SVX, "Silicon Graphics SVx"), + ENUM_ENT(EM_ST19, "STMicroelectronics ST19 8-bit microcontroller"), + ENUM_ENT(EM_VAX, "Digital VAX"), + ENUM_ENT(EM_CRIS, "Axis Communications 32-bit embedded processor"), + ENUM_ENT(EM_JAVELIN, "Infineon Technologies 32-bit embedded cpu"), + ENUM_ENT(EM_FIREPATH, "Element 14 64-bit DSP processor"), + ENUM_ENT(EM_ZSP, "LSI Logic's 16-bit DSP processor"), + ENUM_ENT(EM_MMIX, "Donald Knuth's educational 64-bit processor"), + ENUM_ENT(EM_HUANY, "Harvard Universitys's machine-independent object format"), + ENUM_ENT(EM_PRISM, "Vitesse Prism"), + ENUM_ENT(EM_AVR, "Atmel AVR 8-bit microcontroller"), + ENUM_ENT(EM_FR30, "Fujitsu FR30"), + ENUM_ENT(EM_D10V, "Mitsubishi D10V"), + ENUM_ENT(EM_D30V, "Mitsubishi D30V"), + ENUM_ENT(EM_V850, "NEC v850"), + ENUM_ENT(EM_M32R, "Renesas M32R (formerly Mitsubishi M32r)"), + ENUM_ENT(EM_MN10300, "Matsushita MN10300"), + ENUM_ENT(EM_MN10200, "Matsushita MN10200"), + ENUM_ENT(EM_PJ, "picoJava"), + ENUM_ENT(EM_OPENRISC, "OpenRISC 32-bit embedded processor"), + ENUM_ENT(EM_ARC_COMPACT, "EM_ARC_COMPACT"), + ENUM_ENT(EM_XTENSA, "Tensilica Xtensa Processor"), + ENUM_ENT(EM_VIDEOCORE, "Alphamosaic VideoCore processor"), + ENUM_ENT(EM_TMM_GPP, "Thompson Multimedia General Purpose Processor"), + ENUM_ENT(EM_NS32K, "National Semiconductor 32000 series"), + ENUM_ENT(EM_TPC, "Tenor Network TPC processor"), + ENUM_ENT(EM_SNP1K, "EM_SNP1K"), + ENUM_ENT(EM_ST200, "STMicroelectronics ST200 microcontroller"), + ENUM_ENT(EM_IP2K, "Ubicom IP2xxx 8-bit microcontrollers"), + ENUM_ENT(EM_MAX, "MAX Processor"), + ENUM_ENT(EM_CR, "National Semiconductor CompactRISC"), + ENUM_ENT(EM_F2MC16, "Fujitsu F2MC16"), + ENUM_ENT(EM_MSP430, "Texas Instruments msp430 microcontroller"), + ENUM_ENT(EM_BLACKFIN, "Analog Devices Blackfin"), + ENUM_ENT(EM_SE_C33, "S1C33 Family of Seiko Epson processors"), + ENUM_ENT(EM_SEP, "Sharp embedded microprocessor"), + ENUM_ENT(EM_ARCA, "Arca RISC microprocessor"), + ENUM_ENT(EM_UNICORE, "Unicore"), + ENUM_ENT(EM_EXCESS, "eXcess 16/32/64-bit configurable embedded CPU"), + ENUM_ENT(EM_DXP, "Icera Semiconductor Inc. Deep Execution Processor"), + ENUM_ENT(EM_ALTERA_NIOS2, "Altera Nios"), + ENUM_ENT(EM_CRX, "National Semiconductor CRX microprocessor"), + ENUM_ENT(EM_XGATE, "Motorola XGATE embedded processor"), + ENUM_ENT(EM_C166, "Infineon Technologies xc16x"), + ENUM_ENT(EM_M16C, "Renesas M16C"), + ENUM_ENT(EM_DSPIC30F, "Microchip Technology dsPIC30F Digital Signal Controller"), + ENUM_ENT(EM_CE, "Freescale Communication Engine RISC core"), + ENUM_ENT(EM_M32C, "Renesas M32C"), + ENUM_ENT(EM_TSK3000, "Altium TSK3000 core"), + ENUM_ENT(EM_RS08, "Freescale RS08 embedded processor"), + ENUM_ENT(EM_SHARC, "EM_SHARC"), + ENUM_ENT(EM_ECOG2, "Cyan Technology eCOG2 microprocessor"), + ENUM_ENT(EM_SCORE7, "SUNPLUS S+Core"), + ENUM_ENT(EM_DSP24, "New Japan Radio (NJR) 24-bit DSP Processor"), + ENUM_ENT(EM_VIDEOCORE3, "Broadcom VideoCore III processor"), + ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"), + ENUM_ENT(EM_SE_C17, "Seiko Epson C17 family"), + ENUM_ENT(EM_TI_C6000, "Texas Instruments TMS320C6000 DSP family"), + ENUM_ENT(EM_TI_C2000, "Texas Instruments TMS320C2000 DSP family"), + ENUM_ENT(EM_TI_C5500, "Texas Instruments TMS320C55x DSP family"), + ENUM_ENT(EM_MMDSP_PLUS, "STMicroelectronics 64bit VLIW Data Signal Processor"), + ENUM_ENT(EM_CYPRESS_M8C, "Cypress M8C microprocessor"), + ENUM_ENT(EM_R32C, "Renesas R32C series microprocessors"), + ENUM_ENT(EM_TRIMEDIA, "NXP Semiconductors TriMedia architecture family"), + ENUM_ENT(EM_HEXAGON, "Qualcomm Hexagon"), + ENUM_ENT(EM_8051, "Intel 8051 and variants"), + ENUM_ENT(EM_STXP7X, "STMicroelectronics STxP7x family"), + ENUM_ENT(EM_NDS32, "Andes Technology compact code size embedded RISC processor family"), + ENUM_ENT(EM_ECOG1, "Cyan Technology eCOG1 microprocessor"), + ENUM_ENT(EM_ECOG1X, "Cyan Technology eCOG1X family"), + ENUM_ENT(EM_MAXQ30, "Dallas Semiconductor MAXQ30 Core microcontrollers"), + ENUM_ENT(EM_XIMO16, "New Japan Radio (NJR) 16-bit DSP Processor"), + ENUM_ENT(EM_MANIK, "M2000 Reconfigurable RISC Microprocessor"), + ENUM_ENT(EM_CRAYNV2, "Cray Inc. NV2 vector architecture"), + ENUM_ENT(EM_RX, "Renesas RX"), + ENUM_ENT(EM_METAG, "Imagination Technologies Meta processor architecture"), + ENUM_ENT(EM_MCST_ELBRUS, "MCST Elbrus general purpose hardware architecture"), + ENUM_ENT(EM_ECOG16, "Cyan Technology eCOG16 family"), + ENUM_ENT(EM_CR16, "Xilinx MicroBlaze"), + ENUM_ENT(EM_ETPU, "Freescale Extended Time Processing Unit"), + ENUM_ENT(EM_SLE9X, "Infineon Technologies SLE9X core"), + ENUM_ENT(EM_L10M, "EM_L10M"), + ENUM_ENT(EM_K10M, "EM_K10M"), + ENUM_ENT(EM_AARCH64, "AArch64"), + ENUM_ENT(EM_AVR32, "Atmel AVR 8-bit microcontroller"), + ENUM_ENT(EM_STM8, "STMicroeletronics STM8 8-bit microcontroller"), + ENUM_ENT(EM_TILE64, "Tilera TILE64 multicore architecture family"), + ENUM_ENT(EM_TILEPRO, "Tilera TILEPro multicore architecture family"), + ENUM_ENT(EM_CUDA, "NVIDIA CUDA architecture"), + ENUM_ENT(EM_TILEGX, "Tilera TILE-Gx multicore architecture family"), + ENUM_ENT(EM_CLOUDSHIELD, "EM_CLOUDSHIELD"), + ENUM_ENT(EM_COREA_1ST, "EM_COREA_1ST"), + ENUM_ENT(EM_COREA_2ND, "EM_COREA_2ND"), + ENUM_ENT(EM_ARC_COMPACT2, "EM_ARC_COMPACT2"), + ENUM_ENT(EM_OPEN8, "EM_OPEN8"), + ENUM_ENT(EM_RL78, "Renesas RL78"), + ENUM_ENT(EM_VIDEOCORE5, "Broadcom VideoCore V processor"), + ENUM_ENT(EM_78KOR, "EM_78KOR"), + ENUM_ENT(EM_56800EX, "EM_56800EX"), + ENUM_ENT(EM_AMDGPU, "EM_AMDGPU"), + ENUM_ENT(EM_WEBASSEMBLY, "EM_WEBASSEMBLY"), + ENUM_ENT(EM_LANAI, "EM_LANAI"), + ENUM_ENT(EM_BPF, "EM_BPF"), }; static const EnumEntry<unsigned> ElfSymbolBindings[] = { - { "Local", ELF::STB_LOCAL }, - { "Global", ELF::STB_GLOBAL }, - { "Weak", ELF::STB_WEAK }, - { "Unique", ELF::STB_GNU_UNIQUE } -}; + {"Local", "LOCAL", ELF::STB_LOCAL}, + {"Global", "GLOBAL", ELF::STB_GLOBAL}, + {"Weak", "WEAK", ELF::STB_WEAK}, + {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}}; + +static const EnumEntry<unsigned> ElfSymbolVisibilities[] = { + {"DEFAULT", "DEFAULT", ELF::STV_DEFAULT}, + {"INTERNAL", "INTERNAL", ELF::STV_INTERNAL}, + {"HIDDEN", "HIDDEN", ELF::STV_HIDDEN}, + {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}}; static const EnumEntry<unsigned> ElfSymbolTypes[] = { - { "None", ELF::STT_NOTYPE }, - { "Object", ELF::STT_OBJECT }, - { "Function", ELF::STT_FUNC }, - { "Section", ELF::STT_SECTION }, - { "File", ELF::STT_FILE }, - { "Common", ELF::STT_COMMON }, - { "TLS", ELF::STT_TLS }, - { "GNU_IFunc", ELF::STT_GNU_IFUNC } -}; + {"None", "NOTYPE", ELF::STT_NOTYPE}, + {"Object", "OBJECT", ELF::STT_OBJECT}, + {"Function", "FUNC", ELF::STT_FUNC}, + {"Section", "SECTION", ELF::STT_SECTION}, + {"File", "FILE", ELF::STT_FILE}, + {"Common", "COMMON", ELF::STT_COMMON}, + {"TLS", "TLS", ELF::STT_TLS}, + {"GNU_IFunc", "IFUNC", ELF::STT_GNU_IFUNC}}; static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = { { "AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL }, @@ -786,27 +1037,92 @@ static const char *getElfSectionType(unsigned Arch, unsigned Type) { } } +static const char *getGroupType(uint32_t Flag) { + if (Flag & ELF::GRP_COMDAT) + return "COMDAT"; + else + return "(unknown)"; +} + static const EnumEntry<unsigned> ElfSectionFlags[] = { - LLVM_READOBJ_ENUM_ENT(ELF, SHF_WRITE ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_ALLOC ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXCLUDE ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXECINSTR ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_MERGE ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_LINK_ORDER ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_OS_NONCONFORMING), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_GROUP ), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_TLS ), + ENUM_ENT(SHF_WRITE, "W"), + ENUM_ENT(SHF_ALLOC, "A"), + ENUM_ENT(SHF_EXCLUDE, "E"), + ENUM_ENT(SHF_EXECINSTR, "X"), + ENUM_ENT(SHF_MERGE, "M"), + ENUM_ENT(SHF_STRINGS, "S"), + ENUM_ENT(SHF_INFO_LINK, "I"), + ENUM_ENT(SHF_LINK_ORDER, "L"), + ENUM_ENT(SHF_OS_NONCONFORMING, "o"), + ENUM_ENT(SHF_GROUP, "G"), + ENUM_ENT(SHF_TLS, "T"), + ENUM_ENT(SHF_MASKOS, "o"), + ENUM_ENT(SHF_MASKPROC, "p"), + ENUM_ENT_1(SHF_COMPRESSED), +}; + +static const EnumEntry<unsigned> ElfXCoreSectionFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION), - LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION), - LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP ), + LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION) +}; + +static const EnumEntry<unsigned> ElfAMDGPUSectionFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_GLOBAL), LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_READONLY), LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_CODE), LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_AGENT) }; +static const EnumEntry<unsigned> ElfHexagonSectionFlags[] = { + LLVM_READOBJ_ENUM_ENT(ELF, SHF_HEX_GPREL) +}; + +static const EnumEntry<unsigned> ElfMipsSectionFlags[] = { + LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NODUPES), + LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NAMES ), + LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_LOCAL ), + LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP), + LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_GPREL ), + LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_MERGE ), + LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_ADDR ), + LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_STRING ) +}; + +static const EnumEntry<unsigned> ElfX86_64SectionFlags[] = { + LLVM_READOBJ_ENUM_ENT(ELF, SHF_X86_64_LARGE) +}; + +static std::string getGNUFlags(uint64_t Flags) { + std::string Str; + for (auto Entry : ElfSectionFlags) { + uint64_t Flag = Entry.Value & Flags; + Flags &= ~Entry.Value; + switch (Flag) { + case ELF::SHF_WRITE: + case ELF::SHF_ALLOC: + case ELF::SHF_EXECINSTR: + case ELF::SHF_MERGE: + case ELF::SHF_STRINGS: + case ELF::SHF_INFO_LINK: + case ELF::SHF_LINK_ORDER: + case ELF::SHF_OS_NONCONFORMING: + case ELF::SHF_GROUP: + case ELF::SHF_TLS: + case ELF::SHF_EXCLUDE: + Str += Entry.AltName; + break; + default: + if (Flag & ELF::SHF_MASKOS) + Str += "o"; + else if (Flag & ELF::SHF_MASKPROC) + Str += "p"; + else if (Flag) + Str += "x"; + } + } + return Str; +} + static const char *getElfSegmentType(unsigned Arch, unsigned Type) { // Check potentially overlapped processor-specific // program header type. @@ -851,6 +1167,53 @@ static const char *getElfSegmentType(unsigned Arch, unsigned Type) { } } +static std::string getElfPtType(unsigned Arch, unsigned Type) { + switch (Type) { + LLVM_READOBJ_PHDR_ENUM(ELF, PT_NULL) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_LOAD) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_DYNAMIC) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_INTERP) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_NOTE) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_SHLIB) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_PHDR) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_TLS) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_EH_FRAME) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_SUNW_UNWIND) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_STACK) + LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_RELRO) + default: + // All machine specific PT_* types + switch (Arch) { + case ELF::EM_AMDGPU: + switch (Type) { + LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM); + LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_AGENT); + LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_READONLY_AGENT); + LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_CODE_AGENT); + } + return ""; + case ELF::EM_ARM: + if (Type == ELF::PT_ARM_EXIDX) + return "EXIDX"; + return ""; + case ELF::EM_MIPS: + case ELF::EM_MIPS_RS3_LE: + switch (Type) { + case PT_MIPS_REGINFO: + return "REGINFO"; + case PT_MIPS_RTPROC: + return "RTPROC"; + case PT_MIPS_OPTIONS: + return "OPTIONS"; + case PT_MIPS_ABIFLAGS: + return "ABIFLAGS"; + } + return ""; + } + } + return std::string("<unknown>: ") + to_string(format_hex(Type, 1)); +} + static const EnumEntry<unsigned> ElfSegmentFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, PF_X), LLVM_READOBJ_ENUM_ENT(ELF, PF_W), @@ -903,14 +1266,52 @@ static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6) }; +static const EnumEntry<unsigned> ElfSymOtherFlags[] = { + LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL), + LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN), + LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED) +}; + +static const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = { + LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL), + LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT), + LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC), + LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS) +}; + +static const EnumEntry<unsigned> ElfMips16SymOtherFlags[] = { + LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL), + LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT), + LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16) +}; + +static const char *getElfMipsOptionsOdkType(unsigned Odk) { + switch (Odk) { + LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT); + LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE); + default: + return "Unknown"; + } +} + template <typename ELFT> -ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer) +ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, ScopedPrinter &Writer) : ObjDumper(Writer), Obj(Obj) { SmallVector<const Elf_Phdr *, 4> LoadSegments; for (const Elf_Phdr &Phdr : Obj->program_headers()) { if (Phdr.p_type == ELF::PT_DYNAMIC) { - DynamicProgHeader = &Phdr; + DynamicTable = createDRIFrom(&Phdr, sizeof(Elf_Dyn)); continue; } if (Phdr.p_type != ELF::PT_LOAD || Phdr.p_filesz == 0) @@ -918,8 +1319,54 @@ ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer) LoadSegments.push_back(&Phdr); } + for (const Elf_Shdr &Sec : Obj->sections()) { + switch (Sec.sh_type) { + case ELF::SHT_SYMTAB: + if (DotSymtabSec != nullptr) + reportError("Multilpe SHT_SYMTAB"); + DotSymtabSec = &Sec; + break; + case ELF::SHT_DYNSYM: + if (DynSymRegion.Size) + reportError("Multilpe SHT_DYNSYM"); + DynSymRegion = createDRIFrom(&Sec); + // This is only used (if Elf_Shdr present)for naming section in GNU style + DynSymtabName = unwrapOrError(Obj->getSectionName(&Sec)); + break; + case ELF::SHT_SYMTAB_SHNDX: + ShndxTable = unwrapOrError(Obj->getSHNDXTable(Sec)); + break; + case ELF::SHT_GNU_versym: + if (dot_gnu_version_sec != nullptr) + reportError("Multiple SHT_GNU_versym"); + dot_gnu_version_sec = &Sec; + break; + case ELF::SHT_GNU_verdef: + if (dot_gnu_version_d_sec != nullptr) + reportError("Multiple SHT_GNU_verdef"); + dot_gnu_version_d_sec = &Sec; + break; + case ELF::SHT_GNU_verneed: + if (dot_gnu_version_r_sec != nullptr) + reportError("Multilpe SHT_GNU_verneed"); + dot_gnu_version_r_sec = &Sec; + break; + } + } + + parseDynamicTable(LoadSegments); + + if (opts::Output == opts::GNU) + ELFDumperStyle.reset(new GNUStyle<ELFT>(Writer, this)); + else + ELFDumperStyle.reset(new LLVMStyle<ELFT>(Writer, this)); +} + +template <typename ELFT> +void ELFDumper<ELFT>::parseDynamicTable( + ArrayRef<const Elf_Phdr *> LoadSegments) { auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * { - const Elf_Phdr **I = std::upper_bound( + const Elf_Phdr *const *I = std::upper_bound( LoadSegments.begin(), LoadSegments.end(), VAddr, compareAddr<ELFT>); if (I == LoadSegments.begin()) report_fatal_error("Virtual address is not in any segment"); @@ -944,6 +1391,16 @@ ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer) GnuHashTable = reinterpret_cast<const Elf_GnuHash *>(toMappedAddr(Dyn.getPtr())); break; + case ELF::DT_STRTAB: + StringTableBegin = (const char *)toMappedAddr(Dyn.getPtr()); + break; + case ELF::DT_STRSZ: + StringTableSize = Dyn.getVal(); + break; + case ELF::DT_SYMTAB: + DynSymRegion.Addr = toMappedAddr(Dyn.getPtr()); + DynSymRegion.EntSize = sizeof(Elf_Sym); + break; case ELF::DT_RELA: DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr()); break; @@ -956,15 +1413,29 @@ ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer) case ELF::DT_SONAME: SONameOffset = Dyn.getVal(); break; - case ELF::DT_STRTAB: - StringTableBegin = (const char *)toMappedAddr(Dyn.getPtr()); + case ELF::DT_REL: + DynRelRegion.Addr = toMappedAddr(Dyn.getPtr()); break; - case ELF::DT_STRSZ: - StringTableSize = Dyn.getVal(); + case ELF::DT_RELSZ: + DynRelRegion.Size = Dyn.getVal(); break; - case ELF::DT_SYMTAB: - DynSymStart = - reinterpret_cast<const Elf_Sym *>(toMappedAddr(Dyn.getPtr())); + case ELF::DT_RELENT: + DynRelRegion.EntSize = Dyn.getVal(); + break; + case ELF::DT_PLTREL: + if (Dyn.getVal() == DT_REL) + DynPLTRelRegion.EntSize = sizeof(Elf_Rel); + else if (Dyn.getVal() == DT_RELA) + DynPLTRelRegion.EntSize = sizeof(Elf_Rela); + else + reportError(Twine("unknown DT_PLTREL value of ") + + Twine((uint64_t)Dyn.getVal())); + break; + case ELF::DT_JMPREL: + DynPLTRelRegion.Addr = toMappedAddr(Dyn.getPtr()); + break; + case ELF::DT_PLTRELSZ: + DynPLTRelRegion.Size = Dyn.getVal(); break; } } @@ -972,326 +1443,54 @@ ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer) DynamicStringTable = StringRef(StringTableBegin, StringTableSize); if (SONameOffset) SOName = getDynamicString(SONameOffset); - - for (const Elf_Shdr &Sec : Obj->sections()) { - switch (Sec.sh_type) { - case ELF::SHT_GNU_versym: - if (dot_gnu_version_sec != nullptr) - reportError("Multiple SHT_GNU_versym"); - dot_gnu_version_sec = &Sec; - break; - case ELF::SHT_GNU_verdef: - if (dot_gnu_version_d_sec != nullptr) - reportError("Multiple SHT_GNU_verdef"); - dot_gnu_version_d_sec = &Sec; - break; - case ELF::SHT_GNU_verneed: - if (dot_gnu_version_r_sec != nullptr) - reportError("Multilpe SHT_GNU_verneed"); - dot_gnu_version_r_sec = &Sec; - break; - case ELF::SHT_DYNSYM: - if (DotDynSymSec != nullptr) - reportError("Multilpe SHT_DYNSYM"); - DotDynSymSec = &Sec; - break; - case ELF::SHT_SYMTAB: - if (DotSymtabSec != nullptr) - reportError("Multilpe SHT_SYMTAB"); - DotSymtabSec = &Sec; - break; - case ELF::SHT_SYMTAB_SHNDX: { - ErrorOr<ArrayRef<Elf_Word>> TableOrErr = Obj->getSHNDXTable(Sec); - error(TableOrErr.getError()); - ShndxTable = *TableOrErr; - break; - } - } - } -} - -template <typename ELFT> -const typename ELFDumper<ELFT>::Elf_Rela * -ELFDumper<ELFT>::dyn_rela_begin() const { - if (DynRelaRegion.Size && DynRelaRegion.EntSize != sizeof(Elf_Rela)) - report_fatal_error("Invalid relocation entry size"); - return reinterpret_cast<const Elf_Rela *>(DynRelaRegion.Addr); } template <typename ELFT> -const typename ELFDumper<ELFT>::Elf_Rela * -ELFDumper<ELFT>::dyn_rela_end() const { - uint64_t Size = DynRelaRegion.Size; - if (Size % sizeof(Elf_Rela)) - report_fatal_error("Invalid relocation table size"); - return dyn_rela_begin() + Size / sizeof(Elf_Rela); +typename ELFDumper<ELFT>::Elf_Rel_Range ELFDumper<ELFT>::dyn_rels() const { + return DynRelRegion.getAsArrayRef<Elf_Rel>(); } template <typename ELFT> typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const { - return make_range(dyn_rela_begin(), dyn_rela_end()); + return DynRelaRegion.getAsArrayRef<Elf_Rela>(); } template<class ELFT> void ELFDumper<ELFT>::printFileHeaders() { - const Elf_Ehdr *Header = Obj->getHeader(); - - { - DictScope D(W, "ElfHeader"); - { - DictScope D(W, "Ident"); - W.printBinary("Magic", makeArrayRef(Header->e_ident).slice(ELF::EI_MAG0, - 4)); - W.printEnum ("Class", Header->e_ident[ELF::EI_CLASS], - makeArrayRef(ElfClass)); - W.printEnum ("DataEncoding", Header->e_ident[ELF::EI_DATA], - makeArrayRef(ElfDataEncoding)); - W.printNumber("FileVersion", Header->e_ident[ELF::EI_VERSION]); - - // Handle architecture specific OS/ABI values. - if (Header->e_machine == ELF::EM_AMDGPU && - Header->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA) - W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA); - else - W.printEnum ("OS/ABI", Header->e_ident[ELF::EI_OSABI], - makeArrayRef(ElfOSABI)); - W.printNumber("ABIVersion", Header->e_ident[ELF::EI_ABIVERSION]); - W.printBinary("Unused", makeArrayRef(Header->e_ident).slice(ELF::EI_PAD)); - } - - W.printEnum ("Type", Header->e_type, makeArrayRef(ElfObjectFileType)); - W.printEnum ("Machine", Header->e_machine, makeArrayRef(ElfMachineType)); - W.printNumber("Version", Header->e_version); - W.printHex ("Entry", Header->e_entry); - W.printHex ("ProgramHeaderOffset", Header->e_phoff); - W.printHex ("SectionHeaderOffset", Header->e_shoff); - if (Header->e_machine == EM_MIPS) - W.printFlags("Flags", Header->e_flags, makeArrayRef(ElfHeaderMipsFlags), - unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), - unsigned(ELF::EF_MIPS_MACH)); - else - W.printFlags("Flags", Header->e_flags); - W.printNumber("HeaderSize", Header->e_ehsize); - W.printNumber("ProgramHeaderEntrySize", Header->e_phentsize); - W.printNumber("ProgramHeaderCount", Header->e_phnum); - W.printNumber("SectionHeaderEntrySize", Header->e_shentsize); - W.printNumber("SectionHeaderCount", Header->e_shnum); - W.printNumber("StringTableSectionIndex", Header->e_shstrndx); - } + ELFDumperStyle->printFileHeaders(Obj); } template<class ELFT> void ELFDumper<ELFT>::printSections() { - ListScope SectionsD(W, "Sections"); - - int SectionIndex = -1; - for (const Elf_Shdr &Sec : Obj->sections()) { - ++SectionIndex; - - StringRef Name = errorOrDefault(Obj->getSectionName(&Sec)); - - DictScope SectionD(W, "Section"); - W.printNumber("Index", SectionIndex); - W.printNumber("Name", Name, Sec.sh_name); - W.printHex("Type", - getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type), - Sec.sh_type); - W.printFlags("Flags", Sec.sh_flags, makeArrayRef(ElfSectionFlags)); - W.printHex("Address", Sec.sh_addr); - W.printHex("Offset", Sec.sh_offset); - W.printNumber("Size", Sec.sh_size); - W.printNumber("Link", Sec.sh_link); - W.printNumber("Info", Sec.sh_info); - W.printNumber("AddressAlignment", Sec.sh_addralign); - W.printNumber("EntrySize", Sec.sh_entsize); - - if (opts::SectionRelocations) { - ListScope D(W, "Relocations"); - printRelocations(&Sec); - } - - if (opts::SectionSymbols) { - ListScope D(W, "Symbols"); - const Elf_Shdr *Symtab = DotSymtabSec; - ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab); - error(StrTableOrErr.getError()); - StringRef StrTable = *StrTableOrErr; - - for (const Elf_Sym &Sym : Obj->symbols(Symtab)) { - ErrorOr<const Elf_Shdr *> SymSec = - Obj->getSection(&Sym, Symtab, ShndxTable); - if (!SymSec) - continue; - if (*SymSec == &Sec) - printSymbol(&Sym, Symtab, StrTable, false); - } - } - - if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) { - ArrayRef<uint8_t> Data = errorOrDefault(Obj->getSectionContents(&Sec)); - W.printBinaryBlock("SectionData", - StringRef((const char *)Data.data(), Data.size())); - } - } + ELFDumperStyle->printSections(Obj); } template<class ELFT> void ELFDumper<ELFT>::printRelocations() { - ListScope D(W, "Relocations"); - - int SectionNumber = -1; - for (const Elf_Shdr &Sec : Obj->sections()) { - ++SectionNumber; - - if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA) - continue; - - StringRef Name = errorOrDefault(Obj->getSectionName(&Sec)); - - W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n"; - W.indent(); - - printRelocations(&Sec); - - W.unindent(); - W.startLine() << "}\n"; - } -} - -template<class ELFT> -void ELFDumper<ELFT>::printDynamicRelocations() { - W.startLine() << "Dynamic Relocations {\n"; - W.indent(); - for (const Elf_Rela &Rel : dyn_relas()) { - SmallString<32> RelocName; - Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); - StringRef SymbolName; - uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL()); - const Elf_Sym *Sym = DynSymStart + SymIndex; - SymbolName = errorOrDefault(Sym->getName(DynamicStringTable)); - if (opts::ExpandRelocs) { - DictScope Group(W, "Relocation"); - W.printHex("Offset", Rel.r_offset); - W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); - W.printString("Symbol", SymbolName.size() > 0 ? SymbolName : "-"); - W.printHex("Addend", Rel.r_addend); - } - else { - raw_ostream& OS = W.startLine(); - OS << W.hex(Rel.r_offset) << " " << RelocName << " " - << (SymbolName.size() > 0 ? SymbolName : "-") << " " - << W.hex(Rel.r_addend) << "\n"; - } - } - W.unindent(); - W.startLine() << "}\n"; -} - -template <class ELFT> -void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) { - ErrorOr<const Elf_Shdr *> SymTabOrErr = Obj->getSection(Sec->sh_link); - error(SymTabOrErr.getError()); - const Elf_Shdr *SymTab = *SymTabOrErr; - - switch (Sec->sh_type) { - case ELF::SHT_REL: - for (const Elf_Rel &R : Obj->rels(Sec)) { - Elf_Rela Rela; - Rela.r_offset = R.r_offset; - Rela.r_info = R.r_info; - Rela.r_addend = 0; - printRelocation(Rela, SymTab); - } - break; - case ELF::SHT_RELA: - for (const Elf_Rela &R : Obj->relas(Sec)) - printRelocation(R, SymTab); - break; - } + ELFDumperStyle->printRelocations(Obj); } -template <class ELFT> -void ELFDumper<ELFT>::printRelocation(Elf_Rela Rel, const Elf_Shdr *SymTab) { - SmallString<32> RelocName; - Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); - StringRef TargetName; - const Elf_Sym *Sym = Obj->getRelocationSymbol(&Rel, SymTab); - if (Sym && Sym->getType() == ELF::STT_SECTION) { - ErrorOr<const Elf_Shdr *> Sec = Obj->getSection(Sym, SymTab, ShndxTable); - error(Sec.getError()); - ErrorOr<StringRef> SecName = Obj->getSectionName(*Sec); - if (SecName) - TargetName = SecName.get(); - } else if (Sym) { - ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*SymTab); - error(StrTableOrErr.getError()); - TargetName = errorOrDefault(Sym->getName(*StrTableOrErr)); - } - - if (opts::ExpandRelocs) { - DictScope Group(W, "Relocation"); - W.printHex("Offset", Rel.r_offset); - W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); - W.printNumber("Symbol", TargetName.size() > 0 ? TargetName : "-", - Rel.getSymbol(Obj->isMips64EL())); - W.printHex("Addend", Rel.r_addend); - } else { - raw_ostream& OS = W.startLine(); - OS << W.hex(Rel.r_offset) << " " << RelocName << " " - << (TargetName.size() > 0 ? TargetName : "-") << " " - << W.hex(Rel.r_addend) << "\n"; - } +template <class ELFT> void ELFDumper<ELFT>::printProgramHeaders() { + ELFDumperStyle->printProgramHeaders(Obj); } -template<class ELFT> -void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) { - const Elf_Shdr *Symtab = (IsDynamic) ? DotDynSymSec : DotSymtabSec; - if (!Symtab) - return; - ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab); - error(StrTableOrErr.getError()); - StringRef StrTable = *StrTableOrErr; - for (const Elf_Sym &Sym : Obj->symbols(Symtab)) - printSymbol(&Sym, Symtab, StrTable, IsDynamic); +template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() { + ELFDumperStyle->printDynamicRelocations(Obj); } template<class ELFT> void ELFDumper<ELFT>::printSymbols() { - ListScope Group(W, "Symbols"); - printSymbolsHelper(false); + ELFDumperStyle->printSymbols(Obj); } template<class ELFT> void ELFDumper<ELFT>::printDynamicSymbols() { - ListScope Group(W, "DynamicSymbols"); - printSymbolsHelper(true); + ELFDumperStyle->printDynamicSymbols(Obj); } -template <class ELFT> -void ELFDumper<ELFT>::printSymbol(const Elf_Sym *Symbol, const Elf_Shdr *SymTab, - StringRef StrTable, bool IsDynamic) { - unsigned SectionIndex = 0; - StringRef SectionName; - getSectionNameIndex(*Obj, Symbol, SymTab, ShndxTable, SectionName, - SectionIndex); - std::string FullSymbolName = getFullSymbolName(Symbol, StrTable, IsDynamic); - unsigned char SymbolType = Symbol->getType(); - - DictScope D(W, "Symbol"); - W.printNumber("Name", FullSymbolName, Symbol->st_name); - W.printHex ("Value", Symbol->st_value); - W.printNumber("Size", Symbol->st_size); - W.printEnum ("Binding", Symbol->getBinding(), - makeArrayRef(ElfSymbolBindings)); - if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && - SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) - W.printEnum ("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes)); - else - W.printEnum ("Type", SymbolType, makeArrayRef(ElfSymbolTypes)); - W.printNumber("Other", Symbol->st_other); - W.printHex("Section", SectionName, SectionIndex); +template <class ELFT> void ELFDumper<ELFT>::printHashHistogram() { + ELFDumperStyle->printHashHistogram(Obj); } - #define LLVM_READOBJ_TYPE_CASE(name) \ case DT_##name: return #name @@ -1336,8 +1535,11 @@ static const char *getTypeString(uint64_t Type) { LLVM_READOBJ_TYPE_CASE(VERNEED); LLVM_READOBJ_TYPE_CASE(VERNEEDNUM); LLVM_READOBJ_TYPE_CASE(VERSYM); + LLVM_READOBJ_TYPE_CASE(RELACOUNT); LLVM_READOBJ_TYPE_CASE(RELCOUNT); LLVM_READOBJ_TYPE_CASE(GNU_HASH); + LLVM_READOBJ_TYPE_CASE(TLSDESC_PLT); + LLVM_READOBJ_TYPE_CASE(TLSDESC_GOT); LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION); LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP_REL); LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS); @@ -1444,6 +1646,7 @@ StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const { template <class ELFT> void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) { raw_ostream &OS = W.getOStream(); + const char* ConvChar = (opts::Output == opts::GNU) ? "0x%" PRIx64 : "0x%" PRIX64; switch (Type) { case DT_PLTREL: if (Value == DT_REL) { @@ -1478,8 +1681,9 @@ void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) { case DT_MIPS_RLD_MAP_REL: case DT_MIPS_PLTGOT: case DT_MIPS_OPTIONS: - OS << format("0x%" PRIX64, Value); + OS << format(ConvChar, Value); break; + case DT_RELACOUNT: case DT_RELCOUNT: case DT_VERDEFNUM: case DT_VERNEEDNUM: @@ -1521,7 +1725,7 @@ void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) { printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS); break; default: - OS << format("0x%" PRIX64, Value); + OS << format(ConvChar, Value); break; } } @@ -1545,8 +1749,8 @@ template <> void ELFDumper<ELFType<support::little, false>>::printUnwindInfo() { template<class ELFT> void ELFDumper<ELFT>::printDynamicTable() { - auto I = dynamic_table_begin(); - auto E = dynamic_table_end(); + auto I = dynamic_table().begin(); + auto E = dynamic_table().end(); if (I == E) return; @@ -1574,7 +1778,7 @@ void ELFDumper<ELFT>::printDynamicTable() { const Elf_Dyn &Entry = *I; uintX_t Tag = Entry.getTag(); ++I; - W.startLine() << " " << format_hex(Tag, Is64 ? 18 : 10, true) << " " + W.startLine() << " " << format_hex(Tag, Is64 ? 18 : 10, opts::Output != opts::GNU) << " " << format("%-21s", getTypeString(Tag)); printValue(Tag, Entry.getVal()); OS << "\n"; @@ -1601,24 +1805,6 @@ void ELFDumper<ELFT>::printNeededLibraries() { } } -template<class ELFT> -void ELFDumper<ELFT>::printProgramHeaders() { - ListScope L(W, "ProgramHeaders"); - - for (const Elf_Phdr &Phdr : Obj->program_headers()) { - DictScope P(W, "ProgramHeader"); - W.printHex("Type", - getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type), - Phdr.p_type); - W.printHex("Offset", Phdr.p_offset); - W.printHex("VirtualAddress", Phdr.p_vaddr); - W.printHex("PhysicalAddress", Phdr.p_paddr); - W.printNumber("FileSize", Phdr.p_filesz); - W.printNumber("MemSize", Phdr.p_memsz); - W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags)); - W.printNumber("Alignment", Phdr.p_align); - } -} template <typename ELFT> void ELFDumper<ELFT>::printHashTable() { @@ -1642,10 +1828,11 @@ void ELFDumper<ELFT>::printGnuHashTable() { W.printNumber("Shift Count", GnuHashTable->shift2); W.printHexList("Bloom Filter", GnuHashTable->filter()); W.printList("Buckets", GnuHashTable->buckets()); - if (!DotDynSymSec) + Elf_Sym_Range Syms = dynamic_symbols(); + unsigned NumSyms = std::distance(Syms.begin(), Syms.end()); + if (!NumSyms) reportError("No dynamic symbol section"); - W.printHexList("Values", - GnuHashTable->values(DotDynSymSec->getEntityCount())); + W.printHexList("Values", GnuHashTable->values(NumSyms)); } template <typename ELFT> void ELFDumper<ELFT>::printLoadName() { @@ -1669,21 +1856,18 @@ template <> void ELFDumper<ELFType<support::little, false>>::printAttributes() { if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES) continue; - ErrorOr<ArrayRef<uint8_t>> Contents = Obj->getSectionContents(&Sec); - if (!Contents) - continue; - - if ((*Contents)[0] != ARMBuildAttrs::Format_Version) { - errs() << "unrecognised FormatVersion: 0x" << utohexstr((*Contents)[0]) + ArrayRef<uint8_t> Contents = unwrapOrError(Obj->getSectionContents(&Sec)); + if (Contents[0] != ARMBuildAttrs::Format_Version) { + errs() << "unrecognised FormatVersion: 0x" << utohexstr(Contents[0]) << '\n'; continue; } - W.printHex("FormatVersion", (*Contents)[0]); - if (Contents->size() == 1) + W.printHex("FormatVersion", Contents[0]); + if (Contents.size() == 1) continue; - ARMAttributeParser(W).Parse(*Contents); + ARMAttributeParser(W).Parse(Contents); } } } @@ -1700,7 +1884,7 @@ public: typedef typename ELFO::Elf_Rela Elf_Rela; MipsGOTParser(ELFDumper<ELFT> *Dumper, const ELFO *Obj, - Elf_Dyn_Range DynTable, StreamWriter &W); + Elf_Dyn_Range DynTable, ScopedPrinter &W); void parseGOT(); void parsePLT(); @@ -1708,7 +1892,7 @@ public: private: ELFDumper<ELFT> *Dumper; const ELFO *Obj; - StreamWriter &W; + ScopedPrinter &W; llvm::Optional<uint64_t> DtPltGot; llvm::Optional<uint64_t> DtLocalGotNum; llvm::Optional<uint64_t> DtGotSym; @@ -1733,7 +1917,7 @@ private: template <class ELFT> MipsGOTParser<ELFT>::MipsGOTParser(ELFDumper<ELFT> *Dumper, const ELFO *Obj, - Elf_Dyn_Range DynTable, StreamWriter &W) + Elf_Dyn_Range DynTable, ScopedPrinter &W) : Dumper(Dumper), Obj(Obj), W(W) { for (const auto &Entry : DynTable) { switch (Entry.getTag()) { @@ -1773,44 +1957,33 @@ template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() { return; } - const Elf_Shdr *GOTShdr = findSectionByAddress(Obj, *DtPltGot); - if (!GOTShdr) { - W.startLine() << "There is no .got section in the file.\n"; - return; - } - - ErrorOr<ArrayRef<uint8_t>> GOT = Obj->getSectionContents(GOTShdr); - if (!GOT) { - W.startLine() << "The .got section is empty.\n"; - return; - } - - if (*DtLocalGotNum > getGOTTotal(*GOT)) { - W.startLine() << "MIPS_LOCAL_GOTNO exceeds a number of GOT entries.\n"; - return; - } - - const Elf_Shdr *DynSymSec = Dumper->getDotDynSymSec(); - ErrorOr<StringRef> StrTable = Obj->getStringTableForSymtab(*DynSymSec); - error(StrTable.getError()); - const Elf_Sym *DynSymBegin = Obj->symbol_begin(DynSymSec); - const Elf_Sym *DynSymEnd = Obj->symbol_end(DynSymSec); + StringRef StrTable = Dumper->getDynamicStringTable(); + const Elf_Sym *DynSymBegin = Dumper->dynamic_symbols().begin(); + const Elf_Sym *DynSymEnd = Dumper->dynamic_symbols().end(); std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd)); - if (*DtGotSym > DynSymTotal) { - W.startLine() << "MIPS_GOTSYM exceeds a number of dynamic symbols.\n"; - return; - } + if (*DtGotSym > DynSymTotal) + report_fatal_error("MIPS_GOTSYM exceeds a number of dynamic symbols"); std::size_t GlobalGotNum = DynSymTotal - *DtGotSym; - if (*DtLocalGotNum + GlobalGotNum > getGOTTotal(*GOT)) { - W.startLine() << "Number of global GOT entries exceeds the size of GOT.\n"; + if (*DtLocalGotNum + GlobalGotNum == 0) { + W.startLine() << "GOT is empty.\n"; return; } - const GOTEntry *GotBegin = makeGOTIter(*GOT, 0); - const GOTEntry *GotLocalEnd = makeGOTIter(*GOT, *DtLocalGotNum); + const Elf_Shdr *GOTShdr = findNotEmptySectionByAddress(Obj, *DtPltGot); + if (!GOTShdr) + report_fatal_error("There is no not empty GOT section at 0x" + + Twine::utohexstr(*DtPltGot)); + + ArrayRef<uint8_t> GOT = unwrapOrError(Obj->getSectionContents(GOTShdr)); + + if (*DtLocalGotNum + GlobalGotNum > getGOTTotal(GOT)) + report_fatal_error("Number of GOT entries exceeds the size of GOT section"); + + const GOTEntry *GotBegin = makeGOTIter(GOT, 0); + const GOTEntry *GotLocalEnd = makeGOTIter(GOT, *DtLocalGotNum); const GOTEntry *It = GotBegin; DictScope GS(W, "Primary GOT"); @@ -1842,16 +2015,16 @@ template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() { ListScope GS(W, "Global entries"); const GOTEntry *GotGlobalEnd = - makeGOTIter(*GOT, *DtLocalGotNum + GlobalGotNum); + makeGOTIter(GOT, *DtLocalGotNum + GlobalGotNum); const Elf_Sym *GotDynSym = DynSymBegin + *DtGotSym; for (; It != GotGlobalEnd; ++It) { DictScope D(W, "Entry"); - printGlobalGotEntry(GOTShdr->sh_addr, GotBegin, It, GotDynSym++, - *StrTable, true); + printGlobalGotEntry(GOTShdr->sh_addr, GotBegin, It, GotDynSym++, StrTable, + true); } } - std::size_t SpecGotNum = getGOTTotal(*GOT) - *DtLocalGotNum - GlobalGotNum; + std::size_t SpecGotNum = getGOTTotal(GOT) - *DtLocalGotNum - GlobalGotNum; W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum)); } @@ -1865,31 +2038,22 @@ template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() { return; } - const Elf_Shdr *PLTShdr = findSectionByAddress(Obj, *DtMipsPltGot); - if (!PLTShdr) { - W.startLine() << "There is no .got.plt section in the file.\n"; - return; - } - ErrorOr<ArrayRef<uint8_t>> PLT = Obj->getSectionContents(PLTShdr); - if (!PLT) { - W.startLine() << "The .got.plt section is empty.\n"; - return; - } + const Elf_Shdr *PLTShdr = findNotEmptySectionByAddress(Obj, *DtMipsPltGot); + if (!PLTShdr) + report_fatal_error("There is no not empty PLTGOT section at 0x " + + Twine::utohexstr(*DtMipsPltGot)); + ArrayRef<uint8_t> PLT = unwrapOrError(Obj->getSectionContents(PLTShdr)); - const Elf_Shdr *PLTRelShdr = findSectionByAddress(Obj, *DtJmpRel); - if (!PLTShdr) { - W.startLine() << "There is no .rel.plt section in the file.\n"; - return; - } - ErrorOr<const Elf_Shdr *> SymTableOrErr = - Obj->getSection(PLTRelShdr->sh_link); - error(SymTableOrErr.getError()); - const Elf_Shdr *SymTable = *SymTableOrErr; - ErrorOr<StringRef> StrTable = Obj->getStringTableForSymtab(*SymTable); - error(StrTable.getError()); + const Elf_Shdr *PLTRelShdr = findNotEmptySectionByAddress(Obj, *DtJmpRel); + if (!PLTRelShdr) + report_fatal_error("There is no not empty RELPLT section at 0x" + + Twine::utohexstr(*DtJmpRel)); + const Elf_Shdr *SymTable = + unwrapOrError(Obj->getSection(PLTRelShdr->sh_link)); + StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTable)); - const GOTEntry *PLTBegin = makeGOTIter(*PLT, 0); - const GOTEntry *PLTEnd = makeGOTIter(*PLT, getGOTTotal(*PLT)); + const GOTEntry *PLTBegin = makeGOTIter(PLT, 0); + const GOTEntry *PLTEnd = makeGOTIter(PLT, getGOTTotal(PLT)); const GOTEntry *It = PLTBegin; DictScope GS(W, "PLT GOT"); @@ -1908,7 +2072,7 @@ template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() { *RE = Obj->rel_end(PLTRelShdr); RI != RE && It != PLTEnd; ++RI, ++It) { const Elf_Sym *Sym = Obj->getRelocationSymbol(&*RI, SymTable); - printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, *StrTable, Sym); + printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, StrTable, Sym); } break; case ELF::SHT_RELA: @@ -1916,7 +2080,7 @@ template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() { *RE = Obj->rela_end(PLTRelShdr); RI != RE && It != PLTEnd; ++RI, ++It) { const Elf_Sym *Sym = Obj->getRelocationSymbol(&*RI, SymTable); - printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, *StrTable, Sym); + printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, StrTable, Sym); } break; } @@ -1956,7 +2120,7 @@ void MipsGOTParser<ELFT>::printGlobalGotEntry( unsigned SectionIndex = 0; StringRef SectionName; - getSectionNameIndex(*Obj, Sym, Dumper->getDotDynSymSec(), + getSectionNameIndex(*Obj, Sym, Dumper->dynamic_symbols().begin(), Dumper->getShndxTable(), SectionName, SectionIndex); W.printHex("Section", SectionName, SectionIndex); @@ -1990,7 +2154,7 @@ void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr, unsigned SectionIndex = 0; StringRef SectionName; - getSectionNameIndex(*Obj, Sym, Dumper->getDotDynSymSec(), + getSectionNameIndex(*Obj, Sym, Dumper->dynamic_symbols().begin(), Dumper->getShndxTable(), SectionName, SectionIndex); W.printHex("Section", SectionName, SectionIndex); @@ -2086,17 +2250,13 @@ template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() { W.startLine() << "There is no .MIPS.abiflags section in the file.\n"; return; } - ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr); - if (!Sec) { - W.startLine() << "The .MIPS.abiflags section is empty.\n"; - return; - } - if (Sec->size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) { + ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr)); + if (Sec.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) { W.startLine() << "The .MIPS.abiflags section has a wrong size.\n"; return; } - auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec->data()); + auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec.data()); raw_ostream &OS = W.getOStream(); DictScope GS(W, "MIPS ABI Flags"); @@ -2118,38 +2278,68 @@ template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() { W.printHex("Flags 2", Flags->flags2); } +template <class ELFT> +static void printMipsReginfoData(ScopedPrinter &W, + const Elf_Mips_RegInfo<ELFT> &Reginfo) { + W.printHex("GP", Reginfo.ri_gp_value); + W.printHex("General Mask", Reginfo.ri_gprmask); + W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]); + W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]); + W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]); + W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]); +} + template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() { const Elf_Shdr *Shdr = findSectionByName(*Obj, ".reginfo"); if (!Shdr) { W.startLine() << "There is no .reginfo section in the file.\n"; return; } - ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr); - if (!Sec) { - W.startLine() << "The .reginfo section is empty.\n"; + ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr)); + if (Sec.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) { + W.startLine() << "The .reginfo section has a wrong size.\n"; return; } - if (Sec->size() != sizeof(Elf_Mips_RegInfo<ELFT>)) { - W.startLine() << "The .reginfo section has a wrong size.\n"; + + DictScope GS(W, "MIPS RegInfo"); + auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec.data()); + printMipsReginfoData(W, *Reginfo); +} + +template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() { + const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.options"); + if (!Shdr) { + W.startLine() << "There is no .MIPS.options section in the file.\n"; return; } - auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec->data()); + DictScope GS(W, "MIPS Options"); - DictScope GS(W, "MIPS RegInfo"); - W.printHex("GP", Reginfo->ri_gp_value); - W.printHex("General Mask", Reginfo->ri_gprmask); - W.printHex("Co-Proc Mask0", Reginfo->ri_cprmask[0]); - W.printHex("Co-Proc Mask1", Reginfo->ri_cprmask[1]); - W.printHex("Co-Proc Mask2", Reginfo->ri_cprmask[2]); - W.printHex("Co-Proc Mask3", Reginfo->ri_cprmask[3]); + ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr)); + while (!Sec.empty()) { + if (Sec.size() < sizeof(Elf_Mips_Options<ELFT>)) { + W.startLine() << "The .MIPS.options section has a wrong size.\n"; + return; + } + auto *O = reinterpret_cast<const Elf_Mips_Options<ELFT> *>(Sec.data()); + DictScope GS(W, getElfMipsOptionsOdkType(O->kind)); + switch (O->kind) { + case ODK_REGINFO: + printMipsReginfoData(W, O->getRegInfo()); + break; + default: + W.startLine() << "Unsupported MIPS options tag.\n"; + break; + } + Sec = Sec.slice(O->size); + } } template <class ELFT> void ELFDumper<ELFT>::printStackMap() const { const Elf_Shdr *StackMapSection = nullptr; for (const auto &Sec : Obj->sections()) { - ErrorOr<StringRef> Name = Obj->getSectionName(&Sec); - if (*Name == ".llvm_stackmaps") { + StringRef Name = unwrapOrError(Obj->getSectionName(&Sec)); + if (Name == ".llvm_stackmaps") { StackMapSection = &Sec; break; } @@ -2159,10 +2349,1184 @@ template <class ELFT> void ELFDumper<ELFT>::printStackMap() const { return; StringRef StackMapContents; - ErrorOr<ArrayRef<uint8_t>> StackMapContentsArray = - Obj->getSectionContents(StackMapSection); + ArrayRef<uint8_t> StackMapContentsArray = + unwrapOrError(Obj->getSectionContents(StackMapSection)); + + prettyPrintStackMap(llvm::outs(), StackMapV1Parser<ELFT::TargetEndianness>( + StackMapContentsArray)); +} + +template <class ELFT> void ELFDumper<ELFT>::printGroupSections() { + ELFDumperStyle->printGroupSections(Obj); +} + +static inline void printFields(formatted_raw_ostream &OS, StringRef Str1, + StringRef Str2) { + OS.PadToColumn(2u); + OS << Str1; + OS.PadToColumn(37u); + OS << Str2 << "\n"; + OS.flush(); +} + +template <class ELFT> void GNUStyle<ELFT>::printFileHeaders(const ELFO *Obj) { + const Elf_Ehdr *e = Obj->getHeader(); + OS << "ELF Header:\n"; + OS << " Magic: "; + std::string Str; + for (int i = 0; i < ELF::EI_NIDENT; i++) + OS << format(" %02x", static_cast<int>(e->e_ident[i])); + OS << "\n"; + Str = printEnum(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); + printFields(OS, "Class:", Str); + Str = printEnum(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding)); + printFields(OS, "Data:", Str); + OS.PadToColumn(2u); + OS << "Version:"; + OS.PadToColumn(37u); + OS << to_hexString(e->e_ident[ELF::EI_VERSION]); + if (e->e_version == ELF::EV_CURRENT) + OS << " (current)"; + OS << "\n"; + Str = printEnum(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI)); + printFields(OS, "OS/ABI:", Str); + Str = "0x" + to_hexString(e->e_version); + Str = to_hexString(e->e_ident[ELF::EI_ABIVERSION]); + printFields(OS, "ABI Version:", Str); + Str = printEnum(e->e_type, makeArrayRef(ElfObjectFileType)); + printFields(OS, "Type:", Str); + Str = printEnum(e->e_machine, makeArrayRef(ElfMachineType)); + printFields(OS, "Machine:", Str); + Str = "0x" + to_hexString(e->e_version); + printFields(OS, "Version:", Str); + Str = "0x" + to_hexString(e->e_entry); + printFields(OS, "Entry point address:", Str); + Str = to_string(e->e_phoff) + " (bytes into file)"; + printFields(OS, "Start of program headers:", Str); + Str = to_string(e->e_shoff) + " (bytes into file)"; + printFields(OS, "Start of section headers:", Str); + Str = "0x" + to_hexString(e->e_flags); + printFields(OS, "Flags:", Str); + Str = to_string(e->e_ehsize) + " (bytes)"; + printFields(OS, "Size of this header:", Str); + Str = to_string(e->e_phentsize) + " (bytes)"; + printFields(OS, "Size of program headers:", Str); + Str = to_string(e->e_phnum); + printFields(OS, "Number of program headers:", Str); + Str = to_string(e->e_shentsize) + " (bytes)"; + printFields(OS, "Size of section headers:", Str); + Str = to_string(e->e_shnum); + printFields(OS, "Number of section headers:", Str); + Str = to_string(e->e_shstrndx); + printFields(OS, "Section header string table index:", Str); +} + +template <class ELFT> void GNUStyle<ELFT>::printGroupSections(const ELFO *Obj) { + uint32_t SectionIndex = 0; + bool HasGroups = false; + for (const Elf_Shdr &Sec : Obj->sections()) { + if (Sec.sh_type == ELF::SHT_GROUP) { + HasGroups = true; + const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link)); + StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab)); + const Elf_Sym *Signature = + Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info); + ArrayRef<Elf_Word> Data = unwrapOrError( + Obj->template getSectionContentsAsArray<Elf_Word>(&Sec)); + StringRef Name = unwrapOrError(Obj->getSectionName(&Sec)); + OS << "\n" << getGroupType(Data[0]) << " group section [" + << format_decimal(SectionIndex, 5) << "] `" << Name << "' [" + << StrTable.data() + Signature->st_name << "] contains " + << (Data.size() - 1) << " sections:\n" + << " [Index] Name\n"; + for (auto &Ndx : Data.slice(1)) { + auto Sec = unwrapOrError(Obj->getSection(Ndx)); + const StringRef Name = unwrapOrError(Obj->getSectionName(Sec)); + OS << " [" << format_decimal(Ndx, 5) << "] " << Name + << "\n"; + } + } + ++SectionIndex; + } + if (!HasGroups) + OS << "There are no section groups in this file.\n"; +} + +template <class ELFT> +void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab, + const Elf_Rela &R, bool IsRela) { + std::string Offset, Info, Addend = "", Value; + SmallString<32> RelocName; + StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab)); + StringRef TargetName; + const Elf_Sym *Sym = nullptr; + unsigned Width = ELFT::Is64Bits ? 16 : 8; + unsigned Bias = ELFT::Is64Bits ? 8 : 0; + + // First two fields are bit width dependent. The rest of them are after are + // fixed width. + Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias}; + Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName); + Sym = Obj->getRelocationSymbol(&R, SymTab); + if (Sym && Sym->getType() == ELF::STT_SECTION) { + const Elf_Shdr *Sec = unwrapOrError( + Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable())); + TargetName = unwrapOrError(Obj->getSectionName(Sec)); + } else if (Sym) { + TargetName = unwrapOrError(Sym->getName(StrTable)); + } + + if (Sym && IsRela) { + if (R.r_addend < 0) + Addend = " - "; + else + Addend = " + "; + } + + Offset = to_string(format_hex_no_prefix(R.r_offset, Width)); + Info = to_string(format_hex_no_prefix(R.r_info, Width)); + + int64_t RelAddend = R.r_addend; + if (IsRela) + Addend += to_hexString(std::abs(RelAddend), false); + + if (Sym) + Value = to_string(format_hex_no_prefix(Sym->getValue(), Width)); + + Fields[0].Str = Offset; + Fields[1].Str = Info; + Fields[2].Str = RelocName; + Fields[3].Str = Value; + Fields[4].Str = TargetName; + for (auto &field : Fields) + printField(field); + OS << Addend; + OS << "\n"; +} + +static inline void printRelocHeader(raw_ostream &OS, bool Is64, bool IsRela) { + if (Is64) + OS << " Offset Info Type" + << " Symbol's Value Symbol's Name"; + else + OS << " Offset Info Type Sym. Value " + << "Symbol's Name"; + if (IsRela) + OS << (IsRela ? " + Addend" : ""); + OS << "\n"; +} + +template <class ELFT> void GNUStyle<ELFT>::printRelocations(const ELFO *Obj) { + bool HasRelocSections = false; + for (const Elf_Shdr &Sec : Obj->sections()) { + if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA) + continue; + HasRelocSections = true; + StringRef Name = unwrapOrError(Obj->getSectionName(&Sec)); + unsigned Entries = Sec.getEntityCount(); + uintX_t Offset = Sec.sh_offset; + OS << "\nRelocation section '" << Name << "' at offset 0x" + << to_hexString(Offset, false) << " contains " << Entries + << " entries:\n"; + printRelocHeader(OS, ELFT::Is64Bits, (Sec.sh_type == ELF::SHT_RELA)); + const Elf_Shdr *SymTab = unwrapOrError(Obj->getSection(Sec.sh_link)); + if (Sec.sh_type == ELF::SHT_REL) { + for (const auto &R : Obj->rels(&Sec)) { + Elf_Rela Rela; + Rela.r_offset = R.r_offset; + Rela.r_info = R.r_info; + Rela.r_addend = 0; + printRelocation(Obj, SymTab, Rela, false); + } + } else { + for (const auto &R : Obj->relas(&Sec)) + printRelocation(Obj, SymTab, R, true); + } + } + if (!HasRelocSections) + OS << "\nThere are no relocations in this file.\n"; +} + +std::string getSectionTypeString(unsigned Arch, unsigned Type) { + using namespace ELF; + switch (Arch) { + case EM_ARM: + switch (Type) { + case SHT_ARM_EXIDX: + return "ARM_EXIDX"; + case SHT_ARM_PREEMPTMAP: + return "ARM_PREEMPTMAP"; + case SHT_ARM_ATTRIBUTES: + return "ARM_ATTRIBUTES"; + case SHT_ARM_DEBUGOVERLAY: + return "ARM_DEBUGOVERLAY"; + case SHT_ARM_OVERLAYSECTION: + return "ARM_OVERLAYSECTION"; + } + case EM_X86_64: + switch (Type) { + case SHT_X86_64_UNWIND: + return "X86_64_UNWIND"; + } + case EM_MIPS: + case EM_MIPS_RS3_LE: + switch (Type) { + case SHT_MIPS_REGINFO: + return "MIPS_REGINFO"; + case SHT_MIPS_OPTIONS: + return "MIPS_OPTIONS"; + case SHT_MIPS_ABIFLAGS: + return "MIPS_ABIFLAGS"; + } + } + switch (Type) { + case SHT_NULL: + return "NULL"; + case SHT_PROGBITS: + return "PROGBITS"; + case SHT_SYMTAB: + return "SYMTAB"; + case SHT_STRTAB: + return "STRTAB"; + case SHT_RELA: + return "RELA"; + case SHT_HASH: + return "HASH"; + case SHT_DYNAMIC: + return "DYNAMIC"; + case SHT_NOTE: + return "NOTE"; + case SHT_NOBITS: + return "NOBITS"; + case SHT_REL: + return "REL"; + case SHT_SHLIB: + return "SHLIB"; + case SHT_DYNSYM: + return "DYNSYM"; + case SHT_INIT_ARRAY: + return "INIT_ARRAY"; + case SHT_FINI_ARRAY: + return "FINI_ARRAY"; + case SHT_PREINIT_ARRAY: + return "PREINIT_ARRAY"; + case SHT_GROUP: + return "GROUP"; + case SHT_SYMTAB_SHNDX: + return "SYMTAB SECTION INDICES"; + // FIXME: Parse processor specific GNU attributes + case SHT_GNU_ATTRIBUTES: + return "ATTRIBUTES"; + case SHT_GNU_HASH: + return "GNU_HASH"; + case SHT_GNU_verdef: + return "VERDEF"; + case SHT_GNU_verneed: + return "VERNEED"; + case SHT_GNU_versym: + return "VERSYM"; + default: + return ""; + } + return ""; +} + +template <class ELFT> void GNUStyle<ELFT>::printSections(const ELFO *Obj) { + size_t SectionIndex = 0; + std::string Number, Type, Size, Address, Offset, Flags, Link, Info, EntrySize, + Alignment; + unsigned Bias; + unsigned Width; + + if (ELFT::Is64Bits) { + Bias = 0; + Width = 16; + } else { + Bias = 8; + Width = 8; + } + OS << "There are " << to_string(Obj->getHeader()->e_shnum) + << " section headers, starting at offset " + << "0x" << to_hexString(Obj->getHeader()->e_shoff, false) << ":\n\n"; + OS << "Section Headers:\n"; + Field Fields[11] = {{"[Nr]", 2}, + {"Name", 7}, + {"Type", 25}, + {"Address", 41}, + {"Off", 58 - Bias}, + {"Size", 65 - Bias}, + {"ES", 72 - Bias}, + {"Flg", 75 - Bias}, + {"Lk", 79 - Bias}, + {"Inf", 82 - Bias}, + {"Al", 86 - Bias}}; + for (auto &f : Fields) + printField(f); + OS << "\n"; + + for (const Elf_Shdr &Sec : Obj->sections()) { + Number = to_string(SectionIndex); + Fields[0].Str = Number; + Fields[1].Str = unwrapOrError(Obj->getSectionName(&Sec)); + Type = getSectionTypeString(Obj->getHeader()->e_machine, Sec.sh_type); + Fields[2].Str = Type; + Address = to_string(format_hex_no_prefix(Sec.sh_addr, Width)); + Fields[3].Str = Address; + Offset = to_string(format_hex_no_prefix(Sec.sh_offset, 6)); + Fields[4].Str = Offset; + Size = to_string(format_hex_no_prefix(Sec.sh_size, 6)); + Fields[5].Str = Size; + EntrySize = to_string(format_hex_no_prefix(Sec.sh_entsize, 2)); + Fields[6].Str = EntrySize; + Flags = getGNUFlags(Sec.sh_flags); + Fields[7].Str = Flags; + Link = to_string(Sec.sh_link); + Fields[8].Str = Link; + Info = to_string(Sec.sh_info); + Fields[9].Str = Info; + Alignment = to_string(Sec.sh_addralign); + Fields[10].Str = Alignment; + OS.PadToColumn(Fields[0].Column); + OS << "[" << right_justify(Fields[0].Str, 2) << "]"; + for (int i = 1; i < 7; i++) + printField(Fields[i]); + OS.PadToColumn(Fields[7].Column); + OS << right_justify(Fields[7].Str, 3); + OS.PadToColumn(Fields[8].Column); + OS << right_justify(Fields[8].Str, 2); + OS.PadToColumn(Fields[9].Column); + OS << right_justify(Fields[9].Str, 3); + OS.PadToColumn(Fields[10].Column); + OS << right_justify(Fields[10].Str, 2); + OS << "\n"; + ++SectionIndex; + } + OS << "Key to Flags:\n" + << " W (write), A (alloc), X (execute), M (merge), S (strings), l " + "(large)\n" + << " I (info), L (link order), G (group), T (TLS), E (exclude),\ + x (unknown)\n" + << " O (extra OS processing required) o (OS specific),\ + p (processor specific)\n"; +} + +template <class ELFT> +void GNUStyle<ELFT>::printSymtabMessage(const ELFO *Obj, StringRef Name, + size_t Entries) { + if (Name.size()) + OS << "\nSymbol table '" << Name << "' contains " << Entries + << " entries:\n"; + else + OS << "\n Symbol table for image:\n"; + + if (ELFT::Is64Bits) + OS << " Num: Value Size Type Bind Vis Ndx Name\n"; + else + OS << " Num: Value Size Type Bind Vis Ndx Name\n"; +} + +template <class ELFT> +std::string GNUStyle<ELFT>::getSymbolSectionNdx(const ELFO *Obj, + const Elf_Sym *Symbol, + const Elf_Sym *FirstSym) { + unsigned SectionIndex = Symbol->st_shndx; + switch (SectionIndex) { + case ELF::SHN_UNDEF: + return "UND"; + case ELF::SHN_ABS: + return "ABS"; + case ELF::SHN_COMMON: + return "COM"; + case ELF::SHN_XINDEX: + SectionIndex = Obj->getExtendedSymbolTableIndex( + Symbol, FirstSym, this->dumper()->getShndxTable()); + default: + // Find if: + // Processor specific + if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC) + return std::string("PRC[0x") + + to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; + // OS specific + if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS) + return std::string("OS[0x") + + to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; + // Architecture reserved: + if (SectionIndex >= ELF::SHN_LORESERVE && + SectionIndex <= ELF::SHN_HIRESERVE) + return std::string("RSV[0x") + + to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; + // A normal section with an index + return to_string(format_decimal(SectionIndex, 3)); + } +} + +template <class ELFT> +void GNUStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, + const Elf_Sym *FirstSym, StringRef StrTable, + bool IsDynamic) { + static int Idx = 0; + static bool Dynamic = true; + size_t Width; + + // If this function was called with a different value from IsDynamic + // from last call, happens when we move from dynamic to static symbol + // table, "Num" field should be reset. + if (!Dynamic != !IsDynamic) { + Idx = 0; + Dynamic = false; + } + std::string Num, Name, Value, Size, Binding, Type, Visibility, Section; + unsigned Bias = 0; + if (ELFT::Is64Bits) { + Bias = 8; + Width = 16; + } else { + Bias = 0; + Width = 8; + } + Field Fields[8] = {0, 8, 17 + Bias, 23 + Bias, + 31 + Bias, 38 + Bias, 47 + Bias, 51 + Bias}; + Num = to_string(format_decimal(Idx++, 6)) + ":"; + Value = to_string(format_hex_no_prefix(Symbol->st_value, Width)); + Size = to_string(format_decimal(Symbol->st_size, 5)); + unsigned char SymbolType = Symbol->getType(); + if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && + SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) + Type = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); + else + Type = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes)); + unsigned Vis = Symbol->getVisibility(); + Binding = printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); + Visibility = printEnum(Vis, makeArrayRef(ElfSymbolVisibilities)); + Section = getSymbolSectionNdx(Obj, Symbol, FirstSym); + Name = this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic); + Fields[0].Str = Num; + Fields[1].Str = Value; + Fields[2].Str = Size; + Fields[3].Str = Type; + Fields[4].Str = Binding; + Fields[5].Str = Visibility; + Fields[6].Str = Section; + Fields[7].Str = Name; + for (auto &Entry : Fields) + printField(Entry); + OS << "\n"; +} + +template <class ELFT> void GNUStyle<ELFT>::printSymbols(const ELFO *Obj) { + this->dumper()->printSymbolsHelper(true); + this->dumper()->printSymbolsHelper(false); +} + +template <class ELFT> +void GNUStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) { + this->dumper()->printSymbolsHelper(true); +} + +static inline std::string printPhdrFlags(unsigned Flag) { + std::string Str; + Str = (Flag & PF_R) ? "R" : " "; + Str += (Flag & PF_W) ? "W" : " "; + Str += (Flag & PF_X) ? "E" : " "; + return Str; +} + +// SHF_TLS sections are only in PT_TLS, PT_LOAD or PT_GNU_RELRO +// PT_TLS must only have SHF_TLS sections +template <class ELFT> +bool GNUStyle<ELFT>::checkTLSSections(const Elf_Phdr &Phdr, + const Elf_Shdr &Sec) { + return (((Sec.sh_flags & ELF::SHF_TLS) && + ((Phdr.p_type == ELF::PT_TLS) || (Phdr.p_type == ELF::PT_LOAD) || + (Phdr.p_type == ELF::PT_GNU_RELRO))) || + (!(Sec.sh_flags & ELF::SHF_TLS) && Phdr.p_type != ELF::PT_TLS)); +} + +// Non-SHT_NOBITS must have its offset inside the segment +// Only non-zero section can be at end of segment +template <class ELFT> +bool GNUStyle<ELFT>::checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) { + if (Sec.sh_type == ELF::SHT_NOBITS) + return true; + bool IsSpecial = + (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0); + // .tbss is special, it only has memory in PT_TLS and has NOBITS properties + auto SectionSize = + (IsSpecial && Phdr.p_type != ELF::PT_TLS) ? 0 : Sec.sh_size; + if (Sec.sh_offset >= Phdr.p_offset) + return ((Sec.sh_offset + SectionSize <= Phdr.p_filesz + Phdr.p_offset) + /*only non-zero sized sections at end*/ && + (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz)); + return false; +} + +// SHF_ALLOC must have VMA inside segment +// Only non-zero section can be at end of segment +template <class ELFT> +bool GNUStyle<ELFT>::checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) { + if (!(Sec.sh_flags & ELF::SHF_ALLOC)) + return true; + bool IsSpecial = + (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0); + // .tbss is special, it only has memory in PT_TLS and has NOBITS properties + auto SectionSize = + (IsSpecial && Phdr.p_type != ELF::PT_TLS) ? 0 : Sec.sh_size; + if (Sec.sh_addr >= Phdr.p_vaddr) + return ((Sec.sh_addr + SectionSize <= Phdr.p_vaddr + Phdr.p_memsz) && + (Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz)); + return false; +} + +// No section with zero size must be at start or end of PT_DYNAMIC +template <class ELFT> +bool GNUStyle<ELFT>::checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) { + if (Phdr.p_type != ELF::PT_DYNAMIC || Sec.sh_size != 0 || Phdr.p_memsz == 0) + return true; + // Is section within the phdr both based on offset and VMA ? + return ((Sec.sh_type == ELF::SHT_NOBITS) || + (Sec.sh_offset > Phdr.p_offset && + Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz)) && + (!(Sec.sh_flags & ELF::SHF_ALLOC) || + (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz)); +} + +template <class ELFT> +void GNUStyle<ELFT>::printProgramHeaders(const ELFO *Obj) { + unsigned Bias = ELFT::Is64Bits ? 8 : 0; + unsigned Width = ELFT::Is64Bits ? 18 : 10; + unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7; + std::string Type, Offset, VMA, LMA, FileSz, MemSz, Flag, Align; + + const Elf_Ehdr *Header = Obj->getHeader(); + Field Fields[8] = {2, 17, 26, 37 + Bias, + 48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias}; + OS << "\nElf file type is " + << printEnum(Header->e_type, makeArrayRef(ElfObjectFileType)) << "\n" + << "Entry point " << format_hex(Header->e_entry, 3) << "\n" + << "There are " << Header->e_phnum << " program headers," + << " starting at offset " << Header->e_phoff << "\n\n" + << "Program Headers:\n"; + if (ELFT::Is64Bits) + OS << " Type Offset VirtAddr PhysAddr " + << " FileSiz MemSiz Flg Align\n"; + else + OS << " Type Offset VirtAddr PhysAddr FileSiz " + << "MemSiz Flg Align\n"; + for (const auto &Phdr : Obj->program_headers()) { + Type = getElfPtType(Header->e_machine, Phdr.p_type); + Offset = to_string(format_hex(Phdr.p_offset, 8)); + VMA = to_string(format_hex(Phdr.p_vaddr, Width)); + LMA = to_string(format_hex(Phdr.p_paddr, Width)); + FileSz = to_string(format_hex(Phdr.p_filesz, SizeWidth)); + MemSz = to_string(format_hex(Phdr.p_memsz, SizeWidth)); + Flag = printPhdrFlags(Phdr.p_flags); + Align = to_string(format_hex(Phdr.p_align, 1)); + Fields[0].Str = Type; + Fields[1].Str = Offset; + Fields[2].Str = VMA; + Fields[3].Str = LMA; + Fields[4].Str = FileSz; + Fields[5].Str = MemSz; + Fields[6].Str = Flag; + Fields[7].Str = Align; + for (auto Field : Fields) + printField(Field); + if (Phdr.p_type == ELF::PT_INTERP) { + OS << "\n [Requesting program interpreter: "; + OS << reinterpret_cast<const char *>(Obj->base()) + Phdr.p_offset << "]"; + } + OS << "\n"; + } + OS << "\n Section to Segment mapping:\n Segment Sections...\n"; + int Phnum = 0; + for (const Elf_Phdr &Phdr : Obj->program_headers()) { + std::string Sections; + OS << format(" %2.2d ", Phnum++); + for (const Elf_Shdr &Sec : Obj->sections()) { + // Check if each section is in a segment and then print mapping. + // readelf additionally makes sure it does not print zero sized sections + // at end of segments and for PT_DYNAMIC both start and end of section + // .tbss must only be shown in PT_TLS section. + bool TbssInNonTLS = (Sec.sh_type == ELF::SHT_NOBITS) && + ((Sec.sh_flags & ELF::SHF_TLS) != 0) && + Phdr.p_type != ELF::PT_TLS; + if (!TbssInNonTLS && checkTLSSections(Phdr, Sec) && + checkoffsets(Phdr, Sec) && checkVMA(Phdr, Sec) && + checkPTDynamic(Phdr, Sec) && (Sec.sh_type != ELF::SHT_NULL)) + Sections += unwrapOrError(Obj->getSectionName(&Sec)).str() + " "; + } + OS << Sections << "\n"; + OS.flush(); + } +} + +template <class ELFT> +void GNUStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela R, + bool IsRela) { + SmallString<32> RelocName; + StringRef SymbolName; + unsigned Width = ELFT::Is64Bits ? 16 : 8; + unsigned Bias = ELFT::Is64Bits ? 8 : 0; + // First two fields are bit width dependent. The rest of them are after are + // fixed width. + Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias}; + + uint32_t SymIndex = R.getSymbol(Obj->isMips64EL()); + const Elf_Sym *Sym = this->dumper()->dynamic_symbols().begin() + SymIndex; + Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName); + SymbolName = + unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable())); + std::string Addend = "", Info, Offset, Value; + Offset = to_string(format_hex_no_prefix(R.r_offset, Width)); + Info = to_string(format_hex_no_prefix(R.r_info, Width)); + Value = to_string(format_hex_no_prefix(Sym->getValue(), Width)); + int64_t RelAddend = R.r_addend; + if (SymbolName.size() && IsRela) { + if (R.r_addend < 0) + Addend = " - "; + else + Addend = " + "; + } + + if (!SymbolName.size() && Sym->getValue() == 0) + Value = ""; + + if (IsRela) + Addend += to_string(format_hex_no_prefix(std::abs(RelAddend), 1)); + + + Fields[0].Str = Offset; + Fields[1].Str = Info; + Fields[2].Str = RelocName.c_str(); + Fields[3].Str = Value; + Fields[4].Str = SymbolName; + for (auto &Field : Fields) + printField(Field); + OS << Addend; + OS << "\n"; +} + +template <class ELFT> +void GNUStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) { + const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion(); + const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion(); + const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion(); + if (DynRelaRegion.Size > 0) { + OS << "\n'RELA' relocation section at offset " + << format_hex(reinterpret_cast<const uint8_t *>(DynRelaRegion.Addr) - + Obj->base(), + 1) << " contains " << DynRelaRegion.Size << " bytes:\n"; + printRelocHeader(OS, ELFT::Is64Bits, true); + for (const Elf_Rela &Rela : this->dumper()->dyn_relas()) + printDynamicRelocation(Obj, Rela, true); + } + if (DynRelRegion.Size > 0) { + OS << "\n'REL' relocation section at offset " + << format_hex(reinterpret_cast<const uint8_t *>(DynRelRegion.Addr) - + Obj->base(), + 1) << " contains " << DynRelRegion.Size << " bytes:\n"; + printRelocHeader(OS, ELFT::Is64Bits, false); + for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) { + Elf_Rela Rela; + Rela.r_offset = Rel.r_offset; + Rela.r_info = Rel.r_info; + Rela.r_addend = 0; + printDynamicRelocation(Obj, Rela, false); + } + } + if (DynPLTRelRegion.Size) { + OS << "\n'PLT' relocation section at offset " + << format_hex(reinterpret_cast<const uint8_t *>(DynPLTRelRegion.Addr) - + Obj->base(), + 1) << " contains " << DynPLTRelRegion.Size << " bytes:\n"; + } + if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) { + printRelocHeader(OS, ELFT::Is64Bits, true); + for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>()) + printDynamicRelocation(Obj, Rela, true); + } else { + printRelocHeader(OS, ELFT::Is64Bits, false); + for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) { + Elf_Rela Rela; + Rela.r_offset = Rel.r_offset; + Rela.r_info = Rel.r_info; + Rela.r_addend = 0; + printDynamicRelocation(Obj, Rela, false); + } + } +} + +// Hash histogram shows statistics of how efficient the hash was for the +// dynamic symbol table. The table shows number of hash buckets for different +// lengths of chains as absolute number and percentage of the total buckets. +// Additionally cumulative coverage of symbols for each set of buckets. +template <class ELFT> +void GNUStyle<ELFT>::printHashHistogram(const ELFFile<ELFT> *Obj) { + + const Elf_Hash *HashTable = this->dumper()->getHashTable(); + const Elf_GnuHash *GnuHashTable = this->dumper()->getGnuHashTable(); + + // Print histogram for .hash section + if (HashTable) { + size_t NBucket = HashTable->nbucket; + size_t NChain = HashTable->nchain; + ArrayRef<Elf_Word> Buckets = HashTable->buckets(); + ArrayRef<Elf_Word> Chains = HashTable->chains(); + size_t TotalSyms = 0; + // If hash table is correct, we have at least chains with 0 length + size_t MaxChain = 1; + size_t CumulativeNonZero = 0; + + if (NChain == 0 || NBucket == 0) + return; + + std::vector<size_t> ChainLen(NBucket, 0); + // Go over all buckets and and note chain lengths of each bucket (total + // unique chain lengths). + for (size_t B = 0; B < NBucket; B++) { + for (size_t C = Buckets[B]; C > 0 && C < NChain; C = Chains[C]) + if (MaxChain <= ++ChainLen[B]) + MaxChain++; + TotalSyms += ChainLen[B]; + } + + if (!TotalSyms) + return; + + std::vector<size_t> Count(MaxChain, 0) ; + // Count how long is the chain for each bucket + for (size_t B = 0; B < NBucket; B++) + ++Count[ChainLen[B]]; + // Print Number of buckets with each chain lengths and their cumulative + // coverage of the symbols + OS << "Histogram for bucket list length (total of " << NBucket + << " buckets)\n" + << " Length Number % of total Coverage\n"; + for (size_t I = 0; I < MaxChain; I++) { + CumulativeNonZero += Count[I] * I; + OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], + (Count[I] * 100.0) / NBucket, + (CumulativeNonZero * 100.0) / TotalSyms); + } + } + + // Print histogram for .gnu.hash section + if (GnuHashTable) { + size_t NBucket = GnuHashTable->nbuckets; + ArrayRef<Elf_Word> Buckets = GnuHashTable->buckets(); + unsigned NumSyms = this->dumper()->dynamic_symbols().size(); + if (!NumSyms) + return; + ArrayRef<Elf_Word> Chains = GnuHashTable->values(NumSyms); + size_t Symndx = GnuHashTable->symndx; + size_t TotalSyms = 0; + size_t MaxChain = 1; + size_t CumulativeNonZero = 0; + + if (Chains.size() == 0 || NBucket == 0) + return; + + std::vector<size_t> ChainLen(NBucket, 0); + + for (size_t B = 0; B < NBucket; B++) { + if (!Buckets[B]) + continue; + size_t Len = 1; + for (size_t C = Buckets[B] - Symndx; + C < Chains.size() && (Chains[C] & 1) == 0; C++) + if (MaxChain < ++Len) + MaxChain++; + ChainLen[B] = Len; + TotalSyms += Len; + } + MaxChain++; + + if (!TotalSyms) + return; + + std::vector<size_t> Count(MaxChain, 0) ; + for (size_t B = 0; B < NBucket; B++) + ++Count[ChainLen[B]]; + // Print Number of buckets with each chain lengths and their cumulative + // coverage of the symbols + OS << "Histogram for `.gnu.hash' bucket list length (total of " << NBucket + << " buckets)\n" + << " Length Number % of total Coverage\n"; + for (size_t I = 0; I <MaxChain; I++) { + CumulativeNonZero += Count[I] * I; + OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], + (Count[I] * 100.0) / NBucket, + (CumulativeNonZero * 100.0) / TotalSyms); + } + } +} + +template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders(const ELFO *Obj) { + const Elf_Ehdr *e = Obj->getHeader(); + { + DictScope D(W, "ElfHeader"); + { + DictScope D(W, "Ident"); + W.printBinary("Magic", makeArrayRef(e->e_ident).slice(ELF::EI_MAG0, 4)); + W.printEnum("Class", e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); + W.printEnum("DataEncoding", e->e_ident[ELF::EI_DATA], + makeArrayRef(ElfDataEncoding)); + W.printNumber("FileVersion", e->e_ident[ELF::EI_VERSION]); + + // Handle architecture specific OS/ABI values. + if (e->e_machine == ELF::EM_AMDGPU && + e->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA) + W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA); + else + W.printEnum("OS/ABI", e->e_ident[ELF::EI_OSABI], + makeArrayRef(ElfOSABI)); + W.printNumber("ABIVersion", e->e_ident[ELF::EI_ABIVERSION]); + W.printBinary("Unused", makeArrayRef(e->e_ident).slice(ELF::EI_PAD)); + } + + W.printEnum("Type", e->e_type, makeArrayRef(ElfObjectFileType)); + W.printEnum("Machine", e->e_machine, makeArrayRef(ElfMachineType)); + W.printNumber("Version", e->e_version); + W.printHex("Entry", e->e_entry); + W.printHex("ProgramHeaderOffset", e->e_phoff); + W.printHex("SectionHeaderOffset", e->e_shoff); + if (e->e_machine == EM_MIPS) + W.printFlags("Flags", e->e_flags, makeArrayRef(ElfHeaderMipsFlags), + unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), + unsigned(ELF::EF_MIPS_MACH)); + else + W.printFlags("Flags", e->e_flags); + W.printNumber("HeaderSize", e->e_ehsize); + W.printNumber("ProgramHeaderEntrySize", e->e_phentsize); + W.printNumber("ProgramHeaderCount", e->e_phnum); + W.printNumber("SectionHeaderEntrySize", e->e_shentsize); + W.printNumber("SectionHeaderCount", e->e_shnum); + W.printNumber("StringTableSectionIndex", e->e_shstrndx); + } +} + +template <class ELFT> +void LLVMStyle<ELFT>::printGroupSections(const ELFO *Obj) { + DictScope Lists(W, "Groups"); + uint32_t SectionIndex = 0; + bool HasGroups = false; + for (const Elf_Shdr &Sec : Obj->sections()) { + if (Sec.sh_type == ELF::SHT_GROUP) { + HasGroups = true; + const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link)); + StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab)); + const Elf_Sym *Sym = Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info); + auto Data = unwrapOrError( + Obj->template getSectionContentsAsArray<Elf_Word>(&Sec)); + DictScope D(W, "Group"); + StringRef Name = unwrapOrError(Obj->getSectionName(&Sec)); + W.printNumber("Name", Name, Sec.sh_name); + W.printNumber("Index", SectionIndex); + W.printHex("Type", getGroupType(Data[0]), Data[0]); + W.startLine() << "Signature: " << StrTable.data() + Sym->st_name << "\n"; + { + ListScope L(W, "Section(s) in group"); + size_t Member = 1; + while (Member < Data.size()) { + auto Sec = unwrapOrError(Obj->getSection(Data[Member])); + const StringRef Name = unwrapOrError(Obj->getSectionName(Sec)); + W.startLine() << Name << " (" << Data[Member++] << ")\n"; + } + } + } + ++SectionIndex; + } + if (!HasGroups) + W.startLine() << "There are no group sections in the file.\n"; +} + +template <class ELFT> void LLVMStyle<ELFT>::printRelocations(const ELFO *Obj) { + ListScope D(W, "Relocations"); + + int SectionNumber = -1; + for (const Elf_Shdr &Sec : Obj->sections()) { + ++SectionNumber; + + if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA) + continue; + + StringRef Name = unwrapOrError(Obj->getSectionName(&Sec)); + + W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n"; + W.indent(); + + printRelocations(&Sec, Obj); + + W.unindent(); + W.startLine() << "}\n"; + } +} + +template <class ELFT> +void LLVMStyle<ELFT>::printRelocations(const Elf_Shdr *Sec, const ELFO *Obj) { + const Elf_Shdr *SymTab = unwrapOrError(Obj->getSection(Sec->sh_link)); + + switch (Sec->sh_type) { + case ELF::SHT_REL: + for (const Elf_Rel &R : Obj->rels(Sec)) { + Elf_Rela Rela; + Rela.r_offset = R.r_offset; + Rela.r_info = R.r_info; + Rela.r_addend = 0; + printRelocation(Obj, Rela, SymTab); + } + break; + case ELF::SHT_RELA: + for (const Elf_Rela &R : Obj->relas(Sec)) + printRelocation(Obj, R, SymTab); + break; + } +} + +template <class ELFT> +void LLVMStyle<ELFT>::printRelocation(const ELFO *Obj, Elf_Rela Rel, + const Elf_Shdr *SymTab) { + SmallString<32> RelocName; + Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); + StringRef TargetName; + const Elf_Sym *Sym = Obj->getRelocationSymbol(&Rel, SymTab); + if (Sym && Sym->getType() == ELF::STT_SECTION) { + const Elf_Shdr *Sec = unwrapOrError( + Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable())); + TargetName = unwrapOrError(Obj->getSectionName(Sec)); + } else if (Sym) { + StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab)); + TargetName = unwrapOrError(Sym->getName(StrTable)); + } + + if (opts::ExpandRelocs) { + DictScope Group(W, "Relocation"); + W.printHex("Offset", Rel.r_offset); + W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); + W.printNumber("Symbol", TargetName.size() > 0 ? TargetName : "-", + Rel.getSymbol(Obj->isMips64EL())); + W.printHex("Addend", Rel.r_addend); + } else { + raw_ostream &OS = W.startLine(); + OS << W.hex(Rel.r_offset) << " " << RelocName << " " + << (TargetName.size() > 0 ? TargetName : "-") << " " + << W.hex(Rel.r_addend) << "\n"; + } +} + +template <class ELFT> void LLVMStyle<ELFT>::printSections(const ELFO *Obj) { + ListScope SectionsD(W, "Sections"); + + int SectionIndex = -1; + for (const Elf_Shdr &Sec : Obj->sections()) { + ++SectionIndex; + + StringRef Name = unwrapOrError(Obj->getSectionName(&Sec)); + + DictScope SectionD(W, "Section"); + W.printNumber("Index", SectionIndex); + W.printNumber("Name", Name, Sec.sh_name); + W.printHex("Type", + getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type), + Sec.sh_type); + std::vector<EnumEntry<unsigned>> SectionFlags(std::begin(ElfSectionFlags), + std::end(ElfSectionFlags)); + switch (Obj->getHeader()->e_machine) { + case EM_AMDGPU: + SectionFlags.insert(SectionFlags.end(), std::begin(ElfAMDGPUSectionFlags), + std::end(ElfAMDGPUSectionFlags)); + break; + case EM_HEXAGON: + SectionFlags.insert(SectionFlags.end(), + std::begin(ElfHexagonSectionFlags), + std::end(ElfHexagonSectionFlags)); + break; + case EM_MIPS: + SectionFlags.insert(SectionFlags.end(), std::begin(ElfMipsSectionFlags), + std::end(ElfMipsSectionFlags)); + break; + case EM_X86_64: + SectionFlags.insert(SectionFlags.end(), std::begin(ElfX86_64SectionFlags), + std::end(ElfX86_64SectionFlags)); + break; + case EM_XCORE: + SectionFlags.insert(SectionFlags.end(), std::begin(ElfXCoreSectionFlags), + std::end(ElfXCoreSectionFlags)); + break; + default: + // Nothing to do. + break; + } + W.printFlags("Flags", Sec.sh_flags, makeArrayRef(SectionFlags)); + W.printHex("Address", Sec.sh_addr); + W.printHex("Offset", Sec.sh_offset); + W.printNumber("Size", Sec.sh_size); + W.printNumber("Link", Sec.sh_link); + W.printNumber("Info", Sec.sh_info); + W.printNumber("AddressAlignment", Sec.sh_addralign); + W.printNumber("EntrySize", Sec.sh_entsize); + + if (opts::SectionRelocations) { + ListScope D(W, "Relocations"); + printRelocations(&Sec, Obj); + } + + if (opts::SectionSymbols) { + ListScope D(W, "Symbols"); + const Elf_Shdr *Symtab = this->dumper()->getDotSymtabSec(); + StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab)); + + for (const Elf_Sym &Sym : Obj->symbols(Symtab)) { + const Elf_Shdr *SymSec = unwrapOrError( + Obj->getSection(&Sym, Symtab, this->dumper()->getShndxTable())); + if (SymSec == &Sec) + printSymbol(Obj, &Sym, Obj->symbol_begin(Symtab), StrTable, false); + } + } + + if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) { + ArrayRef<uint8_t> Data = unwrapOrError(Obj->getSectionContents(&Sec)); + W.printBinaryBlock("SectionData", + StringRef((const char *)Data.data(), Data.size())); + } + } +} + +template <class ELFT> +void LLVMStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, + const Elf_Sym *First, StringRef StrTable, + bool IsDynamic) { + unsigned SectionIndex = 0; + StringRef SectionName; + getSectionNameIndex(*Obj, Symbol, First, this->dumper()->getShndxTable(), + SectionName, SectionIndex); + std::string FullSymbolName = + this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic); + unsigned char SymbolType = Symbol->getType(); + + DictScope D(W, "Symbol"); + W.printNumber("Name", FullSymbolName, Symbol->st_name); + W.printHex("Value", Symbol->st_value); + W.printNumber("Size", Symbol->st_size); + W.printEnum("Binding", Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); + if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && + SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) + W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes)); + else + W.printEnum("Type", SymbolType, makeArrayRef(ElfSymbolTypes)); + if (Symbol->st_other == 0) + // Usually st_other flag is zero. Do not pollute the output + // by flags enumeration in that case. + W.printNumber("Other", 0); + else { + std::vector<EnumEntry<unsigned>> SymOtherFlags(std::begin(ElfSymOtherFlags), + std::end(ElfSymOtherFlags)); + if (Obj->getHeader()->e_machine == EM_MIPS) { + // Someones in their infinite wisdom decided to make STO_MIPS_MIPS16 + // flag overlapped with other ST_MIPS_xxx flags. So consider both + // cases separately. + if ((Symbol->st_other & STO_MIPS_MIPS16) == STO_MIPS_MIPS16) + SymOtherFlags.insert(SymOtherFlags.end(), + std::begin(ElfMips16SymOtherFlags), + std::end(ElfMips16SymOtherFlags)); + else + SymOtherFlags.insert(SymOtherFlags.end(), + std::begin(ElfMipsSymOtherFlags), + std::end(ElfMipsSymOtherFlags)); + } + W.printFlags("Other", Symbol->st_other, makeArrayRef(SymOtherFlags), 0x3u); + } + W.printHex("Section", SectionName, SectionIndex); +} + +template <class ELFT> void LLVMStyle<ELFT>::printSymbols(const ELFO *Obj) { + ListScope Group(W, "Symbols"); + this->dumper()->printSymbolsHelper(false); +} + +template <class ELFT> +void LLVMStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) { + ListScope Group(W, "DynamicSymbols"); + this->dumper()->printSymbolsHelper(true); +} + +template <class ELFT> +void LLVMStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) { + const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion(); + const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion(); + const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion(); + if (DynRelRegion.Size && DynRelaRegion.Size) + report_fatal_error("There are both REL and RELA dynamic relocations"); + W.startLine() << "Dynamic Relocations {\n"; + W.indent(); + if (DynRelaRegion.Size > 0) + for (const Elf_Rela &Rela : this->dumper()->dyn_relas()) + printDynamicRelocation(Obj, Rela); + else + for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) { + Elf_Rela Rela; + Rela.r_offset = Rel.r_offset; + Rela.r_info = Rel.r_info; + Rela.r_addend = 0; + printDynamicRelocation(Obj, Rela); + } + if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) + for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>()) + printDynamicRelocation(Obj, Rela); + else + for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) { + Elf_Rela Rela; + Rela.r_offset = Rel.r_offset; + Rela.r_info = Rel.r_info; + Rela.r_addend = 0; + printDynamicRelocation(Obj, Rela); + } + W.unindent(); + W.startLine() << "}\n"; +} + +template <class ELFT> +void LLVMStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel) { + SmallString<32> RelocName; + Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); + StringRef SymbolName; + uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL()); + const Elf_Sym *Sym = this->dumper()->dynamic_symbols().begin() + SymIndex; + SymbolName = + unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable())); + if (opts::ExpandRelocs) { + DictScope Group(W, "Relocation"); + W.printHex("Offset", Rel.r_offset); + W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); + W.printString("Symbol", SymbolName.size() > 0 ? SymbolName : "-"); + W.printHex("Addend", Rel.r_addend); + } else { + raw_ostream &OS = W.startLine(); + OS << W.hex(Rel.r_offset) << " " << RelocName << " " + << (SymbolName.size() > 0 ? SymbolName : "-") << " " + << W.hex(Rel.r_addend) << "\n"; + } +} + +template <class ELFT> +void LLVMStyle<ELFT>::printProgramHeaders(const ELFO *Obj) { + ListScope L(W, "ProgramHeaders"); - prettyPrintStackMap( - llvm::outs(), - StackMapV1Parser<ELFT::TargetEndianness>(*StackMapContentsArray)); + for (const Elf_Phdr &Phdr : Obj->program_headers()) { + DictScope P(W, "ProgramHeader"); + W.printHex("Type", + getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type), + Phdr.p_type); + W.printHex("Offset", Phdr.p_offset); + W.printHex("VirtualAddress", Phdr.p_vaddr); + W.printHex("PhysicalAddress", Phdr.p_paddr); + W.printNumber("FileSize", Phdr.p_filesz); + W.printNumber("MemSize", Phdr.p_memsz); + W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags)); + W.printNumber("Alignment", Phdr.p_align); + } +} +template <class ELFT> +void LLVMStyle<ELFT>::printHashHistogram(const ELFFile<ELFT> *Obj) { + W.startLine() << "Hash Histogram not implemented!\n"; } diff --git a/contrib/llvm/tools/llvm-readobj/Error.cpp b/contrib/llvm/tools/llvm-readobj/Error.cpp index 7e6f780..492eb33 100644 --- a/contrib/llvm/tools/llvm-readobj/Error.cpp +++ b/contrib/llvm/tools/llvm-readobj/Error.cpp @@ -17,6 +17,9 @@ using namespace llvm; namespace { +// FIXME: This class is only here to support the transition to llvm::Error. It +// will be removed once this transition is complete. Clients should prefer to +// deal with the Error value directly, rather than converting to error_code. class _readobj_error_category : public std::error_category { public: const char* name() const LLVM_NOEXCEPT override; diff --git a/contrib/llvm/tools/llvm-readobj/MachODumper.cpp b/contrib/llvm/tools/llvm-readobj/MachODumper.cpp index 58d2c9f..3773df2 100644 --- a/contrib/llvm/tools/llvm-readobj/MachODumper.cpp +++ b/contrib/llvm/tools/llvm-readobj/MachODumper.cpp @@ -11,15 +11,15 @@ // //===----------------------------------------------------------------------===// -#include "llvm-readobj.h" #include "Error.h" #include "ObjDumper.h" #include "StackMapPrinter.h" -#include "StreamWriter.h" +#include "llvm-readobj.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Object/MachO.h" #include "llvm/Support/Casting.h" +#include "llvm/Support/ScopedPrinter.h" using namespace llvm; using namespace object; @@ -28,9 +28,8 @@ namespace { class MachODumper : public ObjDumper { public: - MachODumper(const MachOObjectFile *Obj, StreamWriter& Writer) - : ObjDumper(Writer) - , Obj(Obj) { } + MachODumper(const MachOObjectFile *Obj, ScopedPrinter &Writer) + : ObjDumper(Writer), Obj(Obj) {} void printFileHeaders() override; void printSections() override; @@ -69,7 +68,7 @@ private: namespace llvm { std::error_code createMachODumper(const object::ObjectFile *Obj, - StreamWriter &Writer, + ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result) { const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(Obj); if (!MachOObj) @@ -239,7 +238,8 @@ static const EnumEntry<unsigned> MachOSymbolFlags[] = { { "ReferencedDynamically", 0x10 }, { "NoDeadStrip", 0x20 }, { "WeakRef", 0x40 }, - { "WeakDef", 0x80 } + { "WeakDef", 0x80 }, + { "AltEntry", 0x200 }, }; static const EnumEntry<unsigned> MachOSymbolTypes[] = { @@ -540,8 +540,9 @@ void MachODumper::printRelocation(const MachOObjectFile *Obj, if (IsExtern) { symbol_iterator Symbol = Reloc.getSymbol(); if (Symbol != Obj->symbol_end()) { - ErrorOr<StringRef> TargetNameOrErr = Symbol->getName(); - error(TargetNameOrErr.getError()); + Expected<StringRef> TargetNameOrErr = Symbol->getName(); + if (!TargetNameOrErr) + error(errorToErrorCode(TargetNameOrErr.takeError())); TargetName = *TargetNameOrErr; } } else if (!IsScattered) { @@ -604,15 +605,19 @@ void MachODumper::printDynamicSymbols() { void MachODumper::printSymbol(const SymbolRef &Symbol) { StringRef SymbolName; - if (ErrorOr<StringRef> SymbolNameOrErr = Symbol.getName()) + Expected<StringRef> SymbolNameOrErr = Symbol.getName(); + if (!SymbolNameOrErr) { + // TODO: Actually report errors helpfully. + consumeError(SymbolNameOrErr.takeError()); + } else SymbolName = *SymbolNameOrErr; MachOSymbol MOSymbol; getSymbol(Obj, Symbol.getRawDataRefImpl(), MOSymbol); StringRef SectionName = ""; - ErrorOr<section_iterator> SecIOrErr = Symbol.getSection(); - error(SecIOrErr.getError()); + Expected<section_iterator> SecIOrErr = Symbol.getSection(); + error(errorToErrorCode(SecIOrErr.takeError())); section_iterator SecI = *SecIOrErr; if (SecI != Obj->section_end()) error(SecI->getName(SectionName)); diff --git a/contrib/llvm/tools/llvm-readobj/ObjDumper.cpp b/contrib/llvm/tools/llvm-readobj/ObjDumper.cpp index f500a05..2a0a90e 100644 --- a/contrib/llvm/tools/llvm-readobj/ObjDumper.cpp +++ b/contrib/llvm/tools/llvm-readobj/ObjDumper.cpp @@ -14,16 +14,13 @@ #include "ObjDumper.h" #include "Error.h" -#include "StreamWriter.h" -#include "llvm/ADT/StringRef.h" #include "llvm/Object/ObjectFile.h" +#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/raw_ostream.h" namespace llvm { -ObjDumper::ObjDumper(StreamWriter& Writer) - : W(Writer) { -} +ObjDumper::ObjDumper(ScopedPrinter &Writer) : W(Writer) {} ObjDumper::~ObjDumper() { } diff --git a/contrib/llvm/tools/llvm-readobj/ObjDumper.h b/contrib/llvm/tools/llvm-readobj/ObjDumper.h index db26d69..a39fc26 100644 --- a/contrib/llvm/tools/llvm-readobj/ObjDumper.h +++ b/contrib/llvm/tools/llvm-readobj/ObjDumper.h @@ -18,12 +18,15 @@ namespace object { class COFFImportFile; class ObjectFile; } +namespace codeview { +class MemoryTypeTableBuilder; +} -class StreamWriter; +class ScopedPrinter; class ObjDumper { public: - ObjDumper(StreamWriter& Writer); + ObjDumper(ScopedPrinter &Writer); virtual ~ObjDumper(); virtual void printFileHeaders() = 0; @@ -42,6 +45,8 @@ public: virtual void printGnuHashTable() { } virtual void printLoadName() {} virtual void printVersionInfo() {} + virtual void printGroupSections() {} + virtual void printHashHistogram() {} // Only implemented for ARM ELF at this time. virtual void printAttributes() { } @@ -50,13 +55,17 @@ public: virtual void printMipsPLTGOT() { } virtual void printMipsABIFlags() { } virtual void printMipsReginfo() { } + virtual void printMipsOptions() { } // Only implemented for PE/COFF. virtual void printCOFFImports() { } virtual void printCOFFExports() { } virtual void printCOFFDirectives() { } virtual void printCOFFBaseReloc() { } + virtual void printCOFFDebugDirectory() { } virtual void printCodeViewDebugInfo() { } + virtual void + mergeCodeViewTypes(llvm::codeview::MemoryTypeTableBuilder &CVTypes) {} // Only implemented for MachO. virtual void printMachODataInCode() { } @@ -69,23 +78,26 @@ public: virtual void printStackMap() const = 0; protected: - StreamWriter& W; + ScopedPrinter &W; }; std::error_code createCOFFDumper(const object::ObjectFile *Obj, - StreamWriter &Writer, + ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result); std::error_code createELFDumper(const object::ObjectFile *Obj, - StreamWriter &Writer, + ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result); std::error_code createMachODumper(const object::ObjectFile *Obj, - StreamWriter &Writer, + ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result); void dumpCOFFImportFile(const object::COFFImportFile *File); +void dumpCodeViewMergedTypes(ScopedPrinter &Writer, + llvm::codeview::MemoryTypeTableBuilder &CVTypes); + } // namespace llvm #endif diff --git a/contrib/llvm/tools/llvm-readobj/StreamWriter.cpp b/contrib/llvm/tools/llvm-readobj/StreamWriter.cpp deleted file mode 100644 index 8718112..0000000 --- a/contrib/llvm/tools/llvm-readobj/StreamWriter.cpp +++ /dev/null @@ -1,79 +0,0 @@ -#include "StreamWriter.h" -#include "llvm/ADT/StringExtras.h" -#include "llvm/Support/Format.h" -#include <cctype> - -using namespace llvm::support; - -namespace llvm { - -raw_ostream &operator<<(raw_ostream &OS, const HexNumber& Value) { - uint64_t N = Value.Value; - // Zero is a special case. - if (N == 0) - return OS << "0x0"; - - char NumberBuffer[20]; - char *EndPtr = NumberBuffer + sizeof(NumberBuffer); - char *CurPtr = EndPtr; - - while (N) { - uintptr_t X = N % 16; - *--CurPtr = (X < 10 ? '0' + X : 'A' + X - 10); - N /= 16; - } - - OS << "0x"; - return OS.write(CurPtr, EndPtr - CurPtr); -} - -void StreamWriter::printBinaryImpl(StringRef Label, StringRef Str, - ArrayRef<uint8_t> Data, bool Block) { - if (Data.size() > 16) - Block = true; - - if (Block) { - startLine() << Label; - if (Str.size() > 0) - OS << ": " << Str; - OS << " (\n"; - for (size_t addr = 0, end = Data.size(); addr < end; addr += 16) { - startLine() << format(" %04" PRIX64 ": ", uint64_t(addr)); - // Dump line of hex. - for (size_t i = 0; i < 16; ++i) { - if (i != 0 && i % 4 == 0) - OS << ' '; - if (addr + i < end) - OS << hexdigit((Data[addr + i] >> 4) & 0xF, false) - << hexdigit(Data[addr + i] & 0xF, false); - else - OS << " "; - } - // Print ascii. - OS << " |"; - for (std::size_t i = 0; i < 16 && addr + i < end; ++i) { - if (std::isprint(Data[addr + i] & 0xFF)) - OS << Data[addr + i]; - else - OS << "."; - } - OS << "|\n"; - } - - startLine() << ")\n"; - } else { - startLine() << Label << ":"; - if (Str.size() > 0) - OS << " " << Str; - OS << " ("; - for (size_t i = 0; i < Data.size(); ++i) { - if (i > 0) - OS << " "; - - OS << format("%02X", static_cast<int>(Data[i])); - } - OS << ")\n"; - } -} - -} // namespace llvm diff --git a/contrib/llvm/tools/llvm-readobj/StreamWriter.h b/contrib/llvm/tools/llvm-readobj/StreamWriter.h deleted file mode 100644 index d2dbb07..0000000 --- a/contrib/llvm/tools/llvm-readobj/StreamWriter.h +++ /dev/null @@ -1,320 +0,0 @@ -//===-- StreamWriter.h ----------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_TOOLS_LLVM_READOBJ_STREAMWRITER_H -#define LLVM_TOOLS_LLVM_READOBJ_STREAMWRITER_H - -#include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/Support/DataTypes.h" -#include "llvm/Support/Endian.h" -#include "llvm/Support/raw_ostream.h" -#include <algorithm> - -using namespace llvm; -using namespace llvm::support; - -namespace llvm { - -template<typename T> -struct EnumEntry { - StringRef Name; - T Value; -}; - -struct HexNumber { - // To avoid sign-extension we have to explicitly cast to the appropriate - // unsigned type. The overloads are here so that every type that is implicitly - // convertible to an integer (including enums and endian helpers) can be used - // without requiring type traits or call-site changes. - HexNumber(char Value) : Value(static_cast<unsigned char>(Value)) { } - HexNumber(signed char Value) : Value(static_cast<unsigned char>(Value)) { } - HexNumber(signed short Value) : Value(static_cast<unsigned short>(Value)) { } - HexNumber(signed int Value) : Value(static_cast<unsigned int>(Value)) { } - HexNumber(signed long Value) : Value(static_cast<unsigned long>(Value)) { } - HexNumber(signed long long Value) : Value(static_cast<unsigned long long>(Value)) { } - HexNumber(unsigned char Value) : Value(Value) { } - HexNumber(unsigned short Value) : Value(Value) { } - HexNumber(unsigned int Value) : Value(Value) { } - HexNumber(unsigned long Value) : Value(Value) { } - HexNumber(unsigned long long Value) : Value(Value) { } - uint64_t Value; -}; - -raw_ostream &operator<<(raw_ostream &OS, const HexNumber& Value); - -class StreamWriter { -public: - StreamWriter(raw_ostream &OS) - : OS(OS) - , IndentLevel(0) { - } - - void flush() { - OS.flush(); - } - - void indent(int Levels = 1) { - IndentLevel += Levels; - } - - void unindent(int Levels = 1) { - IndentLevel = std::max(0, IndentLevel - Levels); - } - - void printIndent() { - for (int i = 0; i < IndentLevel; ++i) - OS << " "; - } - - template<typename T> - HexNumber hex(T Value) { - return HexNumber(Value); - } - - template<typename T, typename TEnum> - void printEnum(StringRef Label, T Value, - ArrayRef<EnumEntry<TEnum> > EnumValues) { - StringRef Name; - bool Found = false; - for (const auto &EnumItem : EnumValues) { - if (EnumItem.Value == Value) { - Name = EnumItem.Name; - Found = true; - break; - } - } - - if (Found) { - startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n"; - } else { - startLine() << Label << ": " << hex(Value) << "\n"; - } - } - - template <typename T, typename TFlag> - void printFlags(StringRef Label, T Value, ArrayRef<EnumEntry<TFlag>> Flags, - TFlag EnumMask1 = {}, TFlag EnumMask2 = {}, - TFlag EnumMask3 = {}) { - typedef EnumEntry<TFlag> FlagEntry; - typedef SmallVector<FlagEntry, 10> FlagVector; - FlagVector SetFlags; - - for (const auto &Flag : Flags) { - if (Flag.Value == 0) - continue; - - TFlag EnumMask{}; - if (Flag.Value & EnumMask1) - EnumMask = EnumMask1; - else if (Flag.Value & EnumMask2) - EnumMask = EnumMask2; - else if (Flag.Value & EnumMask3) - EnumMask = EnumMask3; - bool IsEnum = (Flag.Value & EnumMask) != 0; - if ((!IsEnum && (Value & Flag.Value) == Flag.Value) || - (IsEnum && (Value & EnumMask) == Flag.Value)) { - SetFlags.push_back(Flag); - } - } - - std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>); - - startLine() << Label << " [ (" << hex(Value) << ")\n"; - for (const auto &Flag : SetFlags) { - startLine() << " " << Flag.Name << " (" << hex(Flag.Value) << ")\n"; - } - startLine() << "]\n"; - } - - template<typename T> - void printFlags(StringRef Label, T Value) { - startLine() << Label << " [ (" << hex(Value) << ")\n"; - uint64_t Flag = 1; - uint64_t Curr = Value; - while (Curr > 0) { - if (Curr & 1) - startLine() << " " << hex(Flag) << "\n"; - Curr >>= 1; - Flag <<= 1; - } - startLine() << "]\n"; - } - - void printNumber(StringRef Label, uint64_t Value) { - startLine() << Label << ": " << Value << "\n"; - } - - void printNumber(StringRef Label, uint32_t Value) { - startLine() << Label << ": " << Value << "\n"; - } - - void printNumber(StringRef Label, uint16_t Value) { - startLine() << Label << ": " << Value << "\n"; - } - - void printNumber(StringRef Label, uint8_t Value) { - startLine() << Label << ": " << unsigned(Value) << "\n"; - } - - void printNumber(StringRef Label, int64_t Value) { - startLine() << Label << ": " << Value << "\n"; - } - - void printNumber(StringRef Label, int32_t Value) { - startLine() << Label << ": " << Value << "\n"; - } - - void printNumber(StringRef Label, int16_t Value) { - startLine() << Label << ": " << Value << "\n"; - } - - void printNumber(StringRef Label, int8_t Value) { - startLine() << Label << ": " << int(Value) << "\n"; - } - - void printBoolean(StringRef Label, bool Value) { - startLine() << Label << ": " << (Value ? "Yes" : "No") << '\n'; - } - - template <typename T> - void printList(StringRef Label, const T &List) { - startLine() << Label << ": ["; - bool Comma = false; - for (const auto &Item : List) { - if (Comma) - OS << ", "; - OS << Item; - Comma = true; - } - OS << "]\n"; - } - - template <typename T> - void printHexList(StringRef Label, const T &List) { - startLine() << Label << ": ["; - bool Comma = false; - for (const auto &Item : List) { - if (Comma) - OS << ", "; - OS << hex(Item); - Comma = true; - } - OS << "]\n"; - } - - template<typename T> - void printHex(StringRef Label, T Value) { - startLine() << Label << ": " << hex(Value) << "\n"; - } - - template<typename T> - void printHex(StringRef Label, StringRef Str, T Value) { - startLine() << Label << ": " << Str << " (" << hex(Value) << ")\n"; - } - - void printString(StringRef Label, StringRef Value) { - startLine() << Label << ": " << Value << "\n"; - } - - void printString(StringRef Label, const std::string &Value) { - startLine() << Label << ": " << Value << "\n"; - } - - template<typename T> - void printNumber(StringRef Label, StringRef Str, T Value) { - startLine() << Label << ": " << Str << " (" << Value << ")\n"; - } - - void printBinary(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value) { - printBinaryImpl(Label, Str, Value, false); - } - - void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) { - auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()), - Value.size()); - printBinaryImpl(Label, Str, V, false); - } - - void printBinary(StringRef Label, ArrayRef<uint8_t> Value) { - printBinaryImpl(Label, StringRef(), Value, false); - } - - void printBinary(StringRef Label, ArrayRef<char> Value) { - auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()), - Value.size()); - printBinaryImpl(Label, StringRef(), V, false); - } - - void printBinary(StringRef Label, StringRef Value) { - auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()), - Value.size()); - printBinaryImpl(Label, StringRef(), V, false); - } - - void printBinaryBlock(StringRef Label, StringRef Value) { - auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()), - Value.size()); - printBinaryImpl(Label, StringRef(), V, true); - } - - raw_ostream& startLine() { - printIndent(); - return OS; - } - - raw_ostream& getOStream() { - return OS; - } - -private: - template<typename T> - static bool flagName(const EnumEntry<T>& lhs, const EnumEntry<T>& rhs) { - return lhs.Name < rhs.Name; - } - - void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value, - bool Block); - - raw_ostream &OS; - int IndentLevel; -}; - -struct DictScope { - DictScope(StreamWriter& W, StringRef N) : W(W) { - W.startLine() << N << " {\n"; - W.indent(); - } - - ~DictScope() { - W.unindent(); - W.startLine() << "}\n"; - } - - StreamWriter& W; -}; - -struct ListScope { - ListScope(StreamWriter& W, StringRef N) : W(W) { - W.startLine() << N << " [\n"; - W.indent(); - } - - ~ListScope() { - W.unindent(); - W.startLine() << "]\n"; - } - - StreamWriter& W; -}; - -} // namespace llvm - -#endif diff --git a/contrib/llvm/tools/llvm-readobj/Win64EHDumper.cpp b/contrib/llvm/tools/llvm-readobj/Win64EHDumper.cpp index 2da5ae3..f7e56b3 100644 --- a/contrib/llvm/tools/llvm-readobj/Win64EHDumper.cpp +++ b/contrib/llvm/tools/llvm-readobj/Win64EHDumper.cpp @@ -120,13 +120,17 @@ static std::string formatSymbol(const Dumper::Context &Ctx, SymbolRef Symbol; if (!Ctx.ResolveSymbol(Section, Offset, Symbol, Ctx.UserData)) { - if (ErrorOr<StringRef> Name = Symbol.getName()) { + Expected<StringRef> Name = Symbol.getName(); + if (Name) { OS << *Name; if (Displacement > 0) OS << format(" +0x%X (0x%" PRIX64 ")", Displacement, Offset); else OS << format(" (0x%" PRIX64 ")", Offset); return OS.str(); + } else { + // TODO: Actually report errors helpfully. + consumeError(Name.takeError()); } } @@ -144,12 +148,14 @@ static std::error_code resolveRelocation(const Dumper::Context &Ctx, Ctx.ResolveSymbol(Section, Offset, Symbol, Ctx.UserData)) return EC; - ErrorOr<uint64_t> ResolvedAddressOrErr = Symbol.getAddress(); - if (std::error_code EC = ResolvedAddressOrErr.getError()) - return EC; + Expected<uint64_t> ResolvedAddressOrErr = Symbol.getAddress(); + if (!ResolvedAddressOrErr) + return errorToErrorCode(ResolvedAddressOrErr.takeError()); ResolvedAddress = *ResolvedAddressOrErr; - ErrorOr<section_iterator> SI = Symbol.getSection(); + Expected<section_iterator> SI = Symbol.getSection(); + if (!SI) + return errorToErrorCode(SI.takeError()); ResolvedSection = Ctx.COFF.getCOFFSection(**SI); return std::error_code(); } diff --git a/contrib/llvm/tools/llvm-readobj/Win64EHDumper.h b/contrib/llvm/tools/llvm-readobj/Win64EHDumper.h index a80df9c..772f68b 100644 --- a/contrib/llvm/tools/llvm-readobj/Win64EHDumper.h +++ b/contrib/llvm/tools/llvm-readobj/Win64EHDumper.h @@ -10,7 +10,7 @@ #ifndef LLVM_TOOLS_LLVM_READOBJ_WIN64EHDUMPER_H #define LLVM_TOOLS_LLVM_READOBJ_WIN64EHDUMPER_H -#include "StreamWriter.h" +#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/Win64EH.h" namespace llvm { @@ -22,7 +22,7 @@ struct coff_section; namespace Win64EH { class Dumper { - StreamWriter &SW; + ScopedPrinter &SW; raw_ostream &OS; public: @@ -53,7 +53,7 @@ private: uint64_t SectionOffset, const RuntimeFunction &RF); public: - Dumper(StreamWriter &SW) : SW(SW), OS(SW.getOStream()) {} + Dumper(ScopedPrinter &SW) : SW(SW), OS(SW.getOStream()) {} void printData(const Context &Ctx); }; diff --git a/contrib/llvm/tools/llvm-readobj/llvm-readobj.cpp b/contrib/llvm/tools/llvm-readobj/llvm-readobj.cpp index fa8fee2..c293919 100644 --- a/contrib/llvm/tools/llvm-readobj/llvm-readobj.cpp +++ b/contrib/llvm/tools/llvm-readobj/llvm-readobj.cpp @@ -22,7 +22,7 @@ #include "llvm-readobj.h" #include "Error.h" #include "ObjDumper.h" -#include "StreamWriter.h" +#include "llvm/DebugInfo/CodeView/MemoryTypeTableBuilder.h" #include "llvm/Object/Archive.h" #include "llvm/Object/COFFImportFile.h" #include "llvm/Object/ELFObjectFile.h" @@ -35,6 +35,7 @@ #include "llvm/Support/FileSystem.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/Signals.h" #include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetSelect.h" @@ -144,6 +145,11 @@ namespace opts { cl::opt<bool> CodeView("codeview", cl::desc("Display CodeView debug information")); + // -codeview-merged-types + cl::opt<bool> + CodeViewMergedTypes("codeview-merged-types", + cl::desc("Display the merged CodeView type stream")); + // -codeview-subsection-bytes cl::opt<bool> CodeViewSubsectionBytes( "codeview-subsection-bytes", @@ -168,6 +174,10 @@ namespace opts { cl::opt<bool> MipsReginfo("mips-reginfo", cl::desc("Display the MIPS .reginfo section")); + // -mips-options + cl::opt<bool> MipsOptions("mips-options", + cl::desc("Display the MIPS .MIPS.options section")); + // -coff-imports cl::opt<bool> COFFImports("coff-imports", cl::desc("Display the PE/COFF import table")); @@ -186,6 +196,11 @@ namespace opts { COFFBaseRelocs("coff-basereloc", cl::desc("Display the PE/COFF .reloc section")); + // -coff-debug-directory + cl::opt<bool> + COFFDebugDirectory("coff-debug-directory", + cl::desc("Display the PE/COFF debug directory")); + // -macho-data-in-code cl::opt<bool> MachODataInCode("macho-data-in-code", @@ -227,6 +242,22 @@ namespace opts { cl::desc("Display ELF version sections (if present)")); cl::alias VersionInfoShort("V", cl::desc("Alias for -version-info"), cl::aliasopt(VersionInfo)); + + cl::opt<bool> SectionGroups("elf-section-groups", + cl::desc("Display ELF section group contents")); + cl::alias SectionGroupsShort("g", cl::desc("Alias for -elf-sections-groups"), + cl::aliasopt(SectionGroups)); + cl::opt<bool> HashHistogram( + "elf-hash-histogram", + cl::desc("Display bucket list histogram for hash sections")); + cl::alias HashHistogramShort("I", cl::desc("Alias for -elf-hash-histogram"), + cl::aliasopt(HashHistogram)); + + cl::opt<OutputStyleTy> + Output("elf-output-style", cl::desc("Specify ELF dump style"), + cl::values(clEnumVal(LLVM, "LLVM default style"), + clEnumVal(GNU, "GNU readelf style"), clEnumValEnd), + cl::init(LLVM)); } // namespace opts namespace llvm { @@ -264,6 +295,17 @@ static void reportError(StringRef Input, StringRef Message) { reportError(Twine(Input) + ": " + Message); } +static void reportError(StringRef Input, Error Err) { + if (Input == "-") + Input = "<stdin>"; + std::string ErrMsg; + { + raw_string_ostream ErrStream(ErrMsg); + logAllUnhandledErrors(std::move(Err), ErrStream, Input + ": "); + } + reportError(ErrMsg); +} + static bool isMipsArch(unsigned Arch) { switch (Arch) { case llvm::Triple::mips: @@ -276,8 +318,11 @@ static bool isMipsArch(unsigned Arch) { } } +static llvm::codeview::MemoryTypeTableBuilder CVTypes; + /// @brief Creates an format-specific object file dumper. -static std::error_code createDumper(const ObjectFile *Obj, StreamWriter &Writer, +static std::error_code createDumper(const ObjectFile *Obj, + ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result) { if (!Obj) return readobj_error::unsupported_file_format; @@ -294,19 +339,20 @@ static std::error_code createDumper(const ObjectFile *Obj, StreamWriter &Writer, /// @brief Dumps the specified object file. static void dumpObject(const ObjectFile *Obj) { - StreamWriter Writer(outs()); + ScopedPrinter Writer(outs()); std::unique_ptr<ObjDumper> Dumper; if (std::error_code EC = createDumper(Obj, Writer, Dumper)) reportError(Obj->getFileName(), EC); - outs() << '\n'; - outs() << "File: " << Obj->getFileName() << "\n"; - outs() << "Format: " << Obj->getFileFormatName() << "\n"; - outs() << "Arch: " - << Triple::getArchTypeName((llvm::Triple::ArchType)Obj->getArch()) - << "\n"; - outs() << "AddressSize: " << (8*Obj->getBytesInAddress()) << "bit\n"; - Dumper->printLoadName(); + if (opts::Output == opts::LLVM) { + outs() << '\n'; + outs() << "File: " << Obj->getFileName() << "\n"; + outs() << "Format: " << Obj->getFileFormatName() << "\n"; + outs() << "Arch: " << Triple::getArchTypeName( + (llvm::Triple::ArchType)Obj->getArch()) << "\n"; + outs() << "AddressSize: " << (8 * Obj->getBytesInAddress()) << "bit\n"; + Dumper->printLoadName(); + } if (opts::FileHeaders) Dumper->printFileHeaders(); @@ -334,16 +380,24 @@ static void dumpObject(const ObjectFile *Obj) { Dumper->printGnuHashTable(); if (opts::VersionInfo) Dumper->printVersionInfo(); - if (Obj->getArch() == llvm::Triple::arm && Obj->isELF()) - if (opts::ARMAttributes) - Dumper->printAttributes(); - if (isMipsArch(Obj->getArch()) && Obj->isELF()) { - if (opts::MipsPLTGOT) - Dumper->printMipsPLTGOT(); - if (opts::MipsABIFlags) - Dumper->printMipsABIFlags(); - if (opts::MipsReginfo) - Dumper->printMipsReginfo(); + if (Obj->isELF()) { + if (Obj->getArch() == llvm::Triple::arm) + if (opts::ARMAttributes) + Dumper->printAttributes(); + if (isMipsArch(Obj->getArch())) { + if (opts::MipsPLTGOT) + Dumper->printMipsPLTGOT(); + if (opts::MipsABIFlags) + Dumper->printMipsABIFlags(); + if (opts::MipsReginfo) + Dumper->printMipsReginfo(); + if (opts::MipsOptions) + Dumper->printMipsOptions(); + } + if (opts::SectionGroups) + Dumper->printGroupSections(); + if (opts::HashHistogram) + Dumper->printHashHistogram(); } if (Obj->isCOFF()) { if (opts::COFFImports) @@ -354,8 +408,12 @@ static void dumpObject(const ObjectFile *Obj) { Dumper->printCOFFDirectives(); if (opts::COFFBaseRelocs) Dumper->printCOFFBaseReloc(); + if (opts::COFFDebugDirectory) + Dumper->printCOFFDebugDirectory(); if (opts::CodeView) Dumper->printCodeViewDebugInfo(); + if (opts::CodeViewMergedTypes) + Dumper->mergeCodeViewTypes(CVTypes); } if (Obj->isMachO()) { if (opts::MachODataInCode) @@ -377,35 +435,43 @@ static void dumpObject(const ObjectFile *Obj) { /// @brief Dumps each object file in \a Arc; static void dumpArchive(const Archive *Arc) { - for (auto &ErrorOrChild : Arc->children()) { - if (std::error_code EC = ErrorOrChild.getError()) - reportError(Arc->getFileName(), EC.message()); - const auto &Child = *ErrorOrChild; - ErrorOr<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary(); - if (std::error_code EC = ChildOrErr.getError()) { - // Ignore non-object files. - if (EC != object_error::invalid_file_type) - reportError(Arc->getFileName(), EC.message()); + Error Err; + for (auto &Child : Arc->children(Err)) { + Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary(); + if (!ChildOrErr) { + if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) { + std::string Buf; + raw_string_ostream OS(Buf); + logAllUnhandledErrors(ChildOrErr.takeError(), OS, ""); + OS.flush(); + reportError(Arc->getFileName(), Buf); + } continue; } - if (ObjectFile *Obj = dyn_cast<ObjectFile>(&*ChildOrErr.get())) dumpObject(Obj); else reportError(Arc->getFileName(), readobj_error::unrecognized_file_format); } + if (Err) + reportError(Arc->getFileName(), std::move(Err)); } /// @brief Dumps each object file in \a MachO Universal Binary; static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary) { for (const MachOUniversalBinary::ObjectForArch &Obj : UBinary->objects()) { - ErrorOr<std::unique_ptr<MachOObjectFile>> ObjOrErr = Obj.getAsObjectFile(); + Expected<std::unique_ptr<MachOObjectFile>> ObjOrErr = Obj.getAsObjectFile(); if (ObjOrErr) dumpObject(&*ObjOrErr.get()); - else if (ErrorOr<std::unique_ptr<Archive>> AOrErr = Obj.getAsArchive()) + else if (auto E = isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) { + std::string Buf; + raw_string_ostream OS(Buf); + logAllUnhandledErrors(ObjOrErr.takeError(), OS, ""); + OS.flush(); + reportError(UBinary->getFileName(), Buf); + } + else if (Expected<std::unique_ptr<Archive>> AOrErr = Obj.getAsArchive()) dumpArchive(&*AOrErr.get()); - else - reportError(UBinary->getFileName(), ObjOrErr.getError().message()); } } @@ -413,9 +479,9 @@ static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary) { static void dumpInput(StringRef File) { // Attempt to open the binary. - ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(File); - if (std::error_code EC = BinaryOrErr.getError()) - reportError(File, EC); + Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(File); + if (!BinaryOrErr) + reportError(File, errorToErrorCode(BinaryOrErr.takeError())); Binary &Binary = *BinaryOrErr.get().getBinary(); if (Archive *Arc = dyn_cast<Archive>(&Binary)) @@ -432,7 +498,7 @@ static void dumpInput(StringRef File) { } int main(int argc, const char *argv[]) { - sys::PrintStackTraceOnErrorSignal(); + sys::PrintStackTraceOnErrorSignal(argv[0]); PrettyStackTraceProgram X(argc, argv); llvm_shutdown_obj Y; @@ -448,5 +514,10 @@ int main(int argc, const char *argv[]) { std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(), dumpInput); + if (opts::CodeViewMergedTypes) { + ScopedPrinter W(outs()); + dumpCodeViewMergedTypes(W, CVTypes); + } + return 0; } diff --git a/contrib/llvm/tools/llvm-readobj/llvm-readobj.h b/contrib/llvm/tools/llvm-readobj/llvm-readobj.h index 5a10392..b169c00 100644 --- a/contrib/llvm/tools/llvm-readobj/llvm-readobj.h +++ b/contrib/llvm/tools/llvm-readobj/llvm-readobj.h @@ -12,6 +12,8 @@ #include "llvm/Support/CommandLine.h" #include "llvm/Support/Compiler.h" +#include "llvm/Support/ErrorOr.h" +#include "llvm/Support/Error.h" #include <string> namespace llvm { @@ -22,6 +24,20 @@ namespace llvm { // Various helper functions. LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg); void error(std::error_code ec); + template <class T> T unwrapOrError(ErrorOr<T> EO) { + if (EO) + return *EO; + reportError(EO.getError().message()); + } + template <class T> T unwrapOrError(Expected<T> EO) { + if (EO) + return *EO; + std::string Buf; + raw_string_ostream OS(Buf); + logAllUnhandledErrors(EO.takeError(), OS, ""); + OS.flush(); + reportError(Buf); + } bool relocAddressLess(object::RelocationRef A, object::RelocationRef B); } // namespace llvm @@ -42,9 +58,14 @@ namespace opts { extern llvm::cl::opt<bool> CodeViewSubsectionBytes; extern llvm::cl::opt<bool> ARMAttributes; extern llvm::cl::opt<bool> MipsPLTGOT; + enum OutputStyleTy { LLVM, GNU }; + extern llvm::cl::opt<OutputStyleTy> Output; } // namespace opts #define LLVM_READOBJ_ENUM_ENT(ns, enum) \ { #enum, ns::enum } +#define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \ + { #enum, std::underlying_type<enum_class>::type(enum_class::enum) } + #endif |
