1//===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This program is a utility that works like binutils "objdump", that is, it
11// dumps out a plethora of information about an object file depending on the
12// flags.
13//
14// The flags and output of this program should be near identical to those of
15// binutils objdump.
16//
17//===----------------------------------------------------------------------===//
18
19#include "llvm-objdump.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/StringExtras.h"
22#include "llvm/ADT/Triple.h"
23#include "llvm/MC/MCAsmInfo.h"
24#include "llvm/MC/MCContext.h"
25#include "llvm/MC/MCDisassembler.h"
26#include "llvm/MC/MCInst.h"
27#include "llvm/MC/MCInstPrinter.h"
28#include "llvm/MC/MCInstrAnalysis.h"
29#include "llvm/MC/MCInstrInfo.h"
30#include "llvm/MC/MCObjectFileInfo.h"
31#include "llvm/MC/MCRegisterInfo.h"
32#include "llvm/MC/MCRelocationInfo.h"
33#include "llvm/MC/MCSubtargetInfo.h"
34#include "llvm/Object/Archive.h"
35#include "llvm/Object/COFF.h"
36#include "llvm/Object/MachO.h"
37#include "llvm/Object/ObjectFile.h"
38#include "llvm/Support/Casting.h"
39#include "llvm/Support/CommandLine.h"
40#include "llvm/Support/Debug.h"
41#include "llvm/Support/FileSystem.h"
42#include "llvm/Support/Format.h"
43#include "llvm/Support/GraphWriter.h"
44#include "llvm/Support/Host.h"
45#include "llvm/Support/ManagedStatic.h"
46#include "llvm/Support/MemoryBuffer.h"
47#include "llvm/Support/PrettyStackTrace.h"
48#include "llvm/Support/Signals.h"
49#include "llvm/Support/SourceMgr.h"
50#include "llvm/Support/TargetRegistry.h"
51#include "llvm/Support/TargetSelect.h"
52#include "llvm/Support/raw_ostream.h"
53#include <algorithm>
54#include <cctype>
55#include <cstring>
56#include <system_error>
57
58using namespace llvm;
59using namespace object;
60
61static cl::list<std::string>
62InputFilenames(cl::Positional, cl::desc("<input object files>"),cl::ZeroOrMore);
63
64cl::opt<bool>
65llvm::Disassemble("disassemble",
66  cl::desc("Display assembler mnemonics for the machine instructions"));
67static cl::alias
68Disassembled("d", cl::desc("Alias for --disassemble"),
69             cl::aliasopt(Disassemble));
70
71cl::opt<bool>
72llvm::Relocations("r", cl::desc("Display the relocation entries in the file"));
73
74cl::opt<bool>
75llvm::SectionContents("s", cl::desc("Display the content of each section"));
76
77cl::opt<bool>
78llvm::SymbolTable("t", cl::desc("Display the symbol table"));
79
80cl::opt<bool>
81llvm::ExportsTrie("exports-trie", cl::desc("Display mach-o exported symbols"));
82
83cl::opt<bool>
84llvm::Rebase("rebase", cl::desc("Display mach-o rebasing info"));
85
86cl::opt<bool>
87llvm::Bind("bind", cl::desc("Display mach-o binding info"));
88
89cl::opt<bool>
90llvm::LazyBind("lazy-bind", cl::desc("Display mach-o lazy binding info"));
91
92cl::opt<bool>
93llvm::WeakBind("weak-bind", cl::desc("Display mach-o weak binding info"));
94
95static cl::opt<bool>
96MachOOpt("macho", cl::desc("Use MachO specific object file parser"));
97static cl::alias
98MachOm("m", cl::desc("Alias for --macho"), cl::aliasopt(MachOOpt));
99
100cl::opt<std::string>
101llvm::TripleName("triple", cl::desc("Target triple to disassemble for, "
102                                    "see -version for available targets"));
103
104cl::opt<std::string>
105llvm::MCPU("mcpu",
106     cl::desc("Target a specific cpu type (-mcpu=help for details)"),
107     cl::value_desc("cpu-name"),
108     cl::init(""));
109
110cl::opt<std::string>
111llvm::ArchName("arch-name", cl::desc("Target arch to disassemble for, "
112                                "see -version for available targets"));
113
114cl::opt<bool>
115llvm::SectionHeaders("section-headers", cl::desc("Display summaries of the "
116                                                 "headers for each section."));
117static cl::alias
118SectionHeadersShort("headers", cl::desc("Alias for --section-headers"),
119                    cl::aliasopt(SectionHeaders));
120static cl::alias
121SectionHeadersShorter("h", cl::desc("Alias for --section-headers"),
122                      cl::aliasopt(SectionHeaders));
123
124cl::list<std::string>
125llvm::MAttrs("mattr",
126  cl::CommaSeparated,
127  cl::desc("Target specific attributes"),
128  cl::value_desc("a1,+a2,-a3,..."));
129
130cl::opt<bool>
131llvm::NoShowRawInsn("no-show-raw-insn", cl::desc("When disassembling "
132                                                 "instructions, do not print "
133                                                 "the instruction bytes."));
134
135cl::opt<bool>
136llvm::UnwindInfo("unwind-info", cl::desc("Display unwind information"));
137
138static cl::alias
139UnwindInfoShort("u", cl::desc("Alias for --unwind-info"),
140                cl::aliasopt(UnwindInfo));
141
142cl::opt<bool>
143llvm::PrivateHeaders("private-headers",
144                     cl::desc("Display format specific file headers"));
145
146static cl::alias
147PrivateHeadersShort("p", cl::desc("Alias for --private-headers"),
148                    cl::aliasopt(PrivateHeaders));
149
150static StringRef ToolName;
151static int ReturnValue = EXIT_SUCCESS;
152
153bool llvm::error(std::error_code EC) {
154  if (!EC)
155    return false;
156
157  outs() << ToolName << ": error reading file: " << EC.message() << ".\n";
158  outs().flush();
159  ReturnValue = EXIT_FAILURE;
160  return true;
161}
162
163static const Target *getTarget(const ObjectFile *Obj = nullptr) {
164  // Figure out the target triple.
165  llvm::Triple TheTriple("unknown-unknown-unknown");
166  if (TripleName.empty()) {
167    if (Obj) {
168      TheTriple.setArch(Triple::ArchType(Obj->getArch()));
169      // TheTriple defaults to ELF, and COFF doesn't have an environment:
170      // the best we can do here is indicate that it is mach-o.
171      if (Obj->isMachO())
172        TheTriple.setObjectFormat(Triple::MachO);
173
174      if (Obj->isCOFF()) {
175        const auto COFFObj = dyn_cast<COFFObjectFile>(Obj);
176        if (COFFObj->getArch() == Triple::thumb)
177          TheTriple.setTriple("thumbv7-windows");
178      }
179    }
180  } else
181    TheTriple.setTriple(Triple::normalize(TripleName));
182
183  // Get the target specific parser.
184  std::string Error;
185  const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple,
186                                                         Error);
187  if (!TheTarget) {
188    errs() << ToolName << ": " << Error;
189    return nullptr;
190  }
191
192  // Update the triple name and return the found target.
193  TripleName = TheTriple.getTriple();
194  return TheTarget;
195}
196
197void llvm::DumpBytes(ArrayRef<uint8_t> bytes) {
198  static const char hex_rep[] = "0123456789abcdef";
199  SmallString<64> output;
200
201  for (char i: bytes) {
202    output.push_back(hex_rep[(i & 0xF0) >> 4]);
203    output.push_back(hex_rep[i & 0xF]);
204    output.push_back(' ');
205  }
206
207  outs() << output.c_str();
208}
209
210bool llvm::RelocAddressLess(RelocationRef a, RelocationRef b) {
211  uint64_t a_addr, b_addr;
212  if (error(a.getOffset(a_addr))) return false;
213  if (error(b.getOffset(b_addr))) return false;
214  return a_addr < b_addr;
215}
216
217static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
218  const Target *TheTarget = getTarget(Obj);
219  // getTarget() will have already issued a diagnostic if necessary, so
220  // just bail here if it failed.
221  if (!TheTarget)
222    return;
223
224  // Package up features to be passed to target/subtarget
225  std::string FeaturesStr;
226  if (MAttrs.size()) {
227    SubtargetFeatures Features;
228    for (unsigned i = 0; i != MAttrs.size(); ++i)
229      Features.AddFeature(MAttrs[i]);
230    FeaturesStr = Features.getString();
231  }
232
233  std::unique_ptr<const MCRegisterInfo> MRI(
234      TheTarget->createMCRegInfo(TripleName));
235  if (!MRI) {
236    errs() << "error: no register info for target " << TripleName << "\n";
237    return;
238  }
239
240  // Set up disassembler.
241  std::unique_ptr<const MCAsmInfo> AsmInfo(
242      TheTarget->createMCAsmInfo(*MRI, TripleName));
243  if (!AsmInfo) {
244    errs() << "error: no assembly info for target " << TripleName << "\n";
245    return;
246  }
247
248  std::unique_ptr<const MCSubtargetInfo> STI(
249      TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr));
250  if (!STI) {
251    errs() << "error: no subtarget info for target " << TripleName << "\n";
252    return;
253  }
254
255  std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
256  if (!MII) {
257    errs() << "error: no instruction info for target " << TripleName << "\n";
258    return;
259  }
260
261  std::unique_ptr<const MCObjectFileInfo> MOFI(new MCObjectFileInfo);
262  MCContext Ctx(AsmInfo.get(), MRI.get(), MOFI.get());
263
264  std::unique_ptr<MCDisassembler> DisAsm(
265    TheTarget->createMCDisassembler(*STI, Ctx));
266
267  if (!DisAsm) {
268    errs() << "error: no disassembler for target " << TripleName << "\n";
269    return;
270  }
271
272  std::unique_ptr<const MCInstrAnalysis> MIA(
273      TheTarget->createMCInstrAnalysis(MII.get()));
274
275  int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
276  std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
277      Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
278  if (!IP) {
279    errs() << "error: no instruction printer for target " << TripleName
280      << '\n';
281    return;
282  }
283
284  StringRef Fmt = Obj->getBytesInAddress() > 4 ? "\t\t%016" PRIx64 ":  " :
285                                                 "\t\t\t%08" PRIx64 ":  ";
286
287  // Create a mapping, RelocSecs = SectionRelocMap[S], where sections
288  // in RelocSecs contain the relocations for section S.
289  std::error_code EC;
290  std::map<SectionRef, SmallVector<SectionRef, 1>> SectionRelocMap;
291  for (const SectionRef &Section : Obj->sections()) {
292    section_iterator Sec2 = Section.getRelocatedSection();
293    if (Sec2 != Obj->section_end())
294      SectionRelocMap[*Sec2].push_back(Section);
295  }
296
297  for (const SectionRef &Section : Obj->sections()) {
298    if (!Section.isText() || Section.isVirtual())
299      continue;
300
301    uint64_t SectionAddr = Section.getAddress();
302    uint64_t SectSize = Section.getSize();
303    if (!SectSize)
304      continue;
305
306    // Make a list of all the symbols in this section.
307    std::vector<std::pair<uint64_t, StringRef>> Symbols;
308    for (const SymbolRef &Symbol : Obj->symbols()) {
309      if (Section.containsSymbol(Symbol)) {
310        uint64_t Address;
311        if (error(Symbol.getAddress(Address)))
312          break;
313        if (Address == UnknownAddressOrSize)
314          continue;
315        Address -= SectionAddr;
316        if (Address >= SectSize)
317          continue;
318
319        StringRef Name;
320        if (error(Symbol.getName(Name)))
321          break;
322        Symbols.push_back(std::make_pair(Address, Name));
323      }
324    }
325
326    // Sort the symbols by address, just in case they didn't come in that way.
327    array_pod_sort(Symbols.begin(), Symbols.end());
328
329    // Make a list of all the relocations for this section.
330    std::vector<RelocationRef> Rels;
331    if (InlineRelocs) {
332      for (const SectionRef &RelocSec : SectionRelocMap[Section]) {
333        for (const RelocationRef &Reloc : RelocSec.relocations()) {
334          Rels.push_back(Reloc);
335        }
336      }
337    }
338
339    // Sort relocations by address.
340    std::sort(Rels.begin(), Rels.end(), RelocAddressLess);
341
342    StringRef SegmentName = "";
343    if (const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj)) {
344      DataRefImpl DR = Section.getRawDataRefImpl();
345      SegmentName = MachO->getSectionFinalSegmentName(DR);
346    }
347    StringRef name;
348    if (error(Section.getName(name)))
349      break;
350    outs() << "Disassembly of section ";
351    if (!SegmentName.empty())
352      outs() << SegmentName << ",";
353    outs() << name << ':';
354
355    // If the section has no symbols just insert a dummy one and disassemble
356    // the whole section.
357    if (Symbols.empty())
358      Symbols.push_back(std::make_pair(0, name));
359
360
361    SmallString<40> Comments;
362    raw_svector_ostream CommentStream(Comments);
363
364    StringRef BytesStr;
365    if (error(Section.getContents(BytesStr)))
366      break;
367    ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
368                            BytesStr.size());
369
370    uint64_t Size;
371    uint64_t Index;
372
373    std::vector<RelocationRef>::const_iterator rel_cur = Rels.begin();
374    std::vector<RelocationRef>::const_iterator rel_end = Rels.end();
375    // Disassemble symbol by symbol.
376    for (unsigned si = 0, se = Symbols.size(); si != se; ++si) {
377
378      uint64_t Start = Symbols[si].first;
379      // The end is either the section end or the beginning of the next symbol.
380      uint64_t End = (si == se - 1) ? SectSize : Symbols[si + 1].first;
381      // If this symbol has the same address as the next symbol, then skip it.
382      if (Start == End)
383        continue;
384
385      outs() << '\n' << Symbols[si].second << ":\n";
386
387#ifndef NDEBUG
388      raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
389#else
390      raw_ostream &DebugOut = nulls();
391#endif
392
393      for (Index = Start; Index < End; Index += Size) {
394        MCInst Inst;
395
396        if (DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
397                                   SectionAddr + Index, DebugOut,
398                                   CommentStream)) {
399          outs() << format("%8" PRIx64 ":", SectionAddr + Index);
400          if (!NoShowRawInsn) {
401            outs() << "\t";
402            DumpBytes(ArrayRef<uint8_t>(Bytes.data() + Index, Size));
403          }
404          IP->printInst(&Inst, outs(), "", *STI);
405          outs() << CommentStream.str();
406          Comments.clear();
407          outs() << "\n";
408        } else {
409          errs() << ToolName << ": warning: invalid instruction encoding\n";
410          if (Size == 0)
411            Size = 1; // skip illegible bytes
412        }
413
414        // Print relocation for instruction.
415        while (rel_cur != rel_end) {
416          bool hidden = false;
417          uint64_t addr;
418          SmallString<16> name;
419          SmallString<32> val;
420
421          // If this relocation is hidden, skip it.
422          if (error(rel_cur->getHidden(hidden))) goto skip_print_rel;
423          if (hidden) goto skip_print_rel;
424
425          if (error(rel_cur->getOffset(addr))) goto skip_print_rel;
426          // Stop when rel_cur's address is past the current instruction.
427          if (addr >= Index + Size) break;
428          if (error(rel_cur->getTypeName(name))) goto skip_print_rel;
429          if (error(rel_cur->getValueString(val))) goto skip_print_rel;
430
431          outs() << format(Fmt.data(), SectionAddr + addr) << name
432                 << "\t" << val << "\n";
433
434        skip_print_rel:
435          ++rel_cur;
436        }
437      }
438    }
439  }
440}
441
442void llvm::PrintRelocations(const ObjectFile *Obj) {
443  StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 :
444                                                 "%08" PRIx64;
445  // Regular objdump doesn't print relocations in non-relocatable object
446  // files.
447  if (!Obj->isRelocatableObject())
448    return;
449
450  for (const SectionRef &Section : Obj->sections()) {
451    if (Section.relocation_begin() == Section.relocation_end())
452      continue;
453    StringRef secname;
454    if (error(Section.getName(secname)))
455      continue;
456    outs() << "RELOCATION RECORDS FOR [" << secname << "]:\n";
457    for (const RelocationRef &Reloc : Section.relocations()) {
458      bool hidden;
459      uint64_t address;
460      SmallString<32> relocname;
461      SmallString<32> valuestr;
462      if (error(Reloc.getHidden(hidden)))
463        continue;
464      if (hidden)
465        continue;
466      if (error(Reloc.getTypeName(relocname)))
467        continue;
468      if (error(Reloc.getOffset(address)))
469        continue;
470      if (error(Reloc.getValueString(valuestr)))
471        continue;
472      outs() << format(Fmt.data(), address) << " " << relocname << " "
473             << valuestr << "\n";
474    }
475    outs() << "\n";
476  }
477}
478
479void llvm::PrintSectionHeaders(const ObjectFile *Obj) {
480  outs() << "Sections:\n"
481            "Idx Name          Size      Address          Type\n";
482  unsigned i = 0;
483  for (const SectionRef &Section : Obj->sections()) {
484    StringRef Name;
485    if (error(Section.getName(Name)))
486      return;
487    uint64_t Address = Section.getAddress();
488    uint64_t Size = Section.getSize();
489    bool Text = Section.isText();
490    bool Data = Section.isData();
491    bool BSS = Section.isBSS();
492    std::string Type = (std::string(Text ? "TEXT " : "") +
493                        (Data ? "DATA " : "") + (BSS ? "BSS" : ""));
494    outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n", i,
495                     Name.str().c_str(), Size, Address, Type.c_str());
496    ++i;
497  }
498}
499
500void llvm::PrintSectionContents(const ObjectFile *Obj) {
501  std::error_code EC;
502  for (const SectionRef &Section : Obj->sections()) {
503    StringRef Name;
504    StringRef Contents;
505    if (error(Section.getName(Name)))
506      continue;
507    uint64_t BaseAddr = Section.getAddress();
508    uint64_t Size = Section.getSize();
509    if (!Size)
510      continue;
511
512    outs() << "Contents of section " << Name << ":\n";
513    if (Section.isBSS()) {
514      outs() << format("<skipping contents of bss section at [%04" PRIx64
515                       ", %04" PRIx64 ")>\n",
516                       BaseAddr, BaseAddr + Size);
517      continue;
518    }
519
520    if (error(Section.getContents(Contents)))
521      continue;
522
523    // Dump out the content as hex and printable ascii characters.
524    for (std::size_t addr = 0, end = Contents.size(); addr < end; addr += 16) {
525      outs() << format(" %04" PRIx64 " ", BaseAddr + addr);
526      // Dump line of hex.
527      for (std::size_t i = 0; i < 16; ++i) {
528        if (i != 0 && i % 4 == 0)
529          outs() << ' ';
530        if (addr + i < end)
531          outs() << hexdigit((Contents[addr + i] >> 4) & 0xF, true)
532                 << hexdigit(Contents[addr + i] & 0xF, true);
533        else
534          outs() << "  ";
535      }
536      // Print ascii.
537      outs() << "  ";
538      for (std::size_t i = 0; i < 16 && addr + i < end; ++i) {
539        if (std::isprint(static_cast<unsigned char>(Contents[addr + i]) & 0xFF))
540          outs() << Contents[addr + i];
541        else
542          outs() << ".";
543      }
544      outs() << "\n";
545    }
546  }
547}
548
549static void PrintCOFFSymbolTable(const COFFObjectFile *coff) {
550  for (unsigned SI = 0, SE = coff->getNumberOfSymbols(); SI != SE; ++SI) {
551    ErrorOr<COFFSymbolRef> Symbol = coff->getSymbol(SI);
552    StringRef Name;
553    if (error(Symbol.getError()))
554      return;
555
556    if (error(coff->getSymbolName(*Symbol, Name)))
557      return;
558
559    outs() << "[" << format("%2d", SI) << "]"
560           << "(sec " << format("%2d", int(Symbol->getSectionNumber())) << ")"
561           << "(fl 0x00)" // Flag bits, which COFF doesn't have.
562           << "(ty " << format("%3x", unsigned(Symbol->getType())) << ")"
563           << "(scl " << format("%3x", unsigned(Symbol->getStorageClass())) << ") "
564           << "(nx " << unsigned(Symbol->getNumberOfAuxSymbols()) << ") "
565           << "0x" << format("%08x", unsigned(Symbol->getValue())) << " "
566           << Name << "\n";
567
568    for (unsigned AI = 0, AE = Symbol->getNumberOfAuxSymbols(); AI < AE; ++AI, ++SI) {
569      if (Symbol->isSectionDefinition()) {
570        const coff_aux_section_definition *asd;
571        if (error(coff->getAuxSymbol<coff_aux_section_definition>(SI + 1, asd)))
572          return;
573
574        int32_t AuxNumber = asd->getNumber(Symbol->isBigObj());
575
576        outs() << "AUX "
577               << format("scnlen 0x%x nreloc %d nlnno %d checksum 0x%x "
578                         , unsigned(asd->Length)
579                         , unsigned(asd->NumberOfRelocations)
580                         , unsigned(asd->NumberOfLinenumbers)
581                         , unsigned(asd->CheckSum))
582               << format("assoc %d comdat %d\n"
583                         , unsigned(AuxNumber)
584                         , unsigned(asd->Selection));
585      } else if (Symbol->isFileRecord()) {
586        const char *FileName;
587        if (error(coff->getAuxSymbol<char>(SI + 1, FileName)))
588          return;
589
590        StringRef Name(FileName, Symbol->getNumberOfAuxSymbols() *
591                                     coff->getSymbolTableEntrySize());
592        outs() << "AUX " << Name.rtrim(StringRef("\0", 1))  << '\n';
593
594        SI = SI + Symbol->getNumberOfAuxSymbols();
595        break;
596      } else {
597        outs() << "AUX Unknown\n";
598      }
599    }
600  }
601}
602
603void llvm::PrintSymbolTable(const ObjectFile *o) {
604  outs() << "SYMBOL TABLE:\n";
605
606  if (const COFFObjectFile *coff = dyn_cast<const COFFObjectFile>(o)) {
607    PrintCOFFSymbolTable(coff);
608    return;
609  }
610  for (const SymbolRef &Symbol : o->symbols()) {
611    StringRef Name;
612    uint64_t Address;
613    SymbolRef::Type Type;
614    uint64_t Size;
615    uint32_t Flags = Symbol.getFlags();
616    section_iterator Section = o->section_end();
617    if (error(Symbol.getName(Name)))
618      continue;
619    if (error(Symbol.getAddress(Address)))
620      continue;
621    if (error(Symbol.getType(Type)))
622      continue;
623    if (error(Symbol.getSize(Size)))
624      continue;
625    if (error(Symbol.getSection(Section)))
626      continue;
627
628    bool Global = Flags & SymbolRef::SF_Global;
629    bool Weak = Flags & SymbolRef::SF_Weak;
630    bool Absolute = Flags & SymbolRef::SF_Absolute;
631    bool Common = Flags & SymbolRef::SF_Common;
632
633    if (Common) {
634      uint32_t Alignment;
635      if (error(Symbol.getAlignment(Alignment)))
636        Alignment = 0;
637      Address = Size;
638      Size = Alignment;
639    }
640    if (Address == UnknownAddressOrSize)
641      Address = 0;
642    if (Size == UnknownAddressOrSize)
643      Size = 0;
644    char GlobLoc = ' ';
645    if (Type != SymbolRef::ST_Unknown)
646      GlobLoc = Global ? 'g' : 'l';
647    char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
648                 ? 'd' : ' ';
649    char FileFunc = ' ';
650    if (Type == SymbolRef::ST_File)
651      FileFunc = 'f';
652    else if (Type == SymbolRef::ST_Function)
653      FileFunc = 'F';
654
655    const char *Fmt = o->getBytesInAddress() > 4 ? "%016" PRIx64 :
656                                                   "%08" PRIx64;
657
658    outs() << format(Fmt, Address) << " "
659           << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' '
660           << (Weak ? 'w' : ' ') // Weak?
661           << ' ' // Constructor. Not supported yet.
662           << ' ' // Warning. Not supported yet.
663           << ' ' // Indirect reference to another symbol.
664           << Debug // Debugging (d) or dynamic (D) symbol.
665           << FileFunc // Name of function (F), file (f) or object (O).
666           << ' ';
667    if (Absolute) {
668      outs() << "*ABS*";
669    } else if (Common) {
670      outs() << "*COM*";
671    } else if (Section == o->section_end()) {
672      outs() << "*UND*";
673    } else {
674      if (const MachOObjectFile *MachO =
675          dyn_cast<const MachOObjectFile>(o)) {
676        DataRefImpl DR = Section->getRawDataRefImpl();
677        StringRef SegmentName = MachO->getSectionFinalSegmentName(DR);
678        outs() << SegmentName << ",";
679      }
680      StringRef SectionName;
681      if (error(Section->getName(SectionName)))
682        SectionName = "";
683      outs() << SectionName;
684    }
685    outs() << '\t'
686           << format("%08" PRIx64 " ", Size)
687           << Name
688           << '\n';
689  }
690}
691
692static void PrintUnwindInfo(const ObjectFile *o) {
693  outs() << "Unwind info:\n\n";
694
695  if (const COFFObjectFile *coff = dyn_cast<COFFObjectFile>(o)) {
696    printCOFFUnwindInfo(coff);
697  } else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
698    printMachOUnwindInfo(MachO);
699  else {
700    // TODO: Extract DWARF dump tool to objdump.
701    errs() << "This operation is only currently supported "
702              "for COFF and MachO object files.\n";
703    return;
704  }
705}
706
707void llvm::printExportsTrie(const ObjectFile *o) {
708  outs() << "Exports trie:\n";
709  if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
710    printMachOExportsTrie(MachO);
711  else {
712    errs() << "This operation is only currently supported "
713              "for Mach-O executable files.\n";
714    return;
715  }
716}
717
718void llvm::printRebaseTable(const ObjectFile *o) {
719  outs() << "Rebase table:\n";
720  if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
721    printMachORebaseTable(MachO);
722  else {
723    errs() << "This operation is only currently supported "
724              "for Mach-O executable files.\n";
725    return;
726  }
727}
728
729void llvm::printBindTable(const ObjectFile *o) {
730  outs() << "Bind table:\n";
731  if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
732    printMachOBindTable(MachO);
733  else {
734    errs() << "This operation is only currently supported "
735              "for Mach-O executable files.\n";
736    return;
737  }
738}
739
740void llvm::printLazyBindTable(const ObjectFile *o) {
741  outs() << "Lazy bind table:\n";
742  if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
743    printMachOLazyBindTable(MachO);
744  else {
745    errs() << "This operation is only currently supported "
746              "for Mach-O executable files.\n";
747    return;
748  }
749}
750
751void llvm::printWeakBindTable(const ObjectFile *o) {
752  outs() << "Weak bind table:\n";
753  if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
754    printMachOWeakBindTable(MachO);
755  else {
756    errs() << "This operation is only currently supported "
757              "for Mach-O executable files.\n";
758    return;
759  }
760}
761
762static void printPrivateFileHeader(const ObjectFile *o) {
763  if (o->isELF()) {
764    printELFFileHeader(o);
765  } else if (o->isCOFF()) {
766    printCOFFFileHeader(o);
767  } else if (o->isMachO()) {
768    printMachOFileHeader(o);
769  }
770}
771
772static void DumpObject(const ObjectFile *o) {
773  outs() << '\n';
774  outs() << o->getFileName()
775         << ":\tfile format " << o->getFileFormatName() << "\n\n";
776
777  if (Disassemble)
778    DisassembleObject(o, Relocations);
779  if (Relocations && !Disassemble)
780    PrintRelocations(o);
781  if (SectionHeaders)
782    PrintSectionHeaders(o);
783  if (SectionContents)
784    PrintSectionContents(o);
785  if (SymbolTable)
786    PrintSymbolTable(o);
787  if (UnwindInfo)
788    PrintUnwindInfo(o);
789  if (PrivateHeaders)
790    printPrivateFileHeader(o);
791  if (ExportsTrie)
792    printExportsTrie(o);
793  if (Rebase)
794    printRebaseTable(o);
795  if (Bind)
796    printBindTable(o);
797  if (LazyBind)
798    printLazyBindTable(o);
799  if (WeakBind)
800    printWeakBindTable(o);
801}
802
803/// @brief Dump each object file in \a a;
804static void DumpArchive(const Archive *a) {
805  for (Archive::child_iterator i = a->child_begin(), e = a->child_end(); i != e;
806       ++i) {
807    ErrorOr<std::unique_ptr<Binary>> ChildOrErr = i->getAsBinary();
808    if (std::error_code EC = ChildOrErr.getError()) {
809      // Ignore non-object files.
810      if (EC != object_error::invalid_file_type)
811        errs() << ToolName << ": '" << a->getFileName() << "': " << EC.message()
812               << ".\n";
813      continue;
814    }
815    if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get()))
816      DumpObject(o);
817    else
818      errs() << ToolName << ": '" << a->getFileName() << "': "
819              << "Unrecognized file type.\n";
820  }
821}
822
823/// @brief Open file and figure out how to dump it.
824static void DumpInput(StringRef file) {
825  // If file isn't stdin, check that it exists.
826  if (file != "-" && !sys::fs::exists(file)) {
827    errs() << ToolName << ": '" << file << "': " << "No such file\n";
828    return;
829  }
830
831  // If we are using the Mach-O specific object file parser, then let it parse
832  // the file and process the command line options.  So the -arch flags can
833  // be used to select specific slices, etc.
834  if (MachOOpt) {
835    ParseInputMachO(file);
836    return;
837  }
838
839  // Attempt to open the binary.
840  ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(file);
841  if (std::error_code EC = BinaryOrErr.getError()) {
842    errs() << ToolName << ": '" << file << "': " << EC.message() << ".\n";
843    return;
844  }
845  Binary &Binary = *BinaryOrErr.get().getBinary();
846
847  if (Archive *a = dyn_cast<Archive>(&Binary))
848    DumpArchive(a);
849  else if (ObjectFile *o = dyn_cast<ObjectFile>(&Binary))
850    DumpObject(o);
851  else
852    errs() << ToolName << ": '" << file << "': " << "Unrecognized file type.\n";
853}
854
855int main(int argc, char **argv) {
856  // Print a stack trace if we signal out.
857  sys::PrintStackTraceOnErrorSignal();
858  PrettyStackTraceProgram X(argc, argv);
859  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
860
861  // Initialize targets and assembly printers/parsers.
862  llvm::InitializeAllTargetInfos();
863  llvm::InitializeAllTargetMCs();
864  llvm::InitializeAllAsmParsers();
865  llvm::InitializeAllDisassemblers();
866
867  // Register the target printer for --version.
868  cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
869
870  cl::ParseCommandLineOptions(argc, argv, "llvm object file dumper\n");
871  TripleName = Triple::normalize(TripleName);
872
873  ToolName = argv[0];
874
875  // Defaults to a.out if no filenames specified.
876  if (InputFilenames.size() == 0)
877    InputFilenames.push_back("a.out");
878
879  if (!Disassemble
880      && !Relocations
881      && !SectionHeaders
882      && !SectionContents
883      && !SymbolTable
884      && !UnwindInfo
885      && !PrivateHeaders
886      && !ExportsTrie
887      && !Rebase
888      && !Bind
889      && !LazyBind
890      && !WeakBind
891      && !(UniversalHeaders && MachOOpt)
892      && !(ArchiveHeaders && MachOOpt)
893      && !(IndirectSymbols && MachOOpt)
894      && !(DataInCode && MachOOpt)
895      && !(LinkOptHints && MachOOpt)
896      && !(InfoPlist && MachOOpt)
897      && !(DylibsUsed && MachOOpt)
898      && !(DylibId && MachOOpt)
899      && !(ObjcMetaData && MachOOpt)
900      && !(DumpSections.size() != 0 && MachOOpt)) {
901    cl::PrintHelpMessage();
902    return 2;
903  }
904
905  std::for_each(InputFilenames.begin(), InputFilenames.end(),
906                DumpInput);
907
908  return ReturnValue;
909}
910