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