fa5906bb2396ce4592eca7e4830b6deabedb201f
[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 = UnknownAddress) {
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     if (n_value == UnknownAddress)
2450       n_value = 0;
2451     ErrorOr<StringRef> NameOrError = Symbol.getName();
2452     if (std::error_code EC = NameOrError.getError())
2453       report_fatal_error(EC.message());
2454     StringRef Name = *NameOrError;
2455     if (!Name.empty()) {
2456       SymbolName = Name.data();
2457       return SymbolName;
2458     }
2459   }
2460
2461   // TODO: For fully linked images, look through the external relocation
2462   // entries off the dynamic symtab command. For these the r_offset is from the
2463   // start of the first writeable segment in the Mach-O file.  So the offset
2464   // to this section from that segment is passed to this routine by the caller,
2465   // as the database_offset. Which is the difference of the section's starting
2466   // address and the first writable segment.
2467   //
2468   // NOTE: need add passing the database_offset to this routine.
2469
2470   // We did not find an external relocation entry so look up the ReferenceValue
2471   // as an address of a symbol and if found return that symbol's name.
2472   if (ReferenceValue != UnknownAddress)
2473     SymbolName = GuessSymbolName(ReferenceValue, info->AddrMap);
2474
2475   return SymbolName;
2476 }
2477
2478 static const char *get_symbol_32(uint32_t sect_offset, SectionRef S,
2479                                  DisassembleInfo *info,
2480                                  uint32_t ReferenceValue) {
2481   uint64_t n_value64;
2482   return get_symbol_64(sect_offset, S, info, n_value64, ReferenceValue);
2483 }
2484
2485 // These are structs in the Objective-C meta data and read to produce the
2486 // comments for disassembly.  While these are part of the ABI they are no
2487 // public defintions.  So the are here not in include/llvm/Support/MachO.h .
2488
2489 // The cfstring object in a 64-bit Mach-O file.
2490 struct cfstring64_t {
2491   uint64_t isa;        // class64_t * (64-bit pointer)
2492   uint64_t flags;      // flag bits
2493   uint64_t characters; // char * (64-bit pointer)
2494   uint64_t length;     // number of non-NULL characters in above
2495 };
2496
2497 // The class object in a 64-bit Mach-O file.
2498 struct class64_t {
2499   uint64_t isa;        // class64_t * (64-bit pointer)
2500   uint64_t superclass; // class64_t * (64-bit pointer)
2501   uint64_t cache;      // Cache (64-bit pointer)
2502   uint64_t vtable;     // IMP * (64-bit pointer)
2503   uint64_t data;       // class_ro64_t * (64-bit pointer)
2504 };
2505
2506 struct class32_t {
2507   uint32_t isa;        /* class32_t * (32-bit pointer) */
2508   uint32_t superclass; /* class32_t * (32-bit pointer) */
2509   uint32_t cache;      /* Cache (32-bit pointer) */
2510   uint32_t vtable;     /* IMP * (32-bit pointer) */
2511   uint32_t data;       /* class_ro32_t * (32-bit pointer) */
2512 };
2513
2514 struct class_ro64_t {
2515   uint32_t flags;
2516   uint32_t instanceStart;
2517   uint32_t instanceSize;
2518   uint32_t reserved;
2519   uint64_t ivarLayout;     // const uint8_t * (64-bit pointer)
2520   uint64_t name;           // const char * (64-bit pointer)
2521   uint64_t baseMethods;    // const method_list_t * (64-bit pointer)
2522   uint64_t baseProtocols;  // const protocol_list_t * (64-bit pointer)
2523   uint64_t ivars;          // const ivar_list_t * (64-bit pointer)
2524   uint64_t weakIvarLayout; // const uint8_t * (64-bit pointer)
2525   uint64_t baseProperties; // const struct objc_property_list (64-bit pointer)
2526 };
2527
2528 struct class_ro32_t {
2529   uint32_t flags;
2530   uint32_t instanceStart;
2531   uint32_t instanceSize;
2532   uint32_t ivarLayout;     /* const uint8_t * (32-bit pointer) */
2533   uint32_t name;           /* const char * (32-bit pointer) */
2534   uint32_t baseMethods;    /* const method_list_t * (32-bit pointer) */
2535   uint32_t baseProtocols;  /* const protocol_list_t * (32-bit pointer) */
2536   uint32_t ivars;          /* const ivar_list_t * (32-bit pointer) */
2537   uint32_t weakIvarLayout; /* const uint8_t * (32-bit pointer) */
2538   uint32_t baseProperties; /* const struct objc_property_list *
2539                                                    (32-bit pointer) */
2540 };
2541
2542 /* Values for class_ro{64,32}_t->flags */
2543 #define RO_META (1 << 0)
2544 #define RO_ROOT (1 << 1)
2545 #define RO_HAS_CXX_STRUCTORS (1 << 2)
2546
2547 struct method_list64_t {
2548   uint32_t entsize;
2549   uint32_t count;
2550   /* struct method64_t first;  These structures follow inline */
2551 };
2552
2553 struct method_list32_t {
2554   uint32_t entsize;
2555   uint32_t count;
2556   /* struct method32_t first;  These structures follow inline */
2557 };
2558
2559 struct method64_t {
2560   uint64_t name;  /* SEL (64-bit pointer) */
2561   uint64_t types; /* const char * (64-bit pointer) */
2562   uint64_t imp;   /* IMP (64-bit pointer) */
2563 };
2564
2565 struct method32_t {
2566   uint32_t name;  /* SEL (32-bit pointer) */
2567   uint32_t types; /* const char * (32-bit pointer) */
2568   uint32_t imp;   /* IMP (32-bit pointer) */
2569 };
2570
2571 struct protocol_list64_t {
2572   uint64_t count; /* uintptr_t (a 64-bit value) */
2573   /* struct protocol64_t * list[0];  These pointers follow inline */
2574 };
2575
2576 struct protocol_list32_t {
2577   uint32_t count; /* uintptr_t (a 32-bit value) */
2578   /* struct protocol32_t * list[0];  These pointers follow inline */
2579 };
2580
2581 struct protocol64_t {
2582   uint64_t isa;                     /* id * (64-bit pointer) */
2583   uint64_t name;                    /* const char * (64-bit pointer) */
2584   uint64_t protocols;               /* struct protocol_list64_t *
2585                                                     (64-bit pointer) */
2586   uint64_t instanceMethods;         /* method_list_t * (64-bit pointer) */
2587   uint64_t classMethods;            /* method_list_t * (64-bit pointer) */
2588   uint64_t optionalInstanceMethods; /* method_list_t * (64-bit pointer) */
2589   uint64_t optionalClassMethods;    /* method_list_t * (64-bit pointer) */
2590   uint64_t instanceProperties;      /* struct objc_property_list *
2591                                                        (64-bit pointer) */
2592 };
2593
2594 struct protocol32_t {
2595   uint32_t isa;                     /* id * (32-bit pointer) */
2596   uint32_t name;                    /* const char * (32-bit pointer) */
2597   uint32_t protocols;               /* struct protocol_list_t *
2598                                                     (32-bit pointer) */
2599   uint32_t instanceMethods;         /* method_list_t * (32-bit pointer) */
2600   uint32_t classMethods;            /* method_list_t * (32-bit pointer) */
2601   uint32_t optionalInstanceMethods; /* method_list_t * (32-bit pointer) */
2602   uint32_t optionalClassMethods;    /* method_list_t * (32-bit pointer) */
2603   uint32_t instanceProperties;      /* struct objc_property_list *
2604                                                        (32-bit pointer) */
2605 };
2606
2607 struct ivar_list64_t {
2608   uint32_t entsize;
2609   uint32_t count;
2610   /* struct ivar64_t first;  These structures follow inline */
2611 };
2612
2613 struct ivar_list32_t {
2614   uint32_t entsize;
2615   uint32_t count;
2616   /* struct ivar32_t first;  These structures follow inline */
2617 };
2618
2619 struct ivar64_t {
2620   uint64_t offset; /* uintptr_t * (64-bit pointer) */
2621   uint64_t name;   /* const char * (64-bit pointer) */
2622   uint64_t type;   /* const char * (64-bit pointer) */
2623   uint32_t alignment;
2624   uint32_t size;
2625 };
2626
2627 struct ivar32_t {
2628   uint32_t offset; /* uintptr_t * (32-bit pointer) */
2629   uint32_t name;   /* const char * (32-bit pointer) */
2630   uint32_t type;   /* const char * (32-bit pointer) */
2631   uint32_t alignment;
2632   uint32_t size;
2633 };
2634
2635 struct objc_property_list64 {
2636   uint32_t entsize;
2637   uint32_t count;
2638   /* struct objc_property64 first;  These structures follow inline */
2639 };
2640
2641 struct objc_property_list32 {
2642   uint32_t entsize;
2643   uint32_t count;
2644   /* struct objc_property32 first;  These structures follow inline */
2645 };
2646
2647 struct objc_property64 {
2648   uint64_t name;       /* const char * (64-bit pointer) */
2649   uint64_t attributes; /* const char * (64-bit pointer) */
2650 };
2651
2652 struct objc_property32 {
2653   uint32_t name;       /* const char * (32-bit pointer) */
2654   uint32_t attributes; /* const char * (32-bit pointer) */
2655 };
2656
2657 struct category64_t {
2658   uint64_t name;               /* const char * (64-bit pointer) */
2659   uint64_t cls;                /* struct class_t * (64-bit pointer) */
2660   uint64_t instanceMethods;    /* struct method_list_t * (64-bit pointer) */
2661   uint64_t classMethods;       /* struct method_list_t * (64-bit pointer) */
2662   uint64_t protocols;          /* struct protocol_list_t * (64-bit pointer) */
2663   uint64_t instanceProperties; /* struct objc_property_list *
2664                                   (64-bit pointer) */
2665 };
2666
2667 struct category32_t {
2668   uint32_t name;               /* const char * (32-bit pointer) */
2669   uint32_t cls;                /* struct class_t * (32-bit pointer) */
2670   uint32_t instanceMethods;    /* struct method_list_t * (32-bit pointer) */
2671   uint32_t classMethods;       /* struct method_list_t * (32-bit pointer) */
2672   uint32_t protocols;          /* struct protocol_list_t * (32-bit pointer) */
2673   uint32_t instanceProperties; /* struct objc_property_list *
2674                                   (32-bit pointer) */
2675 };
2676
2677 struct objc_image_info64 {
2678   uint32_t version;
2679   uint32_t flags;
2680 };
2681 struct objc_image_info32 {
2682   uint32_t version;
2683   uint32_t flags;
2684 };
2685 struct imageInfo_t {
2686   uint32_t version;
2687   uint32_t flags;
2688 };
2689 /* masks for objc_image_info.flags */
2690 #define OBJC_IMAGE_IS_REPLACEMENT (1 << 0)
2691 #define OBJC_IMAGE_SUPPORTS_GC (1 << 1)
2692
2693 struct message_ref64 {
2694   uint64_t imp; /* IMP (64-bit pointer) */
2695   uint64_t sel; /* SEL (64-bit pointer) */
2696 };
2697
2698 struct message_ref32 {
2699   uint32_t imp; /* IMP (32-bit pointer) */
2700   uint32_t sel; /* SEL (32-bit pointer) */
2701 };
2702
2703 // Objective-C 1 (32-bit only) meta data structs.
2704
2705 struct objc_module_t {
2706   uint32_t version;
2707   uint32_t size;
2708   uint32_t name;   /* char * (32-bit pointer) */
2709   uint32_t symtab; /* struct objc_symtab * (32-bit pointer) */
2710 };
2711
2712 struct objc_symtab_t {
2713   uint32_t sel_ref_cnt;
2714   uint32_t refs; /* SEL * (32-bit pointer) */
2715   uint16_t cls_def_cnt;
2716   uint16_t cat_def_cnt;
2717   // uint32_t defs[1];        /* void * (32-bit pointer) variable size */
2718 };
2719
2720 struct objc_class_t {
2721   uint32_t isa;         /* struct objc_class * (32-bit pointer) */
2722   uint32_t super_class; /* struct objc_class * (32-bit pointer) */
2723   uint32_t name;        /* const char * (32-bit pointer) */
2724   int32_t version;
2725   int32_t info;
2726   int32_t instance_size;
2727   uint32_t ivars;       /* struct objc_ivar_list * (32-bit pointer) */
2728   uint32_t methodLists; /* struct objc_method_list ** (32-bit pointer) */
2729   uint32_t cache;       /* struct objc_cache * (32-bit pointer) */
2730   uint32_t protocols;   /* struct objc_protocol_list * (32-bit pointer) */
2731 };
2732
2733 #define CLS_GETINFO(cls, infomask) ((cls)->info & (infomask))
2734 // class is not a metaclass
2735 #define CLS_CLASS 0x1
2736 // class is a metaclass
2737 #define CLS_META 0x2
2738
2739 struct objc_category_t {
2740   uint32_t category_name;    /* char * (32-bit pointer) */
2741   uint32_t class_name;       /* char * (32-bit pointer) */
2742   uint32_t instance_methods; /* struct objc_method_list * (32-bit pointer) */
2743   uint32_t class_methods;    /* struct objc_method_list * (32-bit pointer) */
2744   uint32_t protocols;        /* struct objc_protocol_list * (32-bit ptr) */
2745 };
2746
2747 struct objc_ivar_t {
2748   uint32_t ivar_name; /* char * (32-bit pointer) */
2749   uint32_t ivar_type; /* char * (32-bit pointer) */
2750   int32_t ivar_offset;
2751 };
2752
2753 struct objc_ivar_list_t {
2754   int32_t ivar_count;
2755   // struct objc_ivar_t ivar_list[1];          /* variable length structure */
2756 };
2757
2758 struct objc_method_list_t {
2759   uint32_t obsolete; /* struct objc_method_list * (32-bit pointer) */
2760   int32_t method_count;
2761   // struct objc_method_t method_list[1];      /* variable length structure */
2762 };
2763
2764 struct objc_method_t {
2765   uint32_t method_name;  /* SEL, aka struct objc_selector * (32-bit pointer) */
2766   uint32_t method_types; /* char * (32-bit pointer) */
2767   uint32_t method_imp;   /* IMP, aka function pointer, (*IMP)(id, SEL, ...)
2768                             (32-bit pointer) */
2769 };
2770
2771 struct objc_protocol_list_t {
2772   uint32_t next; /* struct objc_protocol_list * (32-bit pointer) */
2773   int32_t count;
2774   // uint32_t list[1];   /* Protocol *, aka struct objc_protocol_t *
2775   //                        (32-bit pointer) */
2776 };
2777
2778 struct objc_protocol_t {
2779   uint32_t isa;              /* struct objc_class * (32-bit pointer) */
2780   uint32_t protocol_name;    /* char * (32-bit pointer) */
2781   uint32_t protocol_list;    /* struct objc_protocol_list * (32-bit pointer) */
2782   uint32_t instance_methods; /* struct objc_method_description_list *
2783                                 (32-bit pointer) */
2784   uint32_t class_methods;    /* struct objc_method_description_list *
2785                                 (32-bit pointer) */
2786 };
2787
2788 struct objc_method_description_list_t {
2789   int32_t count;
2790   // struct objc_method_description_t list[1];
2791 };
2792
2793 struct objc_method_description_t {
2794   uint32_t name;  /* SEL, aka struct objc_selector * (32-bit pointer) */
2795   uint32_t types; /* char * (32-bit pointer) */
2796 };
2797
2798 inline void swapStruct(struct cfstring64_t &cfs) {
2799   sys::swapByteOrder(cfs.isa);
2800   sys::swapByteOrder(cfs.flags);
2801   sys::swapByteOrder(cfs.characters);
2802   sys::swapByteOrder(cfs.length);
2803 }
2804
2805 inline void swapStruct(struct class64_t &c) {
2806   sys::swapByteOrder(c.isa);
2807   sys::swapByteOrder(c.superclass);
2808   sys::swapByteOrder(c.cache);
2809   sys::swapByteOrder(c.vtable);
2810   sys::swapByteOrder(c.data);
2811 }
2812
2813 inline void swapStruct(struct class32_t &c) {
2814   sys::swapByteOrder(c.isa);
2815   sys::swapByteOrder(c.superclass);
2816   sys::swapByteOrder(c.cache);
2817   sys::swapByteOrder(c.vtable);
2818   sys::swapByteOrder(c.data);
2819 }
2820
2821 inline void swapStruct(struct class_ro64_t &cro) {
2822   sys::swapByteOrder(cro.flags);
2823   sys::swapByteOrder(cro.instanceStart);
2824   sys::swapByteOrder(cro.instanceSize);
2825   sys::swapByteOrder(cro.reserved);
2826   sys::swapByteOrder(cro.ivarLayout);
2827   sys::swapByteOrder(cro.name);
2828   sys::swapByteOrder(cro.baseMethods);
2829   sys::swapByteOrder(cro.baseProtocols);
2830   sys::swapByteOrder(cro.ivars);
2831   sys::swapByteOrder(cro.weakIvarLayout);
2832   sys::swapByteOrder(cro.baseProperties);
2833 }
2834
2835 inline void swapStruct(struct class_ro32_t &cro) {
2836   sys::swapByteOrder(cro.flags);
2837   sys::swapByteOrder(cro.instanceStart);
2838   sys::swapByteOrder(cro.instanceSize);
2839   sys::swapByteOrder(cro.ivarLayout);
2840   sys::swapByteOrder(cro.name);
2841   sys::swapByteOrder(cro.baseMethods);
2842   sys::swapByteOrder(cro.baseProtocols);
2843   sys::swapByteOrder(cro.ivars);
2844   sys::swapByteOrder(cro.weakIvarLayout);
2845   sys::swapByteOrder(cro.baseProperties);
2846 }
2847
2848 inline void swapStruct(struct method_list64_t &ml) {
2849   sys::swapByteOrder(ml.entsize);
2850   sys::swapByteOrder(ml.count);
2851 }
2852
2853 inline void swapStruct(struct method_list32_t &ml) {
2854   sys::swapByteOrder(ml.entsize);
2855   sys::swapByteOrder(ml.count);
2856 }
2857
2858 inline void swapStruct(struct method64_t &m) {
2859   sys::swapByteOrder(m.name);
2860   sys::swapByteOrder(m.types);
2861   sys::swapByteOrder(m.imp);
2862 }
2863
2864 inline void swapStruct(struct method32_t &m) {
2865   sys::swapByteOrder(m.name);
2866   sys::swapByteOrder(m.types);
2867   sys::swapByteOrder(m.imp);
2868 }
2869
2870 inline void swapStruct(struct protocol_list64_t &pl) {
2871   sys::swapByteOrder(pl.count);
2872 }
2873
2874 inline void swapStruct(struct protocol_list32_t &pl) {
2875   sys::swapByteOrder(pl.count);
2876 }
2877
2878 inline void swapStruct(struct protocol64_t &p) {
2879   sys::swapByteOrder(p.isa);
2880   sys::swapByteOrder(p.name);
2881   sys::swapByteOrder(p.protocols);
2882   sys::swapByteOrder(p.instanceMethods);
2883   sys::swapByteOrder(p.classMethods);
2884   sys::swapByteOrder(p.optionalInstanceMethods);
2885   sys::swapByteOrder(p.optionalClassMethods);
2886   sys::swapByteOrder(p.instanceProperties);
2887 }
2888
2889 inline void swapStruct(struct protocol32_t &p) {
2890   sys::swapByteOrder(p.isa);
2891   sys::swapByteOrder(p.name);
2892   sys::swapByteOrder(p.protocols);
2893   sys::swapByteOrder(p.instanceMethods);
2894   sys::swapByteOrder(p.classMethods);
2895   sys::swapByteOrder(p.optionalInstanceMethods);
2896   sys::swapByteOrder(p.optionalClassMethods);
2897   sys::swapByteOrder(p.instanceProperties);
2898 }
2899
2900 inline void swapStruct(struct ivar_list64_t &il) {
2901   sys::swapByteOrder(il.entsize);
2902   sys::swapByteOrder(il.count);
2903 }
2904
2905 inline void swapStruct(struct ivar_list32_t &il) {
2906   sys::swapByteOrder(il.entsize);
2907   sys::swapByteOrder(il.count);
2908 }
2909
2910 inline void swapStruct(struct ivar64_t &i) {
2911   sys::swapByteOrder(i.offset);
2912   sys::swapByteOrder(i.name);
2913   sys::swapByteOrder(i.type);
2914   sys::swapByteOrder(i.alignment);
2915   sys::swapByteOrder(i.size);
2916 }
2917
2918 inline void swapStruct(struct ivar32_t &i) {
2919   sys::swapByteOrder(i.offset);
2920   sys::swapByteOrder(i.name);
2921   sys::swapByteOrder(i.type);
2922   sys::swapByteOrder(i.alignment);
2923   sys::swapByteOrder(i.size);
2924 }
2925
2926 inline void swapStruct(struct objc_property_list64 &pl) {
2927   sys::swapByteOrder(pl.entsize);
2928   sys::swapByteOrder(pl.count);
2929 }
2930
2931 inline void swapStruct(struct objc_property_list32 &pl) {
2932   sys::swapByteOrder(pl.entsize);
2933   sys::swapByteOrder(pl.count);
2934 }
2935
2936 inline void swapStruct(struct objc_property64 &op) {
2937   sys::swapByteOrder(op.name);
2938   sys::swapByteOrder(op.attributes);
2939 }
2940
2941 inline void swapStruct(struct objc_property32 &op) {
2942   sys::swapByteOrder(op.name);
2943   sys::swapByteOrder(op.attributes);
2944 }
2945
2946 inline void swapStruct(struct category64_t &c) {
2947   sys::swapByteOrder(c.name);
2948   sys::swapByteOrder(c.cls);
2949   sys::swapByteOrder(c.instanceMethods);
2950   sys::swapByteOrder(c.classMethods);
2951   sys::swapByteOrder(c.protocols);
2952   sys::swapByteOrder(c.instanceProperties);
2953 }
2954
2955 inline void swapStruct(struct category32_t &c) {
2956   sys::swapByteOrder(c.name);
2957   sys::swapByteOrder(c.cls);
2958   sys::swapByteOrder(c.instanceMethods);
2959   sys::swapByteOrder(c.classMethods);
2960   sys::swapByteOrder(c.protocols);
2961   sys::swapByteOrder(c.instanceProperties);
2962 }
2963
2964 inline void swapStruct(struct objc_image_info64 &o) {
2965   sys::swapByteOrder(o.version);
2966   sys::swapByteOrder(o.flags);
2967 }
2968
2969 inline void swapStruct(struct objc_image_info32 &o) {
2970   sys::swapByteOrder(o.version);
2971   sys::swapByteOrder(o.flags);
2972 }
2973
2974 inline void swapStruct(struct imageInfo_t &o) {
2975   sys::swapByteOrder(o.version);
2976   sys::swapByteOrder(o.flags);
2977 }
2978
2979 inline void swapStruct(struct message_ref64 &mr) {
2980   sys::swapByteOrder(mr.imp);
2981   sys::swapByteOrder(mr.sel);
2982 }
2983
2984 inline void swapStruct(struct message_ref32 &mr) {
2985   sys::swapByteOrder(mr.imp);
2986   sys::swapByteOrder(mr.sel);
2987 }
2988
2989 inline void swapStruct(struct objc_module_t &module) {
2990   sys::swapByteOrder(module.version);
2991   sys::swapByteOrder(module.size);
2992   sys::swapByteOrder(module.name);
2993   sys::swapByteOrder(module.symtab);
2994 }
2995
2996 inline void swapStruct(struct objc_symtab_t &symtab) {
2997   sys::swapByteOrder(symtab.sel_ref_cnt);
2998   sys::swapByteOrder(symtab.refs);
2999   sys::swapByteOrder(symtab.cls_def_cnt);
3000   sys::swapByteOrder(symtab.cat_def_cnt);
3001 }
3002
3003 inline void swapStruct(struct objc_class_t &objc_class) {
3004   sys::swapByteOrder(objc_class.isa);
3005   sys::swapByteOrder(objc_class.super_class);
3006   sys::swapByteOrder(objc_class.name);
3007   sys::swapByteOrder(objc_class.version);
3008   sys::swapByteOrder(objc_class.info);
3009   sys::swapByteOrder(objc_class.instance_size);
3010   sys::swapByteOrder(objc_class.ivars);
3011   sys::swapByteOrder(objc_class.methodLists);
3012   sys::swapByteOrder(objc_class.cache);
3013   sys::swapByteOrder(objc_class.protocols);
3014 }
3015
3016 inline void swapStruct(struct objc_category_t &objc_category) {
3017   sys::swapByteOrder(objc_category.category_name);
3018   sys::swapByteOrder(objc_category.class_name);
3019   sys::swapByteOrder(objc_category.instance_methods);
3020   sys::swapByteOrder(objc_category.class_methods);
3021   sys::swapByteOrder(objc_category.protocols);
3022 }
3023
3024 inline void swapStruct(struct objc_ivar_list_t &objc_ivar_list) {
3025   sys::swapByteOrder(objc_ivar_list.ivar_count);
3026 }
3027
3028 inline void swapStruct(struct objc_ivar_t &objc_ivar) {
3029   sys::swapByteOrder(objc_ivar.ivar_name);
3030   sys::swapByteOrder(objc_ivar.ivar_type);
3031   sys::swapByteOrder(objc_ivar.ivar_offset);
3032 }
3033
3034 inline void swapStruct(struct objc_method_list_t &method_list) {
3035   sys::swapByteOrder(method_list.obsolete);
3036   sys::swapByteOrder(method_list.method_count);
3037 }
3038
3039 inline void swapStruct(struct objc_method_t &method) {
3040   sys::swapByteOrder(method.method_name);
3041   sys::swapByteOrder(method.method_types);
3042   sys::swapByteOrder(method.method_imp);
3043 }
3044
3045 inline void swapStruct(struct objc_protocol_list_t &protocol_list) {
3046   sys::swapByteOrder(protocol_list.next);
3047   sys::swapByteOrder(protocol_list.count);
3048 }
3049
3050 inline void swapStruct(struct objc_protocol_t &protocol) {
3051   sys::swapByteOrder(protocol.isa);
3052   sys::swapByteOrder(protocol.protocol_name);
3053   sys::swapByteOrder(protocol.protocol_list);
3054   sys::swapByteOrder(protocol.instance_methods);
3055   sys::swapByteOrder(protocol.class_methods);
3056 }
3057
3058 inline void swapStruct(struct objc_method_description_list_t &mdl) {
3059   sys::swapByteOrder(mdl.count);
3060 }
3061
3062 inline void swapStruct(struct objc_method_description_t &md) {
3063   sys::swapByteOrder(md.name);
3064   sys::swapByteOrder(md.types);
3065 }
3066
3067 static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue,
3068                                                  struct DisassembleInfo *info);
3069
3070 // get_objc2_64bit_class_name() is used for disassembly and is passed a pointer
3071 // to an Objective-C class and returns the class name.  It is also passed the
3072 // address of the pointer, so when the pointer is zero as it can be in an .o
3073 // file, that is used to look for an external relocation entry with a symbol
3074 // name.
3075 static const char *get_objc2_64bit_class_name(uint64_t pointer_value,
3076                                               uint64_t ReferenceValue,
3077                                               struct DisassembleInfo *info) {
3078   const char *r;
3079   uint32_t offset, left;
3080   SectionRef S;
3081
3082   // The pointer_value can be 0 in an object file and have a relocation
3083   // entry for the class symbol at the ReferenceValue (the address of the
3084   // pointer).
3085   if (pointer_value == 0) {
3086     r = get_pointer_64(ReferenceValue, offset, left, S, info);
3087     if (r == nullptr || left < sizeof(uint64_t))
3088       return nullptr;
3089     uint64_t n_value;
3090     const char *symbol_name = get_symbol_64(offset, S, info, n_value);
3091     if (symbol_name == nullptr)
3092       return nullptr;
3093     const char *class_name = strrchr(symbol_name, '$');
3094     if (class_name != nullptr && class_name[1] == '_' && class_name[2] != '\0')
3095       return class_name + 2;
3096     else
3097       return nullptr;
3098   }
3099
3100   // The case were the pointer_value is non-zero and points to a class defined
3101   // in this Mach-O file.
3102   r = get_pointer_64(pointer_value, offset, left, S, info);
3103   if (r == nullptr || left < sizeof(struct class64_t))
3104     return nullptr;
3105   struct class64_t c;
3106   memcpy(&c, r, sizeof(struct class64_t));
3107   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3108     swapStruct(c);
3109   if (c.data == 0)
3110     return nullptr;
3111   r = get_pointer_64(c.data, offset, left, S, info);
3112   if (r == nullptr || left < sizeof(struct class_ro64_t))
3113     return nullptr;
3114   struct class_ro64_t cro;
3115   memcpy(&cro, r, sizeof(struct class_ro64_t));
3116   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3117     swapStruct(cro);
3118   if (cro.name == 0)
3119     return nullptr;
3120   const char *name = get_pointer_64(cro.name, offset, left, S, info);
3121   return name;
3122 }
3123
3124 // get_objc2_64bit_cfstring_name is used for disassembly and is passed a
3125 // pointer to a cfstring and returns its name or nullptr.
3126 static const char *get_objc2_64bit_cfstring_name(uint64_t ReferenceValue,
3127                                                  struct DisassembleInfo *info) {
3128   const char *r, *name;
3129   uint32_t offset, left;
3130   SectionRef S;
3131   struct cfstring64_t cfs;
3132   uint64_t cfs_characters;
3133
3134   r = get_pointer_64(ReferenceValue, offset, left, S, info);
3135   if (r == nullptr || left < sizeof(struct cfstring64_t))
3136     return nullptr;
3137   memcpy(&cfs, r, sizeof(struct cfstring64_t));
3138   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3139     swapStruct(cfs);
3140   if (cfs.characters == 0) {
3141     uint64_t n_value;
3142     const char *symbol_name = get_symbol_64(
3143         offset + offsetof(struct cfstring64_t, characters), S, info, n_value);
3144     if (symbol_name == nullptr)
3145       return nullptr;
3146     cfs_characters = n_value;
3147   } else
3148     cfs_characters = cfs.characters;
3149   name = get_pointer_64(cfs_characters, offset, left, S, info);
3150
3151   return name;
3152 }
3153
3154 // get_objc2_64bit_selref() is used for disassembly and is passed a the address
3155 // of a pointer to an Objective-C selector reference when the pointer value is
3156 // zero as in a .o file and is likely to have a external relocation entry with
3157 // who's symbol's n_value is the real pointer to the selector name.  If that is
3158 // the case the real pointer to the selector name is returned else 0 is
3159 // returned
3160 static uint64_t get_objc2_64bit_selref(uint64_t ReferenceValue,
3161                                        struct DisassembleInfo *info) {
3162   uint32_t offset, left;
3163   SectionRef S;
3164
3165   const char *r = get_pointer_64(ReferenceValue, offset, left, S, info);
3166   if (r == nullptr || left < sizeof(uint64_t))
3167     return 0;
3168   uint64_t n_value;
3169   const char *symbol_name = get_symbol_64(offset, S, info, n_value);
3170   if (symbol_name == nullptr)
3171     return 0;
3172   return n_value;
3173 }
3174
3175 static const SectionRef get_section(MachOObjectFile *O, const char *segname,
3176                                     const char *sectname) {
3177   for (const SectionRef &Section : O->sections()) {
3178     StringRef SectName;
3179     Section.getName(SectName);
3180     DataRefImpl Ref = Section.getRawDataRefImpl();
3181     StringRef SegName = O->getSectionFinalSegmentName(Ref);
3182     if (SegName == segname && SectName == sectname)
3183       return Section;
3184   }
3185   return SectionRef();
3186 }
3187
3188 static void
3189 walk_pointer_list_64(const char *listname, const SectionRef S,
3190                      MachOObjectFile *O, struct DisassembleInfo *info,
3191                      void (*func)(uint64_t, struct DisassembleInfo *info)) {
3192   if (S == SectionRef())
3193     return;
3194
3195   StringRef SectName;
3196   S.getName(SectName);
3197   DataRefImpl Ref = S.getRawDataRefImpl();
3198   StringRef SegName = O->getSectionFinalSegmentName(Ref);
3199   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
3200
3201   StringRef BytesStr;
3202   S.getContents(BytesStr);
3203   const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
3204
3205   for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint64_t)) {
3206     uint32_t left = S.getSize() - i;
3207     uint32_t size = left < sizeof(uint64_t) ? left : sizeof(uint64_t);
3208     uint64_t p = 0;
3209     memcpy(&p, Contents + i, size);
3210     if (i + sizeof(uint64_t) > S.getSize())
3211       outs() << listname << " list pointer extends past end of (" << SegName
3212              << "," << SectName << ") section\n";
3213     outs() << format("%016" PRIx64, S.getAddress() + i) << " ";
3214
3215     if (O->isLittleEndian() != sys::IsLittleEndianHost)
3216       sys::swapByteOrder(p);
3217
3218     uint64_t n_value = 0;
3219     const char *name = get_symbol_64(i, S, info, n_value, p);
3220     if (name == nullptr)
3221       name = get_dyld_bind_info_symbolname(S.getAddress() + i, info);
3222
3223     if (n_value != 0) {
3224       outs() << format("0x%" PRIx64, n_value);
3225       if (p != 0)
3226         outs() << " + " << format("0x%" PRIx64, p);
3227     } else
3228       outs() << format("0x%" PRIx64, p);
3229     if (name != nullptr)
3230       outs() << " " << name;
3231     outs() << "\n";
3232
3233     p += n_value;
3234     if (func)
3235       func(p, info);
3236   }
3237 }
3238
3239 static void
3240 walk_pointer_list_32(const char *listname, const SectionRef S,
3241                      MachOObjectFile *O, struct DisassembleInfo *info,
3242                      void (*func)(uint32_t, struct DisassembleInfo *info)) {
3243   if (S == SectionRef())
3244     return;
3245
3246   StringRef SectName;
3247   S.getName(SectName);
3248   DataRefImpl Ref = S.getRawDataRefImpl();
3249   StringRef SegName = O->getSectionFinalSegmentName(Ref);
3250   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
3251
3252   StringRef BytesStr;
3253   S.getContents(BytesStr);
3254   const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
3255
3256   for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint32_t)) {
3257     uint32_t left = S.getSize() - i;
3258     uint32_t size = left < sizeof(uint32_t) ? left : sizeof(uint32_t);
3259     uint32_t p = 0;
3260     memcpy(&p, Contents + i, size);
3261     if (i + sizeof(uint32_t) > S.getSize())
3262       outs() << listname << " list pointer extends past end of (" << SegName
3263              << "," << SectName << ") section\n";
3264     uint32_t Address = S.getAddress() + i;
3265     outs() << format("%08" PRIx32, Address) << " ";
3266
3267     if (O->isLittleEndian() != sys::IsLittleEndianHost)
3268       sys::swapByteOrder(p);
3269     outs() << format("0x%" PRIx32, p);
3270
3271     const char *name = get_symbol_32(i, S, info, p);
3272     if (name != nullptr)
3273       outs() << " " << name;
3274     outs() << "\n";
3275
3276     if (func)
3277       func(p, info);
3278   }
3279 }
3280
3281 static void print_layout_map(const char *layout_map, uint32_t left) {
3282   outs() << "                layout map: ";
3283   do {
3284     outs() << format("0x%02" PRIx32, (*layout_map) & 0xff) << " ";
3285     left--;
3286     layout_map++;
3287   } while (*layout_map != '\0' && left != 0);
3288   outs() << "\n";
3289 }
3290
3291 static void print_layout_map64(uint64_t p, struct DisassembleInfo *info) {
3292   uint32_t offset, left;
3293   SectionRef S;
3294   const char *layout_map;
3295
3296   if (p == 0)
3297     return;
3298   layout_map = get_pointer_64(p, offset, left, S, info);
3299   print_layout_map(layout_map, left);
3300 }
3301
3302 static void print_layout_map32(uint32_t p, struct DisassembleInfo *info) {
3303   uint32_t offset, left;
3304   SectionRef S;
3305   const char *layout_map;
3306
3307   if (p == 0)
3308     return;
3309   layout_map = get_pointer_32(p, offset, left, S, info);
3310   print_layout_map(layout_map, left);
3311 }
3312
3313 static void print_method_list64_t(uint64_t p, struct DisassembleInfo *info,
3314                                   const char *indent) {
3315   struct method_list64_t ml;
3316   struct method64_t m;
3317   const char *r;
3318   uint32_t offset, xoffset, left, i;
3319   SectionRef S, xS;
3320   const char *name, *sym_name;
3321   uint64_t n_value;
3322
3323   r = get_pointer_64(p, offset, left, S, info);
3324   if (r == nullptr)
3325     return;
3326   memset(&ml, '\0', sizeof(struct method_list64_t));
3327   if (left < sizeof(struct method_list64_t)) {
3328     memcpy(&ml, r, left);
3329     outs() << "   (method_list_t entends past the end of the section)\n";
3330   } else
3331     memcpy(&ml, r, sizeof(struct method_list64_t));
3332   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3333     swapStruct(ml);
3334   outs() << indent << "\t\t   entsize " << ml.entsize << "\n";
3335   outs() << indent << "\t\t     count " << ml.count << "\n";
3336
3337   p += sizeof(struct method_list64_t);
3338   offset += sizeof(struct method_list64_t);
3339   for (i = 0; i < ml.count; i++) {
3340     r = get_pointer_64(p, offset, left, S, info);
3341     if (r == nullptr)
3342       return;
3343     memset(&m, '\0', sizeof(struct method64_t));
3344     if (left < sizeof(struct method64_t)) {
3345       memcpy(&ml, r, left);
3346       outs() << indent << "   (method_t entends past the end of the section)\n";
3347     } else
3348       memcpy(&m, r, sizeof(struct method64_t));
3349     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3350       swapStruct(m);
3351
3352     outs() << indent << "\t\t      name ";
3353     sym_name = get_symbol_64(offset + offsetof(struct method64_t, name), S,
3354                              info, n_value, m.name);
3355     if (n_value != 0) {
3356       if (info->verbose && sym_name != nullptr)
3357         outs() << sym_name;
3358       else
3359         outs() << format("0x%" PRIx64, n_value);
3360       if (m.name != 0)
3361         outs() << " + " << format("0x%" PRIx64, m.name);
3362     } else
3363       outs() << format("0x%" PRIx64, m.name);
3364     name = get_pointer_64(m.name + n_value, xoffset, left, xS, info);
3365     if (name != nullptr)
3366       outs() << format(" %.*s", left, name);
3367     outs() << "\n";
3368
3369     outs() << indent << "\t\t     types ";
3370     sym_name = get_symbol_64(offset + offsetof(struct method64_t, types), S,
3371                              info, n_value, m.types);
3372     if (n_value != 0) {
3373       if (info->verbose && sym_name != nullptr)
3374         outs() << sym_name;
3375       else
3376         outs() << format("0x%" PRIx64, n_value);
3377       if (m.types != 0)
3378         outs() << " + " << format("0x%" PRIx64, m.types);
3379     } else
3380       outs() << format("0x%" PRIx64, m.types);
3381     name = get_pointer_64(m.types + n_value, xoffset, left, xS, info);
3382     if (name != nullptr)
3383       outs() << format(" %.*s", left, name);
3384     outs() << "\n";
3385
3386     outs() << indent << "\t\t       imp ";
3387     name = get_symbol_64(offset + offsetof(struct method64_t, imp), S, info,
3388                          n_value, m.imp);
3389     if (info->verbose && name == nullptr) {
3390       if (n_value != 0) {
3391         outs() << format("0x%" PRIx64, n_value) << " ";
3392         if (m.imp != 0)
3393           outs() << "+ " << format("0x%" PRIx64, m.imp) << " ";
3394       } else
3395         outs() << format("0x%" PRIx64, m.imp) << " ";
3396     }
3397     if (name != nullptr)
3398       outs() << name;
3399     outs() << "\n";
3400
3401     p += sizeof(struct method64_t);
3402     offset += sizeof(struct method64_t);
3403   }
3404 }
3405
3406 static void print_method_list32_t(uint64_t p, struct DisassembleInfo *info,
3407                                   const char *indent) {
3408   struct method_list32_t ml;
3409   struct method32_t m;
3410   const char *r, *name;
3411   uint32_t offset, xoffset, left, i;
3412   SectionRef S, xS;
3413
3414   r = get_pointer_32(p, offset, left, S, info);
3415   if (r == nullptr)
3416     return;
3417   memset(&ml, '\0', sizeof(struct method_list32_t));
3418   if (left < sizeof(struct method_list32_t)) {
3419     memcpy(&ml, r, left);
3420     outs() << "   (method_list_t entends past the end of the section)\n";
3421   } else
3422     memcpy(&ml, r, sizeof(struct method_list32_t));
3423   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3424     swapStruct(ml);
3425   outs() << indent << "\t\t   entsize " << ml.entsize << "\n";
3426   outs() << indent << "\t\t     count " << ml.count << "\n";
3427
3428   p += sizeof(struct method_list32_t);
3429   offset += sizeof(struct method_list32_t);
3430   for (i = 0; i < ml.count; i++) {
3431     r = get_pointer_32(p, offset, left, S, info);
3432     if (r == nullptr)
3433       return;
3434     memset(&m, '\0', sizeof(struct method32_t));
3435     if (left < sizeof(struct method32_t)) {
3436       memcpy(&ml, r, left);
3437       outs() << indent << "   (method_t entends past the end of the section)\n";
3438     } else
3439       memcpy(&m, r, sizeof(struct method32_t));
3440     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3441       swapStruct(m);
3442
3443     outs() << indent << "\t\t      name " << format("0x%" PRIx32, m.name);
3444     name = get_pointer_32(m.name, xoffset, left, xS, info);
3445     if (name != nullptr)
3446       outs() << format(" %.*s", left, name);
3447     outs() << "\n";
3448
3449     outs() << indent << "\t\t     types " << format("0x%" PRIx32, m.types);
3450     name = get_pointer_32(m.types, xoffset, left, xS, info);
3451     if (name != nullptr)
3452       outs() << format(" %.*s", left, name);
3453     outs() << "\n";
3454
3455     outs() << indent << "\t\t       imp " << format("0x%" PRIx32, m.imp);
3456     name = get_symbol_32(offset + offsetof(struct method32_t, imp), S, info,
3457                          m.imp);
3458     if (name != nullptr)
3459       outs() << " " << name;
3460     outs() << "\n";
3461
3462     p += sizeof(struct method32_t);
3463     offset += sizeof(struct method32_t);
3464   }
3465 }
3466
3467 static bool print_method_list(uint32_t p, struct DisassembleInfo *info) {
3468   uint32_t offset, left, xleft;
3469   SectionRef S;
3470   struct objc_method_list_t method_list;
3471   struct objc_method_t method;
3472   const char *r, *methods, *name, *SymbolName;
3473   int32_t i;
3474
3475   r = get_pointer_32(p, offset, left, S, info, true);
3476   if (r == nullptr)
3477     return true;
3478
3479   outs() << "\n";
3480   if (left > sizeof(struct objc_method_list_t)) {
3481     memcpy(&method_list, r, sizeof(struct objc_method_list_t));
3482   } else {
3483     outs() << "\t\t objc_method_list extends past end of the section\n";
3484     memset(&method_list, '\0', sizeof(struct objc_method_list_t));
3485     memcpy(&method_list, r, left);
3486   }
3487   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3488     swapStruct(method_list);
3489
3490   outs() << "\t\t         obsolete "
3491          << format("0x%08" PRIx32, method_list.obsolete) << "\n";
3492   outs() << "\t\t     method_count " << method_list.method_count << "\n";
3493
3494   methods = r + sizeof(struct objc_method_list_t);
3495   for (i = 0; i < method_list.method_count; i++) {
3496     if ((i + 1) * sizeof(struct objc_method_t) > left) {
3497       outs() << "\t\t remaining method's extend past the of the section\n";
3498       break;
3499     }
3500     memcpy(&method, methods + i * sizeof(struct objc_method_t),
3501            sizeof(struct objc_method_t));
3502     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3503       swapStruct(method);
3504
3505     outs() << "\t\t      method_name "
3506            << format("0x%08" PRIx32, method.method_name);
3507     if (info->verbose) {
3508       name = get_pointer_32(method.method_name, offset, xleft, S, info, true);
3509       if (name != nullptr)
3510         outs() << format(" %.*s", xleft, name);
3511       else
3512         outs() << " (not in an __OBJC section)";
3513     }
3514     outs() << "\n";
3515
3516     outs() << "\t\t     method_types "
3517            << format("0x%08" PRIx32, method.method_types);
3518     if (info->verbose) {
3519       name = get_pointer_32(method.method_types, offset, xleft, S, info, true);
3520       if (name != nullptr)
3521         outs() << format(" %.*s", xleft, name);
3522       else
3523         outs() << " (not in an __OBJC section)";
3524     }
3525     outs() << "\n";
3526
3527     outs() << "\t\t       method_imp "
3528            << format("0x%08" PRIx32, method.method_imp) << " ";
3529     if (info->verbose) {
3530       SymbolName = GuessSymbolName(method.method_imp, info->AddrMap);
3531       if (SymbolName != nullptr)
3532         outs() << SymbolName;
3533     }
3534     outs() << "\n";
3535   }
3536   return false;
3537 }
3538
3539 static void print_protocol_list64_t(uint64_t p, struct DisassembleInfo *info) {
3540   struct protocol_list64_t pl;
3541   uint64_t q, n_value;
3542   struct protocol64_t pc;
3543   const char *r;
3544   uint32_t offset, xoffset, left, i;
3545   SectionRef S, xS;
3546   const char *name, *sym_name;
3547
3548   r = get_pointer_64(p, offset, left, S, info);
3549   if (r == nullptr)
3550     return;
3551   memset(&pl, '\0', sizeof(struct protocol_list64_t));
3552   if (left < sizeof(struct protocol_list64_t)) {
3553     memcpy(&pl, r, left);
3554     outs() << "   (protocol_list_t entends past the end of the section)\n";
3555   } else
3556     memcpy(&pl, r, sizeof(struct protocol_list64_t));
3557   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3558     swapStruct(pl);
3559   outs() << "                      count " << pl.count << "\n";
3560
3561   p += sizeof(struct protocol_list64_t);
3562   offset += sizeof(struct protocol_list64_t);
3563   for (i = 0; i < pl.count; i++) {
3564     r = get_pointer_64(p, offset, left, S, info);
3565     if (r == nullptr)
3566       return;
3567     q = 0;
3568     if (left < sizeof(uint64_t)) {
3569       memcpy(&q, r, left);
3570       outs() << "   (protocol_t * entends past the end of the section)\n";
3571     } else
3572       memcpy(&q, r, sizeof(uint64_t));
3573     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3574       sys::swapByteOrder(q);
3575
3576     outs() << "\t\t      list[" << i << "] ";
3577     sym_name = get_symbol_64(offset, S, info, n_value, q);
3578     if (n_value != 0) {
3579       if (info->verbose && sym_name != nullptr)
3580         outs() << sym_name;
3581       else
3582         outs() << format("0x%" PRIx64, n_value);
3583       if (q != 0)
3584         outs() << " + " << format("0x%" PRIx64, q);
3585     } else
3586       outs() << format("0x%" PRIx64, q);
3587     outs() << " (struct protocol_t *)\n";
3588
3589     r = get_pointer_64(q + n_value, offset, left, S, info);
3590     if (r == nullptr)
3591       return;
3592     memset(&pc, '\0', sizeof(struct protocol64_t));
3593     if (left < sizeof(struct protocol64_t)) {
3594       memcpy(&pc, r, left);
3595       outs() << "   (protocol_t entends past the end of the section)\n";
3596     } else
3597       memcpy(&pc, r, sizeof(struct protocol64_t));
3598     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3599       swapStruct(pc);
3600
3601     outs() << "\t\t\t      isa " << format("0x%" PRIx64, pc.isa) << "\n";
3602
3603     outs() << "\t\t\t     name ";
3604     sym_name = get_symbol_64(offset + offsetof(struct protocol64_t, name), S,
3605                              info, n_value, pc.name);
3606     if (n_value != 0) {
3607       if (info->verbose && sym_name != nullptr)
3608         outs() << sym_name;
3609       else
3610         outs() << format("0x%" PRIx64, n_value);
3611       if (pc.name != 0)
3612         outs() << " + " << format("0x%" PRIx64, pc.name);
3613     } else
3614       outs() << format("0x%" PRIx64, pc.name);
3615     name = get_pointer_64(pc.name + n_value, xoffset, left, xS, info);
3616     if (name != nullptr)
3617       outs() << format(" %.*s", left, name);
3618     outs() << "\n";
3619
3620     outs() << "\t\t\tprotocols " << format("0x%" PRIx64, pc.protocols) << "\n";
3621
3622     outs() << "\t\t  instanceMethods ";
3623     sym_name =
3624         get_symbol_64(offset + offsetof(struct protocol64_t, instanceMethods),
3625                       S, info, n_value, pc.instanceMethods);
3626     if (n_value != 0) {
3627       if (info->verbose && sym_name != nullptr)
3628         outs() << sym_name;
3629       else
3630         outs() << format("0x%" PRIx64, n_value);
3631       if (pc.instanceMethods != 0)
3632         outs() << " + " << format("0x%" PRIx64, pc.instanceMethods);
3633     } else
3634       outs() << format("0x%" PRIx64, pc.instanceMethods);
3635     outs() << " (struct method_list_t *)\n";
3636     if (pc.instanceMethods + n_value != 0)
3637       print_method_list64_t(pc.instanceMethods + n_value, info, "\t");
3638
3639     outs() << "\t\t     classMethods ";
3640     sym_name =
3641         get_symbol_64(offset + offsetof(struct protocol64_t, classMethods), S,
3642                       info, n_value, pc.classMethods);
3643     if (n_value != 0) {
3644       if (info->verbose && sym_name != nullptr)
3645         outs() << sym_name;
3646       else
3647         outs() << format("0x%" PRIx64, n_value);
3648       if (pc.classMethods != 0)
3649         outs() << " + " << format("0x%" PRIx64, pc.classMethods);
3650     } else
3651       outs() << format("0x%" PRIx64, pc.classMethods);
3652     outs() << " (struct method_list_t *)\n";
3653     if (pc.classMethods + n_value != 0)
3654       print_method_list64_t(pc.classMethods + n_value, info, "\t");
3655
3656     outs() << "\t  optionalInstanceMethods "
3657            << format("0x%" PRIx64, pc.optionalInstanceMethods) << "\n";
3658     outs() << "\t     optionalClassMethods "
3659            << format("0x%" PRIx64, pc.optionalClassMethods) << "\n";
3660     outs() << "\t       instanceProperties "
3661            << format("0x%" PRIx64, pc.instanceProperties) << "\n";
3662
3663     p += sizeof(uint64_t);
3664     offset += sizeof(uint64_t);
3665   }
3666 }
3667
3668 static void print_protocol_list32_t(uint32_t p, struct DisassembleInfo *info) {
3669   struct protocol_list32_t pl;
3670   uint32_t q;
3671   struct protocol32_t pc;
3672   const char *r;
3673   uint32_t offset, xoffset, left, i;
3674   SectionRef S, xS;
3675   const char *name;
3676
3677   r = get_pointer_32(p, offset, left, S, info);
3678   if (r == nullptr)
3679     return;
3680   memset(&pl, '\0', sizeof(struct protocol_list32_t));
3681   if (left < sizeof(struct protocol_list32_t)) {
3682     memcpy(&pl, r, left);
3683     outs() << "   (protocol_list_t entends past the end of the section)\n";
3684   } else
3685     memcpy(&pl, r, sizeof(struct protocol_list32_t));
3686   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3687     swapStruct(pl);
3688   outs() << "                      count " << pl.count << "\n";
3689
3690   p += sizeof(struct protocol_list32_t);
3691   offset += sizeof(struct protocol_list32_t);
3692   for (i = 0; i < pl.count; i++) {
3693     r = get_pointer_32(p, offset, left, S, info);
3694     if (r == nullptr)
3695       return;
3696     q = 0;
3697     if (left < sizeof(uint32_t)) {
3698       memcpy(&q, r, left);
3699       outs() << "   (protocol_t * entends past the end of the section)\n";
3700     } else
3701       memcpy(&q, r, sizeof(uint32_t));
3702     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3703       sys::swapByteOrder(q);
3704     outs() << "\t\t      list[" << i << "] " << format("0x%" PRIx32, q)
3705            << " (struct protocol_t *)\n";
3706     r = get_pointer_32(q, offset, left, S, info);
3707     if (r == nullptr)
3708       return;
3709     memset(&pc, '\0', sizeof(struct protocol32_t));
3710     if (left < sizeof(struct protocol32_t)) {
3711       memcpy(&pc, r, left);
3712       outs() << "   (protocol_t entends past the end of the section)\n";
3713     } else
3714       memcpy(&pc, r, sizeof(struct protocol32_t));
3715     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3716       swapStruct(pc);
3717     outs() << "\t\t\t      isa " << format("0x%" PRIx32, pc.isa) << "\n";
3718     outs() << "\t\t\t     name " << format("0x%" PRIx32, pc.name);
3719     name = get_pointer_32(pc.name, xoffset, left, xS, info);
3720     if (name != nullptr)
3721       outs() << format(" %.*s", left, name);
3722     outs() << "\n";
3723     outs() << "\t\t\tprotocols " << format("0x%" PRIx32, pc.protocols) << "\n";
3724     outs() << "\t\t  instanceMethods "
3725            << format("0x%" PRIx32, pc.instanceMethods)
3726            << " (struct method_list_t *)\n";
3727     if (pc.instanceMethods != 0)
3728       print_method_list32_t(pc.instanceMethods, info, "\t");
3729     outs() << "\t\t     classMethods " << format("0x%" PRIx32, pc.classMethods)
3730            << " (struct method_list_t *)\n";
3731     if (pc.classMethods != 0)
3732       print_method_list32_t(pc.classMethods, info, "\t");
3733     outs() << "\t  optionalInstanceMethods "
3734            << format("0x%" PRIx32, pc.optionalInstanceMethods) << "\n";
3735     outs() << "\t     optionalClassMethods "
3736            << format("0x%" PRIx32, pc.optionalClassMethods) << "\n";
3737     outs() << "\t       instanceProperties "
3738            << format("0x%" PRIx32, pc.instanceProperties) << "\n";
3739     p += sizeof(uint32_t);
3740     offset += sizeof(uint32_t);
3741   }
3742 }
3743
3744 static void print_indent(uint32_t indent) {
3745   for (uint32_t i = 0; i < indent;) {
3746     if (indent - i >= 8) {
3747       outs() << "\t";
3748       i += 8;
3749     } else {
3750       for (uint32_t j = i; j < indent; j++)
3751         outs() << " ";
3752       return;
3753     }
3754   }
3755 }
3756
3757 static bool print_method_description_list(uint32_t p, uint32_t indent,
3758                                           struct DisassembleInfo *info) {
3759   uint32_t offset, left, xleft;
3760   SectionRef S;
3761   struct objc_method_description_list_t mdl;
3762   struct objc_method_description_t md;
3763   const char *r, *list, *name;
3764   int32_t i;
3765
3766   r = get_pointer_32(p, offset, left, S, info, true);
3767   if (r == nullptr)
3768     return true;
3769
3770   outs() << "\n";
3771   if (left > sizeof(struct objc_method_description_list_t)) {
3772     memcpy(&mdl, r, sizeof(struct objc_method_description_list_t));
3773   } else {
3774     print_indent(indent);
3775     outs() << " objc_method_description_list extends past end of the section\n";
3776     memset(&mdl, '\0', sizeof(struct objc_method_description_list_t));
3777     memcpy(&mdl, r, left);
3778   }
3779   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3780     swapStruct(mdl);
3781
3782   print_indent(indent);
3783   outs() << "        count " << mdl.count << "\n";
3784
3785   list = r + sizeof(struct objc_method_description_list_t);
3786   for (i = 0; i < mdl.count; i++) {
3787     if ((i + 1) * sizeof(struct objc_method_description_t) > left) {
3788       print_indent(indent);
3789       outs() << " remaining list entries extend past the of the section\n";
3790       break;
3791     }
3792     print_indent(indent);
3793     outs() << "        list[" << i << "]\n";
3794     memcpy(&md, list + i * sizeof(struct objc_method_description_t),
3795            sizeof(struct objc_method_description_t));
3796     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3797       swapStruct(md);
3798
3799     print_indent(indent);
3800     outs() << "             name " << format("0x%08" PRIx32, md.name);
3801     if (info->verbose) {
3802       name = get_pointer_32(md.name, offset, xleft, S, info, true);
3803       if (name != nullptr)
3804         outs() << format(" %.*s", xleft, name);
3805       else
3806         outs() << " (not in an __OBJC section)";
3807     }
3808     outs() << "\n";
3809
3810     print_indent(indent);
3811     outs() << "            types " << format("0x%08" PRIx32, md.types);
3812     if (info->verbose) {
3813       name = get_pointer_32(md.types, offset, xleft, S, info, true);
3814       if (name != nullptr)
3815         outs() << format(" %.*s", xleft, name);
3816       else
3817         outs() << " (not in an __OBJC section)";
3818     }
3819     outs() << "\n";
3820   }
3821   return false;
3822 }
3823
3824 static bool print_protocol_list(uint32_t p, uint32_t indent,
3825                                 struct DisassembleInfo *info);
3826
3827 static bool print_protocol(uint32_t p, uint32_t indent,
3828                            struct DisassembleInfo *info) {
3829   uint32_t offset, left;
3830   SectionRef S;
3831   struct objc_protocol_t protocol;
3832   const char *r, *name;
3833
3834   r = get_pointer_32(p, offset, left, S, info, true);
3835   if (r == nullptr)
3836     return true;
3837
3838   outs() << "\n";
3839   if (left >= sizeof(struct objc_protocol_t)) {
3840     memcpy(&protocol, r, sizeof(struct objc_protocol_t));
3841   } else {
3842     print_indent(indent);
3843     outs() << "            Protocol extends past end of the section\n";
3844     memset(&protocol, '\0', sizeof(struct objc_protocol_t));
3845     memcpy(&protocol, r, left);
3846   }
3847   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3848     swapStruct(protocol);
3849
3850   print_indent(indent);
3851   outs() << "              isa " << format("0x%08" PRIx32, protocol.isa)
3852          << "\n";
3853
3854   print_indent(indent);
3855   outs() << "    protocol_name "
3856          << format("0x%08" PRIx32, protocol.protocol_name);
3857   if (info->verbose) {
3858     name = get_pointer_32(protocol.protocol_name, offset, left, S, info, true);
3859     if (name != nullptr)
3860       outs() << format(" %.*s", left, name);
3861     else
3862       outs() << " (not in an __OBJC section)";
3863   }
3864   outs() << "\n";
3865
3866   print_indent(indent);
3867   outs() << "    protocol_list "
3868          << format("0x%08" PRIx32, protocol.protocol_list);
3869   if (print_protocol_list(protocol.protocol_list, indent + 4, info))
3870     outs() << " (not in an __OBJC section)\n";
3871
3872   print_indent(indent);
3873   outs() << " instance_methods "
3874          << format("0x%08" PRIx32, protocol.instance_methods);
3875   if (print_method_description_list(protocol.instance_methods, indent, info))
3876     outs() << " (not in an __OBJC section)\n";
3877
3878   print_indent(indent);
3879   outs() << "    class_methods "
3880          << format("0x%08" PRIx32, protocol.class_methods);
3881   if (print_method_description_list(protocol.class_methods, indent, info))
3882     outs() << " (not in an __OBJC section)\n";
3883
3884   return false;
3885 }
3886
3887 static bool print_protocol_list(uint32_t p, uint32_t indent,
3888                                 struct DisassembleInfo *info) {
3889   uint32_t offset, left, l;
3890   SectionRef S;
3891   struct objc_protocol_list_t protocol_list;
3892   const char *r, *list;
3893   int32_t i;
3894
3895   r = get_pointer_32(p, offset, left, S, info, true);
3896   if (r == nullptr)
3897     return true;
3898
3899   outs() << "\n";
3900   if (left > sizeof(struct objc_protocol_list_t)) {
3901     memcpy(&protocol_list, r, sizeof(struct objc_protocol_list_t));
3902   } else {
3903     outs() << "\t\t objc_protocol_list_t extends past end of the section\n";
3904     memset(&protocol_list, '\0', sizeof(struct objc_protocol_list_t));
3905     memcpy(&protocol_list, r, left);
3906   }
3907   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3908     swapStruct(protocol_list);
3909
3910   print_indent(indent);
3911   outs() << "         next " << format("0x%08" PRIx32, protocol_list.next)
3912          << "\n";
3913   print_indent(indent);
3914   outs() << "        count " << protocol_list.count << "\n";
3915
3916   list = r + sizeof(struct objc_protocol_list_t);
3917   for (i = 0; i < protocol_list.count; i++) {
3918     if ((i + 1) * sizeof(uint32_t) > left) {
3919       outs() << "\t\t remaining list entries extend past the of the section\n";
3920       break;
3921     }
3922     memcpy(&l, list + i * sizeof(uint32_t), sizeof(uint32_t));
3923     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3924       sys::swapByteOrder(l);
3925
3926     print_indent(indent);
3927     outs() << "      list[" << i << "] " << format("0x%08" PRIx32, l);
3928     if (print_protocol(l, indent, info))
3929       outs() << "(not in an __OBJC section)\n";
3930   }
3931   return false;
3932 }
3933
3934 static void print_ivar_list64_t(uint64_t p, struct DisassembleInfo *info) {
3935   struct ivar_list64_t il;
3936   struct ivar64_t i;
3937   const char *r;
3938   uint32_t offset, xoffset, left, j;
3939   SectionRef S, xS;
3940   const char *name, *sym_name, *ivar_offset_p;
3941   uint64_t ivar_offset, n_value;
3942
3943   r = get_pointer_64(p, offset, left, S, info);
3944   if (r == nullptr)
3945     return;
3946   memset(&il, '\0', sizeof(struct ivar_list64_t));
3947   if (left < sizeof(struct ivar_list64_t)) {
3948     memcpy(&il, r, left);
3949     outs() << "   (ivar_list_t entends past the end of the section)\n";
3950   } else
3951     memcpy(&il, r, sizeof(struct ivar_list64_t));
3952   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3953     swapStruct(il);
3954   outs() << "                    entsize " << il.entsize << "\n";
3955   outs() << "                      count " << il.count << "\n";
3956
3957   p += sizeof(struct ivar_list64_t);
3958   offset += sizeof(struct ivar_list64_t);
3959   for (j = 0; j < il.count; j++) {
3960     r = get_pointer_64(p, offset, left, S, info);
3961     if (r == nullptr)
3962       return;
3963     memset(&i, '\0', sizeof(struct ivar64_t));
3964     if (left < sizeof(struct ivar64_t)) {
3965       memcpy(&i, r, left);
3966       outs() << "   (ivar_t entends past the end of the section)\n";
3967     } else
3968       memcpy(&i, r, sizeof(struct ivar64_t));
3969     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3970       swapStruct(i);
3971
3972     outs() << "\t\t\t   offset ";