This is an archive of the discontinued LLVM Phabricator instance.

Differential D86718

[llvm-readobj] - Simplify the code that creates dumpers. NFCI.
ClosedPublic

Authored by grimar on Aug 27 2020, 8:30 AM.

Details

Reviewers
jhenderson
MaskRay
Commits
rG3fe01f0e215b: [llvm-readobj] - Simplify the code that creates dumpers. NFCI.
Summary

We have a few helper functions like the following:

std::error_code create*Dumper(...)

In fact we do not need or want to use std::error_code and the code
can be simpler if we just return std::unique_ptr<ObjDumper>.

This patch does this change and refines the signature of createDumper
as well.

Diff Detail

Event Timeline

grimar created this revision.Aug 27 2020, 8:30 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 27 2020, 8:30 AM
Herald added subscribers: rupprecht, sbc100. · View Herald Transcript
grimar requested review of this revision.Aug 27 2020, 8:30 AM
Herald added a subscriber: aheejin. · View Herald TranscriptAug 27 2020, 8:30 AM
MaskRay added a comment.EditedAug 27 2020, 12:24 PM

The observation of this patch is that createDumper does not fail.

The construction of an ObjectFile just inspects the leading magic bytes (isELF isMachO ...). createDumper dispatches on magic bytes to different binary formats. Indeed currently the various create*Dumper do not fail, but is it possible that we will enforce stricter verification in the future? If so, the new interface with the unique_ptr return type does not seem very suitable.

The dumpObject interface change is fine: using a reference to emphasize that the pointer argument cannot be null.

grimar added a comment.EditedAug 27 2020, 2:13 PM
In D86718#2242876, @MaskRay wrote:

The observation of this patch is that createDumper does not fail.

The construction of an ObjectFile just inspects the leading magic bytes (isELF isMachO ...). createDumper dispatches on magic bytes to different binary formats. Indeed currently the various create*Dumper do not fail, but is it possible that we will enforce stricter verification in the future?

I think it should never fail. The idea of llvm-readobj/elf is all about dumping of all kind of objects, e.g. they must be able to dump broken objects.
I believe we always want to be able at least to create dumpers.

If one day situation changes, we will be able to change the API, but currently it is redundant to return an error.

MaskRay accepted this revision.Aug 27 2020, 2:18 PM

Because currently we call many print* after the dumper is created. The many print* may fail due to the same reason. If we one day we want to change, we can call a verification method before print*.

This revision is now accepted and ready to land.Aug 27 2020, 2:18 PM
Closed by commit rG3fe01f0e215b: [llvm-readobj] - Simplify the code that creates dumpers. NFCI. (authored by grimar). · Explain WhyAug 28 2020, 1:44 AM
This revision was automatically updated to reflect the committed changes.
grimar added a commit: rG3fe01f0e215b: [llvm-readobj] - Simplify the code that creates dumpers. NFCI..

Revision Contents

PathSize
llvm/
tools/
llvm-readobj/
12 lines
30 lines
12 lines
27 lines
11 lines
12 lines
80 lines

Diff 288552

