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/DWARF/DIContext.h"
  21 #include "llvm/MC/MCAsmInfo.h"
  22 #include "llvm/MC/MCContext.h"
  23 #include "llvm/MC/MCDisassembler.h"
  24 #include "llvm/MC/MCInst.h"
  25 #include "llvm/MC/MCInstPrinter.h"
  26 #include "llvm/MC/MCInstrDesc.h"
  27 #include "llvm/MC/MCInstrInfo.h"
  28 #include "llvm/MC/MCRegisterInfo.h"
  29 #include "llvm/MC/MCSubtargetInfo.h"
  30 #include "llvm/Object/MachO.h"
  31 #include "llvm/Object/MachOUniversal.h"
  32 #include "llvm/Support/Casting.h"
  33 #include "llvm/Support/CommandLine.h"
  34 #include "llvm/Support/Debug.h"
  35 #include "llvm/Support/Endian.h"
  36 #include "llvm/Support/Format.h"
  37 #include "llvm/Support/FormattedStream.h"
  38 #include "llvm/Support/GraphWriter.h"
  39 #include "llvm/Support/LEB128.h"
  40 #include "llvm/Support/MachO.h"
  41 #include "llvm/Support/MemoryBuffer.h"
  42 #include "llvm/Support/TargetRegistry.h"
  43 #include "llvm/Support/TargetSelect.h"
  44 #include "llvm/Support/raw_ostream.h"
  45 #include <algorithm>
  46 #include <cstring>
  47 #include <system_error>
  48
  49 #if HAVE_CXXABI_H
  50 #include <cxxabi.h>
  51 #endif
  52
  53 using namespace llvm;
  54 using namespace object;
  55
  56 static cl::opt<bool>
  57     UseDbg("g",
  58            cl::desc("Print line information from debug info if available"));
  59
  60 static cl::opt<std::string> DSYMFile("dsym",
  61                                      cl::desc("Use .dSYM file for debug info"));
  62
  63 static cl::opt<bool> FullLeadingAddr("full-leading-addr",
  64                                      cl::desc("Print full leading address"));
  65
  66 static cl::opt<bool> NoLeadingAddr("no-leading-addr",
  67                                    cl::desc("Print no leading address"));
  68
  69 static cl::opt<bool>
  70     PrintImmHex("print-imm-hex",
  71                 cl::desc("Use hex format for immediate values"));
  72
  73 cl::opt<bool> llvm::UniversalHeaders("universal-headers",
  74                                      cl::desc("Print Mach-O universal headers "
  75                                               "(requires -macho)"));
  76
  77 cl::opt<bool>
  78     llvm::ArchiveHeaders("archive-headers",
  79                          cl::desc("Print archive headers for Mach-O archives "
  80                                   "(requires -macho)"));
  81
  82 cl::opt<bool>
  83     llvm::IndirectSymbols("indirect-symbols",
  84                           cl::desc("Print indirect symbol table for Mach-O "
  85                                    "objects (requires -macho)"));
  86
  87 cl::opt<bool>
  88     llvm::DataInCode("data-in-code",
  89                      cl::desc("Print the data in code table for Mach-O objects "
  90                               "(requires -macho)"));
  91
  92 cl::opt<bool>
  93     llvm::LinkOptHints("link-opt-hints",
  94                        cl::desc("Print the linker optimization hints for "
  95                                 "Mach-O objects (requires -macho)"));
  96
  97 cl::list<std::string>
  98     llvm::DumpSections("section",
  99                        cl::desc("Prints the specified segment,section for "
 100                                 "Mach-O objects (requires -macho)"));
 101
 102 cl::opt<bool> llvm::Raw("raw",
 103                         cl::desc("Have -section dump the raw binary contents"));
 104
 105 cl::opt<bool>
 106     llvm::InfoPlist("info-plist",
 107                     cl::desc("Print the info plist section as strings for "
 108                              "Mach-O objects (requires -macho)"));
 109
 110 cl::opt<bool>
 111     llvm::DylibsUsed("dylibs-used",
 112                      cl::desc("Print the shared libraries used for linked "
 113                               "Mach-O files (requires -macho)"));
 114
 115 cl::opt<bool>
 116     llvm::DylibId("dylib-id",
 117                   cl::desc("Print the shared library's id for the dylib Mach-O "
 118                            "file (requires -macho)"));
 119
 120 cl::opt<bool>
 121     llvm::NonVerbose("non-verbose",
 122                      cl::desc("Print the info for Mach-O objects in "
 123                               "non-verbose or numeric form (requires -macho)"));
 124
 125 cl::opt<bool>
 126     llvm::ObjcMetaData("objc-meta-data",
 127                        cl::desc("Print the Objective-C runtime meta data for "
 128                                 "Mach-O files (requires -macho)"));
 129
 130 cl::opt<std::string> llvm::DisSymName(
 131     "dis-symname",
 132     cl::desc("disassemble just this symbol's instructions (requires -macho"));
 133
 134 static cl::opt<bool> NoSymbolicOperands(
 135     "no-symbolic-operands",
 136     cl::desc("do not symbolic operands when disassembling (requires -macho)"));
 137
 138 static cl::list<std::string>
 139     ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
 140               cl::ZeroOrMore);
 141 bool ArchAll = false;
 142
 143 static std::string ThumbTripleName;
 144
 145 static const Target *GetTarget(const MachOObjectFile *MachOObj,
 146                                const char **McpuDefault,
 147                                const Target **ThumbTarget) {
 148   // Figure out the target triple.
 149   if (TripleName.empty()) {
 150     llvm::Triple TT("unknown-unknown-unknown");
 151     llvm::Triple ThumbTriple = Triple();
 152     TT = MachOObj->getArch(McpuDefault, &ThumbTriple);
 153     TripleName = TT.str();
 154     ThumbTripleName = ThumbTriple.str();
 155   }
 156
 157   // Get the target specific parser.
 158   std::string Error;
 159   const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
 160   if (TheTarget && ThumbTripleName.empty())
 161     return TheTarget;
 162
 163   *ThumbTarget = TargetRegistry::lookupTarget(ThumbTripleName, Error);
 164   if (*ThumbTarget)
 165     return TheTarget;
 166
 167   errs() << "llvm-objdump: error: unable to get target for '";
 168   if (!TheTarget)
 169     errs() << TripleName;
 170   else
 171     errs() << ThumbTripleName;
 172   errs() << "', see --version and --triple.\n";
 173   return nullptr;
 174 }
 175
 176 struct SymbolSorter {
 177   bool operator()(const SymbolRef &A, const SymbolRef &B) {
 178     SymbolRef::Type AType, BType;
 179     A.getType(AType);
 180     B.getType(BType);
 181
 182     uint64_t AAddr, BAddr;
 183     if (AType != SymbolRef::ST_Function)
 184       AAddr = 0;
 185     else
 186       A.getAddress(AAddr);
 187     if (BType != SymbolRef::ST_Function)
 188       BAddr = 0;
 189     else
 190       B.getAddress(BAddr);
 191     return AAddr < BAddr;
 192   }
 193 };
 194
 195 // Types for the storted data in code table that is built before disassembly
 196 // and the predicate function to sort them.
 197 typedef std::pair<uint64_t, DiceRef> DiceTableEntry;
 198 typedef std::vector<DiceTableEntry> DiceTable;
 199 typedef DiceTable::iterator dice_table_iterator;
 200
 201 // This is used to search for a data in code table entry for the PC being
 202 // disassembled.  The j parameter has the PC in j.first.  A single data in code
 203 // table entry can cover many bytes for each of its Kind's.  So if the offset,
 204 // aka the i.first value, of the data in code table entry plus its Length
 205 // covers the PC being searched for this will return true.  If not it will
 206 // return false.
 207 static bool compareDiceTableEntries(const DiceTableEntry &i,
 208                                     const DiceTableEntry &j) {
 209   uint16_t Length;
 210   i.second.getLength(Length);
 211
 212   return j.first >= i.first && j.first < i.first + Length;
 213 }
 214
 215 static uint64_t DumpDataInCode(const uint8_t *bytes, uint64_t Length,
 216                                unsigned short Kind) {
 217   uint32_t Value, Size = 1;
 218
 219   switch (Kind) {
 220   default:
 221   case MachO::DICE_KIND_DATA:
 222     if (Length >= 4) {
 223       if (!NoShowRawInsn)
 224         DumpBytes(ArrayRef<uint8_t>(bytes, 4));
 225       Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
 226       outs() << "\t.long " << Value;
 227       Size = 4;
 228     } else if (Length >= 2) {
 229       if (!NoShowRawInsn)
 230         DumpBytes(ArrayRef<uint8_t>(bytes, 2));
 231       Value = bytes[1] << 8 | bytes[0];
 232       outs() << "\t.short " << Value;
 233       Size = 2;
 234     } else {
 235       if (!NoShowRawInsn)
 236         DumpBytes(ArrayRef<uint8_t>(bytes, 2));
 237       Value = bytes[0];
 238       outs() << "\t.byte " << Value;
 239       Size = 1;
 240     }
 241     if (Kind == MachO::DICE_KIND_DATA)
 242       outs() << "\t@ KIND_DATA\n";
 243     else
 244       outs() << "\t@ data in code kind = " << Kind << "\n";
 245     break;
 246   case MachO::DICE_KIND_JUMP_TABLE8:
 247     if (!NoShowRawInsn)
 248       DumpBytes(ArrayRef<uint8_t>(bytes, 1));
 249     Value = bytes[0];
 250     outs() << "\t.byte " << format("%3u", Value) << "\t@ KIND_JUMP_TABLE8\n";
 251     Size = 1;
 252     break;
 253   case MachO::DICE_KIND_JUMP_TABLE16:
 254     if (!NoShowRawInsn)
 255       DumpBytes(ArrayRef<uint8_t>(bytes, 2));
 256     Value = bytes[1] << 8 | bytes[0];
 257     outs() << "\t.short " << format("%5u", Value & 0xffff)
 258            << "\t@ KIND_JUMP_TABLE16\n";
 259     Size = 2;
 260     break;
 261   case MachO::DICE_KIND_JUMP_TABLE32:
 262   case MachO::DICE_KIND_ABS_JUMP_TABLE32:
 263     if (!NoShowRawInsn)
 264       DumpBytes(ArrayRef<uint8_t>(bytes, 4));
 265     Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
 266     outs() << "\t.long " << Value;
 267     if (Kind == MachO::DICE_KIND_JUMP_TABLE32)
 268       outs() << "\t@ KIND_JUMP_TABLE32\n";
 269     else
 270       outs() << "\t@ KIND_ABS_JUMP_TABLE32\n";
 271     Size = 4;
 272     break;
 273   }
 274   return Size;
 275 }
 276
 277 static void getSectionsAndSymbols(const MachO::mach_header Header,
 278                                   MachOObjectFile *MachOObj,
 279                                   std::vector<SectionRef> &Sections,
 280                                   std::vector<SymbolRef> &Symbols,
 281                                   SmallVectorImpl<uint64_t> &FoundFns,
 282                                   uint64_t &BaseSegmentAddress) {
 283   for (const SymbolRef &Symbol : MachOObj->symbols()) {
 284     StringRef SymName;
 285     Symbol.getName(SymName);
 286     if (!SymName.startswith("ltmp"))
 287       Symbols.push_back(Symbol);
 288   }
 289
 290   for (const SectionRef &Section : MachOObj->sections()) {
 291     StringRef SectName;
 292     Section.getName(SectName);
 293     Sections.push_back(Section);
 294   }
 295
 296   MachOObjectFile::LoadCommandInfo Command =
 297       MachOObj->getFirstLoadCommandInfo();
 298   bool BaseSegmentAddressSet = false;
 299   for (unsigned i = 0;; ++i) {
 300     if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) {
 301       // We found a function starts segment, parse the addresses for later
 302       // consumption.
 303       MachO::linkedit_data_command LLC =
 304           MachOObj->getLinkeditDataLoadCommand(Command);
 305
 306       MachOObj->ReadULEB128s(LLC.dataoff, FoundFns);
 307     } else if (Command.C.cmd == MachO::LC_SEGMENT) {
 308       MachO::segment_command SLC = MachOObj->getSegmentLoadCommand(Command);
 309       StringRef SegName = SLC.segname;
 310       if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
 311         BaseSegmentAddressSet = true;
 312         BaseSegmentAddress = SLC.vmaddr;
 313       }
 314     }
 315
 316     if (i == Header.ncmds - 1)
 317       break;
 318     else
 319       Command = MachOObj->getNextLoadCommandInfo(Command);
 320   }
 321 }
 322
 323 static void PrintIndirectSymbolTable(MachOObjectFile *O, bool verbose,
 324                                      uint32_t n, uint32_t count,
 325                                      uint32_t stride, uint64_t addr) {
 326   MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand();
 327   uint32_t nindirectsyms = Dysymtab.nindirectsyms;
 328   if (n > nindirectsyms)
 329     outs() << " (entries start past the end of the indirect symbol "
 330               "table) (reserved1 field greater than the table size)";
 331   else if (n + count > nindirectsyms)
 332     outs() << " (entries extends past the end of the indirect symbol "
 333               "table)";
 334   outs() << "\n";
 335   uint32_t cputype = O->getHeader().cputype;
 336   if (cputype & MachO::CPU_ARCH_ABI64)
 337     outs() << "address            index";
 338   else
 339     outs() << "address    index";
 340   if (verbose)
 341     outs() << " name\n";
 342   else
 343     outs() << "\n";
 344   for (uint32_t j = 0; j < count && n + j < nindirectsyms; j++) {
 345     if (cputype & MachO::CPU_ARCH_ABI64)
 346       outs() << format("0x%016" PRIx64, addr + j * stride) << " ";
 347     else
 348       outs() << format("0x%08" PRIx32, addr + j * stride) << " ";
 349     MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand();
 350     uint32_t indirect_symbol = O->getIndirectSymbolTableEntry(Dysymtab, n + j);
 351     if (indirect_symbol == MachO::INDIRECT_SYMBOL_LOCAL) {
 352       outs() << "LOCAL\n";
 353       continue;
 354     }
 355     if (indirect_symbol ==
 356         (MachO::INDIRECT_SYMBOL_LOCAL | MachO::INDIRECT_SYMBOL_ABS)) {
 357       outs() << "LOCAL ABSOLUTE\n";
 358       continue;
 359     }
 360     if (indirect_symbol == MachO::INDIRECT_SYMBOL_ABS) {
 361       outs() << "ABSOLUTE\n";
 362       continue;
 363     }
 364     outs() << format("%5u ", indirect_symbol);
 365     if (verbose) {
 366       MachO::symtab_command Symtab = O->getSymtabLoadCommand();
 367       if (indirect_symbol < Symtab.nsyms) {
 368         symbol_iterator Sym = O->getSymbolByIndex(indirect_symbol);
 369         SymbolRef Symbol = *Sym;
 370         StringRef SymName;
 371         Symbol.getName(SymName);
 372         outs() << SymName;
 373       } else {
 374         outs() << "?";
 375       }
 376     }
 377     outs() << "\n";
 378   }
 379 }
 380
 381 static void PrintIndirectSymbols(MachOObjectFile *O, bool verbose) {
 382   uint32_t LoadCommandCount = O->getHeader().ncmds;
 383   MachOObjectFile::LoadCommandInfo Load = O->getFirstLoadCommandInfo();
 384   for (unsigned I = 0;; ++I) {
 385     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
 386       MachO::segment_command_64 Seg = O->getSegment64LoadCommand(Load);
 387       for (unsigned J = 0; J < Seg.nsects; ++J) {
 388         MachO::section_64 Sec = O->getSection64(Load, J);
 389         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
 390         if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
 391             section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
 392             section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
 393             section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
 394             section_type == MachO::S_SYMBOL_STUBS) {
 395           uint32_t stride;
 396           if (section_type == MachO::S_SYMBOL_STUBS)
 397             stride = Sec.reserved2;
 398           else
 399             stride = 8;
 400           if (stride == 0) {
 401             outs() << "Can't print indirect symbols for (" << Sec.segname << ","
 402                    << Sec.sectname << ") "
 403                    << "(size of stubs in reserved2 field is zero)\n";
 404             continue;
 405           }
 406           uint32_t count = Sec.size / stride;
 407           outs() << "Indirect symbols for (" << Sec.segname << ","
 408                  << Sec.sectname << ") " << count << " entries";
 409           uint32_t n = Sec.reserved1;
 410           PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr);
 411         }
 412       }
 413     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
 414       MachO::segment_command Seg = O->getSegmentLoadCommand(Load);
 415       for (unsigned J = 0; J < Seg.nsects; ++J) {
 416         MachO::section Sec = O->getSection(Load, J);
 417         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
 418         if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
 419             section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
 420             section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
 421             section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
 422             section_type == MachO::S_SYMBOL_STUBS) {
 423           uint32_t stride;
 424           if (section_type == MachO::S_SYMBOL_STUBS)
 425             stride = Sec.reserved2;
 426           else
 427             stride = 4;
 428           if (stride == 0) {
 429             outs() << "Can't print indirect symbols for (" << Sec.segname << ","
 430                    << Sec.sectname << ") "
 431                    << "(size of stubs in reserved2 field is zero)\n";
 432             continue;
 433           }
 434           uint32_t count = Sec.size / stride;
 435           outs() << "Indirect symbols for (" << Sec.segname << ","
 436                  << Sec.sectname << ") " << count << " entries";
 437           uint32_t n = Sec.reserved1;
 438           PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr);
 439         }
 440       }
 441     }
 442     if (I == LoadCommandCount - 1)
 443       break;
 444     else
 445       Load = O->getNextLoadCommandInfo(Load);
 446   }
 447 }
 448
 449 static void PrintDataInCodeTable(MachOObjectFile *O, bool verbose) {
 450   MachO::linkedit_data_command DIC = O->getDataInCodeLoadCommand();
 451   uint32_t nentries = DIC.datasize / sizeof(struct MachO::data_in_code_entry);
 452   outs() << "Data in code table (" << nentries << " entries)\n";
 453   outs() << "offset     length kind\n";
 454   for (dice_iterator DI = O->begin_dices(), DE = O->end_dices(); DI != DE;
 455        ++DI) {
 456     uint32_t Offset;
 457     DI->getOffset(Offset);
 458     outs() << format("0x%08" PRIx32, Offset) << " ";
 459     uint16_t Length;
 460     DI->getLength(Length);
 461     outs() << format("%6u", Length) << " ";
 462     uint16_t Kind;
 463     DI->getKind(Kind);
 464     if (verbose) {
 465       switch (Kind) {
 466       case MachO::DICE_KIND_DATA:
 467         outs() << "DATA";
 468         break;
 469       case MachO::DICE_KIND_JUMP_TABLE8:
 470         outs() << "JUMP_TABLE8";
 471         break;
 472       case MachO::DICE_KIND_JUMP_TABLE16:
 473         outs() << "JUMP_TABLE16";
 474         break;
 475       case MachO::DICE_KIND_JUMP_TABLE32:
 476         outs() << "JUMP_TABLE32";
 477         break;
 478       case MachO::DICE_KIND_ABS_JUMP_TABLE32:
 479         outs() << "ABS_JUMP_TABLE32";
 480         break;
 481       default:
 482         outs() << format("0x%04" PRIx32, Kind);
 483         break;
 484       }
 485     } else
 486       outs() << format("0x%04" PRIx32, Kind);
 487     outs() << "\n";
 488   }
 489 }
 490
 491 static void PrintLinkOptHints(MachOObjectFile *O) {
 492   MachO::linkedit_data_command LohLC = O->getLinkOptHintsLoadCommand();
 493   const char *loh = O->getData().substr(LohLC.dataoff, 1).data();
 494   uint32_t nloh = LohLC.datasize;
 495   outs() << "Linker optimiztion hints (" << nloh << " total bytes)\n";
 496   for (uint32_t i = 0; i < nloh;) {
 497     unsigned n;
 498     uint64_t identifier = decodeULEB128((const uint8_t *)(loh + i), &n);
 499     i += n;
 500     outs() << "    identifier " << identifier << " ";
 501     if (i >= nloh)
 502       return;
 503     switch (identifier) {
 504     case 1:
 505       outs() << "AdrpAdrp\n";
 506       break;
 507     case 2:
 508       outs() << "AdrpLdr\n";
 509       break;
 510     case 3:
 511       outs() << "AdrpAddLdr\n";
 512       break;
 513     case 4:
 514       outs() << "AdrpLdrGotLdr\n";
 515       break;
 516     case 5:
 517       outs() << "AdrpAddStr\n";
 518       break;
 519     case 6:
 520       outs() << "AdrpLdrGotStr\n";
 521       break;
 522     case 7:
 523       outs() << "AdrpAdd\n";
 524       break;
 525     case 8:
 526       outs() << "AdrpLdrGot\n";
 527       break;
 528     default:
 529       outs() << "Unknown identifier value\n";
 530       break;
 531     }
 532     uint64_t narguments = decodeULEB128((const uint8_t *)(loh + i), &n);
 533     i += n;
 534     outs() << "    narguments " << narguments << "\n";
 535     if (i >= nloh)
 536       return;
 537
 538     for (uint32_t j = 0; j < narguments; j++) {
 539       uint64_t value = decodeULEB128((const uint8_t *)(loh + i), &n);
 540       i += n;
 541       outs() << "\tvalue " << format("0x%" PRIx64, value) << "\n";
 542       if (i >= nloh)
 543         return;
 544     }
 545   }
 546 }
 547
 548 static void PrintDylibs(MachOObjectFile *O, bool JustId) {
 549   uint32_t LoadCommandCount = O->getHeader().ncmds;
 550   MachOObjectFile::LoadCommandInfo Load = O->getFirstLoadCommandInfo();
 551   for (unsigned I = 0;; ++I) {
 552     if ((JustId && Load.C.cmd == MachO::LC_ID_DYLIB) ||
 553         (!JustId && (Load.C.cmd == MachO::LC_ID_DYLIB ||
 554                      Load.C.cmd == MachO::LC_LOAD_DYLIB ||
 555                      Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
 556                      Load.C.cmd == MachO::LC_REEXPORT_DYLIB ||
 557                      Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
 558                      Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB))) {
 559       MachO::dylib_command dl = O->getDylibIDLoadCommand(Load);
 560       if (dl.dylib.name < dl.cmdsize) {
 561         const char *p = (const char *)(Load.Ptr) + dl.dylib.name;
 562         if (JustId)
 563           outs() << p << "\n";
 564         else {
 565           outs() << "\t" << p;
 566           outs() << " (compatibility version "
 567                  << ((dl.dylib.compatibility_version >> 16) & 0xffff) << "."
 568                  << ((dl.dylib.compatibility_version >> 8) & 0xff) << "."
 569                  << (dl.dylib.compatibility_version & 0xff) << ",";
 570           outs() << " current version "
 571                  << ((dl.dylib.current_version >> 16) & 0xffff) << "."
 572                  << ((dl.dylib.current_version >> 8) & 0xff) << "."
 573                  << (dl.dylib.current_version & 0xff) << ")\n";
 574         }
 575       } else {
 576         outs() << "\tBad offset (" << dl.dylib.name << ") for name of ";
 577         if (Load.C.cmd == MachO::LC_ID_DYLIB)
 578           outs() << "LC_ID_DYLIB ";
 579         else if (Load.C.cmd == MachO::LC_LOAD_DYLIB)
 580           outs() << "LC_LOAD_DYLIB ";
 581         else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB)
 582           outs() << "LC_LOAD_WEAK_DYLIB ";
 583         else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB)
 584           outs() << "LC_LAZY_LOAD_DYLIB ";
 585         else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB)
 586           outs() << "LC_REEXPORT_DYLIB ";
 587         else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB)
 588           outs() << "LC_LOAD_UPWARD_DYLIB ";
 589         else
 590           outs() << "LC_??? ";
 591         outs() << "command " << I << "\n";
 592       }
 593     }
 594     if (I == LoadCommandCount - 1)
 595       break;
 596     else
 597       Load = O->getNextLoadCommandInfo(Load);
 598   }
 599 }
 600
 601 typedef DenseMap<uint64_t, StringRef> SymbolAddressMap;
 602
 603 static void CreateSymbolAddressMap(MachOObjectFile *O,
 604                                    SymbolAddressMap *AddrMap) {
 605   // Create a map of symbol addresses to symbol names.
 606   for (const SymbolRef &Symbol : O->symbols()) {
 607     SymbolRef::Type ST;
 608     Symbol.getType(ST);
 609     if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
 610         ST == SymbolRef::ST_Other) {
 611       uint64_t Address;
 612       Symbol.getAddress(Address);
 613       StringRef SymName;
 614       Symbol.getName(SymName);
 615       if (!SymName.startswith(".objc"))
 616         (*AddrMap)[Address] = SymName;
 617     }
 618   }
 619 }
 620
 621 // GuessSymbolName is passed the address of what might be a symbol and a
 622 // pointer to the SymbolAddressMap.  It returns the name of a symbol
 623 // with that address or nullptr if no symbol is found with that address.
 624 static const char *GuessSymbolName(uint64_t value, SymbolAddressMap *AddrMap) {
 625   const char *SymbolName = nullptr;
 626   // A DenseMap can't lookup up some values.
 627   if (value != 0xffffffffffffffffULL && value != 0xfffffffffffffffeULL) {
 628     StringRef name = AddrMap->lookup(value);
 629     if (!name.empty())
 630       SymbolName = name.data();
 631   }
 632   return SymbolName;
 633 }
 634
 635 static void DumpCstringChar(const char c) {
 636   char p[2];
 637   p[0] = c;
 638   p[1] = '\0';
 639   outs().write_escaped(p);
 640 }
 641
 642 static void DumpCstringSection(MachOObjectFile *O, const char *sect,
 643                                uint32_t sect_size, uint64_t sect_addr,
 644                                bool print_addresses) {
 645   for (uint32_t i = 0; i < sect_size; i++) {
 646     if (print_addresses) {
 647       if (O->is64Bit())
 648         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
 649       else
 650         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
 651     }
 652     for (; i < sect_size && sect[i] != '\0'; i++)
 653       DumpCstringChar(sect[i]);
 654     if (i < sect_size && sect[i] == '\0')
 655       outs() << "\n";
 656   }
 657 }
 658
 659 static void DumpLiteral4(uint32_t l, float f) {
 660   outs() << format("0x%08" PRIx32, l);
 661   if ((l & 0x7f800000) != 0x7f800000)
 662     outs() << format(" (%.16e)\n", f);
 663   else {
 664     if (l == 0x7f800000)
 665       outs() << " (+Infinity)\n";
 666     else if (l == 0xff800000)
 667       outs() << " (-Infinity)\n";
 668     else if ((l & 0x00400000) == 0x00400000)
 669       outs() << " (non-signaling Not-a-Number)\n";
 670     else
 671       outs() << " (signaling Not-a-Number)\n";
 672   }
 673 }
 674
 675 static void DumpLiteral4Section(MachOObjectFile *O, const char *sect,
 676                                 uint32_t sect_size, uint64_t sect_addr,
 677                                 bool print_addresses) {
 678   for (uint32_t i = 0; i < sect_size; i += sizeof(float)) {
 679     if (print_addresses) {
 680       if (O->is64Bit())
 681         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
 682       else
 683         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
 684     }
 685     float f;
 686     memcpy(&f, sect + i, sizeof(float));
 687     if (O->isLittleEndian() != sys::IsLittleEndianHost)
 688       sys::swapByteOrder(f);
 689     uint32_t l;
 690     memcpy(&l, sect + i, sizeof(uint32_t));
 691     if (O->isLittleEndian() != sys::IsLittleEndianHost)
 692       sys::swapByteOrder(l);
 693     DumpLiteral4(l, f);
 694   }
 695 }
 696
 697 static void DumpLiteral8(MachOObjectFile *O, uint32_t l0, uint32_t l1,
 698                          double d) {
 699   outs() << format("0x%08" PRIx32, l0) << " " << format("0x%08" PRIx32, l1);
 700   uint32_t Hi, Lo;
 701   if (O->isLittleEndian()) {
 702     Hi = l1;
 703     Lo = l0;
 704   } else {
 705     Hi = l0;
 706     Lo = l1;
 707   }
 708   // Hi is the high word, so this is equivalent to if(isfinite(d))
 709   if ((Hi & 0x7ff00000) != 0x7ff00000)
 710     outs() << format(" (%.16e)\n", d);
 711   else {
 712     if (Hi == 0x7ff00000 && Lo == 0)
 713       outs() << " (+Infinity)\n";
 714     else if (Hi == 0xfff00000 && Lo == 0)
 715       outs() << " (-Infinity)\n";
 716     else if ((Hi & 0x00080000) == 0x00080000)
 717       outs() << " (non-signaling Not-a-Number)\n";
 718     else
 719       outs() << " (signaling Not-a-Number)\n";
 720   }
 721 }
 722
 723 static void DumpLiteral8Section(MachOObjectFile *O, const char *sect,
 724                                 uint32_t sect_size, uint64_t sect_addr,
 725                                 bool print_addresses) {
 726   for (uint32_t i = 0; i < sect_size; i += sizeof(double)) {
 727     if (print_addresses) {
 728       if (O->is64Bit())
 729         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
 730       else
 731         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
 732     }
 733     double d;
 734     memcpy(&d, sect + i, sizeof(double));
 735     if (O->isLittleEndian() != sys::IsLittleEndianHost)
 736       sys::swapByteOrder(d);
 737     uint32_t l0, l1;
 738     memcpy(&l0, sect + i, sizeof(uint32_t));
 739     memcpy(&l1, sect + i + sizeof(uint32_t), sizeof(uint32_t));
 740     if (O->isLittleEndian() != sys::IsLittleEndianHost) {
 741       sys::swapByteOrder(l0);
 742       sys::swapByteOrder(l1);
 743     }
 744     DumpLiteral8(O, l0, l1, d);
 745   }
 746 }
 747
 748 static void DumpLiteral16(uint32_t l0, uint32_t l1, uint32_t l2, uint32_t l3) {
 749   outs() << format("0x%08" PRIx32, l0) << " ";
 750   outs() << format("0x%08" PRIx32, l1) << " ";
 751   outs() << format("0x%08" PRIx32, l2) << " ";
 752   outs() << format("0x%08" PRIx32, l3) << "\n";
 753 }
 754
 755 static void DumpLiteral16Section(MachOObjectFile *O, const char *sect,
 756                                  uint32_t sect_size, uint64_t sect_addr,
 757                                  bool print_addresses) {
 758   for (uint32_t i = 0; i < sect_size; i += 16) {
 759     if (print_addresses) {
 760       if (O->is64Bit())
 761         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
 762       else
 763         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
 764     }
 765     uint32_t l0, l1, l2, l3;
 766     memcpy(&l0, sect + i, sizeof(uint32_t));
 767     memcpy(&l1, sect + i + sizeof(uint32_t), sizeof(uint32_t));
 768     memcpy(&l2, sect + i + 2 * sizeof(uint32_t), sizeof(uint32_t));
 769     memcpy(&l3, sect + i + 3 * sizeof(uint32_t), sizeof(uint32_t));
 770     if (O->isLittleEndian() != sys::IsLittleEndianHost) {
 771       sys::swapByteOrder(l0);
 772       sys::swapByteOrder(l1);
 773       sys::swapByteOrder(l2);
 774       sys::swapByteOrder(l3);
 775     }
 776     DumpLiteral16(l0, l1, l2, l3);
 777   }
 778 }
 779
 780 static void DumpLiteralPointerSection(MachOObjectFile *O,
 781                                       const SectionRef &Section,
 782                                       const char *sect, uint32_t sect_size,
 783                                       uint64_t sect_addr,
 784                                       bool print_addresses) {
 785   // Collect the literal sections in this Mach-O file.
 786   std::vector<SectionRef> LiteralSections;
 787   for (const SectionRef &Section : O->sections()) {
 788     DataRefImpl Ref = Section.getRawDataRefImpl();
 789     uint32_t section_type;
 790     if (O->is64Bit()) {
 791       const MachO::section_64 Sec = O->getSection64(Ref);
 792       section_type = Sec.flags & MachO::SECTION_TYPE;
 793     } else {
 794       const MachO::section Sec = O->getSection(Ref);
 795       section_type = Sec.flags & MachO::SECTION_TYPE;
 796     }
 797     if (section_type == MachO::S_CSTRING_LITERALS ||
 798         section_type == MachO::S_4BYTE_LITERALS ||
 799         section_type == MachO::S_8BYTE_LITERALS ||
 800         section_type == MachO::S_16BYTE_LITERALS)
 801       LiteralSections.push_back(Section);
 802   }
 803
 804   // Set the size of the literal pointer.
 805   uint32_t lp_size = O->is64Bit() ? 8 : 4;
 806
 807   // Collect the external relocation symbols for the the literal pointers.
 808   std::vector<std::pair<uint64_t, SymbolRef>> Relocs;
 809   for (const RelocationRef &Reloc : Section.relocations()) {
 810     DataRefImpl Rel;
 811     MachO::any_relocation_info RE;
 812     bool isExtern = false;
 813     Rel = Reloc.getRawDataRefImpl();
 814     RE = O->getRelocation(Rel);
 815     isExtern = O->getPlainRelocationExternal(RE);
 816     if (isExtern) {
 817       uint64_t RelocOffset;
 818       Reloc.getOffset(RelocOffset);
 819       symbol_iterator RelocSym = Reloc.getSymbol();
 820       Relocs.push_back(std::make_pair(RelocOffset, *RelocSym));
 821     }
 822   }
 823   array_pod_sort(Relocs.begin(), Relocs.end());
 824
 825   // Dump each literal pointer.
 826   for (uint32_t i = 0; i < sect_size; i += lp_size) {
 827     if (print_addresses) {
 828       if (O->is64Bit())
 829         outs() << format("%016" PRIx64, sect_addr + i) << "  ";
 830       else
 831         outs() << format("%08" PRIx64, sect_addr + i) << "  ";
 832     }
 833     uint64_t lp;
 834     if (O->is64Bit()) {
 835       memcpy(&lp, sect + i, sizeof(uint64_t));
 836       if (O->isLittleEndian() != sys::IsLittleEndianHost)
 837         sys::swapByteOrder(lp);
 838     } else {
 839       uint32_t li;
 840       memcpy(&li, sect + i, sizeof(uint32_t));
 841       if (O->isLittleEndian() != sys::IsLittleEndianHost)
 842         sys::swapByteOrder(li);
 843       lp = li;
 844     }
 845
 846     // First look for an external relocation entry for this literal pointer.
 847     auto Reloc = std::find_if(
 848         Relocs.begin(), Relocs.end(),
 849         [&](const std::pair<uint64_t, SymbolRef> &P) { return P.first == i; });
 850     if (Reloc != Relocs.end()) {
 851       symbol_iterator RelocSym = Reloc->second;
 852       StringRef SymName;
 853       RelocSym->getName(SymName);
 854       outs() << "external relocation entry for symbol:" << SymName << "\n";
 855       continue;
 856     }
 857
 858     // For local references see what the section the literal pointer points to.
 859     auto Sect = std::find_if(LiteralSections.begin(), LiteralSections.end(),
 860                              [&](const SectionRef &R) {
 861                                return lp >= R.getAddress() &&
 862                                       lp < R.getAddress() + R.getSize();
 863                              });
 864     if (Sect == LiteralSections.end()) {
 865       outs() << format("0x%" PRIx64, lp) << " (not in a literal section)\n";
 866       continue;
 867     }
 868
 869     uint64_t SectAddress = Sect->getAddress();
 870     uint64_t SectSize = Sect->getSize();
 871
 872     StringRef SectName;
 873     Sect->getName(SectName);
 874     DataRefImpl Ref = Sect->getRawDataRefImpl();
 875     StringRef SegmentName = O->getSectionFinalSegmentName(Ref);
 876     outs() << SegmentName << ":" << SectName << ":";
 877
 878     uint32_t section_type;
 879     if (O->is64Bit()) {
 880       const MachO::section_64 Sec = O->getSection64(Ref);
 881       section_type = Sec.flags & MachO::SECTION_TYPE;
 882     } else {
 883       const MachO::section Sec = O->getSection(Ref);
 884       section_type = Sec.flags & MachO::SECTION_TYPE;
 885     }
 886
 887     StringRef BytesStr;
 888     Sect->getContents(BytesStr);
 889     const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
 890
 891     switch (section_type) {
 892     case MachO::S_CSTRING_LITERALS:
 893       for (uint64_t i = lp - SectAddress; i < SectSize && Contents[i] != '\0';
 894            i++) {
 895         DumpCstringChar(Contents[i]);
 896       }
 897       outs() << "\n";
 898       break;
 899     case MachO::S_4BYTE_LITERALS:
 900       float f;
 901       memcpy(&f, Contents + (lp - SectAddress), sizeof(float));
 902       uint32_t l;
 903       memcpy(&l, Contents + (lp - SectAddress), sizeof(uint32_t));
 904       if (O->isLittleEndian() != sys::IsLittleEndianHost) {
 905         sys::swapByteOrder(f);
 906         sys::swapByteOrder(l);
 907       }
 908       DumpLiteral4(l, f);
 909       break;
 910     case MachO::S_8BYTE_LITERALS: {
 911       double d;
 912       memcpy(&d, Contents + (lp - SectAddress), sizeof(double));
 913       uint32_t l0, l1;
 914       memcpy(&l0, Contents + (lp - SectAddress), sizeof(uint32_t));
 915       memcpy(&l1, Contents + (lp - SectAddress) + sizeof(uint32_t),
 916              sizeof(uint32_t));
 917       if (O->isLittleEndian() != sys::IsLittleEndianHost) {
 918         sys::swapByteOrder(f);
 919         sys::swapByteOrder(l0);
 920         sys::swapByteOrder(l1);
 921       }
 922       DumpLiteral8(O, l0, l1, d);
 923       break;
 924     }
 925     case MachO::S_16BYTE_LITERALS: {
 926       uint32_t l0, l1, l2, l3;
 927       memcpy(&l0, Contents + (lp - SectAddress), sizeof(uint32_t));
 928       memcpy(&l1, Contents + (lp - SectAddress) + sizeof(uint32_t),
 929              sizeof(uint32_t));
 930       memcpy(&l2, Contents + (lp - SectAddress) + 2 * sizeof(uint32_t),
 931              sizeof(uint32_t));
 932       memcpy(&l3, Contents + (lp - SectAddress) + 3 * sizeof(uint32_t),
 933              sizeof(uint32_t));
 934       if (O->isLittleEndian() != sys::IsLittleEndianHost) {
 935         sys::swapByteOrder(l0);
 936         sys::swapByteOrder(l1);
 937         sys::swapByteOrder(l2);
 938         sys::swapByteOrder(l3);
 939       }
 940       DumpLiteral16(l0, l1, l2, l3);
 941       break;
 942     }
 943     }
 944   }
 945 }
 946
 947 static void DumpInitTermPointerSection(MachOObjectFile *O, const char *sect,
 948                                        uint32_t sect_size, uint64_t sect_addr,
 949                                        SymbolAddressMap *AddrMap,
 950                                        bool verbose) {
 951   uint32_t stride;
 952   if (O->is64Bit())
 953     stride = sizeof(uint64_t);
 954   else
 955     stride = sizeof(uint32_t);
 956   for (uint32_t i = 0; i < sect_size; i += stride) {
 957     const char *SymbolName = nullptr;
 958     if (O->is64Bit()) {
 959       outs() << format("0x%016" PRIx64, sect_addr + i * stride) << " ";
 960       uint64_t pointer_value;
 961       memcpy(&pointer_value, sect + i, stride);
 962       if (O->isLittleEndian() != sys::IsLittleEndianHost)
 963         sys::swapByteOrder(pointer_value);
 964       outs() << format("0x%016" PRIx64, pointer_value);
 965       if (verbose)
 966         SymbolName = GuessSymbolName(pointer_value, AddrMap);
 967     } else {
 968       outs() << format("0x%08" PRIx64, sect_addr + i * stride) << " ";
 969       uint32_t pointer_value;
 970       memcpy(&pointer_value, sect + i, stride);
 971       if (O->isLittleEndian() != sys::IsLittleEndianHost)
 972         sys::swapByteOrder(pointer_value);
 973       outs() << format("0x%08" PRIx32, pointer_value);
 974       if (verbose)
 975         SymbolName = GuessSymbolName(pointer_value, AddrMap);
 976     }
 977     if (SymbolName)
 978       outs() << " " << SymbolName;
 979     outs() << "\n";
 980   }
 981 }
 982
 983 static void DumpRawSectionContents(MachOObjectFile *O, const char *sect,
 984                                    uint32_t size, uint64_t addr) {
 985   uint32_t cputype = O->getHeader().cputype;
 986   if (cputype == MachO::CPU_TYPE_I386 || cputype == MachO::CPU_TYPE_X86_64) {
 987     uint32_t j;
 988     for (uint32_t i = 0; i < size; i += j, addr += j) {
 989       if (O->is64Bit())
 990         outs() << format("%016" PRIx64, addr) << "\t";
 991       else
 992         outs() << format("%08" PRIx64, addr) << "\t";
 993       for (j = 0; j < 16 && i + j < size; j++) {
 994         uint8_t byte_word = *(sect + i + j);
 995         outs() << format("%02" PRIx32, (uint32_t)byte_word) << " ";
 996       }
 997       outs() << "\n";
 998     }
 999   } else {
1000     uint32_t j;
1001     for (uint32_t i = 0; i < size; i += j, addr += j) {
1002       if (O->is64Bit())
1003         outs() << format("%016" PRIx64, addr) << "\t";
1004       else
1005         outs() << format("%08" PRIx64, sect) << "\t";
1006       for (j = 0; j < 4 * sizeof(int32_t) && i + j < size;
1007            j += sizeof(int32_t)) {
1008         if (i + j + sizeof(int32_t) < size) {
1009           uint32_t long_word;
1010           memcpy(&long_word, sect + i + j, sizeof(int32_t));
1011           if (O->isLittleEndian() != sys::IsLittleEndianHost)
1012             sys::swapByteOrder(long_word);
1013           outs() << format("%08" PRIx32, long_word) << " ";
1014         } else {
1015           for (uint32_t k = 0; i + j + k < size; k++) {
1016             uint8_t byte_word = *(sect + i + j);
1017             outs() << format("%02" PRIx32, (uint32_t)byte_word) << " ";
1018           }
1019         }
1020       }
1021       outs() << "\n";
1022     }
1023   }
1024 }
1025
1026 static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
1027                              StringRef DisSegName, StringRef DisSectName);
1028 static void DumpProtocolSection(MachOObjectFile *O, const char *sect,
1029                                 uint32_t size, uint32_t addr);
1030
1031 static void DumpSectionContents(StringRef Filename, MachOObjectFile *O,
1032                                 bool verbose) {
1033   SymbolAddressMap AddrMap;
1034   if (verbose)
1035     CreateSymbolAddressMap(O, &AddrMap);
1036
1037   for (unsigned i = 0; i < DumpSections.size(); ++i) {
1038     StringRef DumpSection = DumpSections[i];
1039     std::pair<StringRef, StringRef> DumpSegSectName;
1040     DumpSegSectName = DumpSection.split(',');
1041     StringRef DumpSegName, DumpSectName;
1042     if (DumpSegSectName.second.size()) {
1043       DumpSegName = DumpSegSectName.first;
1044       DumpSectName = DumpSegSectName.second;
1045     } else {
1046       DumpSegName = "";
1047       DumpSectName = DumpSegSectName.first;
1048     }
1049     for (const SectionRef &Section : O->sections()) {
1050       StringRef SectName;
1051       Section.getName(SectName);
1052       DataRefImpl Ref = Section.getRawDataRefImpl();
1053       StringRef SegName = O->getSectionFinalSegmentName(Ref);
1054       if ((DumpSegName.empty() || SegName == DumpSegName) &&
1055           (SectName == DumpSectName)) {
1056
1057         uint32_t section_flags;
1058         if (O->is64Bit()) {
1059           const MachO::section_64 Sec = O->getSection64(Ref);
1060           section_flags = Sec.flags;
1061
1062         } else {
1063           const MachO::section Sec = O->getSection(Ref);
1064           section_flags = Sec.flags;
1065         }
1066         uint32_t section_type = section_flags & MachO::SECTION_TYPE;
1067
1068         StringRef BytesStr;
1069         Section.getContents(BytesStr);
1070         const char *sect = reinterpret_cast<const char *>(BytesStr.data());
1071         uint32_t sect_size = BytesStr.size();
1072         uint64_t sect_addr = Section.getAddress();
1073
1074         if (Raw) {
1075           outs().write(BytesStr.data(), BytesStr.size());
1076           continue;
1077         }
1078
1079         outs() << "Contents of (" << SegName << "," << SectName
1080                << ") section\n";
1081
1082         if (verbose) {
1083           if ((section_flags & MachO::S_ATTR_PURE_INSTRUCTIONS) ||
1084               (section_flags & MachO::S_ATTR_SOME_INSTRUCTIONS)) {
1085             DisassembleMachO(Filename, O, SegName, SectName);
1086             continue;
1087           }
1088           if (SegName == "__TEXT" && SectName == "__info_plist") {
1089             outs() << sect;
1090             continue;
1091           }
1092           if (SegName == "__OBJC" && SectName == "__protocol") {
1093             DumpProtocolSection(O, sect, sect_size, sect_addr);
1094             continue;
1095           }
1096           switch (section_type) {
1097           case MachO::S_REGULAR:
1098             DumpRawSectionContents(O, sect, sect_size, sect_addr);
1099             break;
1100           case MachO::S_ZEROFILL:
1101             outs() << "zerofill section and has no contents in the file\n";
1102             break;
1103           case MachO::S_CSTRING_LITERALS:
1104             DumpCstringSection(O, sect, sect_size, sect_addr, !NoLeadingAddr);
1105             break;
1106           case MachO::S_4BYTE_LITERALS:
1107             DumpLiteral4Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
1108             break;
1109           case MachO::S_8BYTE_LITERALS:
1110             DumpLiteral8Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
1111             break;
1112           case MachO::S_16BYTE_LITERALS:
1113             DumpLiteral16Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
1114             break;
1115           case MachO::S_LITERAL_POINTERS:
1116             DumpLiteralPointerSection(O, Section, sect, sect_size, sect_addr,
1117                                       !NoLeadingAddr);
1118             break;
1119           case MachO::S_MOD_INIT_FUNC_POINTERS:
1120           case MachO::S_MOD_TERM_FUNC_POINTERS:
1121             DumpInitTermPointerSection(O, sect, sect_size, sect_addr, &AddrMap,
1122                                        verbose);
1123             break;
1124           default:
1125             outs() << "Unknown section type ("
1126                    << format("0x%08" PRIx32, section_type) << ")\n";
1127             DumpRawSectionContents(O, sect, sect_size, sect_addr);
1128             break;
1129           }
1130         } else {
1131           if (section_type == MachO::S_ZEROFILL)
1132             outs() << "zerofill section and has no contents in the file\n";
1133           else
1134             DumpRawSectionContents(O, sect, sect_size, sect_addr);
1135         }
1136       }
1137     }
1138   }
1139 }
1140
1141 static void DumpInfoPlistSectionContents(StringRef Filename,
1142                                          MachOObjectFile *O) {
1143   for (const SectionRef &Section : O->sections()) {
1144     StringRef SectName;
1145     Section.getName(SectName);
1146     DataRefImpl Ref = Section.getRawDataRefImpl();
1147     StringRef SegName = O->getSectionFinalSegmentName(Ref);
1148     if (SegName == "__TEXT" && SectName == "__info_plist") {
1149       outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
1150       StringRef BytesStr;
1151       Section.getContents(BytesStr);
1152       const char *sect = reinterpret_cast<const char *>(BytesStr.data());
1153       outs() << sect;
1154       return;
1155     }
1156   }
1157 }
1158
1159 // checkMachOAndArchFlags() checks to see if the ObjectFile is a Mach-O file
1160 // and if it is and there is a list of architecture flags is specified then
1161 // check to make sure this Mach-O file is one of those architectures or all
1162 // architectures were specified.  If not then an error is generated and this
1163 // routine returns false.  Else it returns true.
1164 static bool checkMachOAndArchFlags(ObjectFile *O, StringRef Filename) {
1165   if (isa<MachOObjectFile>(O) && !ArchAll && ArchFlags.size() != 0) {
1166     MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O);
1167     bool ArchFound = false;
1168     MachO::mach_header H;
1169     MachO::mach_header_64 H_64;
1170     Triple T;
1171     if (MachO->is64Bit()) {
1172       H_64 = MachO->MachOObjectFile::getHeader64();
1173       T = MachOObjectFile::getArch(H_64.cputype, H_64.cpusubtype);
1174     } else {
1175       H = MachO->MachOObjectFile::getHeader();
1176       T = MachOObjectFile::getArch(H.cputype, H.cpusubtype);
1177     }
1178     unsigned i;
1179     for (i = 0; i < ArchFlags.size(); ++i) {
1180       if (ArchFlags[i] == T.getArchName())
1181         ArchFound = true;
1182       break;
1183     }
1184     if (!ArchFound) {
1185       errs() << "llvm-objdump: file: " + Filename + " does not contain "
1186              << "architecture: " + ArchFlags[i] + "\n";
1187       return false;
1188     }
1189   }
1190   return true;
1191 }
1192
1193 static void printObjcMetaData(MachOObjectFile *O, bool verbose);
1194
1195 // ProcessMachO() is passed a single opened Mach-O file, which may be an
1196 // archive member and or in a slice of a universal file.  It prints the
1197 // the file name and header info and then processes it according to the
1198 // command line options.
1199 static void ProcessMachO(StringRef Filename, MachOObjectFile *MachOOF,
1200                          StringRef ArchiveMemberName = StringRef(),
1201                          StringRef ArchitectureName = StringRef()) {
1202   // If we are doing some processing here on the Mach-O file print the header
1203   // info.  And don't print it otherwise like in the case of printing the
1204   // UniversalHeaders or ArchiveHeaders.
1205   if (Disassemble || PrivateHeaders || ExportsTrie || Rebase || Bind ||
1206       LazyBind || WeakBind || IndirectSymbols || DataInCode || LinkOptHints ||
1207       DylibsUsed || DylibId || ObjcMetaData ||
1208       (DumpSections.size() != 0 && !Raw)) {
1209     outs() << Filename;
1210     if (!ArchiveMemberName.empty())
1211       outs() << '(' << ArchiveMemberName << ')';
1212     if (!ArchitectureName.empty())
1213       outs() << " (architecture " << ArchitectureName << ")";
1214     outs() << ":\n";
1215   }
1216
1217   if (Disassemble)
1218     DisassembleMachO(Filename, MachOOF, "__TEXT", "__text");
1219   if (IndirectSymbols)
1220     PrintIndirectSymbols(MachOOF, !NonVerbose);
1221   if (DataInCode)
1222     PrintDataInCodeTable(MachOOF, !NonVerbose);
1223   if (LinkOptHints)
1224     PrintLinkOptHints(MachOOF);
1225   if (Relocations)
1226     PrintRelocations(MachOOF);
1227   if (SectionHeaders)
1228     PrintSectionHeaders(MachOOF);
1229   if (SectionContents)
1230     PrintSectionContents(MachOOF);
1231   if (DumpSections.size() != 0)
1232     DumpSectionContents(Filename, MachOOF, !NonVerbose);
1233   if (InfoPlist)
1234     DumpInfoPlistSectionContents(Filename, MachOOF);
1235   if (DylibsUsed)
1236     PrintDylibs(MachOOF, false);
1237   if (DylibId)
1238     PrintDylibs(MachOOF, true);
1239   if (SymbolTable)
1240     PrintSymbolTable(MachOOF);
1241   if (UnwindInfo)
1242     printMachOUnwindInfo(MachOOF);
1243   if (PrivateHeaders)
1244     printMachOFileHeader(MachOOF);
1245   if (ObjcMetaData)
1246     printObjcMetaData(MachOOF, !NonVerbose);
1247   if (ExportsTrie)
1248     printExportsTrie(MachOOF);
1249   if (Rebase)
1250     printRebaseTable(MachOOF);
1251   if (Bind)
1252     printBindTable(MachOOF);
1253   if (LazyBind)
1254     printLazyBindTable(MachOOF);
1255   if (WeakBind)
1256     printWeakBindTable(MachOOF);
1257 }
1258
1259 // printUnknownCPUType() helps print_fat_headers for unknown CPU's.
1260 static void printUnknownCPUType(uint32_t cputype, uint32_t cpusubtype) {
1261   outs() << "    cputype (" << cputype << ")\n";
1262   outs() << "    cpusubtype (" << cpusubtype << ")\n";
1263 }
1264
1265 // printCPUType() helps print_fat_headers by printing the cputype and
1266 // pusubtype (symbolically for the one's it knows about).
1267 static void printCPUType(uint32_t cputype, uint32_t cpusubtype) {
1268   switch (cputype) {
1269   case MachO::CPU_TYPE_I386:
1270     switch (cpusubtype) {
1271     case MachO::CPU_SUBTYPE_I386_ALL:
1272       outs() << "    cputype CPU_TYPE_I386\n";
1273       outs() << "    cpusubtype CPU_SUBTYPE_I386_ALL\n";
1274       break;
1275     default:
1276       printUnknownCPUType(cputype, cpusubtype);
1277       break;
1278     }
1279     break;
1280   case MachO::CPU_TYPE_X86_64:
1281     switch (cpusubtype) {
1282     case MachO::CPU_SUBTYPE_X86_64_ALL:
1283       outs() << "    cputype CPU_TYPE_X86_64\n";
1284       outs() << "    cpusubtype CPU_SUBTYPE_X86_64_ALL\n";
1285       break;
1286     case MachO::CPU_SUBTYPE_X86_64_H:
1287       outs() << "    cputype CPU_TYPE_X86_64\n";
1288       outs() << "    cpusubtype CPU_SUBTYPE_X86_64_H\n";
1289       break;
1290     default:
1291       printUnknownCPUType(cputype, cpusubtype);
1292       break;
1293     }
1294     break;
1295   case MachO::CPU_TYPE_ARM:
1296     switch (cpusubtype) {
1297     case MachO::CPU_SUBTYPE_ARM_ALL:
1298       outs() << "    cputype CPU_TYPE_ARM\n";
1299       outs() << "    cpusubtype CPU_SUBTYPE_ARM_ALL\n";
1300       break;
1301     case MachO::CPU_SUBTYPE_ARM_V4T:
1302       outs() << "    cputype CPU_TYPE_ARM\n";
1303       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V4T\n";
1304       break;
1305     case MachO::CPU_SUBTYPE_ARM_V5TEJ:
1306       outs() << "    cputype CPU_TYPE_ARM\n";
1307       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V5TEJ\n";
1308       break;
1309     case MachO::CPU_SUBTYPE_ARM_XSCALE:
1310       outs() << "    cputype CPU_TYPE_ARM\n";
1311       outs() << "    cpusubtype CPU_SUBTYPE_ARM_XSCALE\n";
1312       break;
1313     case MachO::CPU_SUBTYPE_ARM_V6:
1314       outs() << "    cputype CPU_TYPE_ARM\n";
1315       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V6\n";
1316       break;
1317     case MachO::CPU_SUBTYPE_ARM_V6M:
1318       outs() << "    cputype CPU_TYPE_ARM\n";
1319       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V6M\n";
1320       break;
1321     case MachO::CPU_SUBTYPE_ARM_V7:
1322       outs() << "    cputype CPU_TYPE_ARM\n";
1323       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7\n";
1324       break;
1325     case MachO::CPU_SUBTYPE_ARM_V7EM:
1326       outs() << "    cputype CPU_TYPE_ARM\n";
1327       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7EM\n";
1328       break;
1329     case MachO::CPU_SUBTYPE_ARM_V7K:
1330       outs() << "    cputype CPU_TYPE_ARM\n";
1331       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7K\n";
1332       break;
1333     case MachO::CPU_SUBTYPE_ARM_V7M:
1334       outs() << "    cputype CPU_TYPE_ARM\n";
1335       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7M\n";
1336       break;
1337     case MachO::CPU_SUBTYPE_ARM_V7S:
1338       outs() << "    cputype CPU_TYPE_ARM\n";
1339       outs() << "    cpusubtype CPU_SUBTYPE_ARM_V7S\n";
1340       break;
1341     default:
1342       printUnknownCPUType(cputype, cpusubtype);
1343       break;
1344     }
1345     break;
1346   case MachO::CPU_TYPE_ARM64:
1347     switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
1348     case MachO::CPU_SUBTYPE_ARM64_ALL:
1349       outs() << "    cputype CPU_TYPE_ARM64\n";
1350       outs() << "    cpusubtype CPU_SUBTYPE_ARM64_ALL\n";
1351       break;
1352     default:
1353       printUnknownCPUType(cputype, cpusubtype);
1354       break;
1355     }
1356     break;
1357   default:
1358     printUnknownCPUType(cputype, cpusubtype);
1359     break;
1360   }
1361 }
1362
1363 static void printMachOUniversalHeaders(const object::MachOUniversalBinary *UB,
1364                                        bool verbose) {
1365   outs() << "Fat headers\n";
1366   if (verbose)
1367     outs() << "fat_magic FAT_MAGIC\n";
1368   else
1369     outs() << "fat_magic " << format("0x%" PRIx32, MachO::FAT_MAGIC) << "\n";
1370
1371   uint32_t nfat_arch = UB->getNumberOfObjects();
1372   StringRef Buf = UB->getData();
1373   uint64_t size = Buf.size();
1374   uint64_t big_size = sizeof(struct MachO::fat_header) +
1375                       nfat_arch * sizeof(struct MachO::fat_arch);
1376   outs() << "nfat_arch " << UB->getNumberOfObjects();
1377   if (nfat_arch == 0)
1378     outs() << " (malformed, contains zero architecture types)\n";
1379   else if (big_size > size)
1380     outs() << " (malformed, architectures past end of file)\n";
1381   else
1382     outs() << "\n";
1383
1384   for (uint32_t i = 0; i < nfat_arch; ++i) {
1385     MachOUniversalBinary::ObjectForArch OFA(UB, i);
1386     uint32_t cputype = OFA.getCPUType();
1387     uint32_t cpusubtype = OFA.getCPUSubType();
1388     outs() << "architecture ";
1389     for (uint32_t j = 0; i != 0 && j <= i - 1; j++) {
1390       MachOUniversalBinary::ObjectForArch other_OFA(UB, j);
1391       uint32_t other_cputype = other_OFA.getCPUType();
1392       uint32_t other_cpusubtype = other_OFA.getCPUSubType();
1393       if (cputype != 0 && cpusubtype != 0 && cputype == other_cputype &&
1394           (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) ==
1395               (other_cpusubtype & ~MachO::CPU_SUBTYPE_MASK)) {
1396         outs() << "(illegal duplicate architecture) ";
1397         break;
1398       }
1399     }
1400     if (verbose) {
1401       outs() << OFA.getArchTypeName() << "\n";
1402       printCPUType(cputype, cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
1403     } else {
1404       outs() << i << "\n";
1405       outs() << "    cputype " << cputype << "\n";
1406       outs() << "    cpusubtype " << (cpusubtype & ~MachO::CPU_SUBTYPE_MASK)
1407              << "\n";
1408     }
1409     if (verbose &&
1410         (cpusubtype & MachO::CPU_SUBTYPE_MASK) == MachO::CPU_SUBTYPE_LIB64)
1411       outs() << "    capabilities CPU_SUBTYPE_LIB64\n";
1412     else
1413       outs() << "    capabilities "
1414              << format("0x%" PRIx32,
1415                        (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24) << "\n";
1416     outs() << "    offset " << OFA.getOffset();
1417     if (OFA.getOffset() > size)
1418       outs() << " (past end of file)";
1419     if (OFA.getOffset() % (1 << OFA.getAlign()) != 0)
1420       outs() << " (not aligned on it's alignment (2^" << OFA.getAlign() << ")";
1421     outs() << "\n";
1422     outs() << "    size " << OFA.getSize();
1423     big_size = OFA.getOffset() + OFA.getSize();
1424     if (big_size > size)
1425       outs() << " (past end of file)";
1426     outs() << "\n";
1427     outs() << "    align 2^" << OFA.getAlign() << " (" << (1 << OFA.getAlign())
1428            << ")\n";
1429   }
1430 }
1431
1432 static void printArchiveChild(Archive::Child &C, bool verbose,
1433                               bool print_offset) {
1434   if (print_offset)
1435     outs() << C.getChildOffset() << "\t";
1436   sys::fs::perms Mode = C.getAccessMode();
1437   if (verbose) {
1438     // FIXME: this first dash, "-", is for (Mode & S_IFMT) == S_IFREG.
1439     // But there is nothing in sys::fs::perms for S_IFMT or S_IFREG.
1440     outs() << "-";
1441     if (Mode & sys::fs::owner_read)
1442       outs() << "r";
1443     else
1444       outs() << "-";
1445     if (Mode & sys::fs::owner_write)
1446       outs() << "w";
1447     else
1448       outs() << "-";
1449     if (Mode & sys::fs::owner_exe)
1450       outs() << "x";
1451     else
1452       outs() << "-";
1453     if (Mode & sys::fs::group_read)
1454       outs() << "r";
1455     else
1456       outs() << "-";
1457     if (Mode & sys::fs::group_write)
1458       outs() << "w";
1459     else
1460       outs() << "-";
1461     if (Mode & sys::fs::group_exe)
1462       outs() << "x";
1463     else
1464       outs() << "-";
1465     if (Mode & sys::fs::others_read)
1466       outs() << "r";
1467     else
1468       outs() << "-";
1469     if (Mode & sys::fs::others_write)
1470       outs() << "w";
1471     else
1472       outs() << "-";
1473     if (Mode & sys::fs::others_exe)
1474       outs() << "x";
1475     else
1476       outs() << "-";
1477   } else {
1478     outs() << format("0%o ", Mode);
1479   }
1480
1481   unsigned UID = C.getUID();
1482   outs() << format("%3d/", UID);
1483   unsigned GID = C.getGID();
1484   outs() << format("%-3d ", GID);
1485   uint64_t Size = C.getRawSize();
1486   outs() << format("%5" PRId64, Size) << " ";
1487
1488   StringRef RawLastModified = C.getRawLastModified();
1489   if (verbose) {
1490     unsigned Seconds;
1491     if (RawLastModified.getAsInteger(10, Seconds))
1492       outs() << "(date: \"%s\" contains non-decimal chars) " << RawLastModified;
1493     else {
1494       // Since cime(3) returns a 26 character string of the form:
1495       // "Sun Sep 16 01:03:52 1973\n\0"
1496       // just print 24 characters.
1497       time_t t = Seconds;
1498       outs() << format("%.24s ", ctime(&t));
1499     }
1500   } else {
1501     outs() << RawLastModified << " ";
1502   }
1503
1504   if (verbose) {
1505     ErrorOr<StringRef> NameOrErr = C.getName();
1506     if (NameOrErr.getError()) {
1507       StringRef RawName = C.getRawName();
1508       outs() << RawName << "\n";
1509     } else {
1510       StringRef Name = NameOrErr.get();
1511       outs() << Name << "\n";
1512     }
1513   } else {
1514     StringRef RawName = C.getRawName();
1515     outs() << RawName << "\n";
1516   }
1517 }
1518
1519 static void printArchiveHeaders(Archive *A, bool verbose, bool print_offset) {
1520   if (A->hasSymbolTable()) {
1521     Archive::child_iterator S = A->getSymbolTableChild();
1522     Archive::Child C = *S;
1523     printArchiveChild(C, verbose, print_offset);
1524   }
1525   for (Archive::child_iterator I = A->child_begin(), E = A->child_end(); I != E;
1526        ++I) {
1527     Archive::Child C = *I;
1528     printArchiveChild(C, verbose, print_offset);
1529   }
1530 }
1531
1532 // ParseInputMachO() parses the named Mach-O file in Filename and handles the
1533 // -arch flags selecting just those slices as specified by them and also parses
1534 // archive files.  Then for each individual Mach-O file ProcessMachO() is
1535 // called to process the file based on the command line options.
1536 void llvm::ParseInputMachO(StringRef Filename) {
1537   // Check for -arch all and verifiy the -arch flags are valid.
1538   for (unsigned i = 0; i < ArchFlags.size(); ++i) {
1539     if (ArchFlags[i] == "all") {
1540       ArchAll = true;
1541     } else {
1542       if (!MachOObjectFile::isValidArch(ArchFlags[i])) {
1543         errs() << "llvm-objdump: Unknown architecture named '" + ArchFlags[i] +
1544                       "'for the -arch option\n";
1545         return;
1546       }
1547     }
1548   }
1549
1550   // Attempt to open the binary.
1551   ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(Filename);
1552   if (std::error_code EC = BinaryOrErr.getError()) {
1553     errs() << "llvm-objdump: '" << Filename << "': " << EC.message() << ".\n";
1554     return;
1555   }
1556   Binary &Bin = *BinaryOrErr.get().getBinary();
1557
1558   if (Archive *A = dyn_cast<Archive>(&Bin)) {
1559     outs() << "Archive : " << Filename << "\n";
1560     if (ArchiveHeaders)
1561       printArchiveHeaders(A, true, false);
1562     for (Archive::child_iterator I = A->child_begin(), E = A->child_end();
1563          I != E; ++I) {
1564       ErrorOr<std::unique_ptr<Binary>> ChildOrErr = I->getAsBinary();
1565       if (ChildOrErr.getError())
1566         continue;
1567       if (MachOObjectFile *O = dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) {
1568         if (!checkMachOAndArchFlags(O, Filename))
1569           return;
1570         ProcessMachO(Filename, O, O->getFileName());
1571       }
1572     }
1573     return;
1574   }
1575   if (UniversalHeaders) {
1576     if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin))
1577       printMachOUniversalHeaders(UB, !NonVerbose);
1578   }
1579   if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) {
1580     // If we have a list of architecture flags specified dump only those.
1581     if (!ArchAll && ArchFlags.size() != 0) {
1582       // Look for a slice in the universal binary that matches each ArchFlag.
1583       bool ArchFound;
1584       for (unsigned i = 0; i < ArchFlags.size(); ++i) {
1585         ArchFound = false;
1586         for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1587                                                    E = UB->end_objects();
1588              I != E; ++I) {
1589           if (ArchFlags[i] == I->getArchTypeName()) {
1590             ArchFound = true;
1591             ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr =
1592                 I->getAsObjectFile();
1593             std::string ArchitectureName = "";
1594             if (ArchFlags.size() > 1)
1595               ArchitectureName = I->getArchTypeName();
1596             if (ObjOrErr) {
1597               ObjectFile &O = *ObjOrErr.get();
1598               if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O))
1599                 ProcessMachO(Filename, MachOOF, "", ArchitectureName);
1600             } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr =
1601                            I->getAsArchive()) {
1602               std::unique_ptr<Archive> &A = *AOrErr;
1603               outs() << "Archive : " << Filename;
1604               if (!ArchitectureName.empty())
1605                 outs() << " (architecture " << ArchitectureName << ")";
1606               outs() << "\n";
1607               if (ArchiveHeaders)
1608                 printArchiveHeaders(A.get(), true, false);
1609               for (Archive::child_iterator AI = A->child_begin(),
1610                                            AE = A->child_end();
1611                    AI != AE; ++AI) {
1612                 ErrorOr<std::unique_ptr<Binary>> ChildOrErr = AI->getAsBinary();
1613                 if (ChildOrErr.getError())
1614                   continue;
1615                 if (MachOObjectFile *O =
1616                         dyn_cast<MachOObjectFile>(&*ChildOrErr.get()))
1617                   ProcessMachO(Filename, O, O->getFileName(), ArchitectureName);
1618               }
1619             }
1620           }
1621         }
1622         if (!ArchFound) {
1623           errs() << "llvm-objdump: file: " + Filename + " does not contain "
1624                  << "architecture: " + ArchFlags[i] + "\n";
1625           return;
1626         }
1627       }
1628       return;
1629     }
1630     // No architecture flags were specified so if this contains a slice that
1631     // matches the host architecture dump only that.
1632     if (!ArchAll) {
1633       for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1634                                                  E = UB->end_objects();
1635            I != E; ++I) {
1636         if (MachOObjectFile::getHostArch().getArchName() ==
1637             I->getArchTypeName()) {
1638           ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
1639           std::string ArchiveName;
1640           ArchiveName.clear();
1641           if (ObjOrErr) {
1642             ObjectFile &O = *ObjOrErr.get();
1643             if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O))
1644               ProcessMachO(Filename, MachOOF);
1645           } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr =
1646                          I->getAsArchive()) {
1647             std::unique_ptr<Archive> &A = *AOrErr;
1648             outs() << "Archive : " << Filename << "\n";
1649             if (ArchiveHeaders)
1650               printArchiveHeaders(A.get(), true, false);
1651             for (Archive::child_iterator AI = A->child_begin(),
1652                                          AE = A->child_end();
1653                  AI != AE; ++AI) {
1654               ErrorOr<std::unique_ptr<Binary>> ChildOrErr = AI->getAsBinary();
1655               if (ChildOrErr.getError())
1656                 continue;
1657               if (MachOObjectFile *O =
1658                       dyn_cast<MachOObjectFile>(&*ChildOrErr.get()))
1659                 ProcessMachO(Filename, O, O->getFileName());
1660             }
1661           }
1662           return;
1663         }
1664       }
1665     }
1666     // Either all architectures have been specified or none have been specified
1667     // and this does not contain the host architecture so dump all the slices.
1668     bool moreThanOneArch = UB->getNumberOfObjects() > 1;
1669     for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1670                                                E = UB->end_objects();
1671          I != E; ++I) {
1672       ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
1673       std::string ArchitectureName = "";
1674       if (moreThanOneArch)
1675         ArchitectureName = I->getArchTypeName();
1676       if (ObjOrErr) {
1677         ObjectFile &Obj = *ObjOrErr.get();
1678         if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&Obj))
1679           ProcessMachO(Filename, MachOOF, "", ArchitectureName);
1680       } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr = I->getAsArchive()) {
1681         std::unique_ptr<Archive> &A = *AOrErr;
1682         outs() << "Archive : " << Filename;
1683         if (!ArchitectureName.empty())
1684           outs() << " (architecture " << ArchitectureName << ")";
1685         outs() << "\n";
1686         if (ArchiveHeaders)
1687           printArchiveHeaders(A.get(), true, false);
1688         for (Archive::child_iterator AI = A->child_begin(), AE = A->child_end();
1689              AI != AE; ++AI) {
1690           ErrorOr<std::unique_ptr<Binary>> ChildOrErr = AI->getAsBinary();
1691           if (ChildOrErr.getError())
1692             continue;
1693           if (MachOObjectFile *O =
1694                   dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) {
1695             if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(O))
1696               ProcessMachO(Filename, MachOOF, MachOOF->getFileName(),
1697                            ArchitectureName);
1698           }
1699         }
1700       }
1701     }
1702     return;
1703   }
1704   if (ObjectFile *O = dyn_cast<ObjectFile>(&Bin)) {
1705     if (!checkMachOAndArchFlags(O, Filename))
1706       return;
1707     if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&*O)) {
1708       ProcessMachO(Filename, MachOOF);
1709     } else
1710       errs() << "llvm-objdump: '" << Filename << "': "
1711              << "Object is not a Mach-O file type.\n";
1712   } else
1713     errs() << "llvm-objdump: '" << Filename << "': "
1714            << "Unrecognized file type.\n";
1715 }
1716
1717 typedef std::pair<uint64_t, const char *> BindInfoEntry;
1718 typedef std::vector<BindInfoEntry> BindTable;
1719 typedef BindTable::iterator bind_table_iterator;
1720
1721 // The block of info used by the Symbolizer call backs.
1722 struct DisassembleInfo {
1723   bool verbose;
1724   MachOObjectFile *O;
1725   SectionRef S;
1726   SymbolAddressMap *AddrMap;
1727   std::vector<SectionRef> *Sections;
1728   const char *class_name;
1729   const char *selector_name;
1730   char *method;
1731   char *demangled_name;
1732   uint64_t adrp_addr;
1733   uint32_t adrp_inst;
1734   BindTable *bindtable;
1735 };
1736
1737 // SymbolizerGetOpInfo() is the operand information call back function.
1738 // This is called to get the symbolic information for operand(s) of an
1739 // instruction when it is being done.  This routine does this from
1740 // the relocation information, symbol table, etc. That block of information
1741 // is a pointer to the struct DisassembleInfo that was passed when the
1742 // disassembler context was created and passed to back to here when
1743 // called back by the disassembler for instruction operands that could have
1744 // relocation information. The address of the instruction containing operand is
1745 // at the Pc parameter.  The immediate value the operand has is passed in
1746 // op_info->Value and is at Offset past the start of the instruction and has a
1747 // byte Size of 1, 2 or 4. The symbolc information is returned in TagBuf is the
1748 // LLVMOpInfo1 struct defined in the header "llvm-c/Disassembler.h" as symbol
1749 // names and addends of the symbolic expression to add for the operand.  The
1750 // value of TagType is currently 1 (for the LLVMOpInfo1 struct). If symbolic
1751 // information is returned then this function returns 1 else it returns 0.
1752 static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
1753                                uint64_t Size, int TagType, void *TagBuf) {
1754   struct DisassembleInfo *info = (struct DisassembleInfo *)DisInfo;
1755   struct LLVMOpInfo1 *op_info = (struct LLVMOpInfo1 *)TagBuf;
1756   uint64_t value = op_info->Value;
1757
1758   // Make sure all fields returned are zero if we don't set them.
1759   memset((void *)op_info, '\0', sizeof(struct LLVMOpInfo1));
1760   op_info->Value = value;
1761
1762   // If the TagType is not the value 1 which it code knows about or if no
1763   // verbose symbolic information is wanted then just return 0, indicating no
1764   // information is being returned.
1765   if (TagType != 1 || !info->verbose)
1766     return 0;
1767
1768   unsigned int Arch = info->O->getArch();
1769   if (Arch == Triple::x86) {
1770     if (Size != 1 && Size != 2 && Size != 4 && Size != 0)
1771       return 0;
1772     // First search the section's relocation entries (if any) for an entry
1773     // for this section offset.
1774     uint32_t sect_addr = info->S.getAddress();
1775     uint32_t sect_offset = (Pc + Offset) - sect_addr;
1776     bool reloc_found = false;
1777     DataRefImpl Rel;
1778     MachO::any_relocation_info RE;
1779     bool isExtern = false;
1780     SymbolRef Symbol;
1781     bool r_scattered = false;
1782     uint32_t r_value, pair_r_value, r_type;
1783     for (const RelocationRef &Reloc : info->S.relocations()) {
1784       uint64_t RelocOffset;
1785       Reloc.getOffset(RelocOffset);
1786       if (RelocOffset == sect_offset) {
1787         Rel = Reloc.getRawDataRefImpl();
1788         RE = info->O->getRelocation(Rel);
1789         r_type = info->O->getAnyRelocationType(RE);
1790         r_scattered = info->O->isRelocationScattered(RE);
1791         if (r_scattered) {
1792           r_value = info->O->getScatteredRelocationValue(RE);
1793           if (r_type == MachO::GENERIC_RELOC_SECTDIFF ||
1794               r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF) {
1795             DataRefImpl RelNext = Rel;
1796             info->O->moveRelocationNext(RelNext);
1797             MachO::any_relocation_info RENext;
1798             RENext = info->O->getRelocation(RelNext);
1799             if (info->O->isRelocationScattered(RENext))
1800               pair_r_value = info->O->getScatteredRelocationValue(RENext);
1801             else
1802               return 0;
1803           }
1804         } else {
1805           isExtern = info->O->getPlainRelocationExternal(RE);
1806           if (isExtern) {
1807             symbol_iterator RelocSym = Reloc.getSymbol();
1808             Symbol = *RelocSym;
1809           }
1810         }
1811         reloc_found = true;
1812         break;
1813       }
1814     }
1815     if (reloc_found && isExtern) {
1816       StringRef SymName;
1817       Symbol.getName(SymName);
1818       const char *name = SymName.data();
1819       op_info->AddSymbol.Present = 1;
1820       op_info->AddSymbol.Name = name;
1821       // For i386 extern relocation entries the value in the instruction is
1822       // the offset from the symbol, and value is already set in op_info->Value.
1823       return 1;
1824     }
1825     if (reloc_found && (r_type == MachO::GENERIC_RELOC_SECTDIFF ||
1826                         r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)) {
1827       const char *add = GuessSymbolName(r_value, info->AddrMap);
1828       const char *sub = GuessSymbolName(pair_r_value, info->AddrMap);
1829       uint32_t offset = value - (r_value - pair_r_value);
1830       op_info->AddSymbol.Present = 1;
1831       if (add != nullptr)
1832         op_info->AddSymbol.Name = add;
1833       else
1834         op_info->AddSymbol.Value = r_value;
1835       op_info->SubtractSymbol.Present = 1;
1836       if (sub != nullptr)
1837         op_info->SubtractSymbol.Name = sub;
1838       else
1839         op_info->SubtractSymbol.Value = pair_r_value;
1840       op_info->Value = offset;
1841       return 1;
1842     }
1843     // TODO:
1844     // Second search the external relocation entries of a fully linked image
1845     // (if any) for an entry that matches this segment offset.
1846     // uint32_t seg_offset = (Pc + Offset);
1847     return 0;
1848   }
1849   if (Arch == Triple::x86_64) {
1850     if (Size != 1 && Size != 2 && Size != 4 && Size != 0)
1851       return 0;
1852     // First search the section's relocation entries (if any) for an entry
1853     // for this section offset.
1854     uint64_t sect_addr = info->S.getAddress();
1855     uint64_t sect_offset = (Pc + Offset) - sect_addr;
1856     bool reloc_found = false;
1857     DataRefImpl Rel;
1858     MachO::any_relocation_info RE;
1859     bool isExtern = false;
1860     SymbolRef Symbol;
1861     for (const RelocationRef &Reloc : info->S.relocations()) {
1862       uint64_t RelocOffset;
1863       Reloc.getOffset(RelocOffset);
1864       if (RelocOffset == sect_offset) {
1865         Rel = Reloc.getRawDataRefImpl();
1866         RE = info->O->getRelocation(Rel);
1867         // NOTE: Scattered relocations don't exist on x86_64.
1868         isExtern = info->O->getPlainRelocationExternal(RE);
1869         if (isExtern) {
1870           symbol_iterator RelocSym = Reloc.getSymbol();
1871           Symbol = *RelocSym;
1872         }
1873         reloc_found = true;
1874         break;
1875       }
1876     }
1877     if (reloc_found && isExtern) {
1878       // The Value passed in will be adjusted by the Pc if the instruction
1879       // adds the Pc.  But for x86_64 external relocation entries the Value
1880       // is the offset from the external symbol.
1881       if (info->O->getAnyRelocationPCRel(RE))
1882         op_info->Value -= Pc + Offset + Size;
1883       StringRef SymName;
1884       Symbol.getName(SymName);
1885       const char *name = SymName.data();
1886       unsigned Type = info->O->getAnyRelocationType(RE);
1887       if (Type == MachO::X86_64_RELOC_SUBTRACTOR) {
1888         DataRefImpl RelNext = Rel;
1889         info->O->moveRelocationNext(RelNext);
1890         MachO::any_relocation_info RENext = info->O->getRelocation(RelNext);
1891         unsigned TypeNext = info->O->getAnyRelocationType(RENext);
1892         bool isExternNext = info->O->getPlainRelocationExternal(RENext);
1893         unsigned SymbolNum = info->O->getPlainRelocationSymbolNum(RENext);
1894         if (TypeNext == MachO::X86_64_RELOC_UNSIGNED && isExternNext) {
1895           op_info->SubtractSymbol.Present = 1;
1896           op_info->SubtractSymbol.Name = name;
1897           symbol_iterator RelocSymNext = info->O->getSymbolByIndex(SymbolNum);
1898           Symbol = *RelocSymNext;
1899           StringRef SymNameNext;
1900           Symbol.getName(SymNameNext);
1901           name = SymNameNext.data();
1902         }
1903       }
1904       // TODO: add the VariantKinds to op_info->VariantKind for relocation types
1905       // like: X86_64_RELOC_TLV, X86_64_RELOC_GOT_LOAD and X86_64_RELOC_GOT.
1906       op_info->AddSymbol.Present = 1;
1907       op_info->AddSymbol.Name = name;
1908       return 1;
1909     }
1910     // TODO:
1911     // Second search the external relocation entries of a fully linked image
1912     // (if any) for an entry that matches this segment offset.
1913     // uint64_t seg_offset = (Pc + Offset);
1914     return 0;
1915   }
1916   if (Arch == Triple::arm) {
1917     if (Offset != 0 || (Size != 4 && Size != 2))
1918       return 0;
1919     // First search the section's relocation entries (if any) for an entry
1920     // for this section offset.
1921     uint32_t sect_addr = info->S.getAddress();
1922     uint32_t sect_offset = (Pc + Offset) - sect_addr;
1923     DataRefImpl Rel;
1924     MachO::any_relocation_info RE;
1925     bool isExtern = false;
1926     SymbolRef Symbol;
1927     bool r_scattered = false;
1928     uint32_t r_value, pair_r_value, r_type, r_length, other_half;
1929     auto Reloc =
1930         std::find_if(info->S.relocations().begin(), info->S.relocations().end(),
1931                      [&](const RelocationRef &Reloc) {
1932                        uint64_t RelocOffset;
1933                        Reloc.getOffset(RelocOffset);
1934                        return RelocOffset == sect_offset;
1935                      });
1936
1937     if (Reloc == info->S.relocations().end())
1938       return 0;
1939
1940     Rel = Reloc->getRawDataRefImpl();
1941     RE = info->O->getRelocation(Rel);
1942     r_length = info->O->getAnyRelocationLength(RE);
1943     r_scattered = info->O->isRelocationScattered(RE);
1944     if (r_scattered) {
1945       r_value = info->O->getScatteredRelocationValue(RE);
1946       r_type = info->O->getScatteredRelocationType(RE);
1947     } else {
1948       r_type = info->O->getAnyRelocationType(RE);
1949       isExtern = info->O->getPlainRelocationExternal(RE);
1950       if (isExtern) {
1951         symbol_iterator RelocSym = Reloc->getSymbol();
1952         Symbol = *RelocSym;
1953       }
1954     }
1955     if (r_type == MachO::ARM_RELOC_HALF ||
1956         r_type == MachO::ARM_RELOC_SECTDIFF ||
1957         r_type == MachO::ARM_RELOC_LOCAL_SECTDIFF ||
1958         r_type == MachO::ARM_RELOC_HALF_SECTDIFF) {
1959       DataRefImpl RelNext = Rel;
1960       info->O->moveRelocationNext(RelNext);
1961       MachO::any_relocation_info RENext;
1962       RENext = info->O->getRelocation(RelNext);
1963       other_half = info->O->getAnyRelocationAddress(RENext) & 0xffff;
1964       if (info->O->isRelocationScattered(RENext))
1965         pair_r_value = info->O->getScatteredRelocationValue(RENext);
1966     }
1967
1968     if (isExtern) {
1969       StringRef SymName;
1970       Symbol.getName(SymName);
1971       const char *name = SymName.data();
1972       op_info->AddSymbol.Present = 1;
1973       op_info->AddSymbol.Name = name;
1974       switch (r_type) {
1975       case MachO::ARM_RELOC_HALF:
1976         if ((r_length & 0x1) == 1) {
1977           op_info->Value = value << 16 | other_half;
1978           op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI16;
1979         } else {
1980           op_info->Value = other_half << 16 | value;
1981           op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO16;
1982         }
1983         break;
1984       default:
1985         break;
1986       }
1987       return 1;
1988     }
1989     // If we have a branch that is not an external relocation entry then
1990     // return 0 so the code in tryAddingSymbolicOperand() can use the
1991     // SymbolLookUp call back with the branch target address to look up the
1992     // symbol and possiblity add an annotation for a symbol stub.
1993     if (isExtern == 0 && (r_type == MachO::ARM_RELOC_BR24 ||
1994                           r_type == MachO::ARM_THUMB_RELOC_BR22))
1995       return 0;
1996
1997     uint32_t offset = 0;
1998     if (r_type == MachO::ARM_RELOC_HALF ||
1999         r_type == MachO::ARM_RELOC_HALF_SECTDIFF) {
2000       if ((r_length & 0x1) == 1)
2001         value = value << 16 | other_half;
2002       else
2003         value = other_half << 16 | value;
2004     }
2005     if (r_scattered && (r_type != MachO::ARM_RELOC_HALF &&
2006                         r_type != MachO::ARM_RELOC_HALF_SECTDIFF)) {
2007       offset = value - r_value;
2008       value = r_value;
2009     }
2010
2011     if (r_type == MachO::ARM_RELOC_HALF_SECTDIFF) {
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       const char *add = GuessSymbolName(r_value, info->AddrMap);
2017       const char *sub = GuessSymbolName(pair_r_value, info->AddrMap);
2018       int32_t offset = value - (r_value - pair_r_value);
2019       op_info->AddSymbol.Present = 1;
2020       if (add != nullptr)
2021         op_info->AddSymbol.Name = add;
2022       else
2023         op_info->AddSymbol.Value = r_value;
2024       op_info->SubtractSymbol.Present = 1;
2025       if (sub != nullptr)
2026         op_info->SubtractSymbol.Name = sub;
2027       else
2028         op_info->SubtractSymbol.Value = pair_r_value;
2029       op_info->Value = offset;
2030       return 1;
2031     }
2032
2033     op_info->AddSymbol.Present = 1;
2034     op_info->Value = offset;
2035     if (r_type == MachO::ARM_RELOC_HALF) {
2036       if ((r_length & 0x1) == 1)
2037         op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI16;
2038       else
2039         op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO16;
2040     }
2041     const char *add = GuessSymbolName(value, info->AddrMap);
2042     if (add != nullptr) {
2043       op_info->AddSymbol.Name = add;
2044       return 1;
2045     }
2046     op_info->AddSymbol.Value = value;
2047     return 1;
2048   }
2049   if (Arch == Triple::aarch64) {
2050     if (Offset != 0 || Size != 4)
2051       return 0;
2052     // First search the section's relocation entries (if any) for an entry
2053     // for this section offset.
2054     uint64_t sect_addr = info->S.getAddress();
2055     uint64_t sect_offset = (Pc + Offset) - sect_addr;
2056     auto Reloc =
2057         std::find_if(info->S.relocations().begin(), info->S.relocations().end(),
2058                      [&](const RelocationRef &Reloc) {
2059                        uint64_t RelocOffset;
2060                        Reloc.getOffset(RelocOffset);
2061                        return RelocOffset == sect_offset;
2062                      });
2063
2064     if (Reloc == info->S.relocations().end())
2065       return 0;
2066
2067     DataRefImpl Rel = Reloc->getRawDataRefImpl();
2068     MachO::any_relocation_info RE = info->O->getRelocation(Rel);
2069     uint32_t r_type = info->O->getAnyRelocationType(RE);
2070     if (r_type == MachO::ARM64_RELOC_ADDEND) {
2071       DataRefImpl RelNext = Rel;
2072       info->O->moveRelocationNext(RelNext);
2073       MachO::any_relocation_info RENext = info->O->getRelocation(RelNext);
2074       if (value == 0) {
2075         value = info->O->getPlainRelocationSymbolNum(RENext);
2076         op_info->Value = value;
2077       }
2078     }
2079     // NOTE: Scattered relocations don't exist on arm64.
2080     if (!info->O->getPlainRelocationExternal(RE))
2081       return 0;
2082     StringRef SymName;
2083     Reloc->getSymbol()->getName(SymName);
2084     const char *name = SymName.data();
2085     op_info->AddSymbol.Present = 1;
2086     op_info->AddSymbol.Name = name;
2087
2088     switch (r_type) {
2089     case MachO::ARM64_RELOC_PAGE21:
2090       /* @page */
2091       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_PAGE;
2092       break;
2093     case MachO::ARM64_RELOC_PAGEOFF12:
2094       /* @pageoff */
2095       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_PAGEOFF;
2096       break;
2097     case MachO::ARM64_RELOC_GOT_LOAD_PAGE21:
2098       /* @gotpage */
2099       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_GOTPAGE;
2100       break;
2101     case MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12:
2102       /* @gotpageoff */
2103       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF;
2104       break;
2105     case MachO::ARM64_RELOC_TLVP_LOAD_PAGE21:
2106       /* @tvlppage is not implemented in llvm-mc */
2107       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_TLVP;
2108       break;
2109     case MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12:
2110       /* @tvlppageoff is not implemented in llvm-mc */
2111       op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_TLVOFF;
2112       break;
2113     default:
2114     case MachO::ARM64_RELOC_BRANCH26:
2115       op_info->VariantKind = LLVMDisassembler_VariantKind_None;
2116       break;
2117     }
2118     return 1;
2119   }
2120   return 0;
2121 }
2122
2123 // GuessCstringPointer is passed the address of what might be a pointer to a
2124 // literal string in a cstring section.  If that address is in a cstring section
2125 // it returns a pointer to that string.  Else it returns nullptr.
2126 static const char *GuessCstringPointer(uint64_t ReferenceValue,
2127                                        struct DisassembleInfo *info) {
2128   uint32_t LoadCommandCount = info->O->getHeader().ncmds;
2129   MachOObjectFile::LoadCommandInfo Load = info->O->getFirstLoadCommandInfo();
2130   for (unsigned I = 0;; ++I) {
2131     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
2132       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
2133       for (unsigned J = 0; J < Seg.nsects; ++J) {
2134         MachO::section_64 Sec = info->O->getSection64(Load, J);
2135         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
2136         if (section_type == MachO::S_CSTRING_LITERALS &&
2137             ReferenceValue >= Sec.addr &&
2138             ReferenceValue < Sec.addr + Sec.size) {
2139           uint64_t sect_offset = ReferenceValue - Sec.addr;
2140           uint64_t object_offset = Sec.offset + sect_offset;
2141           StringRef MachOContents = info->O->getData();
2142           uint64_t object_size = MachOContents.size();
2143           const char *object_addr = (const char *)MachOContents.data();
2144           if (object_offset < object_size) {
2145             const char *name = object_addr + object_offset;
2146             return name;
2147           } else {
2148             return nullptr;
2149           }
2150         }
2151       }
2152     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
2153       MachO::segment_command Seg = info->O->getSegmentLoadCommand(Load);
2154       for (unsigned J = 0; J < Seg.nsects; ++J) {
2155         MachO::section Sec = info->O->getSection(Load, J);
2156         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
2157         if (section_type == MachO::S_CSTRING_LITERALS &&
2158             ReferenceValue >= Sec.addr &&
2159             ReferenceValue < Sec.addr + Sec.size) {
2160           uint64_t sect_offset = ReferenceValue - Sec.addr;
2161           uint64_t object_offset = Sec.offset + sect_offset;
2162           StringRef MachOContents = info->O->getData();
2163           uint64_t object_size = MachOContents.size();
2164           const char *object_addr = (const char *)MachOContents.data();
2165           if (object_offset < object_size) {
2166             const char *name = object_addr + object_offset;
2167             return name;
2168           } else {
2169             return nullptr;
2170           }
2171         }
2172       }
2173     }
2174     if (I == LoadCommandCount - 1)
2175       break;
2176     else
2177       Load = info->O->getNextLoadCommandInfo(Load);
2178   }
2179   return nullptr;
2180 }
2181
2182 // GuessIndirectSymbol returns the name of the indirect symbol for the
2183 // ReferenceValue passed in or nullptr.  This is used when ReferenceValue maybe
2184 // an address of a symbol stub or a lazy or non-lazy pointer to associate the
2185 // symbol name being referenced by the stub or pointer.
2186 static const char *GuessIndirectSymbol(uint64_t ReferenceValue,
2187                                        struct DisassembleInfo *info) {
2188   uint32_t LoadCommandCount = info->O->getHeader().ncmds;
2189   MachOObjectFile::LoadCommandInfo Load = info->O->getFirstLoadCommandInfo();
2190   MachO::dysymtab_command Dysymtab = info->O->getDysymtabLoadCommand();
2191   MachO::symtab_command Symtab = info->O->getSymtabLoadCommand();
2192   for (unsigned I = 0;; ++I) {
2193     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
2194       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
2195       for (unsigned J = 0; J < Seg.nsects; ++J) {
2196         MachO::section_64 Sec = info->O->getSection64(Load, J);
2197         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
2198         if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
2199              section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
2200              section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
2201              section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
2202              section_type == MachO::S_SYMBOL_STUBS) &&
2203             ReferenceValue >= Sec.addr &&
2204             ReferenceValue < Sec.addr + Sec.size) {
2205           uint32_t stride;
2206           if (section_type == MachO::S_SYMBOL_STUBS)
2207             stride = Sec.reserved2;
2208           else
2209             stride = 8;
2210           if (stride == 0)
2211             return nullptr;
2212           uint32_t index = Sec.reserved1 + (ReferenceValue - Sec.addr) / stride;
2213           if (index < Dysymtab.nindirectsyms) {
2214             uint32_t indirect_symbol =
2215                 info->O->getIndirectSymbolTableEntry(Dysymtab, index);
2216             if (indirect_symbol < Symtab.nsyms) {
2217               symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol);
2218               SymbolRef Symbol = *Sym;
2219               StringRef SymName;
2220               Symbol.getName(SymName);
2221               const char *name = SymName.data();
2222               return name;
2223             }
2224           }
2225         }
2226       }
2227     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
2228       MachO::segment_command Seg = info->O->getSegmentLoadCommand(Load);
2229       for (unsigned J = 0; J < Seg.nsects; ++J) {
2230         MachO::section Sec = info->O->getSection(Load, J);
2231         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
2232         if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
2233              section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
2234              section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
2235              section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
2236              section_type == MachO::S_SYMBOL_STUBS) &&
2237             ReferenceValue >= Sec.addr &&
2238             ReferenceValue < Sec.addr + Sec.size) {
2239           uint32_t stride;
2240           if (section_type == MachO::S_SYMBOL_STUBS)
2241             stride = Sec.reserved2;
2242           else
2243             stride = 4;
2244           if (stride == 0)
2245             return nullptr;
2246           uint32_t index = Sec.reserved1 + (ReferenceValue - Sec.addr) / stride;
2247           if (index < Dysymtab.nindirectsyms) {
2248             uint32_t indirect_symbol =
2249                 info->O->getIndirectSymbolTableEntry(Dysymtab, index);
2250             if (indirect_symbol < Symtab.nsyms) {
2251               symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol);
2252               SymbolRef Symbol = *Sym;
2253               StringRef SymName;
2254               Symbol.getName(SymName);
2255               const char *name = SymName.data();
2256               return name;
2257             }
2258           }
2259         }
2260       }
2261     }
2262     if (I == LoadCommandCount - 1)
2263       break;
2264     else
2265       Load = info->O->getNextLoadCommandInfo(Load);
2266   }
2267   return nullptr;
2268 }
2269
2270 // method_reference() is called passing it the ReferenceName that might be
2271 // a reference it to an Objective-C method call.  If so then it allocates and
2272 // assembles a method call string with the values last seen and saved in
2273 // the DisassembleInfo's class_name and selector_name fields.  This is saved
2274 // into the method field of the info and any previous string is free'ed.
2275 // Then the class_name field in the info is set to nullptr.  The method call
2276 // string is set into ReferenceName and ReferenceType is set to
2277 // LLVMDisassembler_ReferenceType_Out_Objc_Message.  If this not a method call
2278 // then both ReferenceType and ReferenceName are left unchanged.
2279 static void method_reference(struct DisassembleInfo *info,
2280                              uint64_t *ReferenceType,
2281                              const char **ReferenceName) {
2282   unsigned int Arch = info->O->getArch();
2283   if (*ReferenceName != nullptr) {
2284     if (strcmp(*ReferenceName, "_objc_msgSend") == 0) {
2285       if (info->selector_name != nullptr) {
2286         if (info->method != nullptr)
2287           free(info->method);
2288         if (info->class_name != nullptr) {
2289           info->method = (char *)malloc(5 + strlen(info->class_name) +
2290                                         strlen(info->selector_name));
2291           if (info->method != nullptr) {
2292             strcpy(info->method, "+[");
2293             strcat(info->method, info->class_name);
2294             strcat(info->method, " ");
2295             strcat(info->method, info->selector_name);
2296             strcat(info->method, "]");
2297             *ReferenceName = info->method;
2298             *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message;
2299           }
2300         } else {
2301           info->method = (char *)malloc(9 + strlen(info->selector_name));
2302           if (info->method != nullptr) {
2303             if (Arch == Triple::x86_64)
2304               strcpy(info->method, "-[%rdi ");
2305             else if (Arch == Triple::aarch64)
2306               strcpy(info->method, "-[x0 ");
2307             else
2308               strcpy(info->method, "-[r? ");
2309             strcat(info->method, info->selector_name);
2310             strcat(info->method, "]");
2311             *ReferenceName = info->method;
2312             *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message;
2313           }
2314         }
2315         info->class_name = nullptr;
2316       }
2317     } else if (strcmp(*ReferenceName, "_objc_msgSendSuper2") == 0) {
2318       if (info->selector_name != nullptr) {
2319         if (info->method != nullptr)
2320           free(info->method);
2321         info->method = (char *)malloc(17 + strlen(info->selector_name));
2322         if (info->method != nullptr) {
2323           if (Arch == Triple::x86_64)
2324             strcpy(info->method, "-[[%rdi super] ");
2325           else if (Arch == Triple::aarch64)
2326             strcpy(info->method, "-[[x0 super] ");
2327           else
2328             strcpy(info->method, "-[[r? super] ");
2329           strcat(info->method, info->selector_name);
2330           strcat(info->method, "]");
2331           *ReferenceName = info->method;
2332           *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message;
2333         }
2334         info->class_name = nullptr;
2335       }
2336     }
2337   }
2338 }
2339
2340 // GuessPointerPointer() is passed the address of what might be a pointer to
2341 // a reference to an Objective-C class, selector, message ref or cfstring.
2342 // If so the value of the pointer is returned and one of the booleans are set
2343 // to true.  If not zero is returned and all the booleans are set to false.
2344 static uint64_t GuessPointerPointer(uint64_t ReferenceValue,
2345                                     struct DisassembleInfo *info,
2346                                     bool &classref, bool &selref, bool &msgref,
2347                                     bool &cfstring) {
2348   classref = false;
2349   selref = false;
2350   msgref = false;
2351   cfstring = false;
2352   uint32_t LoadCommandCount = info->O->getHeader().ncmds;
2353   MachOObjectFile::LoadCommandInfo Load = info->O->getFirstLoadCommandInfo();
2354   for (unsigned I = 0;; ++I) {
2355     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
2356       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
2357       for (unsigned J = 0; J < Seg.nsects; ++J) {
2358         MachO::section_64 Sec = info->O->getSection64(Load, J);
2359         if ((strncmp(Sec.sectname, "__objc_selrefs", 16) == 0 ||
2360              strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 ||
2361              strncmp(Sec.sectname, "__objc_superrefs", 16) == 0 ||
2362              strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 ||
2363              strncmp(Sec.sectname, "__cfstring", 16) == 0) &&
2364             ReferenceValue >= Sec.addr &&
2365             ReferenceValue < Sec.addr + Sec.size) {
2366           uint64_t sect_offset = ReferenceValue - Sec.addr;
2367           uint64_t object_offset = Sec.offset + sect_offset;
2368           StringRef MachOContents = info->O->getData();
2369           uint64_t object_size = MachOContents.size();
2370           const char *object_addr = (const char *)MachOContents.data();
2371           if (object_offset < object_size) {
2372             uint64_t pointer_value;
2373             memcpy(&pointer_value, object_addr + object_offset,
2374                    sizeof(uint64_t));
2375             if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
2376               sys::swapByteOrder(pointer_value);
2377             if (strncmp(Sec.sectname, "__objc_selrefs", 16) == 0)
2378               selref = true;
2379             else if (strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 ||
2380                      strncmp(Sec.sectname, "__objc_superrefs", 16) == 0)
2381               classref = true;
2382             else if (strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 &&
2383                      ReferenceValue + 8 < Sec.addr + Sec.size) {
2384               msgref = true;
2385               memcpy(&pointer_value, object_addr + object_offset + 8,
2386                      sizeof(uint64_t));
2387               if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
2388                 sys::swapByteOrder(pointer_value);
2389             } else if (strncmp(Sec.sectname, "__cfstring", 16) == 0)
2390               cfstring = true;
2391             return pointer_value;
2392           } else {
2393             return 0;
2394           }
2395         }
2396       }
2397     }
2398     // TODO: Look for LC_SEGMENT for 32-bit Mach-O files.
2399     if (I == LoadCommandCount - 1)
2400       break;
2401     else
2402       Load = info->O->getNextLoadCommandInfo(Load);
2403   }
2404   return 0;
2405 }
2406
2407 // get_pointer_64 returns a pointer to the bytes in the object file at the
2408 // Address from a section in the Mach-O file.  And indirectly returns the
2409 // offset into the section, number of bytes left in the section past the offset
2410 // and which section is was being referenced.  If the Address is not in a
2411 // section nullptr is returned.
2412 static const char *get_pointer_64(uint64_t Address, uint32_t &offset,
2413                                   uint32_t &left, SectionRef &S,
2414                                   DisassembleInfo *info,
2415                                   bool objc_only = false) {
2416   offset = 0;
2417   left = 0;
2418   S = SectionRef();
2419   for (unsigned SectIdx = 0; SectIdx != info->Sections->size(); SectIdx++) {
2420     uint64_t SectAddress = ((*(info->Sections))[SectIdx]).getAddress();
2421     uint64_t SectSize = ((*(info->Sections))[SectIdx]).getSize();
2422     if (objc_only) {
2423       StringRef SectName;
2424       ((*(info->Sections))[SectIdx]).getName(SectName);
2425       DataRefImpl Ref = ((*(info->Sections))[SectIdx]).getRawDataRefImpl();
2426       StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
2427       if (SegName != "__OBJC" && SectName != "__cstring")
2428         continue;
2429     }
2430     if (Address >= SectAddress && Address < SectAddress + SectSize) {
2431       S = (*(info->Sections))[SectIdx];
2432       offset = Address - SectAddress;
2433       left = SectSize - offset;
2434       StringRef SectContents;
2435       ((*(info->Sections))[SectIdx]).getContents(SectContents);
2436       return SectContents.data() + offset;
2437     }
2438   }
2439   return nullptr;
2440 }
2441
2442 static const char *get_pointer_32(uint32_t Address, uint32_t &offset,
2443                                   uint32_t &left, SectionRef &S,
2444                                   DisassembleInfo *info,
2445                                   bool objc_only = false) {
2446   return get_pointer_64(Address, offset, left, S, info, objc_only);
2447 }
2448
2449 // get_symbol_64() returns the name of a symbol (or nullptr) and the address of
2450 // the symbol indirectly through n_value. Based on the relocation information
2451 // for the specified section offset in the specified section reference.
2452 // If no relocation information is found and a non-zero ReferenceValue for the
2453 // symbol is passed, look up that address in the info's AddrMap.
2454 static const char *
2455 get_symbol_64(uint32_t sect_offset, SectionRef S, DisassembleInfo *info,
2456               uint64_t &n_value,
2457               uint64_t ReferenceValue = UnknownAddressOrSize) {
2458   n_value = 0;
2459   if (!info->verbose)
2460     return nullptr;
2461
2462   // See if there is an external relocation entry at the sect_offset.
2463   bool reloc_found = false;
2464   DataRefImpl Rel;
2465   MachO::any_relocation_info RE;
2466   bool isExtern = false;
2467   SymbolRef Symbol;
2468   for (const RelocationRef &Reloc : S.relocations()) {
2469     uint64_t RelocOffset;
2470     Reloc.getOffset(RelocOffset);
2471     if (RelocOffset == sect_offset) {
2472       Rel = Reloc.getRawDataRefImpl();
2473       RE = info->O->getRelocation(Rel);
2474       if (info->O->isRelocationScattered(RE))
2475         continue;
2476       isExtern = info->O->getPlainRelocationExternal(RE);
2477       if (isExtern) {
2478         symbol_iterator RelocSym = Reloc.getSymbol();
2479         Symbol = *RelocSym;
2480       }
2481       reloc_found = true;
2482       break;
2483     }
2484   }
2485   // If there is an external relocation entry for a symbol in this section
2486   // at this section_offset then use that symbol's value for the n_value
2487   // and return its name.
2488   const char *SymbolName = nullptr;
2489   if (reloc_found && isExtern) {
2490     Symbol.getAddress(n_value);
2491     if (n_value == UnknownAddressOrSize)
2492       n_value = 0;
2493     StringRef name;
2494     Symbol.getName(name);
2495     if (!name.empty()) {
2496       SymbolName = name.data();
2497       return SymbolName;
2498     }
2499   }
2500
2501   // TODO: For fully linked images, look through the external relocation
2502   // entries off the dynamic symtab command. For these the r_offset is from the
2503   // start of the first writeable segment in the Mach-O file.  So the offset
2504   // to this section from that segment is passed to this routine by the caller,
2505   // as the database_offset. Which is the difference of the section's starting
2506   // address and the first writable segment.
2507   //
2508   // NOTE: need add passing the database_offset to this routine.
2509
2510   // We did not find an external relocation entry so look up the ReferenceValue
2511   // as an address of a symbol and if found return that symbol's name.
2512   if (ReferenceValue != UnknownAddressOrSize)
2513     SymbolName = GuessSymbolName(ReferenceValue, info->AddrMap);
2514
2515   return SymbolName;
2516 }
2517
2518 static const char *get_symbol_32(uint32_t sect_offset, SectionRef S,
2519                                  DisassembleInfo *info,
2520                                  uint32_t ReferenceValue) {
2521   uint64_t n_value64;
2522   return get_symbol_64(sect_offset, S, info, n_value64, ReferenceValue);
2523 }
2524
2525 // These are structs in the Objective-C meta data and read to produce the
2526 // comments for disassembly.  While these are part of the ABI they are no
2527 // public defintions.  So the are here not in include/llvm/Support/MachO.h .
2528
2529 // The cfstring object in a 64-bit Mach-O file.
2530 struct cfstring64_t {
2531   uint64_t isa;        // class64_t * (64-bit pointer)
2532   uint64_t flags;      // flag bits
2533   uint64_t characters; // char * (64-bit pointer)
2534   uint64_t length;     // number of non-NULL characters in above
2535 };
2536
2537 // The class object in a 64-bit Mach-O file.
2538 struct class64_t {
2539   uint64_t isa;        // class64_t * (64-bit pointer)
2540   uint64_t superclass; // class64_t * (64-bit pointer)
2541   uint64_t cache;      // Cache (64-bit pointer)
2542   uint64_t vtable;     // IMP * (64-bit pointer)
2543   uint64_t data;       // class_ro64_t * (64-bit pointer)
2544 };
2545
2546 struct class32_t {
2547   uint32_t isa;        /* class32_t * (32-bit pointer) */
2548   uint32_t superclass; /* class32_t * (32-bit pointer) */
2549   uint32_t cache;      /* Cache (32-bit pointer) */
2550   uint32_t vtable;     /* IMP * (32-bit pointer) */
2551   uint32_t data;       /* class_ro32_t * (32-bit pointer) */
2552 };
2553
2554 struct class_ro64_t {
2555   uint32_t flags;
2556   uint32_t instanceStart;
2557   uint32_t instanceSize;
2558   uint32_t reserved;
2559   uint64_t ivarLayout;     // const uint8_t * (64-bit pointer)
2560   uint64_t name;           // const char * (64-bit pointer)
2561   uint64_t baseMethods;    // const method_list_t * (64-bit pointer)
2562   uint64_t baseProtocols;  // const protocol_list_t * (64-bit pointer)
2563   uint64_t ivars;          // const ivar_list_t * (64-bit pointer)
2564   uint64_t weakIvarLayout; // const uint8_t * (64-bit pointer)
2565   uint64_t baseProperties; // const struct objc_property_list (64-bit pointer)
2566 };
2567
2568 struct class_ro32_t {
2569   uint32_t flags;
2570   uint32_t instanceStart;
2571   uint32_t instanceSize;
2572   uint32_t ivarLayout;     /* const uint8_t * (32-bit pointer) */
2573   uint32_t name;           /* const char * (32-bit pointer) */
2574   uint32_t baseMethods;    /* const method_list_t * (32-bit pointer) */
2575   uint32_t baseProtocols;  /* const protocol_list_t * (32-bit pointer) */
2576   uint32_t ivars;          /* const ivar_list_t * (32-bit pointer) */
2577   uint32_t weakIvarLayout; /* const uint8_t * (32-bit pointer) */
2578   uint32_t baseProperties; /* const struct objc_property_list *
2579                                                    (32-bit pointer) */
2580 };
2581
2582 /* Values for class_ro{64,32}_t->flags */
2583 #define RO_META (1 << 0)
2584 #define RO_ROOT (1 << 1)
2585 #define RO_HAS_CXX_STRUCTORS (1 << 2)
2586
2587 struct method_list64_t {
2588   uint32_t entsize;
2589   uint32_t count;
2590   /* struct method64_t first;  These structures follow inline */
2591 };
2592
2593 struct method_list32_t {
2594   uint32_t entsize;
2595   uint32_t count;
2596   /* struct method32_t first;  These structures follow inline */
2597 };
2598
2599 struct method64_t {
2600   uint64_t name;  /* SEL (64-bit pointer) */
2601   uint64_t types; /* const char * (64-bit pointer) */
2602   uint64_t imp;   /* IMP (64-bit pointer) */
2603 };
2604
2605 struct method32_t {
2606   uint32_t name;  /* SEL (32-bit pointer) */
2607   uint32_t types; /* const char * (32-bit pointer) */
2608   uint32_t imp;   /* IMP (32-bit pointer) */
2609 };
2610
2611 struct protocol_list64_t {
2612   uint64_t count; /* uintptr_t (a 64-bit value) */
2613   /* struct protocol64_t * list[0];  These pointers follow inline */
2614 };
2615
2616 struct protocol_list32_t {
2617   uint32_t count; /* uintptr_t (a 32-bit value) */
2618   /* struct protocol32_t * list[0];  These pointers follow inline */
2619 };
2620
2621 struct protocol64_t {
2622   uint64_t isa;                     /* id * (64-bit pointer) */
2623   uint64_t name;                    /* const char * (64-bit pointer) */
2624   uint64_t protocols;               /* struct protocol_list64_t *
2625                                                     (64-bit pointer) */
2626   uint64_t instanceMethods;         /* method_list_t * (64-bit pointer) */
2627   uint64_t classMethods;            /* method_list_t * (64-bit pointer) */
2628   uint64_t optionalInstanceMethods; /* method_list_t * (64-bit pointer) */
2629   uint64_t optionalClassMethods;    /* method_list_t * (64-bit pointer) */
2630   uint64_t instanceProperties;      /* struct objc_property_list *
2631                                                        (64-bit pointer) */
2632 };
2633
2634 struct protocol32_t {
2635   uint32_t isa;                     /* id * (32-bit pointer) */
2636   uint32_t name;                    /* const char * (32-bit pointer) */
2637   uint32_t protocols;               /* struct protocol_list_t *
2638                                                     (32-bit pointer) */
2639   uint32_t instanceMethods;         /* method_list_t * (32-bit pointer) */
2640   uint32_t classMethods;            /* method_list_t * (32-bit pointer) */
2641   uint32_t optionalInstanceMethods; /* method_list_t * (32-bit pointer) */
2642   uint32_t optionalClassMethods;    /* method_list_t * (32-bit pointer) */
2643   uint32_t instanceProperties;      /* struct objc_property_list *
2644                                                        (32-bit pointer) */
2645 };
2646
2647 struct ivar_list64_t {
2648   uint32_t entsize;
2649   uint32_t count;
2650   /* struct ivar64_t first;  These structures follow inline */
2651 };
2652
2653 struct ivar_list32_t {
2654   uint32_t entsize;
2655   uint32_t count;
2656   /* struct ivar32_t first;  These structures follow inline */
2657 };
2658
2659 struct ivar64_t {
2660   uint64_t offset; /* uintptr_t * (64-bit pointer) */
2661   uint64_t name;   /* const char * (64-bit pointer) */
2662   uint64_t type;   /* const char * (64-bit pointer) */
2663   uint32_t alignment;
2664   uint32_t size;
2665 };
2666
2667 struct ivar32_t {
2668   uint32_t offset; /* uintptr_t * (32-bit pointer) */
2669   uint32_t name;   /* const char * (32-bit pointer) */
2670   uint32_t type;   /* const char * (32-bit pointer) */
2671   uint32_t alignment;
2672   uint32_t size;
2673 };
2674
2675 struct objc_property_list64 {
2676   uint32_t entsize;
2677   uint32_t count;
2678   /* struct objc_property64 first;  These structures follow inline */
2679 };
2680
2681 struct objc_property_list32 {
2682   uint32_t entsize;
2683   uint32_t count;
2684   /* struct objc_property32 first;  These structures follow inline */
2685 };
2686
2687 struct objc_property64 {
2688   uint64_t name;       /* const char * (64-bit pointer) */
2689   uint64_t attributes; /* const char * (64-bit pointer) */
2690 };
2691
2692 struct objc_property32 {
2693   uint32_t name;       /* const char * (32-bit pointer) */
2694   uint32_t attributes; /* const char * (32-bit pointer) */
2695 };
2696
2697 struct category64_t {
2698   uint64_t name;               /* const char * (64-bit pointer) */
2699   uint64_t cls;                /* struct class_t * (64-bit pointer) */
2700   uint64_t instanceMethods;    /* struct method_list_t * (64-bit pointer) */
2701   uint64_t classMethods;       /* struct method_list_t * (64-bit pointer) */
2702   uint64_t protocols;          /* struct protocol_list_t * (64-bit pointer) */
2703   uint64_t instanceProperties; /* struct objc_property_list *
2704                                   (64-bit pointer) */
2705 };
2706
2707 struct category32_t {
2708   uint32_t name;               /* const char * (32-bit pointer) */
2709   uint32_t cls;                /* struct class_t * (32-bit pointer) */
2710   uint32_t instanceMethods;    /* struct method_list_t * (32-bit pointer) */
2711   uint32_t classMethods;       /* struct method_list_t * (32-bit pointer) */
2712   uint32_t protocols;          /* struct protocol_list_t * (32-bit pointer) */
2713   uint32_t instanceProperties; /* struct objc_property_list *
2714                                   (32-bit pointer) */
2715 };
2716
2717 struct objc_image_info64 {
2718   uint32_t version;
2719   uint32_t flags;
2720 };
2721 struct objc_image_info32 {
2722   uint32_t version;
2723   uint32_t flags;
2724 };
2725 struct imageInfo_t {
2726   uint32_t version;
2727   uint32_t flags;
2728 };
2729 /* masks for objc_image_info.flags */
2730 #define OBJC_IMAGE_IS_REPLACEMENT (1 << 0)
2731 #define OBJC_IMAGE_SUPPORTS_GC (1 << 1)
2732
2733 struct message_ref64 {
2734   uint64_t imp; /* IMP (64-bit pointer) */
2735   uint64_t sel; /* SEL (64-bit pointer) */
2736 };
2737
2738 struct message_ref32 {
2739   uint32_t imp; /* IMP (32-bit pointer) */
2740   uint32_t sel; /* SEL (32-bit pointer) */
2741 };
2742
2743 // Objective-C 1 (32-bit only) meta data structs.
2744
2745 struct objc_module_t {
2746   uint32_t version;
2747   uint32_t size;
2748   uint32_t name;   /* char * (32-bit pointer) */
2749   uint32_t symtab; /* struct objc_symtab * (32-bit pointer) */
2750 };
2751
2752 struct objc_symtab_t {
2753   uint32_t sel_ref_cnt;
2754   uint32_t refs; /* SEL * (32-bit pointer) */
2755   uint16_t cls_def_cnt;
2756   uint16_t cat_def_cnt;
2757   // uint32_t defs[1];        /* void * (32-bit pointer) variable size */
2758 };
2759
2760 struct objc_class_t {
2761   uint32_t isa;         /* struct objc_class * (32-bit pointer) */
2762   uint32_t super_class; /* struct objc_class * (32-bit pointer) */
2763   uint32_t name;        /* const char * (32-bit pointer) */
2764   int32_t version;
2765   int32_t info;
2766   int32_t instance_size;
2767   uint32_t ivars;       /* struct objc_ivar_list * (32-bit pointer) */
2768   uint32_t methodLists; /* struct objc_method_list ** (32-bit pointer) */
2769   uint32_t cache;       /* struct objc_cache * (32-bit pointer) */
2770   uint32_t protocols;   /* struct objc_protocol_list * (32-bit pointer) */
2771 };
2772
2773 #define CLS_GETINFO(cls, infomask) ((cls)->info & (infomask))
2774 // class is not a metaclass
2775 #define CLS_CLASS 0x1
2776 // class is a metaclass
2777 #define CLS_META 0x2
2778
2779 struct objc_category_t {
2780   uint32_t category_name;    /* char * (32-bit pointer) */
2781   uint32_t class_name;       /* char * (32-bit pointer) */
2782   uint32_t instance_methods; /* struct objc_method_list * (32-bit pointer) */
2783   uint32_t class_methods;    /* struct objc_method_list * (32-bit pointer) */
2784   uint32_t protocols;        /* struct objc_protocol_list * (32-bit ptr) */
2785 };
2786
2787 struct objc_ivar_t {
2788   uint32_t ivar_name; /* char * (32-bit pointer) */
2789   uint32_t ivar_type; /* char * (32-bit pointer) */
2790   int32_t ivar_offset;
2791 };
2792
2793 struct objc_ivar_list_t {
2794   int32_t ivar_count;
2795   // struct objc_ivar_t ivar_list[1];          /* variable length structure */
2796 };
2797
2798 struct objc_method_list_t {
2799   uint32_t obsolete; /* struct objc_method_list * (32-bit pointer) */
2800   int32_t method_count;
2801   // struct objc_method_t method_list[1];      /* variable length structure */
2802 };
2803
2804 struct objc_method_t {
2805   uint32_t method_name;  /* SEL, aka struct objc_selector * (32-bit pointer) */
2806   uint32_t method_types; /* char * (32-bit pointer) */
2807   uint32_t method_imp;   /* IMP, aka function pointer, (*IMP)(id, SEL, ...)
2808                             (32-bit pointer) */
2809 };
2810
2811 struct objc_protocol_list_t {
2812   uint32_t next; /* struct objc_protocol_list * (32-bit pointer) */
2813   int32_t count;
2814   // uint32_t list[1];   /* Protocol *, aka struct objc_protocol_t *
2815   //                        (32-bit pointer) */
2816 };
2817
2818 struct objc_protocol_t {
2819   uint32_t isa;              /* struct objc_class * (32-bit pointer) */
2820   uint32_t protocol_name;    /* char * (32-bit pointer) */
2821   uint32_t protocol_list;    /* struct objc_protocol_list * (32-bit pointer) */
2822   uint32_t instance_methods; /* struct objc_method_description_list *
2823                                 (32-bit pointer) */
2824   uint32_t class_methods;    /* struct objc_method_description_list *
2825                                 (32-bit pointer) */
2826 };
2827
2828 struct objc_method_description_list_t {
2829   int32_t count;
2830   // struct objc_method_description_t list[1];
2831 };
2832
2833 struct objc_method_description_t {
2834   uint32_t name;  /* SEL, aka struct objc_selector * (32-bit pointer) */
2835   uint32_t types; /* char * (32-bit pointer) */
2836 };
2837
2838 inline void swapStruct(struct cfstring64_t &cfs) {
2839   sys::swapByteOrder(cfs.isa);
2840   sys::swapByteOrder(cfs.flags);
2841   sys::swapByteOrder(cfs.characters);
2842   sys::swapByteOrder(cfs.length);
2843 }
2844
2845 inline void swapStruct(struct class64_t &c) {
2846   sys::swapByteOrder(c.isa);
2847   sys::swapByteOrder(c.superclass);
2848   sys::swapByteOrder(c.cache);
2849   sys::swapByteOrder(c.vtable);
2850   sys::swapByteOrder(c.data);
2851 }
2852
2853 inline void swapStruct(struct class32_t &c) {
2854   sys::swapByteOrder(c.isa);
2855   sys::swapByteOrder(c.superclass);
2856   sys::swapByteOrder(c.cache);
2857   sys::swapByteOrder(c.vtable);
2858   sys::swapByteOrder(c.data);
2859 }
2860
2861 inline void swapStruct(struct class_ro64_t &cro) {
2862   sys::swapByteOrder(cro.flags);
2863   sys::swapByteOrder(cro.instanceStart);
2864   sys::swapByteOrder(cro.instanceSize);
2865   sys::swapByteOrder(cro.reserved);
2866   sys::swapByteOrder(cro.ivarLayout);
2867   sys::swapByteOrder(cro.name);
2868   sys::swapByteOrder(cro.baseMethods);
2869   sys::swapByteOrder(cro.baseProtocols);
2870   sys::swapByteOrder(cro.ivars);
2871   sys::swapByteOrder(cro.weakIvarLayout);
2872   sys::swapByteOrder(cro.baseProperties);
2873 }
2874
2875 inline void swapStruct(struct class_ro32_t &cro) {
2876   sys::swapByteOrder(cro.flags);
2877   sys::swapByteOrder(cro.instanceStart);
2878   sys::swapByteOrder(cro.instanceSize);
2879   sys::swapByteOrder(cro.ivarLayout);
2880   sys::swapByteOrder(cro.name);
2881   sys::swapByteOrder(cro.baseMethods);
2882   sys::swapByteOrder(cro.baseProtocols);
2883   sys::swapByteOrder(cro.ivars);
2884   sys::swapByteOrder(cro.weakIvarLayout);
2885   sys::swapByteOrder(cro.baseProperties);
2886 }
2887
2888 inline void swapStruct(struct method_list64_t &ml) {
2889   sys::swapByteOrder(ml.entsize);
2890   sys::swapByteOrder(ml.count);
2891 }
2892
2893 inline void swapStruct(struct method_list32_t &ml) {
2894   sys::swapByteOrder(ml.entsize);
2895   sys::swapByteOrder(ml.count);
2896 }
2897
2898 inline void swapStruct(struct method64_t &m) {
2899   sys::swapByteOrder(m.name);
2900   sys::swapByteOrder(m.types);
2901   sys::swapByteOrder(m.imp);
2902 }
2903
2904 inline void swapStruct(struct method32_t &m) {
2905   sys::swapByteOrder(m.name);
2906   sys::swapByteOrder(m.types);
2907   sys::swapByteOrder(m.imp);
2908 }
2909
2910 inline void swapStruct(struct protocol_list64_t &pl) {
2911   sys::swapByteOrder(pl.count);
2912 }
2913
2914 inline void swapStruct(struct protocol_list32_t &pl) {
2915   sys::swapByteOrder(pl.count);
2916 }
2917
2918 inline void swapStruct(struct protocol64_t &p) {
2919   sys::swapByteOrder(p.isa);
2920   sys::swapByteOrder(p.name);
2921   sys::swapByteOrder(p.protocols);
2922   sys::swapByteOrder(p.instanceMethods);
2923   sys::swapByteOrder(p.classMethods);
2924   sys::swapByteOrder(p.optionalInstanceMethods);
2925   sys::swapByteOrder(p.optionalClassMethods);
2926   sys::swapByteOrder(p.instanceProperties);
2927 }
2928
2929 inline void swapStruct(struct protocol32_t &p) {
2930   sys::swapByteOrder(p.isa);
2931   sys::swapByteOrder(p.name);
2932   sys::swapByteOrder(p.protocols);
2933   sys::swapByteOrder(p.instanceMethods);
2934   sys::swapByteOrder(p.classMethods);
2935   sys::swapByteOrder(p.optionalInstanceMethods);
2936   sys::swapByteOrder(p.optionalClassMethods);
2937   sys::swapByteOrder(p.instanceProperties);
2938 }
2939
2940 inline void swapStruct(struct ivar_list64_t &il) {
2941   sys::swapByteOrder(il.entsize);
2942   sys::swapByteOrder(il.count);
2943 }
2944
2945 inline void swapStruct(struct ivar_list32_t &il) {
2946   sys::swapByteOrder(il.entsize);
2947   sys::swapByteOrder(il.count);
2948 }
2949
2950 inline void swapStruct(struct ivar64_t &i) {
2951   sys::swapByteOrder(i.offset);
2952   sys::swapByteOrder(i.name);
2953   sys::swapByteOrder(i.type);
2954   sys::swapByteOrder(i.alignment);
2955   sys::swapByteOrder(i.size);
2956 }
2957
2958 inline void swapStruct(struct ivar32_t &i) {
2959   sys::swapByteOrder(i.offset);
2960   sys::swapByteOrder(i.name);
2961   sys::swapByteOrder(i.type);
2962   sys::swapByteOrder(i.alignment);
2963   sys::swapByteOrder(i.size);
2964 }
2965
2966 inline void swapStruct(struct objc_property_list64 &pl) {
2967   sys::swapByteOrder(pl.entsize);
2968   sys::swapByteOrder(pl.count);
2969 }
2970
2971 inline void swapStruct(struct objc_property_list32 &pl) {
2972   sys::swapByteOrder(pl.entsize);
2973   sys::swapByteOrder(pl.count);
2974 }
2975
2976 inline void swapStruct(struct objc_property64 &op) {
2977   sys::swapByteOrder(op.name);
2978   sys::swapByteOrder(op.attributes);
2979 }
2980
2981 inline void swapStruct(struct objc_property32 &op) {
2982   sys::swapByteOrder(op.name);
2983   sys::swapByteOrder(op.attributes);
2984 }
2985
2986 inline void swapStruct(struct category64_t &c) {
2987   sys::swapByteOrder(c.name);
2988   sys::swapByteOrder(c.cls);
2989   sys::swapByteOrder(c.instanceMethods);
2990   sys::swapByteOrder(c.classMethods);
2991   sys::swapByteOrder(c.protocols);
2992   sys::swapByteOrder(c.instanceProperties);
2993 }
2994
2995 inline void swapStruct(struct category32_t &c) {
2996   sys::swapByteOrder(c.name);
2997   sys::swapByteOrder(c.cls);
2998   sys::swapByteOrder(c.instanceMethods);
2999   sys::swapByteOrder(c.classMethods);
3000   sys::swapByteOrder(c.protocols);
3001   sys::swapByteOrder(c.instanceProperties);
3002 }
3003
3004 inline void swapStruct(struct objc_image_info64 &o) {
3005   sys::swapByteOrder(o.version);
3006   sys::swapByteOrder(o.flags);
3007 }
3008
3009 inline void swapStruct(struct objc_image_info32 &o) {
3010   sys::swapByteOrder(o.version);
3011   sys::swapByteOrder(o.flags);
3012 }
3013
3014 inline void swapStruct(struct imageInfo_t &o) {
3015   sys::swapByteOrder(o.version);
3016   sys::swapByteOrder(o.flags);
3017 }
3018
3019 inline void swapStruct(struct message_ref64 &mr) {
3020   sys::swapByteOrder(mr.imp);
3021   sys::swapByteOrder(mr.sel);
3022 }
3023
3024 inline void swapStruct(struct message_ref32 &mr) {
3025   sys::swapByteOrder(mr.imp);
3026   sys::swapByteOrder(mr.sel);
3027 }
3028
3029 inline void swapStruct(struct objc_module_t &module) {
3030   sys::swapByteOrder(module.version);
3031   sys::swapByteOrder(module.size);
3032   sys::swapByteOrder(module.name);
3033   sys::swapByteOrder(module.symtab);
3034 }
3035
3036 inline void swapStruct(struct objc_symtab_t &symtab) {
3037   sys::swapByteOrder(symtab.sel_ref_cnt);
3038   sys::swapByteOrder(symtab.refs);
3039   sys::swapByteOrder(symtab.cls_def_cnt);
3040   sys::swapByteOrder(symtab.cat_def_cnt);
3041 }
3042
3043 inline void swapStruct(struct objc_class_t &objc_class) {
3044   sys::swapByteOrder(objc_class.isa);
3045   sys::swapByteOrder(objc_class.super_class);
3046   sys::swapByteOrder(objc_class.name);
3047   sys::swapByteOrder(objc_class.version);
3048   sys::swapByteOrder(objc_class.info);
3049   sys::swapByteOrder(objc_class.instance_size);
3050   sys::swapByteOrder(objc_class.ivars);
3051   sys::swapByteOrder(objc_class.methodLists);
3052   sys::swapByteOrder(objc_class.cache);
3053   sys::swapByteOrder(objc_class.protocols);
3054 }
3055
3056 inline void swapStruct(struct objc_category_t &objc_category) {
3057   sys::swapByteOrder(objc_category.category_name);
3058   sys::swapByteOrder(objc_category.class_name);
3059   sys::swapByteOrder(objc_category.instance_methods);
3060   sys::swapByteOrder(objc_category.class_methods);
3061   sys::swapByteOrder(objc_category.protocols);
3062 }
3063
3064 inline void swapStruct(struct objc_ivar_list_t &objc_ivar_list) {
3065   sys::swapByteOrder(objc_ivar_list.ivar_count);
3066 }
3067
3068 inline void swapStruct(struct objc_ivar_t &objc_ivar) {
3069   sys::swapByteOrder(objc_ivar.ivar_name);
3070   sys::swapByteOrder(objc_ivar.ivar_type);
3071   sys::swapByteOrder(objc_ivar.ivar_offset);
3072 }
3073
3074 inline void swapStruct(struct objc_method_list_t &method_list) {
3075   sys::swapByteOrder(method_list.obsolete);
3076   sys::swapByteOrder(method_list.method_count);
3077 }
3078
3079 inline void swapStruct(struct objc_method_t &method) {
3080   sys::swapByteOrder(method.method_name);
3081   sys::swapByteOrder(method.method_types);
3082   sys::swapByteOrder(method.method_imp);
3083 }
3084
3085 inline void swapStruct(struct objc_protocol_list_t &protocol_list) {
3086   sys::swapByteOrder(protocol_list.next);
3087   sys::swapByteOrder(protocol_list.count);
3088 }
3089
3090 inline void swapStruct(struct objc_protocol_t &protocol) {
3091   sys::swapByteOrder(protocol.isa);
3092   sys::swapByteOrder(protocol.protocol_name);
3093   sys::swapByteOrder(protocol.protocol_list);
3094   sys::swapByteOrder(protocol.instance_methods);
3095   sys::swapByteOrder(protocol.class_methods);
3096 }
3097
3098 inline void swapStruct(struct objc_method_description_list_t &mdl) {
3099   sys::swapByteOrder(mdl.count);
3100 }
3101
3102 inline void swapStruct(struct objc_method_description_t &md) {
3103   sys::swapByteOrder(md.name);
3104   sys::swapByteOrder(md.types);
3105 }
3106
3107 static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue,
3108                                                  struct DisassembleInfo *info);
3109
3110 // get_objc2_64bit_class_name() is used for disassembly and is passed a pointer
3111 // to an Objective-C class and returns the class name.  It is also passed the
3112 // address of the pointer, so when the pointer is zero as it can be in an .o
3113 // file, that is used to look for an external relocation entry with a symbol
3114 // name.
3115 static const char *get_objc2_64bit_class_name(uint64_t pointer_value,
3116                                               uint64_t ReferenceValue,
3117                                               struct DisassembleInfo *info) {
3118   const char *r;
3119   uint32_t offset, left;
3120   SectionRef S;
3121
3122   // The pointer_value can be 0 in an object file and have a relocation
3123   // entry for the class symbol at the ReferenceValue (the address of the
3124   // pointer).
3125   if (pointer_value == 0) {
3126     r = get_pointer_64(ReferenceValue, offset, left, S, info);
3127     if (r == nullptr || left < sizeof(uint64_t))
3128       return nullptr;
3129     uint64_t n_value;
3130     const char *symbol_name = get_symbol_64(offset, S, info, n_value);
3131     if (symbol_name == nullptr)
3132       return nullptr;
3133     const char *class_name = strrchr(symbol_name, '$');
3134     if (class_name != nullptr && class_name[1] == '_' && class_name[2] != '\0')
3135       return class_name + 2;
3136     else
3137       return nullptr;
3138   }
3139
3140   // The case were the pointer_value is non-zero and points to a class defined
3141   // in this Mach-O file.
3142   r = get_pointer_64(pointer_value, offset, left, S, info);
3143   if (r == nullptr || left < sizeof(struct class64_t))
3144     return nullptr;
3145   struct class64_t c;
3146   memcpy(&c, r, sizeof(struct class64_t));
3147   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3148     swapStruct(c);
3149   if (c.data == 0)
3150     return nullptr;
3151   r = get_pointer_64(c.data, offset, left, S, info);
3152   if (r == nullptr || left < sizeof(struct class_ro64_t))
3153     return nullptr;
3154   struct class_ro64_t cro;
3155   memcpy(&cro, r, sizeof(struct class_ro64_t));
3156   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3157     swapStruct(cro);
3158   if (cro.name == 0)
3159     return nullptr;
3160   const char *name = get_pointer_64(cro.name, offset, left, S, info);
3161   return name;
3162 }
3163
3164 // get_objc2_64bit_cfstring_name is used for disassembly and is passed a
3165 // pointer to a cfstring and returns its name or nullptr.
3166 static const char *get_objc2_64bit_cfstring_name(uint64_t ReferenceValue,
3167                                                  struct DisassembleInfo *info) {
3168   const char *r, *name;
3169   uint32_t offset, left;
3170   SectionRef S;
3171   struct cfstring64_t cfs;
3172   uint64_t cfs_characters;
3173
3174   r = get_pointer_64(ReferenceValue, offset, left, S, info);
3175   if (r == nullptr || left < sizeof(struct cfstring64_t))
3176     return nullptr;
3177   memcpy(&cfs, r, sizeof(struct cfstring64_t));
3178   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3179     swapStruct(cfs);
3180   if (cfs.characters == 0) {
3181     uint64_t n_value;
3182     const char *symbol_name = get_symbol_64(
3183         offset + offsetof(struct cfstring64_t, characters), S, info, n_value);
3184     if (symbol_name == nullptr)
3185       return nullptr;
3186     cfs_characters = n_value;
3187   } else
3188     cfs_characters = cfs.characters;
3189   name = get_pointer_64(cfs_characters, offset, left, S, info);
3190
3191   return name;
3192 }
3193
3194 // get_objc2_64bit_selref() is used for disassembly and is passed a the address
3195 // of a pointer to an Objective-C selector reference when the pointer value is
3196 // zero as in a .o file and is likely to have a external relocation entry with
3197 // who's symbol's n_value is the real pointer to the selector name.  If that is
3198 // the case the real pointer to the selector name is returned else 0 is
3199 // returned
3200 static uint64_t get_objc2_64bit_selref(uint64_t ReferenceValue,
3201                                        struct DisassembleInfo *info) {
3202   uint32_t offset, left;
3203   SectionRef S;
3204
3205   const char *r = get_pointer_64(ReferenceValue, offset, left, S, info);
3206   if (r == nullptr || left < sizeof(uint64_t))
3207     return 0;
3208   uint64_t n_value;
3209   const char *symbol_name = get_symbol_64(offset, S, info, n_value);
3210   if (symbol_name == nullptr)
3211     return 0;
3212   return n_value;
3213 }
3214
3215 static const SectionRef get_section(MachOObjectFile *O, const char *segname,
3216                                     const char *sectname) {
3217   for (const SectionRef &Section : O->sections()) {
3218     StringRef SectName;
3219     Section.getName(SectName);
3220     DataRefImpl Ref = Section.getRawDataRefImpl();
3221     StringRef SegName = O->getSectionFinalSegmentName(Ref);
3222     if (SegName == segname && SectName == sectname)
3223       return Section;
3224   }
3225   return SectionRef();
3226 }
3227
3228 static void
3229 walk_pointer_list_64(const char *listname, const SectionRef S,
3230                      MachOObjectFile *O, struct DisassembleInfo *info,
3231                      void (*func)(uint64_t, struct DisassembleInfo *info)) {
3232   if (S == SectionRef())
3233     return;
3234
3235   StringRef SectName;
3236   S.getName(SectName);
3237   DataRefImpl Ref = S.getRawDataRefImpl();
3238   StringRef SegName = O->getSectionFinalSegmentName(Ref);
3239   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
3240
3241   StringRef BytesStr;
3242   S.getContents(BytesStr);
3243   const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
3244
3245   for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint64_t)) {
3246     uint32_t left = S.getSize() - i;
3247     uint32_t size = left < sizeof(uint64_t) ? left : sizeof(uint64_t);
3248     uint64_t p = 0;
3249     memcpy(&p, Contents + i, size);
3250     if (i + sizeof(uint64_t) > S.getSize())
3251       outs() << listname << " list pointer extends past end of (" << SegName
3252              << "," << SectName << ") section\n";
3253     outs() << format("%016" PRIx64, S.getAddress() + i) << " ";
3254
3255     if (O->isLittleEndian() != sys::IsLittleEndianHost)
3256       sys::swapByteOrder(p);
3257
3258     uint64_t n_value = 0;
3259     const char *name = get_symbol_64(i, S, info, n_value, p);
3260     if (name == nullptr)
3261       name = get_dyld_bind_info_symbolname(S.getAddress() + i, info);
3262
3263     if (n_value != 0) {
3264       outs() << format("0x%" PRIx64, n_value);
3265       if (p != 0)
3266         outs() << " + " << format("0x%" PRIx64, p);
3267     } else
3268       outs() << format("0x%" PRIx64, p);
3269     if (name != nullptr)
3270       outs() << " " << name;
3271     outs() << "\n";
3272
3273     p += n_value;
3274     if (func)
3275       func(p, info);
3276   }
3277 }
3278
3279 static void
3280 walk_pointer_list_32(const char *listname, const SectionRef S,
3281                      MachOObjectFile *O, struct DisassembleInfo *info,
3282                      void (*func)(uint32_t, struct DisassembleInfo *info)) {
3283   if (S == SectionRef())
3284     return;
3285
3286   StringRef SectName;
3287   S.getName(SectName);
3288   DataRefImpl Ref = S.getRawDataRefImpl();
3289   StringRef SegName = O->getSectionFinalSegmentName(Ref);
3290   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
3291
3292   StringRef BytesStr;
3293   S.getContents(BytesStr);
3294   const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
3295
3296   for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint32_t)) {
3297     uint32_t left = S.getSize() - i;
3298     uint32_t size = left < sizeof(uint32_t) ? left : sizeof(uint32_t);
3299     uint32_t p = 0;
3300     memcpy(&p, Contents + i, size);
3301     if (i + sizeof(uint32_t) > S.getSize())
3302       outs() << listname << " list pointer extends past end of (" << SegName
3303              << "," << SectName << ") section\n";
3304     uint32_t Address = S.getAddress() + i;
3305     outs() << format("%08" PRIx32, Address) << " ";
3306
3307     if (O->isLittleEndian() != sys::IsLittleEndianHost)
3308       sys::swapByteOrder(p);
3309     outs() << format("0x%" PRIx32, p);
3310
3311     const char *name = get_symbol_32(i, S, info, p);
3312     if (name != nullptr)
3313       outs() << " " << name;
3314     outs() << "\n";
3315
3316     if (func)
3317       func(p, info);
3318   }
3319 }
3320
3321 static void print_layout_map(const char *layout_map, uint32_t left) {
3322   outs() << "                layout map: ";
3323   do {
3324     outs() << format("0x%02" PRIx32, (*layout_map) & 0xff) << " ";
3325     left--;
3326     layout_map++;
3327   } while (*layout_map != '\0' && left != 0);
3328   outs() << "\n";
3329 }
3330
3331 static void print_layout_map64(uint64_t p, struct DisassembleInfo *info) {
3332   uint32_t offset, left;
3333   SectionRef S;
3334   const char *layout_map;
3335
3336   if (p == 0)
3337     return;
3338   layout_map = get_pointer_64(p, offset, left, S, info);
3339   print_layout_map(layout_map, left);
3340 }
3341
3342 static void print_layout_map32(uint32_t p, struct DisassembleInfo *info) {
3343   uint32_t offset, left;
3344   SectionRef S;
3345   const char *layout_map;
3346
3347   if (p == 0)
3348     return;
3349   layout_map = get_pointer_32(p, offset, left, S, info);
3350   print_layout_map(layout_map, left);
3351 }
3352
3353 static void print_method_list64_t(uint64_t p, struct DisassembleInfo *info,
3354                                   const char *indent) {
3355   struct method_list64_t ml;
3356   struct method64_t m;
3357   const char *r;
3358   uint32_t offset, xoffset, left, i;
3359   SectionRef S, xS;
3360   const char *name, *sym_name;
3361   uint64_t n_value;
3362
3363   r = get_pointer_64(p, offset, left, S, info);
3364   if (r == nullptr)
3365     return;
3366   memset(&ml, '\0', sizeof(struct method_list64_t));
3367   if (left < sizeof(struct method_list64_t)) {
3368     memcpy(&ml, r, left);
3369     outs() << "   (method_list_t entends past the end of the section)\n";
3370   } else
3371     memcpy(&ml, r, sizeof(struct method_list64_t));
3372   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3373     swapStruct(ml);
3374   outs() << indent << "\t\t   entsize " << ml.entsize << "\n";
3375   outs() << indent << "\t\t     count " << ml.count << "\n";
3376
3377   p += sizeof(struct method_list64_t);
3378   offset += sizeof(struct method_list64_t);
3379   for (i = 0; i < ml.count; i++) {
3380     r = get_pointer_64(p, offset, left, S, info);
3381     if (r == nullptr)
3382       return;
3383     memset(&m, '\0', sizeof(struct method64_t));
3384     if (left < sizeof(struct method64_t)) {
3385       memcpy(&ml, r, left);
3386       outs() << indent << "   (method_t entends past the end of the section)\n";
3387     } else
3388       memcpy(&m, r, sizeof(struct method64_t));
3389     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3390       swapStruct(m);
3391
3392     outs() << indent << "\t\t      name ";
3393     sym_name = get_symbol_64(offset + offsetof(struct method64_t, name), S,
3394                              info, n_value, m.name);
3395     if (n_value != 0) {
3396       if (info->verbose && sym_name != nullptr)
3397         outs() << sym_name;
3398       else
3399         outs() << format("0x%" PRIx64, n_value);
3400       if (m.name != 0)
3401         outs() << " + " << format("0x%" PRIx64, m.name);
3402     } else
3403       outs() << format("0x%" PRIx64, m.name);
3404     name = get_pointer_64(m.name + n_value, xoffset, left, xS, info);
3405     if (name != nullptr)
3406       outs() << format(" %.*s", left, name);
3407     outs() << "\n";
3408
3409     outs() << indent << "\t\t     types ";
3410     sym_name = get_symbol_64(offset + offsetof(struct method64_t, types), S,
3411                              info, n_value, m.types);
3412     if (n_value != 0) {
3413       if (info->verbose && sym_name != nullptr)
3414         outs() << sym_name;
3415       else
3416         outs() << format("0x%" PRIx64, n_value);
3417       if (m.types != 0)
3418         outs() << " + " << format("0x%" PRIx64, m.types);
3419     } else
3420       outs() << format("0x%" PRIx64, m.types);
3421     name = get_pointer_64(m.types + n_value, xoffset, left, xS, info);
3422     if (name != nullptr)
3423       outs() << format(" %.*s", left, name);
3424     outs() << "\n";
3425
3426     outs() << indent << "\t\t       imp ";
3427     name = get_symbol_64(offset + offsetof(struct method64_t, imp), S, info,
3428                          n_value, m.imp);
3429     if (info->verbose && name == nullptr) {
3430       if (n_value != 0) {
3431         outs() << format("0x%" PRIx64, n_value) << " ";
3432         if (m.imp != 0)
3433           outs() << "+ " << format("0x%" PRIx64, m.imp) << " ";
3434       } else
3435         outs() << format("0x%" PRIx64, m.imp) << " ";
3436     }
3437     if (name != nullptr)
3438       outs() << name;
3439     outs() << "\n";
3440
3441     p += sizeof(struct method64_t);
3442     offset += sizeof(struct method64_t);
3443   }
3444 }
3445
3446 static void print_method_list32_t(uint64_t p, struct DisassembleInfo *info,
3447                                   const char *indent) {
3448   struct method_list32_t ml;
3449   struct method32_t m;
3450   const char *r, *name;
3451   uint32_t offset, xoffset, left, i;
3452   SectionRef S, xS;
3453
3454   r = get_pointer_32(p, offset, left, S, info);
3455   if (r == nullptr)
3456     return;
3457   memset(&ml, '\0', sizeof(struct method_list32_t));
3458   if (left < sizeof(struct method_list32_t)) {
3459     memcpy(&ml, r, left);
3460     outs() << "   (method_list_t entends past the end of the section)\n";
3461   } else
3462     memcpy(&ml, r, sizeof(struct method_list32_t));
3463   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3464     swapStruct(ml);
3465   outs() << indent << "\t\t   entsize " << ml.entsize << "\n";
3466   outs() << indent << "\t\t     count " << ml.count << "\n";
3467
3468   p += sizeof(struct method_list32_t);
3469   offset += sizeof(struct method_list32_t);
3470   for (i = 0; i < ml.count; i++) {
3471     r = get_pointer_32(p, offset, left, S, info);
3472     if (r == nullptr)
3473       return;
3474     memset(&m, '\0', sizeof(struct method32_t));
3475     if (left < sizeof(struct method32_t)) {
3476       memcpy(&ml, r, left);
3477       outs() << indent << "   (method_t entends past the end of the section)\n";
3478     } else
3479       memcpy(&m, r, sizeof(struct method32_t));
3480     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3481       swapStruct(m);
3482
3483     outs() << indent << "\t\t      name " << format("0x%" PRIx32, m.name);
3484     name = get_pointer_32(m.name, xoffset, left, xS, info);
3485     if (name != nullptr)
3486       outs() << format(" %.*s", left, name);
3487     outs() << "\n";
3488
3489     outs() << indent << "\t\t     types " << format("0x%" PRIx32, m.types);
3490     name = get_pointer_32(m.types, xoffset, left, xS, info);
3491     if (name != nullptr)
3492       outs() << format(" %.*s", left, name);
3493     outs() << "\n";
3494
3495     outs() << indent << "\t\t       imp " << format("0x%" PRIx32, m.imp);
3496     name = get_symbol_32(offset + offsetof(struct method32_t, imp), S, info,
3497                          m.imp);
3498     if (name != nullptr)
3499       outs() << " " << name;
3500     outs() << "\n";
3501
3502     p += sizeof(struct method32_t);
3503     offset += sizeof(struct method32_t);
3504   }
3505 }
3506
3507 static bool print_method_list(uint32_t p, struct DisassembleInfo *info) {
3508   uint32_t offset, left, xleft;
3509   SectionRef S;
3510   struct objc_method_list_t method_list;
3511   struct objc_method_t method;
3512   const char *r, *methods, *name, *SymbolName;
3513   int32_t i;
3514
3515   r = get_pointer_32(p, offset, left, S, info, true);
3516   if (r == nullptr)
3517     return true;
3518
3519   outs() << "\n";
3520   if (left > sizeof(struct objc_method_list_t)) {
3521     memcpy(&method_list, r, sizeof(struct objc_method_list_t));
3522   } else {
3523     outs() << "\t\t objc_method_list extends past end of the section\n";
3524     memset(&method_list, '\0', sizeof(struct objc_method_list_t));
3525     memcpy(&method_list, r, left);
3526   }
3527   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3528     swapStruct(method_list);
3529
3530   outs() << "\t\t         obsolete "
3531          << format("0x%08" PRIx32, method_list.obsolete) << "\n";
3532   outs() << "\t\t     method_count " << method_list.method_count << "\n";
3533
3534   methods = r + sizeof(struct objc_method_list_t);
3535   for (i = 0; i < method_list.method_count; i++) {
3536     if ((i + 1) * sizeof(struct objc_method_t) > left) {
3537       outs() << "\t\t remaining method's extend past the of the section\n";
3538       break;
3539     }
3540     memcpy(&method, methods + i * sizeof(struct objc_method_t),
3541            sizeof(struct objc_method_t));
3542     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3543       swapStruct(method);
3544
3545     outs() << "\t\t      method_name "
3546            << format("0x%08" PRIx32, method.method_name);
3547     if (info->verbose) {
3548       name = get_pointer_32(method.method_name, offset, xleft, S, info, true);
3549       if (name != nullptr)
3550         outs() << format(" %.*s", xleft, name);
3551       else
3552         outs() << " (not in an __OBJC section)";
3553     }
3554     outs() << "\n";
3555
3556     outs() << "\t\t     method_types "
3557            << format("0x%08" PRIx32, method.method_types);
3558     if (info->verbose) {
3559       name = get_pointer_32(method.method_types, offset, xleft, S, info, true);
3560       if (name != nullptr)
3561         outs() << format(" %.*s", xleft, name);
3562       else
3563         outs() << " (not in an __OBJC section)";
3564     }
3565     outs() << "\n";
3566
3567     outs() << "\t\t       method_imp "
3568            << format("0x%08" PRIx32, method.method_imp) << " ";
3569     if (info->verbose) {
3570       SymbolName = GuessSymbolName(method.method_imp, info->AddrMap);
3571       if (SymbolName != nullptr)
3572         outs() << SymbolName;
3573     }
3574     outs() << "\n";
3575   }
3576   return false;
3577 }
3578
3579 static void print_protocol_list64_t(uint64_t p, struct DisassembleInfo *info) {
3580   struct protocol_list64_t pl;
3581   uint64_t q, n_value;
3582   struct protocol64_t pc;
3583   const char *r;
3584   uint32_t offset, xoffset, left, i;
3585   SectionRef S, xS;
3586   const char *name, *sym_name;
3587
3588   r = get_pointer_64(p, offset, left, S, info);
3589   if (r == nullptr)
3590     return;
3591   memset(&pl, '\0', sizeof(struct protocol_list64_t));
3592   if (left < sizeof(struct protocol_list64_t)) {
3593     memcpy(&pl, r, left);
3594     outs() << "   (protocol_list_t entends past the end of the section)\n";
3595   } else
3596     memcpy(&pl, r, sizeof(struct protocol_list64_t));
3597   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3598     swapStruct(pl);
3599   outs() << "                      count " << pl.count << "\n";
3600
3601   p += sizeof(struct protocol_list64_t);
3602   offset += sizeof(struct protocol_list64_t);
3603   for (i = 0; i < pl.count; i++) {
3604     r = get_pointer_64(p, offset, left, S, info);
3605     if (r == nullptr)
3606       return;
3607     q = 0;
3608     if (left < sizeof(uint64_t)) {
3609       memcpy(&q, r, left);
3610       outs() << "   (protocol_t * entends past the end of the section)\n";
3611     } else
3612       memcpy(&q, r, sizeof(uint64_t));
3613     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3614       sys::swapByteOrder(q);
3615
3616     outs() << "\t\t      list[" << i << "] ";
3617     sym_name = get_symbol_64(offset, S, info, n_value, q);
3618     if (n_value != 0) {
3619       if (info->verbose && sym_name != nullptr)
3620         outs() << sym_name;
3621       else
3622         outs() << format("0x%" PRIx64, n_value);
3623       if (q != 0)
3624         outs() << " + " << format("0x%" PRIx64, q);
3625     } else
3626       outs() << format("0x%" PRIx64, q);
3627     outs() << " (struct protocol_t *)\n";
3628
3629     r = get_pointer_64(q + n_value, offset, left, S, info);
3630     if (r == nullptr)
3631       return;
3632     memset(&pc, '\0', sizeof(struct protocol64_t));
3633     if (left < sizeof(struct protocol64_t)) {
3634       memcpy(&pc, r, left);
3635       outs() << "   (protocol_t entends past the end of the section)\n";
3636     } else
3637       memcpy(&pc, r, sizeof(struct protocol64_t));
3638     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3639       swapStruct(pc);
3640
3641     outs() << "\t\t\t      isa " << format("0x%" PRIx64, pc.isa) << "\n";
3642
3643     outs() << "\t\t\t     name ";
3644     sym_name = get_symbol_64(offset + offsetof(struct protocol64_t, name), S,
3645                              info, n_value, pc.name);
3646     if (n_value != 0) {
3647       if (info->verbose && sym_name != nullptr)
3648         outs() << sym_name;
3649       else
3650         outs() << format("0x%" PRIx64, n_value);
3651       if (pc.name != 0)
3652         outs() << " + " << format("0x%" PRIx64, pc.name);
3653     } else
3654       outs() << format("0x%" PRIx64, pc.name);
3655     name = get_pointer_64(pc.name + n_value, xoffset, left, xS, info);
3656     if (name != nullptr)
3657       outs() << format(" %.*s", left, name);
3658     outs() << "\n";
3659
3660     outs() << "\t\t\tprotocols " << format("0x%" PRIx64, pc.protocols) << "\n";
3661
3662     outs() << "\t\t  instanceMethods ";
3663     sym_name =
3664         get_symbol_64(offset + offsetof(struct protocol64_t, instanceMethods),
3665                       S, info, n_value, pc.instanceMethods);
3666     if (n_value != 0) {
3667       if (info->verbose && sym_name != nullptr)
3668         outs() << sym_name;
3669       else
3670         outs() << format("0x%" PRIx64, n_value);
3671       if (pc.instanceMethods != 0)
3672         outs() << " + " << format("0x%" PRIx64, pc.instanceMethods);
3673     } else
3674       outs() << format("0x%" PRIx64, pc.instanceMethods);
3675     outs() << " (struct method_list_t *)\n";
3676     if (pc.instanceMethods + n_value != 0)
3677       print_method_list64_t(pc.instanceMethods + n_value, info, "\t");
3678
3679     outs() << "\t\t     classMethods ";
3680     sym_name =
3681         get_symbol_64(offset + offsetof(struct protocol64_t, classMethods), S,
3682                       info, n_value, pc.classMethods);
3683     if (n_value != 0) {
3684       if (info->verbose && sym_name != nullptr)
3685         outs() << sym_name;
3686       else
3687         outs() << format("0x%" PRIx64, n_value);
3688       if (pc.classMethods != 0)
3689         outs() << " + " << format("0x%" PRIx64, pc.classMethods);
3690     } else
3691       outs() << format("0x%" PRIx64, pc.classMethods);
3692     outs() << " (struct method_list_t *)\n";
3693     if (pc.classMethods + n_value != 0)
3694       print_method_list64_t(pc.classMethods + n_value, info, "\t");
3695
3696     outs() << "\t  optionalInstanceMethods "
3697            << format("0x%" PRIx64, pc.optionalInstanceMethods) << "\n";
3698     outs() << "\t     optionalClassMethods "
3699            << format("0x%" PRIx64, pc.optionalClassMethods) << "\n";
3700     outs() << "\t       instanceProperties "
3701            << format("0x%" PRIx64, pc.instanceProperties) << "\n";
3702
3703     p += sizeof(uint64_t);
3704     offset += sizeof(uint64_t);
3705   }
3706 }
3707
3708 static void print_protocol_list32_t(uint32_t p, struct DisassembleInfo *info) {
3709   struct protocol_list32_t pl;
3710   uint32_t q;
3711   struct protocol32_t pc;
3712   const char *r;
3713   uint32_t offset, xoffset, left, i;
3714   SectionRef S, xS;
3715   const char *name;
3716
3717   r = get_pointer_32(p, offset, left, S, info);
3718   if (r == nullptr)
3719     return;
3720   memset(&pl, '\0', sizeof(struct protocol_list32_t));
3721   if (left < sizeof(struct protocol_list32_t)) {
3722     memcpy(&pl, r, left);
3723     outs() << "   (protocol_list_t entends past the end of the section)\n";
3724   } else
3725     memcpy(&pl, r, sizeof(struct protocol_list32_t));
3726   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3727     swapStruct(pl);
3728   outs() << "                      count " << pl.count << "\n";
3729
3730   p += sizeof(struct protocol_list32_t);
3731   offset += sizeof(struct protocol_list32_t);
3732   for (i = 0; i < pl.count; i++) {
3733     r = get_pointer_32(p, offset, left, S, info);
3734     if (r == nullptr)
3735       return;
3736     q = 0;
3737     if (left < sizeof(uint32_t)) {
3738       memcpy(&q, r, left);
3739       outs() << "   (protocol_t * entends past the end of the section)\n";
3740     } else
3741       memcpy(&q, r, sizeof(uint32_t));
3742     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3743       sys::swapByteOrder(q);
3744     outs() << "\t\t      list[" << i << "] " << format("0x%" PRIx32, q)
3745            << " (struct protocol_t *)\n";
3746     r = get_pointer_32(q, offset, left, S, info);
3747     if (r == nullptr)
3748       return;
3749     memset(&pc, '\0', sizeof(struct protocol32_t));
3750     if (left < sizeof(struct protocol32_t)) {
3751       memcpy(&pc, r, left);
3752       outs() << "   (protocol_t entends past the end of the section)\n";
3753     } else
3754       memcpy(&pc, r, sizeof(struct protocol32_t));
3755     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3756       swapStruct(pc);
3757     outs() << "\t\t\t      isa " << format("0x%" PRIx32, pc.isa) << "\n";
3758     outs() << "\t\t\t     name " << format("0x%" PRIx32, pc.name);
3759     name = get_pointer_32(pc.name, xoffset, left, xS, info);
3760     if (name != nullptr)
3761       outs() << format(" %.*s", left, name);
3762     outs() << "\n";
3763     outs() << "\t\t\tprotocols " << format("0x%" PRIx32, pc.protocols) << "\n";
3764     outs() << "\t\t  instanceMethods "
3765            << format("0x%" PRIx32, pc.instanceMethods)
3766            << " (struct method_list_t *)\n";
3767     if (pc.instanceMethods != 0)
3768       print_method_list32_t(pc.instanceMethods, info, "\t");
3769     outs() << "\t\t     classMethods " << format("0x%" PRIx32, pc.classMethods)
3770            << " (struct method_list_t *)\n";
3771     if (pc.classMethods != 0)
3772       print_method_list32_t(pc.classMethods, info, "\t");
3773     outs() << "\t  optionalInstanceMethods "
3774            << format("0x%" PRIx32, pc.optionalInstanceMethods) << "\n";
3775     outs() << "\t     optionalClassMethods "
3776            << format("0x%" PRIx32, pc.optionalClassMethods) << "\n";
3777     outs() << "\t       instanceProperties "
3778            << format("0x%" PRIx32, pc.instanceProperties) << "\n";
3779     p += sizeof(uint32_t);
3780     offset += sizeof(uint32_t);
3781   }
3782 }
3783
3784 static void print_indent(uint32_t indent) {
3785   for (uint32_t i = 0; i < indent;) {
3786     if (indent - i >= 8) {
3787       outs() << "\t";
3788       i += 8;
3789     } else {
3790       for (uint32_t j = i; j < indent; j++)
3791         outs() << " ";
3792       return;
3793     }
3794   }
3795 }
3796
3797 static bool print_method_description_list(uint32_t p, uint32_t indent,
3798                                           struct DisassembleInfo *info) {
3799   uint32_t offset, left, xleft;
3800   SectionRef S;
3801   struct objc_method_description_list_t mdl;
3802   struct objc_method_description_t md;
3803   const char *r, *list, *name;
3804   int32_t i;
3805
3806   r = get_pointer_32(p, offset, left, S, info, true);
3807   if (r == nullptr)
3808     return true;
3809
3810   outs() << "\n";
3811   if (left > sizeof(struct objc_method_description_list_t)) {
3812     memcpy(&mdl, r, sizeof(struct objc_method_description_list_t));
3813   } else {
3814     print_indent(indent);
3815     outs() << " objc_method_description_list extends past end of the section\n";
3816     memset(&mdl, '\0', sizeof(struct objc_method_description_list_t));
3817     memcpy(&mdl, r, left);
3818   }
3819   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3820     swapStruct(mdl);
3821
3822   print_indent(indent);
3823   outs() << "        count " << mdl.count << "\n";
3824
3825   list = r + sizeof(struct objc_method_description_list_t);
3826   for (i = 0; i < mdl.count; i++) {
3827     if ((i + 1) * sizeof(struct objc_method_description_t) > left) {
3828       print_indent(indent);
3829       outs() << " remaining list entries extend past the of the section\n";
3830       break;
3831     }
3832     print_indent(indent);
3833     outs() << "        list[" << i << "]\n";
3834     memcpy(&md, list + i * sizeof(struct objc_method_description_t),
3835            sizeof(struct objc_method_description_t));
3836     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3837       swapStruct(md);
3838
3839     print_indent(indent);
3840     outs() << "             name " << format("0x%08" PRIx32, md.name);
3841     if (info->verbose) {
3842       name = get_pointer_32(md.name, offset, xleft, S, info, true);
3843       if (name != nullptr)
3844         outs() << format(" %.*s", xleft, name);
3845       else
3846         outs() << " (not in an __OBJC section)";
3847     }
3848     outs() << "\n";
3849
3850     print_indent(indent);
3851     outs() << "            types " << format("0x%08" PRIx32, md.types);
3852     if (info->verbose) {
3853       name = get_pointer_32(md.types, offset, xleft, S, info, true);
3854       if (name != nullptr)
3855         outs() << format(" %.*s", xleft, name);
3856       else
3857         outs() << " (not in an __OBJC section)";
3858     }
3859     outs() << "\n";
3860   }
3861   return false;
3862 }
3863
3864 static bool print_protocol_list(uint32_t p, uint32_t indent,
3865                                 struct DisassembleInfo *info);
3866
3867 static bool print_protocol(uint32_t p, uint32_t indent,
3868                            struct DisassembleInfo *info) {
3869   uint32_t offset, left;
3870   SectionRef S;
3871   struct objc_protocol_t protocol;
3872   const char *r, *name;
3873
3874   r = get_pointer_32(p, offset, left, S, info, true);
3875   if (r == nullptr)
3876     return true;
3877
3878   outs() << "\n";
3879   if (left >= sizeof(struct objc_protocol_t)) {
3880     memcpy(&protocol, r, sizeof(struct objc_protocol_t));
3881   } else {
3882     print_indent(indent);
3883     outs() << "            Protocol extends past end of the section\n";
3884     memset(&protocol, '\0', sizeof(struct objc_protocol_t));
3885     memcpy(&protocol, r, left);
3886   }
3887   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3888     swapStruct(protocol);
3889
3890   print_indent(indent);
3891   outs() << "              isa " << format("0x%08" PRIx32, protocol.isa)
3892          << "\n";
3893
3894   print_indent(indent);
3895   outs() << "    protocol_name "
3896          << format("0x%08" PRIx32, protocol.protocol_name);
3897   if (info->verbose) {
3898     name = get_pointer_32(protocol.protocol_name, offset, left, S, info, true);
3899     if (name != nullptr)
3900       outs() << format(" %.*s", left, name);
3901     else
3902       outs() << " (not in an __OBJC section)";
3903   }
3904   outs() << "\n";
3905
3906   print_indent(indent);
3907   outs() << "    protocol_list "
3908          << format("0x%08" PRIx32, protocol.protocol_list);
3909   if (print_protocol_list(protocol.protocol_list, indent + 4, info))
3910     outs() << " (not in an __OBJC section)\n";
3911
3912   print_indent(indent);
3913   outs() << " instance_methods "
3914          << format("0x%08" PRIx32, protocol.instance_methods);
3915   if (print_method_description_list(protocol.instance_methods, indent, info))
3916     outs() << " (not in an __OBJC section)\n";
3917
3918   print_indent(indent);
3919   outs() << "    class_methods "
3920          << format("0x%08" PRIx32, protocol.class_methods);
3921   if (print_method_description_list(protocol.class_methods, indent, info))
3922     outs() << " (not in an __OBJC section)\n";
3923
3924   return false;
3925 }
3926
3927 static bool print_protocol_list(uint32_t p, uint32_t indent,
3928                                 struct DisassembleInfo *info) {
3929   uint32_t offset, left, l;
3930   SectionRef S;
3931   struct objc_protocol_list_t protocol_list;
3932   const char *r, *list;
3933   int32_t i;
3934
3935   r = get_pointer_32(p, offset, left, S, info, true);
3936   if (r == nullptr)
3937     return true;
3938
3939   outs() << "\n";
3940   if (left > sizeof(struct objc_protocol_list_t)) {
3941     memcpy(&protocol_list, r, sizeof(struct objc_protocol_list_t));
3942   } else {
3943     outs() << "\t\t objc_protocol_list_t extends past end of the section\n";
3944     memset(&protocol_list, '\0', sizeof(struct objc_protocol_list_t));
3945     memcpy(&protocol_list, r, left);
3946   }
3947   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3948     swapStruct(protocol_list);
3949
3950   print_indent(indent);
3951   outs() << "         next " << format("0x%08" PRIx32, protocol_list.next)
3952          << "\n";
3953   print_indent(indent);
3954   outs() << "        count " << protocol_list.count << "\n";
3955
3956   list = r + sizeof(struct objc_protocol_list_t);
3957   for (i = 0; i < protocol_list.count; i++) {
3958     if ((i + 1) * sizeof(uint32_t) > left) {
3959       outs() << "\t\t remaining list entries extend past the of the section\n";
3960       break;
3961     }
3962     memcpy(&l, list + i * sizeof(uint32_t), sizeof(uint32_t));
3963     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3964       sys::swapByteOrder(l);
3965
3966     print_indent(indent);
3967     outs() << "      list[" << i << "] " << format("0x%08" PRIx32, l);
3968     if (print_protocol(l, indent, info))
3969       outs() << "(not in an __OBJC section)\n";
3970   }
3971   return false;
3972 }
3973
3974 static void print_ivar_list64_t(uint64_t p, struct DisassembleInfo *info) {
3975   struct ivar_list64_t il;
3976   struct ivar64_t i;
3977   const char *r;
3978   uint32_t offset, xoffset, left, j;
3979   SectionRef S, xS;
3980   const char *name, *sym_name, *ivar_offset_p;
3981   uint64_t ivar_offset, n_value;
3982
3983   r = get_pointer_64(p, offset, left, S, info);
3984   if (r == nullptr)
3985     return;
3986   memset(&il, '\0', sizeof(struct ivar_list64_t));
3987   if (left < sizeof(struct ivar_list64_t)) {
3988     memcpy(&il, r, left);
3989     outs() << "   (ivar_list_t entends past the end of the section)\n";
3990   } else
3991     memcpy(&il, r, sizeof(struct ivar_list64_t));
3992   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3993     swapStruct(il);
3994   outs() << "                    entsize " << il.entsize << "\n";
3995   outs() << "                      count " << il.count << "\n";
3996
3997   p += sizeof(struct ivar_list64_t);
3998   offset += sizeof(struct ivar_list64_t);
3999   for (j = 0; j < il.count; j++) {
4000     r = get_pointer_64(p, offset, left, S, info);
4001     if (r == nullptr)
4002       return;
4003     memset(&i, '\0', sizeof(struct ivar64_t));
4004     if (left < sizeof(struct ivar64_t)) {
4005       memcpy(&i, r, left);
4006       outs() << "   (ivar_t entends past the end of the section)\n";
4007     } else
4008       memcpy(&i, r, sizeof(struct ivar64_t));
4009     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4010       swapStruct(i);
4011
4012     outs() << "\t\t\t   offset ";
4013     sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, offset), S,
4014                              info, n_value, i.offset);
4015     if (n_value != 0) {
4016       if (info->verbose && sym_name != nullptr)
4017         outs() << sym_name;
4018       else
4019         outs() << format("0x%" PRIx64, n_value);
4020       if (i.offset != 0)
4021         outs() << " + " << format("0x%" PRIx64, i.offset);
4022     } else
4023       outs() << format("0x%" PRIx64, i.offset);
4024     ivar_offset_p = get_pointer_64(i.offset + n_value, xoffset, left, xS, info);
4025     if (ivar_offset_p != nullptr && left >= sizeof(*ivar_offset_p)) {
4026       memcpy(&ivar_offset, ivar_offset_p, sizeof(ivar_offset));
4027       if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4028         sys::swapByteOrder(ivar_offset);
4029       outs() << " " << ivar_offset << "\n";
4030     } else
4031       outs() << "\n";
4032
4033     outs() << "\t\t\t     name ";
4034     sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, name), S, info,
4035                              n_value, i.name);
4036     if (n_value != 0) {
4037       if (info->verbose && sym_name != nullptr)
4038         outs() << sym_name;
4039       else
4040         outs() << format("0x%" PRIx64, n_value);
4041       if (i.name != 0)
4042         outs() << " + " << format("0x%" PRIx64, i.name);
4043     } else
4044       outs() << format("0x%" PRIx64, i.name);
4045     name = get_pointer_64(i.name + n_value, xoffset, left, xS, info);
4046     if (name != nullptr)
4047       outs() << format(" %.*s", left, name);
4048     outs() << "\n";
4049
4050     outs() << "\t\t\t     type ";
4051     sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, type), S, info,
4052                              n_value, i.name);
4053     name = get_pointer_64(i.type + n_value, xoffset, left, xS, info);
4054     if (n_value != 0) {
4055       if (info->verbose && sym_name != nullptr)
4056         outs() << sym_name;
4057       else
4058         outs() << format("0x%" PRIx64, n_value);
4059       if (i.type != 0)
4060         outs() << " + " << format("0x%" PRIx64, i.type);
4061     } else
4062       outs() << format("0x%" PRIx64, i.type);
4063     if (name != nullptr)
4064       outs() << format(" %.*s", left, name);
4065     outs() << "\n";
4066
4067     outs() << "\t\t\talignment " << i.alignment << "\n";
4068     outs() << "\t\t\t     size " << i.size << "\n";
4069
4070     p += sizeof(struct ivar64_t);
4071     offset += sizeof(struct ivar64_t);
4072   }
4073 }
4074
4075 static void print_ivar_list32_t(uint32_t p, struct DisassembleInfo *info) {
4076   struct ivar_list32_t il;
4077   struct ivar32_t i;
4078   const char *r;
4079   uint32_t offset, xoffset, left, j;
4080   SectionRef S, xS;
4081   const char *name, *ivar_offset_p;
4082   uint32_t ivar_offset;
4083
4084   r = get_pointer_32(p, offset, left, S, info);
4085   if (r == nullptr)
4086     return;
4087   memset(&il, '\0', sizeof(struct ivar_list32_t));
4088   if (left < sizeof(struct ivar_list32_t)) {
4089     memcpy(&il, r, left);
4090     outs() << "   (ivar_list_t entends past the end of the section)\n";
4091   } else
4092     memcpy(&il, r, sizeof(struct ivar_list32_t));
4093   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4094     swapStruct(il);
4095   outs() << "                    entsize " << il.entsize << "\n";
4096   outs() << "                      count " << il.count << "\n";
4097
4098   p += sizeof(struct ivar_list32_t);
4099   offset += sizeof(struct ivar_list32_t);
4100   for (j = 0; j < il.count; j++) {
4101     r = get_pointer_32(p, offset, left, S, info);
4102     if (r == nullptr)
4103       return;
4104     memset(&i, '\0', sizeof(struct ivar32_t));
4105     if (left < sizeof(struct ivar32_t)) {
4106       memcpy(&i, r, left);
4107       outs() << "   (ivar_t entends past the end of the section)\n";
4108     } else
4109       memcpy(&i, r, sizeof(struct ivar32_t));
4110     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4111       swapStruct(i);
4112
4113     outs() << "\t\t\t   offset " << format("0x%" PRIx32, i.offset);
4114     ivar_offset_p = get_pointer_32(i.offset, xoffset, left, xS, info);
4115     if (ivar_offset_p != nullptr && left >= sizeof(*ivar_offset_p)) {
4116       memcpy(&ivar_offset, ivar_offset_p, sizeof(ivar_offset));
4117       if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4118         sys::swapByteOrder(ivar_offset);
4119       outs() << " " << ivar_offset << "\n";
4120     } else
4121       outs() << "\n";
4122
4123     outs() << "\t\t\t     name " << format("0x%" PRIx32, i.name);
4124     name = get_pointer_32(i.name, xoffset, left, xS, info);
4125     if (name != nullptr)
4126       outs() << format(" %.*s", left, name);
4127     outs() << "\n";
4128
4129     outs() << "\t\t\t     type " << format("0x%" PRIx32, i.type);
4130     name = get_pointer_32(i.type, xoffset, left, xS, info);
4131     if (name != nullptr)
4132       outs() << format(" %.*s", left, name);
4133     outs() << "\n";
4134
4135     outs() << "\t\t\talignment " << i.alignment << "\n";
4136     outs() << "\t\t\t     size " << i.size << "\n";
4137
4138     p += sizeof(struct ivar32_t);
4139     offset += sizeof(struct ivar32_t);
4140   }
4141 }
4142
4143 static void print_objc_property_list64(uint64_t p,
4144                                        struct DisassembleInfo *info) {
4145   struct objc_property_list64 opl;
4146   struct objc_property64 op;
4147   const char *r;
4148   uint32_t offset, xoffset, left, j;
4149   SectionRef S, xS;
4150   const char *name, *sym_name;
4151   uint64_t n_value;
4152
4153   r = get_pointer_64(p, offset, left, S, info);
4154   if (r == nullptr)
4155     return;
4156   memset(&opl, '\0', sizeof(struct objc_property_list64));
4157   if (left < sizeof(struct objc_property_list64)) {
4158     memcpy(&opl, r, left);
4159     outs() << "   (objc_property_list entends past the end of the section)\n";
4160   } else
4161     memcpy(&opl, r, sizeof(struct objc_property_list64));
4162   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4163     swapStruct(opl);
4164   outs() << "                    entsize " << opl.entsize << "\n";
4165   outs() << "                      count " << opl.count << "\n";
4166
4167   p += sizeof(struct objc_property_list64);
4168   offset += sizeof(struct objc_property_list64);
4169   for (j = 0; j < opl.count; j++) {
4170     r = get_pointer_64(p, offset, left, S, info);
4171     if (r == nullptr)
4172       return;
4173     memset(&op, '\0', sizeof(struct objc_property64));
4174     if (left < sizeof(struct objc_property64)) {
4175       memcpy(&op, r, left);
4176       outs() << "   (objc_property entends past the end of the section)\n";
4177     } else
4178       memcpy(&op, r, sizeof(struct objc_property64));
4179     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4180       swapStruct(op);
4181
4182     outs() << "\t\t\t     name ";
4183     sym_name = get_symbol_64(offset + offsetof(struct objc_property64, name), S,
4184                              info, n_value, op.name);
4185     if (n_value != 0) {
4186       if (info->verbose && sym_name != nullptr)
4187         outs() << sym_name;
4188       else
4189         outs() << format("0x%" PRIx64, n_value);
4190       if (op.name != 0)
4191         outs() << " + " << format("0x%" PRIx64, op.name);
4192     } else
4193       outs() << format("0x%" PRIx64, op.name);
4194     name = get_pointer_64(op.name + n_value, xoffset, left, xS, info);
4195     if (name != nullptr)
4196       outs() << format(" %.*s", left, name);
4197     outs() << "\n";
4198
4199     outs() << "\t\t\tattributes ";
4200     sym_name =
4201         get_symbol_64(offset + offsetof(struct objc_property64, attributes), S,
4202                       info, n_value, op.attributes);
4203     if (n_value != 0) {
4204       if (info->verbose && sym_name != nullptr)
4205         outs() << sym_name;
4206       else
4207         outs() << format("0x%" PRIx64, n_value);
4208       if (op.attributes != 0)
4209         outs() << " + " << format("0x%" PRIx64, op.attributes);
4210     } else
4211       outs() << format("0x%" PRIx64, op.attributes);
4212     name = get_pointer_64(op.attributes + n_value, xoffset, left, xS, info);
4213     if (name != nullptr)
4214       outs() << format(" %.*s", left, name);
4215     outs() << "\n";
4216
4217     p += sizeof(struct objc_property64);
4218     offset += sizeof(struct objc_property64);
4219   }
4220 }
4221
4222 static void print_objc_property_list32(uint32_t p,
4223                                        struct DisassembleInfo *info) {
4224   struct objc_property_list32 opl;
4225   struct objc_property32 op;
4226   const char *r;
4227   uint32_t offset, xoffset, left, j;
4228   SectionRef S, xS;
4229   const char *name;
4230
4231   r = get_pointer_32(p, offset, left, S, info);
4232   if (r == nullptr)
4233     return;
4234   memset(&opl, '\0', sizeof(struct objc_property_list32));
4235   if (left < sizeof(struct objc_property_list32)) {
4236     memcpy(&opl, r, left);
4237     outs() << "   (objc_property_list entends past the end of the section)\n";
4238   } else
4239     memcpy(&opl, r, sizeof(struct objc_property_list32));
4240   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4241     swapStruct(opl);
4242   outs() << "                    entsize " << opl.entsize << "\n";
4243   outs() << "                      count " << opl.count << "\n";
4244
4245   p += sizeof(struct objc_property_list32);
4246   offset += sizeof(struct objc_property_list32);
4247   for (j = 0; j < opl.count; j++) {
4248     r = get_pointer_32(p, offset, left, S, info);
4249     if (r == nullptr)
4250       return;
4251     memset(&op, '\0', sizeof(struct objc_property32));
4252     if (left < sizeof(struct objc_property32)) {
4253       memcpy(&op, r, left);
4254       outs() << "   (objc_property entends past the end of the section)\n";
4255     } else
4256       memcpy(&op, r, sizeof(struct objc_property32));
4257     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4258       swapStruct(op);
4259
4260     outs() << "\t\t\t     name " << format("0x%" PRIx32, op.name);
4261     name = get_pointer_32(op.name, xoffset, left, xS, info);
4262     if (name != nullptr)
4263       outs() << format(" %.*s", left, name);
4264     outs() << "\n";
4265
4266     outs() << "\t\t\tattributes " << format("0x%" PRIx32, op.attributes);
4267     name = get_pointer_32(op.attributes, xoffset, left, xS, info);
4268     if (name != nullptr)
4269       outs() << format(" %.*s", left, name);
4270     outs() << "\n";
4271
4272     p += sizeof(struct objc_property32);
4273     offset += sizeof(struct objc_property32);
4274   }
4275 }
4276
4277 static void print_class_ro64_t(uint64_t p, struct DisassembleInfo *info,
4278                                bool &is_meta_class) {
4279   struct class_ro64_t cro;
4280   const char *r;
4281   uint32_t offset, xoffset, left;
4282   SectionRef S, xS;
4283   const char *name, *sym_name;
4284   uint64_t n_value;
4285
4286   r = get_pointer_64(p, offset, left, S, info);
4287   if (r == nullptr || left < sizeof(struct class_ro64_t))
4288     return;
4289   memset(&cro, '\0', sizeof(struct class_ro64_t));
4290   if (left < sizeof(struct class_ro64_t)) {
4291     memcpy(&cro, r, left);
4292     outs() << "   (class_ro_t entends past the end of the section)\n";
4293   } else
4294     memcpy(&cro, r, sizeof(struct class_ro64_t));
4295   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4296     swapStruct(cro);
4297   outs() << "                    flags " << format("0x%" PRIx32, cro.flags);
4298   if (cro.flags & RO_META)
4299     outs() << " RO_META";
4300   if (cro.flags & RO_ROOT)
4301     outs() << " RO_ROOT";
4302   if (cro.flags & RO_HAS_CXX_STRUCTORS)
4303     outs() << " RO_HAS_CXX_STRUCTORS";
4304   outs() << "\n";
4305   outs() << "            instanceStart " << cro.instanceStart << "\n";
4306   outs() << "             instanceSize " << cro.instanceSize << "\n";
4307   outs() << "                 reserved " << format("0x%" PRIx32, cro.reserved)
4308          << "\n";
4309   outs() << "               ivarLayout " << format("0x%" PRIx64, cro.ivarLayout)
4310          << "\n";
4311   print_layout_map64(cro.ivarLayout, info);
4312
4313   outs() << "                     name ";
4314   sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, name), S,
4315                            info, n_value, cro.name);
4316   if (n_value != 0) {
4317     if (info->verbose && sym_name != nullptr)
4318       outs() << sym_name;
4319     else
4320       outs() << format("0x%" PRIx64, n_value);
4321     if (cro.name != 0)
4322       outs() << " + " << format("0x%" PRIx64, cro.name);
4323   } else
4324     outs() << format("0x%" PRIx64, cro.name);
4325   name = get_pointer_64(cro.name + n_value, xoffset, left, xS, info);
4326   if (name != nullptr)
4327     outs() << format(" %.*s", left, name);
4328   outs() << "\n";
4329
4330   outs() << "              baseMethods ";
4331   sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, baseMethods),
4332                            S, info, n_value, cro.baseMethods);
4333   if (n_value != 0) {
4334     if (info->verbose && sym_name != nullptr)
4335       outs() << sym_name;
4336     else
4337       outs() << format("0x%" PRIx64, n_value);
4338     if (cro.baseMethods != 0)
4339       outs() << " + " << format("0x%" PRIx64, cro.baseMethods);
4340   } else
4341     outs() << format("0x%" PRIx64, cro.baseMethods);
4342   outs() << " (struct method_list_t *)\n";
4343   if (cro.baseMethods + n_value != 0)
4344     print_method_list64_t(cro.baseMethods + n_value, info, "");
4345
4346   outs() << "            baseProtocols ";
4347   sym_name =
4348       get_symbol_64(offset + offsetof(struct class_ro64_t, baseProtocols), S,
4349                     info, n_value, cro.baseProtocols);
4350   if (n_value != 0) {
4351     if (info->verbose && sym_name != nullptr)
4352       outs() << sym_name;
4353     else
4354       outs() << format("0x%" PRIx64, n_value);
4355     if (cro.baseProtocols != 0)
4356       outs() << " + " << format("0x%" PRIx64, cro.baseProtocols);
4357   } else
4358     outs() << format("0x%" PRIx64, cro.baseProtocols);
4359   outs() << "\n";
4360   if (cro.baseProtocols + n_value != 0)
4361     print_protocol_list64_t(cro.baseProtocols + n_value, info);
4362
4363   outs() << "                    ivars ";
4364   sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, ivars), S,
4365                            info, n_value, cro.ivars);
4366   if (n_value != 0) {
4367     if (info->verbose && sym_name != nullptr)
4368       outs() << sym_name;
4369     else
4370       outs() << format("0x%" PRIx64, n_value);
4371     if (cro.ivars != 0)
4372       outs() << " + " << format("0x%" PRIx64, cro.ivars);
4373   } else
4374     outs() << format("0x%" PRIx64, cro.ivars);
4375   outs() << "\n";
4376   if (cro.ivars + n_value != 0)
4377     print_ivar_list64_t(cro.ivars + n_value, info);
4378
4379   outs() << "           weakIvarLayout ";
4380   sym_name =
4381       get_symbol_64(offset + offsetof(struct class_ro64_t, weakIvarLayout), S,
4382                     info, n_value, cro.weakIvarLayout);
4383   if (n_value != 0) {
4384     if (info->verbose && sym_name != nullptr)
4385       outs() << sym_name;
4386     else
4387       outs() << format("0x%" PRIx64, n_value);
4388     if (cro.weakIvarLayout != 0)
4389       outs() << " + " << format("0x%" PRIx64, cro.weakIvarLayout);
4390   } else
4391     outs() << format("0x%" PRIx64, cro.weakIvarLayout);
4392   outs() << "\n";
4393   print_layout_map64(cro.weakIvarLayout + n_value, info);
4394
4395   outs() << "           baseProperties ";
4396   sym_name =
4397       get_symbol_64(offset + offsetof(struct class_ro64_t, baseProperties), S,
4398                     info, n_value, cro.baseProperties);
4399   if (n_value != 0) {
4400     if (info->verbose && sym_name != nullptr)
4401       outs() << sym_name;
4402     else
4403       outs() << format("0x%" PRIx64, n_value);
4404     if (cro.baseProperties != 0)
4405       outs() << " + " << format("0x%" PRIx64, cro.baseProperties);
4406   } else
4407     outs() << format("0x%" PRIx64, cro.baseProperties);
4408   outs() << "\n";
4409   if (cro.baseProperties + n_value != 0)
4410     print_objc_property_list64(cro.baseProperties + n_value, info);
4411
4412   is_meta_class = (cro.flags & RO_META) ? true : false;
4413 }
4414
4415 static void print_class_ro32_t(uint32_t p, struct DisassembleInfo *info,
4416                                bool &is_meta_class) {
4417   struct class_ro32_t cro;
4418   const char *r;
4419   uint32_t offset, xoffset, left;
4420   SectionRef S, xS;
4421   const char *name;
4422
4423   r = get_pointer_32(p, offset, left, S, info);
4424   if (r == nullptr)
4425     return;
4426   memset(&cro, '\0', sizeof(struct class_ro32_t));
4427   if (left < sizeof(struct class_ro32_t)) {
4428     memcpy(&cro, r, left);
4429     outs() << "   (class_ro_t entends past the end of the section)\n";
4430   } else
4431     memcpy(&cro, r, sizeof(struct class_ro32_t));
4432   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4433     swapStruct(cro);
4434   outs() << "                    flags " << format("0x%" PRIx32, cro.flags);
4435   if (cro.flags & RO_META)
4436     outs() << " RO_META";
4437   if (cro.flags & RO_ROOT)
4438     outs() << " RO_ROOT";
4439   if (cro.flags & RO_HAS_CXX_STRUCTORS)
4440     outs() << " RO_HAS_CXX_STRUCTORS";
4441   outs() << "\n";
4442   outs() << "            instanceStart " << cro.instanceStart << "\n";
4443   outs() << "             instanceSize " << cro.instanceSize << "\n";
4444   outs() << "               ivarLayout " << format("0x%" PRIx32, cro.ivarLayout)
4445          << "\n";
4446   print_layout_map32(cro.ivarLayout, info);
4447
4448   outs() << "                     name " << format("0x%" PRIx32, cro.name);
4449   name = get_pointer_32(cro.name, xoffset, left, xS, info);
4450   if (name != nullptr)
4451     outs() << format(" %.*s", left, name);
4452   outs() << "\n";
4453
4454   outs() << "              baseMethods "
4455          << format("0x%" PRIx32, cro.baseMethods)
4456          << " (struct method_list_t *)\n";
4457   if (cro.baseMethods != 0)
4458     print_method_list32_t(cro.baseMethods, info, "");
4459
4460   outs() << "            baseProtocols "
4461          << format("0x%" PRIx32, cro.baseProtocols) << "\n";
4462   if (cro.baseProtocols != 0)
4463     print_protocol_list32_t(cro.baseProtocols, info);
4464   outs() << "                    ivars " << format("0x%" PRIx32, cro.ivars)
4465          << "\n";
4466   if (cro.ivars != 0)
4467     print_ivar_list32_t(cro.ivars, info);
4468   outs() << "           weakIvarLayout "
4469          << format("0x%" PRIx32, cro.weakIvarLayout) << "\n";
4470   print_layout_map32(cro.weakIvarLayout, info);
4471   outs() << "           baseProperties "
4472          << format("0x%" PRIx32, cro.baseProperties) << "\n";
4473   if (cro.baseProperties != 0)
4474     print_objc_property_list32(cro.baseProperties, info);
4475   is_meta_class = (cro.flags & RO_META) ? true : false;
4476 }
4477
4478 static void print_class64_t(uint64_t p, struct DisassembleInfo *info) {
4479   struct class64_t c;
4480   const char *r;
4481   uint32_t offset, left;
4482   SectionRef S;
4483   const char *name;
4484   uint64_t isa_n_value, n_value;
4485
4486   r = get_pointer_64(p, offset, left, S, info);
4487   if (r == nullptr || left < sizeof(struct class64_t))
4488     return;
4489   memset(&c, '\0', sizeof(struct class64_t));
4490   if (left < sizeof(struct class64_t)) {
4491     memcpy(&c, r, left);
4492     outs() << "   (class_t entends past the end of the section)\n";
4493   } else
4494     memcpy(&c, r, sizeof(struct class64_t));
4495   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4496     swapStruct(c);
4497
4498   outs() << "           isa " << format("0x%" PRIx64, c.isa);
4499   name = get_symbol_64(offset + offsetof(struct class64_t, isa), S, info,
4500                        isa_n_value, c.isa);
4501   if (name != nullptr)
4502     outs() << " " << name;
4503   outs() << "\n";
4504
4505   outs() << "    superclass " << format("0x%" PRIx64, c.superclass);
4506   name = get_symbol_64(offset + offsetof(struct class64_t, superclass), S, info,
4507                        n_value, c.superclass);
4508   if (name != nullptr)
4509     outs() << " " << name;
4510   outs() << "\n";
4511
4512   outs() << "         cache " << format("0x%" PRIx64, c.cache);
4513   name = get_symbol_64(offset + offsetof(struct class64_t, cache), S, info,
4514                        n_value, c.cache);
4515   if (name != nullptr)
4516     outs() << " " << name;
4517   outs() << "\n";
4518
4519   outs() << "        vtable " << format("0x%" PRIx64, c.vtable);
4520   name = get_symbol_64(offset + offsetof(struct class64_t, vtable), S, info,
4521                        n_value, c.vtable);
4522   if (name != nullptr)
4523     outs() << " " << name;
4524   outs() << "\n";
4525
4526   name = get_symbol_64(offset + offsetof(struct class64_t, data), S, info,
4527                        n_value, c.data);
4528   outs() << "          data ";
4529   if (n_value != 0) {
4530     if (info->verbose && name != nullptr)
4531       outs() << name;
4532     else
4533       outs() << format("0x%" PRIx64, n_value);
4534     if (c.data != 0)
4535       outs() << " + " << format("0x%" PRIx64, c.data);
4536   } else
4537     outs() << format("0x%" PRIx64, c.data);
4538   outs() << " (struct class_ro_t *)";
4539
4540   // This is a Swift class if some of the low bits of the pointer are set.
4541   if ((c.data + n_value) & 0x7)
4542     outs() << " Swift class";
4543   outs() << "\n";
4544   bool is_meta_class;
4545   print_class_ro64_t((c.data + n_value) & ~0x7, info, is_meta_class);
4546
4547   if (is_meta_class == false) {
4548     outs() << "Meta Class\n";
4549     print_class64_t(c.isa + isa_n_value, info);
4550   }
4551 }
4552
4553 static void print_class32_t(uint32_t p, struct DisassembleInfo *info) {
4554   struct class32_t c;
4555   const char *r;
4556   uint32_t offset, left;
4557   SectionRef S;
4558   const char *name;
4559
4560   r = get_pointer_32(p, offset, left, S, info);
4561   if (r == nullptr)
4562     return;
4563   memset(&c, '\0', sizeof(struct class32_t));
4564   if (left < sizeof(struct class32_t)) {
4565     memcpy(&c, r, left);
4566     outs() << "   (class_t entends past the end of the section)\n";
4567   } else
4568     memcpy(&c, r, sizeof(struct class32_t));
4569   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4570     swapStruct(c);
4571
4572   outs() << "           isa " << format("0x%" PRIx32, c.isa);
4573   name =
4574       get_symbol_32(offset + offsetof(struct class32_t, isa), S, info, c.isa);
4575   if (name != nullptr)
4576     outs() << " " << name;
4577   outs() << "\n";
4578
4579   outs() << "    superclass " << format("0x%" PRIx32, c.superclass);
4580   name = get_symbol_32(offset + offsetof(struct class32_t, superclass), S, info,
4581                        c.superclass);
4582   if (name != nullptr)
4583     outs() << " " << name;
4584   outs() << "\n";
4585
4586   outs() << "         cache " << format("0x%" PRIx32, c.cache);
4587   name = get_symbol_32(offset + offsetof(struct class32_t, cache), S, info,
4588                        c.cache);
4589   if (name != nullptr)
4590     outs() << " " << name;
4591   outs() << "\n";
4592
4593   outs() << "        vtable " << format("0x%" PRIx32, c.vtable);
4594   name = get_symbol_32(offset + offsetof(struct class32_t, vtable), S, info,
4595                        c.vtable);
4596   if (name != nullptr)
4597     outs() << " " << name;
4598   outs() << "\n";
4599
4600   name =
4601       get_symbol_32(offset + offsetof(struct class32_t, data), S, info, c.data);
4602   outs() << "          data " << format("0x%" PRIx32, c.data)
4603          << " (struct class_ro_t *)";
4604
4605   // This is a Swift class if some of the low bits of the pointer are set.
4606   if (c.data & 0x3)
4607     outs() << " Swift class";
4608   outs() << "\n";
4609   bool is_meta_class;
4610   print_class_ro32_t(c.data & ~0x3, info, is_meta_class);
4611
4612   if (is_meta_class == false) {
4613     outs() << "Meta Class\n";
4614     print_class32_t(c.isa, info);
4615   }
4616 }
4617
4618 static void print_objc_class_t(struct objc_class_t *objc_class,
4619                                struct DisassembleInfo *info) {
4620   uint32_t offset, left, xleft;
4621   const char *name, *p, *ivar_list;
4622   SectionRef S;
4623   int32_t i;
4624   struct objc_ivar_list_t objc_ivar_list;
4625   struct objc_ivar_t ivar;
4626
4627   outs() << "\t\t      isa " << format("0x%08" PRIx32, objc_class->isa);
4628   if (info->verbose && CLS_GETINFO(objc_class, CLS_META)) {
4629     name = get_pointer_32(objc_class->isa, offset, left, S, info, true);
4630     if (name != nullptr)
4631       outs() << format(" %.*s", left, name);
4632     else
4633       outs() << " (not in an __OBJC section)";
4634   }
4635   outs() << "\n";
4636
4637   outs() << "\t      super_class "
4638          << format("0x%08" PRIx32, objc_class->super_class);
4639   if (info->verbose) {
4640     name = get_pointer_32(objc_class->super_class, offset, left, S, info, true);
4641     if (name != nullptr)
4642       outs() << format(" %.*s", left, name);
4643     else
4644       outs() << " (not in an __OBJC section)";
4645   }
4646   outs() << "\n";
4647
4648   outs() << "\t\t     name " << format("0x%08" PRIx32, objc_class->name);
4649   if (info->verbose) {
4650     name = get_pointer_32(objc_class->name, offset, left, S, info, true);
4651     if (name != nullptr)
4652       outs() << format(" %.*s", left, name);
4653     else
4654       outs() << " (not in an __OBJC section)";
4655   }
4656   outs() << "\n";
4657
4658   outs() << "\t\t  version " << format("0x%08" PRIx32, objc_class->version)
4659          << "\n";
4660
4661   outs() << "\t\t     info " << format("0x%08" PRIx32, objc_class->info);
4662   if (info->verbose) {
4663     if (CLS_GETINFO(objc_class, CLS_CLASS))
4664       outs() << " CLS_CLASS";
4665     else if (CLS_GETINFO(objc_class, CLS_META))
4666       outs() << " CLS_META";
4667   }
4668   outs() << "\n";
4669
4670   outs() << "\t    instance_size "
4671          << format("0x%08" PRIx32, objc_class->instance_size) << "\n";
4672
4673   p = get_pointer_32(objc_class->ivars, offset, left, S, info, true);
4674   outs() << "\t\t    ivars " << format("0x%08" PRIx32, objc_class->ivars);
4675   if (p != nullptr) {
4676     if (left > sizeof(struct objc_ivar_list_t)) {
4677       outs() << "\n";
4678       memcpy(&objc_ivar_list, p, sizeof(struct objc_ivar_list_t));
4679     } else {
4680       outs() << " (entends past the end of the section)\n";
4681       memset(&objc_ivar_list, '\0', sizeof(struct objc_ivar_list_t));
4682       memcpy(&objc_ivar_list, p, left);
4683     }
4684     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4685       swapStruct(objc_ivar_list);
4686     outs() << "\t\t       ivar_count " << objc_ivar_list.ivar_count << "\n";
4687     ivar_list = p + sizeof(struct objc_ivar_list_t);
4688     for (i = 0; i < objc_ivar_list.ivar_count; i++) {
4689       if ((i + 1) * sizeof(struct objc_ivar_t) > left) {
4690         outs() << "\t\t remaining ivar's extend past the of the section\n";
4691         break;
4692       }
4693       memcpy(&ivar, ivar_list + i * sizeof(struct objc_ivar_t),
4694              sizeof(struct objc_ivar_t));
4695       if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4696         swapStruct(ivar);
4697
4698       outs() << "\t\t\tivar_name " << format("0x%08" PRIx32, ivar.ivar_name);
4699       if (info->verbose) {
4700         name = get_pointer_32(ivar.ivar_name, offset, xleft, S, info, true);
4701         if (name != nullptr)
4702           outs() << format(" %.*s", xleft, name);
4703         else
4704           outs() << " (not in an __OBJC section)";
4705       }
4706       outs() << "\n";
4707
4708       outs() << "\t\t\tivar_type " << format("0x%08" PRIx32, ivar.ivar_type);
4709       if (info->verbose) {
4710         name = get_pointer_32(ivar.ivar_type, offset, xleft, S, info, true);
4711         if (name != nullptr)
4712           outs() << format(" %.*s", xleft, name);
4713         else
4714           outs() << " (not in an __OBJC section)";
4715       }
4716       outs() << "\n";
4717
4718       outs() << "\t\t      ivar_offset "
4719              << format("0x%08" PRIx32, ivar.ivar_offset) << "\n";
4720     }
4721   } else {
4722     outs() << " (not in an __OBJC section)\n";
4723   }
4724
4725   outs() << "\t\t  methods " << format("0x%08" PRIx32, objc_class->methodLists);
4726   if (print_method_list(objc_class->methodLists, info))
4727     outs() << " (not in an __OBJC section)\n";
4728
4729   outs() << "\t\t    cache " << format("0x%08" PRIx32, objc_class->cache)
4730          << "\n";
4731
4732   outs() << "\t\tprotocols " << format("0x%08" PRIx32, objc_class->protocols);
4733   if (print_protocol_list(objc_class->protocols, 16, info))
4734     outs() << " (not in an __OBJC section)\n";
4735 }
4736
4737 static void print_objc_objc_category_t(struct objc_category_t *objc_category,
4738                                        struct DisassembleInfo *info) {
4739   uint32_t offset, left;
4740   const char *name;
4741   SectionRef S;
4742
4743   outs() << "\t       category name "
4744          << format("0x%08" PRIx32, objc_category->category_name);
4745   if (info->verbose) {
4746     name = get_pointer_32(objc_category->category_name, offset, left, S, info,
4747                           true);
4748     if (name != nullptr)
4749       outs() << format(" %.*s", left, name);
4750     else
4751       outs() << " (not in an __OBJC section)";
4752   }
4753   outs() << "\n";
4754
4755   outs() << "\t\t  class name "
4756          << format("0x%08" PRIx32, objc_category->class_name);
4757   if (info->verbose) {
4758     name =
4759         get_pointer_32(objc_category->class_name, offset, left, S, info, true);
4760     if (name != nullptr)
4761       outs() << format(" %.*s", left, name);
4762     else
4763       outs() << " (not in an __OBJC section)";
4764   }
4765   outs() << "\n";
4766
4767   outs() << "\t    instance methods "
4768          << format("0x%08" PRIx32, objc_category->instance_methods);
4769   if (print_method_list(objc_category->instance_methods, info))
4770     outs() << " (not in an __OBJC section)\n";
4771
4772   outs() << "\t       class methods "
4773          << format("0x%08" PRIx32, objc_category->class_methods);
4774   if (print_method_list(objc_category->class_methods, info))
4775     outs() << " (not in an __OBJC section)\n";
4776 }
4777
4778 static void print_category64_t(uint64_t p, struct DisassembleInfo *info) {
4779   struct category64_t c;
4780   const char *r;
4781   uint32_t offset, xoffset, left;
4782   SectionRef S, xS;
4783   const char *name, *sym_name;
4784   uint64_t n_value;
4785
4786   r = get_pointer_64(p, offset, left, S, info);
4787   if (r == nullptr)
4788     return;
4789   memset(&c, '\0', sizeof(struct category64_t));
4790   if (left < sizeof(struct category64_t)) {
4791     memcpy(&c, r, left);
4792     outs() << "   (category_t entends past the end of the section)\n";
4793   } else
4794     memcpy(&c, r, sizeof(struct category64_t));
4795   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4796     swapStruct(c);
4797
4798   outs() << "              name ";
4799   sym_name = get_symbol_64(offset + offsetof(struct category64_t, name), S,
4800                            info, n_value, c.name);
4801   if (n_value != 0) {
4802     if (info->verbose && sym_name != nullptr)
4803       outs() << sym_name;
4804     else
4805       outs() << format("0x%" PRIx64, n_value);
4806     if (c.name != 0)
4807       outs() << " + " << format("0x%" PRIx64, c.name);
4808   } else
4809     outs() << format("0x%" PRIx64, c.name);
4810   name = get_pointer_64(c.name + n_value, xoffset, left, xS, info);
4811   if (name != nullptr)
4812     outs() << format(" %.*s", left, name);
4813   outs() << "\n";
4814
4815   outs() << "               cls ";
4816   sym_name = get_symbol_64(offset + offsetof(struct category64_t, cls), S, info,
4817                            n_value, c.cls);
4818   if (n_value != 0) {
4819     if (info->verbose && sym_name != nullptr)
4820       outs() << sym_name;
4821     else
4822       outs() << format("0x%" PRIx64, n_value);
4823     if (c.cls != 0)
4824       outs() << " + " << format("0x%" PRIx64, c.cls);
4825   } else
4826     outs() << format("0x%" PRIx64, c.cls);
4827   outs() << "\n";
4828   if (c.cls + n_value != 0)
4829     print_class64_t(c.cls + n_value, info);
4830
4831   outs() << "   instanceMethods ";
4832   sym_name =
4833       get_symbol_64(offset + offsetof(struct category64_t, instanceMethods), S,
4834                     info, n_value, c.instanceMethods);
4835   if (n_value != 0) {
4836     if (info->verbose && sym_name != nullptr)
4837       outs() << sym_name;
4838     else
4839       outs() << format("0x%" PRIx64, n_value);
4840     if (c.instanceMethods != 0)
4841       outs() << " + " << format("0x%" PRIx64, c.instanceMethods);
4842   } else
4843     outs() << format("0x%" PRIx64, c.instanceMethods);
4844   outs() << "\n";
4845   if (c.instanceMethods + n_value != 0)
4846     print_method_list64_t(c.instanceMethods + n_value, info, "");
4847
4848   outs() << "      classMethods ";
4849   sym_name = get_symbol_64(offset + offsetof(struct category64_t, classMethods),
4850                            S, info, n_value, c.classMethods);
4851   if (n_value != 0) {
4852     if (info->verbose && sym_name != nullptr)
4853       outs() << sym_name;
4854     else
4855       outs() << format("0x%" PRIx64, n_value);
4856     if (c.classMethods != 0)
4857       outs() << " + " << format("0x%" PRIx64, c.classMethods);
4858   } else
4859     outs() << format("0x%" PRIx64, c.classMethods);
4860   outs() << "\n";
4861   if (c.classMethods + n_value != 0)
4862     print_method_list64_t(c.classMethods + n_value, info, "");
4863
4864   outs() << "         protocols ";
4865   sym_name = get_symbol_64(offset + offsetof(struct category64_t, protocols), S,
4866                            info, n_value, c.protocols);
4867   if (n_value != 0) {
4868     if (info->verbose && sym_name != nullptr)
4869       outs() << sym_name;
4870     else
4871       outs() << format("0x%" PRIx64, n_value);
4872     if (c.protocols != 0)
4873       outs() << " + " << format("0x%" PRIx64, c.protocols);
4874   } else
4875     outs() << format("0x%" PRIx64, c.protocols);
4876   outs() << "\n";
4877   if (c.protocols + n_value != 0)
4878     print_protocol_list64_t(c.protocols + n_value, info);
4879
4880   outs() << "instanceProperties ";
4881   sym_name =
4882       get_symbol_64(offset + offsetof(struct category64_t, instanceProperties),
4883                     S, info, n_value, c.instanceProperties);
4884   if (n_value != 0) {
4885     if (info->verbose && sym_name != nullptr)
4886       outs() << sym_name;
4887     else
4888       outs() << format("0x%" PRIx64, n_value);
4889     if (c.instanceProperties != 0)
4890       outs() << " + " << format("0x%" PRIx64, c.instanceProperties);
4891   } else
4892     outs() << format("0x%" PRIx64, c.instanceProperties);
4893   outs() << "\n";
4894   if (c.instanceProperties + n_value != 0)
4895     print_objc_property_list64(c.instanceProperties + n_value, info);
4896 }
4897
4898 static void print_category32_t(uint32_t p, struct DisassembleInfo *info) {
4899   struct category32_t c;
4900   const char *r;
4901   uint32_t offset, left;
4902   SectionRef S, xS;
4903   const char *name;
4904
4905   r = get_pointer_32(p, offset, left, S, info);
4906   if (r == nullptr)
4907     return;
4908   memset(&c, '\0', sizeof(struct category32_t));
4909   if (left < sizeof(struct category32_t)) {
4910     memcpy(&c, r, left);
4911     outs() << "   (category_t entends past the end of the section)\n";
4912   } else
4913     memcpy(&c, r, sizeof(struct category32_t));
4914   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4915     swapStruct(c);
4916
4917   outs() << "              name " << format("0x%" PRIx32, c.name);
4918   name = get_symbol_32(offset + offsetof(struct category32_t, name), S, info,
4919                        c.name);
4920   if (name != NULL)
4921     outs() << " " << name;
4922   outs() << "\n";
4923
4924   outs() << "               cls " << format("0x%" PRIx32, c.cls) << "\n";
4925   if (c.cls != 0)
4926     print_class32_t(c.cls, info);
4927   outs() << "   instanceMethods " << format("0x%" PRIx32, c.instanceMethods)
4928          << "\n";
4929   if (c.instanceMethods != 0)
4930     print_method_list32_t(c.instanceMethods, info, "");
4931   outs() << "      classMethods " << format("0x%" PRIx32, c.classMethods)
4932          << "\n";
4933   if (c.classMethods != 0)
4934     print_method_list32_t(c.classMethods, info, "");
4935   outs() << "         protocols " << format("0x%" PRIx32, c.protocols) << "\n";
4936   if (c.protocols != 0)
4937     print_protocol_list32_t(c.protocols, info);
4938   outs() << "instanceProperties " << format("0x%" PRIx32, c.instanceProperties)
4939          << "\n";
4940   if (c.instanceProperties != 0)
4941     print_objc_property_list32(c.instanceProperties, info);
4942 }
4943
4944 static void print_message_refs64(SectionRef S, struct DisassembleInfo *info) {
4945   uint32_t i, left, offset, xoffset;
4946   uint64_t p, n_value;
4947   struct message_ref64 mr;
4948   const char *name, *sym_name;
4949   const char *r;
4950   SectionRef xS;
4951
4952   if (S == SectionRef())
4953     return;
4954
4955   StringRef SectName;
4956   S.getName(SectName);
4957   DataRefImpl Ref = S.getRawDataRefImpl();
4958   StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
4959   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
4960   offset = 0;
4961   for (i = 0; i < S.getSize(); i += sizeof(struct message_ref64)) {
4962     p = S.getAddress() + i;
4963     r = get_pointer_64(p, offset, left, S, info);
4964     if (r == nullptr)
4965       return;
4966     memset(&mr, '\0', sizeof(struct message_ref64));
4967     if (left < sizeof(struct message_ref64)) {
4968       memcpy(&mr, r, left);
4969       outs() << "   (message_ref entends past the end of the section)\n";
4970     } else
4971       memcpy(&mr, r, sizeof(struct message_ref64));
4972     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4973       swapStruct(mr);
4974
4975     outs() << "  imp ";
4976     name = get_symbol_64(offset + offsetof(struct message_ref64, imp), S, info,
4977                          n_value, mr.imp);
4978     if (n_value != 0) {
4979       outs() << format("0x%" PRIx64, n_value) << " ";
4980       if (mr.imp != 0)
4981         outs() << "+ " << format("0x%" PRIx64, mr.imp) << " ";
4982     } else
4983       outs() << format("0x%" PRIx64, mr.imp) << " ";
4984     if (name != nullptr)
4985       outs() << " " << name;
4986     outs() << "\n";
4987
4988     outs() << "  sel ";
4989     sym_name = get_symbol_64(offset + offsetof(struct message_ref64, sel), S,
4990                              info, n_value, mr.sel);
4991     if (n_value != 0) {
4992       if (info->verbose && sym_name != nullptr)
4993         outs() << sym_name;
4994       else
4995         outs() << format("0x%" PRIx64, n_value);
4996       if (mr.sel != 0)
4997         outs() << " + " << format("0x%" PRIx64, mr.sel);
4998     } else
4999       outs() << format("0x%" PRIx64, mr.sel);
5000     name = get_pointer_64(mr.sel + n_value, xoffset, left, xS, info);
5001     if (name != nullptr)
5002       outs() << format(" %.*s", left, name);
5003     outs() << "\n";
5004
5005     offset += sizeof(struct message_ref64);
5006   }
5007 }
5008
5009 static void print_message_refs32(SectionRef S, struct DisassembleInfo *info) {
5010   uint32_t i, left, offset, xoffset, p;
5011   struct message_ref32 mr;
5012   const char *name, *r;
5013   SectionRef xS;
5014
5015   if (S == SectionRef())
5016     return;
5017
5018   StringRef SectName;
5019   S.getName(SectName);
5020   DataRefImpl Ref = S.getRawDataRefImpl();
5021   StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
5022   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
5023   offset = 0;
5024   for (i = 0; i < S.getSize(); i += sizeof(struct message_ref64)) {
5025     p = S.getAddress() + i;
5026     r = get_pointer_32(p, offset, left, S, info);
5027     if (r == nullptr)
5028       return;
5029     memset(&mr, '\0', sizeof(struct message_ref32));
5030     if (left < sizeof(struct message_ref32)) {
5031       memcpy(&mr, r, left);
5032       outs() << "   (message_ref entends past the end of the section)\n";
5033     } else
5034       memcpy(&mr, r, sizeof(struct message_ref32));
5035     if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5036       swapStruct(mr);
5037
5038     outs() << "  imp " << format("0x%" PRIx32, mr.imp);
5039     name = get_symbol_32(offset + offsetof(struct message_ref32, imp), S, info,
5040                          mr.imp);
5041     if (name != nullptr)
5042       outs() << " " << name;
5043     outs() << "\n";
5044
5045     outs() << "  sel " << format("0x%" PRIx32, mr.sel);
5046     name = get_pointer_32(mr.sel, xoffset, left, xS, info);
5047     if (name != nullptr)
5048       outs() << " " << name;
5049     outs() << "\n";
5050
5051     offset += sizeof(struct message_ref32);
5052   }
5053 }
5054
5055 static void print_image_info64(SectionRef S, struct DisassembleInfo *info) {
5056   uint32_t left, offset, swift_version;
5057   uint64_t p;
5058   struct objc_image_info64 o;
5059   const char *r;
5060
5061   StringRef SectName;
5062   S.getName(SectName);
5063   DataRefImpl Ref = S.getRawDataRefImpl();
5064   StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
5065   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
5066   p = S.getAddress();
5067   r = get_pointer_64(p, offset, left, S, info);
5068   if (r == nullptr)
5069     return;
5070   memset(&o, '\0', sizeof(struct objc_image_info64));
5071   if (left < sizeof(struct objc_image_info64)) {
5072     memcpy(&o, r, left);
5073     outs() << "   (objc_image_info entends past the end of the section)\n";
5074   } else
5075     memcpy(&o, r, sizeof(struct objc_image_info64));
5076   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5077     swapStruct(o);
5078   outs() << "  version " << o.version << "\n";
5079   outs() << "    flags " << format("0x%" PRIx32, o.flags);
5080   if (o.flags & OBJC_IMAGE_IS_REPLACEMENT)
5081     outs() << " OBJC_IMAGE_IS_REPLACEMENT";
5082   if (o.flags & OBJC_IMAGE_SUPPORTS_GC)
5083     outs() << " OBJC_IMAGE_SUPPORTS_GC";
5084   swift_version = (o.flags >> 8) & 0xff;
5085   if (swift_version != 0) {
5086     if (swift_version == 1)
5087       outs() << " Swift 1.0";
5088     else if (swift_version == 2)
5089       outs() << " Swift 1.1";
5090     else
5091       outs() << " unknown future Swift version (" << swift_version << ")";
5092   }
5093   outs() << "\n";
5094 }
5095
5096 static void print_image_info32(SectionRef S, struct DisassembleInfo *info) {
5097   uint32_t left, offset, swift_version, p;
5098   struct objc_image_info32 o;
5099   const char *r;
5100
5101   StringRef SectName;
5102   S.getName(SectName);
5103   DataRefImpl Ref = S.getRawDataRefImpl();
5104   StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
5105   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
5106   p = S.getAddress();
5107   r = get_pointer_32(p, offset, left, S, info);
5108   if (r == nullptr)
5109     return;
5110   memset(&o, '\0', sizeof(struct objc_image_info32));
5111   if (left < sizeof(struct objc_image_info32)) {
5112     memcpy(&o, r, left);
5113     outs() << "   (objc_image_info entends past the end of the section)\n";
5114   } else
5115     memcpy(&o, r, sizeof(struct objc_image_info32));
5116   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5117     swapStruct(o);
5118   outs() << "  version " << o.version << "\n";
5119   outs() << "    flags " << format("0x%" PRIx32, o.flags);
5120   if (o.flags & OBJC_IMAGE_IS_REPLACEMENT)
5121     outs() << " OBJC_IMAGE_IS_REPLACEMENT";
5122   if (o.flags & OBJC_IMAGE_SUPPORTS_GC)
5123     outs() << " OBJC_IMAGE_SUPPORTS_GC";
5124   swift_version = (o.flags >> 8) & 0xff;
5125   if (swift_version != 0) {
5126     if (swift_version == 1)
5127       outs() << " Swift 1.0";
5128     else if (swift_version == 2)
5129       outs() << " Swift 1.1";
5130     else
5131       outs() << " unknown future Swift version (" << swift_version << ")";
5132   }
5133   outs() << "\n";
5134 }
5135
5136 static void print_image_info(SectionRef S, struct DisassembleInfo *info) {
5137   uint32_t left, offset, p;
5138   struct imageInfo_t o;
5139   const char *r;
5140
5141   StringRef SectName;
5142   S.getName(SectName);
5143   DataRefImpl Ref = S.getRawDataRefImpl();
5144   StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
5145   outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
5146   p = S.getAddress();
5147   r = get_pointer_32(p, offset, left, S, info);
5148   if (r == nullptr)
5149     return;
5150   memset(&o, '\0', sizeof(struct imageInfo_t));
5151   if (left < sizeof(struct imageInfo_t)) {
5152     memcpy(&o, r, left);
5153     outs() << " (imageInfo entends past the end of the section)\n";
5154   } else
5155     memcpy(&o, r, sizeof(struct imageInfo_t));
5156   if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5157     swapStruct(o);
5158   outs() << "  version " << o.version << "\n";
5159   outs() << "    flags " << format("0x%" PRIx32, o.flags);
5160   if (o.flags & 0x1)
5161     outs() << "  F&C";
5162   if (o.flags & 0x2)
5163     outs() << " GC";
5164   if (o.flags & 0x4)
5165     outs() << " GC-only";
5166   else
5167     outs() << " RR";
5168   outs() << "\n";
5169 }
5170
5171 static void printObjc2_64bit_MetaData(MachOObjectFile *O, bool verbose) {
5172   SymbolAddressMap AddrMap;
5173   if (verbose)
5174     CreateSymbolAddressMap(O, &AddrMap);
5175
5176   std::vector<SectionRef> Sections;
5177   for (const SectionRef &Section : O->sections()) {
5178     StringRef SectName;
5179     Section.getName(SectName);
5180     Sections.push_back(Section);
5181   }
5182
5183   struct DisassembleInfo info;
5184   // Set up the block of info used by the Symbolizer call backs.
5185   info.verbose = verbose;
5186   info.O = O;
5187   info.AddrMap = &AddrMap;
5188   info.Sections = &Sections;
5189   info.class_name = nullptr;
5190   info.selector_name = nullptr;
5191   info.method = nullptr;
5192   info.demangled_name = nullptr;
5193   info.bindtable = nullptr;
5194   info.adrp_addr = 0;
5195   info.adrp_inst = 0;
5196
5197   const SectionRef CL = get_section(O, "__OBJC2", "__class_list");
5198   if (CL != SectionRef()) {
5199     info.S = CL;
5200     walk_pointer_list_64("class", CL, O, &info, print_class64_t);
5201   } else {
5202     const SectionRef CL = get_section(O, "__DATA", "__objc_classlist");
5203     info.S = CL;
5204     walk_pointer_list_64("class", CL, O, &info, print_class64_t);
5205   }
5206
5207   const SectionRef CR = get_section(O, "__OBJC2", "__class_refs");
5208   if (CR != SectionRef()) {
5209     info.S = CR;
5210     walk_pointer_list_64("class refs", CR, O, &info, nullptr);
5211   } else {
5212     const SectionRef CR = get_section(O, "__DATA", "__objc_classrefs");
5213     info.S = CR;
5214     walk_pointer_list_64("class refs", CR, O, &info, nullptr);
5215   }
5216
5217   const SectionRef SR = get_section(O, "__OBJC2", "__super_refs");
5218   if (SR != SectionRef()) {
5219     info.S = SR;
5220     walk_pointer_list_64("super refs", SR, O, &info, nullptr);
5221   } else {
5222     const SectionRef SR = get_section(O, "__DATA", "__objc_superrefs");
5223     info.S = SR;
5224     walk_pointer_list_64("super refs", SR, O, &info, nullptr);
5225   }
5226
5227   const SectionRef CA = get_section(O, "__OBJC2", "__category_list");
5228   if (CA != SectionRef()) {
5229     info.S = CA;
5230     walk_pointer_list_64("category", CA, O, &info, print_category64_t);
5231   } else {
5232     const SectionRef CA = get_section(O, "__DATA", "__objc_catlist");
5233     info.S = CA;
5234     walk_pointer_list_64("category", CA, O, &info, print_category64_t);
5235   }
5236
5237   const SectionRef PL = get_section(O, "__OBJC2", "__protocol_list");
5238   if (PL != SectionRef()) {
5239     info.S = PL;
5240     walk_pointer_list_64("protocol", PL, O, &info, nullptr);
5241   } else {
5242     const SectionRef PL = get_section(O, "__DATA", "__objc_protolist");
5243     info.S = PL;
5244     walk_pointer_list_64("protocol", PL, O, &info, nullptr);
5245   }
5246
5247   const SectionRef MR = get_section(O, "__OBJC2", "__message_refs");
5248   if (MR != SectionRef()) {
5249     info.S = MR;
5250     print_message_refs64(MR, &info);
5251   } else {
5252     const SectionRef MR = get_section(O, "__DATA", "__objc_msgrefs");
5253     info.S = MR;
5254     print_message_refs64(MR, &info);
5255   }
5256
5257   const SectionRef II = get_section(O, "__OBJC2", "__image_info");
5258   if (II != SectionRef()) {
5259     info.S = II;
5260     print_image_info64(II, &info);
5261   } else {
5262     const SectionRef II = get_section(O, "__DATA", "__objc_imageinfo");
5263     info.S = II;
5264     print_image_info64(II, &info);
5265   }
5266
5267   if (info.bindtable != nullptr)
5268     delete info.bindtable;
5269 }
5270
5271 static void printObjc2_32bit_MetaData(MachOObjectFile *O, bool verbose) {
5272   SymbolAddressMap AddrMap;
5273   if (verbose)
5274     CreateSymbolAddressMap(O, &AddrMap);
5275
5276   std::vector<SectionRef> Sections;
5277   for (const SectionRef &Section : O->sections()) {
5278     StringRef SectName;
5279     Section.getName(SectName);
5280     Sections.push_back(Section);
5281   }
5282
5283   struct DisassembleInfo info;
5284   // Set up the block of info used by the Symbolizer call backs.
5285   info.verbose = verbose;
5286   info.O = O;
5287   info.AddrMap = &AddrMap;
5288   info.Sections = &Sections;
5289   info.class_name = nullptr;
5290   info.selector_name = nullptr;
5291   info.method = nullptr;
5292   info.demangled_name = nullptr;
5293   info.bindtable = nullptr;
5294   info.adrp_addr = 0;
5295   info.adrp_inst = 0;
5296
5297   const SectionRef CL = get_section(O, "__OBJC2", "__class_list");
5298   if (CL != SectionRef()) {
5299     info.S = CL;
5300     walk_pointer_list_32("class", CL, O, &info, print_class32_t);
5301   } else {
5302     const SectionRef CL = get_section(O, "__DATA", "__objc_classlist");
5303     info.S = CL;
5304     walk_pointer_list_32("class", CL, O, &info, print_class32_t);
5305   }
5306
5307   const SectionRef CR = get_section(O, "__OBJC2", "__class_refs");
5308   if (CR != SectionRef()) {
5309     info.S = CR;
5310     walk_pointer_list_32("class refs", CR, O, &info, nullptr);
5311   } else {
5312     const SectionRef CR = get_section(O, "__DATA", "__objc_classrefs");
5313     info.S = CR;
5314     walk_pointer_list_32("class refs", CR, O, &info, nullptr);
5315   }
5316
5317   const SectionRef SR = get_section(O, "__OBJC2", "__super_refs");
5318   if (SR != SectionRef()) {
5319     info.S = SR;
5320     walk_pointer_list_32("super refs", SR, O, &info, nullptr);
5321   } else {
5322     const SectionRef SR = get_section(O, "__DATA", "__objc_superrefs");
5323     info.S = SR;
5324     walk_pointer_list_32("super refs", SR, O, &info, nullptr);
5325   }
5326
5327   const SectionRef CA = get_section(O, "__OBJC2", "__category_list");
5328   if (CA != SectionRef()) {
5329     info.S = CA;
5330     walk_pointer_list_32("category", CA, O, &info, print_category32_t);
5331   } else {
5332     const SectionRef CA = get_section(O, "__DATA", "__objc_catlist");
5333     info.S = CA;
5334     walk_pointer_list_32("category", CA, O, &info, print_category32_t);
5335   }
5336
5337   const SectionRef PL = get_section(O, "__OBJC2", "__protocol_list");
5338   if (PL != SectionRef()) {
5339     info.S = PL;
5340     walk_pointer_list_32("protocol", PL, O, &info, nullptr);
5341   } else {
5342     const SectionRef PL = get_section(O, "__DATA", "__objc_protolist");
5343     info.S = PL;
5344     walk_pointer_list_32("protocol", PL, O, &info, nullptr);
5345   }
5346
5347   const SectionRef MR = get_section(O, "__OBJC2", "__message_refs");
5348   if (MR != SectionRef()) {
5349     info.S = MR;
5350     print_message_refs32(MR, &info);
5351   } else {
5352     const SectionRef MR = get_section(O, "__DATA", "__objc_msgrefs");
5353     info.S = MR;
5354     print_message_refs32(MR, &info);
5355   }
5356
5357   const SectionRef II = get_section(O, "__OBJC2", "__image_info");
5358   if (II != SectionRef()) {
5359     info.S = II;
5360     print_image_info32(II, &info);
5361   } else {
5362     const SectionRef II = get_section(O, "__DATA", "__objc_imageinfo");
5363     info.S = II;
5364     print_image_info32(II, &info);
5365   }
5366 }
5367
5368 static bool printObjc1_32bit_MetaData(MachOObjectFile *O, bool verbose) {
5369   uint32_t i, j, p, offset, xoffset, left, defs_left, def;
5370   const char *r, *name, *defs;
5371   struct objc_module_t module;
5372   SectionRef S, xS;
5373   struct objc_symtab_t symtab;
5374   struct objc_class_t objc_class;
5375   struct objc_category_t objc_category;
5376
5377   outs() << "Objective-C segment\n";
5378   S = get_section(O, "__OBJC", "__module_info");
5379   if (S == SectionRef())
5380     return false;
5381
5382   SymbolAddressMap AddrMap;
5383   if (verbose)
5384     CreateSymbolAddressMap(O, &AddrMap);
5385
5386   std::vector<SectionRef> Sections;
5387   for (const SectionRef &Section : O->sections()) {
5388     StringRef SectName;
5389     Section.getName(SectName);
5390     Sections.push_back(Section);
5391   }
5392
5393   struct DisassembleInfo info;
5394   // Set up the block of info used by the Symbolizer call backs.
5395   info.verbose = verbose;
5396   info.O = O;
5397   info.AddrMap = &AddrMap;
5398   info.Sections = &Sections;
5399   info.class_name = nullptr;
5400   info.selector_name = nullptr;
5401   info.method = nullptr;
5402   info.demangled_name = nullptr;
5403   info.bindtable = nullptr;
5404   info.adrp_addr = 0;
5405   info.adrp_inst = 0;
5406
5407   for (i = 0; i < S.getSize(); i += sizeof(struct objc_module_t)) {
5408     p = S.getAddress() + i;
5409     r = get_pointer_32(p, offset, left, S, &info, true);
5410     if (r == nullptr)
5411       return true;
5412     memset(&module, '\0', sizeof(struct objc_module_t));
5413     if (left < sizeof(struct objc_module_t)) {
5414       memcpy(&module, r, left);
5415       outs() << "   (module extends past end of __module_info section)\n";
5416     } else
5417       memcpy(&module, r, sizeof(struct objc_module_t));
5418     if (O->isLittleEndian() != sys::IsLittleEndianHost)
5419       swapStruct(module);
5420
5421     outs() << "Module " << format("0x%" PRIx32, p) << "\n";
5422     outs() << "    version " << module.version << "\n";
5423     outs() << "       size " << module.size << "\n";
5424     outs() << "       name ";
5425     name = get_pointer_32(module.name, xoffset, left, xS, &info, true);
5426     if (name != nullptr)
5427       outs() << format("%.*s", left, name);
5428     else
5429       outs() << format("0x%08" PRIx32, module.name)
5430              << "(not in an __OBJC section)";
5431     outs() << "\n";
5432
5433     r = get_pointer_32(module.symtab, xoffset, left, xS, &info, true);
5434     if (module.symtab == 0 || r == nullptr) {
5435       outs() << "     symtab " << format("0x%08" PRIx32, module.symtab)
5436              << " (not in an __OBJC section)\n";
5437       continue;
5438     }
5439     outs() << "     symtab " << format("0x%08" PRIx32, module.symtab) << "\n";
5440     memset(&symtab, '\0', sizeof(struct objc_symtab_t));
5441     defs_left = 0;
5442     defs = nullptr;
5443     if (left < sizeof(struct objc_symtab_t)) {
5444       memcpy(&symtab, r, left);
5445       outs() << "\tsymtab extends past end of an __OBJC section)\n";
5446     } else {
5447       memcpy(&symtab, r, sizeof(struct objc_symtab_t));
5448       if (left > sizeof(struct objc_symtab_t)) {
5449         defs_left = left - sizeof(struct objc_symtab_t);
5450         defs = r + sizeof(struct objc_symtab_t);
5451       }
5452     }
5453     if (O->isLittleEndian() != sys::IsLittleEndianHost)
5454       swapStruct(symtab);
5455
5456     outs() << "\tsel_ref_cnt " << symtab.sel_ref_cnt << "\n";
5457     r = get_pointer_32(symtab.refs, xoffset, left, xS, &info, true);
5458     outs() << "\trefs " << format("0x%08" PRIx32, symtab.refs);
5459     if (r == nullptr)
5460       outs() << " (not in an __OBJC section)";
5461     outs() << "\n";
5462     outs() << "\tcls_def_cnt " << symtab.cls_def_cnt << "\n";
5463     outs() << "\tcat_def_cnt " << symtab.cat_def_cnt << "\n";
5464     if (symtab.cls_def_cnt > 0)
5465       outs() << "\tClass Definitions\n";
5466     for (j = 0; j < symtab.cls_def_cnt; j++) {
5467       if ((j + 1) * sizeof(uint32_t) > defs_left) {
5468         outs() << "\t(remaining class defs entries entends past the end of the "
5469                << "section)\n";
5470         break;
5471       }
5472       memcpy(&def, defs + j * sizeof(uint32_t), sizeof(uint32_t));
5473       if (O->isLittleEndian() != sys::IsLittleEndianHost)
5474         sys::swapByteOrder(def);
5475
5476       r = get_pointer_32(def, xoffset, left, xS, &info, true);
5477       outs() << "\tdefs[" << j << "] " << format("0x%08" PRIx32, def);
5478       if (r != nullptr) {
5479         if (left > sizeof(struct objc_class_t)) {
5480           outs() << "\n";
5481           memcpy(&objc_class, r, sizeof(struct objc_class_t));
5482         } else {
5483           outs() << " (entends past the end of the section)\n";
5484           memset(&objc_class, '\0', sizeof(struct objc_class_t));
5485           memcpy(&objc_class, r, left);
5486         }
5487         if (O->isLittleEndian() != sys::IsLittleEndianHost)
5488           swapStruct(objc_class);
5489         print_objc_class_t(&objc_class, &info);
5490       } else {
5491         outs() << "(not in an __OBJC section)\n";
5492       }
5493
5494       if (CLS_GETINFO(&objc_class, CLS_CLASS)) {
5495         outs() << "\tMeta Class";
5496         r = get_pointer_32(objc_class.isa, xoffset, left, xS, &info, true);
5497         if (r != nullptr) {
5498           if (left > sizeof(struct objc_class_t)) {
5499             outs() << "\n";
5500             memcpy(&objc_class, r, sizeof(struct objc_class_t));
5501           } else {
5502             outs() << " (entends past the end of the section)\n";
5503             memset(&objc_class, '\0', sizeof(struct objc_class_t));
5504             memcpy(&objc_class, r, left);
5505           }
5506           if (O->isLittleEndian() != sys::IsLittleEndianHost)
5507             swapStruct(objc_class);
5508           print_objc_class_t(&objc_class, &info);
5509         } else {
5510           outs() << "(not in an __OBJC section)\n";
5511         }
5512       }
5513     }
5514     if (symtab.cat_def_cnt > 0)
5515       outs() << "\tCategory Definitions\n";
5516     for (j = 0; j < symtab.cat_def_cnt; j++) {
5517       if ((j + symtab.cls_def_cnt + 1) * sizeof(uint32_t) > defs_left) {
5518         outs() << "\t(remaining category defs entries entends past the end of "
5519                << "the section)\n";
5520         break;
5521       }
5522       memcpy(&def, defs + (j + symtab.cls_def_cnt) * sizeof(uint32_t),
5523              sizeof(uint32_t));
5524       if (O->isLittleEndian() != sys::IsLittleEndianHost)
5525         sys::swapByteOrder(def);
5526
5527       r = get_pointer_32(def, xoffset, left, xS, &info, true);
5528       outs() << "\tdefs[" << j + symtab.cls_def_cnt << "] "
5529              << format("0x%08" PRIx32, def);
5530       if (r != nullptr) {
5531         if (left > sizeof(struct objc_category_t)) {
5532           outs() << "\n";
5533           memcpy(&objc_category, r, sizeof(struct objc_category_t));
5534         } else {
5535           outs() << " (entends past the end of the section)\n";
5536           memset(&objc_category, '\0', sizeof(struct objc_category_t));
5537           memcpy(&objc_category, r, left);
5538         }
5539         if (O->isLittleEndian() != sys::IsLittleEndianHost)
5540           swapStruct(objc_category);
5541         print_objc_objc_category_t(&objc_category, &info);
5542       } else {
5543         outs() << "(not in an __OBJC section)\n";
5544       }
5545     }
5546   }
5547   const SectionRef II = get_section(O, "__OBJC", "__image_info");
5548   if (II != SectionRef())
5549     print_image_info(II, &info);
5550
5551   return true;
5552 }
5553
5554 static void DumpProtocolSection(MachOObjectFile *O, const char *sect,
5555                                 uint32_t size, uint32_t addr) {
5556   SymbolAddressMap AddrMap;
5557   CreateSymbolAddressMap(O, &AddrMap);
5558
5559   std::vector<SectionRef> Sections;
5560   for (const SectionRef &Section : O->sections()) {
5561     StringRef SectName;
5562     Section.getName(SectName);
5563     Sections.push_back(Section);
5564   }
5565
5566   struct DisassembleInfo info;
5567   // Set up the block of info used by the Symbolizer call backs.
5568   info.verbose = true;
5569   info.O = O;
5570   info.AddrMap = &AddrMap;
5571   info.Sections = &Sections;
5572   info.class_name = nullptr;
5573   info.selector_name = nullptr;
5574   info.method = nullptr;
5575   info.demangled_name = nullptr;
5576   info.bindtable = nullptr;
5577   info.adrp_addr = 0;
5578   info.adrp_inst = 0;
5579
5580   const char *p;
5581   struct objc_protocol_t protocol;
5582   uint32_t left, paddr;
5583   for (p = sect; p < sect + size; p += sizeof(struct objc_protocol_t)) {
5584     memset(&protocol, '\0', sizeof(struct objc_protocol_t));
5585     left = size - (p - sect);
5586     if (left < sizeof(struct objc_protocol_t)) {
5587       outs() << "Protocol extends past end of __protocol section\n";
5588       memcpy(&protocol, p, left);
5589     } else
5590       memcpy(&protocol, p, sizeof(struct objc_protocol_t));
5591     if (O->isLittleEndian() != sys::IsLittleEndianHost)
5592       swapStruct(protocol);
5593     paddr = addr + (p - sect);
5594     outs() << "Protocol " << format("0x%" PRIx32, paddr);
5595     if (print_protocol(paddr, 0, &info))
5596       outs() << "(not in an __OBJC section)\n";
5597   }
5598 }
5599
5600 static void printObjcMetaData(MachOObjectFile *O, bool verbose) {
5601   if (O->is64Bit())
5602     printObjc2_64bit_MetaData(O, verbose);
5603   else {
5604     MachO::mach_header H;
5605     H = O->getHeader();
5606     if (H.cputype == MachO::CPU_TYPE_ARM)
5607       printObjc2_32bit_MetaData(O, verbose);
5608     else {
5609       // This is the 32-bit non-arm cputype case.  Which is normally
5610       // the first Objective-C ABI.  But it may be the case of a
5611       // binary for the iOS simulator which is the second Objective-C
5612       // ABI.  In that case printObjc1_32bit_MetaData() will determine that
5613       // and return false.
5614       if (printObjc1_32bit_MetaData(O, verbose) == false)
5615         printObjc2_32bit_MetaData(O, verbose);
5616     }
5617   }
5618 }
5619
5620 // GuessLiteralPointer returns a string which for the item in the Mach-O file
5621 // for the address passed in as ReferenceValue for printing as a comment with
5622 // the instruction and also returns the corresponding type of that item
5623 // indirectly through ReferenceType.
5624 //
5625 // If ReferenceValue is an address of literal cstring then a pointer to the
5626 // cstring is returned and ReferenceType is set to
5627 // LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr .
5628 //
5629 // If ReferenceValue is an address of an Objective-C CFString, Selector ref or
5630 // Class ref that name is returned and the ReferenceType is set accordingly.
5631 //
5632 // Lastly, literals which are Symbol address in a literal pool are looked for
5633 // and if found the symbol name is returned and ReferenceType is set to
5634 // LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr .
5635 //
5636 // If there is no item in the Mach-O file for the address passed in as
5637 // ReferenceValue nullptr is returned and ReferenceType is unchanged.
5638 static const char *GuessLiteralPointer(uint64_t ReferenceValue,
5639                                        uint64_t ReferencePC,
5640                                        uint64_t *ReferenceType,
5641                                        struct DisassembleInfo *info) {
5642   // First see if there is an external relocation entry at the ReferencePC.
5643   uint64_t sect_addr = info->S.getAddress();
5644   uint64_t sect_offset = ReferencePC - sect_addr;
5645   bool reloc_found = false;
5646   DataRefImpl Rel;
5647   MachO::any_relocation_info RE;
5648   bool isExtern = false;
5649   SymbolRef Symbol;
5650   for (const RelocationRef &Reloc : info->S.relocations()) {
5651     uint64_t RelocOffset;
5652     Reloc.getOffset(RelocOffset);
5653     if (RelocOffset == sect_offset) {
5654       Rel = Reloc.getRawDataRefImpl();
5655       RE = info->O->getRelocation(Rel);
5656       if (info->O->isRelocationScattered(RE))
5657         continue;
5658       isExtern = info->O->getPlainRelocationExternal(RE);
5659       if (isExtern) {
5660         symbol_iterator RelocSym = Reloc.getSymbol();
5661         Symbol = *RelocSym;
5662       }
5663       reloc_found = true;
5664       break;
5665     }
5666   }
5667   // If there is an external relocation entry for a symbol in a section
5668   // then used that symbol's value for the value of the reference.
5669   if (reloc_found && isExtern) {
5670     if (info->O->getAnyRelocationPCRel(RE)) {
5671       unsigned Type = info->O->getAnyRelocationType(RE);
5672       if (Type == MachO::X86_64_RELOC_SIGNED) {
5673         Symbol.getAddress(ReferenceValue);
5674       }
5675     }
5676   }
5677
5678   // Look for literals such as Objective-C CFStrings refs, Selector refs,
5679   // Message refs and Class refs.
5680   bool classref, selref, msgref, cfstring;
5681   uint64_t pointer_value = GuessPointerPointer(ReferenceValue, info, classref,
5682                                                selref, msgref, cfstring);
5683   if (classref && pointer_value == 0) {
5684     // Note the ReferenceValue is a pointer into the __objc_classrefs section.
5685     // And the pointer_value in that section is typically zero as it will be
5686     // set by dyld as part of the "bind information".
5687     const char *name = get_dyld_bind_info_symbolname(ReferenceValue, info);
5688     if (name != nullptr) {
5689       *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref;
5690       const char *class_name = strrchr(name, '$');
5691       if (class_name != nullptr && class_name[1] == '_' &&
5692           class_name[2] != '\0') {
5693         info->class_name = class_name + 2;
5694         return name;
5695       }
5696     }
5697   }
5698
5699   if (classref) {
5700     *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref;
5701     const char *name =
5702         get_objc2_64bit_class_name(pointer_value, ReferenceValue, info);
5703     if (name != nullptr)
5704       info->class_name = name;
5705     else
5706       name = "bad class ref";
5707     return name;
5708   }
5709
5710   if (cfstring) {
5711     *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref;
5712     const char *name = get_objc2_64bit_cfstring_name(ReferenceValue, info);
5713     return name;
5714   }
5715
5716   if (selref && pointer_value == 0)
5717     pointer_value = get_objc2_64bit_selref(ReferenceValue, info);
5718
5719   if (pointer_value != 0)
5720     ReferenceValue = pointer_value;
5721
5722   const char *name = GuessCstringPointer(ReferenceValue, info);
5723   if (name) {
5724     if (pointer_value != 0 && selref) {
5725       *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref;
5726       info->selector_name = name;
5727     } else if (pointer_value != 0 && msgref) {
5728       info->class_name = nullptr;
5729       *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref;
5730       info->selector_name = name;
5731     } else
5732       *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr;
5733     return name;
5734   }
5735
5736   // Lastly look for an indirect symbol with this ReferenceValue which is in
5737   // a literal pool.  If found return that symbol name.
5738   name = GuessIndirectSymbol(ReferenceValue, info);
5739   if (name) {
5740     *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr;
5741     return name;
5742   }
5743
5744   return nullptr;
5745 }
5746
5747 // SymbolizerSymbolLookUp is the symbol lookup function passed when creating
5748 // the Symbolizer.  It looks up the ReferenceValue using the info passed via the
5749 // pointer to the struct DisassembleInfo that was passed when MCSymbolizer
5750 // is created and returns the symbol name that matches the ReferenceValue or
5751 // nullptr if none.  The ReferenceType is passed in for the IN type of
5752 // reference the instruction is making from the values in defined in the header
5753 // "llvm-c/Disassembler.h".  On return the ReferenceType can set to a specific
5754 // Out type and the ReferenceName will also be set which is added as a comment
5755 // to the disassembled instruction.
5756 //
5757 #if HAVE_CXXABI_H
5758 // If the symbol name is a C++ mangled name then the demangled name is
5759 // returned through ReferenceName and ReferenceType is set to
5760 // LLVMDisassembler_ReferenceType_DeMangled_Name .
5761 #endif
5762 //
5763 // When this is called to get a symbol name for a branch target then the
5764 // ReferenceType will be LLVMDisassembler_ReferenceType_In_Branch and then
5765 // SymbolValue will be looked for in the indirect symbol table to determine if
5766 // it is an address for a symbol stub.  If so then the symbol name for that
5767 // stub is returned indirectly through ReferenceName and then ReferenceType is
5768 // set to LLVMDisassembler_ReferenceType_Out_SymbolStub.
5769 //
5770 // When this is called with an value loaded via a PC relative load then
5771 // ReferenceType will be LLVMDisassembler_ReferenceType_In_PCrel_Load then the
5772 // SymbolValue is checked to be an address of literal pointer, symbol pointer,
5773 // or an Objective-C meta data reference.  If so the output ReferenceType is
5774 // set to correspond to that as well as setting the ReferenceName.
5775 static const char *SymbolizerSymbolLookUp(void *DisInfo,
5776                                           uint64_t ReferenceValue,
5777                                           uint64_t *ReferenceType,
5778                                           uint64_t ReferencePC,
5779                                           const char **ReferenceName) {
5780   struct DisassembleInfo *info = (struct DisassembleInfo *)DisInfo;
5781   // If no verbose symbolic information is wanted then just return nullptr.
5782   if (!info->verbose) {
5783     *ReferenceName = nullptr;
5784     *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5785     return nullptr;
5786   }
5787
5788   const char *SymbolName = GuessSymbolName(ReferenceValue, info->AddrMap);
5789
5790   if (*ReferenceType == LLVMDisassembler_ReferenceType_In_Branch) {
5791     *ReferenceName = GuessIndirectSymbol(ReferenceValue, info);
5792     if (*ReferenceName != nullptr) {
5793       method_reference(info, ReferenceType, ReferenceName);
5794       if (*ReferenceType != LLVMDisassembler_ReferenceType_Out_Objc_Message)
5795         *ReferenceType = LLVMDisassembler_ReferenceType_Out_SymbolStub;
5796     } else
5797 #if HAVE_CXXABI_H
5798         if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) {
5799       if (info->demangled_name != nullptr)
5800         free(info->demangled_name);
5801       int status;
5802       info->demangled_name =
5803           abi::__cxa_demangle(SymbolName + 1, nullptr, nullptr, &status);
5804       if (info->demangled_name != nullptr) {
5805         *ReferenceName = info->demangled_name;
5806         *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name;
5807       } else
5808         *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5809     } else
5810 #endif
5811       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5812   } else if (*ReferenceType == LLVMDisassembler_ReferenceType_In_PCrel_Load) {
5813     *ReferenceName =
5814         GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
5815     if (*ReferenceName)
5816       method_reference(info, ReferenceType, ReferenceName);
5817     else
5818       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5819     // If this is arm64 and the reference is an adrp instruction save the
5820     // instruction, passed in ReferenceValue and the address of the instruction
5821     // for use later if we see and add immediate instruction.
5822   } else if (info->O->getArch() == Triple::aarch64 &&
5823              *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADRP) {
5824     info->adrp_inst = ReferenceValue;
5825     info->adrp_addr = ReferencePC;
5826     SymbolName = nullptr;
5827     *ReferenceName = nullptr;
5828     *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5829     // If this is arm64 and reference is an add immediate instruction and we
5830     // have
5831     // seen an adrp instruction just before it and the adrp's Xd register
5832     // matches
5833     // this add's Xn register reconstruct the value being referenced and look to
5834     // see if it is a literal pointer.  Note the add immediate instruction is
5835     // passed in ReferenceValue.
5836   } else if (info->O->getArch() == Triple::aarch64 &&
5837              *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADDXri &&
5838              ReferencePC - 4 == info->adrp_addr &&
5839              (info->adrp_inst & 0x9f000000) == 0x90000000 &&
5840              (info->adrp_inst & 0x1f) == ((ReferenceValue >> 5) & 0x1f)) {
5841     uint32_t addxri_inst;
5842     uint64_t adrp_imm, addxri_imm;
5843
5844     adrp_imm =
5845         ((info->adrp_inst & 0x00ffffe0) >> 3) | ((info->adrp_inst >> 29) & 0x3);
5846     if (info->adrp_inst & 0x0200000)
5847       adrp_imm |= 0xfffffffffc000000LL;
5848
5849     addxri_inst = ReferenceValue;
5850     addxri_imm = (addxri_inst >> 10) & 0xfff;
5851     if (((addxri_inst >> 22) & 0x3) == 1)
5852       addxri_imm <<= 12;
5853
5854     ReferenceValue = (info->adrp_addr & 0xfffffffffffff000LL) +
5855                      (adrp_imm << 12) + addxri_imm;
5856
5857     *ReferenceName =
5858         GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
5859     if (*ReferenceName == nullptr)
5860       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5861     // If this is arm64 and the reference is a load register instruction and we
5862     // have seen an adrp instruction just before it and the adrp's Xd register
5863     // matches this add's Xn register reconstruct the value being referenced and
5864     // look to see if it is a literal pointer.  Note the load register
5865     // instruction is passed in ReferenceValue.
5866   } else if (info->O->getArch() == Triple::aarch64 &&
5867              *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_LDRXui &&
5868              ReferencePC - 4 == info->adrp_addr &&
5869              (info->adrp_inst & 0x9f000000) == 0x90000000 &&
5870              (info->adrp_inst & 0x1f) == ((ReferenceValue >> 5) & 0x1f)) {
5871     uint32_t ldrxui_inst;
5872     uint64_t adrp_imm, ldrxui_imm;
5873
5874     adrp_imm =
5875         ((info->adrp_inst & 0x00ffffe0) >> 3) | ((info->adrp_inst >> 29) & 0x3);
5876     if (info->adrp_inst & 0x0200000)
5877       adrp_imm |= 0xfffffffffc000000LL;
5878
5879     ldrxui_inst = ReferenceValue;
5880     ldrxui_imm = (ldrxui_inst >> 10) & 0xfff;
5881
5882     ReferenceValue = (info->adrp_addr & 0xfffffffffffff000LL) +
5883                      (adrp_imm << 12) + (ldrxui_imm << 3);
5884
5885     *ReferenceName =
5886         GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
5887     if (*ReferenceName == nullptr)
5888       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5889   }
5890   // If this arm64 and is an load register (PC-relative) instruction the
5891   // ReferenceValue is the PC plus the immediate value.
5892   else if (info->O->getArch() == Triple::aarch64 &&
5893            (*ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_LDRXl ||
5894             *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADR)) {
5895     *ReferenceName =
5896         GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
5897     if (*ReferenceName == nullptr)
5898       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5899   }
5900 #if HAVE_CXXABI_H
5901   else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) {
5902     if (info->demangled_name != nullptr)
5903       free(info->demangled_name);
5904     int status;
5905     info->demangled_name =
5906         abi::__cxa_demangle(SymbolName + 1, nullptr, nullptr, &status);
5907     if (info->demangled_name != nullptr) {
5908       *ReferenceName = info->demangled_name;
5909       *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name;
5910     }
5911   }
5912 #endif
5913   else {
5914     *ReferenceName = nullptr;
5915     *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
5916   }
5917
5918   return SymbolName;
5919 }
5920
5921 /// \brief Emits the comments that are stored in the CommentStream.
5922 /// Each comment in the CommentStream must end with a newline.
5923 static void emitComments(raw_svector_ostream &CommentStream,
5924                          SmallString<128> &CommentsToEmit,
5925                          formatted_raw_ostream &FormattedOS,
5926                          const MCAsmInfo &MAI) {
5927   // Flush the stream before taking its content.
5928   CommentStream.flush();
5929   StringRef Comments = CommentsToEmit.str();
5930   // Get the default information for printing a comment.
5931   const char *CommentBegin = MAI.getCommentString();
5932   unsigned CommentColumn = MAI.getCommentColumn();
5933   bool IsFirst = true;
5934   while (!Comments.empty()) {
5935     if (!IsFirst)
5936       FormattedOS << '\n';
5937     // Emit a line of comments.
5938     FormattedOS.PadToColumn(CommentColumn);
5939     size_t Position = Comments.find('\n');
5940     FormattedOS << CommentBegin << ' ' << Comments.substr(0, Position);
5941     // Move after the newline character.
5942     Comments = Comments.substr(Position + 1);
5943     IsFirst = false;
5944   }
5945   FormattedOS.flush();
5946
5947   // Tell the comment stream that the vector changed underneath it.
5948   CommentsToEmit.clear();
5949   CommentStream.resync();
5950 }
5951
5952 static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
5953                              StringRef DisSegName, StringRef DisSectName) {
5954   const char *McpuDefault = nullptr;
5955   const Target *ThumbTarget = nullptr;
5956   const Target *TheTarget = GetTarget(MachOOF, &McpuDefault, &ThumbTarget);
5957   if (!TheTarget) {
5958     // GetTarget prints out stuff.
5959     return;
5960   }
5961   if (MCPU.empty() && McpuDefault)
5962     MCPU = McpuDefault;
5963
5964   std::unique_ptr<const MCInstrInfo> InstrInfo(TheTarget->createMCInstrInfo());
5965   std::unique_ptr<const MCInstrInfo> ThumbInstrInfo;
5966   if (ThumbTarget)
5967     ThumbInstrInfo.reset(ThumbTarget->createMCInstrInfo());
5968
5969   // Package up features to be passed to target/subtarget
5970   std::string FeaturesStr;
5971   if (MAttrs.size()) {
5972     SubtargetFeatures Features;
5973     for (unsigned i = 0; i != MAttrs.size(); ++i)
5974       Features.AddFeature(MAttrs[i]);
5975     FeaturesStr = Features.getString();
5976   }
5977
5978   // Set up disassembler.
5979   std::unique_ptr<const MCRegisterInfo> MRI(
5980       TheTarget->createMCRegInfo(TripleName));
5981   std::unique_ptr<const MCAsmInfo> AsmInfo(
5982       TheTarget->createMCAsmInfo(*MRI, TripleName));
5983   std::unique_ptr<const MCSubtargetInfo> STI(
5984       TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr));
5985   MCContext Ctx(AsmInfo.get(), MRI.get(), nullptr);
5986   std::unique_ptr<MCDisassembler> DisAsm(
5987       TheTarget->createMCDisassembler(*STI, Ctx));
5988   std::unique_ptr<MCSymbolizer> Symbolizer;
5989   struct DisassembleInfo SymbolizerInfo;
5990   std::unique_ptr<MCRelocationInfo> RelInfo(
5991       TheTarget->createMCRelocationInfo(TripleName, Ctx));
5992   if (RelInfo) {
5993     Symbolizer.reset(TheTarget->createMCSymbolizer(
5994         TripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
5995         &SymbolizerInfo, &Ctx, std::move(RelInfo)));
5996     DisAsm->setSymbolizer(std::move(Symbolizer));
5997   }
5998   int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
5999   std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
6000       Triple(TripleName), AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI));
6001   // Set the display preference for hex vs. decimal immediates.
6002   IP->setPrintImmHex(PrintImmHex);
6003   // Comment stream and backing vector.
6004   SmallString<128> CommentsToEmit;
6005   raw_svector_ostream CommentStream(CommentsToEmit);
6006   // FIXME: Setting the CommentStream in the InstPrinter is problematic in that
6007   // if it is done then arm64 comments for string literals don't get printed
6008   // and some constant get printed instead and not setting it causes intel
6009   // (32-bit and 64-bit) comments printed with different spacing before the
6010   // comment causing different diffs with the 'C' disassembler library API.
6011   // IP->setCommentStream(CommentStream);
6012
6013   if (!AsmInfo || !STI || !DisAsm || !IP) {
6014     errs() << "error: couldn't initialize disassembler for target "
6015            << TripleName << '\n';
6016     return;
6017   }
6018
6019   // Set up thumb disassembler.
6020   std::unique_ptr<const MCRegisterInfo> ThumbMRI;
6021   std::unique_ptr<const MCAsmInfo> ThumbAsmInfo;
6022   std::unique_ptr<const MCSubtargetInfo> ThumbSTI;
6023   std::unique_ptr<MCDisassembler> ThumbDisAsm;
6024   std::unique_ptr<MCInstPrinter> ThumbIP;
6025   std::unique_ptr<MCContext> ThumbCtx;
6026   std::unique_ptr<MCSymbolizer> ThumbSymbolizer;
6027   struct DisassembleInfo ThumbSymbolizerInfo;
6028   std::unique_ptr<MCRelocationInfo> ThumbRelInfo;
6029   if (ThumbTarget) {
6030     ThumbMRI.reset(ThumbTarget->createMCRegInfo(ThumbTripleName));
6031     ThumbAsmInfo.reset(
6032         ThumbTarget->createMCAsmInfo(*ThumbMRI, ThumbTripleName));
6033     ThumbSTI.reset(
6034         ThumbTarget->createMCSubtargetInfo(ThumbTripleName, MCPU, FeaturesStr));
6035     ThumbCtx.reset(new MCContext(ThumbAsmInfo.get(), ThumbMRI.get(), nullptr));
6036     ThumbDisAsm.reset(ThumbTarget->createMCDisassembler(*ThumbSTI, *ThumbCtx));
6037     MCContext *PtrThumbCtx = ThumbCtx.get();
6038     ThumbRelInfo.reset(
6039         ThumbTarget->createMCRelocationInfo(ThumbTripleName, *PtrThumbCtx));
6040     if (ThumbRelInfo) {
6041       ThumbSymbolizer.reset(ThumbTarget->createMCSymbolizer(
6042           ThumbTripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
6043           &ThumbSymbolizerInfo, PtrThumbCtx, std::move(ThumbRelInfo)));
6044       ThumbDisAsm->setSymbolizer(std::move(ThumbSymbolizer));
6045     }
6046     int ThumbAsmPrinterVariant = ThumbAsmInfo->getAssemblerDialect();
6047     ThumbIP.reset(ThumbTarget->createMCInstPrinter(
6048         Triple(ThumbTripleName), ThumbAsmPrinterVariant, *ThumbAsmInfo,
6049         *ThumbInstrInfo, *ThumbMRI));
6050     // Set the display preference for hex vs. decimal immediates.
6051     ThumbIP->setPrintImmHex(PrintImmHex);
6052   }
6053
6054   if (ThumbTarget && (!ThumbAsmInfo || !ThumbSTI || !ThumbDisAsm || !ThumbIP)) {
6055     errs() << "error: couldn't initialize disassembler for target "
6056            << ThumbTripleName << '\n';
6057     return;
6058   }
6059
6060   MachO::mach_header Header = MachOOF->getHeader();
6061
6062   // FIXME: Using the -cfg command line option, this code used to be able to
6063   // annotate relocations with the referenced symbol's name, and if this was
6064   // inside a __[cf]string section, the data it points to. This is now replaced
6065   // by the upcoming MCSymbolizer, which needs the appropriate setup done above.
6066   std::vector<SectionRef> Sections;
6067   std::vector<SymbolRef> Symbols;
6068   SmallVector<uint64_t, 8> FoundFns;
6069   uint64_t BaseSegmentAddress;
6070
6071   getSectionsAndSymbols(Header, MachOOF, Sections, Symbols, FoundFns,
6072                         BaseSegmentAddress);
6073
6074   // Sort the symbols by address, just in case they didn't come in that way.
6075   std::sort(Symbols.begin(), Symbols.end(), SymbolSorter());
6076
6077   // Build a data in code table that is sorted on by the address of each entry.
6078   uint64_t BaseAddress = 0;
6079   if (Header.filetype == MachO::MH_OBJECT)
6080     BaseAddress = Sections[0].getAddress();
6081   else
6082     BaseAddress = BaseSegmentAddress;
6083   DiceTable Dices;
6084   for (dice_iterator DI = MachOOF->begin_dices(), DE = MachOOF->end_dices();
6085        DI != DE; ++DI) {
6086     uint32_t Offset;
6087     DI->getOffset(Offset);
6088     Dices.push_back(std::make_pair(BaseAddress + Offset, *DI));
6089   }
6090   array_pod_sort(Dices.begin(), Dices.end());
6091
6092 #ifndef NDEBUG
6093   raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
6094 #else
6095   raw_ostream &DebugOut = nulls();
6096 #endif
6097
6098   std::unique_ptr<DIContext> diContext;
6099   ObjectFile *DbgObj = MachOOF;
6100   // Try to find debug info and set up the DIContext for it.
6101   if (UseDbg) {
6102     // A separate DSym file path was specified, parse it as a macho file,
6103     // get the sections and supply it to the section name parsing machinery.
6104     if (!DSYMFile.empty()) {
6105       ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
6106           MemoryBuffer::getFileOrSTDIN(DSYMFile);
6107       if (std::error_code EC = BufOrErr.getError()) {
6108         errs() << "llvm-objdump: " << Filename << ": " << EC.message() << '\n';
6109         return;
6110       }
6111       DbgObj =
6112           ObjectFile::createMachOObjectFile(BufOrErr.get()->getMemBufferRef())
6113               .get()
6114               .release();
6115     }
6116
6117     // Setup the DIContext
6118     diContext.reset(DIContext::getDWARFContext(*DbgObj));
6119   }
6120
6121   if (DumpSections.size() == 0)
6122     outs() << "(" << DisSegName << "," << DisSectName << ") section\n";
6123
6124   for (unsigned SectIdx = 0; SectIdx != Sections.size(); SectIdx++) {
6125     StringRef SectName;
6126     if (Sections[SectIdx].getName(SectName) || SectName != DisSectName)
6127       continue;
6128
6129     DataRefImpl DR = Sections[SectIdx].getRawDataRefImpl();
6130
6131     StringRef SegmentName = MachOOF->getSectionFinalSegmentName(DR);
6132     if (SegmentName != DisSegName)
6133       continue;
6134
6135     StringRef BytesStr;
6136     Sections[SectIdx].getContents(BytesStr);
6137     ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
6138                             BytesStr.size());
6139     uint64_t SectAddress = Sections[SectIdx].getAddress();
6140
6141     bool symbolTableWorked = false;
6142
6143     // Parse relocations.
6144     std::vector<std::pair<uint64_t, SymbolRef>> Relocs;
6145     for (const RelocationRef &Reloc : Sections[SectIdx].relocations()) {
6146       uint64_t RelocOffset;
6147       Reloc.getOffset(RelocOffset);
6148       uint64_t SectionAddress = Sections[SectIdx].getAddress();
6149       RelocOffset -= SectionAddress;
6150
6151       symbol_iterator RelocSym = Reloc.getSymbol();
6152
6153       Relocs.push_back(std::make_pair(RelocOffset, *RelocSym));
6154     }
6155     array_pod_sort(Relocs.begin(), Relocs.end());
6156
6157     // Create a map of symbol addresses to symbol names for use by
6158     // the SymbolizerSymbolLookUp() routine.
6159     SymbolAddressMap AddrMap;
6160     bool DisSymNameFound = false;
6161     for (const SymbolRef &Symbol : MachOOF->symbols()) {
6162       SymbolRef::Type ST;
6163       Symbol.getType(ST);
6164       if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
6165           ST == SymbolRef::ST_Other) {
6166         uint64_t Address;
6167         Symbol.getAddress(Address);
6168         StringRef SymName;
6169         Symbol.getName(SymName);
6170         AddrMap[Address] = SymName;
6171         if (!DisSymName.empty() && DisSymName == SymName)
6172           DisSymNameFound = true;
6173       }
6174     }
6175     if (!DisSymName.empty() && !DisSymNameFound) {
6176       outs() << "Can't find -dis-symname: " << DisSymName << "\n";
6177       return;
6178     }
6179     // Set up the block of info used by the Symbolizer call backs.
6180     SymbolizerInfo.verbose = !NoSymbolicOperands;
6181     SymbolizerInfo.O = MachOOF;
6182     SymbolizerInfo.S = Sections[SectIdx];
6183     SymbolizerInfo.AddrMap = &AddrMap;
6184     SymbolizerInfo.Sections = &Sections;
6185     SymbolizerInfo.class_name = nullptr;
6186     SymbolizerInfo.selector_name = nullptr;
6187     SymbolizerInfo.method = nullptr;
6188     SymbolizerInfo.demangled_name = nullptr;
6189     SymbolizerInfo.bindtable = nullptr;
6190     SymbolizerInfo.adrp_addr = 0;
6191     SymbolizerInfo.adrp_inst = 0;
6192     // Same for the ThumbSymbolizer
6193     ThumbSymbolizerInfo.verbose = !NoSymbolicOperands;
6194     ThumbSymbolizerInfo.O = MachOOF;
6195     ThumbSymbolizerInfo.S = Sections[SectIdx];
6196     ThumbSymbolizerInfo.AddrMap = &AddrMap;
6197     ThumbSymbolizerInfo.Sections = &Sections;
6198     ThumbSymbolizerInfo.class_name = nullptr;
6199     ThumbSymbolizerInfo.selector_name = nullptr;
6200     ThumbSymbolizerInfo.method = nullptr;
6201     ThumbSymbolizerInfo.demangled_name = nullptr;
6202     ThumbSymbolizerInfo.bindtable = nullptr;
6203     ThumbSymbolizerInfo.adrp_addr = 0;
6204     ThumbSymbolizerInfo.adrp_inst = 0;
6205
6206     // Disassemble symbol by symbol.
6207     for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
6208       StringRef SymName;
6209       Symbols[SymIdx].getName(SymName);
6210
6211       SymbolRef::Type ST;
6212       Symbols[SymIdx].getType(ST);
6213       if (ST != SymbolRef::ST_Function)
6214         continue;
6215
6216       // Make sure the symbol is defined in this section.
6217       bool containsSym = Sections[SectIdx].containsSymbol(Symbols[SymIdx]);
6218       if (!containsSym)
6219         continue;
6220
6221       // If we are only disassembling one symbol see if this is that symbol.
6222       if (!DisSymName.empty() && DisSymName != SymName)
6223         continue;
6224
6225       // Start at the address of the symbol relative to the section's address.
6226       uint64_t Start = 0;
6227       uint64_t SectionAddress = Sections[SectIdx].getAddress();
6228       Symbols[SymIdx].getAddress(Start);
6229       Start -= SectionAddress;
6230
6231       // Stop disassembling either at the beginning of the next symbol or at
6232       // the end of the section.
6233       bool containsNextSym = false;
6234       uint64_t NextSym = 0;
6235       uint64_t NextSymIdx = SymIdx + 1;
6236       while (Symbols.size() > NextSymIdx) {
6237         SymbolRef::Type NextSymType;
6238         Symbols[NextSymIdx].getType(NextSymType);
6239         if (NextSymType == SymbolRef::ST_Function) {
6240           containsNextSym =
6241               Sections[SectIdx].containsSymbol(Symbols[NextSymIdx]);
6242           Symbols[NextSymIdx].getAddress(NextSym);
6243           NextSym -= SectionAddress;
6244           break;
6245         }
6246         ++NextSymIdx;
6247       }
6248
6249       uint64_t SectSize = Sections[SectIdx].getSize();
6250       uint64_t End = containsNextSym ? NextSym : SectSize;
6251       uint64_t Size;
6252
6253       symbolTableWorked = true;
6254
6255       DataRefImpl Symb = Symbols[SymIdx].getRawDataRefImpl();
6256       bool isThumb =
6257           (MachOOF->getSymbolFlags(Symb) & SymbolRef::SF_Thumb) && ThumbTarget;
6258
6259       outs() << SymName << ":\n";
6260       DILineInfo lastLine;
6261       for (uint64_t Index = Start; Index < End; Index += Size) {
6262         MCInst Inst;
6263
6264         uint64_t PC = SectAddress + Index;
6265         if (!NoLeadingAddr) {
6266           if (FullLeadingAddr) {
6267             if (MachOOF->is64Bit())
6268               outs() << format("%016" PRIx64, PC);
6269             else
6270               outs() << format("%08" PRIx64, PC);
6271           } else {
6272             outs() << format("%8" PRIx64 ":", PC);
6273           }
6274         }
6275         if (!NoShowRawInsn)
6276           outs() << "\t";
6277
6278         // Check the data in code table here to see if this is data not an
6279         // instruction to be disassembled.
6280         DiceTable Dice;
6281         Dice.push_back(std::make_pair(PC, DiceRef()));
6282         dice_table_iterator DTI =
6283             std::search(Dices.begin(), Dices.end(), Dice.begin(), Dice.end(),
6284                         compareDiceTableEntries);
6285         if (DTI != Dices.end()) {
6286           uint16_t Length;
6287           DTI->second.getLength(Length);
6288           uint16_t Kind;
6289           DTI->second.getKind(Kind);
6290           Size = DumpDataInCode(Bytes.data() + Index, Length, Kind);
6291           if ((Kind == MachO::DICE_KIND_JUMP_TABLE8) &&
6292               (PC == (DTI->first + Length - 1)) && (Length & 1))
6293             Size++;
6294           continue;
6295         }
6296
6297         SmallVector<char, 64> AnnotationsBytes;
6298         raw_svector_ostream Annotations(AnnotationsBytes);
6299
6300         bool gotInst;
6301         if (isThumb)
6302           gotInst = ThumbDisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
6303                                                 PC, DebugOut, Annotations);
6304         else
6305           gotInst = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), PC,
6306                                            DebugOut, Annotations);
6307         if (gotInst) {
6308           if (!NoShowRawInsn) {
6309             DumpBytes(ArrayRef<uint8_t>(Bytes.data() + Index, Size));
6310           }
6311           formatted_raw_ostream FormattedOS(outs());
6312           Annotations.flush();
6313           StringRef AnnotationsStr = Annotations.str();
6314           if (isThumb)
6315             ThumbIP->printInst(&Inst, FormattedOS, AnnotationsStr, *ThumbSTI);
6316           else
6317             IP->printInst(&Inst, FormattedOS, AnnotationsStr, *STI);
6318           emitComments(CommentStream, CommentsToEmit, FormattedOS, *AsmInfo);
6319
6320           // Print debug info.
6321           if (diContext) {
6322             DILineInfo dli = diContext->getLineInfoForAddress(PC);
6323             // Print valid line info if it changed.
6324             if (dli != lastLine && dli.Line != 0)
6325               outs() << "\t## " << dli.FileName << ':' << dli.Line << ':'
6326                      << dli.Column;
6327             lastLine = dli;
6328           }
6329           outs() << "\n";
6330         } else {
6331           unsigned int Arch = MachOOF->getArch();
6332           if (Arch == Triple::x86_64 || Arch == Triple::x86) {
6333             outs() << format("\t.byte 0x%02x #bad opcode\n",
6334                              *(Bytes.data() + Index) & 0xff);
6335             Size = 1; // skip exactly one illegible byte and move on.
6336           } else if (Arch == Triple::aarch64) {
6337             uint32_t opcode = (*(Bytes.data() + Index) & 0xff) |
6338                               (*(Bytes.data() + Index + 1) & 0xff) << 8 |
6339                               (*(Bytes.data() + Index + 2) & 0xff) << 16 |
6340                               (*(Bytes.data() + Index + 3) & 0xff) << 24;
6341             outs() << format("\t.long\t0x%08x\n", opcode);
6342             Size = 4;
6343           } else {
6344             errs() << "llvm-objdump: warning: invalid instruction encoding\n";
6345             if (Size == 0)
6346               Size = 1; // skip illegible bytes
6347           }
6348         }
6349       }
6350     }
6351     if (!symbolTableWorked) {
6352       // Reading the symbol table didn't work, disassemble the whole section.
6353       uint64_t SectAddress = Sections[SectIdx].getAddress();
6354       uint64_t SectSize = Sections[SectIdx].getSize();
6355       uint64_t InstSize;
6356       for (uint64_t Index = 0; Index < SectSize; Index += InstSize) {
6357         MCInst Inst;
6358
6359         uint64_t PC = SectAddress + Index;
6360         if (DisAsm->getInstruction(Inst, InstSize, Bytes.slice(Index), PC,
6361                                    DebugOut, nulls())) {
6362           if (!NoLeadingAddr) {
6363             if (FullLeadingAddr) {
6364               if (MachOOF->is64Bit())
6365                 outs() << format("%016" PRIx64, PC);
6366               else
6367                 outs() << format("%08" PRIx64, PC);
6368             } else {
6369               outs() << format("%8" PRIx64 ":", PC);
6370             }
6371           }
6372           if (!NoShowRawInsn) {
6373             outs() << "\t";
6374             DumpBytes(ArrayRef<uint8_t>(Bytes.data() + Index, InstSize));
6375           }
6376           IP->printInst(&Inst, outs(), "", *STI);
6377           outs() << "\n";
6378         } else {
6379           unsigned int Arch = MachOOF->getArch();
6380           if (Arch == Triple::x86_64 || Arch == Triple::x86) {
6381             outs() << format("\t.byte 0x%02x #bad opcode\n",
6382                              *(Bytes.data() + Index) & 0xff);
6383             InstSize = 1; // skip exactly one illegible byte and move on.
6384           } else {
6385             errs() << "llvm-objdump: warning: invalid instruction encoding\n";
6386             if (InstSize == 0)
6387               InstSize = 1; // skip illegible bytes
6388           }
6389         }
6390       }
6391     }
6392     // The TripleName's need to be reset if we are called again for a different
6393     // archtecture.
6394     TripleName = "";
6395     ThumbTripleName = "";
6396
6397     if (SymbolizerInfo.method != nullptr)
6398       free(SymbolizerInfo.method);
6399     if (SymbolizerInfo.demangled_name != nullptr)
6400       free(SymbolizerInfo.demangled_name);
6401     if (SymbolizerInfo.bindtable != nullptr)
6402       delete SymbolizerInfo.bindtable;
6403     if (ThumbSymbolizerInfo.method != nullptr)
6404       free(ThumbSymbolizerInfo.method);
6405     if (ThumbSymbolizerInfo.demangled_name != nullptr)
6406       free(ThumbSymbolizerInfo.demangled_name);
6407     if (ThumbSymbolizerInfo.bindtable != nullptr)
6408       delete ThumbSymbolizerInfo.bindtable;
6409   }
6410 }
6411
6412 //===----------------------------------------------------------------------===//
6413 // __compact_unwind section dumping
6414 //===----------------------------------------------------------------------===//
6415
6416 namespace {
6417
6418 template <typename T> static uint64_t readNext(const char *&Buf) {
6419   using llvm::support::little;
6420   using llvm::support::unaligned;
6421
6422   uint64_t Val = support::endian::read<T, little, unaligned>(Buf);
6423   Buf += sizeof(T);
6424   return Val;
6425 }
6426
6427 struct CompactUnwindEntry {
6428   uint32_t OffsetInSection;
6429
6430   uint64_t FunctionAddr;
6431   uint32_t Length;
6432   uint32_t CompactEncoding;
6433   uint64_t PersonalityAddr;
6434   uint64_t LSDAAddr;
6435
6436   RelocationRef FunctionReloc;
6437   RelocationRef PersonalityReloc;
6438   RelocationRef LSDAReloc;
6439
6440   CompactUnwindEntry(StringRef Contents, unsigned Offset, bool Is64)
6441       : OffsetInSection(Offset) {
6442     if (Is64)
6443       read<uint64_t>(Contents.data() + Offset);
6444     else
6445       read<uint32_t>(Contents.data() + Offset);
6446   }
6447
6448 private:
6449   template <typename UIntPtr> void read(const char *Buf) {
6450     FunctionAddr = readNext<UIntPtr>(Buf);
6451     Length = readNext<uint32_t>(Buf);
6452     CompactEncoding = readNext<uint32_t>(Buf);
6453     PersonalityAddr = readNext<UIntPtr>(Buf);
6454     LSDAAddr = readNext<UIntPtr>(Buf);
6455   }
6456 };
6457 }
6458
6459 /// Given a relocation from __compact_unwind, consisting of the RelocationRef
6460 /// and data being relocated, determine the best base Name and Addend to use for
6461 /// display purposes.
6462 ///
6463 /// 1. An Extern relocation will directly reference a symbol (and the data is
6464 ///    then already an addend), so use that.
6465 /// 2. Otherwise the data is an offset in the object file's layout; try to find
6466 //     a symbol before it in the same section, and use the offset from there.
6467 /// 3. Finally, if all that fails, fall back to an offset from the start of the
6468 ///    referenced section.
6469 static void findUnwindRelocNameAddend(const MachOObjectFile *Obj,
6470                                       std::map<uint64_t, SymbolRef> &Symbols,
6471                                       const RelocationRef &Reloc, uint64_t Addr,
6472                                       StringRef &Name, uint64_t &Addend) {
6473   if (Reloc.getSymbol() != Obj->symbol_end()) {
6474     Reloc.getSymbol()->getName(Name);
6475     Addend = Addr;
6476     return;
6477   }
6478
6479   auto RE = Obj->getRelocation(Reloc.getRawDataRefImpl());
6480   SectionRef RelocSection = Obj->getRelocationSection(RE);
6481
6482   uint64_t SectionAddr = RelocSection.getAddress();
6483
6484   auto Sym = Symbols.upper_bound(Addr);
6485   if (Sym == Symbols.begin()) {
6486     // The first symbol in the object is after this reference, the best we can
6487     // do is section-relative notation.
6488     RelocSection.getName(Name);
6489     Addend = Addr - SectionAddr;
6490     return;
6491   }
6492
6493   // Go back one so that SymbolAddress <= Addr.
6494   --Sym;
6495
6496   section_iterator SymSection = Obj->section_end();
6497   Sym->second.getSection(SymSection);
6498   if (RelocSection == *SymSection) {
6499     // There's a valid symbol in the same section before this reference.
6500     Sym->second.getName(Name);
6501     Addend = Addr - Sym->first;
6502     return;
6503   }
6504
6505   // There is a symbol before this reference, but it's in a different
6506   // section. Probably not helpful to mention it, so use the section name.
6507   RelocSection.getName(Name);
6508   Addend = Addr - SectionAddr;
6509 }
6510
6511 static void printUnwindRelocDest(const MachOObjectFile *Obj,
6512                                  std::map<uint64_t, SymbolRef> &Symbols,
6513                                  const RelocationRef &Reloc, uint64_t Addr) {
6514   StringRef Name;
6515   uint64_t Addend;
6516
6517   if (!Reloc.getObjectFile())
6518     return;
6519
6520   findUnwindRelocNameAddend(Obj, Symbols, Reloc, Addr, Name, Addend);
6521
6522   outs() << Name;
6523   if (Addend)
6524     outs() << " + " << format("0x%" PRIx64, Addend);
6525 }
6526
6527 static void
6528 printMachOCompactUnwindSection(const MachOObjectFile *Obj,
6529                                std::map<uint64_t, SymbolRef> &Symbols,
6530                                const SectionRef &CompactUnwind) {
6531
6532   assert(Obj->isLittleEndian() &&
6533          "There should not be a big-endian .o with __compact_unwind");
6534
6535   bool Is64 = Obj->is64Bit();
6536   uint32_t PointerSize = Is64 ? sizeof(uint64_t) : sizeof(uint32_t);
6537   uint32_t EntrySize = 3 * PointerSize + 2 * sizeof(uint32_t);
6538
6539   StringRef Contents;
6540   CompactUnwind.getContents(Contents);
6541
6542   SmallVector<CompactUnwindEntry, 4> CompactUnwinds;
6543
6544   // First populate the initial raw offsets, encodings and so on from the entry.
6545   for (unsigned Offset = 0; Offset < Contents.size(); Offset += EntrySize) {
6546     CompactUnwindEntry Entry(Contents.data(), Offset, Is64);
6547     CompactUnwinds.push_back(Entry);
6548   }
6549
6550   // Next we need to look at the relocations to find out what objects are
6551   // actually being referred to.
6552   for (const RelocationRef &Reloc : CompactUnwind.relocations()) {
6553     uint64_t RelocAddress;
6554     Reloc.getOffset(RelocAddress);
6555
6556     uint32_t EntryIdx = RelocAddress / EntrySize;
6557     uint32_t OffsetInEntry = RelocAddress - EntryIdx * EntrySize;
6558     CompactUnwindEntry &Entry = CompactUnwinds[EntryIdx];
6559
6560     if (OffsetInEntry == 0)
6561       Entry.FunctionReloc = Reloc;
6562     else if (OffsetInEntry == PointerSize + 2 * sizeof(uint32_t))
6563       Entry.PersonalityReloc = Reloc;
6564     else if (OffsetInEntry == 2 * PointerSize + 2 * sizeof(uint32_t))
6565       Entry.LSDAReloc = Reloc;
6566     else
6567       llvm_unreachable("Unexpected relocation in __compact_unwind section");
6568   }
6569
6570   // Finally, we're ready to print the data we've gathered.
6571   outs() << "Contents of __compact_unwind section:\n";
6572   for (auto &Entry : CompactUnwinds) {
6573     outs() << "  Entry at offset "
6574            << format("0x%" PRIx32, Entry.OffsetInSection) << ":\n";
6575
6576     // 1. Start of the region this entry applies to.
6577     outs() << "    start:                " << format("0x%" PRIx64,
6578                                                      Entry.FunctionAddr) << ' ';
6579     printUnwindRelocDest(Obj, Symbols, Entry.FunctionReloc, Entry.FunctionAddr);
6580     outs() << '\n';
6581
6582     // 2. Length of the region this entry applies to.
6583     outs() << "    length:               " << format("0x%" PRIx32, Entry.Length)
6584            << '\n';
6585     // 3. The 32-bit compact encoding.
6586     outs() << "    compact encoding:     "
6587            << format("0x%08" PRIx32, Entry.CompactEncoding) << '\n';
6588
6589     // 4. The personality function, if present.
6590     if (Entry.PersonalityReloc.getObjectFile()) {
6591       outs() << "    personality function: "
6592              << format("0x%" PRIx64, Entry.PersonalityAddr) << ' ';
6593       printUnwindRelocDest(Obj, Symbols, Entry.PersonalityReloc,
6594                            Entry.PersonalityAddr);
6595       outs() << '\n';
6596     }
6597
6598     // 5. This entry's language-specific data area.
6599     if (Entry.LSDAReloc.getObjectFile()) {
6600       outs() << "    LSDA:                 " << format("0x%" PRIx64,
6601                                                        Entry.LSDAAddr) << ' ';
6602       printUnwindRelocDest(Obj, Symbols, Entry.LSDAReloc, Entry.LSDAAddr);
6603       outs() << '\n';
6604     }
6605   }
6606 }
6607
6608 //===----------------------------------------------------------------------===//
6609 // __unwind_info section dumping
6610 //===----------------------------------------------------------------------===//
6611
6612 static void printRegularSecondLevelUnwindPage(const char *PageStart) {
6613   const char *Pos = PageStart;
6614   uint32_t Kind = readNext<uint32_t>(Pos);
6615   (void)Kind;
6616   assert(Kind == 2 && "kind for a regular 2nd level index should be 2");
6617
6618   uint16_t EntriesStart = readNext<uint16_t>(Pos);
6619   uint16_t NumEntries = readNext<uint16_t>(Pos);
6620
6621   Pos = PageStart + EntriesStart;
6622   for (unsigned i = 0; i < NumEntries; ++i) {
6623     uint32_t FunctionOffset = readNext<uint32_t>(Pos);
6624     uint32_t Encoding = readNext<uint32_t>(Pos);
6625
6626     outs() << "      [" << i << "]: "
6627            << "function offset=" << format("0x%08" PRIx32, FunctionOffset)
6628            << ", "
6629            << "encoding=" << format("0x%08" PRIx32, Encoding) << '\n';
6630   }
6631 }
6632
6633 static void printCompressedSecondLevelUnwindPage(
6634     const char *PageStart, uint32_t FunctionBase,
6635     const SmallVectorImpl<uint32_t> &CommonEncodings) {
6636   const char *Pos = PageStart;
6637   uint32_t Kind = readNext<uint32_t>(Pos);
6638   (void)Kind;
6639   assert(Kind == 3 && "kind for a compressed 2nd level index should be 3");
6640
6641   uint16_t EntriesStart = readNext<uint16_t>(Pos);
6642   uint16_t NumEntries = readNext<uint16_t>(Pos);
6643
6644   uint16_t EncodingsStart = readNext<uint16_t>(Pos);
6645   readNext<uint16_t>(Pos);
6646   const auto *PageEncodings = reinterpret_cast<const support::ulittle32_t *>(
6647       PageStart + EncodingsStart);
6648
6649   Pos = PageStart + EntriesStart;
6650   for (unsigned i = 0; i < NumEntries; ++i) {
6651     uint32_t Entry = readNext<uint32_t>(Pos);
6652     uint32_t FunctionOffset = FunctionBase + (Entry & 0xffffff);
6653     uint32_t EncodingIdx = Entry >> 24;
6654
6655     uint32_t Encoding;
6656     if (EncodingIdx < CommonEncodings.size())
6657       Encoding = CommonEncodings[EncodingIdx];
6658     else
6659       Encoding = PageEncodings[EncodingIdx - CommonEncodings.size()];
6660
6661     outs() << "      [" << i << "]: "
6662            << "function offset=" << format("0x%08" PRIx32, FunctionOffset)
6663            << ", "
6664            << "encoding[" << EncodingIdx
6665            << "]=" << format("0x%08" PRIx32, Encoding) << '\n';
6666   }
6667 }
6668
6669 static void printMachOUnwindInfoSection(const MachOObjectFile *Obj,
6670                                         std::map<uint64_t, SymbolRef> &Symbols,
6671                                         const SectionRef &UnwindInfo) {
6672
6673   assert(Obj->isLittleEndian() &&
6674          "There should not be a big-endian .o with __unwind_info");
6675
6676   outs() << "Contents of __unwind_info section:\n";
6677
6678   StringRef Contents;
6679   UnwindInfo.getContents(Contents);
6680   const char *Pos = Contents.data();
6681
6682   //===----------------------------------
6683   // Section header
6684   //===----------------------------------
6685
6686   uint32_t Version = readNext<uint32_t>(Pos);
6687   outs() << "  Version:                                   "
6688          << format("0x%" PRIx32, Version) << '\n';
6689   assert(Version == 1 && "only understand version 1");
6690
6691   uint32_t CommonEncodingsStart = readNext<uint32_t>(Pos);
6692   outs() << "  Common encodings array section offset:     "
6693          << format("0x%" PRIx32, CommonEncodingsStart) << '\n';
6694   uint32_t NumCommonEncodings = readNext<uint32_t>(Pos);
6695   outs() << "  Number of common encodings in array:       "
6696          << format("0x%" PRIx32, NumCommonEncodings) << '\n';
6697
6698   uint32_t PersonalitiesStart = readNext<uint32_t>(Pos);
6699   outs() << "  Personality function array section offset: "
6700          << format("0x%" PRIx32, PersonalitiesStart) << '\n';
6701   uint32_t NumPersonalities = readNext<uint32_t>(Pos);
6702   outs() << "  Number of personality functions in array:  "
6703          << format("0x%" PRIx32, NumPersonalities) << '\n';
6704
6705   uint32_t IndicesStart = readNext<uint32_t>(Pos);
6706   outs() << "  Index array section offset:                "
6707          << format("0x%" PRIx32, IndicesStart) << '\n';
6708   uint32_t NumIndices = readNext<uint32_t>(Pos);
6709   outs() << "  Number of indices in array:                "
6710          << format("0x%" PRIx32, NumIndices) << '\n';
6711
6712   //===----------------------------------
6713   // A shared list of common encodings
6714   //===----------------------------------
6715
6716   // These occupy indices in the range [0, N] whenever an encoding is referenced
6717   // from a compressed 2nd level index table. In practice the linker only
6718   // creates ~128 of these, so that indices are available to embed encodings in
6719   // the 2nd level index.
6720
6721   SmallVector<uint32_t, 64> CommonEncodings;
6722   outs() << "  Common encodings: (count = " << NumCommonEncodings << ")\n";
6723   Pos = Contents.data() + CommonEncodingsStart;
6724   for (unsigned i = 0; i < NumCommonEncodings; ++i) {
6725     uint32_t Encoding = readNext<uint32_t>(Pos);
6726     CommonEncodings.push_back(Encoding);
6727
6728     outs() << "    encoding[" << i << "]: " << format("0x%08" PRIx32, Encoding)
6729            << '\n';
6730   }
6731
6732   //===----------------------------------
6733   // Personality functions used in this executable
6734   //===----------------------------------
6735
6736   // There should be only a handful of these (one per source language,
6737   // roughly). Particularly since they only get 2 bits in the compact encoding.
6738
6739   outs() << "  Personality functions: (count = " << NumPersonalities << ")\n";
6740   Pos = Contents.data() + PersonalitiesStart;
6741   for (unsigned i = 0; i < NumPersonalities; ++i) {
6742     uint32_t PersonalityFn = readNext<uint32_t>(Pos);
6743     outs() << "    personality[" << i + 1
6744            << "]: " << format("0x%08" PRIx32, PersonalityFn) << '\n';
6745   }
6746
6747   //===----------------------------------
6748   // The level 1 index entries
6749   //===----------------------------------
6750
6751   // These specify an approximate place to start searching for the more detailed
6752   // information, sorted by PC.
6753
6754   struct IndexEntry {
6755     uint32_t FunctionOffset;
6756     uint32_t SecondLevelPageStart;
6757     uint32_t LSDAStart;
6758   };
6759
6760   SmallVector<IndexEntry, 4> IndexEntries;
6761
6762   outs() << "  Top level indices: (count = " << NumIndices << ")\n";
6763   Pos = Contents.data() + IndicesStart;
6764   for (unsigned i = 0; i < NumIndices; ++i) {
6765     IndexEntry Entry;
6766
6767     Entry.FunctionOffset = readNext<uint32_t>(Pos);
6768     Entry.SecondLevelPageStart = readNext<uint32_t>(Pos);
6769     Entry.LSDAStart = readNext<uint32_t>(Pos);
6770     IndexEntries.push_back(Entry);
6771
6772     outs() << "    [" << i << "]: "
6773            << "function offset=" << format("0x%08" PRIx32, Entry.FunctionOffset)
6774            << ", "
6775            << "2nd level page offset="
6776            << format("0x%08" PRIx32, Entry.SecondLevelPageStart) << ", "
6777            << "LSDA offset=" << format("0x%08" PRIx32, Entry.LSDAStart) << '\n';
6778   }
6779
6780   //===----------------------------------
6781   // Next come the LSDA tables
6782   //===----------------------------------
6783
6784   // The LSDA layout is rather implicit: it's a contiguous array of entries from
6785   // the first top-level index's LSDAOffset to the last (sentinel).
6786
6787   outs() << "  LSDA descriptors:\n";
6788   Pos = Contents.data() + IndexEntries[0].LSDAStart;
6789   int NumLSDAs = (IndexEntries.back().LSDAStart - IndexEntries[0].LSDAStart) /
6790                  (2 * sizeof(uint32_t));
6791   for (int i = 0; i < NumLSDAs; ++i) {
6792     uint32_t FunctionOffset = readNext<uint32_t>(Pos);
6793     uint32_t LSDAOffset = readNext<uint32_t>(Pos);
6794     outs() << "    [" << i << "]: "
6795            << "function offset=" << format("0x%08" PRIx32, FunctionOffset)
6796            << ", "
6797            << "LSDA offset=" << format("0x%08" PRIx32, LSDAOffset) << '\n';
6798   }
6799
6800   //===----------------------------------
6801   // Finally, the 2nd level indices
6802   //===----------------------------------
6803
6804   // Generally these are 4K in size, and have 2 possible forms:
6805   //   + Regular stores up to 511 entries with disparate encodings
6806   //   + Compressed stores up to 1021 entries if few enough compact encoding
6807   //     values are used.
6808   outs() << "  Second level indices:\n";
6809   for (unsigned i = 0; i < IndexEntries.size() - 1; ++i) {
6810     // The final sentinel top-level index has no associated 2nd level page
6811     if (IndexEntries[i].SecondLevelPageStart == 0)
6812       break;
6813
6814     outs() << "    Second level index[" << i << "]: "
6815            << "offset in section="
6816            << format("0x%08" PRIx32, IndexEntries[i].SecondLevelPageStart)
6817            << ", "
6818            << "base function offset="
6819            << format("0x%08" PRIx32, IndexEntries[i].FunctionOffset) << '\n';
6820
6821     Pos = Contents.data() + IndexEntries[i].SecondLevelPageStart;
6822     uint32_t Kind = *reinterpret_cast<const support::ulittle32_t *>(Pos);
6823     if (Kind == 2)
6824       printRegularSecondLevelUnwindPage(Pos);
6825     else if (Kind == 3)
6826       printCompressedSecondLevelUnwindPage(Pos, IndexEntries[i].FunctionOffset,
6827                                            CommonEncodings);
6828     else
6829       llvm_unreachable("Do not know how to print this kind of 2nd level page");
6830   }
6831 }
6832
6833 void llvm::printMachOUnwindInfo(const MachOObjectFile *Obj) {
6834   std::map<uint64_t, SymbolRef> Symbols;
6835   for (const SymbolRef &SymRef : Obj->symbols()) {
6836     // Discard any undefined or absolute symbols. They're not going to take part
6837     // in the convenience lookup for unwind info and just take up resources.
6838     section_iterator Section = Obj->section_end();
6839     SymRef.getSection(Section);
6840     if (Section == Obj->section_end())
6841       continue;
6842
6843     uint64_t Addr;
6844     SymRef.getAddress(Addr);
6845     Symbols.insert(std::make_pair(Addr, SymRef));
6846   }
6847
6848   for (const SectionRef &Section : Obj->sections()) {
6849     StringRef SectName;
6850     Section.getName(SectName);
6851     if (SectName == "__compact_unwind")
6852       printMachOCompactUnwindSection(Obj, Symbols, Section);
6853     else if (SectName == "__unwind_info")
6854       printMachOUnwindInfoSection(Obj, Symbols, Section);
6855     else if (SectName == "__eh_frame")
6856       outs() << "llvm-objdump: warning: unhandled __eh_frame section\n";
6857   }
6858 }
6859
6860 static void PrintMachHeader(uint32_t magic, uint32_t cputype,
6861                             uint32_t cpusubtype, uint32_t filetype,
6862                             uint32_t ncmds, uint32_t sizeofcmds, uint32_t flags,
6863                             bool verbose) {
6864   outs() << "Mach header\n";
6865   outs() << "      magic cputype cpusubtype  caps    filetype ncmds "
6866             "sizeofcmds      flags\n";
6867   if (verbose) {
6868     if (magic == MachO::MH_MAGIC)
6869       outs() << "   MH_MAGIC";
6870     else if (magic == MachO::MH_MAGIC_64)
6871       outs() << "MH_MAGIC_64";
6872     else
6873       outs() << format(" 0x%08" PRIx32, magic);
6874     switch (cputype) {
6875     case MachO::CPU_TYPE_I386:
6876       outs() << "    I386";
6877       switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
6878       case MachO::CPU_SUBTYPE_I386_ALL:
6879         outs() << "        ALL";
6880         break;
6881       default:
6882         outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
6883         break;
6884       }
6885       break;
6886     case MachO::CPU_TYPE_X86_64:
6887       outs() << "  X86_64";
6888       switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
6889       case MachO::CPU_SUBTYPE_X86_64_ALL:
6890         outs() << "        ALL";
6891         break;
6892       case MachO::CPU_SUBTYPE_X86_64_H:
6893         outs() << "    Haswell";
6894         break;
6895       default:
6896         outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
6897         break;
6898       }
6899       break;
6900     case MachO::CPU_TYPE_ARM:
6901       outs() << "     ARM";
6902       switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
6903       case MachO::CPU_SUBTYPE_ARM_ALL:
6904         outs() << "        ALL";
6905         break;
6906       case MachO::CPU_SUBTYPE_ARM_V4T:
6907         outs() << "        V4T";
6908         break;
6909       case MachO::CPU_SUBTYPE_ARM_V5TEJ:
6910         outs() << "      V5TEJ";
6911         break;
6912       case MachO::CPU_SUBTYPE_ARM_XSCALE:
6913         outs() << "     XSCALE";
6914         break;
6915       case MachO::CPU_SUBTYPE_ARM_V6:
6916         outs() << "         V6";
6917         break;
6918       case MachO::CPU_SUBTYPE_ARM_V6M:
6919         outs() << "        V6M";
6920         break;
6921       case MachO::CPU_SUBTYPE_ARM_V7:
6922         outs() << "         V7";
6923         break;
6924       case MachO::CPU_SUBTYPE_ARM_V7EM:
6925         outs() << "       V7EM";
6926         break;
6927       case MachO::CPU_SUBTYPE_ARM_V7K:
6928         outs() << "        V7K";
6929         break;
6930       case MachO::CPU_SUBTYPE_ARM_V7M:
6931         outs() << "        V7M";
6932         break;
6933       case MachO::CPU_SUBTYPE_ARM_V7S:
6934         outs() << "        V7S";
6935         break;
6936       default:
6937         outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
6938         break;
6939       }
6940       break;
6941     case MachO::CPU_TYPE_ARM64:
6942       outs() << "   ARM64";
6943       switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
6944       case MachO::CPU_SUBTYPE_ARM64_ALL:
6945         outs() << "        ALL";
6946         break;
6947       default:
6948         outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
6949         break;
6950       }
6951       break;
6952     case MachO::CPU_TYPE_POWERPC:
6953       outs() << "     PPC";
6954       switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
6955       case MachO::CPU_SUBTYPE_POWERPC_ALL:
6956         outs() << "        ALL";
6957         break;
6958       default:
6959         outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
6960         break;
6961       }
6962       break;
6963     case MachO::CPU_TYPE_POWERPC64:
6964       outs() << "   PPC64";
6965       switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
6966       case MachO::CPU_SUBTYPE_POWERPC_ALL:
6967         outs() << "        ALL";
6968         break;
6969       default:
6970         outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
6971         break;
6972       }
6973       break;
6974     }
6975     if ((cpusubtype & MachO::CPU_SUBTYPE_MASK) == MachO::CPU_SUBTYPE_LIB64) {
6976       outs() << " LIB64";
6977     } else {
6978       outs() << format("  0x%02" PRIx32,
6979                        (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24);
6980     }
6981     switch (filetype) {
6982     case MachO::MH_OBJECT:
6983       outs() << "      OBJECT";
6984       break;
6985     case MachO::MH_EXECUTE:
6986       outs() << "     EXECUTE";
6987       break;
6988     case MachO::MH_FVMLIB:
6989       outs() << "      FVMLIB";
6990       break;
6991     case MachO::MH_CORE:
6992       outs() << "        CORE";
6993       break;
6994     case MachO::MH_PRELOAD:
6995       outs() << "     PRELOAD";
6996       break;
6997     case MachO::MH_DYLIB:
6998       outs() << "       DYLIB";
6999       break;
7000     case MachO::MH_DYLIB_STUB:
7001       outs() << "  DYLIB_STUB";
7002       break;
7003     case MachO::MH_DYLINKER:
7004       outs() << "    DYLINKER";
7005       break;
7006     case MachO::MH_BUNDLE:
7007       outs() << "      BUNDLE";
7008       break;
7009     case MachO::MH_DSYM:
7010       outs() << "        DSYM";
7011       break;
7012     case MachO::MH_KEXT_BUNDLE:
7013       outs() << "  KEXTBUNDLE";
7014       break;
7015     default:
7016       outs() << format("  %10u", filetype);
7017       break;
7018     }
7019     outs() << format(" %5u", ncmds);
7020     outs() << format(" %10u", sizeofcmds);
7021     uint32_t f = flags;
7022     if (f & MachO::MH_NOUNDEFS) {
7023       outs() << "   NOUNDEFS";
7024       f &= ~MachO::MH_NOUNDEFS;
7025     }
7026     if (f & MachO::MH_INCRLINK) {
7027       outs() << " INCRLINK";
7028       f &= ~MachO::MH_INCRLINK;
7029     }
7030     if (f & MachO::MH_DYLDLINK) {
7031       outs() << " DYLDLINK";
7032       f &= ~MachO::MH_DYLDLINK;
7033     }
7034     if (f & MachO::MH_BINDATLOAD) {
7035       outs() << " BINDATLOAD";
7036       f &= ~MachO::MH_BINDATLOAD;
7037     }
7038     if (f & MachO::MH_PREBOUND) {
7039       outs() << " PREBOUND";
7040       f &= ~MachO::MH_PREBOUND;
7041     }
7042     if (f & MachO::MH_SPLIT_SEGS) {
7043       outs() << " SPLIT_SEGS";
7044       f &= ~MachO::MH_SPLIT_SEGS;
7045     }
7046     if (f & MachO::MH_LAZY_INIT) {
7047       outs() << " LAZY_INIT";
7048       f &= ~MachO::MH_LAZY_INIT;
7049     }
7050     if (f & MachO::MH_TWOLEVEL) {
7051       outs() << " TWOLEVEL";
7052       f &= ~MachO::MH_TWOLEVEL;
7053     }
7054     if (f & MachO::MH_FORCE_FLAT) {
7055       outs() << " FORCE_FLAT";
7056       f &= ~MachO::MH_FORCE_FLAT;
7057     }
7058     if (f & MachO::MH_NOMULTIDEFS) {
7059       outs() << " NOMULTIDEFS";
7060       f &= ~MachO::MH_NOMULTIDEFS;
7061     }
7062     if (f & MachO::MH_NOFIXPREBINDING) {
7063       outs() << " NOFIXPREBINDING";
7064       f &= ~MachO::MH_NOFIXPREBINDING;
7065     }
7066     if (f & MachO::MH_PREBINDABLE) {
7067       outs() << " PREBINDABLE";
7068       f &= ~MachO::MH_PREBINDABLE;
7069     }
7070     if (f & MachO::MH_ALLMODSBOUND) {
7071       outs() << " ALLMODSBOUND";
7072       f &= ~MachO::MH_ALLMODSBOUND;
7073     }
7074     if (f & MachO::MH_SUBSECTIONS_VIA_SYMBOLS) {
7075       outs() << " SUBSECTIONS_VIA_SYMBOLS";
7076       f &= ~MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
7077     }
7078     if (f & MachO::MH_CANONICAL) {
7079       outs() << " CANONICAL";
7080       f &= ~MachO::MH_CANONICAL;
7081     }
7082     if (f & MachO::MH_WEAK_DEFINES) {
7083       outs() << " WEAK_DEFINES";
7084       f &= ~MachO::MH_WEAK_DEFINES;
7085     }
7086     if (f & MachO::MH_BINDS_TO_WEAK) {
7087       outs() << " BINDS_TO_WEAK";
7088       f &= ~MachO::MH_BINDS_TO_WEAK;
7089     }
7090     if (f & MachO::MH_ALLOW_STACK_EXECUTION) {
7091       outs() << " ALLOW_STACK_EXECUTION";
7092       f &= ~MachO::MH_ALLOW_STACK_EXECUTION;
7093     }
7094     if (f & MachO::MH_DEAD_STRIPPABLE_DYLIB) {
7095       outs() << " DEAD_STRIPPABLE_DYLIB";
7096       f &= ~MachO::MH_DEAD_STRIPPABLE_DYLIB;
7097     }
7098     if (f & MachO::MH_PIE) {
7099       outs() << " PIE";
7100       f &= ~MachO::MH_PIE;
7101     }
7102     if (f & MachO::MH_NO_REEXPORTED_DYLIBS) {
7103       outs() << " NO_REEXPORTED_DYLIBS";
7104       f &= ~MachO::MH_NO_REEXPORTED_DYLIBS;
7105     }
7106     if (f & MachO::MH_HAS_TLV_DESCRIPTORS) {
7107       outs() << " MH_HAS_TLV_DESCRIPTORS";
7108       f &= ~MachO::MH_HAS_TLV_DESCRIPTORS;
7109     }
7110     if (f & MachO::MH_NO_HEAP_EXECUTION) {
7111       outs() << " MH_NO_HEAP_EXECUTION";
7112       f &= ~MachO::MH_NO_HEAP_EXECUTION;
7113     }
7114     if (f & MachO::MH_APP_EXTENSION_SAFE) {
7115       outs() << " APP_EXTENSION_SAFE";
7116       f &= ~MachO::MH_APP_EXTENSION_SAFE;
7117     }
7118     if (f != 0 || flags == 0)
7119       outs() << format(" 0x%08" PRIx32, f);
7120   } else {
7121     outs() << format(" 0x%08" PRIx32, magic);
7122     outs() << format(" %7d", cputype);
7123     outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
7124     outs() << format("  0x%02" PRIx32,
7125                      (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24);
7126     outs() << format("  %10u", filetype);
7127     outs() << format(" %5u", ncmds);
7128     outs() << format(" %10u", sizeofcmds);
7129     outs() << format(" 0x%08" PRIx32, flags);
7130   }
7131   outs() << "\n";
7132 }
7133
7134 static void PrintSegmentCommand(uint32_t cmd, uint32_t cmdsize,
7135                                 StringRef SegName, uint64_t vmaddr,
7136                                 uint64_t vmsize, uint64_t fileoff,
7137                                 uint64_t filesize, uint32_t maxprot,
7138                                 uint32_t initprot, uint32_t nsects,
7139                                 uint32_t flags, uint32_t object_size,
7140                                 bool verbose) {
7141   uint64_t expected_cmdsize;
7142   if (cmd == MachO::LC_SEGMENT) {
7143     outs() << "      cmd LC_SEGMENT\n";
7144     expected_cmdsize = nsects;
7145     expected_cmdsize *= sizeof(struct MachO::section);
7146     expected_cmdsize += sizeof(struct MachO::segment_command);
7147   } else {
7148     outs() << "      cmd LC_SEGMENT_64\n";
7149     expected_cmdsize = nsects;
7150     expected_cmdsize *= sizeof(struct MachO::section_64);
7151     expected_cmdsize += sizeof(struct MachO::segment_command_64);
7152   }
7153   outs() << "  cmdsize " << cmdsize;
7154   if (cmdsize != expected_cmdsize)
7155     outs() << " Inconsistent size\n";
7156   else
7157     outs() << "\n";
7158   outs() << "  segname " << SegName << "\n";
7159   if (cmd == MachO::LC_SEGMENT_64) {
7160     outs() << "   vmaddr " << format("0x%016" PRIx64, vmaddr) << "\n";
7161     outs() << "   vmsize " << format("0x%016" PRIx64, vmsize) << "\n";
7162   } else {
7163     outs() << "   vmaddr " << format("0x%08" PRIx64, vmaddr) << "\n";
7164     outs() << "   vmsize " << format("0x%08" PRIx64, vmsize) << "\n";
7165   }
7166   outs() << "  fileoff " << fileoff;
7167   if (fileoff > object_size)
7168     outs() << " (past end of file)\n";
7169   else
7170     outs() << "\n";
7171   outs() << " filesize " << filesize;
7172   if (fileoff + filesize > object_size)
7173     outs() << " (past end of file)\n";
7174   else
7175     outs() << "\n";
7176   if (verbose) {
7177     if ((maxprot &
7178          ~(MachO::VM_PROT_READ | MachO::VM_PROT_WRITE |
7179            MachO::VM_PROT_EXECUTE)) != 0)
7180       outs() << "  maxprot ?" << format("0x%08" PRIx32, maxprot) << "\n";
7181     else {
7182       if (maxprot & MachO::VM_PROT_READ)
7183         outs() << "  maxprot r";
7184       else
7185         outs() << "  maxprot -";
7186       if (maxprot & MachO::VM_PROT_WRITE)
7187         outs() << "w";
7188       else
7189         outs() << "-";
7190       if (maxprot & MachO::VM_PROT_EXECUTE)
7191         outs() << "x\n";
7192       else
7193         outs() << "-\n";
7194     }
7195     if ((initprot &
7196          ~(MachO::VM_PROT_READ | MachO::VM_PROT_WRITE |
7197            MachO::VM_PROT_EXECUTE)) != 0)
7198       outs() << "  initprot ?" << format("0x%08" PRIx32, initprot) << "\n";
7199     else {
7200       if (initprot & MachO::VM_PROT_READ)
7201         outs() << " initprot r";
7202       else
7203         outs() << " initprot -";
7204       if (initprot & MachO::VM_PROT_WRITE)
7205         outs() << "w";
7206       else
7207         outs() << "-";
7208       if (initprot & MachO::VM_PROT_EXECUTE)
7209         outs() << "x\n";
7210       else
7211         outs() << "-\n";
7212     }
7213   } else {
7214     outs() << "  maxprot " << format("0x%08" PRIx32, maxprot) << "\n";
7215     outs() << " initprot " << format("0x%08" PRIx32, initprot) << "\n";
7216   }
7217   outs() << "   nsects " << nsects << "\n";
7218   if (verbose) {
7219     outs() << "    flags";
7220     if (flags == 0)
7221       outs() << " (none)\n";
7222     else {
7223       if (flags & MachO::SG_HIGHVM) {
7224         outs() << " HIGHVM";
7225         flags &= ~MachO::SG_HIGHVM;
7226       }
7227       if (flags & MachO::SG_FVMLIB) {
7228         outs() << " FVMLIB";
7229         flags &= ~MachO::SG_FVMLIB;
7230       }
7231       if (flags & MachO::SG_NORELOC) {
7232         outs() << " NORELOC";
7233         flags &= ~MachO::SG_NORELOC;
7234       }
7235       if (flags & MachO::SG_PROTECTED_VERSION_1) {
7236         outs() << " PROTECTED_VERSION_1";
7237         flags &= ~MachO::SG_PROTECTED_VERSION_1;
7238       }
7239       if (flags)
7240         outs() << format(" 0x%08" PRIx32, flags) << " (unknown flags)\n";
7241       else
7242         outs() << "\n";
7243     }
7244   } else {
7245     outs() << "    flags " << format("0x%" PRIx32, flags) << "\n";
7246   }
7247 }
7248
7249 static void PrintSection(const char *sectname, const char *segname,
7250                          uint64_t addr, uint64_t size, uint32_t offset,
7251                          uint32_t align, uint32_t reloff, uint32_t nreloc,
7252                          uint32_t flags, uint32_t reserved1, uint32_t reserved2,
7253                          uint32_t cmd, const char *sg_segname,
7254                          uint32_t filetype, uint32_t object_size,
7255                          bool verbose) {
7256   outs() << "Section\n";
7257   outs() << "  sectname " << format("%.16s\n", sectname);
7258   outs() << "   segname " << format("%.16s", segname);
7259   if (filetype != MachO::MH_OBJECT && strncmp(sg_segname, segname, 16) != 0)
7260     outs() << " (does not match segment)\n";
7261   else
7262     outs() << "\n";
7263   if (cmd == MachO::LC_SEGMENT_64) {
7264     outs() << "      addr " << format("0x%016" PRIx64, addr) << "\n";
7265     outs() << "      size " << format("0x%016" PRIx64, size);
7266   } else {
7267     outs() << "      addr " << format("0x%08" PRIx64, addr) << "\n";
7268     outs() << "      size " << format("0x%08" PRIx64, size);
7269   }
7270   if ((flags & MachO::S_ZEROFILL) != 0 && offset + size > object_size)
7271     outs() << " (past end of file)\n";
7272   else
7273     outs() << "\n";
7274   outs() << "    offset " << offset;
7275   if (offset > object_size)
7276     outs() << " (past end of file)\n";
7277   else
7278     outs() << "\n";
7279   uint32_t align_shifted = 1 << align;
7280   outs() << "     align 2^" << align << " (" << align_shifted << ")\n";
7281   outs() << "    reloff " << reloff;
7282   if (reloff > object_size)
7283     outs() << " (past end of file)\n";
7284   else
7285     outs() << "\n";
7286   outs() << "    nreloc " << nreloc;
7287   if (reloff + nreloc * sizeof(struct MachO::relocation_info) > object_size)
7288     outs() << " (past end of file)\n";
7289   else
7290     outs() << "\n";
7291   uint32_t section_type = flags & MachO::SECTION_TYPE;
7292   if (verbose) {
7293     outs() << "      type";
7294     if (section_type == MachO::S_REGULAR)
7295       outs() << " S_REGULAR\n";
7296     else if (section_type == MachO::S_ZEROFILL)
7297       outs() << " S_ZEROFILL\n";
7298     else if (section_type == MachO::S_CSTRING_LITERALS)
7299       outs() << " S_CSTRING_LITERALS\n";
7300     else if (section_type == MachO::S_4BYTE_LITERALS)
7301       outs() << " S_4BYTE_LITERALS\n";
7302     else if (section_type == MachO::S_8BYTE_LITERALS)
7303       outs() << " S_8BYTE_LITERALS\n";
7304     else if (section_type == MachO::S_16BYTE_LITERALS)
7305       outs() << " S_16BYTE_LITERALS\n";
7306     else if (section_type == MachO::S_LITERAL_POINTERS)
7307       outs() << " S_LITERAL_POINTERS\n";
7308     else if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS)
7309       outs() << " S_NON_LAZY_SYMBOL_POINTERS\n";
7310     else if (section_type == MachO::S_LAZY_SYMBOL_POINTERS)
7311       outs() << " S_LAZY_SYMBOL_POINTERS\n";
7312     else if (section_type == MachO::S_SYMBOL_STUBS)
7313       outs() << " S_SYMBOL_STUBS\n";
7314     else if (section_type == MachO::S_MOD_INIT_FUNC_POINTERS)
7315       outs() << " S_MOD_INIT_FUNC_POINTERS\n";
7316     else if (section_type == MachO::S_MOD_TERM_FUNC_POINTERS)
7317       outs() << " S_MOD_TERM_FUNC_POINTERS\n";
7318     else if (section_type == MachO::S_COALESCED)
7319       outs() << " S_COALESCED\n";
7320     else if (section_type == MachO::S_INTERPOSING)
7321       outs() << " S_INTERPOSING\n";
7322     else if (section_type == MachO::S_DTRACE_DOF)
7323       outs() << " S_DTRACE_DOF\n";
7324     else if (section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS)
7325       outs() << " S_LAZY_DYLIB_SYMBOL_POINTERS\n";
7326     else if (section_type == MachO::S_THREAD_LOCAL_REGULAR)
7327       outs() << " S_THREAD_LOCAL_REGULAR\n";
7328     else if (section_type == MachO::S_THREAD_LOCAL_ZEROFILL)
7329       outs() << " S_THREAD_LOCAL_ZEROFILL\n";
7330     else if (section_type == MachO::S_THREAD_LOCAL_VARIABLES)
7331       outs() << " S_THREAD_LOCAL_VARIABLES\n";
7332     else if (section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS)
7333       outs() << " S_THREAD_LOCAL_VARIABLE_POINTERS\n";
7334     else if (section_type == MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS)
7335       outs() << " S_THREAD_LOCAL_INIT_FUNCTION_POINTERS\n";
7336     else
7337       outs() << format("0x%08" PRIx32, section_type) << "\n";
7338     outs() << "attributes";
7339     uint32_t section_attributes = flags & MachO::SECTION_ATTRIBUTES;
7340     if (section_attributes & MachO::S_ATTR_PURE_INSTRUCTIONS)
7341       outs() << " PURE_INSTRUCTIONS";
7342     if (section_attributes & MachO::S_ATTR_NO_TOC)
7343       outs() << " NO_TOC";
7344     if (section_attributes & MachO::S_ATTR_STRIP_STATIC_SYMS)
7345       outs() << " STRIP_STATIC_SYMS";
7346     if (section_attributes & MachO::S_ATTR_NO_DEAD_STRIP)
7347       outs() << " NO_DEAD_STRIP";
7348     if (section_attributes & MachO::S_ATTR_LIVE_SUPPORT)
7349       outs() << " LIVE_SUPPORT";
7350     if (section_attributes & MachO::S_ATTR_SELF_MODIFYING_CODE)
7351       outs() << " SELF_MODIFYING_CODE";
7352     if (section_attributes & MachO::S_ATTR_DEBUG)
7353       outs() << " DEBUG";
7354     if (section_attributes & MachO::S_ATTR_SOME_INSTRUCTIONS)
7355       outs() << " SOME_INSTRUCTIONS";
7356     if (section_attributes & MachO::S_ATTR_EXT_RELOC)
7357       outs() << " EXT_RELOC";
7358     if (section_attributes & MachO::S_ATTR_LOC_RELOC)
7359       outs() << " LOC_RELOC";
7360     if (section_attributes == 0)
7361       outs() << " (none)";
7362     outs() << "\n";
7363   } else
7364     outs() << "     flags " << format("0x%08" PRIx32, flags) << "\n";
7365   outs() << " reserved1 " << reserved1;
7366   if (section_type == MachO::S_SYMBOL_STUBS ||
7367       section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
7368       section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
7369       section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
7370       section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS)
7371     outs() << " (index into indirect symbol table)\n";
7372   else
7373     outs() << "\n";
7374   outs() << " reserved2 " << reserved2;
7375   if (section_type == MachO::S_SYMBOL_STUBS)
7376     outs() << " (size of stubs)\n";
7377   else
7378     outs() << "\n";
7379 }
7380
7381 static void PrintSymtabLoadCommand(MachO::symtab_command st, bool Is64Bit,
7382                                    uint32_t object_size) {
7383   outs() << "     cmd LC_SYMTAB\n";
7384   outs() << " cmdsize " << st.cmdsize;
7385   if (st.cmdsize != sizeof(struct MachO::symtab_command))
7386     outs() << " Incorrect size\n";
7387   else
7388     outs() << "\n";
7389   outs() << "  symoff " << st.symoff;
7390   if (st.symoff > object_size)
7391     outs() << " (past end of file)\n";
7392   else
7393     outs() << "\n";
7394   outs() << "   nsyms " << st.nsyms;
7395   uint64_t big_size;
7396   if (Is64Bit) {
7397     big_size = st.nsyms;
7398     big_size *= sizeof(struct MachO::nlist_64);
7399     big_size += st.symoff;
7400     if (big_size > object_size)
7401       outs() << " (past end of file)\n";
7402     else
7403       outs() << "\n";
7404   } else {
7405     big_size = st.nsyms;
7406     big_size *= sizeof(struct MachO::nlist);
7407     big_size += st.symoff;
7408     if (big_size > object_size)
7409       outs() << " (past end of file)\n";
7410     else
7411       outs() << "\n";
7412   }
7413   outs() << "  stroff " << st.stroff;
7414   if (st.stroff > object_size)
7415     outs() << " (past end of file)\n";
7416   else
7417     outs() << "\n";
7418   outs() << " strsize " << st.strsize;
7419   big_size = st.stroff;
7420   big_size += st.strsize;
7421   if (big_size > object_size)
7422     outs() << " (past end of file)\n";
7423   else
7424     outs() << "\n";
7425 }
7426
7427 static void PrintDysymtabLoadCommand(MachO::dysymtab_command dyst,
7428                                      uint32_t nsyms, uint32_t object_size,
7429                                      bool Is64Bit) {
7430   outs() << "            cmd LC_DYSYMTAB\n";
7431   outs() << "        cmdsize " << dyst.cmdsize;
7432   if (dyst.cmdsize != sizeof(struct MachO::dysymtab_command))
7433     outs() << " Incorrect size\n";
7434   else
7435     outs() << "\n";
7436   outs() << "      ilocalsym " << dyst.ilocalsym;
7437   if (dyst.ilocalsym > nsyms)
7438     outs() << " (greater than the number of symbols)\n";
7439   else
7440     outs() << "\n";
7441   outs() << "      nlocalsym " << dyst.nlocalsym;
7442   uint64_t big_size;
7443   big_size = dyst.ilocalsym;
7444   big_size += dyst.nlocalsym;
7445   if (big_size > nsyms)
7446     outs() << " (past the end of the symbol table)\n";
7447   else
7448     outs() << "\n";
7449   outs() << "     iextdefsym " << dyst.iextdefsym;
7450   if (dyst.iextdefsym > nsyms)
7451     outs() << " (greater than the number of symbols)\n";
7452   else
7453     outs() << "\n";
7454   outs() << "     nextdefsym " << dyst.nextdefsym;
7455   big_size = dyst.iextdefsym;
7456   big_size += dyst.nextdefsym;
7457   if (big_size > nsyms)
7458     outs() << " (past the end of the symbol table)\n";
7459   else
7460     outs() << "\n";
7461   outs() << "      iundefsym " << dyst.iundefsym;
7462   if (dyst.iundefsym > nsyms)
7463     outs() << " (greater than the number of symbols)\n";
7464   else
7465     outs() << "\n";
7466   outs() << "      nundefsym " << dyst.nundefsym;
7467   big_size = dyst.iundefsym;
7468   big_size += dyst.nundefsym;
7469   if (big_size > nsyms)
7470     outs() << " (past the end of the symbol table)\n";
7471   else
7472     outs() << "\n";
7473   outs() << "         tocoff " << dyst.tocoff;
7474   if (dyst.tocoff > object_size)
7475     outs() << " (past end of file)\n";
7476   else
7477     outs() << "\n";
7478   outs() << "           ntoc " << dyst.ntoc;
7479   big_size = dyst.ntoc;
7480   big_size *= sizeof(struct MachO::dylib_table_of_contents);
7481   big_size += dyst.tocoff;
7482   if (big_size > object_size)
7483     outs() << " (past end of file)\n";
7484   else
7485     outs() << "\n";
7486   outs() << "      modtaboff " << dyst.modtaboff;
7487   if (dyst.modtaboff > object_size)
7488     outs() << " (past end of file)\n";
7489   else
7490     outs() << "\n";
7491   outs() << "        nmodtab " << dyst.nmodtab;
7492   uint64_t modtabend;
7493   if (Is64Bit) {
7494     modtabend = dyst.nmodtab;
7495     modtabend *= sizeof(struct MachO::dylib_module_64);
7496     modtabend += dyst.modtaboff;
7497   } else {
7498     modtabend = dyst.nmodtab;
7499     modtabend *= sizeof(struct MachO::dylib_module);
7500     modtabend += dyst.modtaboff;
7501   }
7502   if (modtabend > object_size)
7503     outs() << " (past end of file)\n";
7504   else
7505     outs() << "\n";
7506   outs() << "   extrefsymoff " << dyst.extrefsymoff;
7507   if (dyst.extrefsymoff > object_size)
7508     outs() << " (past end of file)\n";
7509   else
7510     outs() << "\n";
7511   outs() << "    nextrefsyms " << dyst.nextrefsyms;
7512   big_size = dyst.nextrefsyms;
7513   big_size *= sizeof(struct MachO::dylib_reference);
7514   big_size += dyst.extrefsymoff;
7515   if (big_size > object_size)
7516     outs() << " (past end of file)\n";
7517   else
7518     outs() << "\n";
7519   outs() << " indirectsymoff " << dyst.indirectsymoff;
7520   if (dyst.indirectsymoff > object_size)
7521     outs() << " (past end of file)\n";
7522   else
7523     outs() << "\n";
7524   outs() << "  nindirectsyms " << dyst.nindirectsyms;
7525   big_size = dyst.nindirectsyms;
7526   big_size *= sizeof(uint32_t);
7527   big_size += dyst.indirectsymoff;
7528   if (big_size > object_size)
7529     outs() << " (past end of file)\n";
7530   else
7531     outs() << "\n";
7532   outs() << "      extreloff " << dyst.extreloff;
7533   if (dyst.extreloff > object_size)
7534     outs() << " (past end of file)\n";
7535   else
7536     outs() << "\n";
7537   outs() << "        nextrel " << dyst.nextrel;
7538   big_size = dyst.nextrel;
7539   big_size *= sizeof(struct MachO::relocation_info);
7540   big_size += dyst.extreloff;
7541   if (big_size > object_size)
7542     outs() << " (past end of file)\n";
7543   else
7544     outs() << "\n";
7545   outs() << "      locreloff " << dyst.locreloff;
7546   if (dyst.locreloff > object_size)
7547     outs() << " (past end of file)\n";
7548   else
7549     outs() << "\n";
7550   outs() << "        nlocrel " << dyst.nlocrel;
7551   big_size = dyst.nlocrel;
7552   big_size *= sizeof(struct MachO::relocation_info);
7553   big_size += dyst.locreloff;
7554   if (big_size > object_size)
7555     outs() << " (past end of file)\n";
7556   else
7557     outs() << "\n";
7558 }
7559
7560 static void PrintDyldInfoLoadCommand(MachO::dyld_info_command dc,
7561                                      uint32_t object_size) {
7562   if (dc.cmd == MachO::LC_DYLD_INFO)
7563     outs() << "            cmd LC_DYLD_INFO\n";
7564   else
7565     outs() << "            cmd LC_DYLD_INFO_ONLY\n";
7566   outs() << "        cmdsize " << dc.cmdsize;
7567   if (dc.cmdsize != sizeof(struct MachO::dyld_info_command))
7568     outs() << " Incorrect size\n";
7569   else
7570     outs() << "\n";
7571   outs() << "     rebase_off " << dc.rebase_off;
7572   if (dc.rebase_off > object_size)
7573     outs() << " (past end of file)\n";
7574   else
7575     outs() << "\n";
7576   outs() << "    rebase_size " << dc.rebase_size;
7577   uint64_t big_size;
7578   big_size = dc.rebase_off;
7579   big_size += dc.rebase_size;
7580   if (big_size > object_size)
7581     outs() << " (past end of file)\n";
7582   else
7583     outs() << "\n";
7584   outs() << "       bind_off " << dc.bind_off;
7585   if (dc.bind_off > object_size)
7586     outs() << " (past end of file)\n";
7587   else
7588     outs() << "\n";
7589   outs() << "      bind_size " << dc.bind_size;
7590   big_size = dc.bind_off;
7591   big_size += dc.bind_size;
7592   if (big_size > object_size)
7593     outs() << " (past end of file)\n";
7594   else
7595     outs() << "\n";
7596   outs() << "  weak_bind_off " << dc.weak_bind_off;
7597   if (dc.weak_bind_off > object_size)
7598     outs() << " (past end of file)\n";
7599   else
7600     outs() << "\n";
7601   outs() << " weak_bind_size " << dc.weak_bind_size;
7602   big_size = dc.weak_bind_off;
7603   big_size += dc.weak_bind_size;
7604   if (big_size > object_size)
7605     outs() << " (past end of file)\n";
7606   else
7607     outs() << "\n";
7608   outs() << "  lazy_bind_off " << dc.lazy_bind_off;
7609   if (dc.lazy_bind_off > object_size)
7610     outs() << " (past end of file)\n";
7611   else
7612     outs() << "\n";
7613   outs() << " lazy_bind_size " << dc.lazy_bind_size;
7614   big_size = dc.lazy_bind_off;
7615   big_size += dc.lazy_bind_size;
7616   if (big_size > object_size)
7617     outs() << " (past end of file)\n";
7618   else
7619     outs() << "\n";
7620   outs() << "     export_off " << dc.export_off;
7621   if (dc.export_off > object_size)
7622     outs() << " (past end of file)\n";
7623   else
7624     outs() << "\n";
7625   outs() << "    export_size " << dc.export_size;
7626   big_size = dc.export_off;
7627   big_size += dc.export_size;
7628   if (big_size > object_size)
7629     outs() << " (past end of file)\n";
7630   else
7631     outs() << "\n";
7632 }
7633
7634 static void PrintDyldLoadCommand(MachO::dylinker_command dyld,
7635                                  const char *Ptr) {
7636   if (dyld.cmd == MachO::LC_ID_DYLINKER)
7637     outs() << "          cmd LC_ID_DYLINKER\n";
7638   else if (dyld.cmd == MachO::LC_LOAD_DYLINKER)
7639     outs() << "          cmd LC_LOAD_DYLINKER\n";
7640   else if (dyld.cmd == MachO::LC_DYLD_ENVIRONMENT)
7641     outs() << "          cmd LC_DYLD_ENVIRONMENT\n";
7642   else
7643     outs() << "          cmd ?(" << dyld.cmd << ")\n";
7644   outs() << "      cmdsize " << dyld.cmdsize;
7645   if (dyld.cmdsize < sizeof(struct MachO::dylinker_command))
7646     outs() << " Incorrect size\n";
7647   else
7648     outs() << "\n";
7649   if (dyld.name >= dyld.cmdsize)
7650     outs() << "         name ?(bad offset " << dyld.name << ")\n";
7651   else {
7652     const char *P = (const char *)(Ptr) + dyld.name;
7653     outs() << "         name " << P << " (offset " << dyld.name << ")\n";
7654   }
7655 }
7656
7657 static void PrintUuidLoadCommand(MachO::uuid_command uuid) {
7658   outs() << "     cmd LC_UUID\n";
7659   outs() << " cmdsize " << uuid.cmdsize;
7660   if (uuid.cmdsize != sizeof(struct MachO::uuid_command))
7661     outs() << " Incorrect size\n";
7662   else
7663     outs() << "\n";
7664   outs() << "    uuid ";
7665   outs() << format("%02" PRIX32, uuid.uuid[0]);
7666   outs() << format("%02" PRIX32, uuid.uuid[1]);
7667   outs() << format("%02" PRIX32, uuid.uuid[2]);
7668   outs() << format("%02" PRIX32, uuid.uuid[3]);
7669   outs() << "-";
7670   outs() << format("%02" PRIX32, uuid.uuid[4]);
7671   outs() << format("%02" PRIX32, uuid.uuid[5]);
7672   outs() << "-";
7673   outs() << format("%02" PRIX32, uuid.uuid[6]);
7674   outs() << format("%02" PRIX32, uuid.uuid[7]);
7675   outs() << "-";
7676   outs() << format("%02" PRIX32, uuid.uuid[8]);
7677   outs() << format("%02" PRIX32, uuid.uuid[9]);
7678   outs() << "-";
7679   outs() << format("%02" PRIX32, uuid.uuid[10]);
7680   outs() << format("%02" PRIX32, uuid.uuid[11]);
7681   outs() << format("%02" PRIX32, uuid.uuid[12]);
7682   outs() << format("%02" PRIX32, uuid.uuid[13]);
7683   outs() << format("%02" PRIX32, uuid.uuid[14]);
7684   outs() << format("%02" PRIX32, uuid.uuid[15]);
7685   outs() << "\n";
7686 }
7687
7688 static void PrintRpathLoadCommand(MachO::rpath_command rpath, const char *Ptr) {
7689   outs() << "          cmd LC_RPATH\n";
7690   outs() << "      cmdsize " << rpath.cmdsize;
7691   if (rpath.cmdsize < sizeof(struct MachO::rpath_command))
7692     outs() << " Incorrect size\n";
7693   else
7694     outs() << "\n";
7695   if (rpath.path >= rpath.cmdsize)
7696     outs() << "         path ?(bad offset " << rpath.path << ")\n";
7697   else {
7698     const char *P = (const char *)(Ptr) + rpath.path;
7699     outs() << "         path " << P << " (offset " << rpath.path << ")\n";
7700   }
7701 }
7702
7703 static void PrintVersionMinLoadCommand(MachO::version_min_command vd) {
7704   if (vd.cmd == MachO::LC_VERSION_MIN_MACOSX)
7705     outs() << "      cmd LC_VERSION_MIN_MACOSX\n";
7706   else if (vd.cmd == MachO::LC_VERSION_MIN_IPHONEOS)
7707     outs() << "      cmd LC_VERSION_MIN_IPHONEOS\n";
7708   else
7709     outs() << "      cmd " << vd.cmd << " (?)\n";
7710   outs() << "  cmdsize " << vd.cmdsize;
7711   if (vd.cmdsize != sizeof(struct MachO::version_min_command))
7712     outs() << " Incorrect size\n";
7713   else
7714     outs() << "\n";
7715   outs() << "  version " << ((vd.version >> 16) & 0xffff) << "."
7716          << ((vd.version >> 8) & 0xff);
7717   if ((vd.version & 0xff) != 0)
7718     outs() << "." << (vd.version & 0xff);
7719   outs() << "\n";
7720   if (vd.sdk == 0)
7721     outs() << "      sdk n/a";
7722   else {
7723     outs() << "      sdk " << ((vd.sdk >> 16) & 0xffff) << "."
7724            << ((vd.sdk >> 8) & 0xff);
7725   }
7726   if ((vd.sdk & 0xff) != 0)
7727     outs() << "." << (vd.sdk & 0xff);
7728   outs() << "\n";
7729 }
7730
7731 static void PrintSourceVersionCommand(MachO::source_version_command sd) {
7732   outs() << "      cmd LC_SOURCE_VERSION\n";
7733   outs() << "  cmdsize " << sd.cmdsize;
7734   if (sd.cmdsize != sizeof(struct MachO::source_version_command))
7735     outs() << " Incorrect size\n";
7736   else
7737     outs() << "\n";
7738   uint64_t a = (sd.version >> 40) & 0xffffff;
7739   uint64_t b = (sd.version >> 30) & 0x3ff;
7740   uint64_t c = (sd.version >> 20) & 0x3ff;
7741   uint64_t d = (sd.version >> 10) & 0x3ff;
7742   uint64_t e = sd.version & 0x3ff;
7743   outs() << "  version " << a << "." << b;
7744   if (e != 0)
7745     outs() << "." << c << "." << d << "." << e;
7746   else if (d != 0)
7747     outs() << "." << c << "." << d;
7748   else if (c != 0)
7749     outs() << "." << c;
7750   outs() << "\n";
7751 }
7752
7753 static void PrintEntryPointCommand(MachO::entry_point_command ep) {
7754   outs() << "       cmd LC_MAIN\n";
7755   outs() << "   cmdsize " << ep.cmdsize;
7756   if (ep.cmdsize != sizeof(struct MachO::entry_point_command))
7757     outs() << " Incorrect size\n";
7758   else
7759     outs() << "\n";
7760   outs() << "  entryoff " << ep.entryoff << "\n";
7761   outs() << " stacksize " << ep.stacksize << "\n";
7762 }
7763
7764 static void PrintEncryptionInfoCommand(MachO::encryption_info_command ec,
7765                                        uint32_t object_size) {
7766   outs() << "          cmd LC_ENCRYPTION_INFO\n";
7767   outs() << "      cmdsize " << ec.cmdsize;
7768   if (ec.cmdsize != sizeof(struct MachO::encryption_info_command))
7769     outs() << " Incorrect size\n";
7770   else
7771     outs() << "\n";
7772   outs() << "     cryptoff " << ec.cryptoff;
7773   if (ec.cryptoff > object_size)
7774     outs() << " (past end of file)\n";
7775   else
7776     outs() << "\n";
7777   outs() << "    cryptsize " << ec.cryptsize;
7778   if (ec.cryptsize > object_size)
7779     outs() << " (past end of file)\n";
7780   else
7781     outs() << "\n";
7782   outs() << "      cryptid " << ec.cryptid << "\n";
7783 }
7784
7785 static void PrintEncryptionInfoCommand64(MachO::encryption_info_command_64 ec,
7786                                          uint32_t object_size) {
7787   outs() << "          cmd LC_ENCRYPTION_INFO_64\n";
7788   outs() << "      cmdsize " << ec.cmdsize;
7789   if (ec.cmdsize != sizeof(struct MachO::encryption_info_command_64))
7790     outs() << " Incorrect size\n";
7791   else
7792     outs() << "\n";
7793   outs() << "     cryptoff " << ec.cryptoff;
7794   if (ec.cryptoff > object_size)
7795     outs() << " (past end of file)\n";
7796   else
7797     outs() << "\n";
7798   outs() << "    cryptsize " << ec.cryptsize;
7799   if (ec.cryptsize > object_size)
7800     outs() << " (past end of file)\n";
7801   else
7802     outs() << "\n";
7803   outs() << "      cryptid " << ec.cryptid << "\n";
7804   outs() << "          pad " << ec.pad << "\n";
7805 }
7806
7807 static void PrintLinkerOptionCommand(MachO::linker_option_command lo,
7808                                      const char *Ptr) {
7809   outs() << "     cmd LC_LINKER_OPTION\n";
7810   outs() << " cmdsize " << lo.cmdsize;
7811   if (lo.cmdsize < sizeof(struct MachO::linker_option_command))
7812     outs() << " Incorrect size\n";
7813   else
7814     outs() << "\n";
7815   outs() << "   count " << lo.count << "\n";
7816   const char *string = Ptr + sizeof(struct MachO::linker_option_command);
7817   uint32_t left = lo.cmdsize - sizeof(struct MachO::linker_option_command);
7818   uint32_t i = 0;
7819   while (left > 0) {
7820     while (*string == '\0' && left > 0) {
7821       string++;
7822       left--;
7823     }
7824     if (left > 0) {
7825       i++;
7826       outs() << "  string #" << i << " " << format("%.*s\n", left, string);
7827       uint32_t NullPos = StringRef(string, left).find('\0');
7828       uint32_t len = std::min(NullPos, left) + 1;
7829       string += len;
7830       left -= len;
7831     }
7832   }
7833   if (lo.count != i)
7834     outs() << "   count " << lo.count << " does not match number of strings "
7835            << i << "\n";
7836 }
7837
7838 static void PrintSubFrameworkCommand(MachO::sub_framework_command sub,
7839                                      const char *Ptr) {
7840   outs() << "          cmd LC_SUB_FRAMEWORK\n";
7841   outs() << "      cmdsize " << sub.cmdsize;
7842   if (sub.cmdsize < sizeof(struct MachO::sub_framework_command))
7843     outs() << " Incorrect size\n";
7844   else
7845     outs() << "\n";
7846   if (sub.umbrella < sub.cmdsize) {
7847     const char *P = Ptr + sub.umbrella;
7848     outs() << "     umbrella " << P << " (offset " << sub.umbrella << ")\n";
7849   } else {
7850     outs() << "     umbrella ?(bad offset " << sub.umbrella << ")\n";
7851   }
7852 }
7853
7854 static void PrintSubUmbrellaCommand(MachO::sub_umbrella_command sub,
7855                                     const char *Ptr) {
7856   outs() << "          cmd LC_SUB_UMBRELLA\n";
7857   outs() << "      cmdsize " << sub.cmdsize;
7858   if (sub.cmdsize < sizeof(struct MachO::sub_umbrella_command))
7859     outs() << " Incorrect size\n";
7860   else
7861     outs() << "\n";
7862   if (sub.sub_umbrella < sub.cmdsize) {
7863     const char *P = Ptr + sub.sub_umbrella;
7864     outs() << " sub_umbrella " << P << " (offset " << sub.sub_umbrella << ")\n";
7865   } else {
7866     outs() << " sub_umbrella ?(bad offset " << sub.sub_umbrella << ")\n";
7867   }
7868 }
7869
7870 static void PrintSubLibraryCommand(MachO::sub_library_command sub,
7871                                    const char *Ptr) {
7872   outs() << "          cmd LC_SUB_LIBRARY\n";
7873   outs() << "      cmdsize " << sub.cmdsize;
7874   if (sub.cmdsize < sizeof(struct MachO::sub_library_command))
7875     outs() << " Incorrect size\n";
7876   else
7877     outs() << "\n";
7878   if (sub.sub_library < sub.cmdsize) {
7879     const char *P = Ptr + sub.sub_library;
7880     outs() << "  sub_library " << P << " (offset " << sub.sub_library << ")\n";
7881   } else {
7882     outs() << "  sub_library ?(bad offset " << sub.sub_library << ")\n";
7883   }
7884 }
7885
7886 static void PrintSubClientCommand(MachO::sub_client_command sub,
7887                                   const char *Ptr) {
7888   outs() << "          cmd LC_SUB_CLIENT\n";
7889   outs() << "      cmdsize " << sub.cmdsize;
7890   if (sub.cmdsize < sizeof(struct MachO::sub_client_command))
7891     outs() << " Incorrect size\n";
7892   else
7893     outs() << "\n";
7894   if (sub.client < sub.cmdsize) {
7895     const char *P = Ptr + sub.client;
7896     outs() << "       client " << P << " (offset " << sub.client << ")\n";
7897   } else {
7898     outs() << "       client ?(bad offset " << sub.client << ")\n";
7899   }
7900 }
7901
7902 static void PrintRoutinesCommand(MachO::routines_command r) {
7903   outs() << "          cmd LC_ROUTINES\n";
7904   outs() << "      cmdsize " << r.cmdsize;
7905   if (r.cmdsize != sizeof(struct MachO::routines_command))
7906     outs() << " Incorrect size\n";
7907   else
7908     outs() << "\n";
7909   outs() << " init_address " << format("0x%08" PRIx32, r.init_address) << "\n";
7910   outs() << "  init_module " << r.init_module << "\n";
7911   outs() << "    reserved1 " << r.reserved1 << "\n";
7912   outs() << "    reserved2 " << r.reserved2 << "\n";
7913   outs() << "    reserved3 " << r.reserved3 << "\n";
7914   outs() << "    reserved4 " << r.reserved4 << "\n";
7915   outs() << "    reserved5 " << r.reserved5 << "\n";
7916   outs() << "    reserved6 " << r.reserved6 << "\n";
7917 }
7918
7919 static void PrintRoutinesCommand64(MachO::routines_command_64 r) {
7920   outs() << "          cmd LC_ROUTINES_64\n";
7921   outs() << "      cmdsize " << r.cmdsize;
7922   if (r.cmdsize != sizeof(struct MachO::routines_command_64))
7923     outs() << " Incorrect size\n";
7924   else
7925     outs() << "\n";
7926   outs() << " init_address " << format("0x%016" PRIx64, r.init_address) << "\n";
7927   outs() << "  init_module " << r.init_module << "\n";
7928   outs() << "    reserved1 " << r.reserved1 << "\n";
7929   outs() << "    reserved2 " << r.reserved2 << "\n";
7930   outs() << "    reserved3 " << r.reserved3 << "\n";
7931   outs() << "    reserved4 " << r.reserved4 << "\n";
7932   outs() << "    reserved5 " << r.reserved5 << "\n";
7933   outs() << "    reserved6 " << r.reserved6 << "\n";
7934 }
7935
7936 static void Print_x86_thread_state64_t(MachO::x86_thread_state64_t &cpu64) {
7937   outs() << "   rax  " << format("0x%016" PRIx64, cpu64.rax);
7938   outs() << " rbx " << format("0x%016" PRIx64, cpu64.rbx);
7939   outs() << " rcx  " << format("0x%016" PRIx64, cpu64.rcx) << "\n";
7940   outs() << "   rdx  " << format("0x%016" PRIx64, cpu64.rdx);
7941   outs() << " rdi " << format("0x%016" PRIx64, cpu64.rdi);
7942   outs() << " rsi  " << format("0x%016" PRIx64, cpu64.rsi) << "\n";
7943   outs() << "   rbp  " << format("0x%016" PRIx64, cpu64.rbp);
7944   outs() << " rsp " << format("0x%016" PRIx64, cpu64.rsp);
7945   outs() << " r8   " << format("0x%016" PRIx64, cpu64.r8) << "\n";
7946   outs() << "    r9  " << format("0x%016" PRIx64, cpu64.r9);
7947   outs() << " r10 " << format("0x%016" PRIx64, cpu64.r10);
7948   outs() << " r11  " << format("0x%016" PRIx64, cpu64.r11) << "\n";
7949   outs() << "   r12  " << format("0x%016" PRIx64, cpu64.r12);
7950   outs() << " r13 " << format("0x%016" PRIx64, cpu64.r13);
7951   outs() << " r14  " << format("0x%016" PRIx64, cpu64.r14) << "\n";
7952   outs() << "   r15  " << format("0x%016" PRIx64, cpu64.r15);
7953   outs() << " rip " << format("0x%016" PRIx64, cpu64.rip) << "\n";
7954   outs() << "rflags  " << format("0x%016" PRIx64, cpu64.rflags);
7955   outs() << " cs  " << format("0x%016" PRIx64, cpu64.cs);
7956   outs() << " fs   " << format("0x%016" PRIx64, cpu64.fs) << "\n";
7957   outs() << "    gs  " << format("0x%016" PRIx64, cpu64.gs) << "\n";
7958 }
7959
7960 static void Print_mmst_reg(MachO::mmst_reg_t &r) {
7961   uint32_t f;
7962   outs() << "\t      mmst_reg  ";
7963   for (f = 0; f < 10; f++)
7964     outs() << format("%02" PRIx32, (r.mmst_reg[f] & 0xff)) << " ";
7965   outs() << "\n";
7966   outs() << "\t      mmst_rsrv ";
7967   for (f = 0; f < 6; f++)
7968     outs() << format("%02" PRIx32, (r.mmst_rsrv[f] & 0xff)) << " ";
7969   outs() << "\n";
7970 }
7971
7972 static void Print_xmm_reg(MachO::xmm_reg_t &r) {
7973   uint32_t f;
7974   outs() << "\t      xmm_reg ";
7975   for (f = 0; f < 16; f++)
7976     outs() << format("%02" PRIx32, (r.xmm_reg[f] & 0xff)) << " ";
7977   outs() << "\n";
7978 }
7979
7980 static void Print_x86_float_state_t(MachO::x86_float_state64_t &fpu) {
7981   outs() << "\t    fpu_reserved[0] " << fpu.fpu_reserved[0];
7982   outs() << " fpu_reserved[1] " << fpu.fpu_reserved[1] << "\n";
7983   outs() << "\t    control: invalid " << fpu.fpu_fcw.invalid;
7984   outs() << " denorm " << fpu.fpu_fcw.denorm;
7985   outs() << " zdiv " << fpu.fpu_fcw.zdiv;
7986   outs() << " ovrfl " << fpu.fpu_fcw.ovrfl;
7987   outs() << " undfl " << fpu.fpu_fcw.undfl;
7988   outs() << " precis " << fpu.fpu_fcw.precis << "\n";
7989   outs() << "\t\t     pc ";
7990   if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_24B)
7991     outs() << "FP_PREC_24B ";
7992   else if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_53B)
7993     outs() << "FP_PREC_53B ";
7994   else if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_64B)
7995     outs() << "FP_PREC_64B ";
7996   else
7997     outs() << fpu.fpu_fcw.pc << " ";
7998   outs() << "rc ";
7999   if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_NEAR)
8000     outs() << "FP_RND_NEAR ";
8001   else if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_DOWN)
8002     outs() << "FP_RND_DOWN ";
8003   else if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_UP)
8004     outs() << "FP_RND_UP ";
8005   else if (fpu.fpu_fcw.rc == MachO::x86_FP_CHOP)
8006     outs() << "FP_CHOP ";
8007   outs() << "\n";
8008   outs() << "\t    status: invalid " << fpu.fpu_fsw.invalid;
8009   outs() << " denorm " << fpu.fpu_fsw.denorm;
8010   outs() << " zdiv " << fpu.fpu_fsw.zdiv;
8011   outs() << " ovrfl " << fpu.fpu_fsw.ovrfl;
8012   outs() << " undfl " << fpu.fpu_fsw.undfl;
8013   outs() << " precis " << fpu.fpu_fsw.precis;
8014   outs() << " stkflt " << fpu.fpu_fsw.stkflt << "\n";
8015   outs() << "\t            errsumm " << fpu.fpu_fsw.errsumm;
8016   outs() << " c0 " << fpu.fpu_fsw.c0;
8017   outs() << " c1 " << fpu.fpu_fsw.c1;
8018   outs() << " c2 " << fpu.fpu_fsw.c2;
8019   outs() << " tos " << fpu.fpu_fsw.tos;
8020   outs() << " c3 " << fpu.fpu_fsw.c3;
8021   outs() << " busy " << fpu.fpu_fsw.busy << "\n";
8022   outs() << "\t    fpu_ftw " << format("0x%02" PRIx32, fpu.fpu_ftw);
8023   outs() << " fpu_rsrv1 " << format("0x%02" PRIx32, fpu.fpu_rsrv1);
8024   outs() << " fpu_fop " << format("0x%04" PRIx32, fpu.fpu_fop);
8025   outs() << " fpu_ip " << format("0x%08" PRIx32, fpu.fpu_ip) << "\n";
8026   outs() << "\t    fpu_cs " << format("0x%04" PRIx32, fpu.fpu_cs);
8027   outs() << " fpu_rsrv2 " << format("0x%04" PRIx32, fpu.fpu_rsrv2);
8028   outs() << " fpu_dp " << format("0x%08" PRIx32, fpu.fpu_dp);
8029   outs() << " fpu_ds " << format("0x%04" PRIx32, fpu.fpu_ds) << "\n";
8030   outs() << "\t    fpu_rsrv3 " << format("0x%04" PRIx32, fpu.fpu_rsrv3);
8031   outs() << " fpu_mxcsr " << format("0x%08" PRIx32, fpu.fpu_mxcsr);
8032   outs() << " fpu_mxcsrmask " << format("0x%08" PRIx32, fpu.fpu_mxcsrmask);
8033   outs() << "\n";
8034   outs() << "\t    fpu_stmm0:\n";
8035   Print_mmst_reg(fpu.fpu_stmm0);
8036   outs() << "\t    fpu_stmm1:\n";
8037   Print_mmst_reg(fpu.fpu_stmm1);
8038   outs() << "\t    fpu_stmm2:\n";
8039   Print_mmst_reg(fpu.fpu_stmm2);
8040   outs() << "\t    fpu_stmm3:\n";
8041   Print_mmst_reg(fpu.fpu_stmm3);
8042   outs() << "\t    fpu_stmm4:\n";
8043   Print_mmst_reg(fpu.fpu_stmm4);
8044   outs() << "\t    fpu_stmm5:\n";
8045   Print_mmst_reg(fpu.fpu_stmm5);
8046   outs() << "\t    fpu_stmm6:\n";
8047   Print_mmst_reg(fpu.fpu_stmm6);
8048   outs() << "\t    fpu_stmm7:\n";
8049   Print_mmst_reg(fpu.fpu_stmm7);
8050   outs() << "\t    fpu_xmm0:\n";
8051   Print_xmm_reg(fpu.fpu_xmm0);
8052   outs() << "\t    fpu_xmm1:\n";
8053   Print_xmm_reg(fpu.fpu_xmm1);
8054   outs() << "\t    fpu_xmm2:\n";
8055   Print_xmm_reg(fpu.fpu_xmm2);
8056   outs() << "\t    fpu_xmm3:\n";
8057   Print_xmm_reg(fpu.fpu_xmm3);
8058   outs() << "\t    fpu_xmm4:\n";
8059   Print_xmm_reg(fpu.fpu_xmm4);
8060   outs() << "\t    fpu_xmm5:\n";
8061   Print_xmm_reg(fpu.fpu_xmm5);
8062   outs() << "\t    fpu_xmm6:\n";
8063   Print_xmm_reg(fpu.fpu_xmm6);
8064   outs() << "\t    fpu_xmm7:\n";
8065   Print_xmm_reg(fpu.fpu_xmm7);
8066   outs() << "\t    fpu_xmm8:\n";
8067   Print_xmm_reg(fpu.fpu_xmm8);
8068   outs() << "\t    fpu_xmm9:\n";
8069   Print_xmm_reg(fpu.fpu_xmm9);
8070   outs() << "\t    fpu_xmm10:\n";
8071   Print_xmm_reg(fpu.fpu_xmm10);
8072   outs() << "\t    fpu_xmm11:\n";
8073   Print_xmm_reg(fpu.fpu_xmm11);
8074   outs() << "\t    fpu_xmm12:\n";
8075   Print_xmm_reg(fpu.fpu_xmm12);
8076   outs() << "\t    fpu_xmm13:\n";
8077   Print_xmm_reg(fpu.fpu_xmm13);
8078   outs() << "\t    fpu_xmm14:\n";
8079   Print_xmm_reg(fpu.fpu_xmm14);
8080   outs() << "\t    fpu_xmm15:\n";
8081   Print_xmm_reg(fpu.fpu_xmm15);
8082   outs() << "\t    fpu_rsrv4:\n";
8083   for (uint32_t f = 0; f < 6; f++) {
8084     outs() << "\t            ";
8085     for (uint32_t g = 0; g < 16; g++)
8086       outs() << format("%02" PRIx32, fpu.fpu_rsrv4[f * g]) << " ";
8087     outs() << "\n";
8088   }
8089   outs() << "\t    fpu_reserved1 " << format("0x%08" PRIx32, fpu.fpu_reserved1);
8090   outs() << "\n";
8091 }
8092
8093 static void Print_x86_exception_state_t(MachO::x86_exception_state64_t &exc64) {
8094   outs() << "\t    trapno " << format("0x%08" PRIx32, exc64.trapno);
8095   outs() << " err " << format("0x%08" PRIx32, exc64.err);
8096   outs() << " faultvaddr " << format("0x%016" PRIx64, exc64.faultvaddr) << "\n";
8097 }
8098
8099 static void PrintThreadCommand(MachO::thread_command t, const char *Ptr,
8100                                bool isLittleEndian, uint32_t cputype) {
8101   if (t.cmd == MachO::LC_THREAD)
8102     outs() << "        cmd LC_THREAD\n";
8103   else if (t.cmd == MachO::LC_UNIXTHREAD)
8104     outs() << "        cmd LC_UNIXTHREAD\n";
8105   else
8106     outs() << "        cmd " << t.cmd << " (unknown)\n";
8107   outs() << "    cmdsize " << t.cmdsize;
8108   if (t.cmdsize < sizeof(struct MachO::thread_command) + 2 * sizeof(uint32_t))
8109     outs() << " Incorrect size\n";
8110   else
8111     outs() << "\n";
8112
8113   const char *begin = Ptr + sizeof(struct MachO::thread_command);
8114   const char *end = Ptr + t.cmdsize;
8115   uint32_t flavor, count, left;
8116   if (cputype == MachO::CPU_TYPE_X86_64) {
8117     while (begin < end) {
8118       if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
8119         memcpy((char *)&flavor, begin, sizeof(uint32_t));
8120         begin += sizeof(uint32_t);
8121       } else {
8122         flavor = 0;
8123         begin = end;
8124       }
8125       if (isLittleEndian != sys::IsLittleEndianHost)
8126         sys::swapByteOrder(flavor);
8127       if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
8128         memcpy((char *)&count, begin, sizeof(uint32_t));
8129         begin += sizeof(uint32_t);
8130       } else {
8131         count = 0;
8132         begin = end;
8133       }
8134       if (isLittleEndian != sys::IsLittleEndianHost)
8135         sys::swapByteOrder(count);
8136       if (flavor == MachO::x86_THREAD_STATE64) {
8137         outs() << "     flavor x86_THREAD_STATE64\n";
8138         if (count == MachO::x86_THREAD_STATE64_COUNT)
8139           outs() << "      count x86_THREAD_STATE64_COUNT\n";
8140         else
8141           outs() << "      count " << count
8142                  << " (not x86_THREAD_STATE64_COUNT)\n";
8143         MachO::x86_thread_state64_t cpu64;
8144         left = end - begin;
8145         if (left >= sizeof(MachO::x86_thread_state64_t)) {
8146           memcpy(&cpu64, begin, sizeof(MachO::x86_thread_state64_t));
8147           begin += sizeof(MachO::x86_thread_state64_t);
8148         } else {
8149           memset(&cpu64, '\0', sizeof(MachO::x86_thread_state64_t));
8150           memcpy(&cpu64, begin, left);
8151           begin += left;
8152         }
8153         if (isLittleEndian != sys::IsLittleEndianHost)
8154           swapStruct(cpu64);
8155         Print_x86_thread_state64_t(cpu64);
8156       } else if (flavor == MachO::x86_THREAD_STATE) {
8157         outs() << "     flavor x86_THREAD_STATE\n";
8158         if (count == MachO::x86_THREAD_STATE_COUNT)
8159           outs() << "      count x86_THREAD_STATE_COUNT\n";
8160         else
8161           outs() << "      count " << count
8162                  << " (not x86_THREAD_STATE_COUNT)\n";
8163         struct MachO::x86_thread_state_t ts;
8164         left = end - begin;
8165         if (left >= sizeof(MachO::x86_thread_state_t)) {
8166           memcpy(&ts, begin, sizeof(MachO::x86_thread_state_t));
8167           begin += sizeof(MachO::x86_thread_state_t);
8168         } else {
8169           memset(&ts, '\0', sizeof(MachO::x86_thread_state_t));
8170           memcpy(&ts, begin, left);
8171           begin += left;
8172         }
8173         if (isLittleEndian != sys::IsLittleEndianHost)
8174           swapStruct(ts);
8175         if (ts.tsh.flavor == MachO::x86_THREAD_STATE64) {
8176           outs() << "\t    tsh.flavor x86_THREAD_STATE64 ";
8177           if (ts.tsh.count == MachO::x86_THREAD_STATE64_COUNT)
8178             outs() << "tsh.count x86_THREAD_STATE64_COUNT\n";
8179           else
8180             outs() << "tsh.count " << ts.tsh.count
8181                    << " (not x86_THREAD_STATE64_COUNT\n";
8182           Print_x86_thread_state64_t(ts.uts.ts64);
8183         } else {
8184           outs() << "\t    tsh.flavor " << ts.tsh.flavor << "  tsh.count "
8185                  << ts.tsh.count << "\n";
8186         }
8187       } else if (flavor == MachO::x86_FLOAT_STATE) {
8188         outs() << "     flavor x86_FLOAT_STATE\n";
8189         if (count == MachO::x86_FLOAT_STATE_COUNT)
8190           outs() << "      count x86_FLOAT_STATE_COUNT\n";
8191         else
8192           outs() << "      count " << count << " (not x86_FLOAT_STATE_COUNT)\n";
8193         struct MachO::x86_float_state_t fs;
8194         left = end - begin;
8195         if (left >= sizeof(MachO::x86_float_state_t)) {
8196           memcpy(&fs, begin, sizeof(MachO::x86_float_state_t));
8197           begin += sizeof(MachO::x86_float_state_t);
8198         } else {
8199           memset(&fs, '\0', sizeof(MachO::x86_float_state_t));
8200           memcpy(&fs, begin, left);
8201           begin += left;
8202         }
8203         if (isLittleEndian != sys::IsLittleEndianHost)
8204           swapStruct(fs);
8205         if (fs.fsh.flavor == MachO::x86_FLOAT_STATE64) {
8206           outs() << "\t    fsh.flavor x86_FLOAT_STATE64 ";
8207           if (fs.fsh.count == MachO::x86_FLOAT_STATE64_COUNT)
8208             outs() << "fsh.count x86_FLOAT_STATE64_COUNT\n";
8209           else
8210             outs() << "fsh.count " << fs.fsh.count
8211                    << " (not x86_FLOAT_STATE64_COUNT\n";
8212           Print_x86_float_state_t(fs.ufs.fs64);
8213         } else {
8214           outs() << "\t    fsh.flavor " << fs.fsh.flavor << "  fsh.count "
8215                  << fs.fsh.count << "\n";
8216         }
8217       } else if (flavor == MachO::x86_EXCEPTION_STATE) {
8218         outs() << "     flavor x86_EXCEPTION_STATE\n";
8219         if (count == MachO::x86_EXCEPTION_STATE_COUNT)
8220           outs() << "      count x86_EXCEPTION_STATE_COUNT\n";
8221         else
8222           outs() << "      count " << count
8223                  << " (not x86_EXCEPTION_STATE_COUNT)\n";
8224         struct MachO::x86_exception_state_t es;
8225         left = end - begin;
8226         if (left >= sizeof(MachO::x86_exception_state_t)) {
8227           memcpy(&es, begin, sizeof(MachO::x86_exception_state_t));
8228           begin += sizeof(MachO::x86_exception_state_t);
8229         } else {
8230           memset(&es, '\0', sizeof(MachO::x86_exception_state_t));
8231           memcpy(&es, begin, left);
8232           begin += left;
8233         }
8234         if (isLittleEndian != sys::IsLittleEndianHost)
8235           swapStruct(es);
8236         if (es.esh.flavor == MachO::x86_EXCEPTION_STATE64) {
8237           outs() << "\t    esh.flavor x86_EXCEPTION_STATE64\n";
8238           if (es.esh.count == MachO::x86_EXCEPTION_STATE64_COUNT)
8239             outs() << "\t    esh.count x86_EXCEPTION_STATE64_COUNT\n";
8240           else
8241             outs() << "\t    esh.count " << es.esh.count
8242                    << " (not x86_EXCEPTION_STATE64_COUNT\n";
8243           Print_x86_exception_state_t(es.ues.es64);
8244         } else {
8245           outs() << "\t    esh.flavor " << es.esh.flavor << "  esh.count "
8246                  << es.esh.count << "\n";
8247         }
8248       } else {
8249         outs() << "     flavor " << flavor << " (unknown)\n";
8250         outs() << "      count " << count << "\n";
8251         outs() << "      state (unknown)\n";
8252         begin += count * sizeof(uint32_t);
8253       }
8254     }
8255   } else {
8256     while (begin < end) {
8257       if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
8258         memcpy((char *)&flavor, begin, sizeof(uint32_t));
8259         begin += sizeof(uint32_t);
8260       } else {
8261         flavor = 0;
8262         begin = end;
8263       }
8264       if (isLittleEndian != sys::IsLittleEndianHost)
8265         sys::swapByteOrder(flavor);
8266       if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
8267         memcpy((char *)&count, begin, sizeof(uint32_t));
8268         begin += sizeof(uint32_t);
8269       } else {
8270         count = 0;
8271         begin = end;
8272       }
8273       if (isLittleEndian != sys::IsLittleEndianHost)
8274         sys::swapByteOrder(count);
8275       outs() << "     flavor " << flavor << "\n";
8276       outs() << "      count " << count << "\n";
8277       outs() << "      state (Unknown cputype/cpusubtype)\n";
8278       begin += count * sizeof(uint32_t);
8279     }
8280   }
8281 }
8282
8283 static void PrintDylibCommand(MachO::dylib_command dl, const char *Ptr) {
8284   if (dl.cmd == MachO::LC_ID_DYLIB)
8285     outs() << "          cmd LC_ID_DYLIB\n";
8286   else if (dl.cmd == MachO::LC_LOAD_DYLIB)
8287     outs() << "          cmd LC_LOAD_DYLIB\n";
8288   else if (dl.cmd == MachO::LC_LOAD_WEAK_DYLIB)
8289     outs() << "          cmd LC_LOAD_WEAK_DYLIB\n";
8290   else if (dl.cmd == MachO::LC_REEXPORT_DYLIB)
8291     outs() << "          cmd LC_REEXPORT_DYLIB\n";
8292   else if (dl.cmd == MachO::LC_LAZY_LOAD_DYLIB)
8293     outs() << "          cmd LC_LAZY_LOAD_DYLIB\n";
8294   else if (dl.cmd == MachO::LC_LOAD_UPWARD_DYLIB)
8295     outs() << "          cmd LC_LOAD_UPWARD_DYLIB\n";
8296   else
8297     outs() << "          cmd " << dl.cmd << " (unknown)\n";
8298   outs() << "      cmdsize " << dl.cmdsize;
8299   if (dl.cmdsize < sizeof(struct MachO::dylib_command))
8300     outs() << " Incorrect size\n";
8301   else
8302     outs() << "\n";
8303   if (dl.dylib.name < dl.cmdsize) {
8304     const char *P = (const char *)(Ptr) + dl.dylib.name;
8305     outs() << "         name " << P << " (offset " << dl.dylib.name << ")\n";
8306   } else {
8307     outs() << "         name ?(bad offset " << dl.dylib.name << ")\n";
8308   }
8309   outs() << "   time stamp " << dl.dylib.timestamp << " ";
8310   time_t t = dl.dylib.timestamp;
8311   outs() << ctime(&t);
8312   outs() << "      current version ";
8313   if (dl.dylib.current_version == 0xffffffff)
8314     outs() << "n/a\n";
8315   else
8316     outs() << ((dl.dylib.current_version >> 16) & 0xffff) << "."
8317            << ((dl.dylib.current_version >> 8) & 0xff) << "."
8318            << (dl.dylib.current_version & 0xff) << "\n";
8319   outs() << "compatibility version ";
8320   if (dl.dylib.compatibility_version == 0xffffffff)
8321     outs() << "n/a\n";
8322   else
8323     outs() << ((dl.dylib.compatibility_version >> 16) & 0xffff) << "."
8324            << ((dl.dylib.compatibility_version >> 8) & 0xff) << "."
8325            << (dl.dylib.compatibility_version & 0xff) << "\n";
8326 }
8327
8328 static void PrintLinkEditDataCommand(MachO::linkedit_data_command ld,
8329                                      uint32_t object_size) {
8330   if (ld.cmd == MachO::LC_CODE_SIGNATURE)
8331     outs() << "      cmd LC_FUNCTION_STARTS\n";
8332   else if (ld.cmd == MachO::LC_SEGMENT_SPLIT_INFO)
8333     outs() << "      cmd LC_SEGMENT_SPLIT_INFO\n";
8334   else if (ld.cmd == MachO::LC_FUNCTION_STARTS)
8335     outs() << "      cmd LC_FUNCTION_STARTS\n";
8336   else if (ld.cmd == MachO::LC_DATA_IN_CODE)
8337     outs() << "      cmd LC_DATA_IN_CODE\n";
8338   else if (ld.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS)
8339     outs() << "      cmd LC_DYLIB_CODE_SIGN_DRS\n";
8340   else if (ld.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT)
8341     outs() << "      cmd LC_LINKER_OPTIMIZATION_HINT\n";
8342   else
8343     outs() << "      cmd " << ld.cmd << " (?)\n";
8344   outs() << "  cmdsize " << ld.cmdsize;
8345   if (ld.cmdsize != sizeof(struct MachO::linkedit_data_command))
8346     outs() << " Incorrect size\n";
8347   else
8348     outs() << "\n";
8349   outs() << "  dataoff " << ld.dataoff;
8350   if (ld.dataoff > object_size)
8351     outs() << " (past end of file)\n";
8352   else
8353     outs() << "\n";
8354   outs() << " datasize " << ld.datasize;
8355   uint64_t big_size = ld.dataoff;
8356   big_size += ld.datasize;
8357   if (big_size > object_size)
8358     outs() << " (past end of file)\n";
8359   else
8360     outs() << "\n";
8361 }
8362
8363 static void PrintLoadCommands(const MachOObjectFile *Obj, uint32_t ncmds,
8364                               uint32_t filetype, uint32_t cputype,
8365                               bool verbose) {
8366   if (ncmds == 0)
8367     return;
8368   StringRef Buf = Obj->getData();
8369   MachOObjectFile::LoadCommandInfo Command = Obj->getFirstLoadCommandInfo();
8370   for (unsigned i = 0;; ++i) {
8371     outs() << "Load command " << i << "\n";
8372     if (Command.C.cmd == MachO::LC_SEGMENT) {
8373       MachO::segment_command SLC = Obj->getSegmentLoadCommand(Command);
8374       const char *sg_segname = SLC.segname;
8375       PrintSegmentCommand(SLC.cmd, SLC.cmdsize, SLC.segname, SLC.vmaddr,
8376                           SLC.vmsize, SLC.fileoff, SLC.filesize, SLC.maxprot,
8377                           SLC.initprot, SLC.nsects, SLC.flags, Buf.size(),
8378                           verbose);
8379       for (unsigned j = 0; j < SLC.nsects; j++) {
8380         MachO::section S = Obj->getSection(Command, j);
8381         PrintSection(S.sectname, S.segname, S.addr, S.size, S.offset, S.align,
8382                      S.reloff, S.nreloc, S.flags, S.reserved1, S.reserved2,
8383                      SLC.cmd, sg_segname, filetype, Buf.size(), verbose);
8384       }
8385     } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
8386       MachO::segment_command_64 SLC_64 = Obj->getSegment64LoadCommand(Command);
8387       const char *sg_segname = SLC_64.segname;
8388       PrintSegmentCommand(SLC_64.cmd, SLC_64.cmdsize, SLC_64.segname,
8389                           SLC_64.vmaddr, SLC_64.vmsize, SLC_64.fileoff,
8390                           SLC_64.filesize, SLC_64.maxprot, SLC_64.initprot,
8391                           SLC_64.nsects, SLC_64.flags, Buf.size(), verbose);
8392       for (unsigned j = 0; j < SLC_64.nsects; j++) {
8393         MachO::section_64 S_64 = Obj->getSection64(Command, j);
8394         PrintSection(S_64.sectname, S_64.segname, S_64.addr, S_64.size,
8395                      S_64.offset, S_64.align, S_64.reloff, S_64.nreloc,
8396                      S_64.flags, S_64.reserved1, S_64.reserved2, SLC_64.cmd,
8397                      sg_segname, filetype, Buf.size(), verbose);
8398       }
8399     } else if (Command.C.cmd == MachO::LC_SYMTAB) {
8400       MachO::symtab_command Symtab = Obj->getSymtabLoadCommand();
8401       PrintSymtabLoadCommand(Symtab, Obj->is64Bit(), Buf.size());
8402     } else if (Command.C.cmd == MachO::LC_DYSYMTAB) {
8403       MachO::dysymtab_command Dysymtab = Obj->getDysymtabLoadCommand();
8404       MachO::symtab_command Symtab = Obj->getSymtabLoadCommand();
8405       PrintDysymtabLoadCommand(Dysymtab, Symtab.nsyms, Buf.size(),
8406                                Obj->is64Bit());
8407     } else if (Command.C.cmd == MachO::LC_DYLD_INFO ||
8408                Command.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
8409       MachO::dyld_info_command DyldInfo = Obj->getDyldInfoLoadCommand(Command);
8410       PrintDyldInfoLoadCommand(DyldInfo, Buf.size());
8411     } else if (Command.C.cmd == MachO::LC_LOAD_DYLINKER ||
8412                Command.C.cmd == MachO::LC_ID_DYLINKER ||
8413                Command.C.cmd == MachO::LC_DYLD_ENVIRONMENT) {
8414       MachO::dylinker_command Dyld = Obj->getDylinkerCommand(Command);
8415       PrintDyldLoadCommand(Dyld, Command.Ptr);
8416     } else if (Command.C.cmd == MachO::LC_UUID) {
8417       MachO::uuid_command Uuid = Obj->getUuidCommand(Command);
8418       PrintUuidLoadCommand(Uuid);
8419     } else if (Command.C.cmd == MachO::LC_RPATH) {
8420       MachO::rpath_command Rpath = Obj->getRpathCommand(Command);
8421       PrintRpathLoadCommand(Rpath, Command.Ptr);
8422     } else if (Command.C.cmd == MachO::LC_VERSION_MIN_MACOSX ||
8423                Command.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS) {
8424       MachO::version_min_command Vd = Obj->getVersionMinLoadCommand(Command);
8425       PrintVersionMinLoadCommand(Vd);
8426     } else if (Command.C.cmd == MachO::LC_SOURCE_VERSION) {
8427       MachO::source_version_command Sd = Obj->getSourceVersionCommand(Command);
8428       PrintSourceVersionCommand(Sd);
8429     } else if (Command.C.cmd == MachO::LC_MAIN) {
8430       MachO::entry_point_command Ep = Obj->getEntryPointCommand(Command);
8431       PrintEntryPointCommand(Ep);
8432     } else if (Command.C.cmd == MachO::LC_ENCRYPTION_INFO) {
8433       MachO::encryption_info_command Ei =
8434           Obj->getEncryptionInfoCommand(Command);
8435       PrintEncryptionInfoCommand(Ei, Buf.size());
8436     } else if (Command.C.cmd == MachO::LC_ENCRYPTION_INFO_64) {
8437       MachO::encryption_info_command_64 Ei =
8438           Obj->getEncryptionInfoCommand64(Command);
8439       PrintEncryptionInfoCommand64(Ei, Buf.size());
8440     } else if (Command.C.cmd == MachO::LC_LINKER_OPTION) {
8441       MachO::linker_option_command Lo =
8442           Obj->getLinkerOptionLoadCommand(Command);
8443       PrintLinkerOptionCommand(Lo, Command.Ptr);
8444     } else if (Command.C.cmd == MachO::LC_SUB_FRAMEWORK) {
8445       MachO::sub_framework_command Sf = Obj->getSubFrameworkCommand(Command);
8446       PrintSubFrameworkCommand(Sf, Command.Ptr);
8447     } else if (Command.C.cmd == MachO::LC_SUB_UMBRELLA) {
8448       MachO::sub_umbrella_command Sf = Obj->getSubUmbrellaCommand(Command);
8449       PrintSubUmbrellaCommand(Sf, Command.Ptr);
8450     } else if (Command.C.cmd == MachO::LC_SUB_LIBRARY) {
8451       MachO::sub_library_command Sl = Obj->getSubLibraryCommand(Command);
8452       PrintSubLibraryCommand(Sl, Command.Ptr);
8453     } else if (Command.C.cmd == MachO::LC_SUB_CLIENT) {
8454       MachO::sub_client_command Sc = Obj->getSubClientCommand(Command);
8455       PrintSubClientCommand(Sc, Command.Ptr);
8456     } else if (Command.C.cmd == MachO::LC_ROUTINES) {
8457       MachO::routines_command Rc = Obj->getRoutinesCommand(Command);
8458       PrintRoutinesCommand(Rc);
8459     } else if (Command.C.cmd == MachO::LC_ROUTINES_64) {
8460       MachO::routines_command_64 Rc = Obj->getRoutinesCommand64(Command);
8461       PrintRoutinesCommand64(Rc);
8462     } else if (Command.C.cmd == MachO::LC_THREAD ||
8463                Command.C.cmd == MachO::LC_UNIXTHREAD) {
8464       MachO::thread_command Tc = Obj->getThreadCommand(Command);
8465       PrintThreadCommand(Tc, Command.Ptr, Obj->isLittleEndian(), cputype);
8466     } else if (Command.C.cmd == MachO::LC_LOAD_DYLIB ||
8467                Command.C.cmd == MachO::LC_ID_DYLIB ||
8468                Command.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
8469                Command.C.cmd == MachO::LC_REEXPORT_DYLIB ||
8470                Command.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
8471                Command.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
8472       MachO::dylib_command Dl = Obj->getDylibIDLoadCommand(Command);
8473       PrintDylibCommand(Dl, Command.Ptr);
8474     } else if (Command.C.cmd == MachO::LC_CODE_SIGNATURE ||
8475                Command.C.cmd == MachO::LC_SEGMENT_SPLIT_INFO ||
8476                Command.C.cmd == MachO::LC_FUNCTION_STARTS ||
8477                Command.C.cmd == MachO::LC_DATA_IN_CODE ||
8478                Command.C.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS ||
8479                Command.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) {
8480       MachO::linkedit_data_command Ld =
8481           Obj->getLinkeditDataLoadCommand(Command);
8482       PrintLinkEditDataCommand(Ld, Buf.size());
8483     } else {
8484       outs() << "      cmd ?(" << format("0x%08" PRIx32, Command.C.cmd)
8485              << ")\n";
8486       outs() << "  cmdsize " << Command.C.cmdsize << "\n";
8487       // TODO: get and print the raw bytes of the load command.
8488     }
8489     // TODO: print all the other kinds of load commands.
8490     if (i == ncmds - 1)
8491       break;
8492     else
8493       Command = Obj->getNextLoadCommandInfo(Command);
8494   }
8495 }
8496
8497 static void getAndPrintMachHeader(const MachOObjectFile *Obj, uint32_t &ncmds,
8498                                   uint32_t &filetype, uint32_t &cputype,
8499                                   bool verbose) {
8500   if (Obj->is64Bit()) {
8501     MachO::mach_header_64 H_64;
8502     H_64 = Obj->getHeader64();
8503     PrintMachHeader(H_64.magic, H_64.cputype, H_64.cpusubtype, H_64.filetype,
8504                     H_64.ncmds, H_64.sizeofcmds, H_64.flags, verbose);
8505     ncmds = H_64.ncmds;
8506     filetype = H_64.filetype;
8507     cputype = H_64.cputype;
8508   } else {
8509     MachO::mach_header H;
8510     H = Obj->getHeader();
8511     PrintMachHeader(H.magic, H.cputype, H.cpusubtype, H.filetype, H.ncmds,
8512                     H.sizeofcmds, H.flags, verbose);
8513     ncmds = H.ncmds;
8514     filetype = H.filetype;
8515     cputype = H.cputype;
8516   }
8517 }
8518
8519 void llvm::printMachOFileHeader(const object::ObjectFile *Obj) {
8520   const MachOObjectFile *file = dyn_cast<const MachOObjectFile>(Obj);
8521   uint32_t ncmds = 0;
8522   uint32_t filetype = 0;
8523   uint32_t cputype = 0;
8524   getAndPrintMachHeader(file, ncmds, filetype, cputype, !NonVerbose);
8525   PrintLoadCommands(file, ncmds, filetype, cputype, !NonVerbose);
8526 }
8527
8528 //===----------------------------------------------------------------------===//
8529 // export trie dumping
8530 //===----------------------------------------------------------------------===//
8531
8532 void llvm::printMachOExportsTrie(const object::MachOObjectFile *Obj) {
8533   for (const llvm::object::ExportEntry &Entry : Obj->exports()) {
8534     uint64_t Flags = Entry.flags();
8535     bool ReExport = (Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT);
8536     bool WeakDef = (Flags & MachO::EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION);
8537     bool ThreadLocal = ((Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK) ==
8538                         MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL);
8539     bool Abs = ((Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK) ==
8540                 MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE);
8541     bool Resolver = (Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER);
8542     if (ReExport)
8543       outs() << "[re-export] ";
8544     else
8545       outs() << format("0x%08llX  ",
8546                        Entry.address()); // FIXME:add in base address
8547     outs() << Entry.name();
8548     if (WeakDef || ThreadLocal || Resolver || Abs) {
8549       bool NeedsComma = false;
8550       outs() << " [";
8551       if (WeakDef) {
8552         outs() << "weak_def";
8553         NeedsComma = true;
8554       }
8555       if (ThreadLocal) {
8556         if (NeedsComma)
8557           outs() << ", ";
8558         outs() << "per-thread";
8559         NeedsComma = true;
8560       }
8561       if (Abs) {
8562         if (NeedsComma)
8563           outs() << ", ";
8564         outs() << "absolute";
8565         NeedsComma = true;
8566       }
8567       if (Resolver) {
8568         if (NeedsComma)
8569           outs() << ", ";
8570         outs() << format("resolver=0x%08llX", Entry.other());
8571         NeedsComma = true;
8572       }
8573       outs() << "]";
8574     }
8575     if (ReExport) {
8576       StringRef DylibName = "unknown";
8577       int Ordinal = Entry.other() - 1;
8578       Obj->getLibraryShortNameByIndex(Ordinal, DylibName);
8579       if (Entry.otherName().empty())
8580         outs() << " (from " << DylibName << ")";
8581       else
8582         outs() << " (" << Entry.otherName() << " from " << DylibName << ")";
8583     }
8584     outs() << "\n";
8585   }
8586 }
8587
8588 //===----------------------------------------------------------------------===//
8589 // rebase table dumping
8590 //===----------------------------------------------------------------------===//
8591
8592 namespace {
8593 class SegInfo {
8594 public:
8595   SegInfo(const object::MachOObjectFile *Obj);
8596
8597   StringRef segmentName(uint32_t SegIndex);
8598   StringRef sectionName(uint32_t SegIndex, uint64_t SegOffset);
8599   uint64_t address(uint32_t SegIndex, uint64_t SegOffset);
8600
8601 private:
8602   struct SectionInfo {
8603     uint64_t Address;
8604     uint64_t Size;
8605     StringRef SectionName;
8606     StringRef SegmentName;
8607     uint64_t OffsetInSegment;
8608     uint64_t SegmentStartAddress;
8609     uint32_t SegmentIndex;
8610   };
8611   const SectionInfo &findSection(uint32_t SegIndex, uint64_t SegOffset);
8612   SmallVector<SectionInfo, 32> Sections;
8613 };
8614 }
8615
8616 SegInfo::SegInfo(const object::MachOObjectFile *Obj) {
8617   // Build table of sections so segIndex/offset pairs can be translated.
8618   uint32_t CurSegIndex = Obj->hasPageZeroSegment() ? 1 : 0;
8619   StringRef CurSegName;
8620   uint64_t CurSegAddress;
8621   for (const SectionRef &Section : Obj->sections()) {
8622     SectionInfo Info;
8623     if (error(Section.getName(Info.SectionName)))
8624       return;
8625     Info.Address = Section.getAddress();
8626     Info.Size = Section.getSize();
8627     Info.SegmentName =
8628         Obj->getSectionFinalSegmentName(Section.getRawDataRefImpl());
8629     if (!Info.SegmentName.equals(CurSegName)) {
8630       ++CurSegIndex;
8631       CurSegName = Info.SegmentName;
8632       CurSegAddress = Info.Address;
8633     }
8634     Info.SegmentIndex = CurSegIndex - 1;
8635     Info.OffsetInSegment = Info.Address - CurSegAddress;
8636     Info.SegmentStartAddress = CurSegAddress;
8637     Sections.push_back(Info);
8638   }
8639 }
8640
8641 StringRef SegInfo::segmentName(uint32_t SegIndex) {
8642   for (const SectionInfo &SI : Sections) {
8643     if (SI.SegmentIndex == SegIndex)
8644       return SI.SegmentName;
8645   }
8646   llvm_unreachable("invalid segIndex");
8647 }
8648
8649 const SegInfo::SectionInfo &SegInfo::findSection(uint32_t SegIndex,
8650                                                  uint64_t OffsetInSeg) {
8651   for (const SectionInfo &SI : Sections) {
8652     if (SI.SegmentIndex != SegIndex)
8653       continue;
8654     if (SI.OffsetInSegment > OffsetInSeg)
8655       continue;
8656     if (OffsetInSeg >= (SI.OffsetInSegment + SI.Size))
8657       continue;
8658     return SI;
8659   }
8660   llvm_unreachable("segIndex and offset not in any section");
8661 }
8662
8663 StringRef SegInfo::sectionName(uint32_t SegIndex, uint64_t OffsetInSeg) {
8664   return findSection(SegIndex, OffsetInSeg).SectionName;
8665 }
8666
8667 uint64_t SegInfo::address(uint32_t SegIndex, uint64_t OffsetInSeg) {
8668   const SectionInfo &SI = findSection(SegIndex, OffsetInSeg);
8669   return SI.SegmentStartAddress + OffsetInSeg;
8670 }
8671
8672 void llvm::printMachORebaseTable(const object::MachOObjectFile *Obj) {
8673   // Build table of sections so names can used in final output.
8674   SegInfo sectionTable(Obj);
8675
8676   outs() << "segment  section            address     type\n";
8677   for (const llvm::object::MachORebaseEntry &Entry : Obj->rebaseTable()) {
8678     uint32_t SegIndex = Entry.segmentIndex();
8679     uint64_t OffsetInSeg = Entry.segmentOffset();
8680     StringRef SegmentName = sectionTable.segmentName(SegIndex);
8681     StringRef SectionName = sectionTable.sectionName(SegIndex, OffsetInSeg);
8682     uint64_t Address = sectionTable.address(SegIndex, OffsetInSeg);
8683
8684     // Table lines look like: __DATA  __nl_symbol_ptr  0x0000F00C  pointer
8685     outs() << format("%-8s %-18s 0x%08" PRIX64 "  %s\n",
8686                      SegmentName.str().c_str(), SectionName.str().c_str(),
8687                      Address, Entry.typeName().str().c_str());
8688   }
8689 }
8690
8691 static StringRef ordinalName(const object::MachOObjectFile *Obj, int Ordinal) {
8692   StringRef DylibName;
8693   switch (Ordinal) {
8694   case MachO::BIND_SPECIAL_DYLIB_SELF:
8695     return "this-image";
8696   case MachO::BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE:
8697     return "main-executable";
8698   case MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP:
8699     return "flat-namespace";
8700   default:
8701     if (Ordinal > 0) {
8702       std::error_code EC =
8703           Obj->getLibraryShortNameByIndex(Ordinal - 1, DylibName);
8704       if (EC)
8705         return "<<bad library ordinal>>";
8706       return DylibName;
8707     }
8708   }
8709   return "<<unknown special ordinal>>";
8710 }
8711
8712 //===----------------------------------------------------------------------===//
8713 // bind table dumping
8714 //===----------------------------------------------------------------------===//
8715
8716 void llvm::printMachOBindTable(const object::MachOObjectFile *Obj) {
8717   // Build table of sections so names can used in final output.
8718   SegInfo sectionTable(Obj);
8719
8720   outs() << "segment  section            address    type       "
8721             "addend dylib            symbol\n";
8722   for (const llvm::object::MachOBindEntry &Entry : Obj->bindTable()) {
8723     uint32_t SegIndex = Entry.segmentIndex();
8724     uint64_t OffsetInSeg = Entry.segmentOffset();
8725     StringRef SegmentName = sectionTable.segmentName(SegIndex);
8726     StringRef SectionName = sectionTable.sectionName(SegIndex, OffsetInSeg);
8727     uint64_t Address = sectionTable.address(SegIndex, OffsetInSeg);
8728
8729     // Table lines look like:
8730     //  __DATA  __got  0x00012010    pointer   0 libSystem ___stack_chk_guard
8731     StringRef Attr;
8732     if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT)
8733       Attr = " (weak_import)";
8734     outs() << left_justify(SegmentName, 8) << " "
8735            << left_justify(SectionName, 18) << " "
8736            << format_hex(Address, 10, true) << " "
8737            << left_justify(Entry.typeName(), 8) << " "
8738            << format_decimal(Entry.addend(), 8) << " "
8739            << left_justify(ordinalName(Obj, Entry.ordinal()), 16) << " "
8740            << Entry.symbolName() << Attr << "\n";
8741   }
8742 }
8743
8744 //===----------------------------------------------------------------------===//
8745 // lazy bind table dumping
8746 //===----------------------------------------------------------------------===//
8747
8748 void llvm::printMachOLazyBindTable(const object::MachOObjectFile *Obj) {
8749   // Build table of sections so names can used in final output.
8750   SegInfo sectionTable(Obj);
8751
8752   outs() << "segment  section            address     "
8753             "dylib            symbol\n";
8754   for (const llvm::object::MachOBindEntry &Entry : Obj->lazyBindTable()) {
8755     uint32_t SegIndex = Entry.segmentIndex();
8756     uint64_t OffsetInSeg = Entry.segmentOffset();
8757     StringRef SegmentName = sectionTable.segmentName(SegIndex);
8758     StringRef SectionName = sectionTable.sectionName(SegIndex, OffsetInSeg);
8759     uint64_t Address = sectionTable.address(SegIndex, OffsetInSeg);
8760
8761     // Table lines look like:
8762     //  __DATA  __got  0x00012010 libSystem ___stack_chk_guard
8763     outs() << left_justify(SegmentName, 8) << " "
8764            << left_justify(SectionName, 18) << " "
8765            << format_hex(Address, 10, true) << " "
8766            << left_justify(ordinalName(Obj, Entry.ordinal()), 16) << " "
8767            << Entry.symbolName() << "\n";
8768   }
8769 }
8770
8771 //===----------------------------------------------------------------------===//
8772 // weak bind table dumping
8773 //===----------------------------------------------------------------------===//
8774
8775 void llvm::printMachOWeakBindTable(const object::MachOObjectFile *Obj) {
8776   // Build table of sections so names can used in final output.
8777   SegInfo sectionTable(Obj);
8778
8779   outs() << "segment  section            address     "
8780             "type       addend   symbol\n";
8781   for (const llvm::object::MachOBindEntry &Entry : Obj->weakBindTable()) {
8782     // Strong symbols don't have a location to update.
8783     if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION) {
8784       outs() << "                                        strong              "
8785              << Entry.symbolName() << "\n";
8786       continue;
8787     }
8788     uint32_t SegIndex = Entry.segmentIndex();
8789     uint64_t OffsetInSeg = Entry.segmentOffset();
8790     StringRef SegmentName = sectionTable.segmentName(SegIndex);
8791     StringRef SectionName = sectionTable.sectionName(SegIndex, OffsetInSeg);
8792     uint64_t Address = sectionTable.address(SegIndex, OffsetInSeg);
8793
8794     // Table lines look like:
8795     // __DATA  __data  0x00001000  pointer    0   _foo
8796     outs() << left_justify(SegmentName, 8) << " "
8797            << left_justify(SectionName, 18) << " "
8798            << format_hex(Address, 10, true) << " "
8799            << left_justify(Entry.typeName(), 8) << " "
8800            << format_decimal(Entry.addend(), 8) << "   " << Entry.symbolName()
8801            << "\n";
8802   }
8803 }
8804
8805 // get_dyld_bind_info_symbolname() is used for disassembly and passed an
8806 // address, ReferenceValue, in the Mach-O file and looks in the dyld bind
8807 // information for that address. If the address is found its binding symbol
8808 // name is returned.  If not nullptr is returned.
8809 static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue,
8810                                                  struct DisassembleInfo *info) {
8811   if (info->bindtable == nullptr) {
8812     info->bindtable = new (BindTable);
8813     SegInfo sectionTable(info->O);
8814     for (const llvm::object::MachOBindEntry &Entry : info->O->bindTable()) {
8815       uint32_t SegIndex = Entry.segmentIndex();
8816       uint64_t OffsetInSeg = Entry.segmentOffset();
8817       uint64_t Address = sectionTable.address(SegIndex, OffsetInSeg);
8818       const char *SymbolName = nullptr;
8819       StringRef name = Entry.symbolName();
8820       if (!name.empty())
8821         SymbolName = name.data();
8822       info->bindtable->push_back(std::make_pair(Address, SymbolName));
8823     }
8824   }
8825   for (bind_table_iterator BI = info->bindtable->begin(),
8826                            BE = info->bindtable->end();
8827        BI != BE; ++BI) {
8828     uint64_t Address = BI->first;
8829     if (ReferenceValue == Address) {
8830       const char *SymbolName = BI->second;
8831       return SymbolName;
8832     }
8833   }
8834   return nullptr;
8835 }