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/Optional.h" 21#include "llvm/ADT/STLExtras.h" 22#include "llvm/ADT/StringExtras.h" 23#include "llvm/ADT/Triple.h" 24#include "llvm/CodeGen/FaultMaps.h" 25#include "llvm/DebugInfo/DWARF/DWARFContext.h" 26#include "llvm/MC/MCAsmInfo.h" 27#include "llvm/MC/MCContext.h" 28#include "llvm/MC/MCDisassembler/MCDisassembler.h" 29#include "llvm/MC/MCDisassembler/MCRelocationInfo.h" 30#include "llvm/MC/MCInst.h" 31#include "llvm/MC/MCInstPrinter.h" 32#include "llvm/MC/MCInstrAnalysis.h" 33#include "llvm/MC/MCInstrInfo.h" 34#include "llvm/MC/MCObjectFileInfo.h" 35#include "llvm/MC/MCRegisterInfo.h" 36#include "llvm/MC/MCSubtargetInfo.h" 37#include "llvm/Object/Archive.h" 38#include "llvm/Object/COFF.h" 39#include "llvm/Object/ELFObjectFile.h" 40#include "llvm/Object/MachO.h" 41#include "llvm/Object/ObjectFile.h" 42#include "llvm/Support/Casting.h" 43#include "llvm/Support/CommandLine.h" 44#include "llvm/Support/Debug.h" 45#include "llvm/Support/Errc.h" 46#include "llvm/Support/FileSystem.h" 47#include "llvm/Support/Format.h" 48#include "llvm/Support/GraphWriter.h" 49#include "llvm/Support/Host.h" 50#include "llvm/Support/ManagedStatic.h" 51#include "llvm/Support/MemoryBuffer.h" 52#include "llvm/Support/PrettyStackTrace.h" 53#include "llvm/Support/Signals.h" 54#include "llvm/Support/SourceMgr.h" 55#include "llvm/Support/TargetRegistry.h" 56#include "llvm/Support/TargetSelect.h" 57#include "llvm/Support/raw_ostream.h" 58#include <algorithm> 59#include <cctype> 60#include <cstring> 61#include <system_error> 62#include <utility> 63 64using namespace llvm; 65using namespace object; 66 67static cl::list<std::string> 68InputFilenames(cl::Positional, cl::desc("<input object files>"),cl::ZeroOrMore); 69 70cl::opt<bool> 71llvm::Disassemble("disassemble", 72 cl::desc("Display assembler mnemonics for the machine instructions")); 73static cl::alias 74Disassembled("d", cl::desc("Alias for --disassemble"), 75 cl::aliasopt(Disassemble)); 76 77cl::opt<bool> 78llvm::DisassembleAll("disassemble-all", 79 cl::desc("Display assembler mnemonics for the machine instructions")); 80static cl::alias 81DisassembleAlld("D", cl::desc("Alias for --disassemble-all"), 82 cl::aliasopt(DisassembleAll)); 83 84cl::opt<bool> 85llvm::Relocations("r", cl::desc("Display the relocation entries in the file")); 86 87cl::opt<bool> 88llvm::SectionContents("s", cl::desc("Display the content of each section")); 89 90cl::opt<bool> 91llvm::SymbolTable("t", cl::desc("Display the symbol table")); 92 93cl::opt<bool> 94llvm::ExportsTrie("exports-trie", cl::desc("Display mach-o exported symbols")); 95 96cl::opt<bool> 97llvm::Rebase("rebase", cl::desc("Display mach-o rebasing info")); 98 99cl::opt<bool> 100llvm::Bind("bind", cl::desc("Display mach-o binding info")); 101 102cl::opt<bool> 103llvm::LazyBind("lazy-bind", cl::desc("Display mach-o lazy binding info")); 104 105cl::opt<bool> 106llvm::WeakBind("weak-bind", cl::desc("Display mach-o weak binding info")); 107 108cl::opt<bool> 109llvm::RawClangAST("raw-clang-ast", 110 cl::desc("Dump the raw binary contents of the clang AST section")); 111 112static cl::opt<bool> 113MachOOpt("macho", cl::desc("Use MachO specific object file parser")); 114static cl::alias 115MachOm("m", cl::desc("Alias for --macho"), cl::aliasopt(MachOOpt)); 116 117cl::opt<std::string> 118llvm::TripleName("triple", cl::desc("Target triple to disassemble for, " 119 "see -version for available targets")); 120 121cl::opt<std::string> 122llvm::MCPU("mcpu", 123 cl::desc("Target a specific cpu type (-mcpu=help for details)"), 124 cl::value_desc("cpu-name"), 125 cl::init("")); 126 127cl::opt<std::string> 128llvm::ArchName("arch-name", cl::desc("Target arch to disassemble for, " 129 "see -version for available targets")); 130 131cl::opt<bool> 132llvm::SectionHeaders("section-headers", cl::desc("Display summaries of the " 133 "headers for each section.")); 134static cl::alias 135SectionHeadersShort("headers", cl::desc("Alias for --section-headers"), 136 cl::aliasopt(SectionHeaders)); 137static cl::alias 138SectionHeadersShorter("h", cl::desc("Alias for --section-headers"), 139 cl::aliasopt(SectionHeaders)); 140 141cl::list<std::string> 142llvm::FilterSections("section", cl::desc("Operate on the specified sections only. " 143 "With -macho dump segment,section")); 144cl::alias 145static FilterSectionsj("j", cl::desc("Alias for --section"), 146 cl::aliasopt(llvm::FilterSections)); 147 148cl::list<std::string> 149llvm::MAttrs("mattr", 150 cl::CommaSeparated, 151 cl::desc("Target specific attributes"), 152 cl::value_desc("a1,+a2,-a3,...")); 153 154cl::opt<bool> 155llvm::NoShowRawInsn("no-show-raw-insn", cl::desc("When disassembling " 156 "instructions, do not print " 157 "the instruction bytes.")); 158 159cl::opt<bool> 160llvm::UnwindInfo("unwind-info", cl::desc("Display unwind information")); 161 162static cl::alias 163UnwindInfoShort("u", cl::desc("Alias for --unwind-info"), 164 cl::aliasopt(UnwindInfo)); 165 166cl::opt<bool> 167llvm::PrivateHeaders("private-headers", 168 cl::desc("Display format specific file headers")); 169 170cl::opt<bool> 171llvm::FirstPrivateHeader("private-header", 172 cl::desc("Display only the first format specific file " 173 "header")); 174 175static cl::alias 176PrivateHeadersShort("p", cl::desc("Alias for --private-headers"), 177 cl::aliasopt(PrivateHeaders)); 178 179cl::opt<bool> 180 llvm::PrintImmHex("print-imm-hex", 181 cl::desc("Use hex format for immediate values")); 182 183cl::opt<bool> PrintFaultMaps("fault-map-section", 184 cl::desc("Display contents of faultmap section")); 185 186cl::opt<DIDumpType> llvm::DwarfDumpType( 187 "dwarf", cl::init(DIDT_Null), cl::desc("Dump of dwarf debug sections:"), 188 cl::values(clEnumValN(DIDT_Frames, "frames", ".debug_frame"), 189 clEnumValEnd)); 190 191static StringRef ToolName; 192 193namespace { 194typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate; 195 196class SectionFilterIterator { 197public: 198 SectionFilterIterator(FilterPredicate P, 199 llvm::object::section_iterator const &I, 200 llvm::object::section_iterator const &E) 201 : Predicate(std::move(P)), Iterator(I), End(E) { 202 ScanPredicate(); 203 } 204 const llvm::object::SectionRef &operator*() const { return *Iterator; } 205 SectionFilterIterator &operator++() { 206 ++Iterator; 207 ScanPredicate(); 208 return *this; 209 } 210 bool operator!=(SectionFilterIterator const &Other) const { 211 return Iterator != Other.Iterator; 212 } 213 214private: 215 void ScanPredicate() { 216 while (Iterator != End && !Predicate(*Iterator)) { 217 ++Iterator; 218 } 219 } 220 FilterPredicate Predicate; 221 llvm::object::section_iterator Iterator; 222 llvm::object::section_iterator End; 223}; 224 225class SectionFilter { 226public: 227 SectionFilter(FilterPredicate P, llvm::object::ObjectFile const &O) 228 : Predicate(std::move(P)), Object(O) {} 229 SectionFilterIterator begin() { 230 return SectionFilterIterator(Predicate, Object.section_begin(), 231 Object.section_end()); 232 } 233 SectionFilterIterator end() { 234 return SectionFilterIterator(Predicate, Object.section_end(), 235 Object.section_end()); 236 } 237 238private: 239 FilterPredicate Predicate; 240 llvm::object::ObjectFile const &Object; 241}; 242SectionFilter ToolSectionFilter(llvm::object::ObjectFile const &O) { 243 return SectionFilter([](llvm::object::SectionRef const &S) { 244 if(FilterSections.empty()) 245 return true; 246 llvm::StringRef String; 247 std::error_code error = S.getName(String); 248 if (error) 249 return false; 250 return std::find(FilterSections.begin(), 251 FilterSections.end(), 252 String) != FilterSections.end(); 253 }, 254 O); 255} 256} 257 258void llvm::error(std::error_code EC) { 259 if (!EC) 260 return; 261 262 errs() << ToolName << ": error reading file: " << EC.message() << ".\n"; 263 errs().flush(); 264 exit(1); 265} 266 267LLVM_ATTRIBUTE_NORETURN void llvm::error(Twine Message) { 268 errs() << ToolName << ": " << Message << ".\n"; 269 errs().flush(); 270 exit(1); 271} 272 273LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File, 274 std::error_code EC) { 275 assert(EC); 276 errs() << ToolName << ": '" << File << "': " << EC.message() << ".\n"; 277 exit(1); 278} 279 280LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File, 281 llvm::Error E) { 282 assert(E); 283 std::string Buf; 284 raw_string_ostream OS(Buf); 285 logAllUnhandledErrors(std::move(E), OS, ""); 286 OS.flush(); 287 errs() << ToolName << ": '" << File << "': " << Buf; 288 exit(1); 289} 290 291LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName, 292 StringRef FileName, 293 llvm::Error E, 294 StringRef ArchitectureName) { 295 assert(E); 296 errs() << ToolName << ": "; 297 if (ArchiveName != "") 298 errs() << ArchiveName << "(" << FileName << ")"; 299 else 300 errs() << FileName; 301 if (!ArchitectureName.empty()) 302 errs() << " (for architecture " << ArchitectureName << ")"; 303 std::string Buf; 304 raw_string_ostream OS(Buf); 305 logAllUnhandledErrors(std::move(E), OS, ""); 306 OS.flush(); 307 errs() << " " << Buf; 308 exit(1); 309} 310 311LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName, 312 const object::Archive::Child &C, 313 llvm::Error E, 314 StringRef ArchitectureName) { 315 ErrorOr<StringRef> NameOrErr = C.getName(); 316 // TODO: if we have a error getting the name then it would be nice to print 317 // the index of which archive member this is and or its offset in the 318 // archive instead of "???" as the name. 319 if (NameOrErr.getError()) 320 llvm::report_error(ArchiveName, "???", std::move(E), ArchitectureName); 321 else 322 llvm::report_error(ArchiveName, NameOrErr.get(), std::move(E), 323 ArchitectureName); 324} 325 326static const Target *getTarget(const ObjectFile *Obj = nullptr) { 327 // Figure out the target triple. 328 llvm::Triple TheTriple("unknown-unknown-unknown"); 329 if (TripleName.empty()) { 330 if (Obj) { 331 TheTriple.setArch(Triple::ArchType(Obj->getArch())); 332 // TheTriple defaults to ELF, and COFF doesn't have an environment: 333 // the best we can do here is indicate that it is mach-o. 334 if (Obj->isMachO()) 335 TheTriple.setObjectFormat(Triple::MachO); 336 337 if (Obj->isCOFF()) { 338 const auto COFFObj = dyn_cast<COFFObjectFile>(Obj); 339 if (COFFObj->getArch() == Triple::thumb) 340 TheTriple.setTriple("thumbv7-windows"); 341 } 342 } 343 } else 344 TheTriple.setTriple(Triple::normalize(TripleName)); 345 346 // Get the target specific parser. 347 std::string Error; 348 const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple, 349 Error); 350 if (!TheTarget) 351 report_fatal_error("can't find target: " + Error); 352 353 // Update the triple name and return the found target. 354 TripleName = TheTriple.getTriple(); 355 return TheTarget; 356} 357 358bool llvm::RelocAddressLess(RelocationRef a, RelocationRef b) { 359 return a.getOffset() < b.getOffset(); 360} 361 362namespace { 363class PrettyPrinter { 364public: 365 virtual ~PrettyPrinter(){} 366 virtual void printInst(MCInstPrinter &IP, const MCInst *MI, 367 ArrayRef<uint8_t> Bytes, uint64_t Address, 368 raw_ostream &OS, StringRef Annot, 369 MCSubtargetInfo const &STI) { 370 OS << format("%8" PRIx64 ":", Address); 371 if (!NoShowRawInsn) { 372 OS << "\t"; 373 dumpBytes(Bytes, OS); 374 } 375 if (MI) 376 IP.printInst(MI, OS, "", STI); 377 else 378 OS << " <unknown>"; 379 } 380}; 381PrettyPrinter PrettyPrinterInst; 382class HexagonPrettyPrinter : public PrettyPrinter { 383public: 384 void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address, 385 raw_ostream &OS) { 386 uint32_t opcode = 387 (Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | Bytes[0]; 388 OS << format("%8" PRIx64 ":", Address); 389 if (!NoShowRawInsn) { 390 OS << "\t"; 391 dumpBytes(Bytes.slice(0, 4), OS); 392 OS << format("%08" PRIx32, opcode); 393 } 394 } 395 void printInst(MCInstPrinter &IP, const MCInst *MI, 396 ArrayRef<uint8_t> Bytes, uint64_t Address, 397 raw_ostream &OS, StringRef Annot, 398 MCSubtargetInfo const &STI) override { 399 if (!MI) { 400 printLead(Bytes, Address, OS); 401 OS << " <unknown>"; 402 return; 403 } 404 std::string Buffer; 405 { 406 raw_string_ostream TempStream(Buffer); 407 IP.printInst(MI, TempStream, "", STI); 408 } 409 StringRef Contents(Buffer); 410 // Split off bundle attributes 411 auto PacketBundle = Contents.rsplit('\n'); 412 // Split off first instruction from the rest 413 auto HeadTail = PacketBundle.first.split('\n'); 414 auto Preamble = " { "; 415 auto Separator = ""; 416 while(!HeadTail.first.empty()) { 417 OS << Separator; 418 Separator = "\n"; 419 printLead(Bytes, Address, OS); 420 OS << Preamble; 421 Preamble = " "; 422 StringRef Inst; 423 auto Duplex = HeadTail.first.split('\v'); 424 if(!Duplex.second.empty()){ 425 OS << Duplex.first; 426 OS << "; "; 427 Inst = Duplex.second; 428 } 429 else 430 Inst = HeadTail.first; 431 OS << Inst; 432 Bytes = Bytes.slice(4); 433 Address += 4; 434 HeadTail = HeadTail.second.split('\n'); 435 } 436 OS << " } " << PacketBundle.second; 437 } 438}; 439HexagonPrettyPrinter HexagonPrettyPrinterInst; 440 441class AMDGCNPrettyPrinter : public PrettyPrinter { 442public: 443 void printInst(MCInstPrinter &IP, 444 const MCInst *MI, 445 ArrayRef<uint8_t> Bytes, 446 uint64_t Address, 447 raw_ostream &OS, 448 StringRef Annot, 449 MCSubtargetInfo const &STI) override { 450 if (!MI) { 451 OS << " <unknown>"; 452 return; 453 } 454 455 SmallString<40> InstStr; 456 raw_svector_ostream IS(InstStr); 457 458 IP.printInst(MI, IS, "", STI); 459 460 OS << left_justify(IS.str(), 60) << format("// %012" PRIX64 ": ", Address); 461 typedef support::ulittle32_t U32; 462 for (auto D : makeArrayRef(reinterpret_cast<const U32*>(Bytes.data()), 463 Bytes.size() / sizeof(U32))) 464 // D should be explicitly casted to uint32_t here as it is passed 465 // by format to snprintf as vararg. 466 OS << format("%08" PRIX32 " ", static_cast<uint32_t>(D)); 467 468 if (!Annot.empty()) 469 OS << "// " << Annot; 470 } 471}; 472AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst; 473 474PrettyPrinter &selectPrettyPrinter(Triple const &Triple) { 475 switch(Triple.getArch()) { 476 default: 477 return PrettyPrinterInst; 478 case Triple::hexagon: 479 return HexagonPrettyPrinterInst; 480 case Triple::amdgcn: 481 return AMDGCNPrettyPrinterInst; 482 } 483} 484} 485 486template <class ELFT> 487static std::error_code getRelocationValueString(const ELFObjectFile<ELFT> *Obj, 488 const RelocationRef &RelRef, 489 SmallVectorImpl<char> &Result) { 490 DataRefImpl Rel = RelRef.getRawDataRefImpl(); 491 492 typedef typename ELFObjectFile<ELFT>::Elf_Sym Elf_Sym; 493 typedef typename ELFObjectFile<ELFT>::Elf_Shdr Elf_Shdr; 494 typedef typename ELFObjectFile<ELFT>::Elf_Rela Elf_Rela; 495 496 const ELFFile<ELFT> &EF = *Obj->getELFFile(); 497 498 ErrorOr<const Elf_Shdr *> SecOrErr = EF.getSection(Rel.d.a); 499 if (std::error_code EC = SecOrErr.getError()) 500 return EC; 501 const Elf_Shdr *Sec = *SecOrErr; 502 ErrorOr<const Elf_Shdr *> SymTabOrErr = EF.getSection(Sec->sh_link); 503 if (std::error_code EC = SymTabOrErr.getError()) 504 return EC; 505 const Elf_Shdr *SymTab = *SymTabOrErr; 506 assert(SymTab->sh_type == ELF::SHT_SYMTAB || 507 SymTab->sh_type == ELF::SHT_DYNSYM); 508 ErrorOr<const Elf_Shdr *> StrTabSec = EF.getSection(SymTab->sh_link); 509 if (std::error_code EC = StrTabSec.getError()) 510 return EC; 511 ErrorOr<StringRef> StrTabOrErr = EF.getStringTable(*StrTabSec); 512 if (std::error_code EC = StrTabOrErr.getError()) 513 return EC; 514 StringRef StrTab = *StrTabOrErr; 515 uint8_t type = RelRef.getType(); 516 StringRef res; 517 int64_t addend = 0; 518 switch (Sec->sh_type) { 519 default: 520 return object_error::parse_failed; 521 case ELF::SHT_REL: { 522 // TODO: Read implicit addend from section data. 523 break; 524 } 525 case ELF::SHT_RELA: { 526 const Elf_Rela *ERela = Obj->getRela(Rel); 527 addend = ERela->r_addend; 528 break; 529 } 530 } 531 symbol_iterator SI = RelRef.getSymbol(); 532 const Elf_Sym *symb = Obj->getSymbol(SI->getRawDataRefImpl()); 533 StringRef Target; 534 if (symb->getType() == ELF::STT_SECTION) { 535 Expected<section_iterator> SymSI = SI->getSection(); 536 if (!SymSI) 537 return errorToErrorCode(SymSI.takeError()); 538 const Elf_Shdr *SymSec = Obj->getSection((*SymSI)->getRawDataRefImpl()); 539 ErrorOr<StringRef> SecName = EF.getSectionName(SymSec); 540 if (std::error_code EC = SecName.getError()) 541 return EC; 542 Target = *SecName; 543 } else { 544 Expected<StringRef> SymName = symb->getName(StrTab); 545 if (!SymName) 546 return errorToErrorCode(SymName.takeError()); 547 Target = *SymName; 548 } 549 switch (EF.getHeader()->e_machine) { 550 case ELF::EM_X86_64: 551 switch (type) { 552 case ELF::R_X86_64_PC8: 553 case ELF::R_X86_64_PC16: 554 case ELF::R_X86_64_PC32: { 555 std::string fmtbuf; 556 raw_string_ostream fmt(fmtbuf); 557 fmt << Target << (addend < 0 ? "" : "+") << addend << "-P"; 558 fmt.flush(); 559 Result.append(fmtbuf.begin(), fmtbuf.end()); 560 } break; 561 case ELF::R_X86_64_8: 562 case ELF::R_X86_64_16: 563 case ELF::R_X86_64_32: 564 case ELF::R_X86_64_32S: 565 case ELF::R_X86_64_64: { 566 std::string fmtbuf; 567 raw_string_ostream fmt(fmtbuf); 568 fmt << Target << (addend < 0 ? "" : "+") << addend; 569 fmt.flush(); 570 Result.append(fmtbuf.begin(), fmtbuf.end()); 571 } break; 572 default: 573 res = "Unknown"; 574 } 575 break; 576 case ELF::EM_LANAI: 577 case ELF::EM_AARCH64: { 578 std::string fmtbuf; 579 raw_string_ostream fmt(fmtbuf); 580 fmt << Target; 581 if (addend != 0) 582 fmt << (addend < 0 ? "" : "+") << addend; 583 fmt.flush(); 584 Result.append(fmtbuf.begin(), fmtbuf.end()); 585 break; 586 } 587 case ELF::EM_386: 588 case ELF::EM_IAMCU: 589 case ELF::EM_ARM: 590 case ELF::EM_HEXAGON: 591 case ELF::EM_MIPS: 592 res = Target; 593 break; 594 case ELF::EM_WEBASSEMBLY: 595 switch (type) { 596 case ELF::R_WEBASSEMBLY_DATA: { 597 std::string fmtbuf; 598 raw_string_ostream fmt(fmtbuf); 599 fmt << Target << (addend < 0 ? "" : "+") << addend; 600 fmt.flush(); 601 Result.append(fmtbuf.begin(), fmtbuf.end()); 602 break; 603 } 604 case ELF::R_WEBASSEMBLY_FUNCTION: 605 res = Target; 606 break; 607 default: 608 res = "Unknown"; 609 } 610 break; 611 default: 612 res = "Unknown"; 613 } 614 if (Result.empty()) 615 Result.append(res.begin(), res.end()); 616 return std::error_code(); 617} 618 619static std::error_code getRelocationValueString(const ELFObjectFileBase *Obj, 620 const RelocationRef &Rel, 621 SmallVectorImpl<char> &Result) { 622 if (auto *ELF32LE = dyn_cast<ELF32LEObjectFile>(Obj)) 623 return getRelocationValueString(ELF32LE, Rel, Result); 624 if (auto *ELF64LE = dyn_cast<ELF64LEObjectFile>(Obj)) 625 return getRelocationValueString(ELF64LE, Rel, Result); 626 if (auto *ELF32BE = dyn_cast<ELF32BEObjectFile>(Obj)) 627 return getRelocationValueString(ELF32BE, Rel, Result); 628 auto *ELF64BE = cast<ELF64BEObjectFile>(Obj); 629 return getRelocationValueString(ELF64BE, Rel, Result); 630} 631 632static std::error_code getRelocationValueString(const COFFObjectFile *Obj, 633 const RelocationRef &Rel, 634 SmallVectorImpl<char> &Result) { 635 symbol_iterator SymI = Rel.getSymbol(); 636 Expected<StringRef> SymNameOrErr = SymI->getName(); 637 if (!SymNameOrErr) 638 return errorToErrorCode(SymNameOrErr.takeError()); 639 StringRef SymName = *SymNameOrErr; 640 Result.append(SymName.begin(), SymName.end()); 641 return std::error_code(); 642} 643 644static void printRelocationTargetName(const MachOObjectFile *O, 645 const MachO::any_relocation_info &RE, 646 raw_string_ostream &fmt) { 647 bool IsScattered = O->isRelocationScattered(RE); 648 649 // Target of a scattered relocation is an address. In the interest of 650 // generating pretty output, scan through the symbol table looking for a 651 // symbol that aligns with that address. If we find one, print it. 652 // Otherwise, we just print the hex address of the target. 653 if (IsScattered) { 654 uint32_t Val = O->getPlainRelocationSymbolNum(RE); 655 656 for (const SymbolRef &Symbol : O->symbols()) { 657 std::error_code ec; 658 Expected<uint64_t> Addr = Symbol.getAddress(); 659 if (!Addr) { 660 std::string Buf; 661 raw_string_ostream OS(Buf); 662 logAllUnhandledErrors(Addr.takeError(), OS, ""); 663 OS.flush(); 664 report_fatal_error(Buf); 665 } 666 if (*Addr != Val) 667 continue; 668 Expected<StringRef> Name = Symbol.getName(); 669 if (!Name) { 670 std::string Buf; 671 raw_string_ostream OS(Buf); 672 logAllUnhandledErrors(Name.takeError(), OS, ""); 673 OS.flush(); 674 report_fatal_error(Buf); 675 } 676 fmt << *Name; 677 return; 678 } 679 680 // If we couldn't find a symbol that this relocation refers to, try 681 // to find a section beginning instead. 682 for (const SectionRef &Section : ToolSectionFilter(*O)) { 683 std::error_code ec; 684 685 StringRef Name; 686 uint64_t Addr = Section.getAddress(); 687 if (Addr != Val) 688 continue; 689 if ((ec = Section.getName(Name))) 690 report_fatal_error(ec.message()); 691 fmt << Name; 692 return; 693 } 694 695 fmt << format("0x%x", Val); 696 return; 697 } 698 699 StringRef S; 700 bool isExtern = O->getPlainRelocationExternal(RE); 701 uint64_t Val = O->getPlainRelocationSymbolNum(RE); 702 703 if (isExtern) { 704 symbol_iterator SI = O->symbol_begin(); 705 advance(SI, Val); 706 Expected<StringRef> SOrErr = SI->getName(); 707 error(errorToErrorCode(SOrErr.takeError())); 708 S = *SOrErr; 709 } else { 710 section_iterator SI = O->section_begin(); 711 // Adjust for the fact that sections are 1-indexed. 712 advance(SI, Val - 1); 713 SI->getName(S); 714 } 715 716 fmt << S; 717} 718 719static std::error_code getRelocationValueString(const MachOObjectFile *Obj, 720 const RelocationRef &RelRef, 721 SmallVectorImpl<char> &Result) { 722 DataRefImpl Rel = RelRef.getRawDataRefImpl(); 723 MachO::any_relocation_info RE = Obj->getRelocation(Rel); 724 725 unsigned Arch = Obj->getArch(); 726 727 std::string fmtbuf; 728 raw_string_ostream fmt(fmtbuf); 729 unsigned Type = Obj->getAnyRelocationType(RE); 730 bool IsPCRel = Obj->getAnyRelocationPCRel(RE); 731 732 // Determine any addends that should be displayed with the relocation. 733 // These require decoding the relocation type, which is triple-specific. 734 735 // X86_64 has entirely custom relocation types. 736 if (Arch == Triple::x86_64) { 737 bool isPCRel = Obj->getAnyRelocationPCRel(RE); 738 739 switch (Type) { 740 case MachO::X86_64_RELOC_GOT_LOAD: 741 case MachO::X86_64_RELOC_GOT: { 742 printRelocationTargetName(Obj, RE, fmt); 743 fmt << "@GOT"; 744 if (isPCRel) 745 fmt << "PCREL"; 746 break; 747 } 748 case MachO::X86_64_RELOC_SUBTRACTOR: { 749 DataRefImpl RelNext = Rel; 750 Obj->moveRelocationNext(RelNext); 751 MachO::any_relocation_info RENext = Obj->getRelocation(RelNext); 752 753 // X86_64_RELOC_SUBTRACTOR must be followed by a relocation of type 754 // X86_64_RELOC_UNSIGNED. 755 // NOTE: Scattered relocations don't exist on x86_64. 756 unsigned RType = Obj->getAnyRelocationType(RENext); 757 if (RType != MachO::X86_64_RELOC_UNSIGNED) 758 report_fatal_error("Expected X86_64_RELOC_UNSIGNED after " 759 "X86_64_RELOC_SUBTRACTOR."); 760 761 // The X86_64_RELOC_UNSIGNED contains the minuend symbol; 762 // X86_64_RELOC_SUBTRACTOR contains the subtrahend. 763 printRelocationTargetName(Obj, RENext, fmt); 764 fmt << "-"; 765 printRelocationTargetName(Obj, RE, fmt); 766 break; 767 } 768 case MachO::X86_64_RELOC_TLV: 769 printRelocationTargetName(Obj, RE, fmt); 770 fmt << "@TLV"; 771 if (isPCRel) 772 fmt << "P"; 773 break; 774 case MachO::X86_64_RELOC_SIGNED_1: 775 printRelocationTargetName(Obj, RE, fmt); 776 fmt << "-1"; 777 break; 778 case MachO::X86_64_RELOC_SIGNED_2: 779 printRelocationTargetName(Obj, RE, fmt); 780 fmt << "-2"; 781 break; 782 case MachO::X86_64_RELOC_SIGNED_4: 783 printRelocationTargetName(Obj, RE, fmt); 784 fmt << "-4"; 785 break; 786 default: 787 printRelocationTargetName(Obj, RE, fmt); 788 break; 789 } 790 // X86 and ARM share some relocation types in common. 791 } else if (Arch == Triple::x86 || Arch == Triple::arm || 792 Arch == Triple::ppc) { 793 // Generic relocation types... 794 switch (Type) { 795 case MachO::GENERIC_RELOC_PAIR: // prints no info 796 return std::error_code(); 797 case MachO::GENERIC_RELOC_SECTDIFF: { 798 DataRefImpl RelNext = Rel; 799 Obj->moveRelocationNext(RelNext); 800 MachO::any_relocation_info RENext = Obj->getRelocation(RelNext); 801 802 // X86 sect diff's must be followed by a relocation of type 803 // GENERIC_RELOC_PAIR. 804 unsigned RType = Obj->getAnyRelocationType(RENext); 805 806 if (RType != MachO::GENERIC_RELOC_PAIR) 807 report_fatal_error("Expected GENERIC_RELOC_PAIR after " 808 "GENERIC_RELOC_SECTDIFF."); 809 810 printRelocationTargetName(Obj, RE, fmt); 811 fmt << "-"; 812 printRelocationTargetName(Obj, RENext, fmt); 813 break; 814 } 815 } 816 817 if (Arch == Triple::x86 || Arch == Triple::ppc) { 818 switch (Type) { 819 case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: { 820 DataRefImpl RelNext = Rel; 821 Obj->moveRelocationNext(RelNext); 822 MachO::any_relocation_info RENext = Obj->getRelocation(RelNext); 823 824 // X86 sect diff's must be followed by a relocation of type 825 // GENERIC_RELOC_PAIR. 826 unsigned RType = Obj->getAnyRelocationType(RENext); 827 if (RType != MachO::GENERIC_RELOC_PAIR) 828 report_fatal_error("Expected GENERIC_RELOC_PAIR after " 829 "GENERIC_RELOC_LOCAL_SECTDIFF."); 830 831 printRelocationTargetName(Obj, RE, fmt); 832 fmt << "-"; 833 printRelocationTargetName(Obj, RENext, fmt); 834 break; 835 } 836 case MachO::GENERIC_RELOC_TLV: { 837 printRelocationTargetName(Obj, RE, fmt); 838 fmt << "@TLV"; 839 if (IsPCRel) 840 fmt << "P"; 841 break; 842 } 843 default: 844 printRelocationTargetName(Obj, RE, fmt); 845 } 846 } else { // ARM-specific relocations 847 switch (Type) { 848 case MachO::ARM_RELOC_HALF: 849 case MachO::ARM_RELOC_HALF_SECTDIFF: { 850 // Half relocations steal a bit from the length field to encode 851 // whether this is an upper16 or a lower16 relocation. 852 bool isUpper = Obj->getAnyRelocationLength(RE) >> 1; 853 854 if (isUpper) 855 fmt << ":upper16:("; 856 else 857 fmt << ":lower16:("; 858 printRelocationTargetName(Obj, RE, fmt); 859 860 DataRefImpl RelNext = Rel; 861 Obj->moveRelocationNext(RelNext); 862 MachO::any_relocation_info RENext = Obj->getRelocation(RelNext); 863 864 // ARM half relocs must be followed by a relocation of type 865 // ARM_RELOC_PAIR. 866 unsigned RType = Obj->getAnyRelocationType(RENext); 867 if (RType != MachO::ARM_RELOC_PAIR) 868 report_fatal_error("Expected ARM_RELOC_PAIR after " 869 "ARM_RELOC_HALF"); 870 871 // NOTE: The half of the target virtual address is stashed in the 872 // address field of the secondary relocation, but we can't reverse 873 // engineer the constant offset from it without decoding the movw/movt 874 // instruction to find the other half in its immediate field. 875 876 // ARM_RELOC_HALF_SECTDIFF encodes the second section in the 877 // symbol/section pointer of the follow-on relocation. 878 if (Type == MachO::ARM_RELOC_HALF_SECTDIFF) { 879 fmt << "-"; 880 printRelocationTargetName(Obj, RENext, fmt); 881 } 882 883 fmt << ")"; 884 break; 885 } 886 default: { printRelocationTargetName(Obj, RE, fmt); } 887 } 888 } 889 } else 890 printRelocationTargetName(Obj, RE, fmt); 891 892 fmt.flush(); 893 Result.append(fmtbuf.begin(), fmtbuf.end()); 894 return std::error_code(); 895} 896 897static std::error_code getRelocationValueString(const RelocationRef &Rel, 898 SmallVectorImpl<char> &Result) { 899 const ObjectFile *Obj = Rel.getObject(); 900 if (auto *ELF = dyn_cast<ELFObjectFileBase>(Obj)) 901 return getRelocationValueString(ELF, Rel, Result); 902 if (auto *COFF = dyn_cast<COFFObjectFile>(Obj)) 903 return getRelocationValueString(COFF, Rel, Result); 904 auto *MachO = cast<MachOObjectFile>(Obj); 905 return getRelocationValueString(MachO, Rel, Result); 906} 907 908/// @brief Indicates whether this relocation should hidden when listing 909/// relocations, usually because it is the trailing part of a multipart 910/// relocation that will be printed as part of the leading relocation. 911static bool getHidden(RelocationRef RelRef) { 912 const ObjectFile *Obj = RelRef.getObject(); 913 auto *MachO = dyn_cast<MachOObjectFile>(Obj); 914 if (!MachO) 915 return false; 916 917 unsigned Arch = MachO->getArch(); 918 DataRefImpl Rel = RelRef.getRawDataRefImpl(); 919 uint64_t Type = MachO->getRelocationType(Rel); 920 921 // On arches that use the generic relocations, GENERIC_RELOC_PAIR 922 // is always hidden. 923 if (Arch == Triple::x86 || Arch == Triple::arm || Arch == Triple::ppc) { 924 if (Type == MachO::GENERIC_RELOC_PAIR) 925 return true; 926 } else if (Arch == Triple::x86_64) { 927 // On x86_64, X86_64_RELOC_UNSIGNED is hidden only when it follows 928 // an X86_64_RELOC_SUBTRACTOR. 929 if (Type == MachO::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) { 930 DataRefImpl RelPrev = Rel; 931 RelPrev.d.a--; 932 uint64_t PrevType = MachO->getRelocationType(RelPrev); 933 if (PrevType == MachO::X86_64_RELOC_SUBTRACTOR) 934 return true; 935 } 936 } 937 938 return false; 939} 940 941static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) { 942 const Target *TheTarget = getTarget(Obj); 943 944 // Package up features to be passed to target/subtarget 945 SubtargetFeatures Features = Obj->getFeatures(); 946 if (MAttrs.size()) { 947 for (unsigned i = 0; i != MAttrs.size(); ++i) 948 Features.AddFeature(MAttrs[i]); 949 } 950 951 std::unique_ptr<const MCRegisterInfo> MRI( 952 TheTarget->createMCRegInfo(TripleName)); 953 if (!MRI) 954 report_fatal_error("error: no register info for target " + TripleName); 955 956 // Set up disassembler. 957 std::unique_ptr<const MCAsmInfo> AsmInfo( 958 TheTarget->createMCAsmInfo(*MRI, TripleName)); 959 if (!AsmInfo) 960 report_fatal_error("error: no assembly info for target " + TripleName); 961 std::unique_ptr<const MCSubtargetInfo> STI( 962 TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString())); 963 if (!STI) 964 report_fatal_error("error: no subtarget info for target " + TripleName); 965 std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo()); 966 if (!MII) 967 report_fatal_error("error: no instruction info for target " + TripleName); 968 std::unique_ptr<const MCObjectFileInfo> MOFI(new MCObjectFileInfo); 969 MCContext Ctx(AsmInfo.get(), MRI.get(), MOFI.get()); 970 971 std::unique_ptr<MCDisassembler> DisAsm( 972 TheTarget->createMCDisassembler(*STI, Ctx)); 973 if (!DisAsm) 974 report_fatal_error("error: no disassembler for target " + TripleName); 975 976 std::unique_ptr<const MCInstrAnalysis> MIA( 977 TheTarget->createMCInstrAnalysis(MII.get())); 978 979 int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); 980 std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter( 981 Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI)); 982 if (!IP) 983 report_fatal_error("error: no instruction printer for target " + 984 TripleName); 985 IP->setPrintImmHex(PrintImmHex); 986 PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName)); 987 988 StringRef Fmt = Obj->getBytesInAddress() > 4 ? "\t\t%016" PRIx64 ": " : 989 "\t\t\t%08" PRIx64 ": "; 990 991 // Create a mapping, RelocSecs = SectionRelocMap[S], where sections 992 // in RelocSecs contain the relocations for section S. 993 std::error_code EC; 994 std::map<SectionRef, SmallVector<SectionRef, 1>> SectionRelocMap; 995 for (const SectionRef &Section : ToolSectionFilter(*Obj)) { 996 section_iterator Sec2 = Section.getRelocatedSection(); 997 if (Sec2 != Obj->section_end()) 998 SectionRelocMap[*Sec2].push_back(Section); 999 } 1000 1001 // Create a mapping from virtual address to symbol name. This is used to 1002 // pretty print the symbols while disassembling. 1003 typedef std::vector<std::pair<uint64_t, StringRef>> SectionSymbolsTy; 1004 std::map<SectionRef, SectionSymbolsTy> AllSymbols; 1005 for (const SymbolRef &Symbol : Obj->symbols()) { 1006 Expected<uint64_t> AddressOrErr = Symbol.getAddress(); 1007 error(errorToErrorCode(AddressOrErr.takeError())); 1008 uint64_t Address = *AddressOrErr; 1009 1010 Expected<StringRef> Name = Symbol.getName(); 1011 error(errorToErrorCode(Name.takeError())); 1012 if (Name->empty()) 1013 continue; 1014 1015 Expected<section_iterator> SectionOrErr = Symbol.getSection(); 1016 error(errorToErrorCode(SectionOrErr.takeError())); 1017 section_iterator SecI = *SectionOrErr; 1018 if (SecI == Obj->section_end()) 1019 continue; 1020 1021 AllSymbols[*SecI].emplace_back(Address, *Name); 1022 } 1023 1024 // Create a mapping from virtual address to section. 1025 std::vector<std::pair<uint64_t, SectionRef>> SectionAddresses; 1026 for (SectionRef Sec : Obj->sections()) 1027 SectionAddresses.emplace_back(Sec.getAddress(), Sec); 1028 array_pod_sort(SectionAddresses.begin(), SectionAddresses.end()); 1029 1030 // Linked executables (.exe and .dll files) typically don't include a real 1031 // symbol table but they might contain an export table. 1032 if (const auto *COFFObj = dyn_cast<COFFObjectFile>(Obj)) { 1033 for (const auto &ExportEntry : COFFObj->export_directories()) { 1034 StringRef Name; 1035 error(ExportEntry.getSymbolName(Name)); 1036 if (Name.empty()) 1037 continue; 1038 uint32_t RVA; 1039 error(ExportEntry.getExportRVA(RVA)); 1040 1041 uint64_t VA = COFFObj->getImageBase() + RVA; 1042 auto Sec = std::upper_bound( 1043 SectionAddresses.begin(), SectionAddresses.end(), VA, 1044 [](uint64_t LHS, const std::pair<uint64_t, SectionRef> &RHS) { 1045 return LHS < RHS.first; 1046 }); 1047 if (Sec != SectionAddresses.begin()) 1048 --Sec; 1049 else 1050 Sec = SectionAddresses.end(); 1051 1052 if (Sec != SectionAddresses.end()) 1053 AllSymbols[Sec->second].emplace_back(VA, Name); 1054 } 1055 } 1056 1057 // Sort all the symbols, this allows us to use a simple binary search to find 1058 // a symbol near an address. 1059 for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols) 1060 array_pod_sort(SecSyms.second.begin(), SecSyms.second.end()); 1061 1062 for (const SectionRef &Section : ToolSectionFilter(*Obj)) { 1063 if (!DisassembleAll && (!Section.isText() || Section.isVirtual())) 1064 continue; 1065 1066 uint64_t SectionAddr = Section.getAddress(); 1067 uint64_t SectSize = Section.getSize(); 1068 if (!SectSize) 1069 continue; 1070 1071 // Get the list of all the symbols in this section. 1072 SectionSymbolsTy &Symbols = AllSymbols[Section]; 1073 std::vector<uint64_t> DataMappingSymsAddr; 1074 std::vector<uint64_t> TextMappingSymsAddr; 1075 if (Obj->isELF() && Obj->getArch() == Triple::aarch64) { 1076 for (const auto &Symb : Symbols) { 1077 uint64_t Address = Symb.first; 1078 StringRef Name = Symb.second; 1079 if (Name.startswith("$d")) 1080 DataMappingSymsAddr.push_back(Address - SectionAddr); 1081 if (Name.startswith("$x")) 1082 TextMappingSymsAddr.push_back(Address - SectionAddr); 1083 } 1084 } 1085 1086 std::sort(DataMappingSymsAddr.begin(), DataMappingSymsAddr.end()); 1087 std::sort(TextMappingSymsAddr.begin(), TextMappingSymsAddr.end()); 1088 1089 // Make a list of all the relocations for this section. 1090 std::vector<RelocationRef> Rels; 1091 if (InlineRelocs) { 1092 for (const SectionRef &RelocSec : SectionRelocMap[Section]) { 1093 for (const RelocationRef &Reloc : RelocSec.relocations()) { 1094 Rels.push_back(Reloc); 1095 } 1096 } 1097 } 1098 1099 // Sort relocations by address. 1100 std::sort(Rels.begin(), Rels.end(), RelocAddressLess); 1101 1102 StringRef SegmentName = ""; 1103 if (const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj)) { 1104 DataRefImpl DR = Section.getRawDataRefImpl(); 1105 SegmentName = MachO->getSectionFinalSegmentName(DR); 1106 } 1107 StringRef name; 1108 error(Section.getName(name)); 1109 outs() << "Disassembly of section "; 1110 if (!SegmentName.empty()) 1111 outs() << SegmentName << ","; 1112 outs() << name << ':'; 1113 1114 // If the section has no symbol at the start, just insert a dummy one. 1115 if (Symbols.empty() || Symbols[0].first != 0) 1116 Symbols.insert(Symbols.begin(), std::make_pair(SectionAddr, name)); 1117 1118 SmallString<40> Comments; 1119 raw_svector_ostream CommentStream(Comments); 1120 1121 StringRef BytesStr; 1122 error(Section.getContents(BytesStr)); 1123 ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()), 1124 BytesStr.size()); 1125 1126 uint64_t Size; 1127 uint64_t Index; 1128 1129 std::vector<RelocationRef>::const_iterator rel_cur = Rels.begin(); 1130 std::vector<RelocationRef>::const_iterator rel_end = Rels.end(); 1131 // Disassemble symbol by symbol. 1132 for (unsigned si = 0, se = Symbols.size(); si != se; ++si) { 1133 1134 uint64_t Start = Symbols[si].first - SectionAddr; 1135 // The end is either the section end or the beginning of the next 1136 // symbol. 1137 uint64_t End = 1138 (si == se - 1) ? SectSize : Symbols[si + 1].first - SectionAddr; 1139 // Don't try to disassemble beyond the end of section contents. 1140 if (End > SectSize) 1141 End = SectSize; 1142 // If this symbol has the same address as the next symbol, then skip it. 1143 if (Start >= End) 1144 continue; 1145 1146 if (Obj->isELF() && Obj->getArch() == Triple::amdgcn) { 1147 // make size 4 bytes folded 1148 End = Start + ((End - Start) & ~0x3ull); 1149 Start += 256; // add sizeof(amd_kernel_code_t) 1150 // cut trailing zeroes - up to 256 bytes (align) 1151 const uint64_t EndAlign = 256; 1152 const auto Limit = End - (std::min)(EndAlign, End - Start); 1153 while (End > Limit && 1154 *reinterpret_cast<const support::ulittle32_t*>(&Bytes[End - 4]) == 0) 1155 End -= 4; 1156 } 1157 1158 outs() << '\n' << Symbols[si].second << ":\n"; 1159 1160#ifndef NDEBUG 1161 raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls(); 1162#else 1163 raw_ostream &DebugOut = nulls(); 1164#endif 1165 1166 for (Index = Start; Index < End; Index += Size) { 1167 MCInst Inst; 1168 1169 // AArch64 ELF binaries can interleave data and text in the 1170 // same section. We rely on the markers introduced to 1171 // understand what we need to dump. 1172 if (Obj->isELF() && Obj->getArch() == Triple::aarch64) { 1173 uint64_t Stride = 0; 1174 1175 auto DAI = std::lower_bound(DataMappingSymsAddr.begin(), 1176 DataMappingSymsAddr.end(), Index); 1177 if (DAI != DataMappingSymsAddr.end() && *DAI == Index) { 1178 // Switch to data. 1179 while (Index < End) { 1180 outs() << format("%8" PRIx64 ":", SectionAddr + Index); 1181 outs() << "\t"; 1182 if (Index + 4 <= End) { 1183 Stride = 4; 1184 dumpBytes(Bytes.slice(Index, 4), outs()); 1185 outs() << "\t.word"; 1186 } else if (Index + 2 <= End) { 1187 Stride = 2; 1188 dumpBytes(Bytes.slice(Index, 2), outs()); 1189 outs() << "\t.short"; 1190 } else { 1191 Stride = 1; 1192 dumpBytes(Bytes.slice(Index, 1), outs()); 1193 outs() << "\t.byte"; 1194 } 1195 Index += Stride; 1196 outs() << "\n"; 1197 auto TAI = std::lower_bound(TextMappingSymsAddr.begin(), 1198 TextMappingSymsAddr.end(), Index); 1199 if (TAI != TextMappingSymsAddr.end() && *TAI == Index) 1200 break; 1201 } 1202 } 1203 } 1204 1205 if (Index >= End) 1206 break; 1207 1208 bool Disassembled = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), 1209 SectionAddr + Index, DebugOut, 1210 CommentStream); 1211 if (Size == 0) 1212 Size = 1; 1213 PIP.printInst(*IP, Disassembled ? &Inst : nullptr, 1214 Bytes.slice(Index, Size), 1215 SectionAddr + Index, outs(), "", *STI); 1216 outs() << CommentStream.str(); 1217 Comments.clear(); 1218 1219 // Try to resolve the target of a call, tail call, etc. to a specific 1220 // symbol. 1221 if (MIA && (MIA->isCall(Inst) || MIA->isUnconditionalBranch(Inst) || 1222 MIA->isConditionalBranch(Inst))) { 1223 uint64_t Target; 1224 if (MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target)) { 1225 // In a relocatable object, the target's section must reside in 1226 // the same section as the call instruction or it is accessed 1227 // through a relocation. 1228 // 1229 // In a non-relocatable object, the target may be in any section. 1230 // 1231 // N.B. We don't walk the relocations in the relocatable case yet. 1232 auto *TargetSectionSymbols = &Symbols; 1233 if (!Obj->isRelocatableObject()) { 1234 auto SectionAddress = std::upper_bound( 1235 SectionAddresses.begin(), SectionAddresses.end(), Target, 1236 [](uint64_t LHS, 1237 const std::pair<uint64_t, SectionRef> &RHS) { 1238 return LHS < RHS.first; 1239 }); 1240 if (SectionAddress != SectionAddresses.begin()) { 1241 --SectionAddress; 1242 TargetSectionSymbols = &AllSymbols[SectionAddress->second]; 1243 } else { 1244 TargetSectionSymbols = nullptr; 1245 } 1246 } 1247 1248 // Find the first symbol in the section whose offset is less than 1249 // or equal to the target. 1250 if (TargetSectionSymbols) { 1251 auto TargetSym = std::upper_bound( 1252 TargetSectionSymbols->begin(), TargetSectionSymbols->end(), 1253 Target, [](uint64_t LHS, 1254 const std::pair<uint64_t, StringRef> &RHS) { 1255 return LHS < RHS.first; 1256 }); 1257 if (TargetSym != TargetSectionSymbols->begin()) { 1258 --TargetSym; 1259 uint64_t TargetAddress = std::get<0>(*TargetSym); 1260 StringRef TargetName = std::get<1>(*TargetSym); 1261 outs() << " <" << TargetName; 1262 uint64_t Disp = Target - TargetAddress; 1263 if (Disp) 1264 outs() << "+0x" << utohexstr(Disp); 1265 outs() << '>'; 1266 } 1267 } 1268 } 1269 } 1270 outs() << "\n"; 1271 1272 // Print relocation for instruction. 1273 while (rel_cur != rel_end) { 1274 bool hidden = getHidden(*rel_cur); 1275 uint64_t addr = rel_cur->getOffset(); 1276 SmallString<16> name; 1277 SmallString<32> val; 1278 1279 // If this relocation is hidden, skip it. 1280 if (hidden) goto skip_print_rel; 1281 1282 // Stop when rel_cur's address is past the current instruction. 1283 if (addr >= Index + Size) break; 1284 rel_cur->getTypeName(name); 1285 error(getRelocationValueString(*rel_cur, val)); 1286 outs() << format(Fmt.data(), SectionAddr + addr) << name 1287 << "\t" << val << "\n"; 1288 1289 skip_print_rel: 1290 ++rel_cur; 1291 } 1292 } 1293 } 1294 } 1295} 1296 1297void llvm::PrintRelocations(const ObjectFile *Obj) { 1298 StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 : 1299 "%08" PRIx64; 1300 // Regular objdump doesn't print relocations in non-relocatable object 1301 // files. 1302 if (!Obj->isRelocatableObject()) 1303 return; 1304 1305 for (const SectionRef &Section : ToolSectionFilter(*Obj)) { 1306 if (Section.relocation_begin() == Section.relocation_end()) 1307 continue; 1308 StringRef secname; 1309 error(Section.getName(secname)); 1310 outs() << "RELOCATION RECORDS FOR [" << secname << "]:\n"; 1311 for (const RelocationRef &Reloc : Section.relocations()) { 1312 bool hidden = getHidden(Reloc); 1313 uint64_t address = Reloc.getOffset(); 1314 SmallString<32> relocname; 1315 SmallString<32> valuestr; 1316 if (hidden) 1317 continue; 1318 Reloc.getTypeName(relocname); 1319 error(getRelocationValueString(Reloc, valuestr)); 1320 outs() << format(Fmt.data(), address) << " " << relocname << " " 1321 << valuestr << "\n"; 1322 } 1323 outs() << "\n"; 1324 } 1325} 1326 1327void llvm::PrintSectionHeaders(const ObjectFile *Obj) { 1328 outs() << "Sections:\n" 1329 "Idx Name Size Address Type\n"; 1330 unsigned i = 0; 1331 for (const SectionRef &Section : ToolSectionFilter(*Obj)) { 1332 StringRef Name; 1333 error(Section.getName(Name)); 1334 uint64_t Address = Section.getAddress(); 1335 uint64_t Size = Section.getSize(); 1336 bool Text = Section.isText(); 1337 bool Data = Section.isData(); 1338 bool BSS = Section.isBSS(); 1339 std::string Type = (std::string(Text ? "TEXT " : "") + 1340 (Data ? "DATA " : "") + (BSS ? "BSS" : "")); 1341 outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n", i, 1342 Name.str().c_str(), Size, Address, Type.c_str()); 1343 ++i; 1344 } 1345} 1346 1347void llvm::PrintSectionContents(const ObjectFile *Obj) { 1348 std::error_code EC; 1349 for (const SectionRef &Section : ToolSectionFilter(*Obj)) { 1350 StringRef Name; 1351 StringRef Contents; 1352 error(Section.getName(Name)); 1353 uint64_t BaseAddr = Section.getAddress(); 1354 uint64_t Size = Section.getSize(); 1355 if (!Size) 1356 continue; 1357 1358 outs() << "Contents of section " << Name << ":\n"; 1359 if (Section.isBSS()) { 1360 outs() << format("<skipping contents of bss section at [%04" PRIx64 1361 ", %04" PRIx64 ")>\n", 1362 BaseAddr, BaseAddr + Size); 1363 continue; 1364 } 1365 1366 error(Section.getContents(Contents)); 1367 1368 // Dump out the content as hex and printable ascii characters. 1369 for (std::size_t addr = 0, end = Contents.size(); addr < end; addr += 16) { 1370 outs() << format(" %04" PRIx64 " ", BaseAddr + addr); 1371 // Dump line of hex. 1372 for (std::size_t i = 0; i < 16; ++i) { 1373 if (i != 0 && i % 4 == 0) 1374 outs() << ' '; 1375 if (addr + i < end) 1376 outs() << hexdigit((Contents[addr + i] >> 4) & 0xF, true) 1377 << hexdigit(Contents[addr + i] & 0xF, true); 1378 else 1379 outs() << " "; 1380 } 1381 // Print ascii. 1382 outs() << " "; 1383 for (std::size_t i = 0; i < 16 && addr + i < end; ++i) { 1384 if (std::isprint(static_cast<unsigned char>(Contents[addr + i]) & 0xFF)) 1385 outs() << Contents[addr + i]; 1386 else 1387 outs() << "."; 1388 } 1389 outs() << "\n"; 1390 } 1391 } 1392} 1393 1394void llvm::PrintSymbolTable(const ObjectFile *o, StringRef ArchiveName, 1395 StringRef ArchitectureName) { 1396 outs() << "SYMBOL TABLE:\n"; 1397 1398 if (const COFFObjectFile *coff = dyn_cast<const COFFObjectFile>(o)) { 1399 printCOFFSymbolTable(coff); 1400 return; 1401 } 1402 for (const SymbolRef &Symbol : o->symbols()) { 1403 Expected<uint64_t> AddressOrError = Symbol.getAddress(); 1404 if (!AddressOrError) 1405 report_error(ArchiveName, o->getFileName(), AddressOrError.takeError()); 1406 uint64_t Address = *AddressOrError; 1407 Expected<SymbolRef::Type> TypeOrError = Symbol.getType(); 1408 if (!TypeOrError) 1409 report_error(ArchiveName, o->getFileName(), TypeOrError.takeError()); 1410 SymbolRef::Type Type = *TypeOrError; 1411 uint32_t Flags = Symbol.getFlags(); 1412 Expected<section_iterator> SectionOrErr = Symbol.getSection(); 1413 error(errorToErrorCode(SectionOrErr.takeError())); 1414 section_iterator Section = *SectionOrErr; 1415 StringRef Name; 1416 if (Type == SymbolRef::ST_Debug && Section != o->section_end()) { 1417 Section->getName(Name); 1418 } else { 1419 Expected<StringRef> NameOrErr = Symbol.getName(); 1420 if (!NameOrErr) 1421 report_error(ArchiveName, o->getFileName(), NameOrErr.takeError(), 1422 ArchitectureName); 1423 Name = *NameOrErr; 1424 } 1425 1426 bool Global = Flags & SymbolRef::SF_Global; 1427 bool Weak = Flags & SymbolRef::SF_Weak; 1428 bool Absolute = Flags & SymbolRef::SF_Absolute; 1429 bool Common = Flags & SymbolRef::SF_Common; 1430 bool Hidden = Flags & SymbolRef::SF_Hidden; 1431 1432 char GlobLoc = ' '; 1433 if (Type != SymbolRef::ST_Unknown) 1434 GlobLoc = Global ? 'g' : 'l'; 1435 char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File) 1436 ? 'd' : ' '; 1437 char FileFunc = ' '; 1438 if (Type == SymbolRef::ST_File) 1439 FileFunc = 'f'; 1440 else if (Type == SymbolRef::ST_Function) 1441 FileFunc = 'F'; 1442 1443 const char *Fmt = o->getBytesInAddress() > 4 ? "%016" PRIx64 : 1444 "%08" PRIx64; 1445 1446 outs() << format(Fmt, Address) << " " 1447 << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' ' 1448 << (Weak ? 'w' : ' ') // Weak? 1449 << ' ' // Constructor. Not supported yet. 1450 << ' ' // Warning. Not supported yet. 1451 << ' ' // Indirect reference to another symbol. 1452 << Debug // Debugging (d) or dynamic (D) symbol. 1453 << FileFunc // Name of function (F), file (f) or object (O). 1454 << ' '; 1455 if (Absolute) { 1456 outs() << "*ABS*"; 1457 } else if (Common) { 1458 outs() << "*COM*"; 1459 } else if (Section == o->section_end()) { 1460 outs() << "*UND*"; 1461 } else { 1462 if (const MachOObjectFile *MachO = 1463 dyn_cast<const MachOObjectFile>(o)) { 1464 DataRefImpl DR = Section->getRawDataRefImpl(); 1465 StringRef SegmentName = MachO->getSectionFinalSegmentName(DR); 1466 outs() << SegmentName << ","; 1467 } 1468 StringRef SectionName; 1469 error(Section->getName(SectionName)); 1470 outs() << SectionName; 1471 } 1472 1473 outs() << '\t'; 1474 if (Common || isa<ELFObjectFileBase>(o)) { 1475 uint64_t Val = 1476 Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize(); 1477 outs() << format("\t %08" PRIx64 " ", Val); 1478 } 1479 1480 if (Hidden) { 1481 outs() << ".hidden "; 1482 } 1483 outs() << Name 1484 << '\n'; 1485 } 1486} 1487 1488static void PrintUnwindInfo(const ObjectFile *o) { 1489 outs() << "Unwind info:\n\n"; 1490 1491 if (const COFFObjectFile *coff = dyn_cast<COFFObjectFile>(o)) { 1492 printCOFFUnwindInfo(coff); 1493 } else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 1494 printMachOUnwindInfo(MachO); 1495 else { 1496 // TODO: Extract DWARF dump tool to objdump. 1497 errs() << "This operation is only currently supported " 1498 "for COFF and MachO object files.\n"; 1499 return; 1500 } 1501} 1502 1503void llvm::printExportsTrie(const ObjectFile *o) { 1504 outs() << "Exports trie:\n"; 1505 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 1506 printMachOExportsTrie(MachO); 1507 else { 1508 errs() << "This operation is only currently supported " 1509 "for Mach-O executable files.\n"; 1510 return; 1511 } 1512} 1513 1514void llvm::printRebaseTable(const ObjectFile *o) { 1515 outs() << "Rebase table:\n"; 1516 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 1517 printMachORebaseTable(MachO); 1518 else { 1519 errs() << "This operation is only currently supported " 1520 "for Mach-O executable files.\n"; 1521 return; 1522 } 1523} 1524 1525void llvm::printBindTable(const ObjectFile *o) { 1526 outs() << "Bind table:\n"; 1527 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 1528 printMachOBindTable(MachO); 1529 else { 1530 errs() << "This operation is only currently supported " 1531 "for Mach-O executable files.\n"; 1532 return; 1533 } 1534} 1535 1536void llvm::printLazyBindTable(const ObjectFile *o) { 1537 outs() << "Lazy bind table:\n"; 1538 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 1539 printMachOLazyBindTable(MachO); 1540 else { 1541 errs() << "This operation is only currently supported " 1542 "for Mach-O executable files.\n"; 1543 return; 1544 } 1545} 1546 1547void llvm::printWeakBindTable(const ObjectFile *o) { 1548 outs() << "Weak bind table:\n"; 1549 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) 1550 printMachOWeakBindTable(MachO); 1551 else { 1552 errs() << "This operation is only currently supported " 1553 "for Mach-O executable files.\n"; 1554 return; 1555 } 1556} 1557 1558/// Dump the raw contents of the __clangast section so the output can be piped 1559/// into llvm-bcanalyzer. 1560void llvm::printRawClangAST(const ObjectFile *Obj) { 1561 if (outs().is_displayed()) { 1562 errs() << "The -raw-clang-ast option will dump the raw binary contents of " 1563 "the clang ast section.\n" 1564 "Please redirect the output to a file or another program such as " 1565 "llvm-bcanalyzer.\n"; 1566 return; 1567 } 1568 1569 StringRef ClangASTSectionName("__clangast"); 1570 if (isa<COFFObjectFile>(Obj)) { 1571 ClangASTSectionName = "clangast"; 1572 } 1573 1574 Optional<object::SectionRef> ClangASTSection; 1575 for (auto Sec : ToolSectionFilter(*Obj)) { 1576 StringRef Name; 1577 Sec.getName(Name); 1578 if (Name == ClangASTSectionName) { 1579 ClangASTSection = Sec; 1580 break; 1581 } 1582 } 1583 if (!ClangASTSection) 1584 return; 1585 1586 StringRef ClangASTContents; 1587 error(ClangASTSection.getValue().getContents(ClangASTContents)); 1588 outs().write(ClangASTContents.data(), ClangASTContents.size()); 1589} 1590 1591static void printFaultMaps(const ObjectFile *Obj) { 1592 const char *FaultMapSectionName = nullptr; 1593 1594 if (isa<ELFObjectFileBase>(Obj)) { 1595 FaultMapSectionName = ".llvm_faultmaps"; 1596 } else if (isa<MachOObjectFile>(Obj)) { 1597 FaultMapSectionName = "__llvm_faultmaps"; 1598 } else { 1599 errs() << "This operation is only currently supported " 1600 "for ELF and Mach-O executable files.\n"; 1601 return; 1602 } 1603 1604 Optional<object::SectionRef> FaultMapSection; 1605 1606 for (auto Sec : ToolSectionFilter(*Obj)) { 1607 StringRef Name; 1608 Sec.getName(Name); 1609 if (Name == FaultMapSectionName) { 1610 FaultMapSection = Sec; 1611 break; 1612 } 1613 } 1614 1615 outs() << "FaultMap table:\n"; 1616 1617 if (!FaultMapSection.hasValue()) { 1618 outs() << "<not found>\n"; 1619 return; 1620 } 1621 1622 StringRef FaultMapContents; 1623 error(FaultMapSection.getValue().getContents(FaultMapContents)); 1624 1625 FaultMapParser FMP(FaultMapContents.bytes_begin(), 1626 FaultMapContents.bytes_end()); 1627 1628 outs() << FMP; 1629} 1630 1631static void printPrivateFileHeaders(const ObjectFile *o) { 1632 if (o->isELF()) 1633 printELFFileHeader(o); 1634 else if (o->isCOFF()) 1635 printCOFFFileHeader(o); 1636 else if (o->isMachO()) { 1637 printMachOFileHeader(o); 1638 printMachOLoadCommands(o); 1639 } else 1640 report_fatal_error("Invalid/Unsupported object file format"); 1641} 1642 1643static void printFirstPrivateFileHeader(const ObjectFile *o) { 1644 if (o->isELF()) 1645 printELFFileHeader(o); 1646 else if (o->isCOFF()) 1647 printCOFFFileHeader(o); 1648 else if (o->isMachO()) 1649 printMachOFileHeader(o); 1650 else 1651 report_fatal_error("Invalid/Unsupported object file format"); 1652} 1653 1654static void DumpObject(const ObjectFile *o, const Archive *a = nullptr) { 1655 StringRef ArchiveName = a != nullptr ? a->getFileName() : ""; 1656 // Avoid other output when using a raw option. 1657 if (!RawClangAST) { 1658 outs() << '\n'; 1659 if (a) 1660 outs() << a->getFileName() << "(" << o->getFileName() << ")"; 1661 else 1662 outs() << o->getFileName(); 1663 outs() << ":\tfile format " << o->getFileFormatName() << "\n\n"; 1664 } 1665 1666 if (Disassemble) 1667 DisassembleObject(o, Relocations); 1668 if (Relocations && !Disassemble) 1669 PrintRelocations(o); 1670 if (SectionHeaders) 1671 PrintSectionHeaders(o); 1672 if (SectionContents) 1673 PrintSectionContents(o); 1674 if (SymbolTable) 1675 PrintSymbolTable(o, ArchiveName); 1676 if (UnwindInfo) 1677 PrintUnwindInfo(o); 1678 if (PrivateHeaders) 1679 printPrivateFileHeaders(o); 1680 if (FirstPrivateHeader) 1681 printFirstPrivateFileHeader(o); 1682 if (ExportsTrie) 1683 printExportsTrie(o); 1684 if (Rebase) 1685 printRebaseTable(o); 1686 if (Bind) 1687 printBindTable(o); 1688 if (LazyBind) 1689 printLazyBindTable(o); 1690 if (WeakBind) 1691 printWeakBindTable(o); 1692 if (RawClangAST) 1693 printRawClangAST(o); 1694 if (PrintFaultMaps) 1695 printFaultMaps(o); 1696 if (DwarfDumpType != DIDT_Null) { 1697 std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(*o)); 1698 // Dump the complete DWARF structure. 1699 DICtx->dump(outs(), DwarfDumpType, true /* DumpEH */); 1700 } 1701} 1702 1703/// @brief Dump each object file in \a a; 1704static void DumpArchive(const Archive *a) { 1705 Error Err; 1706 for (auto &C : a->children(Err)) { 1707 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(); 1708 if (!ChildOrErr) { 1709 if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) 1710 report_error(a->getFileName(), C, std::move(E)); 1711 continue; 1712 } 1713 if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) 1714 DumpObject(o, a); 1715 else 1716 report_error(a->getFileName(), object_error::invalid_file_type); 1717 } 1718 if (Err) 1719 report_error(a->getFileName(), std::move(Err)); 1720} 1721 1722/// @brief Open file and figure out how to dump it. 1723static void DumpInput(StringRef file) { 1724 1725 // If we are using the Mach-O specific object file parser, then let it parse 1726 // the file and process the command line options. So the -arch flags can 1727 // be used to select specific slices, etc. 1728 if (MachOOpt) { 1729 ParseInputMachO(file); 1730 return; 1731 } 1732 1733 // Attempt to open the binary. 1734 Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(file); 1735 if (!BinaryOrErr) 1736 report_error(file, BinaryOrErr.takeError()); 1737 Binary &Binary = *BinaryOrErr.get().getBinary(); 1738 1739 if (Archive *a = dyn_cast<Archive>(&Binary)) 1740 DumpArchive(a); 1741 else if (ObjectFile *o = dyn_cast<ObjectFile>(&Binary)) 1742 DumpObject(o); 1743 else 1744 report_error(file, object_error::invalid_file_type); 1745} 1746 1747int main(int argc, char **argv) { 1748 // Print a stack trace if we signal out. 1749 sys::PrintStackTraceOnErrorSignal(argv[0]); 1750 PrettyStackTraceProgram X(argc, argv); 1751 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 1752 1753 // Initialize targets and assembly printers/parsers. 1754 llvm::InitializeAllTargetInfos(); 1755 llvm::InitializeAllTargetMCs(); 1756 llvm::InitializeAllDisassemblers(); 1757 1758 // Register the target printer for --version. 1759 cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); 1760 1761 cl::ParseCommandLineOptions(argc, argv, "llvm object file dumper\n"); 1762 TripleName = Triple::normalize(TripleName); 1763 1764 ToolName = argv[0]; 1765 1766 // Defaults to a.out if no filenames specified. 1767 if (InputFilenames.size() == 0) 1768 InputFilenames.push_back("a.out"); 1769 1770 if (DisassembleAll) 1771 Disassemble = true; 1772 if (!Disassemble 1773 && !Relocations 1774 && !SectionHeaders 1775 && !SectionContents 1776 && !SymbolTable 1777 && !UnwindInfo 1778 && !PrivateHeaders 1779 && !FirstPrivateHeader 1780 && !ExportsTrie 1781 && !Rebase 1782 && !Bind 1783 && !LazyBind 1784 && !WeakBind 1785 && !RawClangAST 1786 && !(UniversalHeaders && MachOOpt) 1787 && !(ArchiveHeaders && MachOOpt) 1788 && !(IndirectSymbols && MachOOpt) 1789 && !(DataInCode && MachOOpt) 1790 && !(LinkOptHints && MachOOpt) 1791 && !(InfoPlist && MachOOpt) 1792 && !(DylibsUsed && MachOOpt) 1793 && !(DylibId && MachOOpt) 1794 && !(ObjcMetaData && MachOOpt) 1795 && !(FilterSections.size() != 0 && MachOOpt) 1796 && !PrintFaultMaps 1797 && DwarfDumpType == DIDT_Null) { 1798 cl::PrintHelpMessage(); 1799 return 2; 1800 } 1801 1802 std::for_each(InputFilenames.begin(), InputFilenames.end(), 1803 DumpInput); 1804 1805 return EXIT_SUCCESS; 1806} 1807