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