Delete UnknownAddress. It is a perfectly valid symbol value.
[oota-llvm.git] / tools / llvm-objdump / MachODump.cpp
1 //===-- MachODump.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 file implements the MachO-specific dumper for llvm-objdump.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm-objdump.h"
15 #include "llvm-c/Disassembler.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/Config/config.h"
20 #include "llvm/DebugInfo/DIContext.h"
21 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
22 #include "llvm/MC/MCAsmInfo.h"
23 #include "llvm/MC/MCContext.h"
24 #include "llvm/MC/MCDisassembler.h"
25 #include "llvm/MC/MCInst.h"
26 #include "llvm/MC/MCInstPrinter.h"
27 #include "llvm/MC/MCInstrDesc.h"
28 #include "llvm/MC/MCInstrInfo.h"
29 #include "llvm/MC/MCRegisterInfo.h"
30 #include "llvm/MC/MCSubtargetInfo.h"
31 #include "llvm/Object/MachO.h"
32 #include "llvm/Object/MachOUniversal.h"
33 #include "llvm/Support/Casting.h"
34 #include "llvm/Support/CommandLine.h"
35 #include "llvm/Support/Debug.h"
36 #include "llvm/Support/Endian.h"
37 #include "llvm/Support/Format.h"
38 #include "llvm/Support/FormattedStream.h"
39 #include "llvm/Support/GraphWriter.h"
40 #include "llvm/Support/LEB128.h"
41 #include "llvm/Support/MachO.h"
42 #include "llvm/Support/MemoryBuffer.h"
43 #include "llvm/Support/TargetRegistry.h"
44 #include "llvm/Support/TargetSelect.h"
45 #include "llvm/Support/raw_ostream.h"
46 #include <algorithm>
47 #include <cstring>
48 #include <system_error>
49
50 #if HAVE_CXXABI_H
51 #include <cxxabi.h>
52 #endif
53
54 using namespace llvm;
55 using namespace object;
56
57 static cl::opt<bool>
58     UseDbg("g",
59            cl::desc("Print line information from debug info if available"));
60
61 static cl::opt<std::string> DSYMFile("dsym",
62                                      cl::desc("Use .dSYM file for debug info"));
63
64 static cl::opt<bool> FullLeadingAddr("full-leading-addr",
65                                      cl::desc("Print full leading address"));
66
67 static cl::opt<bool> NoLeadingAddr("no-leading-addr",
68                                    cl::desc("Print no leading address"));
69
70 cl::opt<bool> llvm::UniversalHeaders("universal-headers",
71                                      cl::desc("Print Mach-O universal headers "
72                                               "(requires -macho)"));
73
74 cl::opt<bool>
75     llvm::ArchiveHeaders("archive-headers",
76                          cl::desc("Print archive headers for Mach-O archives "
77                                   "(requires -macho)"));
78
79 cl::opt<bool>
80     ArchiveMemberOffsets("archive-member-offsets",
81                          cl::desc("Print the offset to each archive member for "
82                                   "Mach-O archives (requires -macho and "
83                                   "-archive-headers)"));
84
85 cl::opt<bool>
86     llvm::IndirectSymbols("indirect-symbols",
87                           cl::desc("Print indirect symbol table for Mach-O "
88                                    "objects (requires -macho)"));
89
90 cl::opt<bool>
91     llvm::DataInCode("data-in-code",
92                      cl::desc("Print the data in code table for Mach-O objects "
93                               "(requires -macho)"));
94
95 cl::opt<bool>
96     llvm::LinkOptHints("link-opt-hints",
97                        cl::desc("Print the linker optimization hints for "
98                                 "Mach-O objects (requires -macho)"));
99
100 cl::list<std::string>
101     llvm::DumpSections("section",
102                        cl::desc("Prints the specified segment,section for "
103                                 "Mach-O objects (requires -macho)"));
104
105 cl::opt<bool> llvm::Raw("raw",
106                         cl::desc("Have -section dump the raw binary contents"));
107
108 cl::opt<bool>
109     llvm::InfoPlist("info-plist",
110                     cl::desc("Print the info plist section as strings for "
111                              "Mach-O objects (requires -macho)"));
112
113 cl::opt<bool>
114     llvm::DylibsUsed("dylibs-used",
115                      cl::desc("Print the shared libraries used for linked "
116                               "Mach-O files (requires -macho)"));
117
118 cl::opt<bool>
119     llvm::DylibId("dylib-id",
120                   cl::desc("Print the shared library's id for the dylib Mach-O "
121                            "file (requires -macho)"));
122
123 cl::opt<bool>
124     llvm::NonVerbose("non-verbose",
125                      cl::desc("Print the info for Mach-O objects in "
126                               "non-verbose or numeric form (requires -macho)"));
127
128 cl::opt<bool>
129     llvm::ObjcMetaData("objc-meta-data",
130                        cl::desc("Print the Objective-C runtime meta data for "
131                                 "Mach-O files (requires -macho)"));
132
133 cl::opt<std::string> llvm::DisSymName(
134     "dis-symname",
135     cl::desc("disassemble just this symbol's instructions (requires -macho"));
136
137 static cl::opt<bool> NoSymbolicOperands(
138     "no-symbolic-operands",
139     cl::desc("do not symbolic operands when disassembling (requires -macho)"));
140
141 static cl::list<std::string>
142     ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
143               cl::ZeroOrMore);
144 bool ArchAll = false;
145
146 static std::string ThumbTripleName;
147
148 static const Target *GetTarget(const MachOObjectFile *MachOObj,
149                                const char **McpuDefault,
150                                const Target **ThumbTarget) {
151   // Figure out the target triple.
152   if (TripleName.empty()) {
153     llvm::Triple TT("unknown-unknown-unknown");
154     llvm::Triple ThumbTriple = Triple();
155     TT = MachOObj->getArch(McpuDefault, &ThumbTriple);
156     TripleName = TT.str();
157     ThumbTripleName = ThumbTriple.str();
158   }
159
160   // Get the target specific parser.
161   std::string Error;
162   const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
163   if (TheTarget && ThumbTripleName.empty())
164     return TheTarget;
165
166   *ThumbTarget = TargetRegistry::lookupTarget(ThumbTripleName, Error);
167   if (*ThumbTarget)
168     return TheTarget;
169
170   errs() << "llvm-objdump: error: unable to get target for '";
171   if (!TheTarget)
172     errs() << TripleName;
173   else
174     errs() << ThumbTripleName;
175   errs() << "', see --version and --triple.\n";
176   return nullptr;
177 }
178
179 struct SymbolSorter {
180   bool operator()(const SymbolRef &A, const SymbolRef &B) {
181     uint64_t AAddr = (A.getType() != SymbolRef::ST_Function) ? 0 : A.getValue();
182     uint64_t BAddr = (B.getType() != SymbolRef::ST_Function) ? 0 : B.getValue();
183     return AAddr < BAddr;
184   }
185 };
186
187 // Types for the storted data in code table that is built before disassembly
188 // and the predicate function to sort them.
189 typedef std::pair<uint64_t, DiceRef> DiceTableEntry;
190 typedef std::vector<DiceTableEntry> DiceTable;
191 typedef DiceTable::iterator dice_table_iterator;
192
193 // This is used to search for a data in code table entry for the PC being
194 // disassembled.  The j parameter has the PC in j.first.  A single data in code
195 // table entry can cover many bytes for each of its Kind's.  So if the offset,
196 // aka the i.first value, of the data in code table entry plus its Length
197 // covers the PC being searched for this will return true.  If not it will
198 // return false.
199 static bool compareDiceTableEntries(const DiceTableEntry &i,
200                                     const DiceTableEntry &j) {
201   uint16_t Length;
202   i.second.getLength(Length);
203
204   return j.first >= i.first && j.first < i.first + Length;
205 }
206
207 static uint64_t DumpDataInCode(const uint8_t *bytes, uint64_t Length,
208                                unsigned short Kind) {
209   uint32_t Value, Size = 1;
210
211   switch (Kind) {
212   default:
213   case MachO::DICE_KIND_DATA:
214     if (Length >= 4) {
215       if (!NoShowRawInsn)
216         dumpBytes(ArrayRef<uint8_t>(bytes, 4), outs());
217       Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
218       outs() << "\t.long " << Value;
219       Size = 4;
220     } else if (Length >= 2) {
221       if (!NoShowRawInsn)
222         dumpBytes(ArrayRef<uint8_t>(bytes, 2), outs());
223       Value = bytes[1] << 8 | bytes[0];
224       outs() << "\t.short " << Value;
225       Size = 2;
226     } else {
227       if (!NoShowRawInsn)
228         dumpBytes(ArrayRef<uint8_t>(bytes, 2), outs());
229       Value = bytes[0];
230       outs() << "\t.byte " << Value;
231       Size = 1;
232     }
233     if (Kind == MachO::DICE_KIND_DATA)
234       outs() << "\t@ KIND_DATA\n";
235     else
236       outs() << "\t@ data in code kind = " << Kind << "\n";
237     break;
238   case MachO::DICE_KIND_JUMP_TABLE8:
239     if (!NoShowRawInsn)
240       dumpBytes(ArrayRef<uint8_t>(bytes, 1), outs());
241     Value = bytes[0];
242     outs() << "\t.byte " << format("%3u", Value) << "\t@ KIND_JUMP_TABLE8\n";
243     Size = 1;
244     break;
245   case MachO::DICE_KIND_JUMP_TABLE16:
246     if (!NoShowRawInsn)
247       dumpBytes(ArrayRef<uint8_t>(bytes, 2), outs());
248     Value = bytes[1] << 8 | bytes[0];
249     outs() << "\t.short " << format("%5u", Value & 0xffff)
250            << "\t@ KIND_JUMP_TABLE16\n";
251     Size = 2;
252     break;
253   case MachO::DICE_KIND_JUMP_TABLE32:
254   case MachO::DICE_KIND_ABS_JUMP_TABLE32:
255     if (!NoShowRawInsn)
256       dumpBytes(ArrayRef<uint8_t>(bytes, 4), outs());
257     Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
258     outs() << "\t.long " << Value;
259     if (Kind == MachO::DICE_KIND_JUMP_TABLE32)
260       outs() << "\t@ KIND_JUMP_TABLE32\n";
261     else
262       outs() << "\t@ KIND_ABS_JUMP_TABLE32\n";
263     Size = 4;
264     break;
265   }
266   return Size;
267 }
268
269 static void getSectionsAndSymbols(MachOObjectFile *MachOObj,
270                                   std::vector<SectionRef> &Sections,
271                                   std::vector<SymbolRef> &Symbols,
272                                   SmallVectorImpl<uint64_t> &FoundFns,
273                                   uint64_t &BaseSegmentAddress) {
274   for (const SymbolRef &Symbol : MachOObj->symbols()) {
275     ErrorOr<StringRef> SymName = Symbol.getName();
276     if (std::error_code EC = SymName.getError())
277       report_fatal_error(EC.message());
278     if (!SymName->startswith("ltmp"))
279       Symbols.push_back(Symbol);
280   }
281
282   for (const SectionRef &Section : MachOObj->sections()) {
283     StringRef SectName;
284     Section.getName(SectName);
285     Sections.push_back(Section);
286   }
287
288   bool BaseSegmentAddressSet = false;
289   for (const auto &Command : MachOObj->load_commands()) {
290     if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) {
291       // We found a function starts segment, parse the addresses for later
292       // consumption.
293       MachO::linkedit_data_command LLC =
294           MachOObj->getLinkeditDataLoadCommand(Command);
295
296       MachOObj->ReadULEB128s(LLC.dataoff, FoundFns);
297     } else if (Command.C.cmd == MachO::LC_SEGMENT) {
298       MachO::segment_command SLC = MachOObj->getSegmentLoadCommand(Command);
299       StringRef SegName = SLC.segname;
300       if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
301         BaseSegmentAddressSet = true;
302         BaseSegmentAddress = SLC.vmaddr;
303       }
304     }
305   }
306 }
307
308 static void PrintIndirectSymbolTable(MachOObjectFile *O, bool verbose,
309                                      uint32_t n, uint32_t count,
310                                      uint32_t stride, uint64_t addr) {
311   MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand();
312   uint32_t nindirectsyms = Dysymtab.nindirectsyms;
313   if (n > nindirectsyms)
314     outs() << " (entries start past the end of the indirect symbol "
315               "table) (reserved1 field greater than the table size)";
316   else if (n + count > nindirectsyms)
317     outs() << " (entries extends past the end of the indirect symbol "
318               "table)";
319   outs() << "\n";
320   uint32_t cputype = O->getHeader().cputype;
321   if (cputype & MachO::CPU_ARCH_ABI64)
322     outs() << "address            index";
323   else
324     outs() << "address    index";
325   if (verbose)
326     outs() << " name\n";
327   else
328     outs() << "\n";
329   for (uint32_t j = 0; j < count && n + j < nindirectsyms; j++) {
330     if (cputype & MachO::CPU_ARCH_ABI64)
331       outs() << format("0x%016" PRIx64, addr + j * stride) << " ";
332     else
333       outs() << format("0x%08" PRIx32, addr + j * stride) << " ";
334     MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand();
335     uint32_t indirect_symbol = O->getIndirectSymbolTableEntry(Dysymtab, n + j);
336     if (indirect_symbol == MachO::INDIRECT_SYMBOL_LOCAL) {
337       outs() << "LOCAL\n";
338       continue;
339     }
340     if (indirect_symbol ==
341         (MachO::INDIRECT_SYMBOL_LOCAL | MachO::INDIRECT_SYMBOL_ABS)) {
342       outs() << "LOCAL ABSOLUTE\n";
343       continue;
344     }
345     if (indirect_symbol == MachO::INDIRECT_SYMBOL_ABS) {
346       outs() << "ABSOLUTE\n";
347       continue;
348     }
349     outs() << format("%5u ", indirect_symbol);
350     if (verbose) {
351       MachO::symtab_command Symtab = O->getSymtabLoadCommand();
352       if (indirect_symbol < Symtab.nsyms) {
353         symbol_iterator Sym = O->getSymbolByIndex(indirect_symbol);
354         SymbolRef Symbol = *Sym;
355         ErrorOr<StringRef> SymName = Symbol.getName();
356         if (std::error_code EC = SymName.getError())
357           report_fatal_error(EC.message());
358         outs() << *SymName;
359       } else {
360         outs() << "?";
361       }
362     }
363     outs() << "\n";
364   }
365 }
366
367 static void PrintIndirectSymbols(MachOObjectFile *O, bool verbose) {
368   for (const auto &Load : O->load_commands()) {
369     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
370       MachO::segment_command_64 Seg = O->getSegment64LoadCommand(Load);
371       for (unsigned J = 0; J < Seg.nsects; ++J) {
372         MachO::section_64 Sec = O->getSection64(Load, J);
373         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
374         if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
375             section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
376             section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
377             section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
378             section_type == MachO::S_SYMBOL_STUBS) {
379           uint32_t stride;
380           if (section_type == MachO::S_SYMBOL_STUBS)
381             stride = Sec.reserved2;
382           else
383             stride = 8;
384           if (stride == 0) {
385             outs() << "Can't print indirect symbols for (" << Sec.segname << ","
386                    << Sec.sectname << ") "
387                    << "(size of stubs in reserved2 field is zero)\n";
388             continue;
389           }
390           uint32_t count = Sec.size / stride;
391           outs() << "Indirect symbols for (" << Sec.segname << ","
392                  << Sec.sectname << ") " << count << " entries";
393           uint32_t n = Sec.reserved1;
394           PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr);
395         }
396       }
397     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
398       MachO::segment_command Seg = O->getSegmentLoadCommand(Load);
399       for (unsigned J = 0; J < Seg.nsects; ++J) {
400         MachO::section Sec = O->getSection(Load, J);
401         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
402         if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
403             section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
404             section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
405             section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
406             section_type == MachO::S_SYMBOL_STUBS) {
407           uint32_t stride;
408           if (section_type == MachO::S_SYMBOL_STUBS)
409             stride = Sec.reserved2;
410           else
411             stride = 4;
412           if (stride == 0) {
413             outs() << "Can't print indirect symbols for (" << Sec.segname << ","
414                    << Sec.sectname << ") "
415                    << "(size of stubs in reserved2 field is zero)\n";
416             continue;
417           }
418           uint32_t count = Sec.size / stride;
419           outs() << "Indirect symbols for (" << Sec.segname << ","
420                  << Sec.sectname << ") " << count << " entries";
421           uint32_t n = Sec.reserved1;
422           PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr);
423         }
424       }
425     }
426   }
427 }
428
429 static void PrintDataInCodeTable(MachOObjectFile *O, bool verbose) {
430   MachO::linkedit_data_command DIC = O->getDataInCodeLoadCommand();
431   uint32_t nentries = DIC.datasize / sizeof(struct MachO::data_in_code_entry);
432   outs() << "Data in code table (" << nentries << " entries)\n";
433   outs() << "offset     length kind\n";
434   for (dice_iterator DI = O->begin_dices(), DE = O->end_dices(); DI != DE;
435        ++DI) {
436     uint32_t Offset;
437     DI->getOffset(Offset);
438     outs() << format("0x%08" PRIx32, Offset) << " ";
439     uint16_t Length;
440     DI->getLength(Length);
441     outs() << format("%6u", Length) << " ";
442     uint16_t Kind;
443     DI->getKind(Kind);
444     if (verbose) {
445       switch (Kind) {
446       case MachO::DICE_KIND_DATA:
447         outs() << "DATA";
448         break;
449       case MachO::DICE_KIND_JUMP_TABLE8:
450         outs() << "JUMP_TABLE8";
451         break;
452       case MachO::DICE_KIND_JUMP_TABLE16:
453         outs() << "JUMP_TABLE16";
454         break;
455       case MachO::DICE_KIND_JUMP_TABLE32:
456         outs() << "JUMP_TABLE32";
457         break;
458       case MachO::DICE_KIND_ABS_JUMP_TABLE32:
459         outs() << "ABS_JUMP_TABLE32";
460         break;
461       default:
462         outs() << format("0x%04" PRIx32, Kind);
463         break;
464       }
465     } else
466       outs() << format("0x%04" PRIx32, Kind);
467     outs() << "\n";
468   }
469 }
470
471 static void PrintLinkOptHints(MachOObjectFile *O) {
472   MachO::linkedit_data_command LohLC = O->getLinkOptHintsLoadCommand();
473   const char *loh = O->getData().substr(LohLC.dataoff, 1).data();
474   uint32_t nloh = LohLC.datasize;
475   outs() << "Linker optimiztion hints (" << nloh << " total bytes)\n";
476   for (uint32_t i = 0; i < nloh;) {
477     unsigned n;
478     uint64_t identifier = decodeULEB128((const uint8_t *)(loh + i), &n);
479     i += n;
480     outs() << "    identifier " << identifier << " ";
481     if (i >= nloh)
482       return;
483     switch (identifier) {
484     case 1:
485       outs() << "AdrpAdrp\n";
486       break;
487     case 2:
488       outs() << "AdrpLdr\n";
489       break;
490     case 3:
491       outs() << "AdrpAddLdr\n";
492       break;
493     case 4:
494       outs() << "AdrpLdrGotLdr\n";
495       break;
496     case 5:
497       outs() << "AdrpAddStr\n";
498       break;
499     case 6:
500       outs() << "AdrpLdrGotStr\n";
501       break;
502     case 7:
503       outs() << "AdrpAdd\n";
504       break;
505     case 8:
506       outs() << "AdrpLdrGot\n";
507       break;
508     default:
509       outs() << "Unknown identifier value\n";
510       break;
511     }
512     uint64_t narguments = decodeULEB128((const uint8_t *)(loh + i), &n);
513     i += n;
514     outs() << "    narguments " << narguments << "\n";
515     if (i >= nloh)
516       return;
517
518     for (uint32_t j = 0; j < narguments; j++) {
519       uint64_t value = decodeULEB128((const uint8_t *)(loh + i), &n);
520       i += n;
521       outs() << "\tvalue " << format("0x%" PRIx64, value) << "\n";
522       if (i >= nloh)
523         return;
524     }
525   }
526 }
527
528 static void PrintDylibs(MachOObjectFile *O, bool JustId) {
529   unsigned Index = 0;
530   for (const auto &Load : O->load_commands()) {
531     if ((JustId && Load.C.cmd == MachO::LC_ID_DYLIB) ||
532         (!JustId && (Load.C.cmd == MachO::LC_ID_DYLIB ||
533                      Load.C.cmd == MachO::LC_LOAD_DYLIB ||
534                      Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
535                      Load.C.cmd == MachO::LC_REEXPORT_DYLIB ||
536                      Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
537                      Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB))) {
538       MachO::dylib_command dl = O->getDylibIDLoadCommand(Load);
539       if (dl.dylib.name < dl.cmdsize) {
540         const char *p = (const char *)(Load.Ptr) + dl.dylib.name;
541         if (JustId)
542           outs() << p << "\n";
543         else {
544           outs() << "\t" << p;
545           outs() << " (compatibility version "
546                  << ((dl.dylib.compatibility_version >> 16) & 0xffff) << "."
547                  << ((dl.dylib.compatibility_version >> 8) & 0xff) << "."
548                  << (dl.dylib.compatibility_version & 0xff) << ",";
549           outs() << " current version "
550                  << ((dl.dylib.current_version >> 16) & 0xffff) << "."
551                  << ((dl.dylib.current_version >> 8) & 0xff) << "."
552                  << (dl.dylib.current_version & 0xff) << ")\n";
553         }
554       } else {
555         outs() << "\tBad offset (" << dl.dylib.name << ") for name of ";
556         if (Load.C.cmd == MachO::LC_ID_DYLIB)
557           outs() << "LC_ID_DYLIB ";
558         else if (Load.C.cmd == MachO::LC_LOAD_DYLIB)
559           outs() << "LC_LOAD_DYLIB ";
560         else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB)
561           outs() << "LC_LOAD_WEAK_DYLIB ";
562         else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB)
563           outs() << "LC_LAZY_LOAD_DYLIB ";
564         else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB)
565           outs() << "LC_REEXPORT_DYLIB ";
566         else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB)
567           outs() << "LC_LOAD_UPWARD_DYLIB ";
568         else
569           outs() << "LC_??? ";
570         outs() << "command " << Index++ << "\n";
571       }
572     }
573   }
574 }
575
576 typedef DenseMap<uint64_t, StringRef> SymbolAddressMap;
577
578 static void CreateSymbolAddressMap(MachOObjectFile *O,
579                                    SymbolAddressMap *AddrMap) {
580   // Create a map of symbol addresses to symbol names.
581   for (const SymbolRef &Symbol : O->symbols()) {
582     SymbolRef::Type ST = Symbol.getType();
583     if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
584         ST == SymbolRef::ST_Other) {
585       uint64_t Address = Symbol.getValue();
586       ErrorOr<StringRef> SymNameOrErr = Symbol.getName();
587       if (std::error_code EC = SymNameOrErr.getError())
588         report_fatal_error(EC.message());
589       StringRef SymName = *SymNameOrErr;
590       if (!SymName.startswith(".objc"))
591         (*AddrMap)[Address] = SymName;
592     }
593   }
594 }
595
596 // GuessSymbolName is passed the address of what might be a symbol and a
597 // pointer to the SymbolAddressMap.  It returns the name of a symbol
598 // with that address or nullptr if no symbol is found with that address.
599 static const char *GuessSymbolName(uint64_t value, SymbolAddressMap *AddrMap) {
600   const char *SymbolName = nullptr;
601   // A DenseMap can't lookup up some values.
602   if (value != 0xffffffffffffffffULL && value != 0xfffffffffffffffeULL) {
603     StringRef name = AddrMap->lookup(value);
604     if (!name.empty())
605       SymbolName = name.data();
606   }
607   return SymbolName;
608 }
609
610 static void DumpCstringChar(const char c) {
611   char p[2];
612   p[0] = c;
613   p[1] = '\0';
614   outs().write_escaped(p);
615 }
616
617 static void DumpCstringSection(MachOObjectFile *O, const char *sect,
618                                uint32_t sect_size, uint64_t sect_addr,
619                                bool print_addresses) {
620   for (uint32_t i = 0; i < sect_size; i++) {
621     if (print_addresses) {
622       if (O->is64Bit())
623         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
624       else
625         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
626     }
627     for (; i < sect_size && sect[i] != '\0'; i++)
628       DumpCstringChar(sect[i]);
629     if (i < sect_size && sect[i] == '\0')
630       outs() << "\n";
631   }
632 }
633
634 static void DumpLiteral4(uint32_t l, float f) {
635   outs() << format("0x%08" PRIx32, l);
636   if ((l & 0x7f800000) != 0x7f800000)
637     outs() << format(" (%.16e)\n", f);
638   else {
639     if (l == 0x7f800000)
640       outs() << " (+Infinity)\n";
641     else if (l == 0xff800000)
642       outs() << " (-Infinity)\n";
643     else if ((l & 0x00400000) == 0x00400000)
644       outs() << " (non-signaling Not-a-Number)\n";
645     else
646       outs() << " (signaling Not-a-Number)\n";
647   }
648 }
649
650 static void DumpLiteral4Section(MachOObjectFile *O, const char *sect,
651                                 uint32_t sect_size, uint64_t sect_addr,
652                                 bool print_addresses) {
653   for (uint32_t i = 0; i < sect_size; i += sizeof(float)) {
654     if (print_addresses) {
655       if (O->is64Bit())
656         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
657       else
658         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
659     }
660     float f;
661     memcpy(&f, sect + i, sizeof(float));
662     if (O->isLittleEndian() != sys::IsLittleEndianHost)
663       sys::swapByteOrder(f);
664     uint32_t l;
665     memcpy(&l, sect + i, sizeof(uint32_t));
666     if (O->isLittleEndian() != sys::IsLittleEndianHost)
667       sys::swapByteOrder(l);
668     DumpLiteral4(l, f);
669   }
670 }
671
672 static void DumpLiteral8(MachOObjectFile *O, uint32_t l0, uint32_t l1,
673                          double d) {
674   outs() << format("0x%08" PRIx32, l0) << " " << format("0x%08" PRIx32, l1);
675   uint32_t Hi, Lo;
676   if (O->isLittleEndian()) {
677     Hi = l1;
678     Lo = l0;
679   } else {
680     Hi = l0;
681     Lo = l1;
682   }
683   // Hi is the high word, so this is equivalent to if(isfinite(d))
684   if ((Hi & 0x7ff00000) != 0x7ff00000)
685     outs() << format(" (%.16e)\n", d);
686   else {
687     if (Hi == 0x7ff00000 && Lo == 0)
688       outs() << " (+Infinity)\n";
689     else if (Hi == 0xfff00000 && Lo == 0)
690       outs() << " (-Infinity)\n";
691     else if ((Hi & 0x00080000) == 0x00080000)
692       outs() << " (non-signaling Not-a-Number)\n";
693     else
694       outs() << " (signaling Not-a-Number)\n";
695   }
696 }
697
698 static void DumpLiteral8Section(MachOObjectFile *O, const char *sect,
699                                 uint32_t sect_size, uint64_t sect_addr,
700                                 bool print_addresses) {
701   for (uint32_t i = 0; i < sect_size; i += sizeof(double)) {
702     if (print_addresses) {
703       if (O->is64Bit())
704         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
705       else
706         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
707     }
708     double d;
709     memcpy(&d, sect + i, sizeof(double));
710     if (O->isLittleEndian() != sys::IsLittleEndianHost)
711       sys::swapByteOrder(d);
712     uint32_t l0, l1;
713     memcpy(&l0, sect + i, sizeof(uint32_t));
714     memcpy(&l1, sect + i + sizeof(uint32_t), sizeof(uint32_t));
715     if (O->isLittleEndian() != sys::IsLittleEndianHost) {
716       sys::swapByteOrder(l0);
717       sys::swapByteOrder(l1);
718     }
719     DumpLiteral8(O, l0, l1, d);
720   }
721 }
722
723 static void DumpLiteral16(uint32_t l0, uint32_t l1, uint32_t l2, uint32_t l3) {
724   outs() << format("0x%08" PRIx32, l0) << " ";
725   outs() << format("0x%08" PRIx32, l1) << " ";
726   outs() << format("0x%08" PRIx32, l2) << " ";
727   outs() << format("0x%08" PRIx32, l3) << "\n";
728 }
729
730 static void DumpLiteral16Section(MachOObjectFile *O, const char *sect,
731                                  uint32_t sect_size, uint64_t sect_addr,
732                                  bool print_addresses) {
733   for (uint32_t i = 0; i < sect_size; i += 16) {
734     if (print_addresses) {
735       if (O->is64Bit())
736         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
737       else
738         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
739     }
740     uint32_t l0, l1, l2, l3;
741     memcpy(&l0, sect + i, sizeof(uint32_t));
742     memcpy(&l1, sect + i + sizeof(uint32_t), sizeof(uint32_t));
743     memcpy(&l2, sect + i + 2 * sizeof(uint32_t), sizeof(uint32_t));
744     memcpy(&l3, sect + i + 3 * sizeof(uint32_t), sizeof(uint32_t));
745     if (O->isLittleEndian() != sys::IsLittleEndianHost) {
746       sys::swapByteOrder(l0);
747       sys::swapByteOrder(l1);
748       sys::swapByteOrder(l2);
749       sys::swapByteOrder(l3);
750     }
751     DumpLiteral16(l0, l1, l2, l3);
752   }
753 }
754
755 static void DumpLiteralPointerSection(MachOObjectFile *O,
756                                       const SectionRef &Section,
757                                       const char *sect, uint32_t sect_size,
758                                       uint64_t sect_addr,
759                                       bool print_addresses) {
760   // Collect the literal sections in this Mach-O file.
761   std::vector<SectionRef> LiteralSections;
762   for (const SectionRef &Section : O->sections()) {
763     DataRefImpl Ref = Section.getRawDataRefImpl();
764     uint32_t section_type;
765     if (O->is64Bit()) {
766       const MachO::section_64 Sec = O->getSection64(Ref);
767       section_type = Sec.flags & MachO::SECTION_TYPE;
768     } else {
769       const MachO::section Sec = O->getSection(Ref);
770       section_type = Sec.flags & MachO::SECTION_TYPE;
771     }
772     if (section_type == MachO::S_CSTRING_LITERALS ||
773         section_type == MachO::S_4BYTE_LITERALS ||
774         section_type == MachO::S_8BYTE_LITERALS ||
775         section_type == MachO::S_16BYTE_LITERALS)
776       LiteralSections.push_back(Section);
777   }
778
779   // Set the size of the literal pointer.
780   uint32_t lp_size = O->is64Bit() ? 8 : 4;
781
782   // Collect the external relocation symbols for the literal pointers.
783   std::vector<std::pair<uint64_t, SymbolRef>> Relocs;
784   for (const RelocationRef &Reloc : Section.relocations()) {
785     DataRefImpl Rel;
786     MachO::any_relocation_info RE;
787     bool isExtern = false;
788     Rel = Reloc.getRawDataRefImpl();
789     RE = O->getRelocation(Rel);
790     isExtern = O->getPlainRelocationExternal(RE);
791     if (isExtern) {
792       uint64_t RelocOffset = Reloc.getOffset();
793       symbol_iterator RelocSym = Reloc.getSymbol();
794       Relocs.push_back(std::make_pair(RelocOffset, *RelocSym));
795     }
796   }
797   array_pod_sort(Relocs.begin(), Relocs.end());
798
799   // Dump each literal pointer.
800   for (uint32_t i = 0; i < sect_size; i += lp_size) {
801     if (print_addresses) {
802       if (O->is64Bit())
803         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
804       else
805         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
806     }
807     uint64_t lp;
808     if (O->is64Bit()) {
809       memcpy(&lp, sect + i, sizeof(uint64_t));
810       if (O->isLittleEndian() != sys::IsLittleEndianHost)
811         sys::swapByteOrder(lp);
812     } else {
813       uint32_t li;
814       memcpy(&li, sect + i, sizeof(uint32_t));
815       if (O->isLittleEndian() != sys::IsLittleEndianHost)
816         sys::swapByteOrder(li);
817       lp = li;
818     }
819
820     // First look for an external relocation entry for this literal pointer.
821     auto Reloc = std::find_if(
822         Relocs.begin(), Relocs.end(),
823         [&](const std::pair<uint64_t, SymbolRef> &P) { return P.first == i; });
824     if (Reloc != Relocs.end()) {
825       symbol_iterator RelocSym = Reloc->second;
826       ErrorOr<StringRef> SymName = RelocSym->getName();
827       if (std::error_code EC = SymName.getError())
828         report_fatal_error(EC.message());
829       outs() << "external relocation entry for symbol:" << *SymName << "\n";
830       continue;
831     }
832
833     // For local references see what the section the literal pointer points to.
834     auto Sect = std::find_if(LiteralSections.begin(), LiteralSections.end(),
835                              [&](const SectionRef &R) {
836                                return lp >= R.getAddress() &&
837                                       lp < R.getAddress() + R.getSize();
838                              });
839     if (Sect == LiteralSections.end()) {
840       outs() << format("0x%" PRIx64, lp) << " (not in a literal section)\n";
841       continue;
842     }
843
844     uint64_t SectAddress = Sect->getAddress();
845     uint64_t SectSize = Sect->getSize();
846
847     StringRef SectName;
848     Sect->getName(SectName);
849     DataRefImpl Ref = Sect->getRawDataRefImpl();
850     StringRef SegmentName = O->getSectionFinalSegmentName(Ref);
851     outs() << SegmentName << ":" << SectName << ":";
852
853     uint32_t section_type;
854     if (O->is64Bit()) {
855       const MachO::section_64 Sec = O->getSection64(Ref);
856       section_type = Sec.flags & MachO::SECTION_TYPE;
857     } else {
858       const MachO::section Sec = O->getSection(Ref);
859       section_type = Sec.flags & MachO::SECTION_TYPE;
860     }
861
862     StringRef BytesStr;
863     Sect->getContents(BytesStr);
864     const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
865
866     switch (section_type) {
867     case MachO::S_CSTRING_LITERALS:
868       for (uint64_t i = lp - SectAddress; i < SectSize && Contents[i] != '\0';
869            i++) {
870         DumpCstringChar(Contents[i]);
871       }
872       outs() << "\n";
873       break;
874     case MachO::S_4BYTE_LITERALS:
875       float f;
876       memcpy(&f, Contents + (lp - SectAddress), sizeof(float));
877       uint32_t l;
878       memcpy(&l, Contents + (lp - SectAddress), sizeof(uint32_t));
879       if (O->isLittleEndian() != sys::IsLittleEndianHost) {
880         sys::swapByteOrder(f);
881         sys::swapByteOrder(l);
882       }
883       DumpLiteral4(l, f);
884       break;
885     case MachO::S_8BYTE_LITERALS: {
886       double d;
887       memcpy(&d, Contents + (lp - SectAddress), sizeof(double));
888       uint32_t l0, l1;
889       memcpy(&l0, Contents + (lp - SectAddress), sizeof(uint32_t));
890       memcpy(&l1, Contents + (lp - SectAddress) + sizeof(uint32_t),
891              sizeof(uint32_t));
892       if (O->isLittleEndian() != sys::IsLittleEndianHost) {
893         sys::swapByteOrder(f);
894         sys::swapByteOrder(l0);
895         sys::swapByteOrder(l1);
896       }
897       DumpLiteral8(O, l0, l1, d);
898       break;
899     }
900     case MachO::S_16BYTE_LITERALS: {
901       uint32_t l0, l1, l2, l3;
902       memcpy(&l0, Contents + (lp - SectAddress), sizeof(uint32_t));
903       memcpy(&l1, Contents + (lp - SectAddress) + sizeof(uint32_t),
904              sizeof(uint32_t));
905       memcpy(&l2, Contents + (lp - SectAddress) + 2 * sizeof(uint32_t),
906              sizeof(uint32_t));
907       memcpy(&l3, Contents + (lp - SectAddress) + 3 * sizeof(uint32_t),
908              sizeof(uint32_t));
909       if (O->isLittleEndian() != sys::IsLittleEndianHost) {
910         sys::swapByteOrder(l0);
911         sys::swapByteOrder(l1);
912         sys::swapByteOrder(l2);
913         sys::swapByteOrder(l3);
914       }
915       DumpLiteral16(l0, l1, l2, l3);
916       break;
917     }
918     }
919   }
920 }
921
922 static void DumpInitTermPointerSection(MachOObjectFile *O, const char *sect,
923                                        uint32_t sect_size, uint64_t sect_addr,
924                                        SymbolAddressMap *AddrMap,
925                                        bool verbose) {
926   uint32_t stride;
927   if (O->is64Bit())
928     stride = sizeof(uint64_t);
929   else
930     stride = sizeof(uint32_t);
931   for (uint32_t i = 0; i < sect_size; i += stride) {
932     const char *SymbolName = nullptr;
933     if (O->is64Bit()) {
934       outs() << format("0x%016" PRIx64, sect_addr + i * stride) << " ";
935       uint64_t pointer_value;
936       memcpy(&pointer_value, sect + i, stride);
937       if (O->isLittleEndian() != sys::IsLittleEndianHost)
938         sys::swapByteOrder(pointer_value);
939       outs() << format("0x%016" PRIx64, pointer_value);
940       if (verbose)
941         SymbolName = GuessSymbolName(pointer_value, AddrMap);
942     } else {
943       outs() << format("0x%08" PRIx64, sect_addr + i * stride) << " ";
944       uint32_t pointer_value;
945       memcpy(&pointer_value, sect + i, stride);
946       if (O->isLittleEndian() != sys::IsLittleEndianHost)
947         sys::swapByteOrder(pointer_value);
948       outs() << format("0x%08" PRIx32, pointer_value);
949       if (verbose)
950         SymbolName = GuessSymbolName(pointer_value, AddrMap);
951     }
952     if (SymbolName)
953       outs() << " " << SymbolName;
954     outs() << "\n";
955   }
956 }
957
958 static void DumpRawSectionContents(MachOObjectFile *O, const char *sect,
959                                    uint32_t size, uint64_t addr) {
960   uint32_t cputype = O->getHeader().cputype;
961   if (cputype == MachO::CPU_TYPE_I386 || cputype == MachO::CPU_TYPE_X86_64) {
962     uint32_t j;
963     for (uint32_t i = 0; i < size; i += j, addr += j) {
964       if (O->is64Bit())
965         outs() << format("%016" PRIx64, addr) << "\t";
966       else
967         outs() << format("%08" PRIx64, addr) << "\t";
968       for (j = 0; j < 16 && i + j < size; j++) {
969         uint8_t byte_word = *(sect + i + j);
970         outs() << format("%02" PRIx32, (uint32_t)byte_word) << " ";
971       }
972       outs() << "\n";
973     }
974   } else {
975     uint32_t j;
976     for (uint32_t i = 0; i < size; i += j, addr += j) {
977       if (O->is64Bit())
978         outs() << format("%016" PRIx64, addr) << "\t";
979       else
980         outs() << format("%08" PRIx64, sect) << "\t";
981       for (j = 0; j < 4 * sizeof(int32_t) && i + j < size;
982            j += sizeof(int32_t)) {
983         if (i + j + sizeof(int32_t) < size) {
984           uint32_t long_word;
985           memcpy(&long_word, sect + i + j, sizeof(int32_t));
986           if (O->isLittleEndian() != sys::IsLittleEndianHost)
987             sys::swapByteOrder(long_word);
988           outs() << format("%08" PRIx32, long_word) << " ";
989         } else {
990           for (uint32_t k = 0; i + j + k < size; k++) {
991             uint8_t byte_word = *(sect + i + j);
992             outs() << format("%02" PRIx32, (uint32_t)byte_word) << " ";
993           }
994         }
995       }
996       outs() << "\n";
997     }
998   }
999 }
1000
1001 static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
1002                              StringRef DisSegName, StringRef DisSectName);
1003 static void DumpProtocolSection(MachOObjectFile *O, const char *sect,
1004                                 uint32_t size, uint32_t addr);
1005
1006 static void DumpSectionContents(StringRef Filename, MachOObjectFile *O,
1007                                 bool verbose) {
1008   SymbolAddressMap AddrMap;
1009   if (verbose)
1010     CreateSymbolAddressMap(O, &AddrMap);
1011
1012   for (unsigned i = 0; i < DumpSections.size(); ++i) {
1013     StringRef DumpSection = DumpSections[i];
1014     std::pair<StringRef, StringRef> DumpSegSectName;
1015     DumpSegSectName = DumpSection.split(',');
1016     StringRef DumpSegName, DumpSectName;
1017     if (DumpSegSectName.second.size()) {
1018       DumpSegName = DumpSegSectName.first;
1019       DumpSectName = DumpSegSectName.second;
1020     } else {
1021       DumpSegName = "";
1022       DumpSectName = DumpSegSectName.first;
1023     }
1024     for (const SectionRef &Section : O->sections()) {
1025       StringRef SectName;
1026       Section.getName(SectName);
1027       DataRefImpl Ref = Section.getRawDataRefImpl();
1028       StringRef SegName = O->getSectionFinalSegmentName(Ref);
1029       if ((DumpSegName.empty() || SegName == DumpSegName) &&
1030           (SectName == DumpSectName)) {
1031
1032         uint32_t section_flags;
1033         if (O->is64Bit()) {
1034           const MachO::section_64 Sec = O->getSection64(Ref);
1035           section_flags = Sec.flags;
1036
1037         } else {
1038           const MachO::section Sec = O->getSection(Ref);
1039           section_flags = Sec.flags;
1040         }
1041         uint32_t section_type = section_flags & MachO::SECTION_TYPE;
1042
1043         StringRef BytesStr;
1044         Section.getContents(BytesStr);
1045         const char *sect = reinterpret_cast<const char *>(BytesStr.data());
1046         uint32_t sect_size = BytesStr.size();
1047         uint64_t sect_addr = Section.getAddress();
1048
1049         if (Raw) {
1050           outs().write(BytesStr.data(), BytesStr.size());
1051           continue;
1052         }
1053
1054         outs() << "Contents of (" << SegName << "," << SectName
1055                << ") section\n";
1056
1057         if (verbose) {
1058           if ((section_flags & MachO::S_ATTR_PURE_INSTRUCTIONS) ||
1059               (section_flags & MachO::S_ATTR_SOME_INSTRUCTIONS)) {
1060             DisassembleMachO(Filename, O, SegName, SectName);
1061             continue;
1062           }
1063           if (SegName == "__TEXT" && SectName == "__info_plist") {
1064             outs() << sect;
1065             continue;
1066           }
1067           if (SegName == "__OBJC" && SectName == "__protocol") {
1068             DumpProtocolSection(O, sect, sect_size, sect_addr);
1069             continue;
1070           }
1071           switch (section_type) {
1072           case MachO::S_REGULAR:
1073             DumpRawSectionContents(O, sect, sect_size, sect_addr);
1074             break;
1075           case MachO::S_ZEROFILL:
1076             outs() << "zerofill section and has no contents in the file\n";
1077             break;
1078           case MachO::S_CSTRING_LITERALS:
1079             DumpCstringSection(O, sect, sect_size, sect_addr, !NoLeadingAddr);
1080             break;
1081           case MachO::S_4BYTE_LITERALS:
1082             DumpLiteral4Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
1083             break;
1084           case MachO::S_8BYTE_LITERALS:
1085             DumpLiteral8Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
1086             break;
1087           case MachO::S_16BYTE_LITERALS:
1088             DumpLiteral16Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
1089             break;
1090           case MachO::S_LITERAL_POINTERS:
1091             DumpLiteralPointerSection(O, Section, sect, sect_size, sect_addr,
1092                                       !NoLeadingAddr);
1093             break;
1094           case MachO::S_MOD_INIT_FUNC_POINTERS:
1095           case MachO::S_MOD_TERM_FUNC_POINTERS:
1096             DumpInitTermPointerSection(O, sect, sect_size, sect_addr, &AddrMap,
1097                                        verbose);
1098             break;
1099           default:
1100             outs() << "Unknown section type ("
1101                    << format("0x%08" PRIx32, section_type) << ")\n";
1102             DumpRawSectionContents(O, sect, sect_size, sect_addr);
1103             break;
1104           }
1105         } else {
1106           if (section_type == MachO::S_ZEROFILL)
1107             outs() << "zerofill section and has no contents in the file\n";
1108           else
1109             DumpRawSectionContents(O, sect, sect_size, sect_addr);
1110         }
1111       }
1112     }
1113   }
1114 }
1115
1116 static void DumpInfoPlistSectionContents(StringRef Filename,
1117                                          MachOObjectFile *O) {
1118   for (const SectionRef &Section : O->sections()) {
1119     StringRef SectName;
1120     Section.getName(SectName);
1121     DataRefImpl Ref = Section.getRawDataRefImpl();
1122     StringRef SegName = O->getSectionFinalSegmentName(Ref);
1123     if (SegName == "__TEXT" && SectName == "__info_plist") {
1124       outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
1125       StringRef BytesStr;
1126       Section.getContents(BytesStr);
1127       const char *sect = reinterpret_cast<const char *>(BytesStr.data());
1128       outs() << sect;
1129       return;
1130     }
1131   }
1132 }
1133
1134 // checkMachOAndArchFlags() checks to see if the ObjectFile is a Mach-O file
1135 // and if it is and there is a list of architecture flags is specified then
1136 // check to make sure this Mach-O file is one of those architectures or all
1137 // architectures were specified.  If not then an error is generated and this
1138 // routine returns false.  Else it returns true.
1139 static bool checkMachOAndArchFlags(ObjectFile *O, StringRef Filename) {
1140   if (isa<MachOObjectFile>(O) && !ArchAll && ArchFlags.size() != 0) {
1141     MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O);
1142     bool ArchFound = false;
1143     MachO::mach_header H;
1144     MachO::mach_header_64 H_64;
1145     Triple T;
1146     if (MachO->is64Bit()) {
1147       H_64 = MachO->MachOObjectFile::getHeader64();
1148       T = MachOObjectFile::getArch(H_64.cputype, H_64.cpusubtype);
1149     } else {
1150       H = MachO->MachOObjectFile::getHeader();
1151       T = MachOObjectFile::getArch(H.cputype, H.cpusubtype);
1152     }
1153     unsigned i;
1154     for (i = 0; i < ArchFlags.size(); ++i) {
1155       if (ArchFlags[i] == T.getArchName())
1156         ArchFound = true;
1157       break;
1158     }
1159     if (!ArchFound) {
1160       errs() << "llvm-objdump: file: " + Filename + " does not contain "
1161              << "architecture: " + ArchFlags[i] + "\n";
1162       return false;
1163     }
1164   }
1165   return true;
1166 }
1167
1168 static void printObjcMetaData(MachOObjectFile *O, bool verbose);
1169
1170 // ProcessMachO() is passed a single opened Mach-O file, which may be an
1171 // archive member and or in a slice of a universal file.  It prints the
1172 // the file name and header info and then processes it according to the
1173 // command line options.
1174 static void ProcessMachO(StringRef Filename, MachOObjectFile *MachOOF,
1175                          StringRef ArchiveMemberName = StringRef(),
1176                          StringRef ArchitectureName = StringRef()) {
1177   // If we are doing some processing here on the Mach-O file print the header
1178   // info.  And don't print it otherwise like in the case of printing the
1179   // UniversalHeaders or ArchiveHeaders.
1180   if (Disassemble || PrivateHeaders || ExportsTrie || Rebase || Bind ||
1181       LazyBind || WeakBind || IndirectSymbols || DataInCode || LinkOptHints ||
1182       DylibsUsed || DylibId || ObjcMetaData ||
1183       (DumpSections.size() != 0 && !Raw)) {
1184     outs() << Filename;
1185     if (!ArchiveMemberName.empty())
1186       outs() << '(' << ArchiveMemberName << ')';
1187     if (!ArchitectureName.empty())
1188       outs() << " (architecture " << ArchitectureName << ")";
1189     outs() << ":\n";
1190   }
1191
1192   if (Disassemble)
1193     DisassembleMachO(Filename, MachOOF, "__TEXT", "__text");
1194   if (IndirectSymbols)
1195     PrintIndirectSymbols(MachOOF, !NonVerbose);
1196   if (DataInCode)
1197     PrintDataInCodeTable(MachOOF, !NonVerbose);
1198   if (LinkOptHints)
1199     PrintLinkOptHints(MachOOF);
1200   if (Relocations)
1201     PrintRelocations(MachOOF);
1202   if (SectionHeaders)
1203     PrintSectionHeaders(MachOOF);
1204   if (SectionContents)
1205     PrintSectionContents(MachOOF);
1206   if (DumpSections.size() != 0)
1207     DumpSectionContents(Filename, MachOOF, !NonVerbose);
1208   if (InfoPlist)
1209     DumpInfoPlistSectionContents(Filename, MachOOF);
1210   if (DylibsUsed)
1211     PrintDylibs(MachOOF, false);
1212   if (DylibId)
1213     PrintDylibs(MachOOF, true);
1214   if (SymbolTable)
1215     PrintSymbolTable(MachOOF);
1216   if (UnwindInfo)
1217     printMachOUnwindInfo(MachOOF);
1218   if (PrivateHeaders)
1219     printMachOFileHeader(MachOOF);
1220   if (ObjcMetaData)
1221     printObjcMetaData(MachOOF, !NonVerbose);
1222   if (ExportsTrie)
1223     printExportsTrie(MachOOF);
1224   if (Rebase)
1225     printRebaseTable(MachOOF);
1226   if (Bind)
1227     printBindTable(MachOOF);
1228   if (LazyBind)
1229     printLazyBindTable(MachOOF);
1230   if (WeakBind)
1231     printWeakBindTable(MachOOF);
1232 }
1233
1234 // printUnknownCPUType() helps print_fat_headers for unknown CPU's.
1235 static void printUnknownCPUType(uint32_t cputype, uint32_t cpusubtype) {
1236   outs() << "    cputype (" << cputype << ")\n";
1237   outs() << "    cpusubtype (" << cpusubtype << ")\n";
1238 }
1239
1240 // printCPUType() helps print_fat_headers by printing the cputype and
1241 // pusubtype (symbolically for the one's it knows about).
1242 static void printCPUType(uint32_t cputype, uint32_t cpusubtype) {
1243   switch (cputype) {
1244   case MachO::CPU_TYPE_I386:
1245     switch (cpusubtype) {
1246     case MachO::CPU_SUBTYPE_I386_ALL:
1247       outs() << "    cputype CPU_TYPE_I386\n";
1248       outs() << "    cpusubtype CPU_SUBTYPE_I386_ALL\n";
1249       break;
1250     default:
1251       printUnknownCPUType(cputype, cpusubtype);
1252       break;
1253     }
1254     break;
1255   case MachO::CPU_TYPE_X86_64:
1256     switch (cpusubtype) {
1257     case MachO::CPU_SUBTYPE_X86_64_ALL:
1258       outs() << "    cputype CPU_TYPE_X86_64\n";
1259       outs() << "    cpusubtype CPU_SUBTYPE_X86_64_ALL\n";
1260       break;
1261     case MachO::CPU_SUBTYPE_X86_64_H:
1262       outs() << "    cputype CPU_TYPE_X86_64\n";
1263       outs() << "    cpusubtype CPU_SUBTYPE_X86_64_H\n";
1264       break;
1265     default:
1266       printUnknownCPUType(cputype, cpusubtype);
1267       break;
1268     }
1269     break;
1270   case MachO::CPU_TYPE_ARM:
1271     switch (cpusubtype) {
1272     case MachO::CPU_SUBTYPE_ARM_ALL:
1273       outs() << "    cputype CPU_TYPE_ARM\n";
1274       outs() << "    cpusubtype CPU_SUBTYPE_ARM_ALL\n";
1275       break;
1276     case MachO::CPU_SUBTYPE_ARM_V4T:
1277       outs() << "    cputype CPU_TYPE_ARM\n";
1278       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V4T\n";
1279       break;
1280     case MachO::CPU_SUBTYPE_ARM_V5TEJ:
1281       outs() << "    cputype CPU_TYPE_ARM\n";
1282       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V5TEJ\n";
1283       break;
1284     case MachO::CPU_SUBTYPE_ARM_XSCALE:
1285       outs() << "    cputype CPU_TYPE_ARM\n";
1286       outs() << "    cpusubtype CPU_SUBTYPE_ARM_XSCALE\n";
1287       break;
1288     case MachO::CPU_SUBTYPE_ARM_V6:
1289       outs() << "    cputype CPU_TYPE_ARM\n";
1290       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V6\n";
1291       break;
1292     case MachO::CPU_SUBTYPE_ARM_V6M:
1293       outs() << "    cputype CPU_TYPE_ARM\n";
1294       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V6M\n";
1295       break;
1296     case MachO::CPU_SUBTYPE_ARM_V7:
1297       outs() << "    cputype CPU_TYPE_ARM\n";
1298       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7\n";
1299       break;
1300     case MachO::CPU_SUBTYPE_ARM_V7EM:
1301       outs() << "    cputype CPU_TYPE_ARM\n";
1302       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7EM\n";
1303       break;
1304     case MachO::CPU_SUBTYPE_ARM_V7K:
1305       outs() << "    cputype CPU_TYPE_ARM\n";
1306       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7K\n";
1307       break;
1308     case MachO::CPU_SUBTYPE_ARM_V7M:
1309       outs() << "    cputype CPU_TYPE_ARM\n";
1310       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7M\n";
1311       break;
1312     case MachO::CPU_SUBTYPE_ARM_V7S:
1313       outs() << "    cputype CPU_TYPE_ARM\n";
1314       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7S\n";
1315       break;
1316     default:
1317       printUnknownCPUType(cputype, cpusubtype);
1318       break;
1319     }
1320     break;
1321   case MachO::CPU_TYPE_ARM64:
1322     switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
1323     case MachO::CPU_SUBTYPE_ARM64_ALL:
1324       outs() << "    cputype CPU_TYPE_ARM64\n";
1325       outs() << "    cpusubtype CPU_SUBTYPE_ARM64_ALL\n";
1326       break;
1327     default:
1328       printUnknownCPUType(cputype, cpusubtype);
1329       break;
1330     }
1331     break;
1332   default:
1333     printUnknownCPUType(cputype, cpusubtype);
1334     break;
1335   }
1336 }
1337
1338 static void printMachOUniversalHeaders(const object::MachOUniversalBinary *UB,
1339                                        bool verbose) {
1340   outs() << "Fat headers\n";
1341   if (verbose)
1342     outs() << "fat_magic FAT_MAGIC\n";
1343   else
1344     outs() << "fat_magic " << format("0x%" PRIx32, MachO::FAT_MAGIC) << "\n";
1345
1346   uint32_t nfat_arch = UB->getNumberOfObjects();
1347   StringRef Buf = UB->getData();
1348   uint64_t size = Buf.size();
1349   uint64_t big_size = sizeof(struct MachO::fat_header) +
1350                       nfat_arch * sizeof(struct MachO::fat_arch);
1351   outs() << "nfat_arch " << UB->getNumberOfObjects();
1352   if (nfat_arch == 0)
1353     outs() << " (malformed, contains zero architecture types)\n";
1354   else if (big_size > size)
1355     outs() << " (malformed, architectures past end of file)\n";
1356   else
1357     outs() << "\n";
1358
1359   for (uint32_t i = 0; i < nfat_arch; ++i) {
1360     MachOUniversalBinary::ObjectForArch OFA(UB, i);
1361     uint32_t cputype = OFA.getCPUType();
1362     uint32_t cpusubtype = OFA.getCPUSubType();
1363     outs() << "architecture ";
1364     for (uint32_t j = 0; i != 0 && j <= i - 1; j++) {
1365       MachOUniversalBinary::ObjectForArch other_OFA(UB, j);
1366       uint32_t other_cputype = other_OFA.getCPUType();
1367       uint32_t other_cpusubtype = other_OFA.getCPUSubType();
1368       if (cputype != 0 && cpusubtype != 0 && cputype == other_cputype &&
1369           (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) ==
1370               (other_cpusubtype & ~MachO::CPU_SUBTYPE_MASK)) {
1371         outs() << "(illegal duplicate architecture) ";
1372         break;
1373       }
1374     }
1375     if (verbose) {
1376       outs() << OFA.getArchTypeName() << "\n";
1377       printCPUType(cputype, cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
1378     } else {
1379       outs() << i << "\n";
1380       outs() << "    cputype " << cputype << "\n";
1381       outs() << "    cpusubtype " << (cpusubtype & ~MachO::CPU_SUBTYPE_MASK)
1382              << "\n";
1383     }
1384     if (verbose &&
1385         (cpusubtype & MachO::CPU_SUBTYPE_MASK) == MachO::CPU_SUBTYPE_LIB64)
1386       outs() << "    capabilities CPU_SUBTYPE_LIB64\n";
1387     else
1388       outs() << "    capabilities "
1389              << format("0x%" PRIx32,
1390                        (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24) << "\n";
1391     outs() << "    offset " << OFA.getOffset();
1392     if (OFA.getOffset() > size)
1393       outs() << " (past end of file)";
1394     if (OFA.getOffset() % (1 << OFA.getAlign()) != 0)
1395       outs() << " (not aligned on it's alignment (2^" << OFA.getAlign() << ")";
1396     outs() << "\n";
1397     outs() << "    size " << OFA.getSize();
1398     big_size = OFA.getOffset() + OFA.getSize();
1399     if (big_size > size)
1400       outs() << " (past end of file)";
1401     outs() << "\n";
1402     outs() << "    align 2^" << OFA.getAlign() << " (" << (1 << OFA.getAlign())
1403            << ")\n";
1404   }
1405 }
1406
1407 static void printArchiveChild(Archive::Child &C, bool verbose,
1408                               bool print_offset) {
1409   if (print_offset)
1410     outs() << C.getChildOffset() << "\t";
1411   sys::fs::perms Mode = C.getAccessMode();
1412   if (verbose) {
1413     // FIXME: this first dash, "-", is for (Mode & S_IFMT) == S_IFREG.
1414     // But there is nothing in sys::fs::perms for S_IFMT or S_IFREG.
1415     outs() << "-";
1416     if (Mode & sys::fs::owner_read)
1417       outs() << "r";
1418     else
1419       outs() << "-";
1420     if (Mode & sys::fs::owner_write)
1421       outs() << "w";
1422     else
1423       outs() << "-";
1424     if (Mode & sys::fs::owner_exe)
1425       outs() << "x";
1426     else
1427       outs() << "-";
1428     if (Mode & sys::fs::group_read)
1429       outs() << "r";
1430     else
1431       outs() << "-";
1432     if (Mode & sys::fs::group_write)
1433       outs() << "w";
1434     else
1435       outs() << "-";
1436     if (Mode & sys::fs::group_exe)
1437       outs() << "x";
1438     else
1439       outs() << "-";
1440     if (Mode & sys::fs::others_read)
1441       outs() << "r";
1442     else
1443       outs() << "-";
1444     if (Mode & sys::fs::others_write)
1445       outs() << "w";
1446     else
1447       outs() << "-";
1448     if (Mode & sys::fs::others_exe)
1449       outs() << "x";
1450     else
1451       outs() << "-";
1452   } else {
1453     outs() << format("0%o ", Mode);
1454   }
1455
1456   unsigned UID = C.getUID();
1457   outs() << format("%3d/", UID);
1458   unsigned GID = C.getGID();
1459   outs() << format("%-3d ", GID);
1460   uint64_t Size = C.getRawSize();
1461   outs() << format("%5" PRId64, Size) << " ";
1462
1463   StringRef RawLastModified = C.getRawLastModified();
1464   if (verbose) {
1465     unsigned Seconds;
1466     if (RawLastModified.getAsInteger(10, Seconds))
1467       outs() << "(date: \"%s\" contains non-decimal chars) " << RawLastModified;
1468     else {
1469       // Since cime(3) returns a 26 character string of the form:
1470       // "Sun Sep 16 01:03:52 1973\n\0"
1471       // just print 24 characters.
1472       time_t t = Seconds;
1473       outs() << format("%.24s ", ctime(&t));
1474     }
1475   } else {
1476     outs() << RawLastModified << " ";
1477   }
1478
1479   if (verbose) {
1480     ErrorOr<StringRef> NameOrErr = C.getName();
1481     if (NameOrErr.getError()) {
1482       StringRef RawName = C.getRawName();
1483       outs() << RawName << "\n";
1484     } else {
1485       StringRef Name = NameOrErr.get();
1486       outs() << Name << "\n";
1487     }
1488   } else {
1489     StringRef RawName = C.getRawName();
1490     outs() << RawName << "\n";
1491   }
1492 }
1493
1494 static void printArchiveHeaders(Archive *A, bool verbose, bool print_offset) {
1495   if (A->hasSymbolTable()) {
1496     Archive::child_iterator S = A->getSymbolTableChild();
1497     Archive::Child C = *S;
1498     printArchiveChild(C, verbose, print_offset);
1499   }
1500   for (Archive::child_iterator I = A->child_begin(), E = A->child_end(); I != E;
1501        ++I) {
1502     Archive::Child C = *I;
1503     printArchiveChild(C, verbose, print_offset);
1504   }
1505 }
1506
1507 // ParseInputMachO() parses the named Mach-O file in Filename and handles the
1508 // -arch flags selecting just those slices as specified by them and also parses
1509 // archive files.  Then for each individual Mach-O file ProcessMachO() is
1510 // called to process the file based on the command line options.
1511 void llvm::ParseInputMachO(StringRef Filename) {
1512   // Check for -arch all and verifiy the -arch flags are valid.
1513   for (unsigned i = 0; i < ArchFlags.size(); ++i) {
1514     if (ArchFlags[i] == "all") {
1515       ArchAll = true;
1516     } else {
1517       if (!MachOObjectFile::isValidArch(ArchFlags[i])) {
1518         errs() << "llvm-objdump: Unknown architecture named '" + ArchFlags[i] +
1519                       "'for the -arch option\n";
1520         return;
1521       }
1522     }
1523   }
1524
1525   // Attempt to open the binary.
1526   ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(Filename);
1527   if (std::error_code EC = BinaryOrErr.getError()) {
1528     errs() << "llvm-objdump: '" << Filename << "': " << EC.message() << ".\n";
1529     return;
1530   }
1531   Binary &Bin = *BinaryOrErr.get().getBinary();
1532
1533   if (Archive *A = dyn_cast<Archive>(&Bin)) {
1534     outs() << "Archive : " << Filename << "\n";
1535     if (ArchiveHeaders)
1536       printArchiveHeaders(A, !NonVerbose, ArchiveMemberOffsets);
1537     for (Archive::child_iterator I = A->child_begin(), E = A->child_end();
1538          I != E; ++I) {
1539       ErrorOr<std::unique_ptr<Binary>> ChildOrErr = I->getAsBinary();
1540       if (ChildOrErr.getError())
1541         continue;
1542       if (MachOObjectFile *O = dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) {
1543         if (!checkMachOAndArchFlags(O, Filename))
1544           return;
1545         ProcessMachO(Filename, O, O->getFileName());
1546       }
1547     }
1548     return;
1549   }
1550   if (UniversalHeaders) {
1551     if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin))
1552       printMachOUniversalHeaders(UB, !NonVerbose);
1553   }
1554   if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) {
1555     // If we have a list of architecture flags specified dump only those.
1556     if (!ArchAll && ArchFlags.size() != 0) {
1557       // Look for a slice in the universal binary that matches each ArchFlag.
1558       bool ArchFound;
1559       for (unsigned i = 0; i < ArchFlags.size(); ++i) {
1560         ArchFound = false;
1561         for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1562                                                    E = UB->end_objects();
1563              I != E; ++I) {
1564           if (ArchFlags[i] == I->getArchTypeName()) {
1565             ArchFound = true;
1566             ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr =
1567                 I->getAsObjectFile();
1568             std::string ArchitectureName = "";
1569             if (ArchFlags.size() > 1)
1570               ArchitectureName = I->getArchTypeName();
1571             if (ObjOrErr) {
1572               ObjectFile &O = *ObjOrErr.get();
1573               if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O))
1574                 ProcessMachO(Filename, MachOOF, "", ArchitectureName);
1575             } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr =
1576                            I->getAsArchive()) {
1577               std::unique_ptr<Archive> &A = *AOrErr;
1578               outs() << "Archive : " << Filename;
1579               if (!ArchitectureName.empty())
1580                 outs() << " (architecture " << ArchitectureName << ")";
1581               outs() << "\n";
1582               if (ArchiveHeaders)
1583                 printArchiveHeaders(A.get(), !NonVerbose, ArchiveMemberOffsets);
1584               for (Archive::child_iterator AI = A->child_begin(),
1585                                            AE = A->child_end();
1586                    AI != AE; ++AI) {
1587                 ErrorOr<std::unique_ptr<Binary>> ChildOrErr = AI->getAsBinary();
1588                 if (ChildOrErr.getError())
1589                   continue;
1590                 if (MachOObjectFile *O =
1591                         dyn_cast<MachOObjectFile>(&*ChildOrErr.get()))
1592                   ProcessMachO(Filename, O, O->getFileName(), ArchitectureName);
1593               }
1594             }
1595           }
1596         }
1597         if (!ArchFound) {
1598           errs() << "llvm-objdump: file: " + Filename + " does not contain "
1599                  << "architecture: " + ArchFlags[i] + "\n";
1600           return;
1601         }
1602       }
1603       return;
1604     }
1605     // No architecture flags were specified so if this contains a slice that
1606     // matches the host architecture dump only that.
1607     if (!ArchAll) {
1608       for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1609                                                  E = UB->end_objects();
1610            I != E; ++I) {
1611         if (MachOObjectFile::getHostArch().getArchName() ==
1612             I->getArchTypeName()) {
1613           ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
1614           std::string ArchiveName;
1615           ArchiveName.clear();
1616           if (ObjOrErr) {
1617             ObjectFile &O = *ObjOrErr.get();
1618             if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O))
1619               ProcessMachO(Filename, MachOOF);
1620           } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr =
1621                          I->getAsArchive()) {
1622             std::unique_ptr<Archive> &A = *AOrErr;
1623             outs() << "Archive : " << Filename << "\n";
1624             if (ArchiveHeaders)
1625               printArchiveHeaders(A.get(), !NonVerbose, ArchiveMemberOffsets);
1626             for (Archive::child_iterator AI = A->child_begin(),
1627                                          AE = A->child_end();
1628                  AI != AE; ++AI) {
1629               ErrorOr<std::unique_ptr<Binary>> ChildOrErr = AI->getAsBinary();
1630               if (ChildOrErr.getError())
1631                 continue;
1632               if (MachOObjectFile *O =
1633                       dyn_cast<MachOObjectFile>(&*ChildOrErr.get()))
1634                 ProcessMachO(Filename, O, O->getFileName());
1635             }
1636           }
1637           return;
1638         }
1639       }
1640     }
1641     // Either all architectures have been specified or none have been specified
1642     // and this does not contain the host architecture so dump all the slices.
1643     bool moreThanOneArch = UB->getNumberOfObjects() > 1;
1644     for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1645                                                E = UB->end_objects();
1646          I != E; ++I) {
1647       ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
1648       std::string ArchitectureName = "";
1649       if (moreThanOneArch)
1650         ArchitectureName = I->getArchTypeName();
1651       if (ObjOrErr) {
1652         ObjectFile &Obj = *ObjOrErr.get();
1653         if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&Obj))
1654           ProcessMachO(Filename, MachOOF, "", ArchitectureName);
1655       } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr = I->getAsArchive()) {
1656         std::unique_ptr<Archive> &A = *AOrErr;
1657         outs() << "Archive : " << Filename;
1658         if (!ArchitectureName.empty())
1659           outs() << " (architecture " << ArchitectureName << ")";
1660         outs() << "\n";
1661         if (ArchiveHeaders)
1662           printArchiveHeaders(A.get(), !NonVerbose, ArchiveMemberOffsets);
1663         for (Archive::child_iterator AI = A->child_begin(), AE = A->child_end();
1664              AI != AE; ++AI) {
1665           ErrorOr<std::unique_ptr<Binary>> ChildOrErr = AI->getAsBinary();
1666           if (ChildOrErr.getError())
1667             continue;
1668           if (MachOObjectFile *O =
1669                   dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) {
1670             if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(O))
1671               ProcessMachO(Filename, MachOOF, MachOOF->getFileName(),
1672                            ArchitectureName);
1673           }
1674         }
1675       }
1676     }
1677     return;
1678   }
1679   if (ObjectFile *O = dyn_cast<ObjectFile>(&Bin)) {
1680     if (!checkMachOAndArchFlags(O, Filename))
1681       return;
1682     if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&*O)) {
1683       ProcessMachO(Filename, MachOOF);
1684     } else
1685       errs() << "llvm-objdump: '" << Filename << "': "
1686              << "Object is not a Mach-O file type.\n";
1687   } else
1688     errs() << "llvm-objdump: '" << Filename << "': "
1689            << "Unrecognized file type.\n";
1690 }
1691
1692 typedef std::pair<uint64_t, const char *> BindInfoEntry;
1693 typedef std::vector<BindInfoEntry> BindTable;
1694 typedef BindTable::iterator bind_table_iterator;
1695
1696 // The block of info used by the Symbolizer call backs.
1697 struct DisassembleInfo {
1698   bool verbose;
1699   MachOObjectFile *O;
1700   SectionRef S;
1701   SymbolAddressMap *AddrMap;
1702   std::vector<SectionRef> *Sections;
1703   const char *class_name;
1704   const char *selector_name;
1705   char *method;
1706   char *demangled_name;
1707   uint64_t adrp_addr;
1708   uint32_t adrp_inst;
1709   BindTable *bindtable;
1710 };
1711
1712 // SymbolizerGetOpInfo() is the operand information call back function.
1713 // This is called to get the symbolic information for operand(s) of an
1714 // instruction when it is being done.  This routine does this from
1715 // the relocation information, symbol table, etc. That block of information
1716 // is a pointer to the struct DisassembleInfo that was passed when the
1717 // disassembler context was created and passed to back to here when
1718 // called back by the disassembler for instruction operands that could have
1719 // relocation information. The address of the instruction containing operand is
1720 // at the Pc parameter.  The immediate value the operand has is passed in
1721 // op_info->Value and is at Offset past the start of the instruction and has a
1722 // byte Size of 1, 2 or 4. The symbolc information is returned in TagBuf is the
1723 // LLVMOpInfo1 struct defined in the header "llvm-c/Disassembler.h" as symbol
1724 // names and addends of the symbolic expression to add for the operand.  The
1725 // value of TagType is currently 1 (for the LLVMOpInfo1 struct). If symbolic
1726 // information is returned then this function returns 1 else it returns 0.
1727 static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
1728                                uint64_t Size, int TagType, void *TagBuf) {
1729   struct DisassembleInfo *info = (struct DisassembleInfo *)DisInfo;
1730   struct LLVMOpInfo1 *op_info = (struct LLVMOpInfo1 *)TagBuf;
1731   uint64_t value = op_info->Value;
1732
1733   // Make sure all fields returned are zero if we don't set them.
1734   memset((void *)op_info, '\0', sizeof(struct LLVMOpInfo1));
1735   op_info->Value = value;
1736
1737   // If the TagType is not the value 1 which it code knows about or if no
1738   // verbose symbolic information is wanted then just return 0, indicating no
1739   // information is being returned.
1740   if (TagType != 1 || !info->verbose)
1741     return 0;
1742
1743   unsigned int Arch = info->O->getArch();
1744   if (Arch == Triple::x86) {
1745     if (Size != 1 && Size != 2 && Size != 4 && Size != 0)
1746       return 0;
1747     // First search the section's relocation entries (if any) for an entry
1748     // for this section offset.
1749     uint32_t sect_addr = info->S.getAddress();
1750     uint32_t sect_offset = (Pc + Offset) - sect_addr;
1751     bool reloc_found = false;
1752     DataRefImpl Rel;
1753     MachO::any_relocation_info RE;
1754     bool isExtern = false;
1755     SymbolRef Symbol;
1756     bool r_scattered = false;
1757     uint32_t r_value, pair_r_value, r_type;
1758     for (const RelocationRef &Reloc : info->S.relocations()) {
1759       uint64_t RelocOffset = Reloc.getOffset();
1760       if (RelocOffset == sect_offset) {
1761         Rel = Reloc.getRawDataRefImpl();
1762         RE = info->O->getRelocation(Rel);
1763         r_type = info->O->getAnyRelocationType(RE);
1764         r_scattered = info->O->isRelocationScattered(RE);
1765         if (r_scattered) {
1766           r_value = info->O->getScatteredRelocationValue(RE);
1767           if (r_type == MachO::GENERIC_RELOC_SECTDIFF ||
1768               r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF) {
1769             DataRefImpl RelNext = Rel;
1770             info->O->moveRelocationNext(RelNext);
1771             MachO::any_relocation_info RENext;
1772             RENext = info->O->getRelocation(RelNext);
1773             if (info->O->isRelocationScattered(RENext))
1774               pair_r_value = info->O->getScatteredRelocationValue(RENext);
1775             else
1776               return 0;
1777           }
1778         } else {
1779           isExtern = info->O->getPlainRelocationExternal(RE);
1780           if (isExtern) {
1781             symbol_iterator RelocSym = Reloc.getSymbol();
1782             Symbol = *RelocSym;
1783           }
1784         }
1785         reloc_found = true;
1786         break;
1787       }
1788     }
1789     if (reloc_found && isExtern) {
1790       ErrorOr<StringRef> SymName = Symbol.getName();
1791       if (std::error_code EC = SymName.getError())
1792         report_fatal_error(EC.message());
1793       const char *name = SymName->data();
1794       op_info->AddSymbol.Present = 1;
1795       op_info->AddSymbol.Name = name;
1796       // For i386 extern relocation entries the value in the instruction is
1797       // the offset from the symbol, and value is already set in op_info->Value.
1798       return 1;
1799     }
1800     if (reloc_found && (r_type == MachO::GENERIC_RELOC_SECTDIFF ||
1801                         r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)) {
1802       const char *add = GuessSymbolName(r_value, info->AddrMap);
1803       const char *sub = GuessSymbolName(pair_r_value, info->AddrMap);
1804       uint32_t offset = value - (r_value - pair_r_value);
1805       op_info->AddSymbol.Present = 1;
1806       if (add != nullptr)
1807         op_info->AddSymbol.Name = add;
1808       else
1809         op_info->AddSymbol.Value = r_value;
1810       op_info->SubtractSymbol.Present = 1;
1811       if (sub != nullptr)
1812         op_info->SubtractSymbol.Name = sub;
1813       else
1814         op_info->SubtractSymbol.Value = pair_r_value;
1815       op_info->Value = offset;
1816       return 1;
1817     }
1818     // TODO:
1819     // Second search the external relocation entries of a fully linked image
1820     // (if any) for an entry that matches this segment offset.
1821     // uint32_t seg_offset = (Pc + Offset);
1822     return 0;
1823   }
1824   if (Arch == Triple::x86_64) {
1825     if (Size != 1 && Size != 2 && Size != 4 && Size != 0)
1826       return 0;
1827     // First search the section's relocation entries (if any) for an entry
1828     // for this section offset.
1829     uint64_t sect_addr = info->S.getAddress();
1830     uint64_t sect_offset = (Pc + Offset) - sect_addr;
1831     bool reloc_found = false;
1832     DataRefImpl Rel;
1833     MachO::any_relocation_info RE;
1834     bool isExtern = false;
1835     SymbolRef Symbol;
1836     for (const RelocationRef &Reloc : info->S.relocations()) {
1837       uint64_t RelocOffset = Reloc.getOffset();
1838       if (RelocOffset == sect_offset) {
1839         Rel = Reloc.getRawDataRefImpl();
1840         RE = info->O->getRelocation(Rel);
1841         // NOTE: Scattered relocations don't exist on x86_64.
1842         isExtern = info->O->getPlainRelocationExternal(RE);
1843         if (isExtern) {
1844           symbol_iterator RelocSym = Reloc.getSymbol();
1845           Symbol = *RelocSym;
1846         }
1847         reloc_found = true;
1848         break;
1849       }
1850     }
1851     if (reloc_found && isExtern) {
1852       // The Value passed in will be adjusted by the Pc if the instruction
1853       // adds the Pc.  But for x86_64 external relocation entries the Value
1854       // is the offset from the external symbol.
1855       if (info->O->getAnyRelocationPCRel(RE))
1856         op_info->Value -= Pc + Offset + Size;
1857       ErrorOr<StringRef> SymName = Symbol.getName();
1858       if (std::error_code EC = SymName.getError())
1859         report_fatal_error(EC.message());
1860       const char *name = SymName->data();
1861       unsigned Type = info->O->getAnyRelocationType(RE);
1862       if (Type == MachO::X86_64_RELOC_SUBTRACTOR) {
1863         DataRefImpl RelNext = Rel;
1864         info->O->moveRelocationNext(RelNext);
1865         MachO::any_relocation_info RENext = info->O->getRelocation(RelNext);
1866         unsigned TypeNext = info->O->getAnyRelocationType(RENext);
1867         bool isExternNext = info->O->getPlainRelocationExternal(RENext);
1868         unsigned SymbolNum = info->O->getPlainRelocationSymbolNum(RENext);
1869         if (TypeNext == MachO::X86_64_RELOC_UNSIGNED && isExternNext) {
1870           op_info->SubtractSymbol.Present = 1;
1871           op_info->SubtractSymbol.Name = name;
1872           symbol_iterator RelocSymNext = info->O->getSymbolByIndex(SymbolNum);
1873           Symbol = *RelocSymNext;
1874           ErrorOr<StringRef> SymNameNext = Symbol.getName();
1875           if (std::error_code EC = SymNameNext.getError())
1876             report_fatal_error(EC.message());
1877           name = SymNameNext->data();
1878         }
1879       }
1880       // TODO: add the VariantKinds to op_info->VariantKind for relocation types
1881       // like: X86_64_RELOC_TLV, X86_64_RELOC_GOT_LOAD and X86_64_RELOC_GOT.
1882       op_info->AddSymbol.Present = 1;
1883       op_info->AddSymbol.Name = name;
1884       return 1;
1885     }
1886     // TODO:
1887     // Second search the external relocation entries of a fully linked image
1888     // (if any) for an entry that matches this segment offset.
1889     // uint64_t seg_offset = (Pc + Offset);
1890     return 0;
1891   }
1892   if (Arch == Triple::arm) {
1893     if (Offset != 0 || (Size != 4 && Size != 2))
1894       return 0;
1895     // First search the section's relocation entries (if any) for an entry
1896     // for this section offset.
1897     uint32_t sect_addr = info->S.getAddress();
1898     uint32_t sect_offset = (Pc + Offset) - sect_addr;
1899     DataRefImpl Rel;
1900     MachO::any_relocation_info RE;
1901     bool isExtern = false;
1902     SymbolRef Symbol;
1903     bool r_scattered = false;
1904     uint32_t r_value, pair_r_value, r_type, r_length, other_half;
1905     auto Reloc =
1906         std::find_if(info->S.relocations().begin(), info->S.relocations().end(),
1907                      [&](const RelocationRef &Reloc) {
1908                        uint64_t RelocOffset = Reloc.getOffset();
1909                        return RelocOffset == sect_offset;
1910                      });
1911
1912     if (Reloc == info->S.relocations().end())
1913       return 0;
1914
1915     Rel = Reloc->getRawDataRefImpl();
1916     RE = info->O->getRelocation(Rel);
1917     r_length = info->O->getAnyRelocationLength(RE);
1918     r_scattered = info->O->isRelocationScattered(RE);
1919     if (r_scattered) {
1920       r_value = info->O->getScatteredRelocationValue(RE);
1921       r_type = info->O->getScatteredRelocationType(RE);
1922     } else {
1923       r_type = info->O->getAnyRelocationType(RE);
1924       isExtern = info->O->getPlainRelocationExternal(RE);
1925       if (isExtern) {
1926         symbol_iterator RelocSym = Reloc->getSymbol();
1927         Symbol = *RelocSym;
1928       }
1929     }
1930     if (r_type == MachO::ARM_RELOC_HALF ||
1931         r_type == MachO::ARM_RELOC_SECTDIFF ||
1932         r_type == MachO::ARM_RELOC_LOCAL_SECTDIFF ||
1933         r_type == MachO::ARM_RELOC_HALF_SECTDIFF) {
1934       DataRefImpl RelNext = Rel;
1935       info->O->moveRelocationNext(RelNext);
1936       MachO::any_relocation_info RENext;
1937       RENext = info->O->getRelocation(RelNext);
1938       other_half = info->O->getAnyRelocationAddress(RENext) & 0xffff;
1939       if (info->O->isRelocationScattered(RENext))
1940         pair_r_value = info->O->getScatteredRelocationValue(RENext);
1941     }
1942
1943     if (isExtern) {
1944       ErrorOr<StringRef> SymName = Symbol.getName();
1945       if (std::error_code EC = SymName.getError())
1946         report_fatal_error(EC.message());
1947       const char *name = SymName->data();
1948       op_info->AddSymbol.Present = 1;
1949       op_info->AddSymbol.Name = name;
1950       switch (r_type) {
1951       case MachO::ARM_RELOC_HALF:
1952         if ((r_length & 0x1) == 1) {
1953           op_info->Value = value << 16 | other_half;
1954           op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI16;
1955         } else {
1956           op_info->Value = other_half << 16 | value;
1957           op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO16;
1958         }
1959         break;
1960       default:
1961         break;
1962       }
1963       return 1;
1964     }
1965     // If we have a branch that is not an external relocation entry then
1966     // return 0 so the code in tryAddingSymbolicOperand() can use the
1967     // SymbolLookUp call back with the branch target address to look up the
1968     // symbol and possiblity add an annotation for a symbol stub.
1969     if (isExtern == 0 && (r_type == MachO::ARM_RELOC_BR24 ||
1970                           r_type == MachO::ARM_THUMB_RELOC_BR22))
1971       return 0;
1972
1973     uint32_t offset = 0;
1974     if (r_type == MachO::ARM_RELOC_HALF ||
1975         r_type == MachO::ARM_RELOC_HALF_SECTDIFF) {
1976       if ((r_length & 0x1) == 1)
1977         value = value << 16 | other_half;
1978       else
1979         value = other_half << 16 | value;
1980     }
1981     if (r_scattered && (r_type != MachO::ARM_RELOC_HALF &&
1982                         r_type != MachO::ARM_RELOC_HALF_SECTDIFF)) {
1983       offset = value - r_value;
1984       value = r_value;
1985     }
1986
1987     if (r_type == MachO::ARM_RELOC_HALF_SECTDIFF) {
1988       if ((r_length & 0x1) == 1)
1989         op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI16;
1990       else
1991         op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO16;
1992       const char *add = GuessSymbolName(r_value, info->AddrMap);
1993       const char *sub = GuessSymbolName(pair_r_value, info->AddrMap);
1994       int32_t offset = value - (r_value - pair_r_value);
1995       op_info->AddSymbol.Present = 1;
1996       if (add != nullptr)
1997         op_info->AddSymbol.Name = add;
1998       else
1999         op_info->AddSymbol.Value = r_value;
2000       op_info->SubtractSymbol.Present = 1;
2001       if (sub != nullptr)
2002         op_info->SubtractSymbol.Name = sub;
2003       else
2004         op_info->SubtractSymbol.Value = pair_r_value;
2005       op_info->Value = offset;
2006       return 1;
2007     }
2008
2009     op_info->AddSymbol.Present = 1;
2010     op_info->Value = offset;
2011     if (r_type == MachO::ARM_RELOC_HALF) {
2012       if ((r_length & 0x1) == 1)
2013         op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI16;
2014       else
2015         op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO16;
2016     }
2017     const char *add = GuessSymbolName(value, info->AddrMap);
2018     if (add != nullptr) {
2019       op_info->AddSymbol.Name = add;
2020       return 1;
2021     }
2022     op_info->AddSymbol.Value = value;
2023     return 1;
2024   }
2025   if (Arch == Triple::aarch64) {
2026     if (Offset != 0 || Size != 4)
2027       return 0;
2028     // First search the section's relocation entries (if any) for an entry
2029     // for this section offset.
2030     uint64_t sect_addr = info->S.getAddress();
2031     uint64_t sect_offset = (Pc + Offset) - sect_addr;
2032     auto Reloc =
2033         std::find_if(info->S.relocations().begin(), info->S.relocations().end(),
2034                      [&](const RelocationRef &Reloc) {
2035                        uint64_t RelocOffset = Reloc.getOffset();
2036                        return RelocOffset == sect_offset;
2037                      });
2038
2039     if (Reloc == info->S.relocations().end())
2040       return 0;
2041
2042     DataRefImpl Rel = Reloc->getRawDataRefImpl();
2043     MachO::any_relocation_info RE = info->O->getRelocation(Rel);
2044     uint32_t r_type = info->O->getAnyRelocationType(RE);
2045     if (r_type == MachO::ARM64_RELOC_ADDEND) {
2046       DataRefImpl RelNext = Rel;
2047       info->O->moveRelocationNext(RelNext);
2048       MachO::any_relocation_info RENext = info->O->getRelocation(RelNext);
2049       if (value == 0) {
2050         value = info->O->getPlainRelocationSymbolNum(RENext);
2051         op_info->Value = value;
2052       }
2053     }
2054     // NOTE: Scattered relocations don't exist on arm64.
2055     if (!info->O->getPlainRelocationExternal(RE))
2056       return 0;
2057     ErrorOr<StringRef> SymName = Reloc->getSymbol()->getName();
2058     if (std::error_code EC = SymName.getError())
2059       report_fatal_error(EC.message());
2060     const char *name = SymName->data();
2061     op_info->AddSymbol.Present = 1;
2062     op_info->AddSymbol.Name = name;
2063
2064     switch (r_type) {
2065     case MachO::ARM64_RELOC_PAGE21:
2066       /* @page */
2067       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_PAGE;
2068       break;
2069     case MachO::ARM64_RELOC_PAGEOFF12:
2070       /* @pageoff */
2071       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_PAGEOFF;
2072       break;
2073     case MachO::ARM64_RELOC_GOT_LOAD_PAGE21:
2074       /* @gotpage */
2075       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_GOTPAGE;
2076       break;
2077     case MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12:
2078       /* @gotpageoff */
2079       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF;
2080       break;
2081     case MachO::ARM64_RELOC_TLVP_LOAD_PAGE21:
2082       /* @tvlppage is not implemented in llvm-mc */
2083       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_TLVP;
2084       break;
2085     case MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12:
2086       /* @tvlppageoff is not implemented in llvm-mc */
2087       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_TLVOFF;
2088       break;
2089     default:
2090     case MachO::ARM64_RELOC_BRANCH26:
2091       op_info->VariantKind = LLVMDisassembler_VariantKind_None;
2092       break;
2093     }
2094     return 1;
2095   }
2096   return 0;
2097 }
2098
2099 // GuessCstringPointer is passed the address of what might be a pointer to a
2100 // literal string in a cstring section.  If that address is in a cstring section
2101 // it returns a pointer to that string.  Else it returns nullptr.
2102 static const char *GuessCstringPointer(uint64_t ReferenceValue,
2103                                        struct DisassembleInfo *info) {
2104   for (const auto &Load : info->O->load_commands()) {
2105     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
2106       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
2107       for (unsigned J = 0; J < Seg.nsects; ++J) {
2108         MachO::section_64 Sec = info->O->getSection64(Load, J);
2109         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
2110         if (section_type == MachO::S_CSTRING_LITERALS &&
2111             ReferenceValue >= Sec.addr &&
2112             ReferenceValue < Sec.addr + Sec.size) {
2113           uint64_t sect_offset = ReferenceValue - Sec.addr;
2114           uint64_t object_offset = Sec.offset + sect_offset;
2115           StringRef MachOContents = info->O->getData();
2116           uint64_t object_size = MachOContents.size();
2117           const char *object_addr = (const char *)MachOContents.data();
2118           if (object_offset < object_size) {
2119             const char *name = object_addr + object_offset;
2120             return name;
2121           } else {
2122             return nullptr;
2123           }
2124         }
2125       }
2126     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
2127       MachO::segment_command Seg = info->O->getSegmentLoadCommand(Load);
2128       for (unsigned J = 0; J < Seg.nsects; ++J) {
2129         MachO::section Sec = info->O->getSection(Load, J);
2130         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
2131         if (section_type == MachO::S_CSTRING_LITERALS &&
2132             ReferenceValue >= Sec.addr &&
2133             ReferenceValue < Sec.addr + Sec.size) {
2134           uint64_t sect_offset = ReferenceValue - Sec.addr;
2135           uint64_t object_offset = Sec.offset + sect_offset;
2136           StringRef MachOContents = info->O->getData();
2137           uint64_t object_size = MachOContents.size();
2138           const char *object_addr = (const char *)MachOContents.data();
2139           if (object_offset < object_size) {
2140             const char *name = object_addr + object_offset;
2141             return name;
2142           } else {
2143             return nullptr;
2144           }
2145         }
2146       }
2147     }
2148   }
2149   return nullptr;
2150 }
2151
2152 // GuessIndirectSymbol returns the name of the indirect symbol for the
2153 // ReferenceValue passed in or nullptr.  This is used when ReferenceValue maybe
2154 // an address of a symbol stub or a lazy or non-lazy pointer to associate the
2155 // symbol name being referenced by the stub or pointer.
2156 static const char *GuessIndirectSymbol(uint64_t ReferenceValue,
2157                                        struct DisassembleInfo *info) {
2158   MachO::dysymtab_command Dysymtab = info->O->getDysymtabLoadCommand();
2159   MachO::symtab_command Symtab = info->O->getSymtabLoadCommand();
2160   for (const auto &Load : info->O->load_commands()) {
2161     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
2162       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
2163       for (unsigned J = 0; J < Seg.nsects; ++J) {
2164         MachO::section_64 Sec = info->O->getSection64(Load, J);
2165         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
2166         if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
2167              section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
2168              section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
2169              section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
2170              section_type == MachO::S_SYMBOL_STUBS) &&
2171             ReferenceValue >= Sec.addr &&
2172             ReferenceValue < Sec.addr + Sec.size) {
2173           uint32_t stride;
2174           if (section_type == MachO::S_SYMBOL_STUBS)
2175             stride = Sec.reserved2;
2176           else
2177             stride = 8;
2178           if (stride == 0)
2179             return nullptr;
2180           uint32_t index = Sec.reserved1 + (ReferenceValue - Sec.addr) / stride;
2181           if (index < Dysymtab.nindirectsyms) {
2182             uint32_t indirect_symbol =
2183                 info->O->getIndirectSymbolTableEntry(Dysymtab, index);
2184             if (indirect_symbol < Symtab.nsyms) {
2185               symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol);
2186               SymbolRef Symbol = *Sym;
2187               ErrorOr<StringRef> SymName = Symbol.getName();
2188               if (std::error_code EC = SymName.getError())
2189                 report_fatal_error(EC.message());
2190               const char *name = SymName->data();
2191               return name;
2192             }
2193           }
2194         }
2195       }
2196     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
2197       MachO::segment_command Seg = info->O->getSegmentLoadCommand(Load);
2198       for (unsigned J = 0; J < Seg.nsects; ++J) {
2199         MachO::section Sec = info->O->getSection(Load, J);
2200         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
2201         if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
2202              section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
2203              section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
2204              section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
2205              section_type == MachO::S_SYMBOL_STUBS) &&
2206             ReferenceValue >= Sec.addr &&
2207             ReferenceValue < Sec.addr + Sec.size) {
2208           uint32_t stride;
2209           if (section_type == MachO::S_SYMBOL_STUBS)
2210             stride = Sec.reserved2;
2211           else
2212             stride = 4;
2213           if (stride == 0)
2214             return nullptr;
2215           uint32_t index = Sec.reserved1 + (ReferenceValue - Sec.addr) / stride;
2216           if (index < Dysymtab.nindirectsyms) {
2217             uint32_t indirect_symbol =
2218                 info->O->getIndirectSymbolTableEntry(Dysymtab, index);
2219             if (indirect_symbol < Symtab.nsyms) {
2220               symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol);
2221               SymbolRef Symbol = *Sym;
2222               ErrorOr<StringRef> SymName = Symbol.getName();
2223               if (std::error_code EC = SymName.getError())
2224                 report_fatal_error(EC.message());
2225               const char *name = SymName->data();
2226               return name;
2227             }
2228           }
2229         }
2230       }
2231     }
2232   }
2233   return nullptr;
2234 }
2235
2236 // method_reference() is called passing it the ReferenceName that might be
2237 // a reference it to an Objective-C method call.  If so then it allocates and
2238 // assembles a method call string with the values last seen and saved in
2239 // the DisassembleInfo's class_name and selector_name fields.  This is saved
2240 // into the method field of the info and any previous string is free'ed.
2241 // Then the class_name field in the info is set to nullptr.  The method call
2242 // string is set into ReferenceName and ReferenceType is set to
2243 // LLVMDisassembler_ReferenceType_Out_Objc_Message.  If this not a method call
2244 // then both ReferenceType and ReferenceName are left unchanged.
2245 static void method_reference(struct DisassembleInfo *info,
2246                              uint64_t *ReferenceType,
2247                              const char **ReferenceName) {
2248   unsigned int Arch = info->O->getArch();
2249   if (*ReferenceName != nullptr) {
2250     if (strcmp(*ReferenceName, "_objc_msgSend") == 0) {
2251       if (info->selector_name != nullptr) {
2252         if (info->method != nullptr)
2253           free(info->method);
2254         if (info->class_name != nullptr) {
2255           info->method = (char *)malloc(5 + strlen(info->class_name) +
2256                                         strlen(info->selector_name));
2257           if (info->method != nullptr) {
2258             strcpy(info->method, "+[");
2259             strcat(info->method, info->class_name);
2260             strcat(info->method, " ");
2261             strcat(info->method, info->selector_name);
2262             strcat(info->method, "]");
2263             *ReferenceName = info->method;
2264             *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message;
2265           }
2266         } else {
2267           info->method = (char *)malloc(9 + strlen(info->selector_name));
2268           if (info->method != nullptr) {
2269             if (Arch == Triple::x86_64)
2270               strcpy(info->method, "-[%rdi ");
2271             else if (Arch == Triple::aarch64)
2272               strcpy(info->method, "-[x0 ");
2273             else
2274               strcpy(info->method, "-[r? ");
2275             strcat(info->method, info->selector_name);
2276             strcat(info->method, "]");
2277             *ReferenceName = info->method;
2278             *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message;
2279           }
2280         }
2281         info->class_name = nullptr;
2282       }
2283     } else if (strcmp(*ReferenceName, "_objc_msgSendSuper2") == 0) {
2284       if (info->selector_name != nullptr) {
2285         if (info->method != nullptr)
2286           free(info->method);
2287         info->method = (char *)malloc(17 + strlen(info->selector_name));
2288         if (info->method != nullptr) {
2289           if (Arch == Triple::x86_64)
2290             strcpy(info->method, "-[[%rdi super] ");
2291           else if (Arch == Triple::aarch64)
2292             strcpy(info->method, "-[[x0 super] ");
2293           else
2294             strcpy(info->method, "-[[r? super] ");
2295           strcat(info->method, info->selector_name);
2296           strcat(info->method, "]");
2297           *ReferenceName = info->method;
2298           *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message;
2299         }
2300         info->class_name = nullptr;
2301       }
2302     }
2303   }
2304 }
2305
2306 // GuessPointerPointer() is passed the address of what might be a pointer to
2307 // a reference to an Objective-C class, selector, message ref or cfstring.
2308 // If so the value of the pointer is returned and one of the booleans are set
2309 // to true.  If not zero is returned and all the booleans are set to false.
2310 static uint64_t GuessPointerPointer(uint64_t ReferenceValue,
2311                                     struct DisassembleInfo *info,
2312                                     bool &classref, bool &selref, bool &msgref,
2313                                     bool &cfstring) {
2314   classref = false;
2315   selref = false;
2316   msgref = false;
2317   cfstring = false;
2318   for (const auto &Load : info->O->load_commands()) {
2319     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
2320       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
2321       for (unsigned J = 0; J < Seg.nsects; ++J) {
2322         MachO::section_64 Sec = info->O->getSection64(Load, J);
2323         if ((strncmp(Sec.sectname, "__objc_selrefs", 16) == 0 ||
2324              strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 ||
2325              strncmp(Sec.sectname, "__objc_superrefs", 16) == 0 ||
2326              strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 ||
2327              strncmp(Sec.sectname, "__cfstring", 16) == 0) &&
2328             ReferenceValue >= Sec.addr &&
2329             ReferenceValue < Sec.addr + Sec.size) {
2330           uint64_t sect_offset = ReferenceValue - Sec.addr;
2331           uint64_t object_offset = Sec.offset + sect_offset;
2332           StringRef MachOContents = info->O->getData();
2333           uint64_t object_size = MachOContents.size();
2334           const char *object_addr = (const char *)MachOContents.data();
2335           if (object_offset < object_size) {
2336             uint64_t pointer_value;
2337             memcpy(&pointer_value, object_addr + object_offset,
2338                    sizeof(uint64_t));
2339             if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
2340               sys::swapByteOrder(pointer_value);
2341             if (strncmp(Sec.sectname, "__objc_selrefs", 16) == 0)
2342               selref = true;
2343             else if (strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 ||
2344                      strncmp(Sec.sectname, "__objc_superrefs", 16) == 0)
2345               classref = true;
2346             else if (strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 &&
2347                      ReferenceValue + 8 < Sec.addr + Sec.size) {
2348               msgref = true;
2349               memcpy(&pointer_value, object_addr + object_offset + 8,
2350                      sizeof(uint64_t));
2351               if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
2352                 sys::swapByteOrder(pointer_value);
2353             } else if (strncmp(Sec.sectname, "__cfstring", 16) == 0)
2354               cfstring = true;
2355             return pointer_value;
2356           } else {
2357             return 0;
2358           }
2359         }
2360       }
2361     }
2362     // TODO: Look for LC_SEGMENT for 32-bit Mach-O files.
2363   }
2364   return 0;
2365 }
2366
2367 // get_pointer_64 returns a pointer to the bytes in the object file at the
2368 // Address from a section in the Mach-O file.  And indirectly returns the
2369 // offset into the section, number of bytes left in the section past the offset
2370 // and which section is was being referenced.  If the Address is not in a
2371 // section nullptr is returned.
2372 static const char *get_pointer_64(uint64_t Address, uint32_t &offset,
2373                                   uint32_t &left, SectionRef &S,
2374                                   DisassembleInfo *info,
2375                                   bool objc_only = false) {
2376   offset = 0;
2377   left = 0;
2378   S = SectionRef();
2379   for (unsigned SectIdx = 0; SectIdx != info->Sections->size(); SectIdx++) {
2380     uint64_t SectAddress = ((*(info->Sections))[SectIdx]).getAddress();
2381     uint64_t SectSize = ((*(info->Sections))[SectIdx]).getSize();
2382     if (objc_only) {
2383       StringRef SectName;
2384       ((*(info->Sections))[SectIdx]).getName(SectName);
2385       DataRefImpl Ref = ((*(info->Sections))[SectIdx]).getRawDataRefImpl();
2386       StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
2387       if (SegName != "__OBJC" && SectName != "__cstring")
2388         continue;
2389     }
2390     if (Address >= SectAddress && Address < SectAddress + SectSize) {
2391       S = (*(info->Sections))[SectIdx];
2392       offset = Address - SectAddress;
2393       left = SectSize - offset;
2394       StringRef SectContents;
2395       ((*(info->Sections))[SectIdx]).getContents(SectContents);
2396       return SectContents.data() + offset;
2397     }
2398   }
2399   return nullptr;
2400 }
2401
2402 static const char *get_pointer_32(uint32_t Address, uint32_t &offset,
2403                                   uint32_t &left, SectionRef &S,
2404                                   DisassembleInfo *info,
2405                                   bool objc_only = false) {
2406   return get_pointer_64(Address, offset, left, S, info, objc_only);
2407 }
2408
2409 // get_symbol_64() returns the name of a symbol (or nullptr) and the address of
2410 // the symbol indirectly through n_value. Based on the relocation information
2411 // for the specified section offset in the specified section reference.
2412 // If no relocation information is found and a non-zero ReferenceValue for the
2413 // symbol is passed, look up that address in the info's AddrMap.
2414 static const char *get_symbol_64(uint32_t sect_offset, SectionRef S,
2415                                  DisassembleInfo *info, uint64_t &n_value,
2416                                  uint64_t ReferenceValue = 0) {
2417   n_value = 0;
2418   if (!info->verbose)
2419     return nullptr;
2420
2421   // See if there is an external relocation entry at the sect_offset.
2422   bool reloc_found = false;
2423   DataRefImpl Rel;
2424   MachO::any_relocation_info RE;
2425   bool isExtern = false;
2426   SymbolRef Symbol;
2427   for (const RelocationRef &Reloc : S.relocations()) {
2428     uint64_t RelocOffset = Reloc.getOffset();
2429     if (RelocOffset == sect_offset) {
2430       Rel = Reloc.getRawDataRefImpl();
2431       RE = info->O->getRelocation(Rel);
2432       if (info->O->isRelocationScattered(RE))
2433         continue;
2434       isExtern = info->O->getPlainRelocationExternal(RE);
2435       if (isExtern) {
2436         symbol_iterator RelocSym = Reloc.getSymbol();
2437         Symbol = *RelocSym;
2438       }
2439       reloc_found = true;
2440       break;
2441     }
2442   }
2443   // If there is an external relocation entry for a symbol in this section
2444   // at this section_offset then use that symbol's value for the n_value
2445   // and return its name.
2446   const char *SymbolName = nullptr;
2447   if (reloc_found && isExtern) {
2448     n_value = Symbol.getValue();
2449     ErrorOr<StringRef> NameOrError = Symbol.getName();
2450     if (std::error_code EC = NameOrError.getError())
2451       report_fatal_error(EC.message());
2452     StringRef Name = *NameOrError;
2453     if (!Name.empty()) {
2454       SymbolName = Name.data();
2455       return SymbolName;
2456     }
2457   }
2458
2459   // TODO: For fully linked images, look through the external relocation
2460   // entries off the dynamic symtab command. For these the r_offset is from the
2461   // start of the first writeable segment in the Mach-O file.  So the offset
2462   // to this section from that segment is passed to this routine by the caller,
2463   // as the database_offset. Which is the difference of the section's starting
2464   // address and the first writable segment.
2465   //
2466   // NOTE: need add passing the database_offset to this routine.
2467
2468   // We did not find an external relocation entry so look up the ReferenceValue
2469   // as an address of a symbol and if found return that symbol's name.
2470   SymbolName = GuessSymbolName(ReferenceValue, info->AddrMap);
2471
2472   return SymbolName;
2473 }
2474
2475 static const char *get_symbol_32(uint32_t sect_offset, SectionRef S,
2476                                  DisassembleInfo *info,
2477                                  uint32_t ReferenceValue) {
2478   uint64_t n_value64;
2479   return get_symbol_64(sect_offset, S, info, n_value64, ReferenceValue);
2480 }
2481
2482 // These are structs in the Objective-C meta data and read to produce the
2483 // comments for disassembly.  While these are part of the ABI they are no
2484 // public defintions.  So the are here not in include/llvm/Support/MachO.h .
2485
2486 // The cfstring object in a 64-bit Mach-O file.
2487 struct cfstring64_t {
2488   uint64_t isa;        // class64_t * (64-bit pointer)
2489   uint64_t flags;      // flag bits
2490   uint64_t characters; // char * (64-bit pointer)
2491   uint64_t length;     // number of non-NULL characters in above
2492 };
2493
2494 // The class object in a 64-bit Mach-O file.
2495 struct class64_t {
2496   uint64_t isa;        // class64_t * (64-bit pointer)
2497   uint64_t superclass; // class64_t * (64-bit pointer)
2498   uint64_t cache;      // Cache (64-bit pointer)
2499   uint64_t vtable;     // IMP * (64-bit pointer)
2500   uint64_t data;       // class_ro64_t * (64-bit pointer)
2501 };
2502
2503 struct class32_t {
2504   uint32_t isa;        /* class32_t * (32-bit pointer) */
2505   uint32_t superclass; /* class32_t * (32-bit pointer) */
2506   uint32_t cache;      /* Cache (32-bit pointer) */
2507   uint32_t vtable;     /* IMP * (32-bit pointer) */
2508   uint32_t data;       /* class_ro32_t * (32-bit pointer) */
2509 };
2510
2511 struct class_ro64_t {
2512   uint32_t flags;
2513   uint32_t instanceStart;
2514   uint32_t instanceSize;
2515   uint32_t reserved;
2516   uint64_t ivarLayout;     // const uint8_t * (64-bit pointer)
2517   uint64_t name;           // const char * (64-bit pointer)
2518   uint64_t baseMethods;    // const method_list_t * (64-bit pointer)
2519   uint64_t baseProtocols;  // const protocol_list_t * (64-bit pointer)
2520   uint64_t ivars;          // const ivar_list_t * (64-bit pointer)
2521   uint64_t weakIvarLayout; // const uint8_t * (64-bit pointer)
2522   uint64_t baseProperties; // const struct objc_property_list (64-bit pointer)
2523 };
2524
2525 struct class_ro32_t {
2526   uint32_t flags;
2527   uint32_t instanceStart;
2528   uint32_t instanceSize;
2529   uint32_t ivarLayout;     /* const uint8_t * (32-bit pointer) */
2530   uint32_t name;           /* const char * (32-bit pointer) */
2531   uint32_t baseMethods;    /* const method_list_t * (32-bit pointer) */
2532   uint32_t baseProtocols;  /* const protocol_list_t * (32-bit pointer) */
2533   uint32_t ivars;          /* const ivar_list_t * (32-bit pointer) */
2534   uint32_t weakIvarLayout; /* const uint8_t * (32-bit pointer) */
2535   uint32_t baseProperties; /* const struct objc_property_list *
2536                                                    (32-bit pointer) */
2537 };
2538
2539 /* Values for class_ro{64,32}_t->flags */
2540 #define RO_META (1 << 0)
2541 #define RO_ROOT (1 << 1)
2542 #define RO_HAS_CXX_STRUCTORS (1 << 2)
2543
2544 struct method_list64_t {
2545   uint32_t entsize;
2546   uint32_t count;
2547   /* struct method64_t first;  These structures follow inline */
2548 };
2549
2550 struct method_list32_t {
2551   uint32_t entsize;
2552   uint32_t count;
2553   /* struct method32_t first;  These structures follow inline */
2554 };
2555
2556 struct method64_t {
2557   uint64_t name;  /* SEL (64-bit pointer) */
2558   uint64_t types; /* const char * (64-bit pointer) */
2559   uint64_t imp;   /* IMP (64-bit pointer) */
2560 };
2561
2562 struct method32_t {
2563   uint32_t name;  /* SEL (32-bit pointer) */
2564   uint32_t types; /* const char * (32-bit pointer) */
2565   uint32_t imp;   /* IMP (32-bit pointer) */
2566 };
2567
2568 struct protocol_list64_t {
2569   uint64_t count; /* uintptr_t (a 64-bit value) */
2570   /* struct protocol64_t * list[0];  These pointers follow inline */
2571 };
2572
2573 struct protocol_list32_t {
2574   uint32_t count; /* uintptr_t (a 32-bit value) */
2575   /* struct protocol32_t * list[0];  These pointers follow inline */
2576 };
2577
2578 struct protocol64_t {
2579   uint64_t isa;                     /* id * (64-bit pointer) */
2580   uint64_t name;                    /* const char * (64-bit pointer) */
2581   uint64_t protocols;               /* struct protocol_list64_t *
2582                                                     (64-bit pointer) */
2583   uint64_t instanceMethods;         /* method_list_t * (64-bit pointer) */
2584   uint64_t classMethods;            /* method_list_t * (64-bit pointer) */
2585   uint64_t optionalInstanceMethods; /* method_list_t * (64-bit pointer) */
2586   uint64_t optionalClassMethods;    /* method_list_t * (64-bit pointer) */
2587   uint64_t instanceProperties;      /* struct objc_property_list *
2588                                                        (64-bit pointer) */
2589 };
2590
2591 struct protocol32_t {
2592   uint32_t isa;                     /* id * (32-bit pointer) */
2593   uint32_t name;                    /* const char * (32-bit pointer) */
2594   uint32_t protocols;               /* struct protocol_list_t *
2595                                                     (32-bit pointer) */
2596   uint32_t instanceMethods;         /* method_list_t * (32-bit pointer) */
2597   uint32_t classMethods;            /* method_list_t * (32-bit pointer) */
2598   uint32_t optionalInstanceMethods; /* method_list_t * (32-bit pointer) */
2599   uint32_t optionalClassMethods;    /* method_list_t * (32-bit pointer) */
2600   uint32_t instanceProperties;      /* struct objc_property_list *
2601                                                        (32-bit pointer) */
2602 };
2603
2604 struct ivar_list64_t {
2605   uint32_t entsize;
2606   uint32_t count;
2607   /* struct ivar64_t first;  These structures follow inline */
2608 };
2609
2610 struct ivar_list32_t {
2611   uint32_t entsize;
2612   uint32_t count;
2613   /* struct ivar32_t first;  These structures follow inline */
2614 };
2615
2616 struct ivar64_t {
2617   uint64_t offset; /* uintptr_t * (64-bit pointer) */
2618   uint64_t name;   /* const char * (64-bit pointer) */
2619   uint64_t type;   /* const char * (64-bit pointer) */
2620   uint32_t alignment;
2621   uint32_t size;
2622 };
2623
2624 struct ivar32_t {
2625   uint32_t offset; /* uintptr_t * (32-bit pointer) */
2626   uint32_t name;   /* const char * (32-bit pointer) */
2627   uint32_t type;   /* const char * (32-bit pointer) */
2628   uint32_t alignment;
2629   uint32_t size;
2630 };
2631
2632 struct objc_property_list64 {
2633   uint32_t entsize;
2634   uint32_t count;
2635   /* struct objc_property64 first;  These structures follow inline */
2636 };
2637
2638 struct objc_property_list32 {
2639   uint32_t entsize;
2640   uint32_t count;
2641   /* struct objc_property32 first;  These structures follow inline */
2642 };
2643
2644 struct objc_property64 {
2645   uint64_t name;       /* const char * (64-bit pointer) */
2646   uint64_t attributes; /* const char * (64-bit pointer) */
2647 };
2648
2649 struct objc_property32 {
2650   uint32_t name;       /* const char * (32-bit pointer) */
2651   uint32_t attributes; /* const char * (32-bit pointer) */
2652 };
2653
2654 struct category64_t {
2655   uint64_t name;               /* const char * (64-bit pointer) */
2656   uint64_t cls;                /* struct class_t * (64-bit pointer) */
2657   uint64_t instanceMethods;    /* struct method_list_t * (64-bit pointer) */
2658   uint64_t classMethods;       /* struct method_list_t * (64-bit pointer) */
2659   uint64_t protocols;          /* struct protocol_list_t * (64-bit pointer) */
2660   uint64_t instanceProperties; /* struct objc_property_list *
2661                                   (64-bit pointer) */
2662 };
2663
2664 struct category32_t {
2665   uint32_t name;               /* const char * (32-bit pointer) */
2666   uint32_t cls;                /* struct class_t * (32-bit pointer) */
2667   uint32_t instanceMethods;    /* struct method_list_t * (32-bit pointer) */
2668   uint32_t classMethods;       /* struct method_list_t * (32-bit pointer) */
2669   uint32_t protocols;          /* struct protocol_list_t * (32-bit pointer) */
2670   uint32_t instanceProperties; /* struct objc_property_list *
2671                                   (32-bit pointer) */
2672 };
2673
2674 struct objc_image_info64 {
2675   uint32_t version;
2676   uint32_t flags;
2677 };
2678 struct objc_image_info32 {
2679   uint32_t version;
2680   uint32_t flags;
2681 };
2682 struct imageInfo_t {
2683   uint32_t version;
2684   uint32_t flags;
2685 };
2686 /* masks for objc_image_info.flags */
2687 #define OBJC_IMAGE_IS_REPLACEMENT (1 << 0)
2688 #define OBJC_IMAGE_SUPPORTS_GC (1 << 1)
2689
2690 struct message_ref64 {
2691   uint64_t imp; /* IMP (64-bit pointer) */
2692   uint64_t sel; /* SEL (64-bit pointer) */
2693 };
2694
2695 struct message_ref32 {
2696   uint32_t imp; /* IMP (32-bit pointer) */
2697   uint32_t sel; /* SEL (32-bit pointer) */
2698 };
2699
2700 // Objective-C 1 (32-bit only) meta data structs.
2701
2702 struct objc_module_t {
2703   uint32_t version;
2704   uint32_t size;
2705   uint32_t name;   /* char * (32-bit pointer) */
2706   uint32_t symtab; /* struct objc_symtab * (32-bit pointer) */
2707 };
2708
2709 struct objc_symtab_t {
2710   uint32_t sel_ref_cnt;
2711   uint32_t refs; /* SEL * (32-bit pointer) */
2712   uint16_t cls_def_cnt;
2713   uint16_t cat_def_cnt;
2714   // uint32_t defs[1];        /* void * (32-bit pointer) variable size */
2715 };
2716
2717 struct objc_class_t {
2718   uint32_t isa;         /* struct objc_class * (32-bit pointer) */
2719   uint32_t super_class; /* struct objc_class * (32-bit pointer) */
2720   uint32_t name;        /* const char * (32-bit pointer) */
2721   int32_t version;
2722   int32_t info;
2723   int32_t instance_size;
2724   uint32_t ivars;       /* struct objc_ivar_list * (32-bit pointer) */
2725   uint32_t methodLists; /* struct objc_method_list ** (32-bit pointer) */
2726   uint32_t cache;       /* struct objc_cache * (32-bit pointer) */
2727   uint32_t protocols;   /* struct objc_protocol_list * (32-bit pointer) */
2728 };
2729
2730 #define CLS_GETINFO(cls, infomask) ((cls)->info & (infomask))
2731 // class is not a metaclass
2732 #define CLS_CLASS 0x1
2733 // class is a metaclass
2734 #define CLS_META 0x2
2735
2736 struct objc_category_t {
2737   uint32_t category_name;    /* char * (32-bit pointer) */
2738   uint32_t class_name;       /* char * (32-bit pointer) */
2739   uint32_t instance_methods; /* struct objc_method_list * (32-bit pointer) */
2740   uint32_t class_methods;    /* struct objc_method_list * (32-bit pointer) */
2741   uint32_t protocols;        /* struct objc_protocol_list * (32-bit ptr) */
2742 };
2743
2744 struct objc_ivar_t {
2745   uint32_t ivar_name; /* char * (32-bit pointer) */
2746   uint32_t ivar_type; /* char * (32-bit pointer) */
2747   int32_t ivar_offset;
2748 };
2749
2750 struct objc_ivar_list_t {
2751   int32_t ivar_count;
2752   // struct objc_ivar_t ivar_list[1];          /* variable length structure */
2753 };
2754
2755 struct objc_method_list_t {
2756   uint32_t obsolete; /* struct objc_method_list * (32-bit pointer) */
2757   int32_t method_count;
2758   // struct objc_method_t method_list[1];      /* variable length structure */
2759 };
2760
2761 struct objc_method_t {
2762   uint32_t method_name;  /* SEL, aka struct objc_selector * (32-bit pointer) */
2763   uint32_t method_types; /* char * (32-bit pointer) */
2764   uint32_t method_imp;   /* IMP, aka function pointer, (*IMP)(id, SEL, ...)
2765                             (32-bit pointer) */
2766 };
2767
2768 struct objc_protocol_list_t {
2769   uint32_t next; /* struct objc_protocol_list * (32-bit pointer) */
2770   int32_t count;
2771   // uint32_t list[1];   /* Protocol *, aka struct objc_protocol_t *
2772   //                        (32-bit pointer) */
2773 };
2774
2775 struct objc_protocol_t {
2776   uint32_t isa;              /* struct objc_class * (32-bit pointer) */
2777   uint32_t protocol_name;    /* char * (32-bit pointer) */
2778   uint32_t protocol_list;    /* struct objc_protocol_list * (32-bit pointer) */
2779   uint32_t instance_methods; /* struct objc_method_description_list *
2780                                 (32-bit pointer) */
2781   uint32_t class_methods;    /* struct objc_method_description_list *
2782                                 (32-bit pointer) */
2783 };
2784
2785 struct objc_method_description_list_t {
2786   int32_t count;
2787   // struct objc_method_description_t list[1];
2788 };
2789
2790 struct objc_method_description_t {
2791   uint32_t name;  /* SEL, aka struct objc_selector * (32-bit pointer) */
2792   uint32_t types; /* char * (32-bit pointer) */
2793 };
2794
2795 inline void swapStruct(struct cfstring64_t &cfs) {
2796   sys::swapByteOrder(cfs.isa);
2797   sys::swapByteOrder(cfs.flags);
2798   sys::swapByteOrder(cfs.characters);
2799   sys::swapByteOrder(cfs.length);
2800 }
2801
2802 inline void swapStruct(struct class64_t &c) {
2803   sys::swapByteOrder(c.isa);
2804   sys::swapByteOrder(c.superclass);
2805   sys::swapByteOrder(c.cache);
2806   sys::swapByteOrder(c.vtable);
2807   sys::swapByteOrder(c.data);
2808 }
2809
2810 inline void swapStruct(struct class32_t &c) {
2811   sys::swapByteOrder(c.isa);
2812   sys::swapByteOrder(c.superclass);
2813   sys::swapByteOrder(c.cache);
2814   sys::swapByteOrder(c.vtable);
2815   sys::swapByteOrder(c.data);
2816 }
2817
2818 inline void swapStruct(struct class_ro64_t &cro) {
2819   sys::swapByteOrder(cro.flags);
2820   sys::swapByteOrder(cro.instanceStart);
2821   sys::swapByteOrder(cro.instanceSize);
2822   sys::swapByteOrder(cro.reserved);
2823   sys::swapByteOrder(cro.ivarLayout);
2824   sys::swapByteOrder(cro.name);
2825   sys::swapByteOrder(cro.baseMethods);
2826   sys::swapByteOrder(cro.baseProtocols);
2827   sys::swapByteOrder(cro.ivars);
2828   sys::swapByteOrder(cro.weakIvarLayout);
2829   sys::swapByteOrder(cro.baseProperties);
2830 }
2831
2832 inline void swapStruct(struct class_ro32_t &cro) {
2833   sys::swapByteOrder(cro.flags);
2834   sys::swapByteOrder(cro.instanceStart);
2835   sys::swapByteOrder(cro.instanceSize);
2836   sys::swapByteOrder(cro.ivarLayout);
2837   sys::swapByteOrder(cro.name);
2838   sys::swapByteOrder(cro.baseMethods);
2839   sys::swapByteOrder(cro.baseProtocols);
2840   sys::swapByteOrder(cro.ivars);
2841   sys::swapByteOrder(cro.weakIvarLayout);
2842   sys::swapByteOrder(cro.baseProperties);
2843 }
2844
2845 inline void swapStruct(struct method_list64_t &ml) {
2846   sys::swapByteOrder(ml.entsize);
2847   sys::swapByteOrder(ml.count);
2848 }
2849
2850 inline void swapStruct(struct method_list32_t &ml) {
2851   sys::swapByteOrder(ml.entsize);
2852   sys::swapByteOrder(ml.count);
2853 }
2854
2855 inline void swapStruct(struct method64_t &m) {
2856   sys::swapByteOrder(m.name);
2857   sys::swapByteOrder(m.types);
2858   sys::swapByteOrder(m.imp);
2859 }
2860
2861 inline void swapStruct(struct method32_t &m) {
2862   sys::swapByteOrder(m.name);
2863   sys::swapByteOrder(m.types);
2864   sys::swapByteOrder(m.imp);
2865 }
2866
2867 inline void swapStruct(struct protocol_list64_t &pl) {
2868   sys::swapByteOrder(pl.count);
2869 }
2870
2871 inline void swapStruct(struct protocol_list32_t &pl) {
2872   sys::swapByteOrder(pl.count);
2873 }
2874
2875 inline void swapStruct(struct protocol64_t &p) {
2876   sys::swapByteOrder(p.isa);
2877   sys::swapByteOrder(p.name);
2878   sys::swapByteOrder(p.protocols);
2879   sys::swapByteOrder(p.instanceMethods);
2880   sys::swapByteOrder(p.classMethods);
2881   sys::swapByteOrder(p.optionalInstanceMethods);
2882   sys::swapByteOrder(p.optionalClassMethods);
2883   sys::swapByteOrder(p.instanceProperties);
2884 }
2885
2886 inline void swapStruct(struct protocol32_t &p) {
2887   sys::swapByteOrder(p.isa);
2888   sys::swapByteOrder(p.name);
2889   sys::swapByteOrder(p.protocols);
2890   sys::swapByteOrder(p.instanceMethods);
2891   sys::swapByteOrder(p.classMethods);
2892   sys::swapByteOrder(p.optionalInstanceMethods);
2893   sys::swapByteOrder(p.optionalClassMethods);
2894   sys::swapByteOrder(p.instanceProperties);
2895 }
2896
2897 inline void swapStruct(struct ivar_list64_t &il) {
2898   sys::swapByteOrder(il.entsize);
2899   sys::swapByteOrder(il.count);
2900 }
2901
2902 inline void swapStruct(struct ivar_list32_t &il) {
2903   sys::swapByteOrder(il.entsize);
2904   sys::swapByteOrder(il.count);
2905 }
2906
2907 inline void swapStruct(struct ivar64_t &i) {
2908   sys::swapByteOrder(i.offset);
2909   sys::swapByteOrder(i.name);
2910   sys::swapByteOrder(i.type);
2911   sys::swapByteOrder(i.alignment);
2912   sys::swapByteOrder(i.size);
2913 }
2914
2915 inline void swapStruct(struct ivar32_t &i) {
2916   sys::swapByteOrder(i.offset);
2917   sys::swapByteOrder(i.name);
2918   sys::swapByteOrder(i.type);
2919   sys::swapByteOrder(i.alignment);
2920   sys::swapByteOrder(i.size);
2921 }
2922
2923 inline void swapStruct(struct objc_property_list64 &pl) {
2924   sys::swapByteOrder(pl.entsize);
2925   sys::swapByteOrder(pl.count);
2926 }
2927
2928 inline void swapStruct(struct objc_property_list32 &pl) {
2929   sys::swapByteOrder(pl.entsize);
2930   sys::swapByteOrder(pl.count);
2931 }
2932
2933 inline void swapStruct(struct objc_property64 &op) {
2934   sys::swapByteOrder(op.name);
2935   sys::swapByteOrder(op.attributes);
2936 }
2937
2938 inline void swapStruct(struct objc_property32 &op) {
2939   sys::swapByteOrder(op.name);
2940   sys::swapByteOrder(op.attributes);
2941 }
2942
2943 inline void swapStruct(struct category64_t &c) {
2944   sys::swapByteOrder(c.name);
2945   sys::swapByteOrder(c.cls);
2946   sys::swapByteOrder(c.instanceMethods);
2947   sys::swapByteOrder(c.classMethods);
2948   sys::swapByteOrder(c.protocols);
2949   sys::swapByteOrder(c.instanceProperties);
2950 }
2951
2952 inline void swapStruct(struct category32_t &c) {
2953   sys::swapByteOrder(c.name);
2954   sys::swapByteOrder(c.cls);
2955   sys::swapByteOrder(c.instanceMethods);
2956   sys::swapByteOrder(c.classMethods);
2957   sys::swapByteOrder(c.protocols);
2958   sys::swapByteOrder(c.instanceProperties);
2959 }
2960
2961 inline void swapStruct(struct objc_image_info64 &o) {
2962   sys::swapByteOrder(o.version);
2963   sys::swapByteOrder(o.flags);
2964 }
2965
2966 inline void swapStruct(struct objc_image_info32 &o) {
2967   sys::swapByteOrder(o.version);
2968   sys::swapByteOrder(o.flags);
2969 }
2970
2971 inline void swapStruct(struct imageInfo_t &o) {
2972   sys::swapByteOrder(o.version);
2973   sys::swapByteOrder(o.flags);
2974 }
2975
2976 inline void swapStruct(struct message_ref64 &mr) {
2977   sys::swapByteOrder(mr.imp);
2978   sys::swapByteOrder(mr.sel);
2979 }
2980
2981 inline void swapStruct(struct message_ref32 &mr) {
2982   sys::swapByteOrder(mr.imp);
2983   sys::swapByteOrder(mr.sel);
2984 }
2985
2986 inline void swapStruct(struct objc_module_t &module) {
2987   sys::swapByteOrder(module.version);
2988   sys::swapByteOrder(module.size);
2989   sys::swapByteOrder(module.name);
2990   sys::swapByteOrder(module.symtab);
2991 }
2992
2993 inline void swapStruct(struct objc_symtab_t &symtab) {
2994   sys::swapByteOrder(symtab.sel_ref_cnt);
2995   sys::swapByteOrder(symtab.refs);
2996   sys::swapByteOrder(symtab.cls_def_cnt);
2997   sys::swapByteOrder(symtab.cat_def_cnt);
2998 }
2999
3000 inline void swapStruct(struct objc_class_t &objc_class) {
3001   sys::swapByteOrder(objc_class.isa);
3002   sys::swapByteOrder(objc_class.super_class);
3003   sys::swapByteOrder(objc_class.name);
3004   sys::swapByteOrder(objc_class.version);
3005   sys::swapByteOrder(objc_class.info);
3006   sys::swapByteOrder(objc_class.instance_size);
3007   sys::swapByteOrder(objc_class.ivars);
3008   sys::swapByteOrder(objc_class.methodLists);
3009   sys::swapByteOrder(objc_class.cache);
3010   sys::swapByteOrder(objc_class.protocols);
3011 }
3012
3013 inline void swapStruct(struct objc_category_t &objc_category) {
3014   sys::swapByteOrder(objc_category.category_name);
3015   sys::swapByteOrder(objc_category.class_name);
3016   sys::swapByteOrder(objc_category.instance_methods);
3017   sys::swapByteOrder(objc_category.class_methods);
3018   sys::swapByteOrder(objc_category.protocols);
3019 }
3020
3021 inline void swapStruct(struct objc_ivar_list_t &objc_ivar_list) {
3022   sys::swapByteOrder(objc_ivar_list.ivar_count);
3023 }
3024
3025 inline void swapStruct(struct objc_ivar_t &objc_ivar) {
3026   sys::swapByteOrder(objc_ivar.ivar_name);
3027   sys::swapByteOrder(objc_ivar.ivar_type);
3028   sys::swapByteOrder(objc_ivar.ivar_offset);
3029 }
3030
3031 inline void swapStruct(struct objc_method_list_t &method_list) {
3032   sys::swapByteOrder(method_list.obsolete);
3033   sys::swapByteOrder(method_list.method_count);
3034 }
3035
3036 inline void swapStruct(struct objc_method_t &method) {
3037   sys::swapByteOrder(method.method_name);
3038   sys::swapByteOrder(method.method_types);
3039   sys::swapByteOrder(method.method_imp);
3040 }
3041
3042 inline void swapStruct(struct objc_protocol_list_t &protocol_list) {
3043   sys::swapByteOrder(protocol_list.next);
3044   sys::swapByteOrder(protocol_list.count);
3045 }
3046
3047 inline void swapStruct(struct objc_protocol_t &protocol) {
3048   sys::swapByteOrder(protocol.isa);
3049   sys::swapByteOrder(protocol.protocol_name);
3050   sys::swapByteOrder(protocol.protocol_list);
3051   sys::swapByteOrder(protocol.instance_methods);
3052   sys::swapByteOrder(protocol.class_methods);
3053 }
3054
3055 inline void swapStruct(struct objc_method_description_list_t &mdl) {
3056   sys::swapByteOrder(mdl.count);
3057 }
3058
3059 inline void swapStruct(struct objc_method_description_t &md) {
3060   sys::swapByteOrder(md.name);
3061   sys::swapByteOrder(md.types);
3062 }
3063
3064 static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue,
3065                                                  struct DisassembleInfo *info);
3066
3067 // get_objc2_64bit_class_name() is used for disassembly and is passed a pointer
3068 // to an Objective-C class and returns the class name.  It is also passed the
3069 // address of the pointer, so when the pointer is zero as it can be in an .o
3070 // file, that is used to look for an external relocation entry with a symbol
3071 // name.
3072 static const char *get_objc2_64bit_class_name(uint64_t pointer_value,
3073                                               uint64_t ReferenceValue,
3074                                               struct DisassembleInfo *info) {
3075   const char *r;
3076   uint32_t offset, left;
3077   SectionRef S;
3078
3079   // The pointer_value can be 0 in an object file and have a relocation
3080   // entry for the class symbol at the ReferenceValue (the address of the
3081   // pointer).
3082   if (pointer_value == 0) {
3083     r = get_pointer_64(ReferenceValue, offset, left, S, info);
3084     if (r == nullptr || left < sizeof(uint64_t))
3085       return nullptr;
3086     uint64_t n_value;
3087     const char *symbol_name = get_symbol_64(offset, S, info, n_value);
3088     if (symbol_name == nullptr)
3089       return nullptr;
3090     const char *class_name = strrchr(symbol_name, '$');
3091     if (class_name != nullptr && class_name[1] == '_' && class_name[2] != '\0')
3092       return class_name + 2;
3093     else
3094       return nullptr;
3095   }
3096
3097   // The case were the pointer_value is non-zero and points to a class defined
3098   // in this Mach-O file.
3099   r = get_pointer_64(pointer_value, offset, left, S, info);
3100   if (r == nullptr || left < sizeof(struct class64_t))
3101     return nullptr;
3102   struct class64_t c;
3103   memcpy(&c, r, sizeof(struct class64_t));
3104   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3105     swapStruct(c);
3106   if (c.data == 0)
3107     return nullptr;
3108   r = get_pointer_64(c.data, offset, left, S, info);
3109   if (r == nullptr || left < sizeof(struct class_ro64_t))
3110     return nullptr;
3111   struct class_ro64_t cro;
3112   memcpy(&cro, r, sizeof(struct class_ro64_t));
3113   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3114     swapStruct(cro);
3115   if (cro.name == 0)
3116     return nullptr;
3117   const char *name = get_pointer_64(cro.name, offset, left, S, info);
3118   return name;
3119 }
3120
3121 // get_objc2_64bit_cfstring_name is used for disassembly and is passed a
3122 // pointer to a cfstring and returns its name or nullptr.
3123 static const char *get_objc2_64bit_cfstring_name(uint64_t ReferenceValue,
3124                                                  struct DisassembleInfo *info) {
3125   const char *r, *name;
3126   uint32_t offset, left;
3127   SectionRef S;
3128   struct cfstring64_t cfs;
3129   uint64_t cfs_characters;
3130
3131   r = get_pointer_64(ReferenceValue, offset, left, S, info);
3132   if (r == nullptr || left < sizeof(struct cfstring64_t))
3133     return nullptr;
3134   memcpy(&cfs, r, sizeof(struct cfstring64_t));
3135   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3136     swapStruct(cfs);
3137   if (cfs.characters == 0) {
3138     uint64_t n_value;
3139     const char *symbol_name = get_symbol_64(
3140         offset + offsetof(struct cfstring64_t, characters), S, info, n_value);
3141     if (symbol_name == nullptr)
3142       return nullptr;
3143     cfs_characters = n_value;
3144   } else
3145     cfs_characters = cfs.characters;
3146   name = get_pointer_64(cfs_characters, offset, left, S, info);
3147
3148   return name;
3149 }
3150
3151 // get_objc2_64bit_selref() is used for disassembly and is passed a the address
3152 // of a pointer to an Objective-C selector reference when the pointer value is
3153 // zero as in a .o file and is likely to have a external relocation entry with
3154 // who's symbol's n_value is the real pointer to the selector name.  If that is
3155 // the case the real pointer to the selector name is returned else 0 is
3156 // returned
3157 static uint64_t get_objc2_64bit_selref(uint64_t ReferenceValue,
3158                                        struct DisassembleInfo *info) {
3159   uint32_t offset, left;
3160   SectionRef S;
3161
3162   const char *r = get_pointer_64(ReferenceValue, offset, left, S, info);
3163   if (r == nullptr || left < sizeof(uint64_t))
3164     return 0;
3165   uint64_t n_value;
3166   const char *symbol_name = get_symbol_64(offset, S, info, n_value);
3167   if (symbol_name == nullptr)
3168     return 0;
3169   return n_value;
3170 }
3171
3172 static const SectionRef get_section(MachOObjectFile *O, const char *segname,
3173                                     const char *sectname) {
3174   for (const SectionRef &Section : O->sections()) {
3175     StringRef SectName;
3176     Section.getName(SectName);
3177     DataRefImpl Ref = Section.getRawDataRefImpl();
3178     StringRef SegName = O->getSectionFinalSegmentName(Ref);
3179     if (SegName == segname && SectName == sectname)
3180       return Section;
3181   }
3182   return SectionRef();
3183 }
3184
3185 static void
3186 walk_pointer_list_64(const char *listname, const SectionRef S,
3187                      MachOObjectFile *O, struct DisassembleInfo *info,
3188                      void (*func)(uint64_t, struct DisassembleInfo *info)) {
3189   if (S == SectionRef())
3190     return;
3191
3192   StringRef SectName;
3193   S.getName(SectName);
3194   DataRefImpl Ref = S.getRawDataRefImpl();
3195   StringRef SegName = O->getSectionFinalSegmentName(Ref);
3196   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
3197
3198   StringRef BytesStr;
3199   S.getContents(BytesStr);
3200   const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
3201
3202   for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint64_t)) {
3203     uint32_t left = S.getSize() - i;
3204     uint32_t size = left < sizeof(uint64_t) ? left : sizeof(uint64_t);
3205     uint64_t p = 0;
3206     memcpy(&p, Contents + i, size);
3207     if (i + sizeof(uint64_t) > S.getSize())
3208       outs() << listname << " list pointer extends past end of (" << SegName
3209              << "," << SectName << ") section\n";
3210     outs() << format("%016" PRIx64, S.getAddress() + i) << " ";
3211
3212     if (O->isLittleEndian() != sys::IsLittleEndianHost)
3213       sys::swapByteOrder(p);
3214
3215     uint64_t n_value = 0;
3216     const char *name = get_symbol_64(i, S, info, n_value, p);
3217     if (name == nullptr)
3218       name = get_dyld_bind_info_symbolname(S.getAddress() + i, info);
3219
3220     if (n_value != 0) {
3221       outs() << format("0x%" PRIx64, n_value);
3222       if (p != 0)
3223         outs() << " + " << format("0x%" PRIx64, p);
3224     } else
3225       outs() << format("0x%" PRIx64, p);
3226     if (name != nullptr)
3227       outs() << " " << name;
3228     outs() << "\n";
3229
3230     p += n_value;
3231     if (func)
3232       func(p, info);
3233   }
3234 }
3235
3236 static void
3237 walk_pointer_list_32(const char *listname, const SectionRef S,
3238                      MachOObjectFile *O, struct DisassembleInfo *info,
3239                      void (*func)(uint32_t, struct DisassembleInfo *info)) {
3240   if (S == SectionRef())
3241     return;
3242
3243   StringRef SectName;
3244   S.getName(SectName);
3245   DataRefImpl Ref = S.getRawDataRefImpl();
3246   StringRef SegName = O->getSectionFinalSegmentName(Ref);
3247   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
3248
3249   StringRef BytesStr;
3250   S.getContents(BytesStr);
3251   const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
3252
3253   for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint32_t)) {
3254     uint32_t left = S.getSize() - i;
3255     uint32_t size = left < sizeof(uint32_t) ? left : sizeof(uint32_t);
3256     uint32_t p = 0;
3257     memcpy(&p, Contents + i, size);
3258     if (i + sizeof(uint32_t) > S.getSize())
3259       outs() << listname << " list pointer extends past end of (" << SegName
3260              << "," << SectName << ") section\n";
3261     uint32_t Address = S.getAddress() + i;
3262     outs() << format("%08" PRIx32, Address) << " ";
3263
3264     if (O->isLittleEndian() != sys::IsLittleEndianHost)
3265       sys::swapByteOrder(p);
3266     outs() << format("0x%" PRIx32, p);
3267
3268     const char *name = get_symbol_32(i, S, info, p);
3269     if (name != nullptr)
3270       outs() << " " << name;
3271     outs() << "\n";
3272
3273     if (func)
3274       func(p, info);
3275   }
3276 }
3277
3278 static void print_layout_map(const char *layout_map, uint32_t left) {
3279   outs() << "                layout map: ";
3280   do {
3281     outs() << format("0x%02" PRIx32, (*layout_map) & 0xff) << " ";
3282     left--;
3283     layout_map++;
3284   } while (*layout_map != '\0' && left != 0);
3285   outs() << "\n";
3286 }
3287
3288 static void print_layout_map64(uint64_t p, struct DisassembleInfo *info) {
3289   uint32_t offset, left;
3290   SectionRef S;
3291   const char *layout_map;
3292
3293   if (p == 0)
3294     return;
3295   layout_map = get_pointer_64(p, offset, left, S, info);
3296   print_layout_map(layout_map, left);
3297 }
3298
3299 static void print_layout_map32(uint32_t p, struct DisassembleInfo *info) {
3300   uint32_t offset, left;
3301   SectionRef S;
3302   const char *layout_map;
3303
3304   if (p == 0)
3305     return;
3306   layout_map = get_pointer_32(p, offset, left, S, info);
3307   print_layout_map(layout_map, left);
3308 }
3309
3310 static void print_method_list64_t(uint64_t p, struct DisassembleInfo *info,
3311                                   const char *indent) {
3312   struct method_list64_t ml;
3313   struct method64_t m;
3314   const char *r;
3315   uint32_t offset, xoffset, left, i;
3316   SectionRef S, xS;
3317   const char *name, *sym_name;
3318   uint64_t n_value;
3319
3320   r = get_pointer_64(p, offset, left, S, info);
3321   if (r == nullptr)
3322     return;
3323   memset(&ml, '\0', sizeof(struct method_list64_t));
3324   if (left < sizeof(struct method_list64_t)) {
3325     memcpy(&ml, r, left);
3326     outs() << "   (method_list_t entends past the end of the section)\n";
3327   } else
3328     memcpy(&ml, r, sizeof(struct method_list64_t));
3329   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3330     swapStruct(ml);
3331   outs() << indent << "\t\t   entsize " << ml.entsize << "\n";
3332   outs() << indent << "\t\t     count " << ml.count << "\n";
3333
3334   p += sizeof(struct method_list64_t);
3335   offset += sizeof(struct method_list64_t);
3336   for (i = 0; i < ml.count; i++) {
3337     r = get_pointer_64(p, offset, left, S, info);
3338     if (r == nullptr)
3339       return;
3340     memset(&m, '\0', sizeof(struct method64_t));
3341     if (left < sizeof(struct method64_t)) {
3342       memcpy(&ml, r, left);
3343       outs() << indent << "   (method_t entends past the end of the section)\n";
3344     } else
3345       memcpy(&m, r, sizeof(struct method64_t));
3346     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3347       swapStruct(m);
3348
3349     outs() << indent << "\t\t      name ";
3350     sym_name = get_symbol_64(offset + offsetof(struct method64_t, name), S,
3351                              info, n_value, m.name);
3352     if (n_value != 0) {
3353       if (info->verbose && sym_name != nullptr)
3354         outs() << sym_name;
3355       else
3356         outs() << format("0x%" PRIx64, n_value);
3357       if (m.name != 0)
3358         outs() << " + " << format("0x%" PRIx64, m.name);
3359     } else
3360       outs() << format("0x%" PRIx64, m.name);
3361     name = get_pointer_64(m.name + n_value, xoffset, left, xS, info);
3362     if (name != nullptr)
3363       outs() << format(" %.*s", left, name);
3364     outs() << "\n";
3365
3366     outs() << indent << "\t\t     types ";
3367     sym_name = get_symbol_64(offset + offsetof(struct method64_t, types), S,
3368                              info, n_value, m.types);
3369     if (n_value != 0) {
3370       if (info->verbose && sym_name != nullptr)
3371         outs() << sym_name;
3372       else
3373         outs() << format("0x%" PRIx64, n_value);
3374       if (m.types != 0)
3375         outs() << " + " << format("0x%" PRIx64, m.types);
3376     } else
3377       outs() << format("0x%" PRIx64, m.types);
3378     name = get_pointer_64(m.types + n_value, xoffset, left, xS, info);
3379     if (name != nullptr)
3380       outs() << format(" %.*s", left, name);
3381     outs() << "\n";
3382
3383     outs() << indent << "\t\t       imp ";
3384     name = get_symbol_64(offset + offsetof(struct method64_t, imp), S, info,
3385                          n_value, m.imp);
3386     if (info->verbose && name == nullptr) {
3387       if (n_value != 0) {
3388         outs() << format("0x%" PRIx64, n_value) << " ";
3389         if (m.imp != 0)
3390           outs() << "+ " << format("0x%" PRIx64, m.imp) << " ";
3391       } else
3392         outs() << format("0x%" PRIx64, m.imp) << " ";
3393     }