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