llvm/tools/llvm-readobj/COFFDumper.cpp

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Linesprivate:
const coff_section *Sec; const coff_section *Sec;
StringRef SectionContents; StringRef SectionContents;
}; };
} // end namespace } // end namespace
namespace llvm { namespace llvm {
std::error_code createCOFFDumper(const object::ObjectFile *Obj, std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
ScopedPrinter &Writer, ScopedPrinter &Writer) {
std::unique_ptr<ObjDumper> &Result) { return std::make_unique<COFFDumper>(&Obj, Writer);
const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(Obj);
if (!COFFObj)
return readobj_error::unsupported_obj_file_format;
Result.reset(new COFFDumper(COFFObj, Writer));
return readobj_error::success;
} }
} // namespace llvm } // namespace llvm
// Given a section and an offset into this section the function returns the // Given a section and an offset into this section the function returns the
// symbol used for the relocation at the offset. // symbol used for the relocation at the offset.
std::error_code COFFDumper::resolveSymbol(const coff_section *Section, std::error_code COFFDumper::resolveSymbol(const coff_section *Section,
uint64_t Offset, SymbolRef &Sym) { uint64_t Offset, SymbolRef &Sym) {
▲ Show 20 Lines • Show All 1,769 Lines • Show Last 20 Lines

llvm/tools/llvm-readobj/ELFDumper.cpp

Show First 20 Lines • Show All 981 Lines • ▼ Show 20 Linesprivate:
ScopedPrinter &W; ScopedPrinter &W;
}; };
} // end anonymous namespace } // end anonymous namespace
namespace llvm { namespace llvm {
template <class ELFT> template <class ELFT>
static std::error_code createELFDumper(const ELFObjectFile<ELFT> *Obj, static std::unique_ptr<ObjDumper> createELFDumper(const ELFObjectFile<ELFT> &Obj,
ScopedPrinter &Writer, ScopedPrinter &Writer) {
std::unique_ptr<ObjDumper> &Result) { return std::make_unique<ELFDumper<ELFT>>(&Obj, Writer);
Result.reset(new ELFDumper<ELFT>(Obj, Writer));
return readobj_error::success;
} }
std::error_code createELFDumper(const object::ObjectFile *Obj, std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
ScopedPrinter &Writer, ScopedPrinter &Writer) {
std::unique_ptr<ObjDumper> &Result) {
// Little-endian 32-bit // Little-endian 32-bit
if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj)) if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(&Obj))
return createELFDumper(ELFObj, Writer, Result); return createELFDumper(*ELFObj, Writer);
// Big-endian 32-bit // Big-endian 32-bit
if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj)) if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(&Obj))
return createELFDumper(ELFObj, Writer, Result); return createELFDumper(*ELFObj, Writer);
// Little-endian 64-bit // Little-endian 64-bit
if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj)) if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(&Obj))
return createELFDumper(ELFObj, Writer, Result); return createELFDumper(*ELFObj, Writer);
// Big-endian 64-bit // Big-endian 64-bit
if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj)) return createELFDumper(*cast<ELF64BEObjectFile>(&Obj), Writer);
return createELFDumper(ELFObj, Writer, Result);
return readobj_error::unsupported_obj_file_format;
} }
} // end namespace llvm } // end namespace llvm
template <class ELFT> Error ELFDumper<ELFT>::LoadVersionMap() const { template <class ELFT> Error ELFDumper<ELFT>::LoadVersionMap() const {
// If there is no dynamic symtab or version table, there is nothing to do. // If there is no dynamic symtab or version table, there is nothing to do.
if (!DynSymRegion || !SymbolVersionSection) if (!DynSymRegion || !SymbolVersionSection)
return Error::success(); return Error::success();
▲ Show 20 Lines • Show All 6,021 Lines • Show Last 20 Lines

llvm/tools/llvm-readobj/MachODumper.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesprivate:
const MachOObjectFile *Obj; const MachOObjectFile *Obj;
}; };
} // namespace } // namespace
namespace llvm { namespace llvm {
std::error_code createMachODumper(const object::ObjectFile *Obj, std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
ScopedPrinter &Writer, ScopedPrinter &Writer) {
std::unique_ptr<ObjDumper> &Result) { return std::make_unique<MachODumper>(&Obj, Writer);
const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(Obj);
if (!MachOObj)
return readobj_error::unsupported_obj_file_format;
Result.reset(new MachODumper(MachOObj, Writer));
return readobj_error::success;
} }
} // namespace llvm } // namespace llvm
static const EnumEntry<uint32_t> MachOMagics[] = { static const EnumEntry<uint32_t> MachOMagics[] = {
{ "Magic", MachO::MH_MAGIC }, { "Magic", MachO::MH_MAGIC },
{ "Cigam", MachO::MH_CIGAM }, { "Cigam", MachO::MH_CIGAM },
{ "Magic64", MachO::MH_MAGIC_64 }, { "Magic64", MachO::MH_MAGIC_64 },
▲ Show 20 Lines • Show All 803 Lines • Show Last 20 Lines

llvm/tools/llvm-readobj/ObjDumper.h

Show All 14 Lines
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Object/ObjectFile.h" #include "llvm/Object/ObjectFile.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
namespace llvm { namespace llvm {
namespace object { namespace object {
class COFFImportFile; class COFFImportFile;
class ObjectFile; class ObjectFile;
class XCOFFObjectFile;
class ELFObjectFileBase;
} }
namespace codeview { namespace codeview {
class GlobalTypeTableBuilder; class GlobalTypeTableBuilder;
class MergingTypeTableBuilder; class MergingTypeTableBuilder;
} // namespace codeview } // namespace codeview
class ScopedPrinter; class ScopedPrinter;
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
private: private:
virtual void printSymbols() {} virtual void printSymbols() {}
virtual void printDynamicSymbols() {} virtual void printDynamicSymbols() {}
virtual void printProgramHeaders() {} virtual void printProgramHeaders() {}
virtual void printSectionMapping() {} virtual void printSectionMapping() {}
}; };
std::error_code createCOFFDumper(const object::ObjectFile *Obj, std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
ScopedPrinter &Writer, ScopedPrinter &Writer);
std::unique_ptr<ObjDumper> &Result);
std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
std::error_code createELFDumper(const object::ObjectFile *Obj, ScopedPrinter &Writer);
ScopedPrinter &Writer,
std::unique_ptr<ObjDumper> &Result); std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
ScopedPrinter &Writer);
std::error_code createMachODumper(const object::ObjectFile *Obj,
ScopedPrinter &Writer, std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
std::unique_ptr<ObjDumper> &Result); ScopedPrinter &Writer);
std::error_code createWasmDumper(const object::ObjectFile *Obj, std::unique_ptr<ObjDumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj,
ScopedPrinter &Writer, ScopedPrinter &Writer);
std::unique_ptr<ObjDumper> &Result);
std::error_code createXCOFFDumper(const object::ObjectFile *Obj,
ScopedPrinter &Writer,
std::unique_ptr<ObjDumper> &Result);
void dumpCOFFImportFile(const object::COFFImportFile *File, void dumpCOFFImportFile(const object::COFFImportFile *File,
ScopedPrinter &Writer); ScopedPrinter &Writer);
void dumpCodeViewMergedTypes(ScopedPrinter &Writer, void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
ArrayRef<ArrayRef<uint8_t>> IpiRecords, ArrayRef<ArrayRef<uint8_t>> IpiRecords,
ArrayRef<ArrayRef<uint8_t>> TpiRecords); ArrayRef<ArrayRef<uint8_t>> TpiRecords);
} // namespace llvm } // namespace llvm
#endif #endif

