1 //===- llvm-readobj.cpp - Dump contents of an Object File -----------------===// 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 is a tool similar to readelf, except it works on multiple object file 10 // formats. The main purpose of this tool is to provide detailed output suitable 11 // for FileCheck. 12 // 13 // Flags should be similar to readelf where supported, but the output format 14 // does not need to be identical. The point is to not make users learn yet 15 // another set of flags. 16 // 17 // Output should be specialized for each format where appropriate. 18 // 19 //===----------------------------------------------------------------------===// 20 21 #include "llvm-readobj.h" 22 #include "ObjDumper.h" 23 #include "WindowsResourceDumper.h" 24 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h" 25 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h" 26 #include "llvm/Object/Archive.h" 27 #include "llvm/Object/COFFImportFile.h" 28 #include "llvm/Object/ELFObjectFile.h" 29 #include "llvm/Object/MachOUniversal.h" 30 #include "llvm/Object/ObjectFile.h" 31 #include "llvm/Object/Wasm.h" 32 #include "llvm/Object/WindowsResource.h" 33 #include "llvm/Object/XCOFFObjectFile.h" 34 #include "llvm/Support/Casting.h" 35 #include "llvm/Support/CommandLine.h" 36 #include "llvm/Support/DataTypes.h" 37 #include "llvm/Support/Debug.h" 38 #include "llvm/Support/Errc.h" 39 #include "llvm/Support/FileSystem.h" 40 #include "llvm/Support/FormatVariadic.h" 41 #include "llvm/Support/InitLLVM.h" 42 #include "llvm/Support/Path.h" 43 #include "llvm/Support/ScopedPrinter.h" 44 #include "llvm/Support/TargetRegistry.h" 45 #include "llvm/Support/WithColor.h" 46 47 using namespace llvm; 48 using namespace llvm::object; 49 50 namespace opts { 51 cl::list<std::string> InputFilenames(cl::Positional, 52 cl::desc("<input object files>"), 53 cl::ZeroOrMore); 54 55 // --all, -a 56 cl::opt<bool> 57 All("all", 58 cl::desc("Equivalent to setting: --file-headers, --program-headers, " 59 "--section-headers, --symbols, --relocations, " 60 "--dynamic-table, --notes, --version-info, --unwind, " 61 "--section-groups and --elf-hash-histogram.")); 62 cl::alias AllShort("a", cl::desc("Alias for --all"), cl::aliasopt(All)); 63 64 // --dependent-libraries 65 cl::opt<bool> 66 DependentLibraries("dependent-libraries", 67 cl::desc("Display the dependent libraries section")); 68 69 // --headers, -e 70 cl::opt<bool> 71 Headers("headers", 72 cl::desc("Equivalent to setting: --file-headers, --program-headers, " 73 "--section-headers")); 74 cl::alias HeadersShort("e", cl::desc("Alias for --headers"), 75 cl::aliasopt(Headers), cl::NotHidden); 76 77 // --wide, -W 78 cl::opt<bool> 79 WideOutput("wide", cl::desc("Ignored for compatibility with GNU readelf"), 80 cl::Hidden); 81 cl::alias WideOutputShort("W", 82 cl::desc("Alias for --wide"), 83 cl::aliasopt(WideOutput)); 84 85 // --file-headers, --file-header, -h 86 cl::opt<bool> FileHeaders("file-headers", 87 cl::desc("Display file headers ")); 88 cl::alias FileHeadersShort("h", cl::desc("Alias for --file-headers"), 89 cl::aliasopt(FileHeaders), cl::NotHidden); 90 cl::alias FileHeadersSingular("file-header", 91 cl::desc("Alias for --file-headers"), 92 cl::aliasopt(FileHeaders)); 93 94 // --section-headers, --sections, -S 95 // Also -s in llvm-readobj mode. 96 cl::opt<bool> SectionHeaders("section-headers", 97 cl::desc("Display all section headers.")); 98 cl::alias SectionsShortUpper("S", cl::desc("Alias for --section-headers"), 99 cl::aliasopt(SectionHeaders), cl::NotHidden); 100 cl::alias SectionHeadersAlias("sections", 101 cl::desc("Alias for --section-headers"), 102 cl::aliasopt(SectionHeaders), cl::NotHidden); 103 104 // --section-relocations 105 // Also --sr in llvm-readobj mode. 106 cl::opt<bool> SectionRelocations("section-relocations", 107 cl::desc("Display relocations for each section shown.")); 108 109 // --section-symbols 110 // Also --st in llvm-readobj mode. 111 cl::opt<bool> SectionSymbols("section-symbols", 112 cl::desc("Display symbols for each section shown.")); 113 114 // --section-data 115 // Also --sd in llvm-readobj mode. 116 cl::opt<bool> SectionData("section-data", 117 cl::desc("Display section data for each section shown.")); 118 119 // --section-mapping 120 cl::opt<cl::boolOrDefault> 121 SectionMapping("section-mapping", 122 cl::desc("Display the section to segment mapping.")); 123 124 // --relocations, --relocs, -r 125 cl::opt<bool> Relocations("relocations", 126 cl::desc("Display the relocation entries in the file")); 127 cl::alias RelocationsShort("r", cl::desc("Alias for --relocations"), 128 cl::aliasopt(Relocations), cl::NotHidden); 129 cl::alias RelocationsGNU("relocs", cl::desc("Alias for --relocations"), 130 cl::aliasopt(Relocations)); 131 132 // --notes, -n 133 cl::opt<bool> Notes("notes", cl::desc("Display the ELF notes in the file")); 134 cl::alias NotesShort("n", cl::desc("Alias for --notes"), cl::aliasopt(Notes), 135 cl::NotHidden); 136 137 // --dyn-relocations 138 cl::opt<bool> DynRelocs("dyn-relocations", 139 cl::desc("Display the dynamic relocation entries in the file")); 140 141 // --section-details 142 // Also -t in llvm-readelf mode. 143 cl::opt<bool> SectionDetails("section-details", 144 cl::desc("Display the section details")); 145 static cl::alias SectionDetailsShort("t", 146 cl::desc("Alias for --section-details"), 147 cl::aliasopt(SectionDetails), 148 cl::NotHidden); 149 150 // --symbols 151 // Also -s in llvm-readelf mode, or -t in llvm-readobj mode. 152 cl::opt<bool> 153 Symbols("symbols", 154 cl::desc("Display the symbol table. Also display the dynamic " 155 "symbol table when using GNU output style for ELF")); 156 cl::alias SymbolsGNU("syms", cl::desc("Alias for --symbols"), 157 cl::aliasopt(Symbols)); 158 static cl::alias SymbolsShort("s", cl::desc("Alias for --symbols"), 159 cl::aliasopt(Symbols), cl::NotHidden, 160 cl::Grouping); 161 162 // --dyn-symbols, --dyn-syms 163 // Also --dt in llvm-readobj mode. 164 cl::opt<bool> DynamicSymbols("dyn-symbols", 165 cl::desc("Display the dynamic symbol table")); 166 cl::alias DynSymsGNU("dyn-syms", cl::desc("Alias for --dyn-symbols"), 167 cl::aliasopt(DynamicSymbols)); 168 169 // --hash-symbols 170 cl::opt<bool> HashSymbols( 171 "hash-symbols", 172 cl::desc("Display the dynamic symbols derived from the hash section")); 173 174 // --unwind, -u 175 cl::opt<bool> UnwindInfo("unwind", 176 cl::desc("Display unwind information")); 177 cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind"), 178 cl::aliasopt(UnwindInfo), cl::NotHidden); 179 180 // --dynamic-table, --dynamic, -d 181 cl::opt<bool> DynamicTable("dynamic-table", 182 cl::desc("Display the ELF .dynamic section table")); 183 cl::alias DynamicTableShort("d", cl::desc("Alias for --dynamic-table"), 184 cl::aliasopt(DynamicTable), cl::NotHidden); 185 cl::alias DynamicTableAlias("dynamic", cl::desc("Alias for --dynamic-table"), 186 cl::aliasopt(DynamicTable)); 187 188 // --needed-libs 189 cl::opt<bool> NeededLibraries("needed-libs", 190 cl::desc("Display the needed libraries")); 191 192 // --program-headers, --segments, -l 193 cl::opt<bool> ProgramHeaders("program-headers", 194 cl::desc("Display ELF program headers")); 195 cl::alias ProgramHeadersShort("l", cl::desc("Alias for --program-headers"), 196 cl::aliasopt(ProgramHeaders), cl::NotHidden); 197 cl::alias SegmentsAlias("segments", cl::desc("Alias for --program-headers"), 198 cl::aliasopt(ProgramHeaders)); 199 200 // --string-dump, -p 201 cl::list<std::string> StringDump( 202 "string-dump", cl::value_desc("number|name"), 203 cl::desc("Display the specified section(s) as a list of strings"), 204 cl::ZeroOrMore); 205 cl::alias StringDumpShort("p", cl::desc("Alias for --string-dump"), 206 cl::aliasopt(StringDump), cl::Prefix, 207 cl::NotHidden); 208 209 // --hex-dump, -x 210 cl::list<std::string> 211 HexDump("hex-dump", cl::value_desc("number|name"), 212 cl::desc("Display the specified section(s) as hexadecimal bytes"), 213 cl::ZeroOrMore); 214 cl::alias HexDumpShort("x", cl::desc("Alias for --hex-dump"), 215 cl::aliasopt(HexDump), cl::Prefix, cl::NotHidden); 216 217 // --demangle, -C 218 cl::opt<bool> Demangle("demangle", 219 cl::desc("Demangle symbol names in output")); 220 cl::alias DemangleShort("C", cl::desc("Alias for --demangle"), 221 cl::aliasopt(Demangle), cl::NotHidden); 222 223 // --hash-table 224 cl::opt<bool> HashTable("hash-table", 225 cl::desc("Display ELF hash table")); 226 227 // --gnu-hash-table 228 cl::opt<bool> GnuHashTable("gnu-hash-table", 229 cl::desc("Display ELF .gnu.hash section")); 230 231 // --expand-relocs 232 cl::opt<bool> ExpandRelocs("expand-relocs", 233 cl::desc("Expand each shown relocation to multiple lines")); 234 235 // --raw-relr 236 cl::opt<bool> RawRelr("raw-relr", 237 cl::desc("Do not decode relocations in SHT_RELR section, display raw contents")); 238 239 // --codeview 240 cl::opt<bool> CodeView("codeview", 241 cl::desc("Display CodeView debug information")); 242 243 // --codeview-merged-types 244 cl::opt<bool> 245 CodeViewMergedTypes("codeview-merged-types", 246 cl::desc("Display the merged CodeView type stream")); 247 248 // --codeview-ghash 249 cl::opt<bool> CodeViewEnableGHash( 250 "codeview-ghash", 251 cl::desc( 252 "Enable global hashing for CodeView type stream de-duplication")); 253 254 // --codeview-subsection-bytes 255 cl::opt<bool> CodeViewSubsectionBytes( 256 "codeview-subsection-bytes", 257 cl::desc("Dump raw contents of codeview debug sections and records")); 258 259 // --arch-specific 260 cl::opt<bool> ArchSpecificInfo("arch-specific", 261 cl::desc("Displays architecture-specific information, if there is any.")); 262 cl::alias ArchSpecifcInfoShort("A", cl::desc("Alias for --arch-specific"), 263 cl::aliasopt(ArchSpecificInfo), cl::NotHidden); 264 265 // --coff-imports 266 cl::opt<bool> 267 COFFImports("coff-imports", cl::desc("Display the PE/COFF import table")); 268 269 // --coff-exports 270 cl::opt<bool> 271 COFFExports("coff-exports", cl::desc("Display the PE/COFF export table")); 272 273 // --coff-directives 274 cl::opt<bool> 275 COFFDirectives("coff-directives", 276 cl::desc("Display the PE/COFF .drectve section")); 277 278 // --coff-basereloc 279 cl::opt<bool> 280 COFFBaseRelocs("coff-basereloc", 281 cl::desc("Display the PE/COFF .reloc section")); 282 283 // --coff-debug-directory 284 cl::opt<bool> 285 COFFDebugDirectory("coff-debug-directory", 286 cl::desc("Display the PE/COFF debug directory")); 287 288 // --coff-tls-directory 289 cl::opt<bool> COFFTLSDirectory("coff-tls-directory", 290 cl::desc("Display the PE/COFF TLS directory")); 291 292 // --coff-resources 293 cl::opt<bool> COFFResources("coff-resources", 294 cl::desc("Display the PE/COFF .rsrc section")); 295 296 // --coff-load-config 297 cl::opt<bool> 298 COFFLoadConfig("coff-load-config", 299 cl::desc("Display the PE/COFF load config")); 300 301 // --elf-linker-options 302 cl::opt<bool> 303 ELFLinkerOptions("elf-linker-options", 304 cl::desc("Display the ELF .linker-options section")); 305 306 // --macho-data-in-code 307 cl::opt<bool> 308 MachODataInCode("macho-data-in-code", 309 cl::desc("Display MachO Data in Code command")); 310 311 // --macho-indirect-symbols 312 cl::opt<bool> 313 MachOIndirectSymbols("macho-indirect-symbols", 314 cl::desc("Display MachO indirect symbols")); 315 316 // --macho-linker-options 317 cl::opt<bool> 318 MachOLinkerOptions("macho-linker-options", 319 cl::desc("Display MachO linker options")); 320 321 // --macho-segment 322 cl::opt<bool> 323 MachOSegment("macho-segment", 324 cl::desc("Display MachO Segment command")); 325 326 // --macho-version-min 327 cl::opt<bool> 328 MachOVersionMin("macho-version-min", 329 cl::desc("Display MachO version min command")); 330 331 // --macho-dysymtab 332 cl::opt<bool> 333 MachODysymtab("macho-dysymtab", 334 cl::desc("Display MachO Dysymtab command")); 335 336 // --stackmap 337 cl::opt<bool> 338 PrintStackMap("stackmap", 339 cl::desc("Display contents of stackmap section")); 340 341 // --stack-sizes 342 cl::opt<bool> 343 PrintStackSizes("stack-sizes", 344 cl::desc("Display contents of all stack sizes sections")); 345 346 // --version-info, -V 347 cl::opt<bool> 348 VersionInfo("version-info", 349 cl::desc("Display ELF version sections (if present)")); 350 cl::alias VersionInfoShort("V", cl::desc("Alias for -version-info"), 351 cl::aliasopt(VersionInfo), cl::NotHidden); 352 353 // --elf-section-groups, --section-groups, -g 354 cl::opt<bool> SectionGroups("elf-section-groups", 355 cl::desc("Display ELF section group contents")); 356 cl::alias SectionGroupsAlias("section-groups", 357 cl::desc("Alias for -elf-sections-groups"), 358 cl::aliasopt(SectionGroups)); 359 cl::alias SectionGroupsShort("g", cl::desc("Alias for -elf-sections-groups"), 360 cl::aliasopt(SectionGroups), cl::NotHidden); 361 362 // --elf-hash-histogram, --histogram, -I 363 cl::opt<bool> HashHistogram( 364 "elf-hash-histogram", 365 cl::desc("Display bucket list histogram for hash sections")); 366 cl::alias HashHistogramShort("I", cl::desc("Alias for -elf-hash-histogram"), 367 cl::aliasopt(HashHistogram), cl::NotHidden); 368 cl::alias HistogramAlias("histogram", 369 cl::desc("Alias for --elf-hash-histogram"), 370 cl::aliasopt(HashHistogram)); 371 372 // --cg-profile 373 cl::opt<bool> CGProfile("cg-profile", 374 cl::desc("Display callgraph profile section")); 375 cl::alias ELFCGProfile("elf-cg-profile", cl::desc("Alias for --cg-profile"), 376 cl::aliasopt(CGProfile)); 377 378 // --bb-addr-map 379 cl::opt<bool> BBAddrMap("bb-addr-map", 380 cl::desc("Display the BB address map section")); 381 382 // -addrsig 383 cl::opt<bool> Addrsig("addrsig", 384 cl::desc("Display address-significance table")); 385 386 // -elf-output-style 387 cl::opt<OutputStyleTy> 388 Output("elf-output-style", cl::desc("Specify ELF dump style"), 389 cl::values(clEnumVal(LLVM, "LLVM default style"), 390 clEnumVal(GNU, "GNU readelf style")), 391 cl::init(LLVM)); 392 393 cl::extrahelp 394 HelpResponse("\nPass @FILE as argument to read options from FILE.\n"); 395 } // namespace opts 396 397 static StringRef ToolName; 398 399 namespace llvm { 400 401 LLVM_ATTRIBUTE_NORETURN static void error(Twine Msg) { 402 // Flush the standard output to print the error at a 403 // proper place. 404 fouts().flush(); 405 WithColor::error(errs(), ToolName) << Msg << "\n"; 406 exit(1); 407 } 408 409 LLVM_ATTRIBUTE_NORETURN void reportError(Error Err, StringRef Input) { 410 assert(Err); 411 if (Input == "-") 412 Input = "<stdin>"; 413 handleAllErrors(createFileError(Input, std::move(Err)), 414 [&](const ErrorInfoBase &EI) { error(EI.message()); }); 415 llvm_unreachable("error() call should never return"); 416 } 417 418 void reportWarning(Error Err, StringRef Input) { 419 assert(Err); 420 if (Input == "-") 421 Input = "<stdin>"; 422 423 // Flush the standard output to print the warning at a 424 // proper place. 425 fouts().flush(); 426 handleAllErrors( 427 createFileError(Input, std::move(Err)), [&](const ErrorInfoBase &EI) { 428 WithColor::warning(errs(), ToolName) << EI.message() << "\n"; 429 }); 430 } 431 432 } // namespace llvm 433 434 namespace { 435 struct ReadObjTypeTableBuilder { 436 ReadObjTypeTableBuilder() 437 : Allocator(), IDTable(Allocator), TypeTable(Allocator), 438 GlobalIDTable(Allocator), GlobalTypeTable(Allocator) {} 439 440 llvm::BumpPtrAllocator Allocator; 441 llvm::codeview::MergingTypeTableBuilder IDTable; 442 llvm::codeview::MergingTypeTableBuilder TypeTable; 443 llvm::codeview::GlobalTypeTableBuilder GlobalIDTable; 444 llvm::codeview::GlobalTypeTableBuilder GlobalTypeTable; 445 std::vector<OwningBinary<Binary>> Binaries; 446 }; 447 } // namespace 448 static ReadObjTypeTableBuilder CVTypes; 449 450 /// Creates an format-specific object file dumper. 451 static Expected<std::unique_ptr<ObjDumper>> 452 createDumper(const ObjectFile &Obj, ScopedPrinter &Writer) { 453 if (const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(&Obj)) 454 return createCOFFDumper(*COFFObj, Writer); 455 456 if (const ELFObjectFileBase *ELFObj = dyn_cast<ELFObjectFileBase>(&Obj)) 457 return createELFDumper(*ELFObj, Writer); 458 459 if (const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(&Obj)) 460 return createMachODumper(*MachOObj, Writer); 461 462 if (const WasmObjectFile *WasmObj = dyn_cast<WasmObjectFile>(&Obj)) 463 return createWasmDumper(*WasmObj, Writer); 464 465 if (const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(&Obj)) 466 return createXCOFFDumper(*XObj, Writer); 467 468 return createStringError(errc::invalid_argument, 469 "unsupported object file format"); 470 } 471 472 /// Dumps the specified object file. 473 static void dumpObject(ObjectFile &Obj, ScopedPrinter &Writer, 474 const Archive *A = nullptr) { 475 std::string FileStr = 476 A ? Twine(A->getFileName() + "(" + Obj.getFileName() + ")").str() 477 : Obj.getFileName().str(); 478 479 std::string ContentErrString; 480 if (Error ContentErr = Obj.initContent()) 481 ContentErrString = "unable to continue dumping, the file is corrupt: " + 482 toString(std::move(ContentErr)); 483 484 ObjDumper *Dumper; 485 Expected<std::unique_ptr<ObjDumper>> DumperOrErr = createDumper(Obj, Writer); 486 if (!DumperOrErr) 487 reportError(DumperOrErr.takeError(), FileStr); 488 Dumper = (*DumperOrErr).get(); 489 490 if (opts::Output == opts::LLVM || opts::InputFilenames.size() > 1 || A) { 491 Writer.startLine() << "\n"; 492 Writer.printString("File", FileStr); 493 } 494 if (opts::Output == opts::LLVM) { 495 Writer.printString("Format", Obj.getFileFormatName()); 496 Writer.printString("Arch", Triple::getArchTypeName(Obj.getArch())); 497 Writer.printString( 498 "AddressSize", 499 std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress()))); 500 Dumper->printLoadName(); 501 } 502 503 if (opts::FileHeaders) 504 Dumper->printFileHeaders(); 505 506 // This is only used for ELF currently. In some cases, when an object is 507 // corrupt (e.g. truncated), we can't dump anything except the file header. 508 if (!ContentErrString.empty()) 509 reportError(createError(ContentErrString), FileStr); 510 511 if (opts::SectionDetails || opts::SectionHeaders) { 512 if (opts::Output == opts::GNU && opts::SectionDetails) 513 Dumper->printSectionDetails(); 514 else 515 Dumper->printSectionHeaders(); 516 } 517 518 if (opts::HashSymbols) 519 Dumper->printHashSymbols(); 520 if (opts::ProgramHeaders || opts::SectionMapping == cl::BOU_TRUE) 521 Dumper->printProgramHeaders(opts::ProgramHeaders, opts::SectionMapping); 522 if (opts::DynamicTable) 523 Dumper->printDynamicTable(); 524 if (opts::NeededLibraries) 525 Dumper->printNeededLibraries(); 526 if (opts::Relocations) 527 Dumper->printRelocations(); 528 if (opts::DynRelocs) 529 Dumper->printDynamicRelocations(); 530 if (opts::UnwindInfo) 531 Dumper->printUnwindInfo(); 532 if (opts::Symbols || opts::DynamicSymbols) 533 Dumper->printSymbols(opts::Symbols, opts::DynamicSymbols); 534 if (!opts::StringDump.empty()) 535 Dumper->printSectionsAsString(Obj, opts::StringDump); 536 if (!opts::HexDump.empty()) 537 Dumper->printSectionsAsHex(Obj, opts::HexDump); 538 if (opts::HashTable) 539 Dumper->printHashTable(); 540 if (opts::GnuHashTable) 541 Dumper->printGnuHashTable(); 542 if (opts::VersionInfo) 543 Dumper->printVersionInfo(); 544 if (Obj.isELF()) { 545 if (opts::DependentLibraries) 546 Dumper->printDependentLibs(); 547 if (opts::ELFLinkerOptions) 548 Dumper->printELFLinkerOptions(); 549 if (opts::ArchSpecificInfo) 550 Dumper->printArchSpecificInfo(); 551 if (opts::SectionGroups) 552 Dumper->printGroupSections(); 553 if (opts::HashHistogram) 554 Dumper->printHashHistograms(); 555 if (opts::CGProfile) 556 Dumper->printCGProfile(); 557 if (opts::BBAddrMap) 558 Dumper->printBBAddrMaps(); 559 if (opts::Addrsig) 560 Dumper->printAddrsig(); 561 if (opts::Notes) 562 Dumper->printNotes(); 563 } 564 if (Obj.isCOFF()) { 565 if (opts::COFFImports) 566 Dumper->printCOFFImports(); 567 if (opts::COFFExports) 568 Dumper->printCOFFExports(); 569 if (opts::COFFDirectives) 570 Dumper->printCOFFDirectives(); 571 if (opts::COFFBaseRelocs) 572 Dumper->printCOFFBaseReloc(); 573 if (opts::COFFDebugDirectory) 574 Dumper->printCOFFDebugDirectory(); 575 if (opts::COFFTLSDirectory) 576 Dumper->printCOFFTLSDirectory(); 577 if (opts::COFFResources) 578 Dumper->printCOFFResources(); 579 if (opts::COFFLoadConfig) 580 Dumper->printCOFFLoadConfig(); 581 if (opts::CGProfile) 582 Dumper->printCGProfile(); 583 if (opts::Addrsig) 584 Dumper->printAddrsig(); 585 if (opts::CodeView) 586 Dumper->printCodeViewDebugInfo(); 587 if (opts::CodeViewMergedTypes) 588 Dumper->mergeCodeViewTypes(CVTypes.IDTable, CVTypes.TypeTable, 589 CVTypes.GlobalIDTable, CVTypes.GlobalTypeTable, 590 opts::CodeViewEnableGHash); 591 } 592 if (Obj.isMachO()) { 593 if (opts::MachODataInCode) 594 Dumper->printMachODataInCode(); 595 if (opts::MachOIndirectSymbols) 596 Dumper->printMachOIndirectSymbols(); 597 if (opts::MachOLinkerOptions) 598 Dumper->printMachOLinkerOptions(); 599 if (opts::MachOSegment) 600 Dumper->printMachOSegment(); 601 if (opts::MachOVersionMin) 602 Dumper->printMachOVersionMin(); 603 if (opts::MachODysymtab) 604 Dumper->printMachODysymtab(); 605 } 606 if (opts::PrintStackMap) 607 Dumper->printStackMap(); 608 if (opts::PrintStackSizes) 609 Dumper->printStackSizes(); 610 } 611 612 /// Dumps each object file in \a Arc; 613 static void dumpArchive(const Archive *Arc, ScopedPrinter &Writer) { 614 Error Err = Error::success(); 615 for (auto &Child : Arc->children(Err)) { 616 Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary(); 617 if (!ChildOrErr) { 618 if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) 619 reportError(std::move(E), Arc->getFileName()); 620 continue; 621 } 622 623 Binary *Bin = ChildOrErr->get(); 624 if (ObjectFile *Obj = dyn_cast<ObjectFile>(Bin)) 625 dumpObject(*Obj, Writer, Arc); 626 else if (COFFImportFile *Imp = dyn_cast<COFFImportFile>(Bin)) 627 dumpCOFFImportFile(Imp, Writer); 628 else 629 reportWarning(createStringError(errc::invalid_argument, 630 Bin->getFileName() + 631 " has an unsupported file type"), 632 Arc->getFileName()); 633 } 634 if (Err) 635 reportError(std::move(Err), Arc->getFileName()); 636 } 637 638 /// Dumps each object file in \a MachO Universal Binary; 639 static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary, 640 ScopedPrinter &Writer) { 641 for (const MachOUniversalBinary::ObjectForArch &Obj : UBinary->objects()) { 642 Expected<std::unique_ptr<MachOObjectFile>> ObjOrErr = Obj.getAsObjectFile(); 643 if (ObjOrErr) 644 dumpObject(*ObjOrErr.get(), Writer); 645 else if (auto E = isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) 646 reportError(ObjOrErr.takeError(), UBinary->getFileName()); 647 else if (Expected<std::unique_ptr<Archive>> AOrErr = Obj.getAsArchive()) 648 dumpArchive(&*AOrErr.get(), Writer); 649 } 650 } 651 652 /// Dumps \a WinRes, Windows Resource (.res) file; 653 static void dumpWindowsResourceFile(WindowsResource *WinRes, 654 ScopedPrinter &Printer) { 655 WindowsRes::Dumper Dumper(WinRes, Printer); 656 if (auto Err = Dumper.printData()) 657 reportError(std::move(Err), WinRes->getFileName()); 658 } 659 660 661 /// Opens \a File and dumps it. 662 static void dumpInput(StringRef File, ScopedPrinter &Writer) { 663 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = 664 MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false, 665 /*RequiresNullTerminator=*/false); 666 if (std::error_code EC = FileOrErr.getError()) 667 return reportError(errorCodeToError(EC), File); 668 669 std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get(); 670 file_magic Type = identify_magic(Buffer->getBuffer()); 671 if (Type == file_magic::bitcode) { 672 reportWarning(createStringError(errc::invalid_argument, 673 "bitcode files are not supported"), 674 File); 675 return; 676 } 677 678 Expected<std::unique_ptr<Binary>> BinaryOrErr = createBinary( 679 Buffer->getMemBufferRef(), /*Context=*/nullptr, /*InitContent=*/false); 680 if (!BinaryOrErr) 681 reportError(BinaryOrErr.takeError(), File); 682 683 std::unique_ptr<Binary> Bin = std::move(*BinaryOrErr); 684 if (Archive *Arc = dyn_cast<Archive>(Bin.get())) 685 dumpArchive(Arc, Writer); 686 else if (MachOUniversalBinary *UBinary = 687 dyn_cast<MachOUniversalBinary>(Bin.get())) 688 dumpMachOUniversalBinary(UBinary, Writer); 689 else if (ObjectFile *Obj = dyn_cast<ObjectFile>(Bin.get())) 690 dumpObject(*Obj, Writer); 691 else if (COFFImportFile *Import = dyn_cast<COFFImportFile>(Bin.get())) 692 dumpCOFFImportFile(Import, Writer); 693 else if (WindowsResource *WinRes = dyn_cast<WindowsResource>(Bin.get())) 694 dumpWindowsResourceFile(WinRes, Writer); 695 else 696 llvm_unreachable("unrecognized file type"); 697 698 CVTypes.Binaries.push_back( 699 OwningBinary<Binary>(std::move(Bin), std::move(Buffer))); 700 } 701 702 /// Registers aliases that should only be allowed by readobj. 703 static void registerReadobjAliases() { 704 // The following two-letter aliases are only provided for readobj, as readelf 705 // allows single-letter args to be grouped together. 706 static cl::alias SectionRelocationsShort( 707 "sr", cl::desc("Alias for --section-relocations"), 708 cl::aliasopt(opts::SectionRelocations)); 709 static cl::alias SectionDataShort("sd", cl::desc("Alias for --section-data"), 710 cl::aliasopt(opts::SectionData)); 711 static cl::alias SectionSymbolsShort("st", 712 cl::desc("Alias for --section-symbols"), 713 cl::aliasopt(opts::SectionSymbols)); 714 static cl::alias DynamicSymbolsShort("dt", 715 cl::desc("Alias for --dyn-symbols"), 716 cl::aliasopt(opts::DynamicSymbols)); 717 } 718 719 /// Registers aliases that should only be allowed by readelf. 720 static void registerReadelfAliases() { 721 // Allow all single letter flags to be grouped together. 722 for (auto &OptEntry : cl::getRegisteredOptions()) { 723 StringRef ArgName = OptEntry.getKey(); 724 cl::Option *Option = OptEntry.getValue(); 725 if (ArgName.size() == 1) 726 apply(Option, cl::Grouping); 727 } 728 } 729 730 int main(int argc, const char *argv[]) { 731 InitLLVM X(argc, argv); 732 ToolName = argv[0]; 733 734 // Register the target printer for --version. 735 cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); 736 737 if (sys::path::stem(argv[0]).contains("readelf")) { 738 opts::Output = opts::GNU; 739 registerReadelfAliases(); 740 } else { 741 registerReadobjAliases(); 742 } 743 744 cl::ParseCommandLineOptions(argc, argv, "LLVM Object Reader\n"); 745 746 // Default to print error if no filename is specified. 747 if (opts::InputFilenames.empty()) { 748 error("no input files specified"); 749 } 750 751 if (opts::All) { 752 opts::FileHeaders = true; 753 opts::ProgramHeaders = true; 754 opts::SectionHeaders = true; 755 opts::Symbols = true; 756 opts::Relocations = true; 757 opts::DynamicTable = true; 758 opts::Notes = true; 759 opts::VersionInfo = true; 760 opts::UnwindInfo = true; 761 opts::SectionGroups = true; 762 opts::HashHistogram = true; 763 if (opts::Output == opts::LLVM) { 764 opts::Addrsig = true; 765 opts::PrintStackSizes = true; 766 } 767 } 768 769 if (opts::Headers) { 770 opts::FileHeaders = true; 771 opts::ProgramHeaders = true; 772 opts::SectionHeaders = true; 773 } 774 775 ScopedPrinter Writer(fouts()); 776 for (const std::string &I : opts::InputFilenames) 777 dumpInput(I, Writer); 778 779 if (opts::CodeViewMergedTypes) { 780 if (opts::CodeViewEnableGHash) 781 dumpCodeViewMergedTypes(Writer, CVTypes.GlobalIDTable.records(), 782 CVTypes.GlobalTypeTable.records()); 783 else 784 dumpCodeViewMergedTypes(Writer, CVTypes.IDTable.records(), 785 CVTypes.TypeTable.records()); 786 } 787 788 return 0; 789 } 790