1 //===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This program is a utility that works like binutils "objdump", that is, it 11 // dumps out a plethora of information about an object file depending on the 12 // flags. 13 // 14 // The flags and output of this program should be near identical to those of 15 // binutils objdump. 16 // 17 //===----------------------------------------------------------------------===// 18 19 #include "llvm-objdump.h" 20 #include "llvm/ADT/STLExtras.h" 21 #include "llvm/ADT/StringExtras.h" 22 #include "llvm/ADT/Triple.h" 23 #include "llvm/MC/MCAsmInfo.h" 24 #include "llvm/MC/MCContext.h" 25 #include "llvm/MC/MCDisassembler.h" 26 #include "llvm/MC/MCInst.h" 27 #include "llvm/MC/MCInstPrinter.h" 28 #include "llvm/MC/MCInstrAnalysis.h" 29 #include "llvm/MC/MCInstrInfo.h" 30 #include "llvm/MC/MCObjectFileInfo.h" 31 #include "llvm/MC/MCRegisterInfo.h" 32 #include "llvm/MC/MCRelocationInfo.h" 33 #include "llvm/MC/MCSubtargetInfo.h" 34 #include "llvm/Object/Archive.h" 35 #include "llvm/Object/COFF.h" 36 #include "llvm/Object/MachO.h" 37 #include "llvm/Object/ObjectFile.h" 38 #include "llvm/Support/Casting.h" 39 #include "llvm/Support/CommandLine.h" 40 #include "llvm/Support/Debug.h" 41 #include "llvm/Support/FileSystem.h" 42 #include "llvm/Support/Format.h" 43 #include "llvm/Support/GraphWriter.h" 44 #include "llvm/Support/Host.h" 45 #include "llvm/Support/ManagedStatic.h" 46 #include "llvm/Support/MemoryBuffer.h" 47 #include "llvm/Support/PrettyStackTrace.h" 48 #include "llvm/Support/Signals.h" 49 #include "llvm/Support/SourceMgr.h" 50 #include "llvm/Support/TargetRegistry.h" 51 #include "llvm/Support/TargetSelect.h" 52 #include "llvm/Support/raw_ostream.h" 53 #include <algorithm> 54 #include <cctype> 55 #include <cstring> 56 #include <system_error> 57 58 using namespace llvm; 59 using namespace object; 60 61 static cl::list<std::string> 62 InputFilenames(cl::Positional, cl::desc("<input object files>"),cl::ZeroOrMore); 63 64 cl::opt<bool> 65 llvm::Disassemble("disassemble", 66 cl::desc("Display assembler mnemonics for the machine instructions")); 67 static cl::alias 68 Disassembled("d", cl::desc("Alias for --disassemble"), 69 cl::aliasopt(Disassemble)); 70 71 static cl::opt<bool> 72 Relocations("r", cl::desc("Display the relocation entries in the file")); 73 74 static cl::opt<bool> 75 SectionContents("s", cl::desc("Display the content of each section")); 76 77 static cl::opt<bool> 78 SymbolTable("t", cl::desc("Display the symbol table")); 79 80 cl::opt<bool> 81 llvm::ExportsTrie("exports-trie", cl::desc("Display mach-o exported symbols")); 82 83 cl::opt<bool> 84 llvm::Rebase("rebase", cl::desc("Display mach-o rebasing info")); 85 86 cl::opt<bool> 87 llvm::Bind("bind", cl::desc("Display mach-o binding info")); 88 89 cl::opt<bool> 90 llvm::LazyBind("lazy-bind", cl::desc("Display mach-o lazy binding info")); 91 92 cl::opt<bool> 93 llvm::WeakBind("weak-bind", cl::desc("Display mach-o weak binding info")); 94 95 static cl::opt<bool> 96 MachOOpt("macho", cl::desc("Use MachO specific object file parser")); 97 static cl::alias 98 MachOm("m", cl::desc("Alias for --macho"), cl::aliasopt(MachOOpt)); 99 100 cl::opt<std::string> 101 llvm::TripleName("triple", cl::desc("Target triple to disassemble for, " 102 "see -version for available targets")); 103 104 cl::opt<std::string> 105 llvm::MCPU("mcpu", 106 cl::desc("Target a specific cpu type (-mcpu=help for details)"), 107 cl::value_desc("cpu-name"), 108 cl::init("")); 109 110 cl::opt<std::string> 111 llvm::ArchName("arch-name", cl::desc("Target arch to disassemble for, " 112 "see -version for available targets")); 113 114 static cl::opt<bool> 115 SectionHeaders("section-headers", cl::desc("Display summaries of the headers " 116 "for each section.")); 117 static cl::alias 118 SectionHeadersShort("headers", cl::desc("Alias for --section-headers"), 119 cl::aliasopt(SectionHeaders)); 120 static cl::alias 121 SectionHeadersShorter("h", cl::desc("Alias for --section-headers"), 122 cl::aliasopt(SectionHeaders)); 123 124 cl::list<std::string> 125 llvm::MAttrs("mattr", 126 cl::CommaSeparated, 127 cl::desc("Target specific attributes"), 128 cl::value_desc("a1,+a2,-a3,...")); 129 130 cl::opt<bool> 131 llvm::NoShowRawInsn("no-show-raw-insn", cl::desc("When disassembling " 132 "instructions, do not print " 133 "the instruction bytes.")); 134 135 static cl::opt<bool> 136 UnwindInfo("unwind-info", cl::desc("Display unwind information")); 137 138 static cl::alias 139 UnwindInfoShort("u", cl::desc("Alias for --unwind-info"), 140 cl::aliasopt(UnwindInfo)); 141 142 cl::opt<bool> 143 llvm::PrivateHeaders("private-headers", 144 cl::desc("Display format specific file headers")); 145 146 static cl::alias 147 PrivateHeadersShort("p", cl::desc("Alias for --private-headers"), 148 cl::aliasopt(PrivateHeaders)); 149 150 static StringRef ToolName; 151 static int ReturnValue = EXIT_SUCCESS; 152 153 bool llvm::error(std::error_code EC) { 154 if (!EC) 155 return false; 156 157 outs() << ToolName << ": error reading file: " << EC.message() << ".\n"; 158 outs().flush(); 159 ReturnValue = EXIT_FAILURE; 160 return true; 161 } 162 163 static const Target *getTarget(const ObjectFile *Obj = nullptr) { 164 // Figure out the target triple. 165 llvm::Triple TheTriple("unknown-unknown-unknown"); 166 if (TripleName.empty()) { 167 if (Obj) { 168 TheTriple.setArch(Triple::ArchType(Obj->getArch())); 169 // TheTriple defaults to ELF, and COFF doesn't have an environment: 170 // the best we can do here is indicate that it is mach-o. 171 if (Obj->isMachO()) 172 TheTriple.setObjectFormat(Triple::MachO); 173 174 if (Obj->isCOFF()) { 175 const auto COFFObj = dyn_cast<COFFObjectFile>(Obj); 176 if (COFFObj->getArch() == Triple::thumb) 177 TheTriple.setTriple("thumbv7-windows"); 178 } 179 } 180 } else 181 TheTriple.setTriple(Triple::normalize(TripleName)); 182 183 // Get the target specific parser. 184 std::string Error; 185 const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple, 186 Error); 187 if (!TheTarget) { 188 errs() << ToolName << ": " << Error; 189 return nullptr; 190 } 191 192 // Update the triple name and return the found target. 193 TripleName = TheTriple.getTriple(); 194 return TheTarget; 195 } 196 197 void llvm::DumpBytes(StringRef bytes) { 198 static const char hex_rep[] = "0123456789abcdef"; 199 // FIXME: The real way to do this is to figure out the longest instruction 200 // and align to that size before printing. I'll fix this when I get 201 // around to outputting relocations. 202 // 15 is the longest x86 instruction 203 // 3 is for the hex rep of a byte + a space. 204 // 1 is for the null terminator. 205 enum { OutputSize = (15 * 3) + 1 }; 206 char output[OutputSize]; 207 208 assert(bytes.size() <= 15 209 && "DumpBytes only supports instructions of up to 15 bytes"); 210 memset(output, ' ', sizeof(output)); 211 unsigned index = 0; 212 for (StringRef::iterator i = bytes.begin(), 213 e = bytes.end(); i != e; ++i) { 214 output[index] = hex_rep[(*i & 0xF0) >> 4]; 215 output[index + 1] = hex_rep[*i & 0xF]; 216 index += 3; 217 } 218 219 output[sizeof(output) - 1] = 0; 220 outs() << output; 221 } 222 223 bool llvm::RelocAddressLess(RelocationRef a, RelocationRef b) { 224 uint64_t a_addr, b_addr; 225 if (error(a.getOffset(a_addr))) return false; 226 if (error(b.getOffset(b_addr))) return false; 227 return a_addr < b_addr; 228 } 229 230 static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { 231 const Target *TheTarget = getTarget(Obj); 232 // getTarget() will have already issued a diagnostic if necessary, so 233 // just bail here if it failed. 234 if (!TheTarget) 235 return; 236 237 // Package up features to be passed to target/subtarget 238 std::string FeaturesStr; 239 if (MAttrs.size()) { 240 SubtargetFeatures Features; 241 for (unsigned i = 0; i != MAttrs.size(); ++i) 242 Features.AddFeature(MAttrs[i]); 243 FeaturesStr = Features.getString(); 244 } 245 246 std::unique_ptr<const MCRegisterInfo> MRI( 247 TheTarget->createMCRegInfo(TripleName)); 248 if (!MRI) { 249 errs() << "error: no register info for target " << TripleName << "\n"; 250 return; 251 } 252 253 // Set up disassembler. 254 std::unique_ptr<const MCAsmInfo> AsmInfo( 255 TheTarget->createMCAsmInfo(*MRI, TripleName)); 256 if (!AsmInfo) { 257 errs() << "error: no assembly info for target " << TripleName << "\n"; 258 return; 259 } 260 261 std::unique_ptr<const MCSubtargetInfo> STI( 262 TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr)); 263 if (!STI) { 264 errs() << "error: no subtarget info for target " << TripleName << "\n"; 265 return; 266 } 267 268 std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo()); 269 if (!MII) { 270 errs() << "error: no instruction info for target " << TripleName << "\n"; 271 return; 272 } 273 274 std::unique_ptr<const MCObjectFileInfo> MOFI(new MCObjectFileInfo); 275 MCContext Ctx(AsmInfo.get(), MRI.get(), MOFI.get()); 276 277 std::unique_ptr<MCDisassembler> DisAsm( 278 TheTarget->createMCDisassembler(*STI, Ctx)); 279 280 if (!DisAsm) { 281 errs() << "error: no disassembler for target " << TripleName << "\n"; 282 return; 283 } 284 285 std::unique_ptr<const MCInstrAnalysis> MIA( 286 TheTarget->createMCInstrAnalysis(MII.get())); 287 288 int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); 289 std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter( 290 AsmPrinterVariant, *AsmInfo, *MII, *MRI, *STI)); 291 if (!IP) { 292 errs() << "error: no instruction printer for target " << TripleName 293 << '\n'; 294 return; 295 } 296 297 StringRef Fmt = Obj->getBytesInAddress() > 4 ? "\t\t%016" PRIx64 ": " : 298 "\t\t\t%08" PRIx64 ": "; 299 300 // Create a mapping, RelocSecs = SectionRelocMap[S], where sections 301 // in RelocSecs contain the relocations for section S. 302 std::error_code EC; 303 std::map<SectionRef, SmallVector<SectionRef, 1>> SectionRelocMap; 304 for (const SectionRef &Section : Obj->sections()) { 305 section_iterator Sec2 = Section.getRelocatedSection(); 306 if (Sec2 != Obj->section_end()) 307 SectionRelocMap[*Sec2].push_back(Section); 308 } 309 310 for (const SectionRef &Section : Obj->sections()) { 311 if (!Section.isText() || Section.isVirtual()) 312 continue; 313 314 uint64_t SectionAddr = Section.getAddress(); 315 uint64_t SectSize = Section.getSize(); 316 if (!SectSize) 317 continue; 318 319 // Make a list of all the symbols in this section. 320 std::vector<std::pair<uint64_t, StringRef>> Symbols; 321 for (const SymbolRef &Symbol : Obj->symbols()) { 322 if (Section.containsSymbol(Symbol)) { 323 uint64_t Address; 324 if (error(Symbol.getAddress(Address))) 325 break; 326 if (Address == UnknownAddressOrSize) 327 continue; 328 Address -= SectionAddr; 329 if (Address >= SectSize) 330 continue; 331 332 StringRef Name; 333 if (error(Symbol.getName(Name))) 334 break; 335 Symbols.push_back(std::make_pair(Address, Name)); 336 } 337 } 338 339 // Sort the symbols by address, just in case they didn't come in that way. 340 array_pod_sort(Symbols.begin(), Symbols.end()); 341 342 // Make a list of all the relocations for this section. 343 std::vector<RelocationRef> Rels; 344 if (InlineRelocs) { 345 for (const SectionRef &RelocSec : SectionRelocMap[Section]) { 346 for (const RelocationRef &Reloc : RelocSec.relocations()) { 347 Rels.push_back(Reloc); 348 } 349 } 350 } 351 352 // Sort relocations by address. 353 std::sort(Rels.begin(), Rels.end(), RelocAddressLess); 354 355 StringRef SegmentName = ""; 356 if (const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj)) { 357 DataRefImpl DR = Section.getRawDataRefImpl(); 358 SegmentName = MachO->getSectionFinalSegmentName(DR); 359 } 360 StringRef name; 361 if (error(Section.getName(name))) 362 break; 363 outs() << "Disassembly of section "; 364 if (!SegmentName.empty()) 365 outs() << SegmentName << ","; 366 outs() << name << ':'; 367 368 // If the section has no symbols just insert a dummy one and disassemble 369 // the whole section. 370 if (Symbols.empty()) 371 Symbols.push_back(std::make_pair(0, name)); 372 373 374 SmallString<40> Comments; 375 raw_svector_ostream CommentStream(Comments); 376 377 StringRef BytesStr; 378 if (error(Section.getContents(BytesStr))) 379 break; 380 ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()), 381 BytesStr.size()); 382 383 uint64_t Size; 384 uint64_t Index; 385 386 std::vector<RelocationRef>::const_iterator rel_cur = Rels.begin(); 387 std::vector<RelocationRef>::const_iterator rel_end = Rels.end(); 388 // Disassemble symbol by symbol. 389 for (unsigned si = 0, se = Symbols.size(); si != se; ++si) { 390 391 uint64_t Start = Symbols[si].first; 392 // The end is either the section end or the beginning of the next symbol. 393 uint64_t End = (si == se - 1) ? SectSize : Symbols[si + 1].first; 394 // If this symbol has the same address as the next symbol, then skip it. 395 if (Start == End) 396 continue; 397 398 outs() << '\n' << Symbols[si].second << ":\n"; 399 400 #ifndef NDEBUG 401 raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls(); 402 #else 403 raw_ostream &DebugOut = nulls(); 404 #endif 405 406 for (Index = Start; Index < End; Index += Size) { 407 MCInst Inst; 408 409 if (DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), 410 SectionAddr + Index, DebugOut, 411 CommentStream)) { 412 outs() << format("%8" PRIx64 ":", SectionAddr + Index); 413 if (!NoShowRawInsn) { 414 outs() << "\t"; 415 DumpBytes(StringRef( 416 reinterpret_cast<const char *>(Bytes.data()) + Index, Size)); 417 } 418 IP->printInst(&Inst, outs(), ""); 419 outs() << CommentStream.str(); 420 Comments.clear(); 421 outs() << "\n"; 422 } else { 423 errs() << ToolName << ": warning: invalid instruction encoding\n"; 424 if (Size == 0) 425 Size = 1; // skip illegible bytes 426 } 427 428 // Print relocation for instruction. 429 while (rel_cur != rel_end) { 430 bool hidden = false; 431 uint64_t addr; 432 SmallString<16> name; 433 SmallString<32> val; 434 435 // If this relocation is hidden, skip it. 436 if (error(rel_cur->getHidden(hidden))) goto skip_print_rel; 437 if (hidden) goto skip_print_rel; 438 439 if (error(rel_cur->getOffset(addr))) goto skip_print_rel; 440 // Stop when rel_cur's address is past the current instruction. 441 if (addr >= Index + Size) break; 442 if (error(rel_cur->getTypeName(name))) goto skip_print_rel; 443 if (error(rel_cur->getValueString(val))) goto skip_print_rel; 444 445 outs() << format(Fmt.data(), SectionAddr + addr) << name 446 << "\t" << val << "\n"; 447 448 skip_print_rel: 449 ++rel_cur; 450 } 451 } 452 } 453 } 454 } 455 456 static void PrintRelocations(const ObjectFile *Obj) { 457 StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 : 458 "%08" PRIx64; 459 // Regular objdump doesn't print relocations in non-relocatable object 460 // files. 461 if (!Obj->isRelocatableObject()) 462 return; 463 464 for (const SectionRef &Section : Obj->sections()) { 465 if (Section.relocation_begin() == Section.relocation_end()) 466 continue; 467 StringRef secname; 468 if (error(Section.getName(secname))) 469 continue; 470 outs() << "RELOCATION RECORDS FOR [" << secname << "]:\n"; 471 for (const RelocationRef &Reloc : Section.relocations()) { 472 bool hidden; 473 uint64_t address; 474 SmallString<32> relocname; 475 SmallString<32> valuestr; 476 if (error(Reloc.getHidden(hidden))) 477 continue; 478 if (hidden) 479 continue; 480 if (error(Reloc.getTypeName(relocname))) 481 continue; 482 if (error(Reloc.getOffset(address))) 483 continue; 484 if (error(Reloc.getValueString(valuestr))) 485 continue; 486 outs() << format(Fmt.data(), address) << " " << relocname << " " 487 << valuestr << "\n"; 488 } 489 outs() << "\n"; 490 } 491 } 492 493 static void PrintSectionHeaders(const ObjectFile *Obj) { 494 outs() << "Sections:\n" 495 "Idx Name Size Address Type\n"; 496 unsigned i = 0; 497 for (const SectionRef &Section : Obj->sections()) { 498 StringRef Name; 499 if (error(Section.getName(Name))) 500 return; 501 uint64_t Address = Section.getAddress(); 502 uint64_t Size = Section.getSize(); 503 bool Text = Section.isText(); 504 bool Data = Section.isData(); 505 bool BSS = Section.isBSS(); 506 std::string Type = (std::string(Text ? "TEXT " : "") + 507 (Data ? "DATA " : "") + (BSS ? "BSS" : "")); 508 outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n", i, 509 Name.str().c_str(), Size, Address, Type.c_str()); 510 ++i; 511 } 512 } 513 514 static void PrintSectionContents(const ObjectFile *Obj) { 515 std::error_code EC; 516 for (const SectionRef &Section : Obj->sections()) { 517 StringRef Name; 518 StringRef Contents; 519 if (error(Section.getName(Name))) 520 continue; 521 uint64_t BaseAddr = Section.getAddress(); 522 uint64_t Size = Section.getSize(); 523 if (!Size) 524 continue; 525 526 outs() << "Contents of section " << Name << ":\n"; 527 if (Section.isBSS()) { 528 outs() << format("<skipping contents of bss section at [%04" PRIx64 529 ", %04" PRIx64 ")>\n", 530 BaseAddr, BaseAddr + Size); 531 continue; 532 } 533 534 if (error(Section.getContents(Contents))) 535 continue; 536 537 // Dump out the content as hex and printable ascii characters. 538 for (std::size_t addr = 0, end = Contents.size(); addr < end; addr += 16) { 539 outs() << format(" %04" PRIx64 " ", BaseAddr + addr); 540 // Dump line of hex. 541 for (std::size_t i = 0; i < 16; ++i) { 542 if (i != 0 && i % 4 == 0) 543 outs() << ' '; 544 if (addr + i < end) 545 outs() << hexdigit((Contents[addr + i] >> 4) & 0xF, true) 546 << hexdigit(Contents[addr + i] & 0xF, true); 547 else 548 outs() << " "; 549 } 550 // Print ascii. 551 outs() << " "; 552 for (std::size_t i = 0; i < 16 && addr + i < end; ++i) { 553 if (std::isprint(static_cast<unsigned char>(Contents[addr + i]) & 0xFF)) 554 outs() << Contents[addr + i]; 555 else 556 outs() << "."; 557 } 558 outs() << "\n"; 559 } 560 } 561 } 562 563 static void PrintCOFFSymbolTable(const COFFObjectFile *coff) { 564 for (unsigned SI = 0, SE = coff->getNumberOfSymbols(); SI != SE; ++SI) { 565 ErrorOr<COFFSymbolRef> Symbol = coff->getSymbol(SI); 566 StringRef Name; 567 if (error(Symbol.getError())) 568 return; 569 570 if (error(coff->getSymbolName(*Symbol, Name))) 571 return; 572 573 outs() << "[" << format("%2d", SI) << "]" 574 << "(sec " << format("%2d", int(Symbol->getSectionNumber())) << ")" 575 << "(fl 0x00)" // Flag bits, which COFF doesn't have. 576 << "(ty " << format("%3x", unsigned(Symbol->getType())) << ")" 577 << "(scl " << format("%3x", unsigned(Symbol->getStorageClass())) << ") " 578 << "(nx " << unsigned(Symbol->getNumberOfAuxSymbols()) << ") " 579 << "0x" << format("%08x", unsigned(Symbol->getValue())) << " " 580 << Name << "\n"; 581 582 for (unsigned AI = 0, AE = Symbol->getNumberOfAuxSymbols(); AI < AE; ++AI, ++SI) { 583 if (Symbol->isSectionDefinition()) { 584 const coff_aux_section_definition *asd; 585 if (error(coff->getAuxSymbol<coff_aux_section_definition>(SI + 1, asd))) 586 return; 587 588 int32_t AuxNumber = asd->getNumber(Symbol->isBigObj()); 589 590 outs() << "AUX " 591 << format("scnlen 0x%x nreloc %d nlnno %d checksum 0x%x " 592 , unsigned(asd->Length) 593 , unsigned(asd->NumberOfRelocations) 594 , unsigned(asd->NumberOfLinenumbers) 595 , unsigned(asd->CheckSum)) 596 << format("assoc %d comdat %d\n" 597 , unsigned(AuxNumber) 598 , unsigned(asd->Selection)); 599 } else if (Symbol->isFileRecord()) { 600 const char *FileName; 601 if (error(coff->getAuxSymbol<char>(SI + 1, FileName))) 602 return; 603 604 StringRef Name(FileName, Symbol->getNumberOfAuxSymbols() * 605 coff->getSymbolTableEntrySize()); 606 outs() << "AUX " << Name.rtrim(StringRef("\0", 1)) << '\n'; 607 608 SI = SI + Symbol->getNumberOfAuxSymbols(); 609 break; 610 } else { 611 outs() << "AUX Unknown\n"; 612 } 613 } 614 } 615 } 616 617 static void PrintSymbolTable(const ObjectFile *o) { 618 outs() << "SYMBOL TABLE:\n"; 619 620 if (const COFFObjectFile *coff = dyn_cast<const COFFObjectFile>(o)) { 621 PrintCOFFSymbolTable(coff); 622 return; 623 } 624 for (const SymbolRef &Symbol : o->symbols()) { 625 StringRef Name; 626 uint64_t Address; 627 SymbolRef::Type Type; 628 uint64_t Size; 629 uint32_t Flags = Symbol.getFlags(); 630 section_iterator Section = o->section_end(); 631 if (error(Symbol.getName(Name))) 632 continue; 633 if (error(Symbol.getAddress(Address))) 634 continue; 635 if (error(Symbol.getType(Type))) 636 continue; 637 if (error(Symbol.getSize(Size))) 638 continue; 639 if (error(Symbol.getSection(Section))) 640 continue; 641 642 bool Global = Flags & SymbolRef::SF_Global; 643 bool Weak = Flags & SymbolRef::SF_Weak; 644 bool Absolute = Flags & SymbolRef::SF_Absolute; 645 646 if (Address == UnknownAddressOrSize) 647 Address = 0; 648 if (Size == UnknownAddressOrSize) 649 Size = 0; 650 char GlobLoc = ' '; 651 if (Type != SymbolRef::ST_Unknown) 652 GlobLoc = Global ? 'g' : 'l'; 653 char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File) 654 ? 'd' : ' '; 655 char FileFunc = ' '; 656 if (Type == SymbolRef::ST_File) 657 FileFunc = 'f'; 658 else if (Type == SymbolRef::ST_Function) 659 FileFunc = 'F'; 660 661 const char *Fmt = o->getBytesInAddress() > 4 ? "%016" PRIx64 : 662 "%08" PRIx64; 663 664 outs() << format(Fmt, Address) << " " 665 << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' ' 666 << (Weak ? 'w' : ' ') // Weak? 667 << ' ' // Constructor. Not supported yet. 668 << ' ' // Warning. Not supported yet. 669 << ' ' // Indirect reference to another symbol. 670 << Debug // Debugging (d) or dynamic (D) symbol. 671 << FileFunc // Name of function (F), file (f) or object (O). 672 << ' '; 673 if (Absolute) { 674 outs() << "*ABS*"; 675 } else if (Section == o->section_end()) { 676 outs() << "*UND*"; 677 } else { 678 if (const MachOObjectFile *MachO = 679 dyn_cast<const MachOObjectFile>(o)) { 680 DataRefImpl DR = Section->getRawDataRefImpl(); 681 StringRef SegmentName = MachO->getSectionFinalSegmentName(DR); 682 outs() << SegmentName << ","; 683 } 684 StringRef SectionName; 685 if (error(Section->getName(SectionName))) 686 SectionName = ""; 687 outs() << SectionName; 688 } 689 outs() << '\t' 690 << format("%08" PRIx64 " ", Size) 691 << Name 692 << '\n'; 693 } 694 } 695 696 static void PrintUnwindInfo(const ObjectFile *o) { 697 outs() << "Unwind info:\n\n"; 698 699 if (const COFFObjectFile *coff = dyn_cast<COFFObjectFile>(o)) { 700 printCOFFUnwindInfo(coff); 701 } else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 702 printMachOUnwindInfo(MachO); 703 else { 704 // TODO: Extract DWARF dump tool to objdump. 705 errs() << "This operation is only currently supported " 706 "for COFF and MachO object files.\n"; 707 return; 708 } 709 } 710 711 void llvm::printExportsTrie(const ObjectFile *o) { 712 outs() << "Exports trie:\n"; 713 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 714 printMachOExportsTrie(MachO); 715 else { 716 errs() << "This operation is only currently supported " 717 "for Mach-O executable files.\n"; 718 return; 719 } 720 } 721 722 void llvm::printRebaseTable(const ObjectFile *o) { 723 outs() << "Rebase table:\n"; 724 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 725 printMachORebaseTable(MachO); 726 else { 727 errs() << "This operation is only currently supported " 728 "for Mach-O executable files.\n"; 729 return; 730 } 731 } 732 733 void llvm::printBindTable(const ObjectFile *o) { 734 outs() << "Bind table:\n"; 735 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 736 printMachOBindTable(MachO); 737 else { 738 errs() << "This operation is only currently supported " 739 "for Mach-O executable files.\n"; 740 return; 741 } 742 } 743 744 void llvm::printLazyBindTable(const ObjectFile *o) { 745 outs() << "Lazy bind table:\n"; 746 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 747 printMachOLazyBindTable(MachO); 748 else { 749 errs() << "This operation is only currently supported " 750 "for Mach-O executable files.\n"; 751 return; 752 } 753 } 754 755 void llvm::printWeakBindTable(const ObjectFile *o) { 756 outs() << "Weak bind table:\n"; 757 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 758 printMachOWeakBindTable(MachO); 759 else { 760 errs() << "This operation is only currently supported " 761 "for Mach-O executable files.\n"; 762 return; 763 } 764 } 765 766 static void printPrivateFileHeader(const ObjectFile *o) { 767 if (o->isELF()) { 768 printELFFileHeader(o); 769 } else if (o->isCOFF()) { 770 printCOFFFileHeader(o); 771 } else if (o->isMachO()) { 772 printMachOFileHeader(o); 773 } 774 } 775 776 static void DumpObject(const ObjectFile *o) { 777 outs() << '\n'; 778 outs() << o->getFileName() 779 << ":\tfile format " << o->getFileFormatName() << "\n\n"; 780 781 if (Disassemble) 782 DisassembleObject(o, Relocations); 783 if (Relocations && !Disassemble) 784 PrintRelocations(o); 785 if (SectionHeaders) 786 PrintSectionHeaders(o); 787 if (SectionContents) 788 PrintSectionContents(o); 789 if (SymbolTable) 790 PrintSymbolTable(o); 791 if (UnwindInfo) 792 PrintUnwindInfo(o); 793 if (PrivateHeaders) 794 printPrivateFileHeader(o); 795 if (ExportsTrie) 796 printExportsTrie(o); 797 if (Rebase) 798 printRebaseTable(o); 799 if (Bind) 800 printBindTable(o); 801 if (LazyBind) 802 printLazyBindTable(o); 803 if (WeakBind) 804 printWeakBindTable(o); 805 } 806 807 /// @brief Dump each object file in \a a; 808 static void DumpArchive(const Archive *a) { 809 for (Archive::child_iterator i = a->child_begin(), e = a->child_end(); i != e; 810 ++i) { 811 ErrorOr<std::unique_ptr<Binary>> ChildOrErr = i->getAsBinary(); 812 if (std::error_code EC = ChildOrErr.getError()) { 813 // Ignore non-object files. 814 if (EC != object_error::invalid_file_type) 815 errs() << ToolName << ": '" << a->getFileName() << "': " << EC.message() 816 << ".\n"; 817 continue; 818 } 819 if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) 820 DumpObject(o); 821 else 822 errs() << ToolName << ": '" << a->getFileName() << "': " 823 << "Unrecognized file type.\n"; 824 } 825 } 826 827 /// @brief Open file and figure out how to dump it. 828 static void DumpInput(StringRef file) { 829 // If file isn't stdin, check that it exists. 830 if (file != "-" && !sys::fs::exists(file)) { 831 errs() << ToolName << ": '" << file << "': " << "No such file\n"; 832 return; 833 } 834 835 // If we are using the Mach-O specific object file parser, then let it parse 836 // the file and process the command line options. So the -arch flags can 837 // be used to select specific slices, etc. 838 if (MachOOpt) { 839 ParseInputMachO(file); 840 return; 841 } 842 843 // Attempt to open the binary. 844 ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(file); 845 if (std::error_code EC = BinaryOrErr.getError()) { 846 errs() << ToolName << ": '" << file << "': " << EC.message() << ".\n"; 847 return; 848 } 849 Binary &Binary = *BinaryOrErr.get().getBinary(); 850 851 if (Archive *a = dyn_cast<Archive>(&Binary)) 852 DumpArchive(a); 853 else if (ObjectFile *o = dyn_cast<ObjectFile>(&Binary)) 854 DumpObject(o); 855 else 856 errs() << ToolName << ": '" << file << "': " << "Unrecognized file type.\n"; 857 } 858 859 int main(int argc, char **argv) { 860 // Print a stack trace if we signal out. 861 sys::PrintStackTraceOnErrorSignal(); 862 PrettyStackTraceProgram X(argc, argv); 863 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 864 865 // Initialize targets and assembly printers/parsers. 866 llvm::InitializeAllTargetInfos(); 867 llvm::InitializeAllTargetMCs(); 868 llvm::InitializeAllAsmParsers(); 869 llvm::InitializeAllDisassemblers(); 870 871 // Register the target printer for --version. 872 cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); 873 874 cl::ParseCommandLineOptions(argc, argv, "llvm object file dumper\n"); 875 TripleName = Triple::normalize(TripleName); 876 877 ToolName = argv[0]; 878 879 // Defaults to a.out if no filenames specified. 880 if (InputFilenames.size() == 0) 881 InputFilenames.push_back("a.out"); 882 883 if (!Disassemble 884 && !Relocations 885 && !SectionHeaders 886 && !SectionContents 887 && !SymbolTable 888 && !UnwindInfo 889 && !PrivateHeaders 890 && !ExportsTrie 891 && !Rebase 892 && !Bind 893 && !LazyBind 894 && !WeakBind 895 && !(UniversalHeaders && MachOOpt)) { 896 cl::PrintHelpMessage(); 897 return 2; 898 } 899 900 std::for_each(InputFilenames.begin(), InputFilenames.end(), 901 DumpInput); 902 903 return ReturnValue; 904 } 905