llvm/tools/llvm-readobj/WasmDumper.cpp

Show First 20 Lines • Show All 235 Lines • ▼ Show 20 Lines if (Symbol.Info.Kind != wasm::WASM_SYMBOL_TYPE_DATA) {
W.printHex("Size", Symbol.Info.DataRef.Size); W.printHex("Size", Symbol.Info.DataRef.Size);
} }
} }
} // namespace } // namespace
namespace llvm { namespace llvm {
std::error_code createWasmDumper(const object::ObjectFile *Obj, std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
ScopedPrinter &Writer, ScopedPrinter &Writer) {
std::unique_ptr<ObjDumper> &Result) { return std::make_unique<WasmDumper>(&Obj, Writer);
const auto *WasmObj = dyn_cast<WasmObjectFile>(Obj);
assert(WasmObj && "createWasmDumper called with non-wasm object");
Result.reset(new WasmDumper(WasmObj, Writer));
return readobj_error::success;
} }
} // namespace llvm } // namespace llvm

llvm/tools/llvm-readobj/XCOFFDumper.cpp

Show First 20 Lines • Show All 509 Lines • ▼ Show 20 Linesvoid XCOFFDumper::printSectionHeaders(ArrayRef<T> Sections) {
if (opts::SectionSymbols) if (opts::SectionSymbols)
report_fatal_error("Dumping symbols is unimplemented"); report_fatal_error("Dumping symbols is unimplemented");
if (opts::SectionData) if (opts::SectionData)
report_fatal_error("Dumping section data is unimplemented"); report_fatal_error("Dumping section data is unimplemented");
} }
namespace llvm { namespace llvm {
std::error_code createXCOFFDumper(const object::ObjectFile *Obj, std::unique_ptr<ObjDumper>
ScopedPrinter &Writer, createXCOFFDumper(const object::XCOFFObjectFile &XObj, ScopedPrinter &Writer) {
std::unique_ptr<ObjDumper> &Result) { return std::make_unique<XCOFFDumper>(XObj, Writer);
const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(Obj);
if (!XObj)
return readobj_error::unsupported_obj_file_format;
Result.reset(new XCOFFDumper(*XObj, Writer));
return readobj_error::success;
} }
} // namespace llvm } // namespace llvm

llvm/tools/llvm-readobj/llvm-readobj.cpp

Show All 20 Lines
#include "llvm-readobj.h" #include "llvm-readobj.h"
#include "Error.h" #include "Error.h"
#include "ObjDumper.h" #include "ObjDumper.h"
#include "WindowsResourceDumper.h" #include "WindowsResourceDumper.h"
#include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h" #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
#include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h" #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
#include "llvm/Object/Archive.h" #include "llvm/Object/Archive.h"
#include "llvm/Object/COFFImportFile.h" #include "llvm/Object/COFFImportFile.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Object/MachOUniversal.h" #include "llvm/Object/MachOUniversal.h"
#include "llvm/Object/ObjectFile.h" #include "llvm/Object/ObjectFile.h"
#include "llvm/Object/Wasm.h"
#include "llvm/Object/WindowsResource.h" #include "llvm/Object/WindowsResource.h"
#include "llvm/Object/XCOFFObjectFile.h"
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/DataTypes.h" #include "llvm/Support/DataTypes.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/InitLLVM.h" #include "llvm/Support/InitLLVM.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/ScopedPrinter.h"
#include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/WithColor.h" #include "llvm/Support/WithColor.h"
▲ Show 20 Lines • Show All 375 Lines • ▼ Show 20 Linesstruct ReadObjTypeTableBuilder {
llvm::codeview::GlobalTypeTableBuilder GlobalIDTable; llvm::codeview::GlobalTypeTableBuilder GlobalIDTable;
llvm::codeview::GlobalTypeTableBuilder GlobalTypeTable; llvm::codeview::GlobalTypeTableBuilder GlobalTypeTable;
std::vector<OwningBinary<Binary>> Binaries; std::vector<OwningBinary<Binary>> Binaries;
}; };
} // namespace } // namespace
static ReadObjTypeTableBuilder CVTypes; static ReadObjTypeTableBuilder CVTypes;
/// Creates an format-specific object file dumper. /// Creates an format-specific object file dumper.
static std::error_code createDumper(const ObjectFile *Obj, static Expected<std::unique_ptr<ObjDumper>>
ScopedPrinter &Writer, createDumper(const ObjectFile &Obj, ScopedPrinter &Writer) {
std::unique_ptr<ObjDumper> &Result) { if (const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(&Obj))
if (!Obj) return createCOFFDumper(*COFFObj, Writer);
return readobj_error::unsupported_file_format;
if (Obj->isCOFF())
return createCOFFDumper(Obj, Writer, Result);
if (Obj->isELF())
return createELFDumper(Obj, Writer, Result);
if (Obj->isMachO())
return createMachODumper(Obj, Writer, Result);
if (Obj->isWasm())
return createWasmDumper(Obj, Writer, Result);
if (Obj->isXCOFF())
return createXCOFFDumper(Obj, Writer, Result);
return readobj_error::unsupported_obj_file_format; if (const ELFObjectFileBase *ELFObj = dyn_cast<ELFObjectFileBase>(&Obj))
return createELFDumper(*ELFObj, Writer);
if (const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(&Obj))
return createMachODumper(*MachOObj, Writer);
if (const WasmObjectFile *WasmObj = dyn_cast<WasmObjectFile>(&Obj))
return createWasmDumper(*WasmObj, Writer);
if (const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(&Obj))
return createXCOFFDumper(*XObj, Writer);
return createStringError(errc::invalid_argument,
"unsupported object file format");
} }
/// Dumps the specified object file. /// Dumps the specified object file.
static void dumpObject(const ObjectFile *Obj, ScopedPrinter &Writer, static void dumpObject(const ObjectFile &Obj, ScopedPrinter &Writer,
const Archive *A = nullptr) { const Archive *A = nullptr) {
std::string FileStr = std::string FileStr =
A ? Twine(A->getFileName() + "(" + Obj->getFileName() + ")").str() A ? Twine(A->getFileName() + "(" + Obj.getFileName() + ")").str()
: Obj->getFileName().str(); : Obj.getFileName().str();
std::unique_ptr<ObjDumper> Dumper; ObjDumper *Dumper;
if (std::error_code EC = createDumper(Obj, Writer, Dumper)) Expected<std::unique_ptr<ObjDumper>> DumperOrErr = createDumper(Obj, Writer);
reportError(errorCodeToError(EC), FileStr); if (!DumperOrErr)
reportError(DumperOrErr.takeError(), FileStr);
Dumper = (*DumperOrErr).get();
if (opts::Output == opts::LLVM || opts::InputFilenames.size() > 1 || A) { if (opts::Output == opts::LLVM || opts::InputFilenames.size() > 1 || A) {
Writer.startLine() << "\n"; Writer.startLine() << "\n";
Writer.printString("File", FileStr); Writer.printString("File", FileStr);
} }
if (opts::Output == opts::LLVM) { if (opts::Output == opts::LLVM) {
Writer.printString("Format", Obj->getFileFormatName()); Writer.printString("Format", Obj.getFileFormatName());
Writer.printString("Arch", Triple::getArchTypeName( Writer.printString("Arch", Triple::getArchTypeName(Obj.getArch()));
(llvm::Triple::ArchType)Obj->getArch()));
Writer.printString( Writer.printString(
"AddressSize", "AddressSize",
std::string(formatv("{0}bit", 8 * Obj->getBytesInAddress()))); std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress())));
Dumper->printLoadName(); Dumper->printLoadName();
} }
if (opts::FileHeaders) if (opts::FileHeaders)
Dumper->printFileHeaders(); Dumper->printFileHeaders();
if (opts::SectionHeaders) if (opts::SectionHeaders)
Dumper->printSectionHeaders(); Dumper->printSectionHeaders();
if (opts::HashSymbols) if (opts::HashSymbols)
Dumper->printHashSymbols(); Dumper->printHashSymbols();
if (opts::ProgramHeaders || opts::SectionMapping == cl::BOU_TRUE) if (opts::ProgramHeaders || opts::SectionMapping == cl::BOU_TRUE)
Dumper->printProgramHeaders(opts::ProgramHeaders, opts::SectionMapping); Dumper->printProgramHeaders(opts::ProgramHeaders, opts::SectionMapping);
if (opts::DynamicTable) if (opts::DynamicTable)
Dumper->printDynamicTable(); Dumper->printDynamicTable();
if (opts::NeededLibraries) if (opts::NeededLibraries)
Dumper->printNeededLibraries(); Dumper->printNeededLibraries();
if (opts::Relocations) if (opts::Relocations)
Dumper->printRelocations(); Dumper->printRelocations();
if (opts::DynRelocs) if (opts::DynRelocs)
Dumper->printDynamicRelocations(); Dumper->printDynamicRelocations();
if (opts::UnwindInfo) if (opts::UnwindInfo)
Dumper->printUnwindInfo(); Dumper->printUnwindInfo();
if (opts::Symbols || opts::DynamicSymbols) if (opts::Symbols || opts::DynamicSymbols)
Dumper->printSymbols(opts::Symbols, opts::DynamicSymbols); Dumper->printSymbols(opts::Symbols, opts::DynamicSymbols);
if (!opts::StringDump.empty()) if (!opts::StringDump.empty())
Dumper->printSectionsAsString(Obj, opts::StringDump); Dumper->printSectionsAsString(&Obj, opts::StringDump);
if (!opts::HexDump.empty()) if (!opts::HexDump.empty())
Dumper->printSectionsAsHex(Obj, opts::HexDump); Dumper->printSectionsAsHex(&Obj, opts::HexDump);
if (opts::HashTable) if (opts::HashTable)
Dumper->printHashTable(); Dumper->printHashTable();
if (opts::GnuHashTable) if (opts::GnuHashTable)
Dumper->printGnuHashTable(Obj); Dumper->printGnuHashTable(&Obj);
if (opts::VersionInfo) if (opts::VersionInfo)
Dumper->printVersionInfo(); Dumper->printVersionInfo();
if (Obj->isELF()) { if (Obj.isELF()) {
if (opts::DependentLibraries) if (opts::DependentLibraries)
Dumper->printDependentLibs(); Dumper->printDependentLibs();
if (opts::ELFLinkerOptions) if (opts::ELFLinkerOptions)
Dumper->printELFLinkerOptions(); Dumper->printELFLinkerOptions();
if (opts::ArchSpecificInfo) if (opts::ArchSpecificInfo)
Dumper->printArchSpecificInfo(); Dumper->printArchSpecificInfo();
if (opts::SectionGroups) if (opts::SectionGroups)
Dumper->printGroupSections(); Dumper->printGroupSections();
if (opts::HashHistogram) if (opts::HashHistogram)
Dumper->printHashHistograms(); Dumper->printHashHistograms();
if (opts::CGProfile) if (opts::CGProfile)
Dumper->printCGProfile(); Dumper->printCGProfile();
if (opts::Addrsig) if (opts::Addrsig)
Dumper->printAddrsig(); Dumper->printAddrsig();
if (opts::Notes) if (opts::Notes)
Dumper->printNotes(); Dumper->printNotes();
} }
if (Obj->isCOFF()) { if (Obj.isCOFF()) {
if (opts::COFFImports) if (opts::COFFImports)
Dumper->printCOFFImports(); Dumper->printCOFFImports();
if (opts::COFFExports) if (opts::COFFExports)
Dumper->printCOFFExports(); Dumper->printCOFFExports();
if (opts::COFFDirectives) if (opts::COFFDirectives)
Dumper->printCOFFDirectives(); Dumper->printCOFFDirectives();
if (opts::COFFBaseRelocs) if (opts::COFFBaseRelocs)
Dumper->printCOFFBaseReloc(); Dumper->printCOFFBaseReloc();
Show All 9 Lines if (opts::Addrsig)
Dumper->printAddrsig(); Dumper->printAddrsig();
if (opts::CodeView) if (opts::CodeView)
Dumper->printCodeViewDebugInfo(); Dumper->printCodeViewDebugInfo();
if (opts::CodeViewMergedTypes) if (opts::CodeViewMergedTypes)
Dumper->mergeCodeViewTypes(CVTypes.IDTable, CVTypes.TypeTable, Dumper->mergeCodeViewTypes(CVTypes.IDTable, CVTypes.TypeTable,
CVTypes.GlobalIDTable, CVTypes.GlobalTypeTable, CVTypes.GlobalIDTable, CVTypes.GlobalTypeTable,
opts::CodeViewEnableGHash); opts::CodeViewEnableGHash);
} }
if (Obj->isMachO()) { if (Obj.isMachO()) {
if (opts::MachODataInCode) if (opts::MachODataInCode)
Dumper->printMachODataInCode(); Dumper->printMachODataInCode();
if (opts::MachOIndirectSymbols) if (opts::MachOIndirectSymbols)
Dumper->printMachOIndirectSymbols(); Dumper->printMachOIndirectSymbols();
if (opts::MachOLinkerOptions) if (opts::MachOLinkerOptions)
Dumper->printMachOLinkerOptions(); Dumper->printMachOLinkerOptions();
if (opts::MachOSegment) if (opts::MachOSegment)
Dumper->printMachOSegment(); Dumper->printMachOSegment();
Show All 14 Linesstatic void dumpArchive(const Archive *Arc, ScopedPrinter &Writer) {
for (auto &Child : Arc->children(Err)) { for (auto &Child : Arc->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary(); Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();
if (!ChildOrErr) { if (!ChildOrErr) {
if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
reportError(std::move(E), Arc->getFileName()); reportError(std::move(E), Arc->getFileName());
continue; continue;
} }
if (ObjectFile *Obj = dyn_cast<ObjectFile>(&*ChildOrErr.get())) if (ObjectFile *Obj = dyn_cast<ObjectFile>(&*ChildOrErr.get()))
dumpObject(Obj, Writer, Arc); dumpObject(*Obj, Writer, Arc);
else if (COFFImportFile *Imp = dyn_cast<COFFImportFile>(&*ChildOrErr.get())) else if (COFFImportFile *Imp = dyn_cast<COFFImportFile>(&*ChildOrErr.get()))
dumpCOFFImportFile(Imp, Writer); dumpCOFFImportFile(Imp, Writer);
else else
reportError(errorCodeToError(readobj_error::unrecognized_file_format), reportError(errorCodeToError(readobj_error::unrecognized_file_format),
Arc->getFileName()); Arc->getFileName());
} }
if (Err) if (Err)
reportError(std::move(Err), Arc->getFileName()); reportError(std::move(Err), Arc->getFileName());
} }
/// Dumps each object file in \a MachO Universal Binary; /// Dumps each object file in \a MachO Universal Binary;
static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary, static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary,
ScopedPrinter &Writer) { ScopedPrinter &Writer) {
for (const MachOUniversalBinary::ObjectForArch &Obj : UBinary->objects()) { for (const MachOUniversalBinary::ObjectForArch &Obj : UBinary->objects()) {
Expected<std::unique_ptr<MachOObjectFile>> ObjOrErr = Obj.getAsObjectFile(); Expected<std::unique_ptr<MachOObjectFile>> ObjOrErr = Obj.getAsObjectFile();
if (ObjOrErr) if (ObjOrErr)
dumpObject(&*ObjOrErr.get(), Writer); dumpObject(*ObjOrErr.get(), Writer);
else if (auto E = isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) else if (auto E = isNotObjectErrorInvalidFileType(ObjOrErr.takeError()))
reportError(ObjOrErr.takeError(), UBinary->getFileName()); reportError(ObjOrErr.takeError(), UBinary->getFileName());
else if (Expected<std::unique_ptr<Archive>> AOrErr = Obj.getAsArchive()) else if (Expected<std::unique_ptr<Archive>> AOrErr = Obj.getAsArchive())
dumpArchive(&*AOrErr.get(), Writer); dumpArchive(&*AOrErr.get(), Writer);
} }
} }
/// Dumps \a WinRes, Windows Resource (.res) file; /// Dumps \a WinRes, Windows Resource (.res) file;
Show All 14 Linesstatic void dumpInput(StringRef File, ScopedPrinter &Writer) {
Binary &Binary = *BinaryOrErr.get().getBinary(); Binary &Binary = *BinaryOrErr.get().getBinary();
if (Archive *Arc = dyn_cast<Archive>(&Binary)) if (Archive *Arc = dyn_cast<Archive>(&Binary))
dumpArchive(Arc, Writer); dumpArchive(Arc, Writer);
else if (MachOUniversalBinary *UBinary = else if (MachOUniversalBinary *UBinary =
dyn_cast<MachOUniversalBinary>(&Binary)) dyn_cast<MachOUniversalBinary>(&Binary))
dumpMachOUniversalBinary(UBinary, Writer); dumpMachOUniversalBinary(UBinary, Writer);
else if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary)) else if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary))
dumpObject(Obj, Writer); dumpObject(*Obj, Writer);
else if (COFFImportFile *Import = dyn_cast<COFFImportFile>(&Binary)) else if (COFFImportFile *Import = dyn_cast<COFFImportFile>(&Binary))
dumpCOFFImportFile(Import, Writer); dumpCOFFImportFile(Import, Writer);
else if (WindowsResource *WinRes = dyn_cast<WindowsResource>(&Binary)) else if (WindowsResource *WinRes = dyn_cast<WindowsResource>(&Binary))
dumpWindowsResourceFile(WinRes, Writer); dumpWindowsResourceFile(WinRes, Writer);
else else
reportError(errorCodeToError(readobj_error::unrecognized_file_format), reportError(errorCodeToError(readobj_error::unrecognized_file_format),
File); File);
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines