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