1 //===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This program is a utility that works like binutils "objdump", that is, it 10 // dumps out a plethora of information about an object file depending on the 11 // flags. 12 // 13 // The flags and output of this program should be near identical to those of 14 // binutils objdump. 15 // 16 //===----------------------------------------------------------------------===// 17 18 #include "llvm-objdump.h" 19 #include "COFFDump.h" 20 #include "ELFDump.h" 21 #include "MachODump.h" 22 #include "WasmDump.h" 23 #include "XCOFFDump.h" 24 #include "llvm/ADT/IndexedMap.h" 25 #include "llvm/ADT/Optional.h" 26 #include "llvm/ADT/SmallSet.h" 27 #include "llvm/ADT/STLExtras.h" 28 #include "llvm/ADT/SetOperations.h" 29 #include "llvm/ADT/StringExtras.h" 30 #include "llvm/ADT/StringSet.h" 31 #include "llvm/ADT/Triple.h" 32 #include "llvm/CodeGen/FaultMaps.h" 33 #include "llvm/DebugInfo/DWARF/DWARFContext.h" 34 #include "llvm/DebugInfo/Symbolize/Symbolize.h" 35 #include "llvm/Demangle/Demangle.h" 36 #include "llvm/MC/MCAsmInfo.h" 37 #include "llvm/MC/MCContext.h" 38 #include "llvm/MC/MCDisassembler/MCDisassembler.h" 39 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h" 40 #include "llvm/MC/MCInst.h" 41 #include "llvm/MC/MCInstPrinter.h" 42 #include "llvm/MC/MCInstrAnalysis.h" 43 #include "llvm/MC/MCInstrInfo.h" 44 #include "llvm/MC/MCObjectFileInfo.h" 45 #include "llvm/MC/MCRegisterInfo.h" 46 #include "llvm/MC/MCSubtargetInfo.h" 47 #include "llvm/MC/MCTargetOptions.h" 48 #include "llvm/Object/Archive.h" 49 #include "llvm/Object/COFF.h" 50 #include "llvm/Object/COFFImportFile.h" 51 #include "llvm/Object/ELFObjectFile.h" 52 #include "llvm/Object/MachO.h" 53 #include "llvm/Object/MachOUniversal.h" 54 #include "llvm/Object/ObjectFile.h" 55 #include "llvm/Object/Wasm.h" 56 #include "llvm/Support/Casting.h" 57 #include "llvm/Support/CommandLine.h" 58 #include "llvm/Support/Debug.h" 59 #include "llvm/Support/Errc.h" 60 #include "llvm/Support/FileSystem.h" 61 #include "llvm/Support/Format.h" 62 #include "llvm/Support/FormatVariadic.h" 63 #include "llvm/Support/GraphWriter.h" 64 #include "llvm/Support/Host.h" 65 #include "llvm/Support/InitLLVM.h" 66 #include "llvm/Support/MemoryBuffer.h" 67 #include "llvm/Support/SourceMgr.h" 68 #include "llvm/Support/StringSaver.h" 69 #include "llvm/Support/TargetRegistry.h" 70 #include "llvm/Support/TargetSelect.h" 71 #include "llvm/Support/WithColor.h" 72 #include "llvm/Support/raw_ostream.h" 73 #include <algorithm> 74 #include <cctype> 75 #include <cstring> 76 #include <system_error> 77 #include <unordered_map> 78 #include <utility> 79 80 using namespace llvm; 81 using namespace llvm::object; 82 using namespace llvm::objdump; 83 84 #define DEBUG_TYPE "objdump" 85 86 static cl::OptionCategory ObjdumpCat("llvm-objdump Options"); 87 88 static cl::opt<uint64_t> AdjustVMA( 89 "adjust-vma", 90 cl::desc("Increase the displayed address by the specified offset"), 91 cl::value_desc("offset"), cl::init(0), cl::cat(ObjdumpCat)); 92 93 static cl::opt<bool> 94 AllHeaders("all-headers", 95 cl::desc("Display all available header information"), 96 cl::cat(ObjdumpCat)); 97 static cl::alias AllHeadersShort("x", cl::desc("Alias for --all-headers"), 98 cl::NotHidden, cl::Grouping, 99 cl::aliasopt(AllHeaders)); 100 101 static cl::opt<std::string> 102 ArchName("arch-name", 103 cl::desc("Target arch to disassemble for, " 104 "see -version for available targets"), 105 cl::cat(ObjdumpCat)); 106 107 cl::opt<bool> 108 objdump::ArchiveHeaders("archive-headers", 109 cl::desc("Display archive header information"), 110 cl::cat(ObjdumpCat)); 111 static cl::alias ArchiveHeadersShort("a", 112 cl::desc("Alias for --archive-headers"), 113 cl::NotHidden, cl::Grouping, 114 cl::aliasopt(ArchiveHeaders)); 115 116 cl::opt<bool> objdump::Demangle("demangle", cl::desc("Demangle symbols names"), 117 cl::init(false), cl::cat(ObjdumpCat)); 118 static cl::alias DemangleShort("C", cl::desc("Alias for --demangle"), 119 cl::NotHidden, cl::Grouping, 120 cl::aliasopt(Demangle)); 121 122 cl::opt<bool> objdump::Disassemble( 123 "disassemble", 124 cl::desc("Display assembler mnemonics for the machine instructions"), 125 cl::cat(ObjdumpCat)); 126 static cl::alias DisassembleShort("d", cl::desc("Alias for --disassemble"), 127 cl::NotHidden, cl::Grouping, 128 cl::aliasopt(Disassemble)); 129 130 cl::opt<bool> objdump::DisassembleAll( 131 "disassemble-all", 132 cl::desc("Display assembler mnemonics for the machine instructions"), 133 cl::cat(ObjdumpCat)); 134 static cl::alias DisassembleAllShort("D", 135 cl::desc("Alias for --disassemble-all"), 136 cl::NotHidden, cl::Grouping, 137 cl::aliasopt(DisassembleAll)); 138 139 cl::opt<bool> objdump::SymbolDescription( 140 "symbol-description", 141 cl::desc("Add symbol description for disassembly. This " 142 "option is for XCOFF files only"), 143 cl::init(false), cl::cat(ObjdumpCat)); 144 145 static cl::list<std::string> 146 DisassembleSymbols("disassemble-symbols", cl::CommaSeparated, 147 cl::desc("List of symbols to disassemble. " 148 "Accept demangled names when --demangle is " 149 "specified, otherwise accept mangled names"), 150 cl::cat(ObjdumpCat)); 151 152 static cl::opt<bool> DisassembleZeroes( 153 "disassemble-zeroes", 154 cl::desc("Do not skip blocks of zeroes when disassembling"), 155 cl::cat(ObjdumpCat)); 156 static cl::alias 157 DisassembleZeroesShort("z", cl::desc("Alias for --disassemble-zeroes"), 158 cl::NotHidden, cl::Grouping, 159 cl::aliasopt(DisassembleZeroes)); 160 161 static cl::list<std::string> 162 DisassemblerOptions("disassembler-options", 163 cl::desc("Pass target specific disassembler options"), 164 cl::value_desc("options"), cl::CommaSeparated, 165 cl::cat(ObjdumpCat)); 166 static cl::alias 167 DisassemblerOptionsShort("M", cl::desc("Alias for --disassembler-options"), 168 cl::NotHidden, cl::Grouping, cl::Prefix, 169 cl::CommaSeparated, 170 cl::aliasopt(DisassemblerOptions)); 171 172 cl::opt<DIDumpType> objdump::DwarfDumpType( 173 "dwarf", cl::init(DIDT_Null), cl::desc("Dump of dwarf debug sections:"), 174 cl::values(clEnumValN(DIDT_DebugFrame, "frames", ".debug_frame")), 175 cl::cat(ObjdumpCat)); 176 177 static cl::opt<bool> DynamicRelocations( 178 "dynamic-reloc", 179 cl::desc("Display the dynamic relocation entries in the file"), 180 cl::cat(ObjdumpCat)); 181 static cl::alias DynamicRelocationShort("R", 182 cl::desc("Alias for --dynamic-reloc"), 183 cl::NotHidden, cl::Grouping, 184 cl::aliasopt(DynamicRelocations)); 185 186 static cl::opt<bool> 187 FaultMapSection("fault-map-section", 188 cl::desc("Display contents of faultmap section"), 189 cl::cat(ObjdumpCat)); 190 191 static cl::opt<bool> 192 FileHeaders("file-headers", 193 cl::desc("Display the contents of the overall file header"), 194 cl::cat(ObjdumpCat)); 195 static cl::alias FileHeadersShort("f", cl::desc("Alias for --file-headers"), 196 cl::NotHidden, cl::Grouping, 197 cl::aliasopt(FileHeaders)); 198 199 cl::opt<bool> 200 objdump::SectionContents("full-contents", 201 cl::desc("Display the content of each section"), 202 cl::cat(ObjdumpCat)); 203 static cl::alias SectionContentsShort("s", 204 cl::desc("Alias for --full-contents"), 205 cl::NotHidden, cl::Grouping, 206 cl::aliasopt(SectionContents)); 207 208 static cl::list<std::string> InputFilenames(cl::Positional, 209 cl::desc("<input object files>"), 210 cl::ZeroOrMore, 211 cl::cat(ObjdumpCat)); 212 213 static cl::opt<bool> 214 PrintLines("line-numbers", 215 cl::desc("Display source line numbers with " 216 "disassembly. Implies disassemble object"), 217 cl::cat(ObjdumpCat)); 218 static cl::alias PrintLinesShort("l", cl::desc("Alias for --line-numbers"), 219 cl::NotHidden, cl::Grouping, 220 cl::aliasopt(PrintLines)); 221 222 static cl::opt<bool> MachOOpt("macho", 223 cl::desc("Use MachO specific object file parser"), 224 cl::cat(ObjdumpCat)); 225 static cl::alias MachOm("m", cl::desc("Alias for --macho"), cl::NotHidden, 226 cl::Grouping, cl::aliasopt(MachOOpt)); 227 228 cl::opt<std::string> objdump::MCPU( 229 "mcpu", cl::desc("Target a specific cpu type (--mcpu=help for details)"), 230 cl::value_desc("cpu-name"), cl::init(""), cl::cat(ObjdumpCat)); 231 232 cl::list<std::string> objdump::MAttrs( 233 "mattr", cl::CommaSeparated, 234 cl::desc("Target specific attributes (--mattr=help for details)"), 235 cl::value_desc("a1,+a2,-a3,..."), cl::cat(ObjdumpCat)); 236 237 cl::opt<bool> objdump::NoShowRawInsn( 238 "no-show-raw-insn", 239 cl::desc( 240 "When disassembling instructions, do not print the instruction bytes."), 241 cl::cat(ObjdumpCat)); 242 243 cl::opt<bool> objdump::NoLeadingAddr("no-leading-addr", 244 cl::desc("Print no leading address"), 245 cl::cat(ObjdumpCat)); 246 247 static cl::opt<bool> RawClangAST( 248 "raw-clang-ast", 249 cl::desc("Dump the raw binary contents of the clang AST section"), 250 cl::cat(ObjdumpCat)); 251 252 cl::opt<bool> 253 objdump::Relocations("reloc", 254 cl::desc("Display the relocation entries in the file"), 255 cl::cat(ObjdumpCat)); 256 static cl::alias RelocationsShort("r", cl::desc("Alias for --reloc"), 257 cl::NotHidden, cl::Grouping, 258 cl::aliasopt(Relocations)); 259 260 cl::opt<bool> 261 objdump::PrintImmHex("print-imm-hex", 262 cl::desc("Use hex format for immediate values"), 263 cl::cat(ObjdumpCat)); 264 265 cl::opt<bool> 266 objdump::PrivateHeaders("private-headers", 267 cl::desc("Display format specific file headers"), 268 cl::cat(ObjdumpCat)); 269 static cl::alias PrivateHeadersShort("p", 270 cl::desc("Alias for --private-headers"), 271 cl::NotHidden, cl::Grouping, 272 cl::aliasopt(PrivateHeaders)); 273 274 cl::list<std::string> 275 objdump::FilterSections("section", 276 cl::desc("Operate on the specified sections only. " 277 "With -macho dump segment,section"), 278 cl::cat(ObjdumpCat)); 279 static cl::alias FilterSectionsj("j", cl::desc("Alias for --section"), 280 cl::NotHidden, cl::Grouping, cl::Prefix, 281 cl::aliasopt(FilterSections)); 282 283 cl::opt<bool> objdump::SectionHeaders( 284 "section-headers", 285 cl::desc("Display summaries of the headers for each section."), 286 cl::cat(ObjdumpCat)); 287 static cl::alias SectionHeadersShort("headers", 288 cl::desc("Alias for --section-headers"), 289 cl::NotHidden, 290 cl::aliasopt(SectionHeaders)); 291 static cl::alias SectionHeadersShorter("h", 292 cl::desc("Alias for --section-headers"), 293 cl::NotHidden, cl::Grouping, 294 cl::aliasopt(SectionHeaders)); 295 296 static cl::opt<bool> 297 ShowLMA("show-lma", 298 cl::desc("Display LMA column when dumping ELF section headers"), 299 cl::cat(ObjdumpCat)); 300 301 static cl::opt<bool> PrintSource( 302 "source", 303 cl::desc( 304 "Display source inlined with disassembly. Implies disassemble object"), 305 cl::cat(ObjdumpCat)); 306 static cl::alias PrintSourceShort("S", cl::desc("Alias for -source"), 307 cl::NotHidden, cl::Grouping, 308 cl::aliasopt(PrintSource)); 309 310 static cl::opt<uint64_t> 311 StartAddress("start-address", cl::desc("Disassemble beginning at address"), 312 cl::value_desc("address"), cl::init(0), cl::cat(ObjdumpCat)); 313 static cl::opt<uint64_t> StopAddress("stop-address", 314 cl::desc("Stop disassembly at address"), 315 cl::value_desc("address"), 316 cl::init(UINT64_MAX), cl::cat(ObjdumpCat)); 317 318 cl::opt<bool> objdump::SymbolTable("syms", cl::desc("Display the symbol table"), 319 cl::cat(ObjdumpCat)); 320 static cl::alias SymbolTableShort("t", cl::desc("Alias for --syms"), 321 cl::NotHidden, cl::Grouping, 322 cl::aliasopt(SymbolTable)); 323 324 static cl::opt<bool> SymbolizeOperands( 325 "symbolize-operands", 326 cl::desc("Symbolize instruction operands when disassembling"), 327 cl::cat(ObjdumpCat)); 328 329 static cl::opt<bool> DynamicSymbolTable( 330 "dynamic-syms", 331 cl::desc("Display the contents of the dynamic symbol table"), 332 cl::cat(ObjdumpCat)); 333 static cl::alias DynamicSymbolTableShort("T", 334 cl::desc("Alias for --dynamic-syms"), 335 cl::NotHidden, cl::Grouping, 336 cl::aliasopt(DynamicSymbolTable)); 337 338 cl::opt<std::string> objdump::TripleName( 339 "triple", 340 cl::desc( 341 "Target triple to disassemble for, see -version for available targets"), 342 cl::cat(ObjdumpCat)); 343 344 cl::opt<bool> objdump::UnwindInfo("unwind-info", 345 cl::desc("Display unwind information"), 346 cl::cat(ObjdumpCat)); 347 static cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind-info"), 348 cl::NotHidden, cl::Grouping, 349 cl::aliasopt(UnwindInfo)); 350 351 static cl::opt<bool> 352 Wide("wide", cl::desc("Ignored for compatibility with GNU objdump"), 353 cl::cat(ObjdumpCat)); 354 static cl::alias WideShort("w", cl::Grouping, cl::aliasopt(Wide)); 355 356 cl::opt<std::string> objdump::Prefix("prefix", 357 cl::desc("Add prefix to absolute paths"), 358 cl::cat(ObjdumpCat)); 359 360 enum DebugVarsFormat { 361 DVDisabled, 362 DVUnicode, 363 DVASCII, 364 }; 365 366 static cl::opt<DebugVarsFormat> DbgVariables( 367 "debug-vars", cl::init(DVDisabled), 368 cl::desc("Print the locations (in registers or memory) of " 369 "source-level variables alongside disassembly"), 370 cl::ValueOptional, 371 cl::values(clEnumValN(DVUnicode, "", "unicode"), 372 clEnumValN(DVUnicode, "unicode", "unicode"), 373 clEnumValN(DVASCII, "ascii", "unicode")), 374 cl::cat(ObjdumpCat)); 375 376 static cl::opt<int> 377 DbgIndent("debug-vars-indent", cl::init(40), 378 cl::desc("Distance to indent the source-level variable display, " 379 "relative to the start of the disassembly"), 380 cl::cat(ObjdumpCat)); 381 382 static cl::extrahelp 383 HelpResponse("\nPass @FILE as argument to read options from FILE.\n"); 384 385 static StringSet<> DisasmSymbolSet; 386 StringSet<> objdump::FoundSectionSet; 387 static StringRef ToolName; 388 389 namespace { 390 struct FilterResult { 391 // True if the section should not be skipped. 392 bool Keep; 393 394 // True if the index counter should be incremented, even if the section should 395 // be skipped. For example, sections may be skipped if they are not included 396 // in the --section flag, but we still want those to count toward the section 397 // count. 398 bool IncrementIndex; 399 }; 400 } // namespace 401 402 static FilterResult checkSectionFilter(object::SectionRef S) { 403 if (FilterSections.empty()) 404 return {/*Keep=*/true, /*IncrementIndex=*/true}; 405 406 Expected<StringRef> SecNameOrErr = S.getName(); 407 if (!SecNameOrErr) { 408 consumeError(SecNameOrErr.takeError()); 409 return {/*Keep=*/false, /*IncrementIndex=*/false}; 410 } 411 StringRef SecName = *SecNameOrErr; 412 413 // StringSet does not allow empty key so avoid adding sections with 414 // no name (such as the section with index 0) here. 415 if (!SecName.empty()) 416 FoundSectionSet.insert(SecName); 417 418 // Only show the section if it's in the FilterSections list, but always 419 // increment so the indexing is stable. 420 return {/*Keep=*/is_contained(FilterSections, SecName), 421 /*IncrementIndex=*/true}; 422 } 423 424 SectionFilter objdump::ToolSectionFilter(object::ObjectFile const &O, 425 uint64_t *Idx) { 426 // Start at UINT64_MAX so that the first index returned after an increment is 427 // zero (after the unsigned wrap). 428 if (Idx) 429 *Idx = UINT64_MAX; 430 return SectionFilter( 431 [Idx](object::SectionRef S) { 432 FilterResult Result = checkSectionFilter(S); 433 if (Idx != nullptr && Result.IncrementIndex) 434 *Idx += 1; 435 return Result.Keep; 436 }, 437 O); 438 } 439 440 std::string objdump::getFileNameForError(const object::Archive::Child &C, 441 unsigned Index) { 442 Expected<StringRef> NameOrErr = C.getName(); 443 if (NameOrErr) 444 return std::string(NameOrErr.get()); 445 // If we have an error getting the name then we print the index of the archive 446 // member. Since we are already in an error state, we just ignore this error. 447 consumeError(NameOrErr.takeError()); 448 return "<file index: " + std::to_string(Index) + ">"; 449 } 450 451 void objdump::reportWarning(Twine Message, StringRef File) { 452 // Output order between errs() and outs() matters especially for archive 453 // files where the output is per member object. 454 outs().flush(); 455 WithColor::warning(errs(), ToolName) 456 << "'" << File << "': " << Message << "\n"; 457 } 458 459 LLVM_ATTRIBUTE_NORETURN void objdump::reportError(StringRef File, 460 Twine Message) { 461 outs().flush(); 462 WithColor::error(errs(), ToolName) << "'" << File << "': " << Message << "\n"; 463 exit(1); 464 } 465 466 LLVM_ATTRIBUTE_NORETURN void objdump::reportError(Error E, StringRef FileName, 467 StringRef ArchiveName, 468 StringRef ArchitectureName) { 469 assert(E); 470 outs().flush(); 471 WithColor::error(errs(), ToolName); 472 if (ArchiveName != "") 473 errs() << ArchiveName << "(" << FileName << ")"; 474 else 475 errs() << "'" << FileName << "'"; 476 if (!ArchitectureName.empty()) 477 errs() << " (for architecture " << ArchitectureName << ")"; 478 errs() << ": "; 479 logAllUnhandledErrors(std::move(E), errs()); 480 exit(1); 481 } 482 483 static void reportCmdLineWarning(Twine Message) { 484 WithColor::warning(errs(), ToolName) << Message << "\n"; 485 } 486 487 LLVM_ATTRIBUTE_NORETURN static void reportCmdLineError(Twine Message) { 488 WithColor::error(errs(), ToolName) << Message << "\n"; 489 exit(1); 490 } 491 492 static void warnOnNoMatchForSections() { 493 SetVector<StringRef> MissingSections; 494 for (StringRef S : FilterSections) { 495 if (FoundSectionSet.count(S)) 496 return; 497 // User may specify a unnamed section. Don't warn for it. 498 if (!S.empty()) 499 MissingSections.insert(S); 500 } 501 502 // Warn only if no section in FilterSections is matched. 503 for (StringRef S : MissingSections) 504 reportCmdLineWarning("section '" + S + 505 "' mentioned in a -j/--section option, but not " 506 "found in any input file"); 507 } 508 509 static const Target *getTarget(const ObjectFile *Obj) { 510 // Figure out the target triple. 511 Triple TheTriple("unknown-unknown-unknown"); 512 if (TripleName.empty()) { 513 TheTriple = Obj->makeTriple(); 514 } else { 515 TheTriple.setTriple(Triple::normalize(TripleName)); 516 auto Arch = Obj->getArch(); 517 if (Arch == Triple::arm || Arch == Triple::armeb) 518 Obj->setARMSubArch(TheTriple); 519 } 520 521 // Get the target specific parser. 522 std::string Error; 523 const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple, 524 Error); 525 if (!TheTarget) 526 reportError(Obj->getFileName(), "can't find target: " + Error); 527 528 // Update the triple name and return the found target. 529 TripleName = TheTriple.getTriple(); 530 return TheTarget; 531 } 532 533 bool objdump::isRelocAddressLess(RelocationRef A, RelocationRef B) { 534 return A.getOffset() < B.getOffset(); 535 } 536 537 static Error getRelocationValueString(const RelocationRef &Rel, 538 SmallVectorImpl<char> &Result) { 539 const ObjectFile *Obj = Rel.getObject(); 540 if (auto *ELF = dyn_cast<ELFObjectFileBase>(Obj)) 541 return getELFRelocationValueString(ELF, Rel, Result); 542 if (auto *COFF = dyn_cast<COFFObjectFile>(Obj)) 543 return getCOFFRelocationValueString(COFF, Rel, Result); 544 if (auto *Wasm = dyn_cast<WasmObjectFile>(Obj)) 545 return getWasmRelocationValueString(Wasm, Rel, Result); 546 if (auto *MachO = dyn_cast<MachOObjectFile>(Obj)) 547 return getMachORelocationValueString(MachO, Rel, Result); 548 if (auto *XCOFF = dyn_cast<XCOFFObjectFile>(Obj)) 549 return getXCOFFRelocationValueString(XCOFF, Rel, Result); 550 llvm_unreachable("unknown object file format"); 551 } 552 553 /// Indicates whether this relocation should hidden when listing 554 /// relocations, usually because it is the trailing part of a multipart 555 /// relocation that will be printed as part of the leading relocation. 556 static bool getHidden(RelocationRef RelRef) { 557 auto *MachO = dyn_cast<MachOObjectFile>(RelRef.getObject()); 558 if (!MachO) 559 return false; 560 561 unsigned Arch = MachO->getArch(); 562 DataRefImpl Rel = RelRef.getRawDataRefImpl(); 563 uint64_t Type = MachO->getRelocationType(Rel); 564 565 // On arches that use the generic relocations, GENERIC_RELOC_PAIR 566 // is always hidden. 567 if (Arch == Triple::x86 || Arch == Triple::arm || Arch == Triple::ppc) 568 return Type == MachO::GENERIC_RELOC_PAIR; 569 570 if (Arch == Triple::x86_64) { 571 // On x86_64, X86_64_RELOC_UNSIGNED is hidden only when it follows 572 // an X86_64_RELOC_SUBTRACTOR. 573 if (Type == MachO::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) { 574 DataRefImpl RelPrev = Rel; 575 RelPrev.d.a--; 576 uint64_t PrevType = MachO->getRelocationType(RelPrev); 577 if (PrevType == MachO::X86_64_RELOC_SUBTRACTOR) 578 return true; 579 } 580 } 581 582 return false; 583 } 584 585 namespace { 586 587 /// Get the column at which we want to start printing the instruction 588 /// disassembly, taking into account anything which appears to the left of it. 589 unsigned getInstStartColumn(const MCSubtargetInfo &STI) { 590 return NoShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24; 591 } 592 593 /// Stores a single expression representing the location of a source-level 594 /// variable, along with the PC range for which that expression is valid. 595 struct LiveVariable { 596 DWARFLocationExpression LocExpr; 597 const char *VarName; 598 DWARFUnit *Unit; 599 const DWARFDie FuncDie; 600 601 LiveVariable(const DWARFLocationExpression &LocExpr, const char *VarName, 602 DWARFUnit *Unit, const DWARFDie FuncDie) 603 : LocExpr(LocExpr), VarName(VarName), Unit(Unit), FuncDie(FuncDie) {} 604 605 bool liveAtAddress(object::SectionedAddress Addr) { 606 if (LocExpr.Range == None) 607 return false; 608 return LocExpr.Range->SectionIndex == Addr.SectionIndex && 609 LocExpr.Range->LowPC <= Addr.Address && 610 LocExpr.Range->HighPC > Addr.Address; 611 } 612 613 void print(raw_ostream &OS, const MCRegisterInfo &MRI) const { 614 DataExtractor Data({LocExpr.Expr.data(), LocExpr.Expr.size()}, 615 Unit->getContext().isLittleEndian(), 0); 616 DWARFExpression Expression(Data, Unit->getAddressByteSize()); 617 Expression.printCompact(OS, MRI); 618 } 619 }; 620 621 /// Helper class for printing source variable locations alongside disassembly. 622 class LiveVariablePrinter { 623 // Information we want to track about one column in which we are printing a 624 // variable live range. 625 struct Column { 626 unsigned VarIdx = NullVarIdx; 627 bool LiveIn = false; 628 bool LiveOut = false; 629 bool MustDrawLabel = false; 630 631 bool isActive() const { return VarIdx != NullVarIdx; } 632 633 static constexpr unsigned NullVarIdx = std::numeric_limits<unsigned>::max(); 634 }; 635 636 // All live variables we know about in the object/image file. 637 std::vector<LiveVariable> LiveVariables; 638 639 // The columns we are currently drawing. 640 IndexedMap<Column> ActiveCols; 641 642 const MCRegisterInfo &MRI; 643 const MCSubtargetInfo &STI; 644 645 void addVariable(DWARFDie FuncDie, DWARFDie VarDie) { 646 uint64_t FuncLowPC, FuncHighPC, SectionIndex; 647 FuncDie.getLowAndHighPC(FuncLowPC, FuncHighPC, SectionIndex); 648 const char *VarName = VarDie.getName(DINameKind::ShortName); 649 DWARFUnit *U = VarDie.getDwarfUnit(); 650 651 Expected<DWARFLocationExpressionsVector> Locs = 652 VarDie.getLocations(dwarf::DW_AT_location); 653 if (!Locs) { 654 // If the variable doesn't have any locations, just ignore it. We don't 655 // report an error or warning here as that could be noisy on optimised 656 // code. 657 consumeError(Locs.takeError()); 658 return; 659 } 660 661 for (const DWARFLocationExpression &LocExpr : *Locs) { 662 if (LocExpr.Range) { 663 LiveVariables.emplace_back(LocExpr, VarName, U, FuncDie); 664 } else { 665 // If the LocExpr does not have an associated range, it is valid for 666 // the whole of the function. 667 // TODO: technically it is not valid for any range covered by another 668 // LocExpr, does that happen in reality? 669 DWARFLocationExpression WholeFuncExpr{ 670 DWARFAddressRange(FuncLowPC, FuncHighPC, SectionIndex), 671 LocExpr.Expr}; 672 LiveVariables.emplace_back(WholeFuncExpr, VarName, U, FuncDie); 673 } 674 } 675 } 676 677 void addFunction(DWARFDie D) { 678 for (const DWARFDie &Child : D.children()) { 679 if (Child.getTag() == dwarf::DW_TAG_variable || 680 Child.getTag() == dwarf::DW_TAG_formal_parameter) 681 addVariable(D, Child); 682 else 683 addFunction(Child); 684 } 685 } 686 687 // Get the column number (in characters) at which the first live variable 688 // line should be printed. 689 unsigned getIndentLevel() const { 690 return DbgIndent + getInstStartColumn(STI); 691 } 692 693 // Indent to the first live-range column to the right of the currently 694 // printed line, and return the index of that column. 695 // TODO: formatted_raw_ostream uses "column" to mean a number of characters 696 // since the last \n, and we use it to mean the number of slots in which we 697 // put live variable lines. Pick a less overloaded word. 698 unsigned moveToFirstVarColumn(formatted_raw_ostream &OS) { 699 // Logical column number: column zero is the first column we print in, each 700 // logical column is 2 physical columns wide. 701 unsigned FirstUnprintedLogicalColumn = 702 std::max((int)(OS.getColumn() - getIndentLevel() + 1) / 2, 0); 703 // Physical column number: the actual column number in characters, with 704 // zero being the left-most side of the screen. 705 unsigned FirstUnprintedPhysicalColumn = 706 getIndentLevel() + FirstUnprintedLogicalColumn * 2; 707 708 if (FirstUnprintedPhysicalColumn > OS.getColumn()) 709 OS.PadToColumn(FirstUnprintedPhysicalColumn); 710 711 return FirstUnprintedLogicalColumn; 712 } 713 714 unsigned findFreeColumn() { 715 for (unsigned ColIdx = 0; ColIdx < ActiveCols.size(); ++ColIdx) 716 if (!ActiveCols[ColIdx].isActive()) 717 return ColIdx; 718 719 size_t OldSize = ActiveCols.size(); 720 ActiveCols.grow(std::max<size_t>(OldSize * 2, 1)); 721 return OldSize; 722 } 723 724 public: 725 LiveVariablePrinter(const MCRegisterInfo &MRI, const MCSubtargetInfo &STI) 726 : LiveVariables(), ActiveCols(Column()), MRI(MRI), STI(STI) {} 727 728 void dump() const { 729 for (const LiveVariable &LV : LiveVariables) { 730 dbgs() << LV.VarName << " @ " << LV.LocExpr.Range << ": "; 731 LV.print(dbgs(), MRI); 732 dbgs() << "\n"; 733 } 734 } 735 736 void addCompileUnit(DWARFDie D) { 737 if (D.getTag() == dwarf::DW_TAG_subprogram) 738 addFunction(D); 739 else 740 for (const DWARFDie &Child : D.children()) 741 addFunction(Child); 742 } 743 744 /// Update to match the state of the instruction between ThisAddr and 745 /// NextAddr. In the common case, any live range active at ThisAddr is 746 /// live-in to the instruction, and any live range active at NextAddr is 747 /// live-out of the instruction. If IncludeDefinedVars is false, then live 748 /// ranges starting at NextAddr will be ignored. 749 void update(object::SectionedAddress ThisAddr, 750 object::SectionedAddress NextAddr, bool IncludeDefinedVars) { 751 // First, check variables which have already been assigned a column, so 752 // that we don't change their order. 753 SmallSet<unsigned, 8> CheckedVarIdxs; 754 for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) { 755 if (!ActiveCols[ColIdx].isActive()) 756 continue; 757 CheckedVarIdxs.insert(ActiveCols[ColIdx].VarIdx); 758 LiveVariable &LV = LiveVariables[ActiveCols[ColIdx].VarIdx]; 759 ActiveCols[ColIdx].LiveIn = LV.liveAtAddress(ThisAddr); 760 ActiveCols[ColIdx].LiveOut = LV.liveAtAddress(NextAddr); 761 LLVM_DEBUG(dbgs() << "pass 1, " << ThisAddr.Address << "-" 762 << NextAddr.Address << ", " << LV.VarName << ", Col " 763 << ColIdx << ": LiveIn=" << ActiveCols[ColIdx].LiveIn 764 << ", LiveOut=" << ActiveCols[ColIdx].LiveOut << "\n"); 765 766 if (!ActiveCols[ColIdx].LiveIn && !ActiveCols[ColIdx].LiveOut) 767 ActiveCols[ColIdx].VarIdx = Column::NullVarIdx; 768 } 769 770 // Next, look for variables which don't already have a column, but which 771 // are now live. 772 if (IncludeDefinedVars) { 773 for (unsigned VarIdx = 0, End = LiveVariables.size(); VarIdx < End; 774 ++VarIdx) { 775 if (CheckedVarIdxs.count(VarIdx)) 776 continue; 777 LiveVariable &LV = LiveVariables[VarIdx]; 778 bool LiveIn = LV.liveAtAddress(ThisAddr); 779 bool LiveOut = LV.liveAtAddress(NextAddr); 780 if (!LiveIn && !LiveOut) 781 continue; 782 783 unsigned ColIdx = findFreeColumn(); 784 LLVM_DEBUG(dbgs() << "pass 2, " << ThisAddr.Address << "-" 785 << NextAddr.Address << ", " << LV.VarName << ", Col " 786 << ColIdx << ": LiveIn=" << LiveIn 787 << ", LiveOut=" << LiveOut << "\n"); 788 ActiveCols[ColIdx].VarIdx = VarIdx; 789 ActiveCols[ColIdx].LiveIn = LiveIn; 790 ActiveCols[ColIdx].LiveOut = LiveOut; 791 ActiveCols[ColIdx].MustDrawLabel = true; 792 } 793 } 794 } 795 796 enum class LineChar { 797 RangeStart, 798 RangeMid, 799 RangeEnd, 800 LabelVert, 801 LabelCornerNew, 802 LabelCornerActive, 803 LabelHoriz, 804 }; 805 const char *getLineChar(LineChar C) const { 806 bool IsASCII = DbgVariables == DVASCII; 807 switch (C) { 808 case LineChar::RangeStart: 809 return IsASCII ? "^" : u8"\u2548"; 810 case LineChar::RangeMid: 811 return IsASCII ? "|" : u8"\u2503"; 812 case LineChar::RangeEnd: 813 return IsASCII ? "v" : u8"\u253b"; 814 case LineChar::LabelVert: 815 return IsASCII ? "|" : u8"\u2502"; 816 case LineChar::LabelCornerNew: 817 return IsASCII ? "/" : u8"\u250c"; 818 case LineChar::LabelCornerActive: 819 return IsASCII ? "|" : u8"\u2520"; 820 case LineChar::LabelHoriz: 821 return IsASCII ? "-" : u8"\u2500"; 822 } 823 llvm_unreachable("Unhandled LineChar enum"); 824 } 825 826 /// Print live ranges to the right of an existing line. This assumes the 827 /// line is not an instruction, so doesn't start or end any live ranges, so 828 /// we only need to print active ranges or empty columns. If AfterInst is 829 /// true, this is being printed after the last instruction fed to update(), 830 /// otherwise this is being printed before it. 831 void printAfterOtherLine(formatted_raw_ostream &OS, bool AfterInst) { 832 if (ActiveCols.size()) { 833 unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS); 834 for (size_t ColIdx = FirstUnprintedColumn, End = ActiveCols.size(); 835 ColIdx < End; ++ColIdx) { 836 if (ActiveCols[ColIdx].isActive()) { 837 if ((AfterInst && ActiveCols[ColIdx].LiveOut) || 838 (!AfterInst && ActiveCols[ColIdx].LiveIn)) 839 OS << getLineChar(LineChar::RangeMid); 840 else if (!AfterInst && ActiveCols[ColIdx].LiveOut) 841 OS << getLineChar(LineChar::LabelVert); 842 else 843 OS << " "; 844 } 845 OS << " "; 846 } 847 } 848 OS << "\n"; 849 } 850 851 /// Print any live variable range info needed to the right of a 852 /// non-instruction line of disassembly. This is where we print the variable 853 /// names and expressions, with thin line-drawing characters connecting them 854 /// to the live range which starts at the next instruction. If MustPrint is 855 /// true, we have to print at least one line (with the continuation of any 856 /// already-active live ranges) because something has already been printed 857 /// earlier on this line. 858 void printBetweenInsts(formatted_raw_ostream &OS, bool MustPrint) { 859 bool PrintedSomething = false; 860 for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) { 861 if (ActiveCols[ColIdx].isActive() && ActiveCols[ColIdx].MustDrawLabel) { 862 // First we need to print the live range markers for any active 863 // columns to the left of this one. 864 OS.PadToColumn(getIndentLevel()); 865 for (unsigned ColIdx2 = 0; ColIdx2 < ColIdx; ++ColIdx2) { 866 if (ActiveCols[ColIdx2].isActive()) { 867 if (ActiveCols[ColIdx2].MustDrawLabel && 868 !ActiveCols[ColIdx2].LiveIn) 869 OS << getLineChar(LineChar::LabelVert) << " "; 870 else 871 OS << getLineChar(LineChar::RangeMid) << " "; 872 } else 873 OS << " "; 874 } 875 876 // Then print the variable name and location of the new live range, 877 // with box drawing characters joining it to the live range line. 878 OS << getLineChar(ActiveCols[ColIdx].LiveIn 879 ? LineChar::LabelCornerActive 880 : LineChar::LabelCornerNew) 881 << getLineChar(LineChar::LabelHoriz) << " "; 882 WithColor(OS, raw_ostream::GREEN) 883 << LiveVariables[ActiveCols[ColIdx].VarIdx].VarName; 884 OS << " = "; 885 { 886 WithColor ExprColor(OS, raw_ostream::CYAN); 887 LiveVariables[ActiveCols[ColIdx].VarIdx].print(OS, MRI); 888 } 889 890 // If there are any columns to the right of the expression we just 891 // printed, then continue their live range lines. 892 unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS); 893 for (unsigned ColIdx2 = FirstUnprintedColumn, End = ActiveCols.size(); 894 ColIdx2 < End; ++ColIdx2) { 895 if (ActiveCols[ColIdx2].isActive() && ActiveCols[ColIdx2].LiveIn) 896 OS << getLineChar(LineChar::RangeMid) << " "; 897 else 898 OS << " "; 899 } 900 901 OS << "\n"; 902 PrintedSomething = true; 903 } 904 } 905 906 for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) 907 if (ActiveCols[ColIdx].isActive()) 908 ActiveCols[ColIdx].MustDrawLabel = false; 909 910 // If we must print something (because we printed a line/column number), 911 // but don't have any new variables to print, then print a line which 912 // just continues any existing live ranges. 913 if (MustPrint && !PrintedSomething) 914 printAfterOtherLine(OS, false); 915 } 916 917 /// Print the live variable ranges to the right of a disassembled instruction. 918 void printAfterInst(formatted_raw_ostream &OS) { 919 if (!ActiveCols.size()) 920 return; 921 unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS); 922 for (unsigned ColIdx = FirstUnprintedColumn, End = ActiveCols.size(); 923 ColIdx < End; ++ColIdx) { 924 if (!ActiveCols[ColIdx].isActive()) 925 OS << " "; 926 else if (ActiveCols[ColIdx].LiveIn && ActiveCols[ColIdx].LiveOut) 927 OS << getLineChar(LineChar::RangeMid) << " "; 928 else if (ActiveCols[ColIdx].LiveOut) 929 OS << getLineChar(LineChar::RangeStart) << " "; 930 else if (ActiveCols[ColIdx].LiveIn) 931 OS << getLineChar(LineChar::RangeEnd) << " "; 932 else 933 llvm_unreachable("var must be live in or out!"); 934 } 935 } 936 }; 937 938 class SourcePrinter { 939 protected: 940 DILineInfo OldLineInfo; 941 const ObjectFile *Obj = nullptr; 942 std::unique_ptr<symbolize::LLVMSymbolizer> Symbolizer; 943 // File name to file contents of source. 944 std::unordered_map<std::string, std::unique_ptr<MemoryBuffer>> SourceCache; 945 // Mark the line endings of the cached source. 946 std::unordered_map<std::string, std::vector<StringRef>> LineCache; 947 // Keep track of missing sources. 948 StringSet<> MissingSources; 949 // Only emit 'no debug info' warning once. 950 bool WarnedNoDebugInfo; 951 952 private: 953 bool cacheSource(const DILineInfo& LineInfoFile); 954 955 void printLines(formatted_raw_ostream &OS, const DILineInfo &LineInfo, 956 StringRef Delimiter, LiveVariablePrinter &LVP); 957 958 void printSources(formatted_raw_ostream &OS, const DILineInfo &LineInfo, 959 StringRef ObjectFilename, StringRef Delimiter, 960 LiveVariablePrinter &LVP); 961 962 public: 963 SourcePrinter() = default; 964 SourcePrinter(const ObjectFile *Obj, StringRef DefaultArch) 965 : Obj(Obj), WarnedNoDebugInfo(false) { 966 symbolize::LLVMSymbolizer::Options SymbolizerOpts; 967 SymbolizerOpts.PrintFunctions = 968 DILineInfoSpecifier::FunctionNameKind::LinkageName; 969 SymbolizerOpts.Demangle = Demangle; 970 SymbolizerOpts.DefaultArch = std::string(DefaultArch); 971 Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts)); 972 } 973 virtual ~SourcePrinter() = default; 974 virtual void printSourceLine(formatted_raw_ostream &OS, 975 object::SectionedAddress Address, 976 StringRef ObjectFilename, 977 LiveVariablePrinter &LVP, 978 StringRef Delimiter = "; "); 979 }; 980 981 bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) { 982 std::unique_ptr<MemoryBuffer> Buffer; 983 if (LineInfo.Source) { 984 Buffer = MemoryBuffer::getMemBuffer(*LineInfo.Source); 985 } else { 986 auto BufferOrError = MemoryBuffer::getFile(LineInfo.FileName); 987 if (!BufferOrError) { 988 if (MissingSources.insert(LineInfo.FileName).second) 989 reportWarning("failed to find source " + LineInfo.FileName, 990 Obj->getFileName()); 991 return false; 992 } 993 Buffer = std::move(*BufferOrError); 994 } 995 // Chomp the file to get lines 996 const char *BufferStart = Buffer->getBufferStart(), 997 *BufferEnd = Buffer->getBufferEnd(); 998 std::vector<StringRef> &Lines = LineCache[LineInfo.FileName]; 999 const char *Start = BufferStart; 1000 for (const char *I = BufferStart; I != BufferEnd; ++I) 1001 if (*I == '\n') { 1002 Lines.emplace_back(Start, I - Start - (BufferStart < I && I[-1] == '\r')); 1003 Start = I + 1; 1004 } 1005 if (Start < BufferEnd) 1006 Lines.emplace_back(Start, BufferEnd - Start); 1007 SourceCache[LineInfo.FileName] = std::move(Buffer); 1008 return true; 1009 } 1010 1011 void SourcePrinter::printSourceLine(formatted_raw_ostream &OS, 1012 object::SectionedAddress Address, 1013 StringRef ObjectFilename, 1014 LiveVariablePrinter &LVP, 1015 StringRef Delimiter) { 1016 if (!Symbolizer) 1017 return; 1018 1019 DILineInfo LineInfo = DILineInfo(); 1020 auto ExpectedLineInfo = Symbolizer->symbolizeCode(*Obj, Address); 1021 std::string ErrorMessage; 1022 if (!ExpectedLineInfo) 1023 ErrorMessage = toString(ExpectedLineInfo.takeError()); 1024 else 1025 LineInfo = *ExpectedLineInfo; 1026 1027 if (LineInfo.FileName == DILineInfo::BadString) { 1028 if (!WarnedNoDebugInfo) { 1029 std::string Warning = 1030 "failed to parse debug information for " + ObjectFilename.str(); 1031 if (!ErrorMessage.empty()) 1032 Warning += ": " + ErrorMessage; 1033 reportWarning(Warning, ObjectFilename); 1034 WarnedNoDebugInfo = true; 1035 } 1036 } 1037 1038 if (!Prefix.empty() && sys::path::is_absolute_gnu(LineInfo.FileName)) { 1039 SmallString<128> FilePath; 1040 sys::path::append(FilePath, Prefix, LineInfo.FileName); 1041 1042 LineInfo.FileName = std::string(FilePath); 1043 } 1044 1045 if (PrintLines) 1046 printLines(OS, LineInfo, Delimiter, LVP); 1047 if (PrintSource) 1048 printSources(OS, LineInfo, ObjectFilename, Delimiter, LVP); 1049 OldLineInfo = LineInfo; 1050 } 1051 1052 void SourcePrinter::printLines(formatted_raw_ostream &OS, 1053 const DILineInfo &LineInfo, StringRef Delimiter, 1054 LiveVariablePrinter &LVP) { 1055 bool PrintFunctionName = LineInfo.FunctionName != DILineInfo::BadString && 1056 LineInfo.FunctionName != OldLineInfo.FunctionName; 1057 if (PrintFunctionName) { 1058 OS << Delimiter << LineInfo.FunctionName; 1059 // If demangling is successful, FunctionName will end with "()". Print it 1060 // only if demangling did not run or was unsuccessful. 1061 if (!StringRef(LineInfo.FunctionName).endswith("()")) 1062 OS << "()"; 1063 OS << ":\n"; 1064 } 1065 if (LineInfo.FileName != DILineInfo::BadString && LineInfo.Line != 0 && 1066 (OldLineInfo.Line != LineInfo.Line || 1067 OldLineInfo.FileName != LineInfo.FileName || PrintFunctionName)) { 1068 OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line; 1069 LVP.printBetweenInsts(OS, true); 1070 } 1071 } 1072 1073 void SourcePrinter::printSources(formatted_raw_ostream &OS, 1074 const DILineInfo &LineInfo, 1075 StringRef ObjectFilename, StringRef Delimiter, 1076 LiveVariablePrinter &LVP) { 1077 if (LineInfo.FileName == DILineInfo::BadString || LineInfo.Line == 0 || 1078 (OldLineInfo.Line == LineInfo.Line && 1079 OldLineInfo.FileName == LineInfo.FileName)) 1080 return; 1081 1082 if (SourceCache.find(LineInfo.FileName) == SourceCache.end()) 1083 if (!cacheSource(LineInfo)) 1084 return; 1085 auto LineBuffer = LineCache.find(LineInfo.FileName); 1086 if (LineBuffer != LineCache.end()) { 1087 if (LineInfo.Line > LineBuffer->second.size()) { 1088 reportWarning( 1089 formatv( 1090 "debug info line number {0} exceeds the number of lines in {1}", 1091 LineInfo.Line, LineInfo.FileName), 1092 ObjectFilename); 1093 return; 1094 } 1095 // Vector begins at 0, line numbers are non-zero 1096 OS << Delimiter << LineBuffer->second[LineInfo.Line - 1]; 1097 LVP.printBetweenInsts(OS, true); 1098 } 1099 } 1100 1101 static bool isAArch64Elf(const ObjectFile *Obj) { 1102 const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj); 1103 return Elf && Elf->getEMachine() == ELF::EM_AARCH64; 1104 } 1105 1106 static bool isArmElf(const ObjectFile *Obj) { 1107 const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj); 1108 return Elf && Elf->getEMachine() == ELF::EM_ARM; 1109 } 1110 1111 static bool hasMappingSymbols(const ObjectFile *Obj) { 1112 return isArmElf(Obj) || isAArch64Elf(Obj); 1113 } 1114 1115 static void printRelocation(formatted_raw_ostream &OS, StringRef FileName, 1116 const RelocationRef &Rel, uint64_t Address, 1117 bool Is64Bits) { 1118 StringRef Fmt = Is64Bits ? "\t\t%016" PRIx64 ": " : "\t\t\t%08" PRIx64 ": "; 1119 SmallString<16> Name; 1120 SmallString<32> Val; 1121 Rel.getTypeName(Name); 1122 if (Error E = getRelocationValueString(Rel, Val)) 1123 reportError(std::move(E), FileName); 1124 OS << format(Fmt.data(), Address) << Name << "\t" << Val; 1125 } 1126 1127 class PrettyPrinter { 1128 public: 1129 virtual ~PrettyPrinter() = default; 1130 virtual void 1131 printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes, 1132 object::SectionedAddress Address, formatted_raw_ostream &OS, 1133 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP, 1134 StringRef ObjectFilename, std::vector<RelocationRef> *Rels, 1135 LiveVariablePrinter &LVP) { 1136 if (SP && (PrintSource || PrintLines)) 1137 SP->printSourceLine(OS, Address, ObjectFilename, LVP); 1138 LVP.printBetweenInsts(OS, false); 1139 1140 size_t Start = OS.tell(); 1141 if (!NoLeadingAddr) 1142 OS << format("%8" PRIx64 ":", Address.Address); 1143 if (!NoShowRawInsn) { 1144 OS << ' '; 1145 dumpBytes(Bytes, OS); 1146 } 1147 1148 // The output of printInst starts with a tab. Print some spaces so that 1149 // the tab has 1 column and advances to the target tab stop. 1150 unsigned TabStop = getInstStartColumn(STI); 1151 unsigned Column = OS.tell() - Start; 1152 OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8); 1153 1154 if (MI) { 1155 // See MCInstPrinter::printInst. On targets where a PC relative immediate 1156 // is relative to the next instruction and the length of a MCInst is 1157 // difficult to measure (x86), this is the address of the next 1158 // instruction. 1159 uint64_t Addr = 1160 Address.Address + (STI.getTargetTriple().isX86() ? Bytes.size() : 0); 1161 IP.printInst(MI, Addr, "", STI, OS); 1162 } else 1163 OS << "\t<unknown>"; 1164 } 1165 }; 1166 PrettyPrinter PrettyPrinterInst; 1167 1168 class HexagonPrettyPrinter : public PrettyPrinter { 1169 public: 1170 void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address, 1171 formatted_raw_ostream &OS) { 1172 uint32_t opcode = 1173 (Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | Bytes[0]; 1174 if (!NoLeadingAddr) 1175 OS << format("%8" PRIx64 ":", Address); 1176 if (!NoShowRawInsn) { 1177 OS << "\t"; 1178 dumpBytes(Bytes.slice(0, 4), OS); 1179 OS << format("\t%08" PRIx32, opcode); 1180 } 1181 } 1182 void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes, 1183 object::SectionedAddress Address, formatted_raw_ostream &OS, 1184 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP, 1185 StringRef ObjectFilename, std::vector<RelocationRef> *Rels, 1186 LiveVariablePrinter &LVP) override { 1187 if (SP && (PrintSource || PrintLines)) 1188 SP->printSourceLine(OS, Address, ObjectFilename, LVP, ""); 1189 if (!MI) { 1190 printLead(Bytes, Address.Address, OS); 1191 OS << " <unknown>"; 1192 return; 1193 } 1194 std::string Buffer; 1195 { 1196 raw_string_ostream TempStream(Buffer); 1197 IP.printInst(MI, Address.Address, "", STI, TempStream); 1198 } 1199 StringRef Contents(Buffer); 1200 // Split off bundle attributes 1201 auto PacketBundle = Contents.rsplit('\n'); 1202 // Split off first instruction from the rest 1203 auto HeadTail = PacketBundle.first.split('\n'); 1204 auto Preamble = " { "; 1205 auto Separator = ""; 1206 1207 // Hexagon's packets require relocations to be inline rather than 1208 // clustered at the end of the packet. 1209 std::vector<RelocationRef>::const_iterator RelCur = Rels->begin(); 1210 std::vector<RelocationRef>::const_iterator RelEnd = Rels->end(); 1211 auto PrintReloc = [&]() -> void { 1212 while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address.Address)) { 1213 if (RelCur->getOffset() == Address.Address) { 1214 printRelocation(OS, ObjectFilename, *RelCur, Address.Address, false); 1215 return; 1216 } 1217 ++RelCur; 1218 } 1219 }; 1220 1221 while (!HeadTail.first.empty()) { 1222 OS << Separator; 1223 Separator = "\n"; 1224 if (SP && (PrintSource || PrintLines)) 1225 SP->printSourceLine(OS, Address, ObjectFilename, LVP, ""); 1226 printLead(Bytes, Address.Address, OS); 1227 OS << Preamble; 1228 Preamble = " "; 1229 StringRef Inst; 1230 auto Duplex = HeadTail.first.split('\v'); 1231 if (!Duplex.second.empty()) { 1232 OS << Duplex.first; 1233 OS << "; "; 1234 Inst = Duplex.second; 1235 } 1236 else 1237 Inst = HeadTail.first; 1238 OS << Inst; 1239 HeadTail = HeadTail.second.split('\n'); 1240 if (HeadTail.first.empty()) 1241 OS << " } " << PacketBundle.second; 1242 PrintReloc(); 1243 Bytes = Bytes.slice(4); 1244 Address.Address += 4; 1245 } 1246 } 1247 }; 1248 HexagonPrettyPrinter HexagonPrettyPrinterInst; 1249 1250 class AMDGCNPrettyPrinter : public PrettyPrinter { 1251 public: 1252 void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes, 1253 object::SectionedAddress Address, formatted_raw_ostream &OS, 1254 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP, 1255 StringRef ObjectFilename, std::vector<RelocationRef> *Rels, 1256 LiveVariablePrinter &LVP) override { 1257 if (SP && (PrintSource || PrintLines)) 1258 SP->printSourceLine(OS, Address, ObjectFilename, LVP); 1259 1260 if (MI) { 1261 SmallString<40> InstStr; 1262 raw_svector_ostream IS(InstStr); 1263 1264 IP.printInst(MI, Address.Address, "", STI, IS); 1265 1266 OS << left_justify(IS.str(), 60); 1267 } else { 1268 // an unrecognized encoding - this is probably data so represent it 1269 // using the .long directive, or .byte directive if fewer than 4 bytes 1270 // remaining 1271 if (Bytes.size() >= 4) { 1272 OS << format("\t.long 0x%08" PRIx32 " ", 1273 support::endian::read32<support::little>(Bytes.data())); 1274 OS.indent(42); 1275 } else { 1276 OS << format("\t.byte 0x%02" PRIx8, Bytes[0]); 1277 for (unsigned int i = 1; i < Bytes.size(); i++) 1278 OS << format(", 0x%02" PRIx8, Bytes[i]); 1279 OS.indent(55 - (6 * Bytes.size())); 1280 } 1281 } 1282 1283 OS << format("// %012" PRIX64 ":", Address.Address); 1284 if (Bytes.size() >= 4) { 1285 // D should be casted to uint32_t here as it is passed by format to 1286 // snprintf as vararg. 1287 for (uint32_t D : makeArrayRef( 1288 reinterpret_cast<const support::little32_t *>(Bytes.data()), 1289 Bytes.size() / 4)) 1290 OS << format(" %08" PRIX32, D); 1291 } else { 1292 for (unsigned char B : Bytes) 1293 OS << format(" %02" PRIX8, B); 1294 } 1295 1296 if (!Annot.empty()) 1297 OS << " // " << Annot; 1298 } 1299 }; 1300 AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst; 1301 1302 class BPFPrettyPrinter : public PrettyPrinter { 1303 public: 1304 void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes, 1305 object::SectionedAddress Address, formatted_raw_ostream &OS, 1306 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP, 1307 StringRef ObjectFilename, std::vector<RelocationRef> *Rels, 1308 LiveVariablePrinter &LVP) override { 1309 if (SP && (PrintSource || PrintLines)) 1310 SP->printSourceLine(OS, Address, ObjectFilename, LVP); 1311 if (!NoLeadingAddr) 1312 OS << format("%8" PRId64 ":", Address.Address / 8); 1313 if (!NoShowRawInsn) { 1314 OS << "\t"; 1315 dumpBytes(Bytes, OS); 1316 } 1317 if (MI) 1318 IP.printInst(MI, Address.Address, "", STI, OS); 1319 else 1320 OS << "\t<unknown>"; 1321 } 1322 }; 1323 BPFPrettyPrinter BPFPrettyPrinterInst; 1324 1325 PrettyPrinter &selectPrettyPrinter(Triple const &Triple) { 1326 switch(Triple.getArch()) { 1327 default: 1328 return PrettyPrinterInst; 1329 case Triple::hexagon: 1330 return HexagonPrettyPrinterInst; 1331 case Triple::amdgcn: 1332 return AMDGCNPrettyPrinterInst; 1333 case Triple::bpfel: 1334 case Triple::bpfeb: 1335 return BPFPrettyPrinterInst; 1336 } 1337 } 1338 } 1339 1340 static uint8_t getElfSymbolType(const ObjectFile *Obj, const SymbolRef &Sym) { 1341 assert(Obj->isELF()); 1342 if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(Obj)) 1343 return Elf32LEObj->getSymbol(Sym.getRawDataRefImpl())->getType(); 1344 if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(Obj)) 1345 return Elf64LEObj->getSymbol(Sym.getRawDataRefImpl())->getType(); 1346 if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(Obj)) 1347 return Elf32BEObj->getSymbol(Sym.getRawDataRefImpl())->getType(); 1348 if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(Obj)) 1349 return Elf64BEObj->getSymbol(Sym.getRawDataRefImpl())->getType(); 1350 llvm_unreachable("Unsupported binary format"); 1351 } 1352 1353 template <class ELFT> static void 1354 addDynamicElfSymbols(const ELFObjectFile<ELFT> *Obj, 1355 std::map<SectionRef, SectionSymbolsTy> &AllSymbols) { 1356 for (auto Symbol : Obj->getDynamicSymbolIterators()) { 1357 uint8_t SymbolType = Symbol.getELFType(); 1358 if (SymbolType == ELF::STT_SECTION) 1359 continue; 1360 1361 uint64_t Address = unwrapOrError(Symbol.getAddress(), Obj->getFileName()); 1362 // ELFSymbolRef::getAddress() returns size instead of value for common 1363 // symbols which is not desirable for disassembly output. Overriding. 1364 if (SymbolType == ELF::STT_COMMON) 1365 Address = Obj->getSymbol(Symbol.getRawDataRefImpl())->st_value; 1366 1367 StringRef Name = unwrapOrError(Symbol.getName(), Obj->getFileName()); 1368 if (Name.empty()) 1369 continue; 1370 1371 section_iterator SecI = 1372 unwrapOrError(Symbol.getSection(), Obj->getFileName()); 1373 if (SecI == Obj->section_end()) 1374 continue; 1375 1376 AllSymbols[*SecI].emplace_back(Address, Name, SymbolType); 1377 } 1378 } 1379 1380 static void 1381 addDynamicElfSymbols(const ObjectFile *Obj, 1382 std::map<SectionRef, SectionSymbolsTy> &AllSymbols) { 1383 assert(Obj->isELF()); 1384 if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(Obj)) 1385 addDynamicElfSymbols(Elf32LEObj, AllSymbols); 1386 else if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(Obj)) 1387 addDynamicElfSymbols(Elf64LEObj, AllSymbols); 1388 else if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(Obj)) 1389 addDynamicElfSymbols(Elf32BEObj, AllSymbols); 1390 else if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(Obj)) 1391 addDynamicElfSymbols(Elf64BEObj, AllSymbols); 1392 else 1393 llvm_unreachable("Unsupported binary format"); 1394 } 1395 1396 static void addPltEntries(const ObjectFile *Obj, 1397 std::map<SectionRef, SectionSymbolsTy> &AllSymbols, 1398 StringSaver &Saver) { 1399 Optional<SectionRef> Plt = None; 1400 for (const SectionRef &Section : Obj->sections()) { 1401 Expected<StringRef> SecNameOrErr = Section.getName(); 1402 if (!SecNameOrErr) { 1403 consumeError(SecNameOrErr.takeError()); 1404 continue; 1405 } 1406 if (*SecNameOrErr == ".plt") 1407 Plt = Section; 1408 } 1409 if (!Plt) 1410 return; 1411 if (auto *ElfObj = dyn_cast<ELFObjectFileBase>(Obj)) { 1412 for (auto PltEntry : ElfObj->getPltAddresses()) { 1413 if (PltEntry.first) { 1414 SymbolRef Symbol(*PltEntry.first, ElfObj); 1415 uint8_t SymbolType = getElfSymbolType(Obj, Symbol); 1416 if (Expected<StringRef> NameOrErr = Symbol.getName()) { 1417 if (!NameOrErr->empty()) 1418 AllSymbols[*Plt].emplace_back( 1419 PltEntry.second, Saver.save((*NameOrErr + "@plt").str()), 1420 SymbolType); 1421 continue; 1422 } else { 1423 // The warning has been reported in disassembleObject(). 1424 consumeError(NameOrErr.takeError()); 1425 } 1426 } 1427 reportWarning("PLT entry at 0x" + Twine::utohexstr(PltEntry.second) + 1428 " references an invalid symbol", 1429 Obj->getFileName()); 1430 } 1431 } 1432 } 1433 1434 // Normally the disassembly output will skip blocks of zeroes. This function 1435 // returns the number of zero bytes that can be skipped when dumping the 1436 // disassembly of the instructions in Buf. 1437 static size_t countSkippableZeroBytes(ArrayRef<uint8_t> Buf) { 1438 // Find the number of leading zeroes. 1439 size_t N = 0; 1440 while (N < Buf.size() && !Buf[N]) 1441 ++N; 1442 1443 // We may want to skip blocks of zero bytes, but unless we see 1444 // at least 8 of them in a row. 1445 if (N < 8) 1446 return 0; 1447 1448 // We skip zeroes in multiples of 4 because do not want to truncate an 1449 // instruction if it starts with a zero byte. 1450 return N & ~0x3; 1451 } 1452 1453 // Returns a map from sections to their relocations. 1454 static std::map<SectionRef, std::vector<RelocationRef>> 1455 getRelocsMap(object::ObjectFile const &Obj) { 1456 std::map<SectionRef, std::vector<RelocationRef>> Ret; 1457 uint64_t I = (uint64_t)-1; 1458 for (SectionRef Sec : Obj.sections()) { 1459 ++I; 1460 Expected<section_iterator> RelocatedOrErr = Sec.getRelocatedSection(); 1461 if (!RelocatedOrErr) 1462 reportError(Obj.getFileName(), 1463 "section (" + Twine(I) + 1464 "): failed to get a relocated section: " + 1465 toString(RelocatedOrErr.takeError())); 1466 1467 section_iterator Relocated = *RelocatedOrErr; 1468 if (Relocated == Obj.section_end() || !checkSectionFilter(*Relocated).Keep) 1469 continue; 1470 std::vector<RelocationRef> &V = Ret[*Relocated]; 1471 for (const RelocationRef &R : Sec.relocations()) 1472 V.push_back(R); 1473 // Sort relocations by address. 1474 llvm::stable_sort(V, isRelocAddressLess); 1475 } 1476 return Ret; 1477 } 1478 1479 // Used for --adjust-vma to check if address should be adjusted by the 1480 // specified value for a given section. 1481 // For ELF we do not adjust non-allocatable sections like debug ones, 1482 // because they are not loadable. 1483 // TODO: implement for other file formats. 1484 static bool shouldAdjustVA(const SectionRef &Section) { 1485 const ObjectFile *Obj = Section.getObject(); 1486 if (Obj->isELF()) 1487 return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC; 1488 return false; 1489 } 1490 1491 1492 typedef std::pair<uint64_t, char> MappingSymbolPair; 1493 static char getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols, 1494 uint64_t Address) { 1495 auto It = 1496 partition_point(MappingSymbols, [Address](const MappingSymbolPair &Val) { 1497 return Val.first <= Address; 1498 }); 1499 // Return zero for any address before the first mapping symbol; this means 1500 // we should use the default disassembly mode, depending on the target. 1501 if (It == MappingSymbols.begin()) 1502 return '\x00'; 1503 return (It - 1)->second; 1504 } 1505 1506 static uint64_t dumpARMELFData(uint64_t SectionAddr, uint64_t Index, 1507 uint64_t End, const ObjectFile *Obj, 1508 ArrayRef<uint8_t> Bytes, 1509 ArrayRef<MappingSymbolPair> MappingSymbols, 1510 raw_ostream &OS) { 1511 support::endianness Endian = 1512 Obj->isLittleEndian() ? support::little : support::big; 1513 OS << format("%8" PRIx64 ":\t", SectionAddr + Index); 1514 if (Index + 4 <= End) { 1515 dumpBytes(Bytes.slice(Index, 4), OS); 1516 OS << "\t.word\t" 1517 << format_hex(support::endian::read32(Bytes.data() + Index, Endian), 1518 10); 1519 return 4; 1520 } 1521 if (Index + 2 <= End) { 1522 dumpBytes(Bytes.slice(Index, 2), OS); 1523 OS << "\t\t.short\t" 1524 << format_hex(support::endian::read16(Bytes.data() + Index, Endian), 1525 6); 1526 return 2; 1527 } 1528 dumpBytes(Bytes.slice(Index, 1), OS); 1529 OS << "\t\t.byte\t" << format_hex(Bytes[0], 4); 1530 return 1; 1531 } 1532 1533 static void dumpELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End, 1534 ArrayRef<uint8_t> Bytes) { 1535 // print out data up to 8 bytes at a time in hex and ascii 1536 uint8_t AsciiData[9] = {'\0'}; 1537 uint8_t Byte; 1538 int NumBytes = 0; 1539 1540 for (; Index < End; ++Index) { 1541 if (NumBytes == 0) 1542 outs() << format("%8" PRIx64 ":", SectionAddr + Index); 1543 Byte = Bytes.slice(Index)[0]; 1544 outs() << format(" %02x", Byte); 1545 AsciiData[NumBytes] = isPrint(Byte) ? Byte : '.'; 1546 1547 uint8_t IndentOffset = 0; 1548 NumBytes++; 1549 if (Index == End - 1 || NumBytes > 8) { 1550 // Indent the space for less than 8 bytes data. 1551 // 2 spaces for byte and one for space between bytes 1552 IndentOffset = 3 * (8 - NumBytes); 1553 for (int Excess = NumBytes; Excess < 8; Excess++) 1554 AsciiData[Excess] = '\0'; 1555 NumBytes = 8; 1556 } 1557 if (NumBytes == 8) { 1558 AsciiData[8] = '\0'; 1559 outs() << std::string(IndentOffset, ' ') << " "; 1560 outs() << reinterpret_cast<char *>(AsciiData); 1561 outs() << '\n'; 1562 NumBytes = 0; 1563 } 1564 } 1565 } 1566 1567 SymbolInfoTy objdump::createSymbolInfo(const ObjectFile *Obj, 1568 const SymbolRef &Symbol) { 1569 const StringRef FileName = Obj->getFileName(); 1570 const uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName); 1571 const StringRef Name = unwrapOrError(Symbol.getName(), FileName); 1572 1573 if (Obj->isXCOFF() && SymbolDescription) { 1574 const auto *XCOFFObj = cast<XCOFFObjectFile>(Obj); 1575 DataRefImpl SymbolDRI = Symbol.getRawDataRefImpl(); 1576 1577 const uint32_t SymbolIndex = XCOFFObj->getSymbolIndex(SymbolDRI.p); 1578 Optional<XCOFF::StorageMappingClass> Smc = 1579 getXCOFFSymbolCsectSMC(XCOFFObj, Symbol); 1580 return SymbolInfoTy(Addr, Name, Smc, SymbolIndex, 1581 isLabel(XCOFFObj, Symbol)); 1582 } else 1583 return SymbolInfoTy(Addr, Name, 1584 Obj->isELF() ? getElfSymbolType(Obj, Symbol) 1585 : (uint8_t)ELF::STT_NOTYPE); 1586 } 1587 1588 static SymbolInfoTy createDummySymbolInfo(const ObjectFile *Obj, 1589 const uint64_t Addr, StringRef &Name, 1590 uint8_t Type) { 1591 if (Obj->isXCOFF() && SymbolDescription) 1592 return SymbolInfoTy(Addr, Name, None, None, false); 1593 else 1594 return SymbolInfoTy(Addr, Name, Type); 1595 } 1596 1597 static void 1598 collectLocalBranchTargets(ArrayRef<uint8_t> Bytes, const MCInstrAnalysis *MIA, 1599 MCDisassembler *DisAsm, MCInstPrinter *IP, 1600 const MCSubtargetInfo *STI, uint64_t SectionAddr, 1601 uint64_t Start, uint64_t End, 1602 std::unordered_map<uint64_t, std::string> &Labels) { 1603 // So far only supports X86. 1604 if (!STI->getTargetTriple().isX86()) 1605 return; 1606 1607 Labels.clear(); 1608 unsigned LabelCount = 0; 1609 Start += SectionAddr; 1610 End += SectionAddr; 1611 uint64_t Index = Start; 1612 while (Index < End) { 1613 // Disassemble a real instruction and record function-local branch labels. 1614 MCInst Inst; 1615 uint64_t Size; 1616 bool Disassembled = DisAsm->getInstruction( 1617 Inst, Size, Bytes.slice(Index - SectionAddr), Index, nulls()); 1618 if (Size == 0) 1619 Size = 1; 1620 1621 if (Disassembled && MIA) { 1622 uint64_t Target; 1623 bool TargetKnown = MIA->evaluateBranch(Inst, Index, Size, Target); 1624 if (TargetKnown && (Target >= Start && Target < End) && 1625 !Labels.count(Target)) 1626 Labels[Target] = ("L" + Twine(LabelCount++)).str(); 1627 } 1628 1629 Index += Size; 1630 } 1631 } 1632 1633 static StringRef getSegmentName(const MachOObjectFile *MachO, 1634 const SectionRef &Section) { 1635 if (MachO) { 1636 DataRefImpl DR = Section.getRawDataRefImpl(); 1637 StringRef SegmentName = MachO->getSectionFinalSegmentName(DR); 1638 return SegmentName; 1639 } 1640 return ""; 1641 } 1642 1643 static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, 1644 MCContext &Ctx, MCDisassembler *PrimaryDisAsm, 1645 MCDisassembler *SecondaryDisAsm, 1646 const MCInstrAnalysis *MIA, MCInstPrinter *IP, 1647 const MCSubtargetInfo *PrimarySTI, 1648 const MCSubtargetInfo *SecondarySTI, 1649 PrettyPrinter &PIP, 1650 SourcePrinter &SP, bool InlineRelocs) { 1651 const MCSubtargetInfo *STI = PrimarySTI; 1652 MCDisassembler *DisAsm = PrimaryDisAsm; 1653 bool PrimaryIsThumb = false; 1654 if (isArmElf(Obj)) 1655 PrimaryIsThumb = STI->checkFeatures("+thumb-mode"); 1656 1657 std::map<SectionRef, std::vector<RelocationRef>> RelocMap; 1658 if (InlineRelocs) 1659 RelocMap = getRelocsMap(*Obj); 1660 bool Is64Bits = Obj->getBytesInAddress() > 4; 1661 1662 // Create a mapping from virtual address to symbol name. This is used to 1663 // pretty print the symbols while disassembling. 1664 std::map<SectionRef, SectionSymbolsTy> AllSymbols; 1665 SectionSymbolsTy AbsoluteSymbols; 1666 const StringRef FileName = Obj->getFileName(); 1667 const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj); 1668 for (const SymbolRef &Symbol : Obj->symbols()) { 1669 Expected<StringRef> NameOrErr = Symbol.getName(); 1670 if (!NameOrErr) { 1671 reportWarning(toString(NameOrErr.takeError()), FileName); 1672 continue; 1673 } 1674 if (NameOrErr->empty() && !(Obj->isXCOFF() && SymbolDescription)) 1675 continue; 1676 1677 if (Obj->isELF() && getElfSymbolType(Obj, Symbol) == ELF::STT_SECTION) 1678 continue; 1679 1680 // Don't ask a Mach-O STAB symbol for its section unless you know that 1681 // STAB symbol's section field refers to a valid section index. Otherwise 1682 // the symbol may error trying to load a section that does not exist. 1683 if (MachO) { 1684 DataRefImpl SymDRI = Symbol.getRawDataRefImpl(); 1685 uint8_t NType = (MachO->is64Bit() ? 1686 MachO->getSymbol64TableEntry(SymDRI).n_type: 1687 MachO->getSymbolTableEntry(SymDRI).n_type); 1688 if (NType & MachO::N_STAB) 1689 continue; 1690 } 1691 1692 section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName); 1693 if (SecI != Obj->section_end()) 1694 AllSymbols[*SecI].push_back(createSymbolInfo(Obj, Symbol)); 1695 else 1696 AbsoluteSymbols.push_back(createSymbolInfo(Obj, Symbol)); 1697 } 1698 1699 if (AllSymbols.empty() && Obj->isELF()) 1700 addDynamicElfSymbols(Obj, AllSymbols); 1701 1702 BumpPtrAllocator A; 1703 StringSaver Saver(A); 1704 addPltEntries(Obj, AllSymbols, Saver); 1705 1706 // Create a mapping from virtual address to section. An empty section can 1707 // cause more than one section at the same address. Sort such sections to be 1708 // before same-addressed non-empty sections so that symbol lookups prefer the 1709 // non-empty section. 1710 std::vector<std::pair<uint64_t, SectionRef>> SectionAddresses; 1711 for (SectionRef Sec : Obj->sections()) 1712 SectionAddresses.emplace_back(Sec.getAddress(), Sec); 1713 llvm::stable_sort(SectionAddresses, [](const auto &LHS, const auto &RHS) { 1714 if (LHS.first != RHS.first) 1715 return LHS.first < RHS.first; 1716 return LHS.second.getSize() < RHS.second.getSize(); 1717 }); 1718 1719 // Linked executables (.exe and .dll files) typically don't include a real 1720 // symbol table but they might contain an export table. 1721 if (const auto *COFFObj = dyn_cast<COFFObjectFile>(Obj)) { 1722 for (const auto &ExportEntry : COFFObj->export_directories()) { 1723 StringRef Name; 1724 if (Error E = ExportEntry.getSymbolName(Name)) 1725 reportError(std::move(E), Obj->getFileName()); 1726 if (Name.empty()) 1727 continue; 1728 1729 uint32_t RVA; 1730 if (Error E = ExportEntry.getExportRVA(RVA)) 1731 reportError(std::move(E), Obj->getFileName()); 1732 1733 uint64_t VA = COFFObj->getImageBase() + RVA; 1734 auto Sec = partition_point( 1735 SectionAddresses, [VA](const std::pair<uint64_t, SectionRef> &O) { 1736 return O.first <= VA; 1737 }); 1738 if (Sec != SectionAddresses.begin()) { 1739 --Sec; 1740 AllSymbols[Sec->second].emplace_back(VA, Name, ELF::STT_NOTYPE); 1741 } else 1742 AbsoluteSymbols.emplace_back(VA, Name, ELF::STT_NOTYPE); 1743 } 1744 } 1745 1746 // Sort all the symbols, this allows us to use a simple binary search to find 1747 // Multiple symbols can have the same address. Use a stable sort to stabilize 1748 // the output. 1749 StringSet<> FoundDisasmSymbolSet; 1750 for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols) 1751 llvm::stable_sort(SecSyms.second); 1752 llvm::stable_sort(AbsoluteSymbols); 1753 1754 std::unique_ptr<DWARFContext> DICtx; 1755 LiveVariablePrinter LVP(*Ctx.getRegisterInfo(), *STI); 1756 1757 if (DbgVariables != DVDisabled) { 1758 DICtx = DWARFContext::create(*Obj); 1759 for (const std::unique_ptr<DWARFUnit> &CU : DICtx->compile_units()) 1760 LVP.addCompileUnit(CU->getUnitDIE(false)); 1761 } 1762 1763 LLVM_DEBUG(LVP.dump()); 1764 1765 for (const SectionRef &Section : ToolSectionFilter(*Obj)) { 1766 if (FilterSections.empty() && !DisassembleAll && 1767 (!Section.isText() || Section.isVirtual())) 1768 continue; 1769 1770 uint64_t SectionAddr = Section.getAddress(); 1771 uint64_t SectSize = Section.getSize(); 1772 if (!SectSize) 1773 continue; 1774 1775 // Get the list of all the symbols in this section. 1776 SectionSymbolsTy &Symbols = AllSymbols[Section]; 1777 std::vector<MappingSymbolPair> MappingSymbols; 1778 if (hasMappingSymbols(Obj)) { 1779 for (const auto &Symb : Symbols) { 1780 uint64_t Address = Symb.Addr; 1781 StringRef Name = Symb.Name; 1782 if (Name.startswith("$d")) 1783 MappingSymbols.emplace_back(Address - SectionAddr, 'd'); 1784 if (Name.startswith("$x")) 1785 MappingSymbols.emplace_back(Address - SectionAddr, 'x'); 1786 if (Name.startswith("$a")) 1787 MappingSymbols.emplace_back(Address - SectionAddr, 'a'); 1788 if (Name.startswith("$t")) 1789 MappingSymbols.emplace_back(Address - SectionAddr, 't'); 1790 } 1791 } 1792 1793 llvm::sort(MappingSymbols); 1794 1795 if (Obj->isELF() && Obj->getArch() == Triple::amdgcn) { 1796 // AMDGPU disassembler uses symbolizer for printing labels 1797 std::unique_ptr<MCRelocationInfo> RelInfo( 1798 TheTarget->createMCRelocationInfo(TripleName, Ctx)); 1799 if (RelInfo) { 1800 std::unique_ptr<MCSymbolizer> Symbolizer( 1801 TheTarget->createMCSymbolizer( 1802 TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo))); 1803 DisAsm->setSymbolizer(std::move(Symbolizer)); 1804 } 1805 } 1806 1807 StringRef SegmentName = getSegmentName(MachO, Section); 1808 StringRef SectionName = unwrapOrError(Section.getName(), Obj->getFileName()); 1809 // If the section has no symbol at the start, just insert a dummy one. 1810 if (Symbols.empty() || Symbols[0].Addr != 0) { 1811 Symbols.insert(Symbols.begin(), 1812 createDummySymbolInfo(Obj, SectionAddr, SectionName, 1813 Section.isText() ? ELF::STT_FUNC 1814 : ELF::STT_OBJECT)); 1815 } 1816 1817 SmallString<40> Comments; 1818 raw_svector_ostream CommentStream(Comments); 1819 1820 ArrayRef<uint8_t> Bytes = arrayRefFromStringRef( 1821 unwrapOrError(Section.getContents(), Obj->getFileName())); 1822 1823 uint64_t VMAAdjustment = 0; 1824 if (shouldAdjustVA(Section)) 1825 VMAAdjustment = AdjustVMA; 1826 1827 uint64_t Size; 1828 uint64_t Index; 1829 bool PrintedSection = false; 1830 std::vector<RelocationRef> Rels = RelocMap[Section]; 1831 std::vector<RelocationRef>::const_iterator RelCur = Rels.begin(); 1832 std::vector<RelocationRef>::const_iterator RelEnd = Rels.end(); 1833 // Disassemble symbol by symbol. 1834 for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) { 1835 std::string SymbolName = Symbols[SI].Name.str(); 1836 if (Demangle) 1837 SymbolName = demangle(SymbolName); 1838 1839 // Skip if --disassemble-symbols is not empty and the symbol is not in 1840 // the list. 1841 if (!DisasmSymbolSet.empty() && !DisasmSymbolSet.count(SymbolName)) 1842 continue; 1843 1844 uint64_t Start = Symbols[SI].Addr; 1845 if (Start < SectionAddr || StopAddress <= Start) 1846 continue; 1847 else 1848 FoundDisasmSymbolSet.insert(SymbolName); 1849 1850 // The end is the section end, the beginning of the next symbol, or 1851 // --stop-address. 1852 uint64_t End = std::min<uint64_t>(SectionAddr + SectSize, StopAddress); 1853 if (SI + 1 < SE) 1854 End = std::min(End, Symbols[SI + 1].Addr); 1855 if (Start >= End || End <= StartAddress) 1856 continue; 1857 Start -= SectionAddr; 1858 End -= SectionAddr; 1859 1860 if (!PrintedSection) { 1861 PrintedSection = true; 1862 outs() << "\nDisassembly of section "; 1863 if (!SegmentName.empty()) 1864 outs() << SegmentName << ","; 1865 outs() << SectionName << ":\n"; 1866 } 1867 1868 outs() << '\n'; 1869 if (!NoLeadingAddr) 1870 outs() << format(Is64Bits ? "%016" PRIx64 " " : "%08" PRIx64 " ", 1871 SectionAddr + Start + VMAAdjustment); 1872 if (Obj->isXCOFF() && SymbolDescription) { 1873 outs() << getXCOFFSymbolDescription(Symbols[SI], SymbolName) << ":\n"; 1874 } else 1875 outs() << '<' << SymbolName << ">:\n"; 1876 1877 // Don't print raw contents of a virtual section. A virtual section 1878 // doesn't have any contents in the file. 1879 if (Section.isVirtual()) { 1880 outs() << "...\n"; 1881 continue; 1882 } 1883 1884 auto Status = DisAsm->onSymbolStart(Symbols[SI], Size, 1885 Bytes.slice(Start, End - Start), 1886 SectionAddr + Start, CommentStream); 1887 // To have round trippable disassembly, we fall back to decoding the 1888 // remaining bytes as instructions. 1889 // 1890 // If there is a failure, we disassemble the failed region as bytes before 1891 // falling back. The target is expected to print nothing in this case. 1892 // 1893 // If there is Success or SoftFail i.e no 'real' failure, we go ahead by 1894 // Size bytes before falling back. 1895 // So if the entire symbol is 'eaten' by the target: 1896 // Start += Size // Now Start = End and we will never decode as 1897 // // instructions 1898 // 1899 // Right now, most targets return None i.e ignore to treat a symbol 1900 // separately. But WebAssembly decodes preludes for some symbols. 1901 // 1902 if (Status.hasValue()) { 1903 if (Status.getValue() == MCDisassembler::Fail) { 1904 outs() << "// Error in decoding " << SymbolName 1905 << " : Decoding failed region as bytes.\n"; 1906 for (uint64_t I = 0; I < Size; ++I) { 1907 outs() << "\t.byte\t " << format_hex(Bytes[I], 1, /*Upper=*/true) 1908 << "\n"; 1909 } 1910 } 1911 } else { 1912 Size = 0; 1913 } 1914 1915 Start += Size; 1916 1917 Index = Start; 1918 if (SectionAddr < StartAddress) 1919 Index = std::max<uint64_t>(Index, StartAddress - SectionAddr); 1920 1921 // If there is a data/common symbol inside an ELF text section and we are 1922 // only disassembling text (applicable all architectures), we are in a 1923 // situation where we must print the data and not disassemble it. 1924 if (Obj->isELF() && !DisassembleAll && Section.isText()) { 1925 uint8_t SymTy = Symbols[SI].Type; 1926 if (SymTy == ELF::STT_OBJECT || SymTy == ELF::STT_COMMON) { 1927 dumpELFData(SectionAddr, Index, End, Bytes); 1928 Index = End; 1929 } 1930 } 1931 1932 bool CheckARMELFData = hasMappingSymbols(Obj) && 1933 Symbols[SI].Type != ELF::STT_OBJECT && 1934 !DisassembleAll; 1935 bool DumpARMELFData = false; 1936 formatted_raw_ostream FOS(outs()); 1937 1938 std::unordered_map<uint64_t, std::string> AllLabels; 1939 if (SymbolizeOperands) 1940 collectLocalBranchTargets(Bytes, MIA, DisAsm, IP, PrimarySTI, 1941 SectionAddr, Index, End, AllLabels); 1942 1943 while (Index < End) { 1944 // ARM and AArch64 ELF binaries can interleave data and text in the 1945 // same section. We rely on the markers introduced to understand what 1946 // we need to dump. If the data marker is within a function, it is 1947 // denoted as a word/short etc. 1948 if (CheckARMELFData) { 1949 char Kind = getMappingSymbolKind(MappingSymbols, Index); 1950 DumpARMELFData = Kind == 'd'; 1951 if (SecondarySTI) { 1952 if (Kind == 'a') { 1953 STI = PrimaryIsThumb ? SecondarySTI : PrimarySTI; 1954 DisAsm = PrimaryIsThumb ? SecondaryDisAsm : PrimaryDisAsm; 1955 } else if (Kind == 't') { 1956 STI = PrimaryIsThumb ? PrimarySTI : SecondarySTI; 1957 DisAsm = PrimaryIsThumb ? PrimaryDisAsm : SecondaryDisAsm; 1958 } 1959 } 1960 } 1961 1962 if (DumpARMELFData) { 1963 Size = dumpARMELFData(SectionAddr, Index, End, Obj, Bytes, 1964 MappingSymbols, FOS); 1965 } else { 1966 // When -z or --disassemble-zeroes are given we always dissasemble 1967 // them. Otherwise we might want to skip zero bytes we see. 1968 if (!DisassembleZeroes) { 1969 uint64_t MaxOffset = End - Index; 1970 // For --reloc: print zero blocks patched by relocations, so that 1971 // relocations can be shown in the dump. 1972 if (RelCur != RelEnd) 1973 MaxOffset = RelCur->getOffset() - Index; 1974 1975 if (size_t N = 1976 countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) { 1977 FOS << "\t\t..." << '\n'; 1978 Index += N; 1979 continue; 1980 } 1981 } 1982 1983 // Print local label if there's any. 1984 auto Iter = AllLabels.find(SectionAddr + Index); 1985 if (Iter != AllLabels.end()) 1986 FOS << "<" << Iter->second << ">:\n"; 1987 1988 // Disassemble a real instruction or a data when disassemble all is 1989 // provided 1990 MCInst Inst; 1991 bool Disassembled = 1992 DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), 1993 SectionAddr + Index, CommentStream); 1994 if (Size == 0) 1995 Size = 1; 1996 1997 LVP.update({Index, Section.getIndex()}, 1998 {Index + Size, Section.getIndex()}, Index + Size != End); 1999 2000 PIP.printInst( 2001 *IP, Disassembled ? &Inst : nullptr, Bytes.slice(Index, Size), 2002 {SectionAddr + Index + VMAAdjustment, Section.getIndex()}, FOS, 2003 "", *STI, &SP, Obj->getFileName(), &Rels, LVP); 2004 FOS << CommentStream.str(); 2005 Comments.clear(); 2006 2007 // If disassembly has failed, avoid analysing invalid/incomplete 2008 // instruction information. Otherwise, try to resolve the target 2009 // address (jump target or memory operand address) and print it on the 2010 // right of the instruction. 2011 if (Disassembled && MIA) { 2012 uint64_t Target; 2013 bool PrintTarget = 2014 MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target); 2015 if (!PrintTarget) 2016 if (Optional<uint64_t> MaybeTarget = 2017 MIA->evaluateMemoryOperandAddress( 2018 Inst, SectionAddr + Index, Size)) { 2019 Target = *MaybeTarget; 2020 PrintTarget = true; 2021 // Do not print real address when symbolizing. 2022 if (!SymbolizeOperands) 2023 FOS << " # " << Twine::utohexstr(Target); 2024 } 2025 if (PrintTarget) { 2026 // In a relocatable object, the target's section must reside in 2027 // the same section as the call instruction or it is accessed 2028 // through a relocation. 2029 // 2030 // In a non-relocatable object, the target may be in any section. 2031 // In that case, locate the section(s) containing the target 2032 // address and find the symbol in one of those, if possible. 2033 // 2034 // N.B. We don't walk the relocations in the relocatable case yet. 2035 std::vector<const SectionSymbolsTy *> TargetSectionSymbols; 2036 if (!Obj->isRelocatableObject()) { 2037 auto It = llvm::partition_point( 2038 SectionAddresses, 2039 [=](const std::pair<uint64_t, SectionRef> &O) { 2040 return O.first <= Target; 2041 }); 2042 uint64_t TargetSecAddr = 0; 2043 while (It != SectionAddresses.begin()) { 2044 --It; 2045 if (TargetSecAddr == 0) 2046 TargetSecAddr = It->first; 2047 if (It->first != TargetSecAddr) 2048 break; 2049 TargetSectionSymbols.push_back(&AllSymbols[It->second]); 2050 } 2051 } else { 2052 TargetSectionSymbols.push_back(&Symbols); 2053 } 2054 TargetSectionSymbols.push_back(&AbsoluteSymbols); 2055 2056 // Find the last symbol in the first candidate section whose 2057 // offset is less than or equal to the target. If there are no 2058 // such symbols, try in the next section and so on, before finally 2059 // using the nearest preceding absolute symbol (if any), if there 2060 // are no other valid symbols. 2061 const SymbolInfoTy *TargetSym = nullptr; 2062 for (const SectionSymbolsTy *TargetSymbols : 2063 TargetSectionSymbols) { 2064 auto It = llvm::partition_point( 2065 *TargetSymbols, 2066 [=](const SymbolInfoTy &O) { return O.Addr <= Target; }); 2067 if (It != TargetSymbols->begin()) { 2068 TargetSym = &*(It - 1); 2069 break; 2070 } 2071 } 2072 2073 // Print the labels corresponding to the target if there's any. 2074 bool LabelAvailable = AllLabels.count(Target); 2075 if (TargetSym != nullptr) { 2076 uint64_t TargetAddress = TargetSym->Addr; 2077 uint64_t Disp = Target - TargetAddress; 2078 std::string TargetName = TargetSym->Name.str(); 2079 if (Demangle) 2080 TargetName = demangle(TargetName); 2081 2082 FOS << " <"; 2083 if (!Disp) { 2084 // Always Print the binary symbol precisely corresponding to 2085 // the target address. 2086 FOS << TargetName; 2087 } else if (!LabelAvailable) { 2088 // Always Print the binary symbol plus an offset if there's no 2089 // local label corresponding to the target address. 2090 FOS << TargetName << "+0x" << Twine::utohexstr(Disp); 2091 } else { 2092 FOS << AllLabels[Target]; 2093 } 2094 FOS << ">"; 2095 } else if (LabelAvailable) { 2096 FOS << " <" << AllLabels[Target] << ">"; 2097 } 2098 } 2099 } 2100 } 2101 2102 LVP.printAfterInst(FOS); 2103 FOS << "\n"; 2104 2105 // Hexagon does this in pretty printer 2106 if (Obj->getArch() != Triple::hexagon) { 2107 // Print relocation for instruction and data. 2108 while (RelCur != RelEnd) { 2109 uint64_t Offset = RelCur->getOffset(); 2110 // If this relocation is hidden, skip it. 2111 if (getHidden(*RelCur) || SectionAddr + Offset < StartAddress) { 2112 ++RelCur; 2113 continue; 2114 } 2115 2116 // Stop when RelCur's offset is past the disassembled 2117 // instruction/data. Note that it's possible the disassembled data 2118 // is not the complete data: we might see the relocation printed in 2119 // the middle of the data, but this matches the binutils objdump 2120 // output. 2121 if (Offset >= Index + Size) 2122 break; 2123 2124 // When --adjust-vma is used, update the address printed. 2125 if (RelCur->getSymbol() != Obj->symbol_end()) { 2126 Expected<section_iterator> SymSI = 2127 RelCur->getSymbol()->getSection(); 2128 if (SymSI && *SymSI != Obj->section_end() && 2129 shouldAdjustVA(**SymSI)) 2130 Offset += AdjustVMA; 2131 } 2132 2133 printRelocation(FOS, Obj->getFileName(), *RelCur, 2134 SectionAddr + Offset, Is64Bits); 2135 LVP.printAfterOtherLine(FOS, true); 2136 ++RelCur; 2137 } 2138 } 2139 2140 Index += Size; 2141 } 2142 } 2143 } 2144 StringSet<> MissingDisasmSymbolSet = 2145 set_difference(DisasmSymbolSet, FoundDisasmSymbolSet); 2146 for (StringRef Sym : MissingDisasmSymbolSet.keys()) 2147 reportWarning("failed to disassemble missing symbol " + Sym, FileName); 2148 } 2149 2150 static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) { 2151 const Target *TheTarget = getTarget(Obj); 2152 2153 // Package up features to be passed to target/subtarget 2154 SubtargetFeatures Features = Obj->getFeatures(); 2155 if (!MAttrs.empty()) 2156 for (unsigned I = 0; I != MAttrs.size(); ++I) 2157 Features.AddFeature(MAttrs[I]); 2158 2159 std::unique_ptr<const MCRegisterInfo> MRI( 2160 TheTarget->createMCRegInfo(TripleName)); 2161 if (!MRI) 2162 reportError(Obj->getFileName(), 2163 "no register info for target " + TripleName); 2164 2165 // Set up disassembler. 2166 MCTargetOptions MCOptions; 2167 std::unique_ptr<const MCAsmInfo> AsmInfo( 2168 TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions)); 2169 if (!AsmInfo) 2170 reportError(Obj->getFileName(), 2171 "no assembly info for target " + TripleName); 2172 2173 if (MCPU.empty()) 2174 MCPU = Obj->tryGetCPUName().getValueOr("").str(); 2175 2176 std::unique_ptr<const MCSubtargetInfo> STI( 2177 TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString())); 2178 if (!STI) 2179 reportError(Obj->getFileName(), 2180 "no subtarget info for target " + TripleName); 2181 std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo()); 2182 if (!MII) 2183 reportError(Obj->getFileName(), 2184 "no instruction info for target " + TripleName); 2185 MCObjectFileInfo MOFI; 2186 MCContext Ctx(AsmInfo.get(), MRI.get(), &MOFI); 2187 // FIXME: for now initialize MCObjectFileInfo with default values 2188 MOFI.InitMCObjectFileInfo(Triple(TripleName), false, Ctx); 2189 2190 std::unique_ptr<MCDisassembler> DisAsm( 2191 TheTarget->createMCDisassembler(*STI, Ctx)); 2192 if (!DisAsm) 2193 reportError(Obj->getFileName(), "no disassembler for target " + TripleName); 2194 2195 // If we have an ARM object file, we need a second disassembler, because 2196 // ARM CPUs have two different instruction sets: ARM mode, and Thumb mode. 2197 // We use mapping symbols to switch between the two assemblers, where 2198 // appropriate. 2199 std::unique_ptr<MCDisassembler> SecondaryDisAsm; 2200 std::unique_ptr<const MCSubtargetInfo> SecondarySTI; 2201 if (isArmElf(Obj) && !STI->checkFeatures("+mclass")) { 2202 if (STI->checkFeatures("+thumb-mode")) 2203 Features.AddFeature("-thumb-mode"); 2204 else 2205 Features.AddFeature("+thumb-mode"); 2206 SecondarySTI.reset(TheTarget->createMCSubtargetInfo(TripleName, MCPU, 2207 Features.getString())); 2208 SecondaryDisAsm.reset(TheTarget->createMCDisassembler(*SecondarySTI, Ctx)); 2209 } 2210 2211 std::unique_ptr<const MCInstrAnalysis> MIA( 2212 TheTarget->createMCInstrAnalysis(MII.get())); 2213 2214 int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); 2215 std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter( 2216 Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI)); 2217 if (!IP) 2218 reportError(Obj->getFileName(), 2219 "no instruction printer for target " + TripleName); 2220 IP->setPrintImmHex(PrintImmHex); 2221 IP->setPrintBranchImmAsAddress(true); 2222 IP->setSymbolizeOperands(SymbolizeOperands); 2223 IP->setMCInstrAnalysis(MIA.get()); 2224 2225 PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName)); 2226 SourcePrinter SP(Obj, TheTarget->getName()); 2227 2228 for (StringRef Opt : DisassemblerOptions) 2229 if (!IP->applyTargetSpecificCLOption(Opt)) 2230 reportError(Obj->getFileName(), 2231 "Unrecognized disassembler option: " + Opt); 2232 2233 disassembleObject(TheTarget, Obj, Ctx, DisAsm.get(), SecondaryDisAsm.get(), 2234 MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP, 2235 SP, InlineRelocs); 2236 } 2237 2238 void objdump::printRelocations(const ObjectFile *Obj) { 2239 StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 : 2240 "%08" PRIx64; 2241 // Regular objdump doesn't print relocations in non-relocatable object 2242 // files. 2243 if (!Obj->isRelocatableObject()) 2244 return; 2245 2246 // Build a mapping from relocation target to a vector of relocation 2247 // sections. Usually, there is an only one relocation section for 2248 // each relocated section. 2249 MapVector<SectionRef, std::vector<SectionRef>> SecToRelSec; 2250 uint64_t Ndx; 2251 for (const SectionRef &Section : ToolSectionFilter(*Obj, &Ndx)) { 2252 if (Section.relocation_begin() == Section.relocation_end()) 2253 continue; 2254 Expected<section_iterator> SecOrErr = Section.getRelocatedSection(); 2255 if (!SecOrErr) 2256 reportError(Obj->getFileName(), 2257 "section (" + Twine(Ndx) + 2258 "): unable to get a relocation target: " + 2259 toString(SecOrErr.takeError())); 2260 SecToRelSec[**SecOrErr].push_back(Section); 2261 } 2262 2263 for (std::pair<SectionRef, std::vector<SectionRef>> &P : SecToRelSec) { 2264 StringRef SecName = unwrapOrError(P.first.getName(), Obj->getFileName()); 2265 outs() << "RELOCATION RECORDS FOR [" << SecName << "]:\n"; 2266 uint32_t OffsetPadding = (Obj->getBytesInAddress() > 4 ? 16 : 8); 2267 uint32_t TypePadding = 24; 2268 outs() << left_justify("OFFSET", OffsetPadding) << " " 2269 << left_justify("TYPE", TypePadding) << " " 2270 << "VALUE\n"; 2271 2272 for (SectionRef Section : P.second) { 2273 for (const RelocationRef &Reloc : Section.relocations()) { 2274 uint64_t Address = Reloc.getOffset(); 2275 SmallString<32> RelocName; 2276 SmallString<32> ValueStr; 2277 if (Address < StartAddress || Address > StopAddress || getHidden(Reloc)) 2278 continue; 2279 Reloc.getTypeName(RelocName); 2280 if (Error E = getRelocationValueString(Reloc, ValueStr)) 2281 reportError(std::move(E), Obj->getFileName()); 2282 2283 outs() << format(Fmt.data(), Address) << " " 2284 << left_justify(RelocName, TypePadding) << " " << ValueStr 2285 << "\n"; 2286 } 2287 } 2288 outs() << "\n"; 2289 } 2290 } 2291 2292 void objdump::printDynamicRelocations(const ObjectFile *Obj) { 2293 // For the moment, this option is for ELF only 2294 if (!Obj->isELF()) 2295 return; 2296 2297 const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj); 2298 if (!Elf || Elf->getEType() != ELF::ET_DYN) { 2299 reportError(Obj->getFileName(), "not a dynamic object"); 2300 return; 2301 } 2302 2303 std::vector<SectionRef> DynRelSec = Obj->dynamic_relocation_sections(); 2304 if (DynRelSec.empty()) 2305 return; 2306 2307 outs() << "DYNAMIC RELOCATION RECORDS\n"; 2308 StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64; 2309 for (const SectionRef &Section : DynRelSec) 2310 for (const RelocationRef &Reloc : Section.relocations()) { 2311 uint64_t Address = Reloc.getOffset(); 2312 SmallString<32> RelocName; 2313 SmallString<32> ValueStr; 2314 Reloc.getTypeName(RelocName); 2315 if (Error E = getRelocationValueString(Reloc, ValueStr)) 2316 reportError(std::move(E), Obj->getFileName()); 2317 outs() << format(Fmt.data(), Address) << " " << RelocName << " " 2318 << ValueStr << "\n"; 2319 } 2320 } 2321 2322 // Returns true if we need to show LMA column when dumping section headers. We 2323 // show it only when the platform is ELF and either we have at least one section 2324 // whose VMA and LMA are different and/or when --show-lma flag is used. 2325 static bool shouldDisplayLMA(const ObjectFile *Obj) { 2326 if (!Obj->isELF()) 2327 return false; 2328 for (const SectionRef &S : ToolSectionFilter(*Obj)) 2329 if (S.getAddress() != getELFSectionLMA(S)) 2330 return true; 2331 return ShowLMA; 2332 } 2333 2334 static size_t getMaxSectionNameWidth(const ObjectFile *Obj) { 2335 // Default column width for names is 13 even if no names are that long. 2336 size_t MaxWidth = 13; 2337 for (const SectionRef &Section : ToolSectionFilter(*Obj)) { 2338 StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName()); 2339 MaxWidth = std::max(MaxWidth, Name.size()); 2340 } 2341 return MaxWidth; 2342 } 2343 2344 void objdump::printSectionHeaders(const ObjectFile *Obj) { 2345 size_t NameWidth = getMaxSectionNameWidth(Obj); 2346 size_t AddressWidth = 2 * Obj->getBytesInAddress(); 2347 bool HasLMAColumn = shouldDisplayLMA(Obj); 2348 if (HasLMAColumn) 2349 outs() << "Sections:\n" 2350 "Idx " 2351 << left_justify("Name", NameWidth) << " Size " 2352 << left_justify("VMA", AddressWidth) << " " 2353 << left_justify("LMA", AddressWidth) << " Type\n"; 2354 else 2355 outs() << "Sections:\n" 2356 "Idx " 2357 << left_justify("Name", NameWidth) << " Size " 2358 << left_justify("VMA", AddressWidth) << " Type\n"; 2359 2360 uint64_t Idx; 2361 for (const SectionRef &Section : ToolSectionFilter(*Obj, &Idx)) { 2362 StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName()); 2363 uint64_t VMA = Section.getAddress(); 2364 if (shouldAdjustVA(Section)) 2365 VMA += AdjustVMA; 2366 2367 uint64_t Size = Section.getSize(); 2368 2369 std::string Type = Section.isText() ? "TEXT" : ""; 2370 if (Section.isData()) 2371 Type += Type.empty() ? "DATA" : " DATA"; 2372 if (Section.isBSS()) 2373 Type += Type.empty() ? "BSS" : " BSS"; 2374 2375 if (HasLMAColumn) 2376 outs() << format("%3" PRIu64 " %-*s %08" PRIx64 " ", Idx, NameWidth, 2377 Name.str().c_str(), Size) 2378 << format_hex_no_prefix(VMA, AddressWidth) << " " 2379 << format_hex_no_prefix(getELFSectionLMA(Section), AddressWidth) 2380 << " " << Type << "\n"; 2381 else 2382 outs() << format("%3" PRIu64 " %-*s %08" PRIx64 " ", Idx, NameWidth, 2383 Name.str().c_str(), Size) 2384 << format_hex_no_prefix(VMA, AddressWidth) << " " << Type << "\n"; 2385 } 2386 outs() << "\n"; 2387 } 2388 2389 void objdump::printSectionContents(const ObjectFile *Obj) { 2390 const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj); 2391 2392 for (const SectionRef &Section : ToolSectionFilter(*Obj)) { 2393 StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName()); 2394 uint64_t BaseAddr = Section.getAddress(); 2395 uint64_t Size = Section.getSize(); 2396 if (!Size) 2397 continue; 2398 2399 outs() << "Contents of section "; 2400 StringRef SegmentName = getSegmentName(MachO, Section); 2401 if (!SegmentName.empty()) 2402 outs() << SegmentName << ","; 2403 outs() << Name << ":\n"; 2404 if (Section.isBSS()) { 2405 outs() << format("<skipping contents of bss section at [%04" PRIx64 2406 ", %04" PRIx64 ")>\n", 2407 BaseAddr, BaseAddr + Size); 2408 continue; 2409 } 2410 2411 StringRef Contents = unwrapOrError(Section.getContents(), Obj->getFileName()); 2412 2413 // Dump out the content as hex and printable ascii characters. 2414 for (std::size_t Addr = 0, End = Contents.size(); Addr < End; Addr += 16) { 2415 outs() << format(" %04" PRIx64 " ", BaseAddr + Addr); 2416 // Dump line of hex. 2417 for (std::size_t I = 0; I < 16; ++I) { 2418 if (I != 0 && I % 4 == 0) 2419 outs() << ' '; 2420 if (Addr + I < End) 2421 outs() << hexdigit((Contents[Addr + I] >> 4) & 0xF, true) 2422 << hexdigit(Contents[Addr + I] & 0xF, true); 2423 else 2424 outs() << " "; 2425 } 2426 // Print ascii. 2427 outs() << " "; 2428 for (std::size_t I = 0; I < 16 && Addr + I < End; ++I) { 2429 if (isPrint(static_cast<unsigned char>(Contents[Addr + I]) & 0xFF)) 2430 outs() << Contents[Addr + I]; 2431 else 2432 outs() << "."; 2433 } 2434 outs() << "\n"; 2435 } 2436 } 2437 } 2438 2439 void objdump::printSymbolTable(const ObjectFile *O, StringRef ArchiveName, 2440 StringRef ArchitectureName, bool DumpDynamic) { 2441 if (O->isCOFF() && !DumpDynamic) { 2442 outs() << "SYMBOL TABLE:\n"; 2443 printCOFFSymbolTable(cast<const COFFObjectFile>(O)); 2444 return; 2445 } 2446 2447 const StringRef FileName = O->getFileName(); 2448 2449 if (!DumpDynamic) { 2450 outs() << "SYMBOL TABLE:\n"; 2451 for (auto I = O->symbol_begin(); I != O->symbol_end(); ++I) 2452 printSymbol(O, *I, FileName, ArchiveName, ArchitectureName, DumpDynamic); 2453 return; 2454 } 2455 2456 outs() << "DYNAMIC SYMBOL TABLE:\n"; 2457 if (!O->isELF()) { 2458 reportWarning( 2459 "this operation is not currently supported for this file format", 2460 FileName); 2461 return; 2462 } 2463 2464 const ELFObjectFileBase *ELF = cast<const ELFObjectFileBase>(O); 2465 for (auto I = ELF->getDynamicSymbolIterators().begin(); 2466 I != ELF->getDynamicSymbolIterators().end(); ++I) 2467 printSymbol(O, *I, FileName, ArchiveName, ArchitectureName, DumpDynamic); 2468 } 2469 2470 void objdump::printSymbol(const ObjectFile *O, const SymbolRef &Symbol, 2471 StringRef FileName, StringRef ArchiveName, 2472 StringRef ArchitectureName, bool DumpDynamic) { 2473 const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(O); 2474 uint64_t Address = unwrapOrError(Symbol.getAddress(), FileName, ArchiveName, 2475 ArchitectureName); 2476 if ((Address < StartAddress) || (Address > StopAddress)) 2477 return; 2478 SymbolRef::Type Type = 2479 unwrapOrError(Symbol.getType(), FileName, ArchiveName, ArchitectureName); 2480 uint32_t Flags = 2481 unwrapOrError(Symbol.getFlags(), FileName, ArchiveName, ArchitectureName); 2482 2483 // Don't ask a Mach-O STAB symbol for its section unless you know that 2484 // STAB symbol's section field refers to a valid section index. Otherwise 2485 // the symbol may error trying to load a section that does not exist. 2486 bool IsSTAB = false; 2487 if (MachO) { 2488 DataRefImpl SymDRI = Symbol.getRawDataRefImpl(); 2489 uint8_t NType = 2490 (MachO->is64Bit() ? MachO->getSymbol64TableEntry(SymDRI).n_type 2491 : MachO->getSymbolTableEntry(SymDRI).n_type); 2492 if (NType & MachO::N_STAB) 2493 IsSTAB = true; 2494 } 2495 section_iterator Section = IsSTAB 2496 ? O->section_end() 2497 : unwrapOrError(Symbol.getSection(), FileName, 2498 ArchiveName, ArchitectureName); 2499 2500 StringRef Name; 2501 if (Type == SymbolRef::ST_Debug && Section != O->section_end()) { 2502 if (Expected<StringRef> NameOrErr = Section->getName()) 2503 Name = *NameOrErr; 2504 else 2505 consumeError(NameOrErr.takeError()); 2506 2507 } else { 2508 Name = unwrapOrError(Symbol.getName(), FileName, ArchiveName, 2509 ArchitectureName); 2510 } 2511 2512 bool Global = Flags & SymbolRef::SF_Global; 2513 bool Weak = Flags & SymbolRef::SF_Weak; 2514 bool Absolute = Flags & SymbolRef::SF_Absolute; 2515 bool Common = Flags & SymbolRef::SF_Common; 2516 bool Hidden = Flags & SymbolRef::SF_Hidden; 2517 2518 char GlobLoc = ' '; 2519 if ((Section != O->section_end() || Absolute) && !Weak) 2520 GlobLoc = Global ? 'g' : 'l'; 2521 char IFunc = ' '; 2522 if (O->isELF()) { 2523 if (ELFSymbolRef(Symbol).getELFType() == ELF::STT_GNU_IFUNC) 2524 IFunc = 'i'; 2525 if (ELFSymbolRef(Symbol).getBinding() == ELF::STB_GNU_UNIQUE) 2526 GlobLoc = 'u'; 2527 } 2528 2529 char Debug = ' '; 2530 if (DumpDynamic) 2531 Debug = 'D'; 2532 else if (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File) 2533 Debug = 'd'; 2534 2535 char FileFunc = ' '; 2536 if (Type == SymbolRef::ST_File) 2537 FileFunc = 'f'; 2538 else if (Type == SymbolRef::ST_Function) 2539 FileFunc = 'F'; 2540 else if (Type == SymbolRef::ST_Data) 2541 FileFunc = 'O'; 2542 2543 const char *Fmt = O->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64; 2544 2545 outs() << format(Fmt, Address) << " " 2546 << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' ' 2547 << (Weak ? 'w' : ' ') // Weak? 2548 << ' ' // Constructor. Not supported yet. 2549 << ' ' // Warning. Not supported yet. 2550 << IFunc // Indirect reference to another symbol. 2551 << Debug // Debugging (d) or dynamic (D) symbol. 2552 << FileFunc // Name of function (F), file (f) or object (O). 2553 << ' '; 2554 if (Absolute) { 2555 outs() << "*ABS*"; 2556 } else if (Common) { 2557 outs() << "*COM*"; 2558 } else if (Section == O->section_end()) { 2559 outs() << "*UND*"; 2560 } else { 2561 StringRef SegmentName = getSegmentName(MachO, *Section); 2562 if (!SegmentName.empty()) 2563 outs() << SegmentName << ","; 2564 StringRef SectionName = unwrapOrError(Section->getName(), FileName); 2565 outs() << SectionName; 2566 } 2567 2568 if (Common || O->isELF()) { 2569 uint64_t Val = 2570 Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize(); 2571 outs() << '\t' << format(Fmt, Val); 2572 } 2573 2574 if (O->isELF()) { 2575 uint8_t Other = ELFSymbolRef(Symbol).getOther(); 2576 switch (Other) { 2577 case ELF::STV_DEFAULT: 2578 break; 2579 case ELF::STV_INTERNAL: 2580 outs() << " .internal"; 2581 break; 2582 case ELF::STV_HIDDEN: 2583 outs() << " .hidden"; 2584 break; 2585 case ELF::STV_PROTECTED: 2586 outs() << " .protected"; 2587 break; 2588 default: 2589 outs() << format(" 0x%02x", Other); 2590 break; 2591 } 2592 } else if (Hidden) { 2593 outs() << " .hidden"; 2594 } 2595 2596 if (Demangle) 2597 outs() << ' ' << demangle(std::string(Name)) << '\n'; 2598 else 2599 outs() << ' ' << Name << '\n'; 2600 } 2601 2602 static void printUnwindInfo(const ObjectFile *O) { 2603 outs() << "Unwind info:\n\n"; 2604 2605 if (const COFFObjectFile *Coff = dyn_cast<COFFObjectFile>(O)) 2606 printCOFFUnwindInfo(Coff); 2607 else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O)) 2608 printMachOUnwindInfo(MachO); 2609 else 2610 // TODO: Extract DWARF dump tool to objdump. 2611 WithColor::error(errs(), ToolName) 2612 << "This operation is only currently supported " 2613 "for COFF and MachO object files.\n"; 2614 } 2615 2616 /// Dump the raw contents of the __clangast section so the output can be piped 2617 /// into llvm-bcanalyzer. 2618 static void printRawClangAST(const ObjectFile *Obj) { 2619 if (outs().is_displayed()) { 2620 WithColor::error(errs(), ToolName) 2621 << "The -raw-clang-ast option will dump the raw binary contents of " 2622 "the clang ast section.\n" 2623 "Please redirect the output to a file or another program such as " 2624 "llvm-bcanalyzer.\n"; 2625 return; 2626 } 2627 2628 StringRef ClangASTSectionName("__clangast"); 2629 if (Obj->isCOFF()) { 2630 ClangASTSectionName = "clangast"; 2631 } 2632 2633 Optional<object::SectionRef> ClangASTSection; 2634 for (auto Sec : ToolSectionFilter(*Obj)) { 2635 StringRef Name; 2636 if (Expected<StringRef> NameOrErr = Sec.getName()) 2637 Name = *NameOrErr; 2638 else 2639 consumeError(NameOrErr.takeError()); 2640 2641 if (Name == ClangASTSectionName) { 2642 ClangASTSection = Sec; 2643 break; 2644 } 2645 } 2646 if (!ClangASTSection) 2647 return; 2648 2649 StringRef ClangASTContents = unwrapOrError( 2650 ClangASTSection.getValue().getContents(), Obj->getFileName()); 2651 outs().write(ClangASTContents.data(), ClangASTContents.size()); 2652 } 2653 2654 static void printFaultMaps(const ObjectFile *Obj) { 2655 StringRef FaultMapSectionName; 2656 2657 if (Obj->isELF()) { 2658 FaultMapSectionName = ".llvm_faultmaps"; 2659 } else if (Obj->isMachO()) { 2660 FaultMapSectionName = "__llvm_faultmaps"; 2661 } else { 2662 WithColor::error(errs(), ToolName) 2663 << "This operation is only currently supported " 2664 "for ELF and Mach-O executable files.\n"; 2665 return; 2666 } 2667 2668 Optional<object::SectionRef> FaultMapSection; 2669 2670 for (auto Sec : ToolSectionFilter(*Obj)) { 2671 StringRef Name; 2672 if (Expected<StringRef> NameOrErr = Sec.getName()) 2673 Name = *NameOrErr; 2674 else 2675 consumeError(NameOrErr.takeError()); 2676 2677 if (Name == FaultMapSectionName) { 2678 FaultMapSection = Sec; 2679 break; 2680 } 2681 } 2682 2683 outs() << "FaultMap table:\n"; 2684 2685 if (!FaultMapSection.hasValue()) { 2686 outs() << "<not found>\n"; 2687 return; 2688 } 2689 2690 StringRef FaultMapContents = 2691 unwrapOrError(FaultMapSection.getValue().getContents(), Obj->getFileName()); 2692 FaultMapParser FMP(FaultMapContents.bytes_begin(), 2693 FaultMapContents.bytes_end()); 2694 2695 outs() << FMP; 2696 } 2697 2698 static void printPrivateFileHeaders(const ObjectFile *O, bool OnlyFirst) { 2699 if (O->isELF()) { 2700 printELFFileHeader(O); 2701 printELFDynamicSection(O); 2702 printELFSymbolVersionInfo(O); 2703 return; 2704 } 2705 if (O->isCOFF()) 2706 return printCOFFFileHeader(O); 2707 if (O->isWasm()) 2708 return printWasmFileHeader(O); 2709 if (O->isMachO()) { 2710 printMachOFileHeader(O); 2711 if (!OnlyFirst) 2712 printMachOLoadCommands(O); 2713 return; 2714 } 2715 reportError(O->getFileName(), "Invalid/Unsupported object file format"); 2716 } 2717 2718 static void printFileHeaders(const ObjectFile *O) { 2719 if (!O->isELF() && !O->isCOFF()) 2720 reportError(O->getFileName(), "Invalid/Unsupported object file format"); 2721 2722 Triple::ArchType AT = O->getArch(); 2723 outs() << "architecture: " << Triple::getArchTypeName(AT) << "\n"; 2724 uint64_t Address = unwrapOrError(O->getStartAddress(), O->getFileName()); 2725 2726 StringRef Fmt = O->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64; 2727 outs() << "start address: " 2728 << "0x" << format(Fmt.data(), Address) << "\n\n"; 2729 } 2730 2731 static void printArchiveChild(StringRef Filename, const Archive::Child &C) { 2732 Expected<sys::fs::perms> ModeOrErr = C.getAccessMode(); 2733 if (!ModeOrErr) { 2734 WithColor::error(errs(), ToolName) << "ill-formed archive entry.\n"; 2735 consumeError(ModeOrErr.takeError()); 2736 return; 2737 } 2738 sys::fs::perms Mode = ModeOrErr.get(); 2739 outs() << ((Mode & sys::fs::owner_read) ? "r" : "-"); 2740 outs() << ((Mode & sys::fs::owner_write) ? "w" : "-"); 2741 outs() << ((Mode & sys::fs::owner_exe) ? "x" : "-"); 2742 outs() << ((Mode & sys::fs::group_read) ? "r" : "-"); 2743 outs() << ((Mode & sys::fs::group_write) ? "w" : "-"); 2744 outs() << ((Mode & sys::fs::group_exe) ? "x" : "-"); 2745 outs() << ((Mode & sys::fs::others_read) ? "r" : "-"); 2746 outs() << ((Mode & sys::fs::others_write) ? "w" : "-"); 2747 outs() << ((Mode & sys::fs::others_exe) ? "x" : "-"); 2748 2749 outs() << " "; 2750 2751 outs() << format("%d/%d %6" PRId64 " ", unwrapOrError(C.getUID(), Filename), 2752 unwrapOrError(C.getGID(), Filename), 2753 unwrapOrError(C.getRawSize(), Filename)); 2754 2755 StringRef RawLastModified = C.getRawLastModified(); 2756 unsigned Seconds; 2757 if (RawLastModified.getAsInteger(10, Seconds)) 2758 outs() << "(date: \"" << RawLastModified 2759 << "\" contains non-decimal chars) "; 2760 else { 2761 // Since ctime(3) returns a 26 character string of the form: 2762 // "Sun Sep 16 01:03:52 1973\n\0" 2763 // just print 24 characters. 2764 time_t t = Seconds; 2765 outs() << format("%.24s ", ctime(&t)); 2766 } 2767 2768 StringRef Name = ""; 2769 Expected<StringRef> NameOrErr = C.getName(); 2770 if (!NameOrErr) { 2771 consumeError(NameOrErr.takeError()); 2772 Name = unwrapOrError(C.getRawName(), Filename); 2773 } else { 2774 Name = NameOrErr.get(); 2775 } 2776 outs() << Name << "\n"; 2777 } 2778 2779 // For ELF only now. 2780 static bool shouldWarnForInvalidStartStopAddress(ObjectFile *Obj) { 2781 if (const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj)) { 2782 if (Elf->getEType() != ELF::ET_REL) 2783 return true; 2784 } 2785 return false; 2786 } 2787 2788 static void checkForInvalidStartStopAddress(ObjectFile *Obj, 2789 uint64_t Start, uint64_t Stop) { 2790 if (!shouldWarnForInvalidStartStopAddress(Obj)) 2791 return; 2792 2793 for (const SectionRef &Section : Obj->sections()) 2794 if (ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC) { 2795 uint64_t BaseAddr = Section.getAddress(); 2796 uint64_t Size = Section.getSize(); 2797 if ((Start < BaseAddr + Size) && Stop > BaseAddr) 2798 return; 2799 } 2800 2801 if (StartAddress.getNumOccurrences() == 0) 2802 reportWarning("no section has address less than 0x" + 2803 Twine::utohexstr(Stop) + " specified by --stop-address", 2804 Obj->getFileName()); 2805 else if (StopAddress.getNumOccurrences() == 0) 2806 reportWarning("no section has address greater than or equal to 0x" + 2807 Twine::utohexstr(Start) + " specified by --start-address", 2808 Obj->getFileName()); 2809 else 2810 reportWarning("no section overlaps the range [0x" + 2811 Twine::utohexstr(Start) + ",0x" + Twine::utohexstr(Stop) + 2812 ") specified by --start-address/--stop-address", 2813 Obj->getFileName()); 2814 } 2815 2816 static void dumpObject(ObjectFile *O, const Archive *A = nullptr, 2817 const Archive::Child *C = nullptr) { 2818 // Avoid other output when using a raw option. 2819 if (!RawClangAST) { 2820 outs() << '\n'; 2821 if (A) 2822 outs() << A->getFileName() << "(" << O->getFileName() << ")"; 2823 else 2824 outs() << O->getFileName(); 2825 outs() << ":\tfile format " << O->getFileFormatName().lower() << "\n\n"; 2826 } 2827 2828 if (StartAddress.getNumOccurrences() || StopAddress.getNumOccurrences()) 2829 checkForInvalidStartStopAddress(O, StartAddress, StopAddress); 2830 2831 // Note: the order here matches GNU objdump for compatability. 2832 StringRef ArchiveName = A ? A->getFileName() : ""; 2833 if (ArchiveHeaders && !MachOOpt && C) 2834 printArchiveChild(ArchiveName, *C); 2835 if (FileHeaders) 2836 printFileHeaders(O); 2837 if (PrivateHeaders || FirstPrivateHeader) 2838 printPrivateFileHeaders(O, FirstPrivateHeader); 2839 if (SectionHeaders) 2840 printSectionHeaders(O); 2841 if (SymbolTable) 2842 printSymbolTable(O, ArchiveName); 2843 if (DynamicSymbolTable) 2844 printSymbolTable(O, ArchiveName, /*ArchitectureName=*/"", 2845 /*DumpDynamic=*/true); 2846 if (DwarfDumpType != DIDT_Null) { 2847 std::unique_ptr<DIContext> DICtx = DWARFContext::create(*O); 2848 // Dump the complete DWARF structure. 2849 DIDumpOptions DumpOpts; 2850 DumpOpts.DumpType = DwarfDumpType; 2851 DICtx->dump(outs(), DumpOpts); 2852 } 2853 if (Relocations && !Disassemble) 2854 printRelocations(O); 2855 if (DynamicRelocations) 2856 printDynamicRelocations(O); 2857 if (SectionContents) 2858 printSectionContents(O); 2859 if (Disassemble) 2860 disassembleObject(O, Relocations); 2861 if (UnwindInfo) 2862 printUnwindInfo(O); 2863 2864 // Mach-O specific options: 2865 if (ExportsTrie) 2866 printExportsTrie(O); 2867 if (Rebase) 2868 printRebaseTable(O); 2869 if (Bind) 2870 printBindTable(O); 2871 if (LazyBind) 2872 printLazyBindTable(O); 2873 if (WeakBind) 2874 printWeakBindTable(O); 2875 2876 // Other special sections: 2877 if (RawClangAST) 2878 printRawClangAST(O); 2879 if (FaultMapSection) 2880 printFaultMaps(O); 2881 } 2882 2883 static void dumpObject(const COFFImportFile *I, const Archive *A, 2884 const Archive::Child *C = nullptr) { 2885 StringRef ArchiveName = A ? A->getFileName() : ""; 2886 2887 // Avoid other output when using a raw option. 2888 if (!RawClangAST) 2889 outs() << '\n' 2890 << ArchiveName << "(" << I->getFileName() << ")" 2891 << ":\tfile format COFF-import-file" 2892 << "\n\n"; 2893 2894 if (ArchiveHeaders && !MachOOpt && C) 2895 printArchiveChild(ArchiveName, *C); 2896 if (SymbolTable) 2897 printCOFFSymbolTable(I); 2898 } 2899 2900 /// Dump each object file in \a a; 2901 static void dumpArchive(const Archive *A) { 2902 Error Err = Error::success(); 2903 unsigned I = -1; 2904 for (auto &C : A->children(Err)) { 2905 ++I; 2906 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(); 2907 if (!ChildOrErr) { 2908 if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) 2909 reportError(std::move(E), getFileNameForError(C, I), A->getFileName()); 2910 continue; 2911 } 2912 if (ObjectFile *O = dyn_cast<ObjectFile>(&*ChildOrErr.get())) 2913 dumpObject(O, A, &C); 2914 else if (COFFImportFile *I = dyn_cast<COFFImportFile>(&*ChildOrErr.get())) 2915 dumpObject(I, A, &C); 2916 else 2917 reportError(errorCodeToError(object_error::invalid_file_type), 2918 A->getFileName()); 2919 } 2920 if (Err) 2921 reportError(std::move(Err), A->getFileName()); 2922 } 2923 2924 /// Open file and figure out how to dump it. 2925 static void dumpInput(StringRef file) { 2926 // If we are using the Mach-O specific object file parser, then let it parse 2927 // the file and process the command line options. So the -arch flags can 2928 // be used to select specific slices, etc. 2929 if (MachOOpt) { 2930 parseInputMachO(file); 2931 return; 2932 } 2933 2934 // Attempt to open the binary. 2935 OwningBinary<Binary> OBinary = unwrapOrError(createBinary(file), file); 2936 Binary &Binary = *OBinary.getBinary(); 2937 2938 if (Archive *A = dyn_cast<Archive>(&Binary)) 2939 dumpArchive(A); 2940 else if (ObjectFile *O = dyn_cast<ObjectFile>(&Binary)) 2941 dumpObject(O); 2942 else if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Binary)) 2943 parseInputMachO(UB); 2944 else 2945 reportError(errorCodeToError(object_error::invalid_file_type), file); 2946 } 2947 2948 int main(int argc, char **argv) { 2949 using namespace llvm; 2950 InitLLVM X(argc, argv); 2951 const cl::OptionCategory *OptionFilters[] = {&ObjdumpCat, &MachOCat}; 2952 cl::HideUnrelatedOptions(OptionFilters); 2953 2954 // Initialize targets and assembly printers/parsers. 2955 InitializeAllTargetInfos(); 2956 InitializeAllTargetMCs(); 2957 InitializeAllDisassemblers(); 2958 2959 // Register the target printer for --version. 2960 cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); 2961 2962 cl::ParseCommandLineOptions(argc, argv, "llvm object file dumper\n", nullptr, 2963 /*EnvVar=*/nullptr, 2964 /*LongOptionsUseDoubleDash=*/true); 2965 2966 if (StartAddress >= StopAddress) 2967 reportCmdLineError("start address should be less than stop address"); 2968 2969 ToolName = argv[0]; 2970 2971 // Defaults to a.out if no filenames specified. 2972 if (InputFilenames.empty()) 2973 InputFilenames.push_back("a.out"); 2974 2975 // Removes trailing separators from prefix. 2976 while (!Prefix.empty() && sys::path::is_separator(Prefix.back())) 2977 Prefix.pop_back(); 2978 2979 if (AllHeaders) 2980 ArchiveHeaders = FileHeaders = PrivateHeaders = Relocations = 2981 SectionHeaders = SymbolTable = true; 2982 2983 if (DisassembleAll || PrintSource || PrintLines || 2984 !DisassembleSymbols.empty()) 2985 Disassemble = true; 2986 2987 if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null && 2988 !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST && 2989 !Relocations && !SectionHeaders && !SectionContents && !SymbolTable && 2990 !DynamicSymbolTable && !UnwindInfo && !FaultMapSection && 2991 !(MachOOpt && 2992 (Bind || DataInCode || DylibId || DylibsUsed || ExportsTrie || 2993 FirstPrivateHeader || IndirectSymbols || InfoPlist || LazyBind || 2994 LinkOptHints || ObjcMetaData || Rebase || UniversalHeaders || 2995 WeakBind || !FilterSections.empty()))) { 2996 cl::PrintHelpMessage(); 2997 return 2; 2998 } 2999 3000 DisasmSymbolSet.insert(DisassembleSymbols.begin(), DisassembleSymbols.end()); 3001 3002 llvm::for_each(InputFilenames, dumpInput); 3003 3004 warnOnNoMatchForSections(); 3005 3006 return EXIT_SUCCESS; 3007 } 3008