X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=tools%2Fllvm-objdump%2Fllvm-objdump.cpp;h=1204a973d45849ac61bff3ebc4c944859b8afdee;hp=d8460fdb247db86f9cd0f1e5cf71cccffae18acf;hb=88fa664c1bc7aec4e717d5bdbfd2ad334d36423b;hpb=341d0f4b9e8219024093a9cc35dd7b321eaaa0f1 diff --git a/tools/llvm-objdump/llvm-objdump.cpp b/tools/llvm-objdump/llvm-objdump.cpp index d8460fdb247..1204a973d45 100644 --- a/tools/llvm-objdump/llvm-objdump.cpp +++ b/tools/llvm-objdump/llvm-objdump.cpp @@ -17,24 +17,17 @@ //===----------------------------------------------------------------------===// #include "llvm-objdump.h" -#include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/Triple.h" #include "llvm/MC/MCAsmInfo.h" -#include "llvm/MC/MCAtom.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/MCDisassembler.h" -#include "llvm/MC/MCFunction.h" #include "llvm/MC/MCInst.h" #include "llvm/MC/MCInstPrinter.h" #include "llvm/MC/MCInstrAnalysis.h" #include "llvm/MC/MCInstrInfo.h" -#include "llvm/MC/MCModule.h" -#include "llvm/MC/MCModuleYAML.h" -#include "llvm/MC/MCObjectDisassembler.h" #include "llvm/MC/MCObjectFileInfo.h" -#include "llvm/MC/MCObjectSymbolizer.h" #include "llvm/MC/MCRegisterInfo.h" #include "llvm/MC/MCRelocationInfo.h" #include "llvm/MC/MCSubtargetInfo.h" @@ -51,17 +44,16 @@ #include "llvm/Support/Host.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/MemoryObject.h" #include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/Signals.h" #include "llvm/Support/SourceMgr.h" #include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetSelect.h" #include "llvm/Support/raw_ostream.h" -#include "llvm/Support/system_error.h" #include #include #include +#include using namespace llvm; using namespace object; @@ -69,21 +61,36 @@ using namespace object; static cl::list InputFilenames(cl::Positional, cl::desc(""),cl::ZeroOrMore); -static cl::opt -Disassemble("disassemble", +cl::opt +llvm::Disassemble("disassemble", cl::desc("Display assembler mnemonics for the machine instructions")); static cl::alias Disassembled("d", cl::desc("Alias for --disassemble"), cl::aliasopt(Disassemble)); -static cl::opt -Relocations("r", cl::desc("Display the relocation entries in the file")); +cl::opt +llvm::Relocations("r", cl::desc("Display the relocation entries in the file")); -static cl::opt -SectionContents("s", cl::desc("Display the content of each section")); +cl::opt +llvm::SectionContents("s", cl::desc("Display the content of each section")); -static cl::opt -SymbolTable("t", cl::desc("Display the symbol table")); +cl::opt +llvm::SymbolTable("t", cl::desc("Display the symbol table")); + +cl::opt +llvm::ExportsTrie("exports-trie", cl::desc("Display mach-o exported symbols")); + +cl::opt +llvm::Rebase("rebase", cl::desc("Display mach-o rebasing info")); + +cl::opt +llvm::Bind("bind", cl::desc("Display mach-o binding info")); + +cl::opt +llvm::LazyBind("lazy-bind", cl::desc("Display mach-o lazy binding info")); + +cl::opt +llvm::WeakBind("weak-bind", cl::desc("Display mach-o weak binding info")); static cl::opt MachOOpt("macho", cl::desc("Use MachO specific object file parser")); @@ -95,12 +102,18 @@ llvm::TripleName("triple", cl::desc("Target triple to disassemble for, " "see -version for available targets")); cl::opt -llvm::ArchName("arch", cl::desc("Target arch to disassemble for, " +llvm::MCPU("mcpu", + cl::desc("Target a specific cpu type (-mcpu=help for details)"), + cl::value_desc("cpu-name"), + cl::init("")); + +cl::opt +llvm::ArchName("arch-name", cl::desc("Target arch to disassemble for, " "see -version for available targets")); -static cl::opt -SectionHeaders("section-headers", cl::desc("Display summaries of the headers " - "for each section.")); +cl::opt +llvm::SectionHeaders("section-headers", cl::desc("Display summaries of the " + "headers for each section.")); static cl::alias SectionHeadersShort("headers", cl::desc("Alias for --section-headers"), cl::aliasopt(SectionHeaders)); @@ -108,57 +121,46 @@ static cl::alias SectionHeadersShorter("h", cl::desc("Alias for --section-headers"), cl::aliasopt(SectionHeaders)); -static cl::list -MAttrs("mattr", +cl::list +llvm::MAttrs("mattr", cl::CommaSeparated, cl::desc("Target specific attributes"), cl::value_desc("a1,+a2,-a3,...")); -static cl::opt -NoShowRawInsn("no-show-raw-insn", cl::desc("When disassembling instructions, " - "do not print the instruction bytes.")); +cl::opt +llvm::NoShowRawInsn("no-show-raw-insn", cl::desc("When disassembling " + "instructions, do not print " + "the instruction bytes.")); -static cl::opt -UnwindInfo("unwind-info", cl::desc("Display unwind information")); +cl::opt +llvm::UnwindInfo("unwind-info", cl::desc("Display unwind information")); static cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind-info"), cl::aliasopt(UnwindInfo)); -static cl::opt -PrivateHeaders("private-headers", - cl::desc("Display format specific file headers")); +cl::opt +llvm::PrivateHeaders("private-headers", + cl::desc("Display format specific file headers")); static cl::alias PrivateHeadersShort("p", cl::desc("Alias for --private-headers"), cl::aliasopt(PrivateHeaders)); -static cl::opt -Symbolize("symbolize", cl::desc("When disassembling instructions, " - "try to symbolize operands.")); - -static cl::opt -CFG("cfg", cl::desc("Create a CFG for every function found in the object" - " and write it to a graphviz file")); - -// FIXME: Does it make sense to have a dedicated tool for yaml cfg output? -static cl::opt -YAMLCFG("yaml-cfg", - cl::desc("Create a CFG and write it as a YAML MCModule."), - cl::value_desc("yaml output file")); - static StringRef ToolName; +static int ReturnValue = EXIT_SUCCESS; -bool llvm::error(error_code EC) { +bool llvm::error(std::error_code EC) { if (!EC) return false; outs() << ToolName << ": error reading file: " << EC.message() << ".\n"; outs().flush(); + ReturnValue = EXIT_FAILURE; return true; } -static const Target *getTarget(const ObjectFile *Obj = NULL) { +static const Target *getTarget(const ObjectFile *Obj = nullptr) { // Figure out the target triple. llvm::Triple TheTriple("unknown-unknown-unknown"); if (TripleName.empty()) { @@ -167,7 +169,13 @@ static const Target *getTarget(const ObjectFile *Obj = NULL) { // TheTriple defaults to ELF, and COFF doesn't have an environment: // the best we can do here is indicate that it is mach-o. if (Obj->isMachO()) - TheTriple.setEnvironment(Triple::MachO); + TheTriple.setObjectFormat(Triple::MachO); + + if (Obj->isCOFF()) { + const auto COFFObj = dyn_cast(Obj); + if (COFFObj->getArch() == Triple::thumb) + TheTriple.setTriple("thumbv7-windows"); + } } } else TheTriple.setTriple(Triple::normalize(TripleName)); @@ -178,7 +186,7 @@ static const Target *getTarget(const ObjectFile *Obj = NULL) { Error); if (!TheTarget) { errs() << ToolName << ": " << Error; - return 0; + return nullptr; } // Update the triple name and return the found target. @@ -186,53 +194,6 @@ static const Target *getTarget(const ObjectFile *Obj = NULL) { return TheTarget; } -// Write a graphviz file for the CFG inside an MCFunction. -// FIXME: Use GraphWriter -static void emitDOTFile(const char *FileName, const MCFunction &f, - MCInstPrinter *IP) { - // Start a new dot file. - std::string Error; - raw_fd_ostream Out(FileName, Error, sys::fs::F_Text); - if (!Error.empty()) { - errs() << "llvm-objdump: warning: " << Error << '\n'; - return; - } - - Out << "digraph \"" << f.getName() << "\" {\n"; - Out << "graph [ rankdir = \"LR\" ];\n"; - for (MCFunction::const_iterator i = f.begin(), e = f.end(); i != e; ++i) { - // Only print blocks that have predecessors. - bool hasPreds = (*i)->pred_begin() != (*i)->pred_end(); - - if (!hasPreds && i != f.begin()) - continue; - - Out << '"' << (*i)->getInsts()->getBeginAddr() << "\" [ label=\""; - // Print instructions. - for (unsigned ii = 0, ie = (*i)->getInsts()->size(); ii != ie; - ++ii) { - if (ii != 0) // Not the first line, start a new row. - Out << '|'; - if (ii + 1 == ie) // Last line, add an end id. - Out << ""; - - // Escape special chars and print the instruction in mnemonic form. - std::string Str; - raw_string_ostream OS(Str); - IP->printInst(&(*i)->getInsts()->at(ii).Inst, OS, ""); - Out << DOT::EscapeString(OS.str()); - } - Out << "\" shape=\"record\" ];\n"; - - // Add edges. - for (MCBasicBlock::succ_const_iterator si = (*i)->succ_begin(), - se = (*i)->succ_end(); si != se; ++si) - Out << (*i)->getInsts()->getBeginAddr() << ":o -> " - << (*si)->getInsts()->getBeginAddr() << ":a\n"; - } - Out << "}\n"; -} - void llvm::DumpBytes(StringRef bytes) { static const char hex_rep[] = "0123456789abcdef"; // FIXME: The real way to do this is to figure out the longest instruction @@ -282,60 +243,50 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { FeaturesStr = Features.getString(); } - OwningPtr MRI(TheTarget->createMCRegInfo(TripleName)); + std::unique_ptr MRI( + TheTarget->createMCRegInfo(TripleName)); if (!MRI) { errs() << "error: no register info for target " << TripleName << "\n"; return; } // Set up disassembler. - OwningPtr AsmInfo( - TheTarget->createMCAsmInfo(*MRI, TripleName)); + std::unique_ptr AsmInfo( + TheTarget->createMCAsmInfo(*MRI, TripleName)); if (!AsmInfo) { errs() << "error: no assembly info for target " << TripleName << "\n"; return; } - OwningPtr STI( - TheTarget->createMCSubtargetInfo(TripleName, "", FeaturesStr)); + std::unique_ptr STI( + TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr)); if (!STI) { errs() << "error: no subtarget info for target " << TripleName << "\n"; return; } - OwningPtr MII(TheTarget->createMCInstrInfo()); + std::unique_ptr MII(TheTarget->createMCInstrInfo()); if (!MII) { errs() << "error: no instruction info for target " << TripleName << "\n"; return; } - OwningPtr DisAsm(TheTarget->createMCDisassembler(*STI)); + std::unique_ptr MOFI(new MCObjectFileInfo); + MCContext Ctx(AsmInfo.get(), MRI.get(), MOFI.get()); + + std::unique_ptr DisAsm( + TheTarget->createMCDisassembler(*STI, Ctx)); + if (!DisAsm) { errs() << "error: no disassembler for target " << TripleName << "\n"; return; } - OwningPtr MOFI; - OwningPtr Ctx; - - if (Symbolize) { - MOFI.reset(new MCObjectFileInfo); - Ctx.reset(new MCContext(AsmInfo.get(), MRI.get(), MOFI.get())); - OwningPtr RelInfo( - TheTarget->createMCRelocationInfo(TripleName, *Ctx.get())); - if (RelInfo) { - OwningPtr Symzer( - MCObjectSymbolizer::createObjectSymbolizer(*Ctx.get(), RelInfo, Obj)); - if (Symzer) - DisAsm->setSymbolizer(Symzer); - } - } - - OwningPtr - MIA(TheTarget->createMCInstrAnalysis(MII.get())); + std::unique_ptr MIA( + TheTarget->createMCInstrAnalysis(MII.get())); int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); - OwningPtr IP(TheTarget->createMCInstPrinter( + std::unique_ptr IP(TheTarget->createMCInstPrinter( AsmPrinterVariant, *AsmInfo, *MII, *MRI, *STI)); if (!IP) { errs() << "error: no instruction printer for target " << TripleName @@ -343,80 +294,34 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { return; } - if (CFG || !YAMLCFG.empty()) { - OwningPtr OD( - new MCObjectDisassembler(*Obj, *DisAsm, *MIA)); - OwningPtr Mod(OD->buildModule(/* withCFG */ true)); - for (MCModule::const_atom_iterator AI = Mod->atom_begin(), - AE = Mod->atom_end(); - AI != AE; ++AI) { - outs() << "Atom " << (*AI)->getName() << ": \n"; - if (const MCTextAtom *TA = dyn_cast(*AI)) { - for (MCTextAtom::const_iterator II = TA->begin(), IE = TA->end(); - II != IE; - ++II) { - IP->printInst(&II->Inst, outs(), ""); - outs() << "\n"; - } - } - } - if (CFG) { - for (MCModule::const_func_iterator FI = Mod->func_begin(), - FE = Mod->func_end(); - FI != FE; ++FI) { - static int filenum = 0; - emitDOTFile((Twine((*FI)->getName()) + "_" + - utostr(filenum) + ".dot").str().c_str(), - **FI, IP.get()); - ++filenum; - } - } - if (!YAMLCFG.empty()) { - std::string Error; - raw_fd_ostream YAMLOut(YAMLCFG.c_str(), Error, sys::fs::F_Text); - if (!Error.empty()) { - errs() << ToolName << ": warning: " << Error << '\n'; - return; - } - mcmodule2yaml(YAMLOut, *Mod, *MII, *MRI); - } - } + StringRef Fmt = Obj->getBytesInAddress() > 4 ? "\t\t%016" PRIx64 ": " : + "\t\t\t%08" PRIx64 ": "; // Create a mapping, RelocSecs = SectionRelocMap[S], where sections // in RelocSecs contain the relocations for section S. - error_code EC; - std::map > SectionRelocMap; - for (section_iterator I = Obj->section_begin(), E = Obj->section_end(); - I != E; ++I) { - section_iterator Sec2 = I->getRelocatedSection(); + std::error_code EC; + std::map> SectionRelocMap; + for (const SectionRef &Section : Obj->sections()) { + section_iterator Sec2 = Section.getRelocatedSection(); if (Sec2 != Obj->section_end()) - SectionRelocMap[*Sec2].push_back(*I); + SectionRelocMap[*Sec2].push_back(Section); } - for (section_iterator I = Obj->section_begin(), E = Obj->section_end(); - I != E; ++I) { - bool Text; - if (error(I->isText(Text))) - break; - if (!Text) + for (const SectionRef &Section : Obj->sections()) { + if (!Section.isText() || Section.isVirtual()) continue; - uint64_t SectionAddr; - if (error(I->getAddress(SectionAddr))) - break; - - uint64_t SectSize; - if (error(I->getSize(SectSize))) - break; + uint64_t SectionAddr = Section.getAddress(); + uint64_t SectSize = Section.getSize(); + if (!SectSize) + continue; // Make a list of all the symbols in this section. - std::vector > Symbols; - for (symbol_iterator SI = Obj->symbol_begin(), SE = Obj->symbol_end(); - SI != SE; ++SI) { - bool contains; - if (!error(I->containsSymbol(*SI, contains)) && contains) { + std::vector> Symbols; + for (const SymbolRef &Symbol : Obj->symbols()) { + if (Section.containsSymbol(Symbol)) { uint64_t Address; - if (error(SI->getAddress(Address))) + if (error(Symbol.getAddress(Address))) break; if (Address == UnknownAddressOrSize) continue; @@ -425,7 +330,7 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { continue; StringRef Name; - if (error(SI->getName(Name))) + if (error(Symbol.getName(Name))) break; Symbols.push_back(std::make_pair(Address, Name)); } @@ -437,14 +342,10 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { // Make a list of all the relocations for this section. std::vector Rels; if (InlineRelocs) { - SmallVectorImpl *RelocSecs = &SectionRelocMap[*I]; - for (SmallVectorImpl::iterator RelocSec = RelocSecs->begin(), - E = RelocSecs->end(); - RelocSec != E; ++RelocSec) { - for (relocation_iterator RI = RelocSec->relocation_begin(), - RE = RelocSec->relocation_end(); - RI != RE; ++RI) - Rels.push_back(*RI); + for (const SectionRef &RelocSec : SectionRelocMap[Section]) { + for (const RelocationRef &Reloc : RelocSec.relocations()) { + Rels.push_back(Reloc); + } } } @@ -453,11 +354,11 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { StringRef SegmentName = ""; if (const MachOObjectFile *MachO = dyn_cast(Obj)) { - DataRefImpl DR = I->getRawDataRefImpl(); + DataRefImpl DR = Section.getRawDataRefImpl(); SegmentName = MachO->getSectionFinalSegmentName(DR); } StringRef name; - if (error(I->getName(name))) + if (error(Section.getName(name))) break; outs() << "Disassembly of section "; if (!SegmentName.empty()) @@ -473,10 +374,12 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { SmallString<40> Comments; raw_svector_ostream CommentStream(Comments); - StringRef Bytes; - if (error(I->getContents(Bytes))) + StringRef BytesStr; + if (error(Section.getContents(BytesStr))) break; - StringRefMemoryObject memoryObject(Bytes, SectionAddr); + ArrayRef Bytes(reinterpret_cast(BytesStr.data()), + BytesStr.size()); + uint64_t Size; uint64_t Index; @@ -484,17 +387,12 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { std::vector::const_iterator rel_end = Rels.end(); // Disassemble symbol by symbol. for (unsigned si = 0, se = Symbols.size(); si != se; ++si) { + uint64_t Start = Symbols[si].first; - uint64_t End; - // The end is either the size of the section or the beginning of the next - // symbol. - if (si == se - 1) - End = SectSize; - // Make sure this symbol takes up space. - else if (Symbols[si + 1].first != Start) - End = Symbols[si + 1].first - 1; - else - // This symbol has the same address as the next symbol. Skip it. + // The end is either the section end or the beginning of the next symbol. + uint64_t End = (si == se - 1) ? SectSize : Symbols[si + 1].first; + // If this symbol has the same address as the next symbol, then skip it. + if (Start == End) continue; outs() << '\n' << Symbols[si].second << ":\n"; @@ -508,13 +406,14 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { for (Index = Start; Index < End; Index += Size) { MCInst Inst; - if (DisAsm->getInstruction(Inst, Size, memoryObject, - SectionAddr + Index, - DebugOut, CommentStream)) { + if (DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), + SectionAddr + Index, DebugOut, + CommentStream)) { outs() << format("%8" PRIx64 ":", SectionAddr + Index); if (!NoShowRawInsn) { outs() << "\t"; - DumpBytes(StringRef(Bytes.data() + Index, Size)); + DumpBytes(StringRef( + reinterpret_cast(Bytes.data()) + Index, Size)); } IP->printInst(&Inst, outs(), ""); outs() << CommentStream.str(); @@ -543,7 +442,7 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { if (error(rel_cur->getTypeName(name))) goto skip_print_rel; if (error(rel_cur->getValueString(val))) goto skip_print_rel; - outs() << format("\t\t\t%8" PRIx64 ": ", SectionAddr + addr) << name + outs() << format(Fmt.data(), SectionAddr + addr) << name << "\t" << val << "\n"; skip_print_rel: @@ -554,78 +453,87 @@ static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { } } -static void PrintRelocations(const ObjectFile *o) { - for (section_iterator si = o->section_begin(), se = o->section_end(); - si != se; ++si) { - if (si->relocation_begin() == si->relocation_end()) +void llvm::PrintRelocations(const ObjectFile *Obj) { + StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 : + "%08" PRIx64; + // Regular objdump doesn't print relocations in non-relocatable object + // files. + if (!Obj->isRelocatableObject()) + return; + + for (const SectionRef &Section : Obj->sections()) { + if (Section.relocation_begin() == Section.relocation_end()) continue; StringRef secname; - if (error(si->getName(secname))) continue; + if (error(Section.getName(secname))) + continue; outs() << "RELOCATION RECORDS FOR [" << secname << "]:\n"; - for (relocation_iterator ri = si->relocation_begin(), - re = si->relocation_end(); - ri != re; ++ri) { + for (const RelocationRef &Reloc : Section.relocations()) { bool hidden; uint64_t address; SmallString<32> relocname; SmallString<32> valuestr; - if (error(ri->getHidden(hidden))) continue; - if (hidden) continue; - if (error(ri->getTypeName(relocname))) continue; - if (error(ri->getOffset(address))) continue; - if (error(ri->getValueString(valuestr))) continue; - outs() << address << " " << relocname << " " << valuestr << "\n"; + if (error(Reloc.getHidden(hidden))) + continue; + if (hidden) + continue; + if (error(Reloc.getTypeName(relocname))) + continue; + if (error(Reloc.getOffset(address))) + continue; + if (error(Reloc.getValueString(valuestr))) + continue; + outs() << format(Fmt.data(), address) << " " << relocname << " " + << valuestr << "\n"; } outs() << "\n"; } } -static void PrintSectionHeaders(const ObjectFile *o) { +void llvm::PrintSectionHeaders(const ObjectFile *Obj) { outs() << "Sections:\n" "Idx Name Size Address Type\n"; unsigned i = 0; - for (section_iterator si = o->section_begin(), se = o->section_end(); - si != se; ++si) { + for (const SectionRef &Section : Obj->sections()) { StringRef Name; - if (error(si->getName(Name))) + if (error(Section.getName(Name))) return; - uint64_t Address; - if (error(si->getAddress(Address))) return; - uint64_t Size; - if (error(si->getSize(Size))) return; - bool Text, Data, BSS; - if (error(si->isText(Text))) return; - if (error(si->isData(Data))) return; - if (error(si->isBSS(BSS))) return; + uint64_t Address = Section.getAddress(); + uint64_t Size = Section.getSize(); + bool Text = Section.isText(); + bool Data = Section.isData(); + bool BSS = Section.isBSS(); std::string Type = (std::string(Text ? "TEXT " : "") + (Data ? "DATA " : "") + (BSS ? "BSS" : "")); - outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n", - i, Name.str().c_str(), Size, Address, Type.c_str()); + outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n", i, + Name.str().c_str(), Size, Address, Type.c_str()); ++i; } } -static void PrintSectionContents(const ObjectFile *o) { - error_code EC; - for (section_iterator si = o->section_begin(), se = o->section_end(); - si != se; ++si) { +void llvm::PrintSectionContents(const ObjectFile *Obj) { + std::error_code EC; + for (const SectionRef &Section : Obj->sections()) { StringRef Name; StringRef Contents; - uint64_t BaseAddr; - bool BSS; - if (error(si->getName(Name))) continue; - if (error(si->getContents(Contents))) continue; - if (error(si->getAddress(BaseAddr))) continue; - if (error(si->isBSS(BSS))) continue; + if (error(Section.getName(Name))) + continue; + uint64_t BaseAddr = Section.getAddress(); + uint64_t Size = Section.getSize(); + if (!Size) + continue; outs() << "Contents of section " << Name << ":\n"; - if (BSS) { + if (Section.isBSS()) { outs() << format("\n", BaseAddr, - BaseAddr + Contents.size()); + ", %04" PRIx64 ")>\n", + BaseAddr, BaseAddr + Size); continue; } + if (error(Section.getContents(Contents))) + continue; + // Dump out the content as hex and printable ascii characters. for (std::size_t addr = 0, end = Contents.size(); addr < end; addr += 16) { outs() << format(" %04" PRIx64 " ", BaseAddr + addr); @@ -653,18 +561,32 @@ static void PrintSectionContents(const ObjectFile *o) { } static void PrintCOFFSymbolTable(const COFFObjectFile *coff) { - const coff_file_header *header; - if (error(coff->getHeader(header))) return; - int aux_count = 0; - const coff_symbol *symbol = 0; - for (int i = 0, e = header->NumberOfSymbols; i != e; ++i) { - if (aux_count--) { - // Figure out which type of aux this is. - if (symbol->StorageClass == COFF::IMAGE_SYM_CLASS_STATIC - && symbol->Value == 0) { // Section definition. + for (unsigned SI = 0, SE = coff->getNumberOfSymbols(); SI != SE; ++SI) { + ErrorOr Symbol = coff->getSymbol(SI); + StringRef Name; + if (error(Symbol.getError())) + return; + + if (error(coff->getSymbolName(*Symbol, Name))) + return; + + outs() << "[" << format("%2d", SI) << "]" + << "(sec " << format("%2d", int(Symbol->getSectionNumber())) << ")" + << "(fl 0x00)" // Flag bits, which COFF doesn't have. + << "(ty " << format("%3x", unsigned(Symbol->getType())) << ")" + << "(scl " << format("%3x", unsigned(Symbol->getStorageClass())) << ") " + << "(nx " << unsigned(Symbol->getNumberOfAuxSymbols()) << ") " + << "0x" << format("%08x", unsigned(Symbol->getValue())) << " " + << Name << "\n"; + + for (unsigned AI = 0, AE = Symbol->getNumberOfAuxSymbols(); AI < AE; ++AI, ++SI) { + if (Symbol->isSectionDefinition()) { const coff_aux_section_definition *asd; - if (error(coff->getAuxSymbol(i, asd))) + if (error(coff->getAuxSymbol(SI + 1, asd))) return; + + int32_t AuxNumber = asd->getNumber(Symbol->isBigObj()); + outs() << "AUX " << format("scnlen 0x%x nreloc %d nlnno %d checksum 0x%x " , unsigned(asd->Length) @@ -672,99 +594,112 @@ static void PrintCOFFSymbolTable(const COFFObjectFile *coff) { , unsigned(asd->NumberOfLinenumbers) , unsigned(asd->CheckSum)) << format("assoc %d comdat %d\n" - , unsigned(asd->Number) + , unsigned(AuxNumber) , unsigned(asd->Selection)); - } else + } else if (Symbol->isFileRecord()) { + const char *FileName; + if (error(coff->getAuxSymbol(SI + 1, FileName))) + return; + + StringRef Name(FileName, Symbol->getNumberOfAuxSymbols() * + coff->getSymbolTableEntrySize()); + outs() << "AUX " << Name.rtrim(StringRef("\0", 1)) << '\n'; + + SI = SI + Symbol->getNumberOfAuxSymbols(); + break; + } else { outs() << "AUX Unknown\n"; - } else { - StringRef name; - if (error(coff->getSymbol(i, symbol))) return; - if (error(coff->getSymbolName(symbol, name))) return; - outs() << "[" << format("%2d", i) << "]" - << "(sec " << format("%2d", int(symbol->SectionNumber)) << ")" - << "(fl 0x00)" // Flag bits, which COFF doesn't have. - << "(ty " << format("%3x", unsigned(symbol->Type)) << ")" - << "(scl " << format("%3x", unsigned(symbol->StorageClass)) << ") " - << "(nx " << unsigned(symbol->NumberOfAuxSymbols) << ") " - << "0x" << format("%08x", unsigned(symbol->Value)) << " " - << name << "\n"; - aux_count = symbol->NumberOfAuxSymbols; + } } } } -static void PrintSymbolTable(const ObjectFile *o) { +void llvm::PrintSymbolTable(const ObjectFile *o) { outs() << "SYMBOL TABLE:\n"; - if (const COFFObjectFile *coff = dyn_cast(o)) + if (const COFFObjectFile *coff = dyn_cast(o)) { PrintCOFFSymbolTable(coff); - else { - for (symbol_iterator si = o->symbol_begin(), se = o->symbol_end(); - si != se; ++si) { - StringRef Name; - uint64_t Address; - SymbolRef::Type Type; - uint64_t Size; - uint32_t Flags = si->getFlags(); - section_iterator Section = o->section_end(); - if (error(si->getName(Name))) continue; - if (error(si->getAddress(Address))) continue; - if (error(si->getType(Type))) continue; - if (error(si->getSize(Size))) continue; - if (error(si->getSection(Section))) continue; - - bool Global = Flags & SymbolRef::SF_Global; - bool Weak = Flags & SymbolRef::SF_Weak; - bool Absolute = Flags & SymbolRef::SF_Absolute; - - if (Address == UnknownAddressOrSize) - Address = 0; - if (Size == UnknownAddressOrSize) - Size = 0; - char GlobLoc = ' '; - if (Type != SymbolRef::ST_Unknown) - GlobLoc = Global ? 'g' : 'l'; - char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File) - ? 'd' : ' '; - char FileFunc = ' '; - if (Type == SymbolRef::ST_File) - FileFunc = 'f'; - else if (Type == SymbolRef::ST_Function) - FileFunc = 'F'; - - const char *Fmt = o->getBytesInAddress() > 4 ? "%016" PRIx64 : - "%08" PRIx64; - - outs() << format(Fmt, Address) << " " - << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' ' - << (Weak ? 'w' : ' ') // Weak? - << ' ' // Constructor. Not supported yet. - << ' ' // Warning. Not supported yet. - << ' ' // Indirect reference to another symbol. - << Debug // Debugging (d) or dynamic (D) symbol. - << FileFunc // Name of function (F), file (f) or object (O). - << ' '; - if (Absolute) - outs() << "*ABS*"; - else if (Section == o->section_end()) - outs() << "*UND*"; - else { - if (const MachOObjectFile *MachO = - dyn_cast(o)) { - DataRefImpl DR = Section->getRawDataRefImpl(); - StringRef SegmentName = MachO->getSectionFinalSegmentName(DR); - outs() << SegmentName << ","; - } - StringRef SectionName; - if (error(Section->getName(SectionName))) - SectionName = ""; - outs() << SectionName; + return; + } + for (const SymbolRef &Symbol : o->symbols()) { + StringRef Name; + uint64_t Address; + SymbolRef::Type Type; + uint64_t Size; + uint32_t Flags = Symbol.getFlags(); + section_iterator Section = o->section_end(); + if (error(Symbol.getName(Name))) + continue; + if (error(Symbol.getAddress(Address))) + continue; + if (error(Symbol.getType(Type))) + continue; + if (error(Symbol.getSize(Size))) + continue; + if (error(Symbol.getSection(Section))) + continue; + + bool Global = Flags & SymbolRef::SF_Global; + bool Weak = Flags & SymbolRef::SF_Weak; + bool Absolute = Flags & SymbolRef::SF_Absolute; + bool Common = Flags & SymbolRef::SF_Common; + + if (Common) { + uint32_t Alignment; + if (error(Symbol.getAlignment(Alignment))) + Alignment = 0; + Address = Size; + Size = Alignment; + } + if (Address == UnknownAddressOrSize) + Address = 0; + if (Size == UnknownAddressOrSize) + Size = 0; + char GlobLoc = ' '; + if (Type != SymbolRef::ST_Unknown) + GlobLoc = Global ? 'g' : 'l'; + char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File) + ? 'd' : ' '; + char FileFunc = ' '; + if (Type == SymbolRef::ST_File) + FileFunc = 'f'; + else if (Type == SymbolRef::ST_Function) + FileFunc = 'F'; + + const char *Fmt = o->getBytesInAddress() > 4 ? "%016" PRIx64 : + "%08" PRIx64; + + outs() << format(Fmt, Address) << " " + << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' ' + << (Weak ? 'w' : ' ') // Weak? + << ' ' // Constructor. Not supported yet. + << ' ' // Warning. Not supported yet. + << ' ' // Indirect reference to another symbol. + << Debug // Debugging (d) or dynamic (D) symbol. + << FileFunc // Name of function (F), file (f) or object (O). + << ' '; + if (Absolute) { + outs() << "*ABS*"; + } else if (Common) { + outs() << "*COM*"; + } else if (Section == o->section_end()) { + outs() << "*UND*"; + } else { + if (const MachOObjectFile *MachO = + dyn_cast(o)) { + DataRefImpl DR = Section->getRawDataRefImpl(); + StringRef SegmentName = MachO->getSectionFinalSegmentName(DR); + outs() << SegmentName << ","; } - outs() << '\t' - << format("%08" PRIx64 " ", Size) - << Name - << '\n'; + StringRef SectionName; + if (error(Section->getName(SectionName))) + SectionName = ""; + outs() << SectionName; } + outs() << '\t' + << format("%08" PRIx64 " ", Size) + << Name + << '\n'; } } @@ -773,10 +708,67 @@ static void PrintUnwindInfo(const ObjectFile *o) { if (const COFFObjectFile *coff = dyn_cast(o)) { printCOFFUnwindInfo(coff); - } else { + } else if (const MachOObjectFile *MachO = dyn_cast(o)) + printMachOUnwindInfo(MachO); + else { // TODO: Extract DWARF dump tool to objdump. errs() << "This operation is only currently supported " - "for COFF object files.\n"; + "for COFF and MachO object files.\n"; + return; + } +} + +void llvm::printExportsTrie(const ObjectFile *o) { + outs() << "Exports trie:\n"; + if (const MachOObjectFile *MachO = dyn_cast(o)) + printMachOExportsTrie(MachO); + else { + errs() << "This operation is only currently supported " + "for Mach-O executable files.\n"; + return; + } +} + +void llvm::printRebaseTable(const ObjectFile *o) { + outs() << "Rebase table:\n"; + if (const MachOObjectFile *MachO = dyn_cast(o)) + printMachORebaseTable(MachO); + else { + errs() << "This operation is only currently supported " + "for Mach-O executable files.\n"; + return; + } +} + +void llvm::printBindTable(const ObjectFile *o) { + outs() << "Bind table:\n"; + if (const MachOObjectFile *MachO = dyn_cast(o)) + printMachOBindTable(MachO); + else { + errs() << "This operation is only currently supported " + "for Mach-O executable files.\n"; + return; + } +} + +void llvm::printLazyBindTable(const ObjectFile *o) { + outs() << "Lazy bind table:\n"; + if (const MachOObjectFile *MachO = dyn_cast(o)) + printMachOLazyBindTable(MachO); + else { + errs() << "This operation is only currently supported " + "for Mach-O executable files.\n"; + return; + } +} + +void llvm::printWeakBindTable(const ObjectFile *o) { + outs() << "Weak bind table:\n"; + if (const MachOObjectFile *MachO = dyn_cast(o)) + printMachOWeakBindTable(MachO); + else { + errs() << "This operation is only currently supported " + "for Mach-O executable files.\n"; return; } } @@ -786,6 +778,8 @@ static void printPrivateFileHeader(const ObjectFile *o) { printELFFileHeader(o); } else if (o->isCOFF()) { printCOFFFileHeader(o); + } else if (o->isMachO()) { + printMachOFileHeader(o); } } @@ -808,21 +802,31 @@ static void DumpObject(const ObjectFile *o) { PrintUnwindInfo(o); if (PrivateHeaders) printPrivateFileHeader(o); + if (ExportsTrie) + printExportsTrie(o); + if (Rebase) + printRebaseTable(o); + if (Bind) + printBindTable(o); + if (LazyBind) + printLazyBindTable(o); + if (WeakBind) + printWeakBindTable(o); } /// @brief Dump each object file in \a a; static void DumpArchive(const Archive *a) { for (Archive::child_iterator i = a->child_begin(), e = a->child_end(); i != e; ++i) { - OwningPtr child; - if (error_code EC = i->getAsBinary(child)) { + ErrorOr> ChildOrErr = i->getAsBinary(); + if (std::error_code EC = ChildOrErr.getError()) { // Ignore non-object files. if (EC != object_error::invalid_file_type) errs() << ToolName << ": '" << a->getFileName() << "': " << EC.message() << ".\n"; continue; } - if (ObjectFile *o = dyn_cast(child.get())) + if (ObjectFile *o = dyn_cast(&*ChildOrErr.get())) DumpObject(o); else errs() << ToolName << ": '" << a->getFileName() << "': " @@ -838,22 +842,25 @@ static void DumpInput(StringRef file) { return; } - if (MachOOpt && Disassemble) { - DisassembleInputMachO(file); + // If we are using the Mach-O specific object file parser, then let it parse + // the file and process the command line options. So the -arch flags can + // be used to select specific slices, etc. + if (MachOOpt) { + ParseInputMachO(file); return; } // Attempt to open the binary. - ErrorOr BinaryOrErr = createBinary(file); - if (error_code EC = BinaryOrErr.getError()) { + ErrorOr> BinaryOrErr = createBinary(file); + if (std::error_code EC = BinaryOrErr.getError()) { errs() << ToolName << ": '" << file << "': " << EC.message() << ".\n"; return; } - OwningPtr binary(BinaryOrErr.get()); + Binary &Binary = *BinaryOrErr.get().getBinary(); - if (Archive *a = dyn_cast(binary.get())) + if (Archive *a = dyn_cast(&Binary)) DumpArchive(a); - else if (ObjectFile *o = dyn_cast(binary.get())) + else if (ObjectFile *o = dyn_cast(&Binary)) DumpObject(o); else errs() << ToolName << ": '" << file << "': " << "Unrecognized file type.\n"; @@ -889,7 +896,16 @@ int main(int argc, char **argv) { && !SectionContents && !SymbolTable && !UnwindInfo - && !PrivateHeaders) { + && !PrivateHeaders + && !ExportsTrie + && !Rebase + && !Bind + && !LazyBind + && !WeakBind + && !(UniversalHeaders && MachOOpt) + && !(ArchiveHeaders && MachOOpt) + && !(IndirectSymbols && MachOOpt) + && !(DataInCode && MachOOpt)) { cl::PrintHelpMessage(); return 2; } @@ -897,5 +913,5 @@ int main(int argc, char **argv) { std::for_each(InputFilenames.begin(), InputFilenames.end(), DumpInput); - return 0; + return ReturnValue; }