1 //===- MachOObjectFile.cpp - Mach-O object file binding -------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines the MachOObjectFile class, which binds the MachOObject 10 // class to the generic ObjectFile wrapper. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/ADT/ArrayRef.h" 15 #include "llvm/ADT/None.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/ADT/SmallVector.h" 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/ADT/StringSwitch.h" 20 #include "llvm/ADT/Triple.h" 21 #include "llvm/ADT/Twine.h" 22 #include "llvm/BinaryFormat/MachO.h" 23 #include "llvm/Object/Error.h" 24 #include "llvm/Object/MachO.h" 25 #include "llvm/Object/ObjectFile.h" 26 #include "llvm/Object/SymbolicFile.h" 27 #include "llvm/Support/DataExtractor.h" 28 #include "llvm/Support/Debug.h" 29 #include "llvm/Support/Error.h" 30 #include "llvm/Support/ErrorHandling.h" 31 #include "llvm/Support/Format.h" 32 #include "llvm/Support/Host.h" 33 #include "llvm/Support/LEB128.h" 34 #include "llvm/Support/MemoryBuffer.h" 35 #include "llvm/Support/SwapByteOrder.h" 36 #include "llvm/Support/raw_ostream.h" 37 #include <algorithm> 38 #include <cassert> 39 #include <cstddef> 40 #include <cstdint> 41 #include <cstring> 42 #include <limits> 43 #include <list> 44 #include <memory> 45 #include <string> 46 #include <system_error> 47 48 using namespace llvm; 49 using namespace object; 50 51 namespace { 52 53 struct section_base { 54 char sectname[16]; 55 char segname[16]; 56 }; 57 58 } // end anonymous namespace 59 60 static Error malformedError(const Twine &Msg) { 61 return make_error<GenericBinaryError>("truncated or malformed object (" + 62 Msg + ")", 63 object_error::parse_failed); 64 } 65 66 // FIXME: Replace all uses of this function with getStructOrErr. 67 template <typename T> 68 static T getStruct(const MachOObjectFile &O, const char *P) { 69 // Don't read before the beginning or past the end of the file 70 if (P < O.getData().begin() || P + sizeof(T) > O.getData().end()) 71 report_fatal_error("Malformed MachO file."); 72 73 T Cmd; 74 memcpy(&Cmd, P, sizeof(T)); 75 if (O.isLittleEndian() != sys::IsLittleEndianHost) 76 MachO::swapStruct(Cmd); 77 return Cmd; 78 } 79 80 template <typename T> 81 static Expected<T> getStructOrErr(const MachOObjectFile &O, const char *P) { 82 // Don't read before the beginning or past the end of the file 83 if (P < O.getData().begin() || P + sizeof(T) > O.getData().end()) 84 return malformedError("Structure read out-of-range"); 85 86 T Cmd; 87 memcpy(&Cmd, P, sizeof(T)); 88 if (O.isLittleEndian() != sys::IsLittleEndianHost) 89 MachO::swapStruct(Cmd); 90 return Cmd; 91 } 92 93 static const char * 94 getSectionPtr(const MachOObjectFile &O, MachOObjectFile::LoadCommandInfo L, 95 unsigned Sec) { 96 uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr); 97 98 bool Is64 = O.is64Bit(); 99 unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) : 100 sizeof(MachO::segment_command); 101 unsigned SectionSize = Is64 ? sizeof(MachO::section_64) : 102 sizeof(MachO::section); 103 104 uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize; 105 return reinterpret_cast<const char*>(SectionAddr); 106 } 107 108 static const char *getPtr(const MachOObjectFile &O, size_t Offset) { 109 assert(Offset <= O.getData().size()); 110 return O.getData().data() + Offset; 111 } 112 113 static MachO::nlist_base 114 getSymbolTableEntryBase(const MachOObjectFile &O, DataRefImpl DRI) { 115 const char *P = reinterpret_cast<const char *>(DRI.p); 116 return getStruct<MachO::nlist_base>(O, P); 117 } 118 119 static StringRef parseSegmentOrSectionName(const char *P) { 120 if (P[15] == 0) 121 // Null terminated. 122 return P; 123 // Not null terminated, so this is a 16 char string. 124 return StringRef(P, 16); 125 } 126 127 static unsigned getCPUType(const MachOObjectFile &O) { 128 return O.getHeader().cputype; 129 } 130 131 static uint32_t 132 getPlainRelocationAddress(const MachO::any_relocation_info &RE) { 133 return RE.r_word0; 134 } 135 136 static unsigned 137 getScatteredRelocationAddress(const MachO::any_relocation_info &RE) { 138 return RE.r_word0 & 0xffffff; 139 } 140 141 static bool getPlainRelocationPCRel(const MachOObjectFile &O, 142 const MachO::any_relocation_info &RE) { 143 if (O.isLittleEndian()) 144 return (RE.r_word1 >> 24) & 1; 145 return (RE.r_word1 >> 7) & 1; 146 } 147 148 static bool 149 getScatteredRelocationPCRel(const MachO::any_relocation_info &RE) { 150 return (RE.r_word0 >> 30) & 1; 151 } 152 153 static unsigned getPlainRelocationLength(const MachOObjectFile &O, 154 const MachO::any_relocation_info &RE) { 155 if (O.isLittleEndian()) 156 return (RE.r_word1 >> 25) & 3; 157 return (RE.r_word1 >> 5) & 3; 158 } 159 160 static unsigned 161 getScatteredRelocationLength(const MachO::any_relocation_info &RE) { 162 return (RE.r_word0 >> 28) & 3; 163 } 164 165 static unsigned getPlainRelocationType(const MachOObjectFile &O, 166 const MachO::any_relocation_info &RE) { 167 if (O.isLittleEndian()) 168 return RE.r_word1 >> 28; 169 return RE.r_word1 & 0xf; 170 } 171 172 static uint32_t getSectionFlags(const MachOObjectFile &O, 173 DataRefImpl Sec) { 174 if (O.is64Bit()) { 175 MachO::section_64 Sect = O.getSection64(Sec); 176 return Sect.flags; 177 } 178 MachO::section Sect = O.getSection(Sec); 179 return Sect.flags; 180 } 181 182 static Expected<MachOObjectFile::LoadCommandInfo> 183 getLoadCommandInfo(const MachOObjectFile &Obj, const char *Ptr, 184 uint32_t LoadCommandIndex) { 185 if (auto CmdOrErr = getStructOrErr<MachO::load_command>(Obj, Ptr)) { 186 if (CmdOrErr->cmdsize + Ptr > Obj.getData().end()) 187 return malformedError("load command " + Twine(LoadCommandIndex) + 188 " extends past end of file"); 189 if (CmdOrErr->cmdsize < 8) 190 return malformedError("load command " + Twine(LoadCommandIndex) + 191 " with size less than 8 bytes"); 192 return MachOObjectFile::LoadCommandInfo({Ptr, *CmdOrErr}); 193 } else 194 return CmdOrErr.takeError(); 195 } 196 197 static Expected<MachOObjectFile::LoadCommandInfo> 198 getFirstLoadCommandInfo(const MachOObjectFile &Obj) { 199 unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64) 200 : sizeof(MachO::mach_header); 201 if (sizeof(MachO::load_command) > Obj.getHeader().sizeofcmds) 202 return malformedError("load command 0 extends past the end all load " 203 "commands in the file"); 204 return getLoadCommandInfo(Obj, getPtr(Obj, HeaderSize), 0); 205 } 206 207 static Expected<MachOObjectFile::LoadCommandInfo> 208 getNextLoadCommandInfo(const MachOObjectFile &Obj, uint32_t LoadCommandIndex, 209 const MachOObjectFile::LoadCommandInfo &L) { 210 unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64) 211 : sizeof(MachO::mach_header); 212 if (L.Ptr + L.C.cmdsize + sizeof(MachO::load_command) > 213 Obj.getData().data() + HeaderSize + Obj.getHeader().sizeofcmds) 214 return malformedError("load command " + Twine(LoadCommandIndex + 1) + 215 " extends past the end all load commands in the file"); 216 return getLoadCommandInfo(Obj, L.Ptr + L.C.cmdsize, LoadCommandIndex + 1); 217 } 218 219 template <typename T> 220 static void parseHeader(const MachOObjectFile &Obj, T &Header, 221 Error &Err) { 222 if (sizeof(T) > Obj.getData().size()) { 223 Err = malformedError("the mach header extends past the end of the " 224 "file"); 225 return; 226 } 227 if (auto HeaderOrErr = getStructOrErr<T>(Obj, getPtr(Obj, 0))) 228 Header = *HeaderOrErr; 229 else 230 Err = HeaderOrErr.takeError(); 231 } 232 233 // This is used to check for overlapping of Mach-O elements. 234 struct MachOElement { 235 uint64_t Offset; 236 uint64_t Size; 237 const char *Name; 238 }; 239 240 static Error checkOverlappingElement(std::list<MachOElement> &Elements, 241 uint64_t Offset, uint64_t Size, 242 const char *Name) { 243 if (Size == 0) 244 return Error::success(); 245 246 for (auto it=Elements.begin() ; it != Elements.end(); ++it) { 247 auto E = *it; 248 if ((Offset >= E.Offset && Offset < E.Offset + E.Size) || 249 (Offset + Size > E.Offset && Offset + Size < E.Offset + E.Size) || 250 (Offset <= E.Offset && Offset + Size >= E.Offset + E.Size)) 251 return malformedError(Twine(Name) + " at offset " + Twine(Offset) + 252 " with a size of " + Twine(Size) + ", overlaps " + 253 E.Name + " at offset " + Twine(E.Offset) + " with " 254 "a size of " + Twine(E.Size)); 255 auto nt = it; 256 nt++; 257 if (nt != Elements.end()) { 258 auto N = *nt; 259 if (Offset + Size <= N.Offset) { 260 Elements.insert(nt, {Offset, Size, Name}); 261 return Error::success(); 262 } 263 } 264 } 265 Elements.push_back({Offset, Size, Name}); 266 return Error::success(); 267 } 268 269 // Parses LC_SEGMENT or LC_SEGMENT_64 load command, adds addresses of all 270 // sections to \param Sections, and optionally sets 271 // \param IsPageZeroSegment to true. 272 template <typename Segment, typename Section> 273 static Error parseSegmentLoadCommand( 274 const MachOObjectFile &Obj, const MachOObjectFile::LoadCommandInfo &Load, 275 SmallVectorImpl<const char *> &Sections, bool &IsPageZeroSegment, 276 uint32_t LoadCommandIndex, const char *CmdName, uint64_t SizeOfHeaders, 277 std::list<MachOElement> &Elements) { 278 const unsigned SegmentLoadSize = sizeof(Segment); 279 if (Load.C.cmdsize < SegmentLoadSize) 280 return malformedError("load command " + Twine(LoadCommandIndex) + 281 " " + CmdName + " cmdsize too small"); 282 if (auto SegOrErr = getStructOrErr<Segment>(Obj, Load.Ptr)) { 283 Segment S = SegOrErr.get(); 284 const unsigned SectionSize = sizeof(Section); 285 uint64_t FileSize = Obj.getData().size(); 286 if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize || 287 S.nsects * SectionSize > Load.C.cmdsize - SegmentLoadSize) 288 return malformedError("load command " + Twine(LoadCommandIndex) + 289 " inconsistent cmdsize in " + CmdName + 290 " for the number of sections"); 291 for (unsigned J = 0; J < S.nsects; ++J) { 292 const char *Sec = getSectionPtr(Obj, Load, J); 293 Sections.push_back(Sec); 294 auto SectionOrErr = getStructOrErr<Section>(Obj, Sec); 295 if (!SectionOrErr) 296 return SectionOrErr.takeError(); 297 Section s = SectionOrErr.get(); 298 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB && 299 Obj.getHeader().filetype != MachO::MH_DSYM && 300 s.flags != MachO::S_ZEROFILL && 301 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL && 302 s.offset > FileSize) 303 return malformedError("offset field of section " + Twine(J) + " in " + 304 CmdName + " command " + Twine(LoadCommandIndex) + 305 " extends past the end of the file"); 306 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB && 307 Obj.getHeader().filetype != MachO::MH_DSYM && 308 s.flags != MachO::S_ZEROFILL && 309 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL && S.fileoff == 0 && 310 s.offset < SizeOfHeaders && s.size != 0) 311 return malformedError("offset field of section " + Twine(J) + " in " + 312 CmdName + " command " + Twine(LoadCommandIndex) + 313 " not past the headers of the file"); 314 uint64_t BigSize = s.offset; 315 BigSize += s.size; 316 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB && 317 Obj.getHeader().filetype != MachO::MH_DSYM && 318 s.flags != MachO::S_ZEROFILL && 319 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL && 320 BigSize > FileSize) 321 return malformedError("offset field plus size field of section " + 322 Twine(J) + " in " + CmdName + " command " + 323 Twine(LoadCommandIndex) + 324 " extends past the end of the file"); 325 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB && 326 Obj.getHeader().filetype != MachO::MH_DSYM && 327 s.flags != MachO::S_ZEROFILL && 328 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL && 329 s.size > S.filesize) 330 return malformedError("size field of section " + 331 Twine(J) + " in " + CmdName + " command " + 332 Twine(LoadCommandIndex) + 333 " greater than the segment"); 334 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB && 335 Obj.getHeader().filetype != MachO::MH_DSYM && s.size != 0 && 336 s.addr < S.vmaddr) 337 return malformedError("addr field of section " + Twine(J) + " in " + 338 CmdName + " command " + Twine(LoadCommandIndex) + 339 " less than the segment's vmaddr"); 340 BigSize = s.addr; 341 BigSize += s.size; 342 uint64_t BigEnd = S.vmaddr; 343 BigEnd += S.vmsize; 344 if (S.vmsize != 0 && s.size != 0 && BigSize > BigEnd) 345 return malformedError("addr field plus size of section " + Twine(J) + 346 " in " + CmdName + " command " + 347 Twine(LoadCommandIndex) + 348 " greater than than " 349 "the segment's vmaddr plus vmsize"); 350 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB && 351 Obj.getHeader().filetype != MachO::MH_DSYM && 352 s.flags != MachO::S_ZEROFILL && 353 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL) 354 if (Error Err = checkOverlappingElement(Elements, s.offset, s.size, 355 "section contents")) 356 return Err; 357 if (s.reloff > FileSize) 358 return malformedError("reloff field of section " + Twine(J) + " in " + 359 CmdName + " command " + Twine(LoadCommandIndex) + 360 " extends past the end of the file"); 361 BigSize = s.nreloc; 362 BigSize *= sizeof(struct MachO::relocation_info); 363 BigSize += s.reloff; 364 if (BigSize > FileSize) 365 return malformedError("reloff field plus nreloc field times sizeof(" 366 "struct relocation_info) of section " + 367 Twine(J) + " in " + CmdName + " command " + 368 Twine(LoadCommandIndex) + 369 " extends past the end of the file"); 370 if (Error Err = checkOverlappingElement(Elements, s.reloff, s.nreloc * 371 sizeof(struct 372 MachO::relocation_info), 373 "section relocation entries")) 374 return Err; 375 } 376 if (S.fileoff > FileSize) 377 return malformedError("load command " + Twine(LoadCommandIndex) + 378 " fileoff field in " + CmdName + 379 " extends past the end of the file"); 380 uint64_t BigSize = S.fileoff; 381 BigSize += S.filesize; 382 if (BigSize > FileSize) 383 return malformedError("load command " + Twine(LoadCommandIndex) + 384 " fileoff field plus filesize field in " + 385 CmdName + " extends past the end of the file"); 386 if (S.vmsize != 0 && S.filesize > S.vmsize) 387 return malformedError("load command " + Twine(LoadCommandIndex) + 388 " filesize field in " + CmdName + 389 " greater than vmsize field"); 390 IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname); 391 } else 392 return SegOrErr.takeError(); 393 394 return Error::success(); 395 } 396 397 static Error checkSymtabCommand(const MachOObjectFile &Obj, 398 const MachOObjectFile::LoadCommandInfo &Load, 399 uint32_t LoadCommandIndex, 400 const char **SymtabLoadCmd, 401 std::list<MachOElement> &Elements) { 402 if (Load.C.cmdsize < sizeof(MachO::symtab_command)) 403 return malformedError("load command " + Twine(LoadCommandIndex) + 404 " LC_SYMTAB cmdsize too small"); 405 if (*SymtabLoadCmd != nullptr) 406 return malformedError("more than one LC_SYMTAB command"); 407 auto SymtabOrErr = getStructOrErr<MachO::symtab_command>(Obj, Load.Ptr); 408 if (!SymtabOrErr) 409 return SymtabOrErr.takeError(); 410 MachO::symtab_command Symtab = SymtabOrErr.get(); 411 if (Symtab.cmdsize != sizeof(MachO::symtab_command)) 412 return malformedError("LC_SYMTAB command " + Twine(LoadCommandIndex) + 413 " has incorrect cmdsize"); 414 uint64_t FileSize = Obj.getData().size(); 415 if (Symtab.symoff > FileSize) 416 return malformedError("symoff field of LC_SYMTAB command " + 417 Twine(LoadCommandIndex) + " extends past the end " 418 "of the file"); 419 uint64_t SymtabSize = Symtab.nsyms; 420 const char *struct_nlist_name; 421 if (Obj.is64Bit()) { 422 SymtabSize *= sizeof(MachO::nlist_64); 423 struct_nlist_name = "struct nlist_64"; 424 } else { 425 SymtabSize *= sizeof(MachO::nlist); 426 struct_nlist_name = "struct nlist"; 427 } 428 uint64_t BigSize = SymtabSize; 429 BigSize += Symtab.symoff; 430 if (BigSize > FileSize) 431 return malformedError("symoff field plus nsyms field times sizeof(" + 432 Twine(struct_nlist_name) + ") of LC_SYMTAB command " + 433 Twine(LoadCommandIndex) + " extends past the end " 434 "of the file"); 435 if (Error Err = checkOverlappingElement(Elements, Symtab.symoff, SymtabSize, 436 "symbol table")) 437 return Err; 438 if (Symtab.stroff > FileSize) 439 return malformedError("stroff field of LC_SYMTAB command " + 440 Twine(LoadCommandIndex) + " extends past the end " 441 "of the file"); 442 BigSize = Symtab.stroff; 443 BigSize += Symtab.strsize; 444 if (BigSize > FileSize) 445 return malformedError("stroff field plus strsize field of LC_SYMTAB " 446 "command " + Twine(LoadCommandIndex) + " extends " 447 "past the end of the file"); 448 if (Error Err = checkOverlappingElement(Elements, Symtab.stroff, 449 Symtab.strsize, "string table")) 450 return Err; 451 *SymtabLoadCmd = Load.Ptr; 452 return Error::success(); 453 } 454 455 static Error checkDysymtabCommand(const MachOObjectFile &Obj, 456 const MachOObjectFile::LoadCommandInfo &Load, 457 uint32_t LoadCommandIndex, 458 const char **DysymtabLoadCmd, 459 std::list<MachOElement> &Elements) { 460 if (Load.C.cmdsize < sizeof(MachO::dysymtab_command)) 461 return malformedError("load command " + Twine(LoadCommandIndex) + 462 " LC_DYSYMTAB cmdsize too small"); 463 if (*DysymtabLoadCmd != nullptr) 464 return malformedError("more than one LC_DYSYMTAB command"); 465 auto DysymtabOrErr = 466 getStructOrErr<MachO::dysymtab_command>(Obj, Load.Ptr); 467 if (!DysymtabOrErr) 468 return DysymtabOrErr.takeError(); 469 MachO::dysymtab_command Dysymtab = DysymtabOrErr.get(); 470 if (Dysymtab.cmdsize != sizeof(MachO::dysymtab_command)) 471 return malformedError("LC_DYSYMTAB command " + Twine(LoadCommandIndex) + 472 " has incorrect cmdsize"); 473 uint64_t FileSize = Obj.getData().size(); 474 if (Dysymtab.tocoff > FileSize) 475 return malformedError("tocoff field of LC_DYSYMTAB command " + 476 Twine(LoadCommandIndex) + " extends past the end of " 477 "the file"); 478 uint64_t BigSize = Dysymtab.ntoc; 479 BigSize *= sizeof(MachO::dylib_table_of_contents); 480 BigSize += Dysymtab.tocoff; 481 if (BigSize > FileSize) 482 return malformedError("tocoff field plus ntoc field times sizeof(struct " 483 "dylib_table_of_contents) of LC_DYSYMTAB command " + 484 Twine(LoadCommandIndex) + " extends past the end of " 485 "the file"); 486 if (Error Err = checkOverlappingElement(Elements, Dysymtab.tocoff, 487 Dysymtab.ntoc * sizeof(struct 488 MachO::dylib_table_of_contents), 489 "table of contents")) 490 return Err; 491 if (Dysymtab.modtaboff > FileSize) 492 return malformedError("modtaboff field of LC_DYSYMTAB command " + 493 Twine(LoadCommandIndex) + " extends past the end of " 494 "the file"); 495 BigSize = Dysymtab.nmodtab; 496 const char *struct_dylib_module_name; 497 uint64_t sizeof_modtab; 498 if (Obj.is64Bit()) { 499 sizeof_modtab = sizeof(MachO::dylib_module_64); 500 struct_dylib_module_name = "struct dylib_module_64"; 501 } else { 502 sizeof_modtab = sizeof(MachO::dylib_module); 503 struct_dylib_module_name = "struct dylib_module"; 504 } 505 BigSize *= sizeof_modtab; 506 BigSize += Dysymtab.modtaboff; 507 if (BigSize > FileSize) 508 return malformedError("modtaboff field plus nmodtab field times sizeof(" + 509 Twine(struct_dylib_module_name) + ") of LC_DYSYMTAB " 510 "command " + Twine(LoadCommandIndex) + " extends " 511 "past the end of the file"); 512 if (Error Err = checkOverlappingElement(Elements, Dysymtab.modtaboff, 513 Dysymtab.nmodtab * sizeof_modtab, 514 "module table")) 515 return Err; 516 if (Dysymtab.extrefsymoff > FileSize) 517 return malformedError("extrefsymoff field of LC_DYSYMTAB command " + 518 Twine(LoadCommandIndex) + " extends past the end of " 519 "the file"); 520 BigSize = Dysymtab.nextrefsyms; 521 BigSize *= sizeof(MachO::dylib_reference); 522 BigSize += Dysymtab.extrefsymoff; 523 if (BigSize > FileSize) 524 return malformedError("extrefsymoff field plus nextrefsyms field times " 525 "sizeof(struct dylib_reference) of LC_DYSYMTAB " 526 "command " + Twine(LoadCommandIndex) + " extends " 527 "past the end of the file"); 528 if (Error Err = checkOverlappingElement(Elements, Dysymtab.extrefsymoff, 529 Dysymtab.nextrefsyms * 530 sizeof(MachO::dylib_reference), 531 "reference table")) 532 return Err; 533 if (Dysymtab.indirectsymoff > FileSize) 534 return malformedError("indirectsymoff field of LC_DYSYMTAB command " + 535 Twine(LoadCommandIndex) + " extends past the end of " 536 "the file"); 537 BigSize = Dysymtab.nindirectsyms; 538 BigSize *= sizeof(uint32_t); 539 BigSize += Dysymtab.indirectsymoff; 540 if (BigSize > FileSize) 541 return malformedError("indirectsymoff field plus nindirectsyms field times " 542 "sizeof(uint32_t) of LC_DYSYMTAB command " + 543 Twine(LoadCommandIndex) + " extends past the end of " 544 "the file"); 545 if (Error Err = checkOverlappingElement(Elements, Dysymtab.indirectsymoff, 546 Dysymtab.nindirectsyms * 547 sizeof(uint32_t), 548 "indirect table")) 549 return Err; 550 if (Dysymtab.extreloff > FileSize) 551 return malformedError("extreloff field of LC_DYSYMTAB command " + 552 Twine(LoadCommandIndex) + " extends past the end of " 553 "the file"); 554 BigSize = Dysymtab.nextrel; 555 BigSize *= sizeof(MachO::relocation_info); 556 BigSize += Dysymtab.extreloff; 557 if (BigSize > FileSize) 558 return malformedError("extreloff field plus nextrel field times sizeof" 559 "(struct relocation_info) of LC_DYSYMTAB command " + 560 Twine(LoadCommandIndex) + " extends past the end of " 561 "the file"); 562 if (Error Err = checkOverlappingElement(Elements, Dysymtab.extreloff, 563 Dysymtab.nextrel * 564 sizeof(MachO::relocation_info), 565 "external relocation table")) 566 return Err; 567 if (Dysymtab.locreloff > FileSize) 568 return malformedError("locreloff field of LC_DYSYMTAB command " + 569 Twine(LoadCommandIndex) + " extends past the end of " 570 "the file"); 571 BigSize = Dysymtab.nlocrel; 572 BigSize *= sizeof(MachO::relocation_info); 573 BigSize += Dysymtab.locreloff; 574 if (BigSize > FileSize) 575 return malformedError("locreloff field plus nlocrel field times sizeof" 576 "(struct relocation_info) of LC_DYSYMTAB command " + 577 Twine(LoadCommandIndex) + " extends past the end of " 578 "the file"); 579 if (Error Err = checkOverlappingElement(Elements, Dysymtab.locreloff, 580 Dysymtab.nlocrel * 581 sizeof(MachO::relocation_info), 582 "local relocation table")) 583 return Err; 584 *DysymtabLoadCmd = Load.Ptr; 585 return Error::success(); 586 } 587 588 static Error checkLinkeditDataCommand(const MachOObjectFile &Obj, 589 const MachOObjectFile::LoadCommandInfo &Load, 590 uint32_t LoadCommandIndex, 591 const char **LoadCmd, const char *CmdName, 592 std::list<MachOElement> &Elements, 593 const char *ElementName) { 594 if (Load.C.cmdsize < sizeof(MachO::linkedit_data_command)) 595 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 596 CmdName + " cmdsize too small"); 597 if (*LoadCmd != nullptr) 598 return malformedError("more than one " + Twine(CmdName) + " command"); 599 auto LinkDataOrError = 600 getStructOrErr<MachO::linkedit_data_command>(Obj, Load.Ptr); 601 if (!LinkDataOrError) 602 return LinkDataOrError.takeError(); 603 MachO::linkedit_data_command LinkData = LinkDataOrError.get(); 604 if (LinkData.cmdsize != sizeof(MachO::linkedit_data_command)) 605 return malformedError(Twine(CmdName) + " command " + 606 Twine(LoadCommandIndex) + " has incorrect cmdsize"); 607 uint64_t FileSize = Obj.getData().size(); 608 if (LinkData.dataoff > FileSize) 609 return malformedError("dataoff field of " + Twine(CmdName) + " command " + 610 Twine(LoadCommandIndex) + " extends past the end of " 611 "the file"); 612 uint64_t BigSize = LinkData.dataoff; 613 BigSize += LinkData.datasize; 614 if (BigSize > FileSize) 615 return malformedError("dataoff field plus datasize field of " + 616 Twine(CmdName) + " command " + 617 Twine(LoadCommandIndex) + " extends past the end of " 618 "the file"); 619 if (Error Err = checkOverlappingElement(Elements, LinkData.dataoff, 620 LinkData.datasize, ElementName)) 621 return Err; 622 *LoadCmd = Load.Ptr; 623 return Error::success(); 624 } 625 626 static Error checkDyldInfoCommand(const MachOObjectFile &Obj, 627 const MachOObjectFile::LoadCommandInfo &Load, 628 uint32_t LoadCommandIndex, 629 const char **LoadCmd, const char *CmdName, 630 std::list<MachOElement> &Elements) { 631 if (Load.C.cmdsize < sizeof(MachO::dyld_info_command)) 632 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 633 CmdName + " cmdsize too small"); 634 if (*LoadCmd != nullptr) 635 return malformedError("more than one LC_DYLD_INFO and or LC_DYLD_INFO_ONLY " 636 "command"); 637 auto DyldInfoOrErr = 638 getStructOrErr<MachO::dyld_info_command>(Obj, Load.Ptr); 639 if (!DyldInfoOrErr) 640 return DyldInfoOrErr.takeError(); 641 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); 642 if (DyldInfo.cmdsize != sizeof(MachO::dyld_info_command)) 643 return malformedError(Twine(CmdName) + " command " + 644 Twine(LoadCommandIndex) + " has incorrect cmdsize"); 645 uint64_t FileSize = Obj.getData().size(); 646 if (DyldInfo.rebase_off > FileSize) 647 return malformedError("rebase_off field of " + Twine(CmdName) + 648 " command " + Twine(LoadCommandIndex) + " extends " 649 "past the end of the file"); 650 uint64_t BigSize = DyldInfo.rebase_off; 651 BigSize += DyldInfo.rebase_size; 652 if (BigSize > FileSize) 653 return malformedError("rebase_off field plus rebase_size field of " + 654 Twine(CmdName) + " command " + 655 Twine(LoadCommandIndex) + " extends past the end of " 656 "the file"); 657 if (Error Err = checkOverlappingElement(Elements, DyldInfo.rebase_off, 658 DyldInfo.rebase_size, 659 "dyld rebase info")) 660 return Err; 661 if (DyldInfo.bind_off > FileSize) 662 return malformedError("bind_off field of " + Twine(CmdName) + 663 " command " + Twine(LoadCommandIndex) + " extends " 664 "past the end of the file"); 665 BigSize = DyldInfo.bind_off; 666 BigSize += DyldInfo.bind_size; 667 if (BigSize > FileSize) 668 return malformedError("bind_off field plus bind_size field of " + 669 Twine(CmdName) + " command " + 670 Twine(LoadCommandIndex) + " extends past the end of " 671 "the file"); 672 if (Error Err = checkOverlappingElement(Elements, DyldInfo.bind_off, 673 DyldInfo.bind_size, 674 "dyld bind info")) 675 return Err; 676 if (DyldInfo.weak_bind_off > FileSize) 677 return malformedError("weak_bind_off field of " + Twine(CmdName) + 678 " command " + Twine(LoadCommandIndex) + " extends " 679 "past the end of the file"); 680 BigSize = DyldInfo.weak_bind_off; 681 BigSize += DyldInfo.weak_bind_size; 682 if (BigSize > FileSize) 683 return malformedError("weak_bind_off field plus weak_bind_size field of " + 684 Twine(CmdName) + " command " + 685 Twine(LoadCommandIndex) + " extends past the end of " 686 "the file"); 687 if (Error Err = checkOverlappingElement(Elements, DyldInfo.weak_bind_off, 688 DyldInfo.weak_bind_size, 689 "dyld weak bind info")) 690 return Err; 691 if (DyldInfo.lazy_bind_off > FileSize) 692 return malformedError("lazy_bind_off field of " + Twine(CmdName) + 693 " command " + Twine(LoadCommandIndex) + " extends " 694 "past the end of the file"); 695 BigSize = DyldInfo.lazy_bind_off; 696 BigSize += DyldInfo.lazy_bind_size; 697 if (BigSize > FileSize) 698 return malformedError("lazy_bind_off field plus lazy_bind_size field of " + 699 Twine(CmdName) + " command " + 700 Twine(LoadCommandIndex) + " extends past the end of " 701 "the file"); 702 if (Error Err = checkOverlappingElement(Elements, DyldInfo.lazy_bind_off, 703 DyldInfo.lazy_bind_size, 704 "dyld lazy bind info")) 705 return Err; 706 if (DyldInfo.export_off > FileSize) 707 return malformedError("export_off field of " + Twine(CmdName) + 708 " command " + Twine(LoadCommandIndex) + " extends " 709 "past the end of the file"); 710 BigSize = DyldInfo.export_off; 711 BigSize += DyldInfo.export_size; 712 if (BigSize > FileSize) 713 return malformedError("export_off field plus export_size field of " + 714 Twine(CmdName) + " command " + 715 Twine(LoadCommandIndex) + " extends past the end of " 716 "the file"); 717 if (Error Err = checkOverlappingElement(Elements, DyldInfo.export_off, 718 DyldInfo.export_size, 719 "dyld export info")) 720 return Err; 721 *LoadCmd = Load.Ptr; 722 return Error::success(); 723 } 724 725 static Error checkDylibCommand(const MachOObjectFile &Obj, 726 const MachOObjectFile::LoadCommandInfo &Load, 727 uint32_t LoadCommandIndex, const char *CmdName) { 728 if (Load.C.cmdsize < sizeof(MachO::dylib_command)) 729 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 730 CmdName + " cmdsize too small"); 731 auto CommandOrErr = getStructOrErr<MachO::dylib_command>(Obj, Load.Ptr); 732 if (!CommandOrErr) 733 return CommandOrErr.takeError(); 734 MachO::dylib_command D = CommandOrErr.get(); 735 if (D.dylib.name < sizeof(MachO::dylib_command)) 736 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 737 CmdName + " name.offset field too small, not past " 738 "the end of the dylib_command struct"); 739 if (D.dylib.name >= D.cmdsize) 740 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 741 CmdName + " name.offset field extends past the end " 742 "of the load command"); 743 // Make sure there is a null between the starting offset of the name and 744 // the end of the load command. 745 uint32_t i; 746 const char *P = (const char *)Load.Ptr; 747 for (i = D.dylib.name; i < D.cmdsize; i++) 748 if (P[i] == '\0') 749 break; 750 if (i >= D.cmdsize) 751 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 752 CmdName + " library name extends past the end of the " 753 "load command"); 754 return Error::success(); 755 } 756 757 static Error checkDylibIdCommand(const MachOObjectFile &Obj, 758 const MachOObjectFile::LoadCommandInfo &Load, 759 uint32_t LoadCommandIndex, 760 const char **LoadCmd) { 761 if (Error Err = checkDylibCommand(Obj, Load, LoadCommandIndex, 762 "LC_ID_DYLIB")) 763 return Err; 764 if (*LoadCmd != nullptr) 765 return malformedError("more than one LC_ID_DYLIB command"); 766 if (Obj.getHeader().filetype != MachO::MH_DYLIB && 767 Obj.getHeader().filetype != MachO::MH_DYLIB_STUB) 768 return malformedError("LC_ID_DYLIB load command in non-dynamic library " 769 "file type"); 770 *LoadCmd = Load.Ptr; 771 return Error::success(); 772 } 773 774 static Error checkDyldCommand(const MachOObjectFile &Obj, 775 const MachOObjectFile::LoadCommandInfo &Load, 776 uint32_t LoadCommandIndex, const char *CmdName) { 777 if (Load.C.cmdsize < sizeof(MachO::dylinker_command)) 778 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 779 CmdName + " cmdsize too small"); 780 auto CommandOrErr = getStructOrErr<MachO::dylinker_command>(Obj, Load.Ptr); 781 if (!CommandOrErr) 782 return CommandOrErr.takeError(); 783 MachO::dylinker_command D = CommandOrErr.get(); 784 if (D.name < sizeof(MachO::dylinker_command)) 785 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 786 CmdName + " name.offset field too small, not past " 787 "the end of the dylinker_command struct"); 788 if (D.name >= D.cmdsize) 789 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 790 CmdName + " name.offset field extends past the end " 791 "of the load command"); 792 // Make sure there is a null between the starting offset of the name and 793 // the end of the load command. 794 uint32_t i; 795 const char *P = (const char *)Load.Ptr; 796 for (i = D.name; i < D.cmdsize; i++) 797 if (P[i] == '\0') 798 break; 799 if (i >= D.cmdsize) 800 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 801 CmdName + " dyld name extends past the end of the " 802 "load command"); 803 return Error::success(); 804 } 805 806 static Error checkVersCommand(const MachOObjectFile &Obj, 807 const MachOObjectFile::LoadCommandInfo &Load, 808 uint32_t LoadCommandIndex, 809 const char **LoadCmd, const char *CmdName) { 810 if (Load.C.cmdsize != sizeof(MachO::version_min_command)) 811 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 812 CmdName + " has incorrect cmdsize"); 813 if (*LoadCmd != nullptr) 814 return malformedError("more than one LC_VERSION_MIN_MACOSX, " 815 "LC_VERSION_MIN_IPHONEOS, LC_VERSION_MIN_TVOS or " 816 "LC_VERSION_MIN_WATCHOS command"); 817 *LoadCmd = Load.Ptr; 818 return Error::success(); 819 } 820 821 static Error checkNoteCommand(const MachOObjectFile &Obj, 822 const MachOObjectFile::LoadCommandInfo &Load, 823 uint32_t LoadCommandIndex, 824 std::list<MachOElement> &Elements) { 825 if (Load.C.cmdsize != sizeof(MachO::note_command)) 826 return malformedError("load command " + Twine(LoadCommandIndex) + 827 " LC_NOTE has incorrect cmdsize"); 828 auto NoteCmdOrErr = getStructOrErr<MachO::note_command>(Obj, Load.Ptr); 829 if (!NoteCmdOrErr) 830 return NoteCmdOrErr.takeError(); 831 MachO::note_command Nt = NoteCmdOrErr.get(); 832 uint64_t FileSize = Obj.getData().size(); 833 if (Nt.offset > FileSize) 834 return malformedError("offset field of LC_NOTE command " + 835 Twine(LoadCommandIndex) + " extends " 836 "past the end of the file"); 837 uint64_t BigSize = Nt.offset; 838 BigSize += Nt.size; 839 if (BigSize > FileSize) 840 return malformedError("size field plus offset field of LC_NOTE command " + 841 Twine(LoadCommandIndex) + " extends past the end of " 842 "the file"); 843 if (Error Err = checkOverlappingElement(Elements, Nt.offset, Nt.size, 844 "LC_NOTE data")) 845 return Err; 846 return Error::success(); 847 } 848 849 static Error 850 parseBuildVersionCommand(const MachOObjectFile &Obj, 851 const MachOObjectFile::LoadCommandInfo &Load, 852 SmallVectorImpl<const char*> &BuildTools, 853 uint32_t LoadCommandIndex) { 854 auto BVCOrErr = 855 getStructOrErr<MachO::build_version_command>(Obj, Load.Ptr); 856 if (!BVCOrErr) 857 return BVCOrErr.takeError(); 858 MachO::build_version_command BVC = BVCOrErr.get(); 859 if (Load.C.cmdsize != 860 sizeof(MachO::build_version_command) + 861 BVC.ntools * sizeof(MachO::build_tool_version)) 862 return malformedError("load command " + Twine(LoadCommandIndex) + 863 " LC_BUILD_VERSION_COMMAND has incorrect cmdsize"); 864 865 auto Start = Load.Ptr + sizeof(MachO::build_version_command); 866 BuildTools.resize(BVC.ntools); 867 for (unsigned i = 0; i < BVC.ntools; ++i) 868 BuildTools[i] = Start + i * sizeof(MachO::build_tool_version); 869 870 return Error::success(); 871 } 872 873 static Error checkRpathCommand(const MachOObjectFile &Obj, 874 const MachOObjectFile::LoadCommandInfo &Load, 875 uint32_t LoadCommandIndex) { 876 if (Load.C.cmdsize < sizeof(MachO::rpath_command)) 877 return malformedError("load command " + Twine(LoadCommandIndex) + 878 " LC_RPATH cmdsize too small"); 879 auto ROrErr = getStructOrErr<MachO::rpath_command>(Obj, Load.Ptr); 880 if (!ROrErr) 881 return ROrErr.takeError(); 882 MachO::rpath_command R = ROrErr.get(); 883 if (R.path < sizeof(MachO::rpath_command)) 884 return malformedError("load command " + Twine(LoadCommandIndex) + 885 " LC_RPATH path.offset field too small, not past " 886 "the end of the rpath_command struct"); 887 if (R.path >= R.cmdsize) 888 return malformedError("load command " + Twine(LoadCommandIndex) + 889 " LC_RPATH path.offset field extends past the end " 890 "of the load command"); 891 // Make sure there is a null between the starting offset of the path and 892 // the end of the load command. 893 uint32_t i; 894 const char *P = (const char *)Load.Ptr; 895 for (i = R.path; i < R.cmdsize; i++) 896 if (P[i] == '\0') 897 break; 898 if (i >= R.cmdsize) 899 return malformedError("load command " + Twine(LoadCommandIndex) + 900 " LC_RPATH library name extends past the end of the " 901 "load command"); 902 return Error::success(); 903 } 904 905 static Error checkEncryptCommand(const MachOObjectFile &Obj, 906 const MachOObjectFile::LoadCommandInfo &Load, 907 uint32_t LoadCommandIndex, 908 uint64_t cryptoff, uint64_t cryptsize, 909 const char **LoadCmd, const char *CmdName) { 910 if (*LoadCmd != nullptr) 911 return malformedError("more than one LC_ENCRYPTION_INFO and or " 912 "LC_ENCRYPTION_INFO_64 command"); 913 uint64_t FileSize = Obj.getData().size(); 914 if (cryptoff > FileSize) 915 return malformedError("cryptoff field of " + Twine(CmdName) + 916 " command " + Twine(LoadCommandIndex) + " extends " 917 "past the end of the file"); 918 uint64_t BigSize = cryptoff; 919 BigSize += cryptsize; 920 if (BigSize > FileSize) 921 return malformedError("cryptoff field plus cryptsize field of " + 922 Twine(CmdName) + " command " + 923 Twine(LoadCommandIndex) + " extends past the end of " 924 "the file"); 925 *LoadCmd = Load.Ptr; 926 return Error::success(); 927 } 928 929 static Error checkLinkerOptCommand(const MachOObjectFile &Obj, 930 const MachOObjectFile::LoadCommandInfo &Load, 931 uint32_t LoadCommandIndex) { 932 if (Load.C.cmdsize < sizeof(MachO::linker_option_command)) 933 return malformedError("load command " + Twine(LoadCommandIndex) + 934 " LC_LINKER_OPTION cmdsize too small"); 935 auto LinkOptionOrErr = 936 getStructOrErr<MachO::linker_option_command>(Obj, Load.Ptr); 937 if (!LinkOptionOrErr) 938 return LinkOptionOrErr.takeError(); 939 MachO::linker_option_command L = LinkOptionOrErr.get(); 940 // Make sure the count of strings is correct. 941 const char *string = (const char *)Load.Ptr + 942 sizeof(struct MachO::linker_option_command); 943 uint32_t left = L.cmdsize - sizeof(struct MachO::linker_option_command); 944 uint32_t i = 0; 945 while (left > 0) { 946 while (*string == '\0' && left > 0) { 947 string++; 948 left--; 949 } 950 if (left > 0) { 951 i++; 952 uint32_t NullPos = StringRef(string, left).find('\0'); 953 if (0xffffffff == NullPos) 954 return malformedError("load command " + Twine(LoadCommandIndex) + 955 " LC_LINKER_OPTION string #" + Twine(i) + 956 " is not NULL terminated"); 957 uint32_t len = std::min(NullPos, left) + 1; 958 string += len; 959 left -= len; 960 } 961 } 962 if (L.count != i) 963 return malformedError("load command " + Twine(LoadCommandIndex) + 964 " LC_LINKER_OPTION string count " + Twine(L.count) + 965 " does not match number of strings"); 966 return Error::success(); 967 } 968 969 static Error checkSubCommand(const MachOObjectFile &Obj, 970 const MachOObjectFile::LoadCommandInfo &Load, 971 uint32_t LoadCommandIndex, const char *CmdName, 972 size_t SizeOfCmd, const char *CmdStructName, 973 uint32_t PathOffset, const char *PathFieldName) { 974 if (PathOffset < SizeOfCmd) 975 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 976 CmdName + " " + PathFieldName + ".offset field too " 977 "small, not past the end of the " + CmdStructName); 978 if (PathOffset >= Load.C.cmdsize) 979 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 980 CmdName + " " + PathFieldName + ".offset field " 981 "extends past the end of the load command"); 982 // Make sure there is a null between the starting offset of the path and 983 // the end of the load command. 984 uint32_t i; 985 const char *P = (const char *)Load.Ptr; 986 for (i = PathOffset; i < Load.C.cmdsize; i++) 987 if (P[i] == '\0') 988 break; 989 if (i >= Load.C.cmdsize) 990 return malformedError("load command " + Twine(LoadCommandIndex) + " " + 991 CmdName + " " + PathFieldName + " name extends past " 992 "the end of the load command"); 993 return Error::success(); 994 } 995 996 static Error checkThreadCommand(const MachOObjectFile &Obj, 997 const MachOObjectFile::LoadCommandInfo &Load, 998 uint32_t LoadCommandIndex, 999 const char *CmdName) { 1000 if (Load.C.cmdsize < sizeof(MachO::thread_command)) 1001 return malformedError("load command " + Twine(LoadCommandIndex) + 1002 CmdName + " cmdsize too small"); 1003 auto ThreadCommandOrErr = 1004 getStructOrErr<MachO::thread_command>(Obj, Load.Ptr); 1005 if (!ThreadCommandOrErr) 1006 return ThreadCommandOrErr.takeError(); 1007 MachO::thread_command T = ThreadCommandOrErr.get(); 1008 const char *state = Load.Ptr + sizeof(MachO::thread_command); 1009 const char *end = Load.Ptr + T.cmdsize; 1010 uint32_t nflavor = 0; 1011 uint32_t cputype = getCPUType(Obj); 1012 while (state < end) { 1013 if(state + sizeof(uint32_t) > end) 1014 return malformedError("load command " + Twine(LoadCommandIndex) + 1015 "flavor in " + CmdName + " extends past end of " 1016 "command"); 1017 uint32_t flavor; 1018 memcpy(&flavor, state, sizeof(uint32_t)); 1019 if (Obj.isLittleEndian() != sys::IsLittleEndianHost) 1020 sys::swapByteOrder(flavor); 1021 state += sizeof(uint32_t); 1022 1023 if(state + sizeof(uint32_t) > end) 1024 return malformedError("load command " + Twine(LoadCommandIndex) + 1025 " count in " + CmdName + " extends past end of " 1026 "command"); 1027 uint32_t count; 1028 memcpy(&count, state, sizeof(uint32_t)); 1029 if (Obj.isLittleEndian() != sys::IsLittleEndianHost) 1030 sys::swapByteOrder(count); 1031 state += sizeof(uint32_t); 1032 1033 if (cputype == MachO::CPU_TYPE_I386) { 1034 if (flavor == MachO::x86_THREAD_STATE32) { 1035 if (count != MachO::x86_THREAD_STATE32_COUNT) 1036 return malformedError("load command " + Twine(LoadCommandIndex) + 1037 " count not x86_THREAD_STATE32_COUNT for " 1038 "flavor number " + Twine(nflavor) + " which is " 1039 "a x86_THREAD_STATE32 flavor in " + CmdName + 1040 " command"); 1041 if (state + sizeof(MachO::x86_thread_state32_t) > end) 1042 return malformedError("load command " + Twine(LoadCommandIndex) + 1043 " x86_THREAD_STATE32 extends past end of " 1044 "command in " + CmdName + " command"); 1045 state += sizeof(MachO::x86_thread_state32_t); 1046 } else { 1047 return malformedError("load command " + Twine(LoadCommandIndex) + 1048 " unknown flavor (" + Twine(flavor) + ") for " 1049 "flavor number " + Twine(nflavor) + " in " + 1050 CmdName + " command"); 1051 } 1052 } else if (cputype == MachO::CPU_TYPE_X86_64) { 1053 if (flavor == MachO::x86_THREAD_STATE) { 1054 if (count != MachO::x86_THREAD_STATE_COUNT) 1055 return malformedError("load command " + Twine(LoadCommandIndex) + 1056 " count not x86_THREAD_STATE_COUNT for " 1057 "flavor number " + Twine(nflavor) + " which is " 1058 "a x86_THREAD_STATE flavor in " + CmdName + 1059 " command"); 1060 if (state + sizeof(MachO::x86_thread_state_t) > end) 1061 return malformedError("load command " + Twine(LoadCommandIndex) + 1062 " x86_THREAD_STATE extends past end of " 1063 "command in " + CmdName + " command"); 1064 state += sizeof(MachO::x86_thread_state_t); 1065 } else if (flavor == MachO::x86_FLOAT_STATE) { 1066 if (count != MachO::x86_FLOAT_STATE_COUNT) 1067 return malformedError("load command " + Twine(LoadCommandIndex) + 1068 " count not x86_FLOAT_STATE_COUNT for " 1069 "flavor number " + Twine(nflavor) + " which is " 1070 "a x86_FLOAT_STATE flavor in " + CmdName + 1071 " command"); 1072 if (state + sizeof(MachO::x86_float_state_t) > end) 1073 return malformedError("load command " + Twine(LoadCommandIndex) + 1074 " x86_FLOAT_STATE extends past end of " 1075 "command in " + CmdName + " command"); 1076 state += sizeof(MachO::x86_float_state_t); 1077 } else if (flavor == MachO::x86_EXCEPTION_STATE) { 1078 if (count != MachO::x86_EXCEPTION_STATE_COUNT) 1079 return malformedError("load command " + Twine(LoadCommandIndex) + 1080 " count not x86_EXCEPTION_STATE_COUNT for " 1081 "flavor number " + Twine(nflavor) + " which is " 1082 "a x86_EXCEPTION_STATE flavor in " + CmdName + 1083 " command"); 1084 if (state + sizeof(MachO::x86_exception_state_t) > end) 1085 return malformedError("load command " + Twine(LoadCommandIndex) + 1086 " x86_EXCEPTION_STATE extends past end of " 1087 "command in " + CmdName + " command"); 1088 state += sizeof(MachO::x86_exception_state_t); 1089 } else if (flavor == MachO::x86_THREAD_STATE64) { 1090 if (count != MachO::x86_THREAD_STATE64_COUNT) 1091 return malformedError("load command " + Twine(LoadCommandIndex) + 1092 " count not x86_THREAD_STATE64_COUNT for " 1093 "flavor number " + Twine(nflavor) + " which is " 1094 "a x86_THREAD_STATE64 flavor in " + CmdName + 1095 " command"); 1096 if (state + sizeof(MachO::x86_thread_state64_t) > end) 1097 return malformedError("load command " + Twine(LoadCommandIndex) + 1098 " x86_THREAD_STATE64 extends past end of " 1099 "command in " + CmdName + " command"); 1100 state += sizeof(MachO::x86_thread_state64_t); 1101 } else if (flavor == MachO::x86_EXCEPTION_STATE64) { 1102 if (count != MachO::x86_EXCEPTION_STATE64_COUNT) 1103 return malformedError("load command " + Twine(LoadCommandIndex) + 1104 " count not x86_EXCEPTION_STATE64_COUNT for " 1105 "flavor number " + Twine(nflavor) + " which is " 1106 "a x86_EXCEPTION_STATE64 flavor in " + CmdName + 1107 " command"); 1108 if (state + sizeof(MachO::x86_exception_state64_t) > end) 1109 return malformedError("load command " + Twine(LoadCommandIndex) + 1110 " x86_EXCEPTION_STATE64 extends past end of " 1111 "command in " + CmdName + " command"); 1112 state += sizeof(MachO::x86_exception_state64_t); 1113 } else { 1114 return malformedError("load command " + Twine(LoadCommandIndex) + 1115 " unknown flavor (" + Twine(flavor) + ") for " 1116 "flavor number " + Twine(nflavor) + " in " + 1117 CmdName + " command"); 1118 } 1119 } else if (cputype == MachO::CPU_TYPE_ARM) { 1120 if (flavor == MachO::ARM_THREAD_STATE) { 1121 if (count != MachO::ARM_THREAD_STATE_COUNT) 1122 return malformedError("load command " + Twine(LoadCommandIndex) + 1123 " count not ARM_THREAD_STATE_COUNT for " 1124 "flavor number " + Twine(nflavor) + " which is " 1125 "a ARM_THREAD_STATE flavor in " + CmdName + 1126 " command"); 1127 if (state + sizeof(MachO::arm_thread_state32_t) > end) 1128 return malformedError("load command " + Twine(LoadCommandIndex) + 1129 " ARM_THREAD_STATE extends past end of " 1130 "command in " + CmdName + " command"); 1131 state += sizeof(MachO::arm_thread_state32_t); 1132 } else { 1133 return malformedError("load command " + Twine(LoadCommandIndex) + 1134 " unknown flavor (" + Twine(flavor) + ") for " 1135 "flavor number " + Twine(nflavor) + " in " + 1136 CmdName + " command"); 1137 } 1138 } else if (cputype == MachO::CPU_TYPE_ARM64 || 1139 cputype == MachO::CPU_TYPE_ARM64_32) { 1140 if (flavor == MachO::ARM_THREAD_STATE64) { 1141 if (count != MachO::ARM_THREAD_STATE64_COUNT) 1142 return malformedError("load command " + Twine(LoadCommandIndex) + 1143 " count not ARM_THREAD_STATE64_COUNT for " 1144 "flavor number " + Twine(nflavor) + " which is " 1145 "a ARM_THREAD_STATE64 flavor in " + CmdName + 1146 " command"); 1147 if (state + sizeof(MachO::arm_thread_state64_t) > end) 1148 return malformedError("load command " + Twine(LoadCommandIndex) + 1149 " ARM_THREAD_STATE64 extends past end of " 1150 "command in " + CmdName + " command"); 1151 state += sizeof(MachO::arm_thread_state64_t); 1152 } else { 1153 return malformedError("load command " + Twine(LoadCommandIndex) + 1154 " unknown flavor (" + Twine(flavor) + ") for " 1155 "flavor number " + Twine(nflavor) + " in " + 1156 CmdName + " command"); 1157 } 1158 } else if (cputype == MachO::CPU_TYPE_POWERPC) { 1159 if (flavor == MachO::PPC_THREAD_STATE) { 1160 if (count != MachO::PPC_THREAD_STATE_COUNT) 1161 return malformedError("load command " + Twine(LoadCommandIndex) + 1162 " count not PPC_THREAD_STATE_COUNT for " 1163 "flavor number " + Twine(nflavor) + " which is " 1164 "a PPC_THREAD_STATE flavor in " + CmdName + 1165 " command"); 1166 if (state + sizeof(MachO::ppc_thread_state32_t) > end) 1167 return malformedError("load command " + Twine(LoadCommandIndex) + 1168 " PPC_THREAD_STATE extends past end of " 1169 "command in " + CmdName + " command"); 1170 state += sizeof(MachO::ppc_thread_state32_t); 1171 } else { 1172 return malformedError("load command " + Twine(LoadCommandIndex) + 1173 " unknown flavor (" + Twine(flavor) + ") for " 1174 "flavor number " + Twine(nflavor) + " in " + 1175 CmdName + " command"); 1176 } 1177 } else { 1178 return malformedError("unknown cputype (" + Twine(cputype) + ") load " 1179 "command " + Twine(LoadCommandIndex) + " for " + 1180 CmdName + " command can't be checked"); 1181 } 1182 nflavor++; 1183 } 1184 return Error::success(); 1185 } 1186 1187 static Error checkTwoLevelHintsCommand(const MachOObjectFile &Obj, 1188 const MachOObjectFile::LoadCommandInfo 1189 &Load, 1190 uint32_t LoadCommandIndex, 1191 const char **LoadCmd, 1192 std::list<MachOElement> &Elements) { 1193 if (Load.C.cmdsize != sizeof(MachO::twolevel_hints_command)) 1194 return malformedError("load command " + Twine(LoadCommandIndex) + 1195 " LC_TWOLEVEL_HINTS has incorrect cmdsize"); 1196 if (*LoadCmd != nullptr) 1197 return malformedError("more than one LC_TWOLEVEL_HINTS command"); 1198 auto HintsOrErr = getStructOrErr<MachO::twolevel_hints_command>(Obj, Load.Ptr); 1199 if(!HintsOrErr) 1200 return HintsOrErr.takeError(); 1201 MachO::twolevel_hints_command Hints = HintsOrErr.get(); 1202 uint64_t FileSize = Obj.getData().size(); 1203 if (Hints.offset > FileSize) 1204 return malformedError("offset field of LC_TWOLEVEL_HINTS command " + 1205 Twine(LoadCommandIndex) + " extends past the end of " 1206 "the file"); 1207 uint64_t BigSize = Hints.nhints; 1208 BigSize *= sizeof(MachO::twolevel_hint); 1209 BigSize += Hints.offset; 1210 if (BigSize > FileSize) 1211 return malformedError("offset field plus nhints times sizeof(struct " 1212 "twolevel_hint) field of LC_TWOLEVEL_HINTS command " + 1213 Twine(LoadCommandIndex) + " extends past the end of " 1214 "the file"); 1215 if (Error Err = checkOverlappingElement(Elements, Hints.offset, Hints.nhints * 1216 sizeof(MachO::twolevel_hint), 1217 "two level hints")) 1218 return Err; 1219 *LoadCmd = Load.Ptr; 1220 return Error::success(); 1221 } 1222 1223 // Returns true if the libObject code does not support the load command and its 1224 // contents. The cmd value it is treated as an unknown load command but with 1225 // an error message that says the cmd value is obsolete. 1226 static bool isLoadCommandObsolete(uint32_t cmd) { 1227 if (cmd == MachO::LC_SYMSEG || 1228 cmd == MachO::LC_LOADFVMLIB || 1229 cmd == MachO::LC_IDFVMLIB || 1230 cmd == MachO::LC_IDENT || 1231 cmd == MachO::LC_FVMFILE || 1232 cmd == MachO::LC_PREPAGE || 1233 cmd == MachO::LC_PREBOUND_DYLIB || 1234 cmd == MachO::LC_TWOLEVEL_HINTS || 1235 cmd == MachO::LC_PREBIND_CKSUM) 1236 return true; 1237 return false; 1238 } 1239 1240 Expected<std::unique_ptr<MachOObjectFile>> 1241 MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian, 1242 bool Is64Bits, uint32_t UniversalCputype, 1243 uint32_t UniversalIndex) { 1244 Error Err = Error::success(); 1245 std::unique_ptr<MachOObjectFile> Obj( 1246 new MachOObjectFile(std::move(Object), IsLittleEndian, 1247 Is64Bits, Err, UniversalCputype, 1248 UniversalIndex)); 1249 if (Err) 1250 return std::move(Err); 1251 return std::move(Obj); 1252 } 1253 1254 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian, 1255 bool Is64bits, Error &Err, 1256 uint32_t UniversalCputype, 1257 uint32_t UniversalIndex) 1258 : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object) { 1259 ErrorAsOutParameter ErrAsOutParam(&Err); 1260 uint64_t SizeOfHeaders; 1261 uint32_t cputype; 1262 if (is64Bit()) { 1263 parseHeader(*this, Header64, Err); 1264 SizeOfHeaders = sizeof(MachO::mach_header_64); 1265 cputype = Header64.cputype; 1266 } else { 1267 parseHeader(*this, Header, Err); 1268 SizeOfHeaders = sizeof(MachO::mach_header); 1269 cputype = Header.cputype; 1270 } 1271 if (Err) 1272 return; 1273 SizeOfHeaders += getHeader().sizeofcmds; 1274 if (getData().data() + SizeOfHeaders > getData().end()) { 1275 Err = malformedError("load commands extend past the end of the file"); 1276 return; 1277 } 1278 if (UniversalCputype != 0 && cputype != UniversalCputype) { 1279 Err = malformedError("universal header architecture: " + 1280 Twine(UniversalIndex) + "'s cputype does not match " 1281 "object file's mach header"); 1282 return; 1283 } 1284 std::list<MachOElement> Elements; 1285 Elements.push_back({0, SizeOfHeaders, "Mach-O headers"}); 1286 1287 uint32_t LoadCommandCount = getHeader().ncmds; 1288 LoadCommandInfo Load; 1289 if (LoadCommandCount != 0) { 1290 if (auto LoadOrErr = getFirstLoadCommandInfo(*this)) 1291 Load = *LoadOrErr; 1292 else { 1293 Err = LoadOrErr.takeError(); 1294 return; 1295 } 1296 } 1297 1298 const char *DyldIdLoadCmd = nullptr; 1299 const char *FuncStartsLoadCmd = nullptr; 1300 const char *SplitInfoLoadCmd = nullptr; 1301 const char *CodeSignDrsLoadCmd = nullptr; 1302 const char *CodeSignLoadCmd = nullptr; 1303 const char *VersLoadCmd = nullptr; 1304 const char *SourceLoadCmd = nullptr; 1305 const char *EntryPointLoadCmd = nullptr; 1306 const char *EncryptLoadCmd = nullptr; 1307 const char *RoutinesLoadCmd = nullptr; 1308 const char *UnixThreadLoadCmd = nullptr; 1309 const char *TwoLevelHintsLoadCmd = nullptr; 1310 for (unsigned I = 0; I < LoadCommandCount; ++I) { 1311 if (is64Bit()) { 1312 if (Load.C.cmdsize % 8 != 0) { 1313 // We have a hack here to allow 64-bit Mach-O core files to have 1314 // LC_THREAD commands that are only a multiple of 4 and not 8 to be 1315 // allowed since the macOS kernel produces them. 1316 if (getHeader().filetype != MachO::MH_CORE || 1317 Load.C.cmd != MachO::LC_THREAD || Load.C.cmdsize % 4) { 1318 Err = malformedError("load command " + Twine(I) + " cmdsize not a " 1319 "multiple of 8"); 1320 return; 1321 } 1322 } 1323 } else { 1324 if (Load.C.cmdsize % 4 != 0) { 1325 Err = malformedError("load command " + Twine(I) + " cmdsize not a " 1326 "multiple of 4"); 1327 return; 1328 } 1329 } 1330 LoadCommands.push_back(Load); 1331 if (Load.C.cmd == MachO::LC_SYMTAB) { 1332 if ((Err = checkSymtabCommand(*this, Load, I, &SymtabLoadCmd, Elements))) 1333 return; 1334 } else if (Load.C.cmd == MachO::LC_DYSYMTAB) { 1335 if ((Err = checkDysymtabCommand(*this, Load, I, &DysymtabLoadCmd, 1336 Elements))) 1337 return; 1338 } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) { 1339 if ((Err = checkLinkeditDataCommand(*this, Load, I, &DataInCodeLoadCmd, 1340 "LC_DATA_IN_CODE", Elements, 1341 "data in code info"))) 1342 return; 1343 } else if (Load.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) { 1344 if ((Err = checkLinkeditDataCommand(*this, Load, I, &LinkOptHintsLoadCmd, 1345 "LC_LINKER_OPTIMIZATION_HINT", 1346 Elements, "linker optimization " 1347 "hints"))) 1348 return; 1349 } else if (Load.C.cmd == MachO::LC_FUNCTION_STARTS) { 1350 if ((Err = checkLinkeditDataCommand(*this, Load, I, &FuncStartsLoadCmd, 1351 "LC_FUNCTION_STARTS", Elements, 1352 "function starts data"))) 1353 return; 1354 } else if (Load.C.cmd == MachO::LC_SEGMENT_SPLIT_INFO) { 1355 if ((Err = checkLinkeditDataCommand(*this, Load, I, &SplitInfoLoadCmd, 1356 "LC_SEGMENT_SPLIT_INFO", Elements, 1357 "split info data"))) 1358 return; 1359 } else if (Load.C.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS) { 1360 if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignDrsLoadCmd, 1361 "LC_DYLIB_CODE_SIGN_DRS", Elements, 1362 "code signing RDs data"))) 1363 return; 1364 } else if (Load.C.cmd == MachO::LC_CODE_SIGNATURE) { 1365 if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignLoadCmd, 1366 "LC_CODE_SIGNATURE", Elements, 1367 "code signature data"))) 1368 return; 1369 } else if (Load.C.cmd == MachO::LC_DYLD_INFO) { 1370 if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd, 1371 "LC_DYLD_INFO", Elements))) 1372 return; 1373 } else if (Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) { 1374 if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd, 1375 "LC_DYLD_INFO_ONLY", Elements))) 1376 return; 1377 } else if (Load.C.cmd == MachO::LC_UUID) { 1378 if (Load.C.cmdsize != sizeof(MachO::uuid_command)) { 1379 Err = malformedError("LC_UUID command " + Twine(I) + " has incorrect " 1380 "cmdsize"); 1381 return; 1382 } 1383 if (UuidLoadCmd) { 1384 Err = malformedError("more than one LC_UUID command"); 1385 return; 1386 } 1387 UuidLoadCmd = Load.Ptr; 1388 } else if (Load.C.cmd == MachO::LC_SEGMENT_64) { 1389 if ((Err = parseSegmentLoadCommand<MachO::segment_command_64, 1390 MachO::section_64>( 1391 *this, Load, Sections, HasPageZeroSegment, I, 1392 "LC_SEGMENT_64", SizeOfHeaders, Elements))) 1393 return; 1394 } else if (Load.C.cmd == MachO::LC_SEGMENT) { 1395 if ((Err = parseSegmentLoadCommand<MachO::segment_command, 1396 MachO::section>( 1397 *this, Load, Sections, HasPageZeroSegment, I, 1398 "LC_SEGMENT", SizeOfHeaders, Elements))) 1399 return; 1400 } else if (Load.C.cmd == MachO::LC_ID_DYLIB) { 1401 if ((Err = checkDylibIdCommand(*this, Load, I, &DyldIdLoadCmd))) 1402 return; 1403 } else if (Load.C.cmd == MachO::LC_LOAD_DYLIB) { 1404 if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_DYLIB"))) 1405 return; 1406 Libraries.push_back(Load.Ptr); 1407 } else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB) { 1408 if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_WEAK_DYLIB"))) 1409 return; 1410 Libraries.push_back(Load.Ptr); 1411 } else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB) { 1412 if ((Err = checkDylibCommand(*this, Load, I, "LC_LAZY_LOAD_DYLIB"))) 1413 return; 1414 Libraries.push_back(Load.Ptr); 1415 } else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB) { 1416 if ((Err = checkDylibCommand(*this, Load, I, "LC_REEXPORT_DYLIB"))) 1417 return; 1418 Libraries.push_back(Load.Ptr); 1419 } else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) { 1420 if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_UPWARD_DYLIB"))) 1421 return; 1422 Libraries.push_back(Load.Ptr); 1423 } else if (Load.C.cmd == MachO::LC_ID_DYLINKER) { 1424 if ((Err = checkDyldCommand(*this, Load, I, "LC_ID_DYLINKER"))) 1425 return; 1426 } else if (Load.C.cmd == MachO::LC_LOAD_DYLINKER) { 1427 if ((Err = checkDyldCommand(*this, Load, I, "LC_LOAD_DYLINKER"))) 1428 return; 1429 } else if (Load.C.cmd == MachO::LC_DYLD_ENVIRONMENT) { 1430 if ((Err = checkDyldCommand(*this, Load, I, "LC_DYLD_ENVIRONMENT"))) 1431 return; 1432 } else if (Load.C.cmd == MachO::LC_VERSION_MIN_MACOSX) { 1433 if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd, 1434 "LC_VERSION_MIN_MACOSX"))) 1435 return; 1436 } else if (Load.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS) { 1437 if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd, 1438 "LC_VERSION_MIN_IPHONEOS"))) 1439 return; 1440 } else if (Load.C.cmd == MachO::LC_VERSION_MIN_TVOS) { 1441 if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd, 1442 "LC_VERSION_MIN_TVOS"))) 1443 return; 1444 } else if (Load.C.cmd == MachO::LC_VERSION_MIN_WATCHOS) { 1445 if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd, 1446 "LC_VERSION_MIN_WATCHOS"))) 1447 return; 1448 } else if (Load.C.cmd == MachO::LC_NOTE) { 1449 if ((Err = checkNoteCommand(*this, Load, I, Elements))) 1450 return; 1451 } else if (Load.C.cmd == MachO::LC_BUILD_VERSION) { 1452 if ((Err = parseBuildVersionCommand(*this, Load, BuildTools, I))) 1453 return; 1454 } else if (Load.C.cmd == MachO::LC_RPATH) { 1455 if ((Err = checkRpathCommand(*this, Load, I))) 1456 return; 1457 } else if (Load.C.cmd == MachO::LC_SOURCE_VERSION) { 1458 if (Load.C.cmdsize != sizeof(MachO::source_version_command)) { 1459 Err = malformedError("LC_SOURCE_VERSION command " + Twine(I) + 1460 " has incorrect cmdsize"); 1461 return; 1462 } 1463 if (SourceLoadCmd) { 1464 Err = malformedError("more than one LC_SOURCE_VERSION command"); 1465 return; 1466 } 1467 SourceLoadCmd = Load.Ptr; 1468 } else if (Load.C.cmd == MachO::LC_MAIN) { 1469 if (Load.C.cmdsize != sizeof(MachO::entry_point_command)) { 1470 Err = malformedError("LC_MAIN command " + Twine(I) + 1471 " has incorrect cmdsize"); 1472 return; 1473 } 1474 if (EntryPointLoadCmd) { 1475 Err = malformedError("more than one LC_MAIN command"); 1476 return; 1477 } 1478 EntryPointLoadCmd = Load.Ptr; 1479 } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO) { 1480 if (Load.C.cmdsize != sizeof(MachO::encryption_info_command)) { 1481 Err = malformedError("LC_ENCRYPTION_INFO command " + Twine(I) + 1482 " has incorrect cmdsize"); 1483 return; 1484 } 1485 MachO::encryption_info_command E = 1486 getStruct<MachO::encryption_info_command>(*this, Load.Ptr); 1487 if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize, 1488 &EncryptLoadCmd, "LC_ENCRYPTION_INFO"))) 1489 return; 1490 } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO_64) { 1491 if (Load.C.cmdsize != sizeof(MachO::encryption_info_command_64)) { 1492 Err = malformedError("LC_ENCRYPTION_INFO_64 command " + Twine(I) + 1493 " has incorrect cmdsize"); 1494 return; 1495 } 1496 MachO::encryption_info_command_64 E = 1497 getStruct<MachO::encryption_info_command_64>(*this, Load.Ptr); 1498 if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize, 1499 &EncryptLoadCmd, "LC_ENCRYPTION_INFO_64"))) 1500 return; 1501 } else if (Load.C.cmd == MachO::LC_LINKER_OPTION) { 1502 if ((Err = checkLinkerOptCommand(*this, Load, I))) 1503 return; 1504 } else if (Load.C.cmd == MachO::LC_SUB_FRAMEWORK) { 1505 if (Load.C.cmdsize < sizeof(MachO::sub_framework_command)) { 1506 Err = malformedError("load command " + Twine(I) + 1507 " LC_SUB_FRAMEWORK cmdsize too small"); 1508 return; 1509 } 1510 MachO::sub_framework_command S = 1511 getStruct<MachO::sub_framework_command>(*this, Load.Ptr); 1512 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_FRAMEWORK", 1513 sizeof(MachO::sub_framework_command), 1514 "sub_framework_command", S.umbrella, 1515 "umbrella"))) 1516 return; 1517 } else if (Load.C.cmd == MachO::LC_SUB_UMBRELLA) { 1518 if (Load.C.cmdsize < sizeof(MachO::sub_umbrella_command)) { 1519 Err = malformedError("load command " + Twine(I) + 1520 " LC_SUB_UMBRELLA cmdsize too small"); 1521 return; 1522 } 1523 MachO::sub_umbrella_command S = 1524 getStruct<MachO::sub_umbrella_command>(*this, Load.Ptr); 1525 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_UMBRELLA", 1526 sizeof(MachO::sub_umbrella_command), 1527 "sub_umbrella_command", S.sub_umbrella, 1528 "sub_umbrella"))) 1529 return; 1530 } else if (Load.C.cmd == MachO::LC_SUB_LIBRARY) { 1531 if (Load.C.cmdsize < sizeof(MachO::sub_library_command)) { 1532 Err = malformedError("load command " + Twine(I) + 1533 " LC_SUB_LIBRARY cmdsize too small"); 1534 return; 1535 } 1536 MachO::sub_library_command S = 1537 getStruct<MachO::sub_library_command>(*this, Load.Ptr); 1538 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_LIBRARY", 1539 sizeof(MachO::sub_library_command), 1540 "sub_library_command", S.sub_library, 1541 "sub_library"))) 1542 return; 1543 } else if (Load.C.cmd == MachO::LC_SUB_CLIENT) { 1544 if (Load.C.cmdsize < sizeof(MachO::sub_client_command)) { 1545 Err = malformedError("load command " + Twine(I) + 1546 " LC_SUB_CLIENT cmdsize too small"); 1547 return; 1548 } 1549 MachO::sub_client_command S = 1550 getStruct<MachO::sub_client_command>(*this, Load.Ptr); 1551 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_CLIENT", 1552 sizeof(MachO::sub_client_command), 1553 "sub_client_command", S.client, "client"))) 1554 return; 1555 } else if (Load.C.cmd == MachO::LC_ROUTINES) { 1556 if (Load.C.cmdsize != sizeof(MachO::routines_command)) { 1557 Err = malformedError("LC_ROUTINES command " + Twine(I) + 1558 " has incorrect cmdsize"); 1559 return; 1560 } 1561 if (RoutinesLoadCmd) { 1562 Err = malformedError("more than one LC_ROUTINES and or LC_ROUTINES_64 " 1563 "command"); 1564 return; 1565 } 1566 RoutinesLoadCmd = Load.Ptr; 1567 } else if (Load.C.cmd == MachO::LC_ROUTINES_64) { 1568 if (Load.C.cmdsize != sizeof(MachO::routines_command_64)) { 1569 Err = malformedError("LC_ROUTINES_64 command " + Twine(I) + 1570 " has incorrect cmdsize"); 1571 return; 1572 } 1573 if (RoutinesLoadCmd) { 1574 Err = malformedError("more than one LC_ROUTINES_64 and or LC_ROUTINES " 1575 "command"); 1576 return; 1577 } 1578 RoutinesLoadCmd = Load.Ptr; 1579 } else if (Load.C.cmd == MachO::LC_UNIXTHREAD) { 1580 if ((Err = checkThreadCommand(*this, Load, I, "LC_UNIXTHREAD"))) 1581 return; 1582 if (UnixThreadLoadCmd) { 1583 Err = malformedError("more than one LC_UNIXTHREAD command"); 1584 return; 1585 } 1586 UnixThreadLoadCmd = Load.Ptr; 1587 } else if (Load.C.cmd == MachO::LC_THREAD) { 1588 if ((Err = checkThreadCommand(*this, Load, I, "LC_THREAD"))) 1589 return; 1590 // Note: LC_TWOLEVEL_HINTS is really obsolete and is not supported. 1591 } else if (Load.C.cmd == MachO::LC_TWOLEVEL_HINTS) { 1592 if ((Err = checkTwoLevelHintsCommand(*this, Load, I, 1593 &TwoLevelHintsLoadCmd, Elements))) 1594 return; 1595 } else if (isLoadCommandObsolete(Load.C.cmd)) { 1596 Err = malformedError("load command " + Twine(I) + " for cmd value of: " + 1597 Twine(Load.C.cmd) + " is obsolete and not " 1598 "supported"); 1599 return; 1600 } 1601 // TODO: generate a error for unknown load commands by default. But still 1602 // need work out an approach to allow or not allow unknown values like this 1603 // as an option for some uses like lldb. 1604 if (I < LoadCommandCount - 1) { 1605 if (auto LoadOrErr = getNextLoadCommandInfo(*this, I, Load)) 1606 Load = *LoadOrErr; 1607 else { 1608 Err = LoadOrErr.takeError(); 1609 return; 1610 } 1611 } 1612 } 1613 if (!SymtabLoadCmd) { 1614 if (DysymtabLoadCmd) { 1615 Err = malformedError("contains LC_DYSYMTAB load command without a " 1616 "LC_SYMTAB load command"); 1617 return; 1618 } 1619 } else if (DysymtabLoadCmd) { 1620 MachO::symtab_command Symtab = 1621 getStruct<MachO::symtab_command>(*this, SymtabLoadCmd); 1622 MachO::dysymtab_command Dysymtab = 1623 getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd); 1624 if (Dysymtab.nlocalsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) { 1625 Err = malformedError("ilocalsym in LC_DYSYMTAB load command " 1626 "extends past the end of the symbol table"); 1627 return; 1628 } 1629 uint64_t BigSize = Dysymtab.ilocalsym; 1630 BigSize += Dysymtab.nlocalsym; 1631 if (Dysymtab.nlocalsym != 0 && BigSize > Symtab.nsyms) { 1632 Err = malformedError("ilocalsym plus nlocalsym in LC_DYSYMTAB load " 1633 "command extends past the end of the symbol table"); 1634 return; 1635 } 1636 if (Dysymtab.nextdefsym != 0 && Dysymtab.iextdefsym > Symtab.nsyms) { 1637 Err = malformedError("iextdefsym in LC_DYSYMTAB load command " 1638 "extends past the end of the symbol table"); 1639 return; 1640 } 1641 BigSize = Dysymtab.iextdefsym; 1642 BigSize += Dysymtab.nextdefsym; 1643 if (Dysymtab.nextdefsym != 0 && BigSize > Symtab.nsyms) { 1644 Err = malformedError("iextdefsym plus nextdefsym in LC_DYSYMTAB " 1645 "load command extends past the end of the symbol " 1646 "table"); 1647 return; 1648 } 1649 if (Dysymtab.nundefsym != 0 && Dysymtab.iundefsym > Symtab.nsyms) { 1650 Err = malformedError("iundefsym in LC_DYSYMTAB load command " 1651 "extends past the end of the symbol table"); 1652 return; 1653 } 1654 BigSize = Dysymtab.iundefsym; 1655 BigSize += Dysymtab.nundefsym; 1656 if (Dysymtab.nundefsym != 0 && BigSize > Symtab.nsyms) { 1657 Err = malformedError("iundefsym plus nundefsym in LC_DYSYMTAB load " 1658 " command extends past the end of the symbol table"); 1659 return; 1660 } 1661 } 1662 if ((getHeader().filetype == MachO::MH_DYLIB || 1663 getHeader().filetype == MachO::MH_DYLIB_STUB) && 1664 DyldIdLoadCmd == nullptr) { 1665 Err = malformedError("no LC_ID_DYLIB load command in dynamic library " 1666 "filetype"); 1667 return; 1668 } 1669 assert(LoadCommands.size() == LoadCommandCount); 1670 1671 Err = Error::success(); 1672 } 1673 1674 Error MachOObjectFile::checkSymbolTable() const { 1675 uint32_t Flags = 0; 1676 if (is64Bit()) { 1677 MachO::mach_header_64 H_64 = MachOObjectFile::getHeader64(); 1678 Flags = H_64.flags; 1679 } else { 1680 MachO::mach_header H = MachOObjectFile::getHeader(); 1681 Flags = H.flags; 1682 } 1683 uint8_t NType = 0; 1684 uint8_t NSect = 0; 1685 uint16_t NDesc = 0; 1686 uint32_t NStrx = 0; 1687 uint64_t NValue = 0; 1688 uint32_t SymbolIndex = 0; 1689 MachO::symtab_command S = getSymtabLoadCommand(); 1690 for (const SymbolRef &Symbol : symbols()) { 1691 DataRefImpl SymDRI = Symbol.getRawDataRefImpl(); 1692 if (is64Bit()) { 1693 MachO::nlist_64 STE_64 = getSymbol64TableEntry(SymDRI); 1694 NType = STE_64.n_type; 1695 NSect = STE_64.n_sect; 1696 NDesc = STE_64.n_desc; 1697 NStrx = STE_64.n_strx; 1698 NValue = STE_64.n_value; 1699 } else { 1700 MachO::nlist STE = getSymbolTableEntry(SymDRI); 1701 NType = STE.n_type; 1702 NSect = STE.n_sect; 1703 NDesc = STE.n_desc; 1704 NStrx = STE.n_strx; 1705 NValue = STE.n_value; 1706 } 1707 if ((NType & MachO::N_STAB) == 0) { 1708 if ((NType & MachO::N_TYPE) == MachO::N_SECT) { 1709 if (NSect == 0 || NSect > Sections.size()) 1710 return malformedError("bad section index: " + Twine((int)NSect) + 1711 " for symbol at index " + Twine(SymbolIndex)); 1712 } 1713 if ((NType & MachO::N_TYPE) == MachO::N_INDR) { 1714 if (NValue >= S.strsize) 1715 return malformedError("bad n_value: " + Twine((int)NValue) + " past " 1716 "the end of string table, for N_INDR symbol at " 1717 "index " + Twine(SymbolIndex)); 1718 } 1719 if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL && 1720 (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) || 1721 (NType & MachO::N_TYPE) == MachO::N_PBUD)) { 1722 uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc); 1723 if (LibraryOrdinal != 0 && 1724 LibraryOrdinal != MachO::EXECUTABLE_ORDINAL && 1725 LibraryOrdinal != MachO::DYNAMIC_LOOKUP_ORDINAL && 1726 LibraryOrdinal - 1 >= Libraries.size() ) { 1727 return malformedError("bad library ordinal: " + Twine(LibraryOrdinal) + 1728 " for symbol at index " + Twine(SymbolIndex)); 1729 } 1730 } 1731 } 1732 if (NStrx >= S.strsize) 1733 return malformedError("bad string table index: " + Twine((int)NStrx) + 1734 " past the end of string table, for symbol at " 1735 "index " + Twine(SymbolIndex)); 1736 SymbolIndex++; 1737 } 1738 return Error::success(); 1739 } 1740 1741 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const { 1742 unsigned SymbolTableEntrySize = is64Bit() ? 1743 sizeof(MachO::nlist_64) : 1744 sizeof(MachO::nlist); 1745 Symb.p += SymbolTableEntrySize; 1746 } 1747 1748 Expected<StringRef> MachOObjectFile::getSymbolName(DataRefImpl Symb) const { 1749 StringRef StringTable = getStringTableData(); 1750 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb); 1751 if (Entry.n_strx == 0) 1752 // A n_strx value of 0 indicates that no name is associated with a 1753 // particular symbol table entry. 1754 return StringRef(); 1755 const char *Start = &StringTable.data()[Entry.n_strx]; 1756 if (Start < getData().begin() || Start >= getData().end()) { 1757 return malformedError("bad string index: " + Twine(Entry.n_strx) + 1758 " for symbol at index " + Twine(getSymbolIndex(Symb))); 1759 } 1760 return StringRef(Start); 1761 } 1762 1763 unsigned MachOObjectFile::getSectionType(SectionRef Sec) const { 1764 DataRefImpl DRI = Sec.getRawDataRefImpl(); 1765 uint32_t Flags = getSectionFlags(*this, DRI); 1766 return Flags & MachO::SECTION_TYPE; 1767 } 1768 1769 uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const { 1770 if (is64Bit()) { 1771 MachO::nlist_64 Entry = getSymbol64TableEntry(Sym); 1772 return Entry.n_value; 1773 } 1774 MachO::nlist Entry = getSymbolTableEntry(Sym); 1775 return Entry.n_value; 1776 } 1777 1778 // getIndirectName() returns the name of the alias'ed symbol who's string table 1779 // index is in the n_value field. 1780 std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb, 1781 StringRef &Res) const { 1782 StringRef StringTable = getStringTableData(); 1783 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb); 1784 if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR) 1785 return object_error::parse_failed; 1786 uint64_t NValue = getNValue(Symb); 1787 if (NValue >= StringTable.size()) 1788 return object_error::parse_failed; 1789 const char *Start = &StringTable.data()[NValue]; 1790 Res = StringRef(Start); 1791 return std::error_code(); 1792 } 1793 1794 uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const { 1795 return getNValue(Sym); 1796 } 1797 1798 Expected<uint64_t> MachOObjectFile::getSymbolAddress(DataRefImpl Sym) const { 1799 return getSymbolValue(Sym); 1800 } 1801 1802 uint32_t MachOObjectFile::getSymbolAlignment(DataRefImpl DRI) const { 1803 uint32_t flags = getSymbolFlags(DRI); 1804 if (flags & SymbolRef::SF_Common) { 1805 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI); 1806 return 1 << MachO::GET_COMM_ALIGN(Entry.n_desc); 1807 } 1808 return 0; 1809 } 1810 1811 uint64_t MachOObjectFile::getCommonSymbolSizeImpl(DataRefImpl DRI) const { 1812 return getNValue(DRI); 1813 } 1814 1815 Expected<SymbolRef::Type> 1816 MachOObjectFile::getSymbolType(DataRefImpl Symb) const { 1817 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb); 1818 uint8_t n_type = Entry.n_type; 1819 1820 // If this is a STAB debugging symbol, we can do nothing more. 1821 if (n_type & MachO::N_STAB) 1822 return SymbolRef::ST_Debug; 1823 1824 switch (n_type & MachO::N_TYPE) { 1825 case MachO::N_UNDF : 1826 return SymbolRef::ST_Unknown; 1827 case MachO::N_SECT : 1828 Expected<section_iterator> SecOrError = getSymbolSection(Symb); 1829 if (!SecOrError) 1830 return SecOrError.takeError(); 1831 section_iterator Sec = *SecOrError; 1832 if (Sec->isData() || Sec->isBSS()) 1833 return SymbolRef::ST_Data; 1834 return SymbolRef::ST_Function; 1835 } 1836 return SymbolRef::ST_Other; 1837 } 1838 1839 uint32_t MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const { 1840 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI); 1841 1842 uint8_t MachOType = Entry.n_type; 1843 uint16_t MachOFlags = Entry.n_desc; 1844 1845 uint32_t Result = SymbolRef::SF_None; 1846 1847 if ((MachOType & MachO::N_TYPE) == MachO::N_INDR) 1848 Result |= SymbolRef::SF_Indirect; 1849 1850 if (MachOType & MachO::N_STAB) 1851 Result |= SymbolRef::SF_FormatSpecific; 1852 1853 if (MachOType & MachO::N_EXT) { 1854 Result |= SymbolRef::SF_Global; 1855 if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) { 1856 if (getNValue(DRI)) 1857 Result |= SymbolRef::SF_Common; 1858 else 1859 Result |= SymbolRef::SF_Undefined; 1860 } 1861 1862 if (!(MachOType & MachO::N_PEXT)) 1863 Result |= SymbolRef::SF_Exported; 1864 } 1865 1866 if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF)) 1867 Result |= SymbolRef::SF_Weak; 1868 1869 if (MachOFlags & (MachO::N_ARM_THUMB_DEF)) 1870 Result |= SymbolRef::SF_Thumb; 1871 1872 if ((MachOType & MachO::N_TYPE) == MachO::N_ABS) 1873 Result |= SymbolRef::SF_Absolute; 1874 1875 return Result; 1876 } 1877 1878 Expected<section_iterator> 1879 MachOObjectFile::getSymbolSection(DataRefImpl Symb) const { 1880 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb); 1881 uint8_t index = Entry.n_sect; 1882 1883 if (index == 0) 1884 return section_end(); 1885 DataRefImpl DRI; 1886 DRI.d.a = index - 1; 1887 if (DRI.d.a >= Sections.size()){ 1888 return malformedError("bad section index: " + Twine((int)index) + 1889 " for symbol at index " + Twine(getSymbolIndex(Symb))); 1890 } 1891 return section_iterator(SectionRef(DRI, this)); 1892 } 1893 1894 unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const { 1895 MachO::nlist_base Entry = 1896 getSymbolTableEntryBase(*this, Sym.getRawDataRefImpl()); 1897 return Entry.n_sect - 1; 1898 } 1899 1900 void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const { 1901 Sec.d.a++; 1902 } 1903 1904 Expected<StringRef> MachOObjectFile::getSectionName(DataRefImpl Sec) const { 1905 ArrayRef<char> Raw = getSectionRawName(Sec); 1906 return parseSegmentOrSectionName(Raw.data()); 1907 } 1908 1909 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const { 1910 if (is64Bit()) 1911 return getSection64(Sec).addr; 1912 return getSection(Sec).addr; 1913 } 1914 1915 uint64_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const { 1916 return Sec.d.a; 1917 } 1918 1919 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const { 1920 // In the case if a malformed Mach-O file where the section offset is past 1921 // the end of the file or some part of the section size is past the end of 1922 // the file return a size of zero or a size that covers the rest of the file 1923 // but does not extend past the end of the file. 1924 uint32_t SectOffset, SectType; 1925 uint64_t SectSize; 1926 1927 if (is64Bit()) { 1928 MachO::section_64 Sect = getSection64(Sec); 1929 SectOffset = Sect.offset; 1930 SectSize = Sect.size; 1931 SectType = Sect.flags & MachO::SECTION_TYPE; 1932 } else { 1933 MachO::section Sect = getSection(Sec); 1934 SectOffset = Sect.offset; 1935 SectSize = Sect.size; 1936 SectType = Sect.flags & MachO::SECTION_TYPE; 1937 } 1938 if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL) 1939 return SectSize; 1940 uint64_t FileSize = getData().size(); 1941 if (SectOffset > FileSize) 1942 return 0; 1943 if (FileSize - SectOffset < SectSize) 1944 return FileSize - SectOffset; 1945 return SectSize; 1946 } 1947 1948 ArrayRef<uint8_t> MachOObjectFile::getSectionContents(uint32_t Offset, 1949 uint64_t Size) const { 1950 return arrayRefFromStringRef(getData().substr(Offset, Size)); 1951 } 1952 1953 Expected<ArrayRef<uint8_t>> 1954 MachOObjectFile::getSectionContents(DataRefImpl Sec) const { 1955 uint32_t Offset; 1956 uint64_t Size; 1957 1958 if (is64Bit()) { 1959 MachO::section_64 Sect = getSection64(Sec); 1960 Offset = Sect.offset; 1961 Size = Sect.size; 1962 } else { 1963 MachO::section Sect = getSection(Sec); 1964 Offset = Sect.offset; 1965 Size = Sect.size; 1966 } 1967 1968 return getSectionContents(Offset, Size); 1969 } 1970 1971 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const { 1972 uint32_t Align; 1973 if (is64Bit()) { 1974 MachO::section_64 Sect = getSection64(Sec); 1975 Align = Sect.align; 1976 } else { 1977 MachO::section Sect = getSection(Sec); 1978 Align = Sect.align; 1979 } 1980 1981 return uint64_t(1) << Align; 1982 } 1983 1984 Expected<SectionRef> MachOObjectFile::getSection(unsigned SectionIndex) const { 1985 if (SectionIndex < 1 || SectionIndex > Sections.size()) 1986 return malformedError("bad section index: " + Twine((int)SectionIndex)); 1987 1988 DataRefImpl DRI; 1989 DRI.d.a = SectionIndex - 1; 1990 return SectionRef(DRI, this); 1991 } 1992 1993 Expected<SectionRef> MachOObjectFile::getSection(StringRef SectionName) const { 1994 for (const SectionRef &Section : sections()) { 1995 auto NameOrErr = Section.getName(); 1996 if (!NameOrErr) 1997 return NameOrErr.takeError(); 1998 if (*NameOrErr == SectionName) 1999 return Section; 2000 } 2001 return errorCodeToError(object_error::parse_failed); 2002 } 2003 2004 bool MachOObjectFile::isSectionCompressed(DataRefImpl Sec) const { 2005 return false; 2006 } 2007 2008 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const { 2009 uint32_t Flags = getSectionFlags(*this, Sec); 2010 return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS; 2011 } 2012 2013 bool MachOObjectFile::isSectionData(DataRefImpl Sec) const { 2014 uint32_t Flags = getSectionFlags(*this, Sec); 2015 unsigned SectionType = Flags & MachO::SECTION_TYPE; 2016 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) && 2017 !(SectionType == MachO::S_ZEROFILL || 2018 SectionType == MachO::S_GB_ZEROFILL); 2019 } 2020 2021 bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const { 2022 uint32_t Flags = getSectionFlags(*this, Sec); 2023 unsigned SectionType = Flags & MachO::SECTION_TYPE; 2024 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) && 2025 (SectionType == MachO::S_ZEROFILL || 2026 SectionType == MachO::S_GB_ZEROFILL); 2027 } 2028 2029 unsigned MachOObjectFile::getSectionID(SectionRef Sec) const { 2030 return Sec.getRawDataRefImpl().d.a; 2031 } 2032 2033 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const { 2034 uint32_t Flags = getSectionFlags(*this, Sec); 2035 unsigned SectionType = Flags & MachO::SECTION_TYPE; 2036 return SectionType == MachO::S_ZEROFILL || 2037 SectionType == MachO::S_GB_ZEROFILL; 2038 } 2039 2040 bool MachOObjectFile::isSectionBitcode(DataRefImpl Sec) const { 2041 StringRef SegmentName = getSectionFinalSegmentName(Sec); 2042 if (Expected<StringRef> NameOrErr = getSectionName(Sec)) 2043 return (SegmentName == "__LLVM" && *NameOrErr == "__bitcode"); 2044 return false; 2045 } 2046 2047 bool MachOObjectFile::isSectionStripped(DataRefImpl Sec) const { 2048 if (is64Bit()) 2049 return getSection64(Sec).offset == 0; 2050 return getSection(Sec).offset == 0; 2051 } 2052 2053 relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const { 2054 DataRefImpl Ret; 2055 Ret.d.a = Sec.d.a; 2056 Ret.d.b = 0; 2057 return relocation_iterator(RelocationRef(Ret, this)); 2058 } 2059 2060 relocation_iterator 2061 MachOObjectFile::section_rel_end(DataRefImpl Sec) const { 2062 uint32_t Num; 2063 if (is64Bit()) { 2064 MachO::section_64 Sect = getSection64(Sec); 2065 Num = Sect.nreloc; 2066 } else { 2067 MachO::section Sect = getSection(Sec); 2068 Num = Sect.nreloc; 2069 } 2070 2071 DataRefImpl Ret; 2072 Ret.d.a = Sec.d.a; 2073 Ret.d.b = Num; 2074 return relocation_iterator(RelocationRef(Ret, this)); 2075 } 2076 2077 relocation_iterator MachOObjectFile::extrel_begin() const { 2078 DataRefImpl Ret; 2079 // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations 2080 Ret.d.a = 0; // Would normally be a section index. 2081 Ret.d.b = 0; // Index into the external relocations 2082 return relocation_iterator(RelocationRef(Ret, this)); 2083 } 2084 2085 relocation_iterator MachOObjectFile::extrel_end() const { 2086 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand(); 2087 DataRefImpl Ret; 2088 // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations 2089 Ret.d.a = 0; // Would normally be a section index. 2090 Ret.d.b = DysymtabLoadCmd.nextrel; // Index into the external relocations 2091 return relocation_iterator(RelocationRef(Ret, this)); 2092 } 2093 2094 relocation_iterator MachOObjectFile::locrel_begin() const { 2095 DataRefImpl Ret; 2096 // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations 2097 Ret.d.a = 1; // Would normally be a section index. 2098 Ret.d.b = 0; // Index into the local relocations 2099 return relocation_iterator(RelocationRef(Ret, this)); 2100 } 2101 2102 relocation_iterator MachOObjectFile::locrel_end() const { 2103 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand(); 2104 DataRefImpl Ret; 2105 // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations 2106 Ret.d.a = 1; // Would normally be a section index. 2107 Ret.d.b = DysymtabLoadCmd.nlocrel; // Index into the local relocations 2108 return relocation_iterator(RelocationRef(Ret, this)); 2109 } 2110 2111 void MachOObjectFile::moveRelocationNext(DataRefImpl &Rel) const { 2112 ++Rel.d.b; 2113 } 2114 2115 uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const { 2116 assert((getHeader().filetype == MachO::MH_OBJECT || 2117 getHeader().filetype == MachO::MH_KEXT_BUNDLE) && 2118 "Only implemented for MH_OBJECT && MH_KEXT_BUNDLE"); 2119 MachO::any_relocation_info RE = getRelocation(Rel); 2120 return getAnyRelocationAddress(RE); 2121 } 2122 2123 symbol_iterator 2124 MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const { 2125 MachO::any_relocation_info RE = getRelocation(Rel); 2126 if (isRelocationScattered(RE)) 2127 return symbol_end(); 2128 2129 uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE); 2130 bool isExtern = getPlainRelocationExternal(RE); 2131 if (!isExtern) 2132 return symbol_end(); 2133 2134 MachO::symtab_command S = getSymtabLoadCommand(); 2135 unsigned SymbolTableEntrySize = is64Bit() ? 2136 sizeof(MachO::nlist_64) : 2137 sizeof(MachO::nlist); 2138 uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize; 2139 DataRefImpl Sym; 2140 Sym.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset)); 2141 return symbol_iterator(SymbolRef(Sym, this)); 2142 } 2143 2144 section_iterator 2145 MachOObjectFile::getRelocationSection(DataRefImpl Rel) const { 2146 return section_iterator(getAnyRelocationSection(getRelocation(Rel))); 2147 } 2148 2149 uint64_t MachOObjectFile::getRelocationType(DataRefImpl Rel) const { 2150 MachO::any_relocation_info RE = getRelocation(Rel); 2151 return getAnyRelocationType(RE); 2152 } 2153 2154 void MachOObjectFile::getRelocationTypeName( 2155 DataRefImpl Rel, SmallVectorImpl<char> &Result) const { 2156 StringRef res; 2157 uint64_t RType = getRelocationType(Rel); 2158 2159 unsigned Arch = this->getArch(); 2160 2161 switch (Arch) { 2162 case Triple::x86: { 2163 static const char *const Table[] = { 2164 "GENERIC_RELOC_VANILLA", 2165 "GENERIC_RELOC_PAIR", 2166 "GENERIC_RELOC_SECTDIFF", 2167 "GENERIC_RELOC_PB_LA_PTR", 2168 "GENERIC_RELOC_LOCAL_SECTDIFF", 2169 "GENERIC_RELOC_TLV" }; 2170 2171 if (RType > 5) 2172 res = "Unknown"; 2173 else 2174 res = Table[RType]; 2175 break; 2176 } 2177 case Triple::x86_64: { 2178 static const char *const Table[] = { 2179 "X86_64_RELOC_UNSIGNED", 2180 "X86_64_RELOC_SIGNED", 2181 "X86_64_RELOC_BRANCH", 2182 "X86_64_RELOC_GOT_LOAD", 2183 "X86_64_RELOC_GOT", 2184 "X86_64_RELOC_SUBTRACTOR", 2185 "X86_64_RELOC_SIGNED_1", 2186 "X86_64_RELOC_SIGNED_2", 2187 "X86_64_RELOC_SIGNED_4", 2188 "X86_64_RELOC_TLV" }; 2189 2190 if (RType > 9) 2191 res = "Unknown"; 2192 else 2193 res = Table[RType]; 2194 break; 2195 } 2196 case Triple::arm: { 2197 static const char *const Table[] = { 2198 "ARM_RELOC_VANILLA", 2199 "ARM_RELOC_PAIR", 2200 "ARM_RELOC_SECTDIFF", 2201 "ARM_RELOC_LOCAL_SECTDIFF", 2202 "ARM_RELOC_PB_LA_PTR", 2203 "ARM_RELOC_BR24", 2204 "ARM_THUMB_RELOC_BR22", 2205 "ARM_THUMB_32BIT_BRANCH", 2206 "ARM_RELOC_HALF", 2207 "ARM_RELOC_HALF_SECTDIFF" }; 2208 2209 if (RType > 9) 2210 res = "Unknown"; 2211 else 2212 res = Table[RType]; 2213 break; 2214 } 2215 case Triple::aarch64: 2216 case Triple::aarch64_32: { 2217 static const char *const Table[] = { 2218 "ARM64_RELOC_UNSIGNED", "ARM64_RELOC_SUBTRACTOR", 2219 "ARM64_RELOC_BRANCH26", "ARM64_RELOC_PAGE21", 2220 "ARM64_RELOC_PAGEOFF12", "ARM64_RELOC_GOT_LOAD_PAGE21", 2221 "ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT", 2222 "ARM64_RELOC_TLVP_LOAD_PAGE21", "ARM64_RELOC_TLVP_LOAD_PAGEOFF12", 2223 "ARM64_RELOC_ADDEND" 2224 }; 2225 2226 if (RType >= array_lengthof(Table)) 2227 res = "Unknown"; 2228 else 2229 res = Table[RType]; 2230 break; 2231 } 2232 case Triple::ppc: { 2233 static const char *const Table[] = { 2234 "PPC_RELOC_VANILLA", 2235 "PPC_RELOC_PAIR", 2236 "PPC_RELOC_BR14", 2237 "PPC_RELOC_BR24", 2238 "PPC_RELOC_HI16", 2239 "PPC_RELOC_LO16", 2240 "PPC_RELOC_HA16", 2241 "PPC_RELOC_LO14", 2242 "PPC_RELOC_SECTDIFF", 2243 "PPC_RELOC_PB_LA_PTR", 2244 "PPC_RELOC_HI16_SECTDIFF", 2245 "PPC_RELOC_LO16_SECTDIFF", 2246 "PPC_RELOC_HA16_SECTDIFF", 2247 "PPC_RELOC_JBSR", 2248 "PPC_RELOC_LO14_SECTDIFF", 2249 "PPC_RELOC_LOCAL_SECTDIFF" }; 2250 2251 if (RType > 15) 2252 res = "Unknown"; 2253 else 2254 res = Table[RType]; 2255 break; 2256 } 2257 case Triple::UnknownArch: 2258 res = "Unknown"; 2259 break; 2260 } 2261 Result.append(res.begin(), res.end()); 2262 } 2263 2264 uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const { 2265 MachO::any_relocation_info RE = getRelocation(Rel); 2266 return getAnyRelocationLength(RE); 2267 } 2268 2269 // 2270 // guessLibraryShortName() is passed a name of a dynamic library and returns a 2271 // guess on what the short name is. Then name is returned as a substring of the 2272 // StringRef Name passed in. The name of the dynamic library is recognized as 2273 // a framework if it has one of the two following forms: 2274 // Foo.framework/Versions/A/Foo 2275 // Foo.framework/Foo 2276 // Where A and Foo can be any string. And may contain a trailing suffix 2277 // starting with an underbar. If the Name is recognized as a framework then 2278 // isFramework is set to true else it is set to false. If the Name has a 2279 // suffix then Suffix is set to the substring in Name that contains the suffix 2280 // else it is set to a NULL StringRef. 2281 // 2282 // The Name of the dynamic library is recognized as a library name if it has 2283 // one of the two following forms: 2284 // libFoo.A.dylib 2285 // libFoo.dylib 2286 // 2287 // The library may have a suffix trailing the name Foo of the form: 2288 // libFoo_profile.A.dylib 2289 // libFoo_profile.dylib 2290 // These dyld image suffixes are separated from the short name by a '_' 2291 // character. Because the '_' character is commonly used to separate words in 2292 // filenames guessLibraryShortName() cannot reliably separate a dylib's short 2293 // name from an arbitrary image suffix; imagine if both the short name and the 2294 // suffix contains an '_' character! To better deal with this ambiguity, 2295 // guessLibraryShortName() will recognize only "_debug" and "_profile" as valid 2296 // Suffix values. Calling code needs to be tolerant of guessLibraryShortName() 2297 // guessing incorrectly. 2298 // 2299 // The Name of the dynamic library is also recognized as a library name if it 2300 // has the following form: 2301 // Foo.qtx 2302 // 2303 // If the Name of the dynamic library is none of the forms above then a NULL 2304 // StringRef is returned. 2305 StringRef MachOObjectFile::guessLibraryShortName(StringRef Name, 2306 bool &isFramework, 2307 StringRef &Suffix) { 2308 StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx; 2309 size_t a, b, c, d, Idx; 2310 2311 isFramework = false; 2312 Suffix = StringRef(); 2313 2314 // Pull off the last component and make Foo point to it 2315 a = Name.rfind('/'); 2316 if (a == Name.npos || a == 0) 2317 goto guess_library; 2318 Foo = Name.slice(a+1, Name.npos); 2319 2320 // Look for a suffix starting with a '_' 2321 Idx = Foo.rfind('_'); 2322 if (Idx != Foo.npos && Foo.size() >= 2) { 2323 Suffix = Foo.slice(Idx, Foo.npos); 2324 if (Suffix != "_debug" && Suffix != "_profile") 2325 Suffix = StringRef(); 2326 else 2327 Foo = Foo.slice(0, Idx); 2328 } 2329 2330 // First look for the form Foo.framework/Foo 2331 b = Name.rfind('/', a); 2332 if (b == Name.npos) 2333 Idx = 0; 2334 else 2335 Idx = b+1; 2336 F = Name.slice(Idx, Idx + Foo.size()); 2337 DotFramework = Name.slice(Idx + Foo.size(), 2338 Idx + Foo.size() + sizeof(".framework/")-1); 2339 if (F == Foo && DotFramework == ".framework/") { 2340 isFramework = true; 2341 return Foo; 2342 } 2343 2344 // Next look for the form Foo.framework/Versions/A/Foo 2345 if (b == Name.npos) 2346 goto guess_library; 2347 c = Name.rfind('/', b); 2348 if (c == Name.npos || c == 0) 2349 goto guess_library; 2350 V = Name.slice(c+1, Name.npos); 2351 if (!V.startswith("Versions/")) 2352 goto guess_library; 2353 d = Name.rfind('/', c); 2354 if (d == Name.npos) 2355 Idx = 0; 2356 else 2357 Idx = d+1; 2358 F = Name.slice(Idx, Idx + Foo.size()); 2359 DotFramework = Name.slice(Idx + Foo.size(), 2360 Idx + Foo.size() + sizeof(".framework/")-1); 2361 if (F == Foo && DotFramework == ".framework/") { 2362 isFramework = true; 2363 return Foo; 2364 } 2365 2366 guess_library: 2367 // pull off the suffix after the "." and make a point to it 2368 a = Name.rfind('.'); 2369 if (a == Name.npos || a == 0) 2370 return StringRef(); 2371 Dylib = Name.slice(a, Name.npos); 2372 if (Dylib != ".dylib") 2373 goto guess_qtx; 2374 2375 // First pull off the version letter for the form Foo.A.dylib if any. 2376 if (a >= 3) { 2377 Dot = Name.slice(a-2, a-1); 2378 if (Dot == ".") 2379 a = a - 2; 2380 } 2381 2382 b = Name.rfind('/', a); 2383 if (b == Name.npos) 2384 b = 0; 2385 else 2386 b = b+1; 2387 // ignore any suffix after an underbar like Foo_profile.A.dylib 2388 Idx = Name.rfind('_'); 2389 if (Idx != Name.npos && Idx != b) { 2390 Lib = Name.slice(b, Idx); 2391 Suffix = Name.slice(Idx, a); 2392 if (Suffix != "_debug" && Suffix != "_profile") { 2393 Suffix = StringRef(); 2394 Lib = Name.slice(b, a); 2395 } 2396 } 2397 else 2398 Lib = Name.slice(b, a); 2399 // There are incorrect library names of the form: 2400 // libATS.A_profile.dylib so check for these. 2401 if (Lib.size() >= 3) { 2402 Dot = Lib.slice(Lib.size()-2, Lib.size()-1); 2403 if (Dot == ".") 2404 Lib = Lib.slice(0, Lib.size()-2); 2405 } 2406 return Lib; 2407 2408 guess_qtx: 2409 Qtx = Name.slice(a, Name.npos); 2410 if (Qtx != ".qtx") 2411 return StringRef(); 2412 b = Name.rfind('/', a); 2413 if (b == Name.npos) 2414 Lib = Name.slice(0, a); 2415 else 2416 Lib = Name.slice(b+1, a); 2417 // There are library names of the form: QT.A.qtx so check for these. 2418 if (Lib.size() >= 3) { 2419 Dot = Lib.slice(Lib.size()-2, Lib.size()-1); 2420 if (Dot == ".") 2421 Lib = Lib.slice(0, Lib.size()-2); 2422 } 2423 return Lib; 2424 } 2425 2426 // getLibraryShortNameByIndex() is used to get the short name of the library 2427 // for an undefined symbol in a linked Mach-O binary that was linked with the 2428 // normal two-level namespace default (that is MH_TWOLEVEL in the header). 2429 // It is passed the index (0 - based) of the library as translated from 2430 // GET_LIBRARY_ORDINAL (1 - based). 2431 std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index, 2432 StringRef &Res) const { 2433 if (Index >= Libraries.size()) 2434 return object_error::parse_failed; 2435 2436 // If the cache of LibrariesShortNames is not built up do that first for 2437 // all the Libraries. 2438 if (LibrariesShortNames.size() == 0) { 2439 for (unsigned i = 0; i < Libraries.size(); i++) { 2440 auto CommandOrErr = 2441 getStructOrErr<MachO::dylib_command>(*this, Libraries[i]); 2442 if (!CommandOrErr) 2443 return object_error::parse_failed; 2444 MachO::dylib_command D = CommandOrErr.get(); 2445 if (D.dylib.name >= D.cmdsize) 2446 return object_error::parse_failed; 2447 const char *P = (const char *)(Libraries[i]) + D.dylib.name; 2448 StringRef Name = StringRef(P); 2449 if (D.dylib.name+Name.size() >= D.cmdsize) 2450 return object_error::parse_failed; 2451 StringRef Suffix; 2452 bool isFramework; 2453 StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix); 2454 if (shortName.empty()) 2455 LibrariesShortNames.push_back(Name); 2456 else 2457 LibrariesShortNames.push_back(shortName); 2458 } 2459 } 2460 2461 Res = LibrariesShortNames[Index]; 2462 return std::error_code(); 2463 } 2464 2465 uint32_t MachOObjectFile::getLibraryCount() const { 2466 return Libraries.size(); 2467 } 2468 2469 section_iterator 2470 MachOObjectFile::getRelocationRelocatedSection(relocation_iterator Rel) const { 2471 DataRefImpl Sec; 2472 Sec.d.a = Rel->getRawDataRefImpl().d.a; 2473 return section_iterator(SectionRef(Sec, this)); 2474 } 2475 2476 basic_symbol_iterator MachOObjectFile::symbol_begin() const { 2477 DataRefImpl DRI; 2478 MachO::symtab_command Symtab = getSymtabLoadCommand(); 2479 if (!SymtabLoadCmd || Symtab.nsyms == 0) 2480 return basic_symbol_iterator(SymbolRef(DRI, this)); 2481 2482 return getSymbolByIndex(0); 2483 } 2484 2485 basic_symbol_iterator MachOObjectFile::symbol_end() const { 2486 DataRefImpl DRI; 2487 MachO::symtab_command Symtab = getSymtabLoadCommand(); 2488 if (!SymtabLoadCmd || Symtab.nsyms == 0) 2489 return basic_symbol_iterator(SymbolRef(DRI, this)); 2490 2491 unsigned SymbolTableEntrySize = is64Bit() ? 2492 sizeof(MachO::nlist_64) : 2493 sizeof(MachO::nlist); 2494 unsigned Offset = Symtab.symoff + 2495 Symtab.nsyms * SymbolTableEntrySize; 2496 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset)); 2497 return basic_symbol_iterator(SymbolRef(DRI, this)); 2498 } 2499 2500 symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const { 2501 MachO::symtab_command Symtab = getSymtabLoadCommand(); 2502 if (!SymtabLoadCmd || Index >= Symtab.nsyms) 2503 report_fatal_error("Requested symbol index is out of range."); 2504 unsigned SymbolTableEntrySize = 2505 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist); 2506 DataRefImpl DRI; 2507 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff)); 2508 DRI.p += Index * SymbolTableEntrySize; 2509 return basic_symbol_iterator(SymbolRef(DRI, this)); 2510 } 2511 2512 uint64_t MachOObjectFile::getSymbolIndex(DataRefImpl Symb) const { 2513 MachO::symtab_command Symtab = getSymtabLoadCommand(); 2514 if (!SymtabLoadCmd) 2515 report_fatal_error("getSymbolIndex() called with no symbol table symbol"); 2516 unsigned SymbolTableEntrySize = 2517 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist); 2518 DataRefImpl DRIstart; 2519 DRIstart.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff)); 2520 uint64_t Index = (Symb.p - DRIstart.p) / SymbolTableEntrySize; 2521 return Index; 2522 } 2523 2524 section_iterator MachOObjectFile::section_begin() const { 2525 DataRefImpl DRI; 2526 return section_iterator(SectionRef(DRI, this)); 2527 } 2528 2529 section_iterator MachOObjectFile::section_end() const { 2530 DataRefImpl DRI; 2531 DRI.d.a = Sections.size(); 2532 return section_iterator(SectionRef(DRI, this)); 2533 } 2534 2535 uint8_t MachOObjectFile::getBytesInAddress() const { 2536 return is64Bit() ? 8 : 4; 2537 } 2538 2539 StringRef MachOObjectFile::getFileFormatName() const { 2540 unsigned CPUType = getCPUType(*this); 2541 if (!is64Bit()) { 2542 switch (CPUType) { 2543 case MachO::CPU_TYPE_I386: 2544 return "Mach-O 32-bit i386"; 2545 case MachO::CPU_TYPE_ARM: 2546 return "Mach-O arm"; 2547 case MachO::CPU_TYPE_ARM64_32: 2548 return "Mach-O arm64 (ILP32)"; 2549 case MachO::CPU_TYPE_POWERPC: 2550 return "Mach-O 32-bit ppc"; 2551 default: 2552 return "Mach-O 32-bit unknown"; 2553 } 2554 } 2555 2556 switch (CPUType) { 2557 case MachO::CPU_TYPE_X86_64: 2558 return "Mach-O 64-bit x86-64"; 2559 case MachO::CPU_TYPE_ARM64: 2560 return "Mach-O arm64"; 2561 case MachO::CPU_TYPE_POWERPC64: 2562 return "Mach-O 64-bit ppc64"; 2563 default: 2564 return "Mach-O 64-bit unknown"; 2565 } 2566 } 2567 2568 Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType) { 2569 switch (CPUType) { 2570 case MachO::CPU_TYPE_I386: 2571 return Triple::x86; 2572 case MachO::CPU_TYPE_X86_64: 2573 return Triple::x86_64; 2574 case MachO::CPU_TYPE_ARM: 2575 return Triple::arm; 2576 case MachO::CPU_TYPE_ARM64: 2577 return Triple::aarch64; 2578 case MachO::CPU_TYPE_ARM64_32: 2579 return Triple::aarch64_32; 2580 case MachO::CPU_TYPE_POWERPC: 2581 return Triple::ppc; 2582 case MachO::CPU_TYPE_POWERPC64: 2583 return Triple::ppc64; 2584 default: 2585 return Triple::UnknownArch; 2586 } 2587 } 2588 2589 Triple MachOObjectFile::getArchTriple(uint32_t CPUType, uint32_t CPUSubType, 2590 const char **McpuDefault, 2591 const char **ArchFlag) { 2592 if (McpuDefault) 2593 *McpuDefault = nullptr; 2594 if (ArchFlag) 2595 *ArchFlag = nullptr; 2596 2597 switch (CPUType) { 2598 case MachO::CPU_TYPE_I386: 2599 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 2600 case MachO::CPU_SUBTYPE_I386_ALL: 2601 if (ArchFlag) 2602 *ArchFlag = "i386"; 2603 return Triple("i386-apple-darwin"); 2604 default: 2605 return Triple(); 2606 } 2607 case MachO::CPU_TYPE_X86_64: 2608 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 2609 case MachO::CPU_SUBTYPE_X86_64_ALL: 2610 if (ArchFlag) 2611 *ArchFlag = "x86_64"; 2612 return Triple("x86_64-apple-darwin"); 2613 case MachO::CPU_SUBTYPE_X86_64_H: 2614 if (ArchFlag) 2615 *ArchFlag = "x86_64h"; 2616 return Triple("x86_64h-apple-darwin"); 2617 default: 2618 return Triple(); 2619 } 2620 case MachO::CPU_TYPE_ARM: 2621 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 2622 case MachO::CPU_SUBTYPE_ARM_V4T: 2623 if (ArchFlag) 2624 *ArchFlag = "armv4t"; 2625 return Triple("armv4t-apple-darwin"); 2626 case MachO::CPU_SUBTYPE_ARM_V5TEJ: 2627 if (ArchFlag) 2628 *ArchFlag = "armv5e"; 2629 return Triple("armv5e-apple-darwin"); 2630 case MachO::CPU_SUBTYPE_ARM_XSCALE: 2631 if (ArchFlag) 2632 *ArchFlag = "xscale"; 2633 return Triple("xscale-apple-darwin"); 2634 case MachO::CPU_SUBTYPE_ARM_V6: 2635 if (ArchFlag) 2636 *ArchFlag = "armv6"; 2637 return Triple("armv6-apple-darwin"); 2638 case MachO::CPU_SUBTYPE_ARM_V6M: 2639 if (McpuDefault) 2640 *McpuDefault = "cortex-m0"; 2641 if (ArchFlag) 2642 *ArchFlag = "armv6m"; 2643 return Triple("armv6m-apple-darwin"); 2644 case MachO::CPU_SUBTYPE_ARM_V7: 2645 if (ArchFlag) 2646 *ArchFlag = "armv7"; 2647 return Triple("armv7-apple-darwin"); 2648 case MachO::CPU_SUBTYPE_ARM_V7EM: 2649 if (McpuDefault) 2650 *McpuDefault = "cortex-m4"; 2651 if (ArchFlag) 2652 *ArchFlag = "armv7em"; 2653 return Triple("thumbv7em-apple-darwin"); 2654 case MachO::CPU_SUBTYPE_ARM_V7K: 2655 if (McpuDefault) 2656 *McpuDefault = "cortex-a7"; 2657 if (ArchFlag) 2658 *ArchFlag = "armv7k"; 2659 return Triple("armv7k-apple-darwin"); 2660 case MachO::CPU_SUBTYPE_ARM_V7M: 2661 if (McpuDefault) 2662 *McpuDefault = "cortex-m3"; 2663 if (ArchFlag) 2664 *ArchFlag = "armv7m"; 2665 return Triple("thumbv7m-apple-darwin"); 2666 case MachO::CPU_SUBTYPE_ARM_V7S: 2667 if (McpuDefault) 2668 *McpuDefault = "cortex-a7"; 2669 if (ArchFlag) 2670 *ArchFlag = "armv7s"; 2671 return Triple("armv7s-apple-darwin"); 2672 default: 2673 return Triple(); 2674 } 2675 case MachO::CPU_TYPE_ARM64: 2676 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 2677 case MachO::CPU_SUBTYPE_ARM64_ALL: 2678 if (McpuDefault) 2679 *McpuDefault = "cyclone"; 2680 if (ArchFlag) 2681 *ArchFlag = "arm64"; 2682 return Triple("arm64-apple-darwin"); 2683 default: 2684 return Triple(); 2685 } 2686 case MachO::CPU_TYPE_ARM64_32: 2687 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 2688 case MachO::CPU_SUBTYPE_ARM64_32_V8: 2689 if (McpuDefault) 2690 *McpuDefault = "cyclone"; 2691 if (ArchFlag) 2692 *ArchFlag = "arm64_32"; 2693 return Triple("arm64_32-apple-darwin"); 2694 default: 2695 return Triple(); 2696 } 2697 case MachO::CPU_TYPE_POWERPC: 2698 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 2699 case MachO::CPU_SUBTYPE_POWERPC_ALL: 2700 if (ArchFlag) 2701 *ArchFlag = "ppc"; 2702 return Triple("ppc-apple-darwin"); 2703 default: 2704 return Triple(); 2705 } 2706 case MachO::CPU_TYPE_POWERPC64: 2707 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 2708 case MachO::CPU_SUBTYPE_POWERPC_ALL: 2709 if (ArchFlag) 2710 *ArchFlag = "ppc64"; 2711 return Triple("ppc64-apple-darwin"); 2712 default: 2713 return Triple(); 2714 } 2715 default: 2716 return Triple(); 2717 } 2718 } 2719 2720 Triple MachOObjectFile::getHostArch() { 2721 return Triple(sys::getDefaultTargetTriple()); 2722 } 2723 2724 bool MachOObjectFile::isValidArch(StringRef ArchFlag) { 2725 auto validArchs = getValidArchs(); 2726 return llvm::find(validArchs, ArchFlag) != validArchs.end(); 2727 } 2728 2729 ArrayRef<StringRef> MachOObjectFile::getValidArchs() { 2730 static const std::array<StringRef, 17> validArchs = {{ 2731 "i386", "x86_64", "x86_64h", "armv4t", "arm", "armv5e", 2732 "armv6", "armv6m", "armv7", "armv7em", "armv7k", "armv7m", 2733 "armv7s", "arm64", "arm64_32", "ppc", "ppc64", 2734 }}; 2735 2736 return validArchs; 2737 } 2738 2739 Triple::ArchType MachOObjectFile::getArch() const { 2740 return getArch(getCPUType(*this)); 2741 } 2742 2743 Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const { 2744 return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault); 2745 } 2746 2747 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const { 2748 DataRefImpl DRI; 2749 DRI.d.a = Index; 2750 return section_rel_begin(DRI); 2751 } 2752 2753 relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const { 2754 DataRefImpl DRI; 2755 DRI.d.a = Index; 2756 return section_rel_end(DRI); 2757 } 2758 2759 dice_iterator MachOObjectFile::begin_dices() const { 2760 DataRefImpl DRI; 2761 if (!DataInCodeLoadCmd) 2762 return dice_iterator(DiceRef(DRI, this)); 2763 2764 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand(); 2765 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, DicLC.dataoff)); 2766 return dice_iterator(DiceRef(DRI, this)); 2767 } 2768 2769 dice_iterator MachOObjectFile::end_dices() const { 2770 DataRefImpl DRI; 2771 if (!DataInCodeLoadCmd) 2772 return dice_iterator(DiceRef(DRI, this)); 2773 2774 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand(); 2775 unsigned Offset = DicLC.dataoff + DicLC.datasize; 2776 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset)); 2777 return dice_iterator(DiceRef(DRI, this)); 2778 } 2779 2780 ExportEntry::ExportEntry(Error *E, const MachOObjectFile *O, 2781 ArrayRef<uint8_t> T) : E(E), O(O), Trie(T) {} 2782 2783 void ExportEntry::moveToFirst() { 2784 ErrorAsOutParameter ErrAsOutParam(E); 2785 pushNode(0); 2786 if (*E) 2787 return; 2788 pushDownUntilBottom(); 2789 } 2790 2791 void ExportEntry::moveToEnd() { 2792 Stack.clear(); 2793 Done = true; 2794 } 2795 2796 bool ExportEntry::operator==(const ExportEntry &Other) const { 2797 // Common case, one at end, other iterating from begin. 2798 if (Done || Other.Done) 2799 return (Done == Other.Done); 2800 // Not equal if different stack sizes. 2801 if (Stack.size() != Other.Stack.size()) 2802 return false; 2803 // Not equal if different cumulative strings. 2804 if (!CumulativeString.equals(Other.CumulativeString)) 2805 return false; 2806 // Equal if all nodes in both stacks match. 2807 for (unsigned i=0; i < Stack.size(); ++i) { 2808 if (Stack[i].Start != Other.Stack[i].Start) 2809 return false; 2810 } 2811 return true; 2812 } 2813 2814 uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr, const char **error) { 2815 unsigned Count; 2816 uint64_t Result = decodeULEB128(Ptr, &Count, Trie.end(), error); 2817 Ptr += Count; 2818 if (Ptr > Trie.end()) 2819 Ptr = Trie.end(); 2820 return Result; 2821 } 2822 2823 StringRef ExportEntry::name() const { 2824 return CumulativeString; 2825 } 2826 2827 uint64_t ExportEntry::flags() const { 2828 return Stack.back().Flags; 2829 } 2830 2831 uint64_t ExportEntry::address() const { 2832 return Stack.back().Address; 2833 } 2834 2835 uint64_t ExportEntry::other() const { 2836 return Stack.back().Other; 2837 } 2838 2839 StringRef ExportEntry::otherName() const { 2840 const char* ImportName = Stack.back().ImportName; 2841 if (ImportName) 2842 return StringRef(ImportName); 2843 return StringRef(); 2844 } 2845 2846 uint32_t ExportEntry::nodeOffset() const { 2847 return Stack.back().Start - Trie.begin(); 2848 } 2849 2850 ExportEntry::NodeState::NodeState(const uint8_t *Ptr) 2851 : Start(Ptr), Current(Ptr) {} 2852 2853 void ExportEntry::pushNode(uint64_t offset) { 2854 ErrorAsOutParameter ErrAsOutParam(E); 2855 const uint8_t *Ptr = Trie.begin() + offset; 2856 NodeState State(Ptr); 2857 const char *error; 2858 uint64_t ExportInfoSize = readULEB128(State.Current, &error); 2859 if (error) { 2860 *E = malformedError("export info size " + Twine(error) + 2861 " in export trie data at node: 0x" + 2862 Twine::utohexstr(offset)); 2863 moveToEnd(); 2864 return; 2865 } 2866 State.IsExportNode = (ExportInfoSize != 0); 2867 const uint8_t* Children = State.Current + ExportInfoSize; 2868 if (Children > Trie.end()) { 2869 *E = malformedError( 2870 "export info size: 0x" + Twine::utohexstr(ExportInfoSize) + 2871 " in export trie data at node: 0x" + Twine::utohexstr(offset) + 2872 " too big and extends past end of trie data"); 2873 moveToEnd(); 2874 return; 2875 } 2876 if (State.IsExportNode) { 2877 const uint8_t *ExportStart = State.Current; 2878 State.Flags = readULEB128(State.Current, &error); 2879 if (error) { 2880 *E = malformedError("flags " + Twine(error) + 2881 " in export trie data at node: 0x" + 2882 Twine::utohexstr(offset)); 2883 moveToEnd(); 2884 return; 2885 } 2886 uint64_t Kind = State.Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK; 2887 if (State.Flags != 0 && 2888 (Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_REGULAR && 2889 Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE && 2890 Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL)) { 2891 *E = malformedError( 2892 "unsupported exported symbol kind: " + Twine((int)Kind) + 2893 " in flags: 0x" + Twine::utohexstr(State.Flags) + 2894 " in export trie data at node: 0x" + Twine::utohexstr(offset)); 2895 moveToEnd(); 2896 return; 2897 } 2898 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) { 2899 State.Address = 0; 2900 State.Other = readULEB128(State.Current, &error); // dylib ordinal 2901 if (error) { 2902 *E = malformedError("dylib ordinal of re-export " + Twine(error) + 2903 " in export trie data at node: 0x" + 2904 Twine::utohexstr(offset)); 2905 moveToEnd(); 2906 return; 2907 } 2908 if (O != nullptr) { 2909 if (State.Other > O->getLibraryCount()) { 2910 *E = malformedError( 2911 "bad library ordinal: " + Twine((int)State.Other) + " (max " + 2912 Twine((int)O->getLibraryCount()) + 2913 ") in export trie data at node: 0x" + Twine::utohexstr(offset)); 2914 moveToEnd(); 2915 return; 2916 } 2917 } 2918 State.ImportName = reinterpret_cast<const char*>(State.Current); 2919 if (*State.ImportName == '\0') { 2920 State.Current++; 2921 } else { 2922 const uint8_t *End = State.Current + 1; 2923 if (End >= Trie.end()) { 2924 *E = malformedError("import name of re-export in export trie data at " 2925 "node: 0x" + 2926 Twine::utohexstr(offset) + 2927 " starts past end of trie data"); 2928 moveToEnd(); 2929 return; 2930 } 2931 while(*End != '\0' && End < Trie.end()) 2932 End++; 2933 if (*End != '\0') { 2934 *E = malformedError("import name of re-export in export trie data at " 2935 "node: 0x" + 2936 Twine::utohexstr(offset) + 2937 " extends past end of trie data"); 2938 moveToEnd(); 2939 return; 2940 } 2941 State.Current = End + 1; 2942 } 2943 } else { 2944 State.Address = readULEB128(State.Current, &error); 2945 if (error) { 2946 *E = malformedError("address " + Twine(error) + 2947 " in export trie data at node: 0x" + 2948 Twine::utohexstr(offset)); 2949 moveToEnd(); 2950 return; 2951 } 2952 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) { 2953 State.Other = readULEB128(State.Current, &error); 2954 if (error) { 2955 *E = malformedError("resolver of stub and resolver " + Twine(error) + 2956 " in export trie data at node: 0x" + 2957 Twine::utohexstr(offset)); 2958 moveToEnd(); 2959 return; 2960 } 2961 } 2962 } 2963 if(ExportStart + ExportInfoSize != State.Current) { 2964 *E = malformedError( 2965 "inconsistant export info size: 0x" + 2966 Twine::utohexstr(ExportInfoSize) + " where actual size was: 0x" + 2967 Twine::utohexstr(State.Current - ExportStart) + 2968 " in export trie data at node: 0x" + Twine::utohexstr(offset)); 2969 moveToEnd(); 2970 return; 2971 } 2972 } 2973 State.ChildCount = *Children; 2974 if (State.ChildCount != 0 && Children + 1 >= Trie.end()) { 2975 *E = malformedError("byte for count of childern in export trie data at " 2976 "node: 0x" + 2977 Twine::utohexstr(offset) + 2978 " extends past end of trie data"); 2979 moveToEnd(); 2980 return; 2981 } 2982 State.Current = Children + 1; 2983 State.NextChildIndex = 0; 2984 State.ParentStringLength = CumulativeString.size(); 2985 Stack.push_back(State); 2986 } 2987 2988 void ExportEntry::pushDownUntilBottom() { 2989 ErrorAsOutParameter ErrAsOutParam(E); 2990 const char *error; 2991 while (Stack.back().NextChildIndex < Stack.back().ChildCount) { 2992 NodeState &Top = Stack.back(); 2993 CumulativeString.resize(Top.ParentStringLength); 2994 for (;*Top.Current != 0 && Top.Current < Trie.end(); Top.Current++) { 2995 char C = *Top.Current; 2996 CumulativeString.push_back(C); 2997 } 2998 if (Top.Current >= Trie.end()) { 2999 *E = malformedError("edge sub-string in export trie data at node: 0x" + 3000 Twine::utohexstr(Top.Start - Trie.begin()) + 3001 " for child #" + Twine((int)Top.NextChildIndex) + 3002 " extends past end of trie data"); 3003 moveToEnd(); 3004 return; 3005 } 3006 Top.Current += 1; 3007 uint64_t childNodeIndex = readULEB128(Top.Current, &error); 3008 if (error) { 3009 *E = malformedError("child node offset " + Twine(error) + 3010 " in export trie data at node: 0x" + 3011 Twine::utohexstr(Top.Start - Trie.begin())); 3012 moveToEnd(); 3013 return; 3014 } 3015 for (const NodeState &node : nodes()) { 3016 if (node.Start == Trie.begin() + childNodeIndex){ 3017 *E = malformedError("loop in childern in export trie data at node: 0x" + 3018 Twine::utohexstr(Top.Start - Trie.begin()) + 3019 " back to node: 0x" + 3020 Twine::utohexstr(childNodeIndex)); 3021 moveToEnd(); 3022 return; 3023 } 3024 } 3025 Top.NextChildIndex += 1; 3026 pushNode(childNodeIndex); 3027 if (*E) 3028 return; 3029 } 3030 if (!Stack.back().IsExportNode) { 3031 *E = malformedError("node is not an export node in export trie data at " 3032 "node: 0x" + 3033 Twine::utohexstr(Stack.back().Start - Trie.begin())); 3034 moveToEnd(); 3035 return; 3036 } 3037 } 3038 3039 // We have a trie data structure and need a way to walk it that is compatible 3040 // with the C++ iterator model. The solution is a non-recursive depth first 3041 // traversal where the iterator contains a stack of parent nodes along with a 3042 // string that is the accumulation of all edge strings along the parent chain 3043 // to this point. 3044 // 3045 // There is one "export" node for each exported symbol. But because some 3046 // symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export 3047 // node may have child nodes too. 3048 // 3049 // The algorithm for moveNext() is to keep moving down the leftmost unvisited 3050 // child until hitting a node with no children (which is an export node or 3051 // else the trie is malformed). On the way down, each node is pushed on the 3052 // stack ivar. If there is no more ways down, it pops up one and tries to go 3053 // down a sibling path until a childless node is reached. 3054 void ExportEntry::moveNext() { 3055 assert(!Stack.empty() && "ExportEntry::moveNext() with empty node stack"); 3056 if (!Stack.back().IsExportNode) { 3057 *E = malformedError("node is not an export node in export trie data at " 3058 "node: 0x" + 3059 Twine::utohexstr(Stack.back().Start - Trie.begin())); 3060 moveToEnd(); 3061 return; 3062 } 3063 3064 Stack.pop_back(); 3065 while (!Stack.empty()) { 3066 NodeState &Top = Stack.back(); 3067 if (Top.NextChildIndex < Top.ChildCount) { 3068 pushDownUntilBottom(); 3069 // Now at the next export node. 3070 return; 3071 } else { 3072 if (Top.IsExportNode) { 3073 // This node has no children but is itself an export node. 3074 CumulativeString.resize(Top.ParentStringLength); 3075 return; 3076 } 3077 Stack.pop_back(); 3078 } 3079 } 3080 Done = true; 3081 } 3082 3083 iterator_range<export_iterator> 3084 MachOObjectFile::exports(Error &E, ArrayRef<uint8_t> Trie, 3085 const MachOObjectFile *O) { 3086 ExportEntry Start(&E, O, Trie); 3087 if (Trie.empty()) 3088 Start.moveToEnd(); 3089 else 3090 Start.moveToFirst(); 3091 3092 ExportEntry Finish(&E, O, Trie); 3093 Finish.moveToEnd(); 3094 3095 return make_range(export_iterator(Start), export_iterator(Finish)); 3096 } 3097 3098 iterator_range<export_iterator> MachOObjectFile::exports(Error &Err) const { 3099 return exports(Err, getDyldInfoExportsTrie(), this); 3100 } 3101 3102 MachORebaseEntry::MachORebaseEntry(Error *E, const MachOObjectFile *O, 3103 ArrayRef<uint8_t> Bytes, bool is64Bit) 3104 : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()), 3105 PointerSize(is64Bit ? 8 : 4) {} 3106 3107 void MachORebaseEntry::moveToFirst() { 3108 Ptr = Opcodes.begin(); 3109 moveNext(); 3110 } 3111 3112 void MachORebaseEntry::moveToEnd() { 3113 Ptr = Opcodes.end(); 3114 RemainingLoopCount = 0; 3115 Done = true; 3116 } 3117 3118 void MachORebaseEntry::moveNext() { 3119 ErrorAsOutParameter ErrAsOutParam(E); 3120 // If in the middle of some loop, move to next rebasing in loop. 3121 SegmentOffset += AdvanceAmount; 3122 if (RemainingLoopCount) { 3123 --RemainingLoopCount; 3124 return; 3125 } 3126 // REBASE_OPCODE_DONE is only used for padding if we are not aligned to 3127 // pointer size. Therefore it is possible to reach the end without ever having 3128 // seen REBASE_OPCODE_DONE. 3129 if (Ptr == Opcodes.end()) { 3130 Done = true; 3131 return; 3132 } 3133 bool More = true; 3134 while (More) { 3135 // Parse next opcode and set up next loop. 3136 const uint8_t *OpcodeStart = Ptr; 3137 uint8_t Byte = *Ptr++; 3138 uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK; 3139 uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK; 3140 uint32_t Count, Skip; 3141 const char *error = nullptr; 3142 switch (Opcode) { 3143 case MachO::REBASE_OPCODE_DONE: 3144 More = false; 3145 Done = true; 3146 moveToEnd(); 3147 DEBUG_WITH_TYPE("mach-o-rebase", dbgs() << "REBASE_OPCODE_DONE\n"); 3148 break; 3149 case MachO::REBASE_OPCODE_SET_TYPE_IMM: 3150 RebaseType = ImmValue; 3151 if (RebaseType > MachO::REBASE_TYPE_TEXT_PCREL32) { 3152 *E = malformedError("for REBASE_OPCODE_SET_TYPE_IMM bad bind type: " + 3153 Twine((int)RebaseType) + " for opcode at: 0x" + 3154 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3155 moveToEnd(); 3156 return; 3157 } 3158 DEBUG_WITH_TYPE( 3159 "mach-o-rebase", 3160 dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: " 3161 << "RebaseType=" << (int) RebaseType << "\n"); 3162 break; 3163 case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: 3164 SegmentIndex = ImmValue; 3165 SegmentOffset = readULEB128(&error); 3166 if (error) { 3167 *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " + 3168 Twine(error) + " for opcode at: 0x" + 3169 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3170 moveToEnd(); 3171 return; 3172 } 3173 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3174 PointerSize); 3175 if (error) { 3176 *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " + 3177 Twine(error) + " for opcode at: 0x" + 3178 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3179 moveToEnd(); 3180 return; 3181 } 3182 DEBUG_WITH_TYPE( 3183 "mach-o-rebase", 3184 dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: " 3185 << "SegmentIndex=" << SegmentIndex << ", " 3186 << format("SegmentOffset=0x%06X", SegmentOffset) 3187 << "\n"); 3188 break; 3189 case MachO::REBASE_OPCODE_ADD_ADDR_ULEB: 3190 SegmentOffset += readULEB128(&error); 3191 if (error) { 3192 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) + 3193 " for opcode at: 0x" + 3194 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3195 moveToEnd(); 3196 return; 3197 } 3198 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3199 PointerSize); 3200 if (error) { 3201 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) + 3202 " for opcode at: 0x" + 3203 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3204 moveToEnd(); 3205 return; 3206 } 3207 DEBUG_WITH_TYPE("mach-o-rebase", 3208 dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: " 3209 << format("SegmentOffset=0x%06X", 3210 SegmentOffset) << "\n"); 3211 break; 3212 case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED: 3213 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3214 PointerSize); 3215 if (error) { 3216 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED " + 3217 Twine(error) + " for opcode at: 0x" + 3218 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3219 moveToEnd(); 3220 return; 3221 } 3222 SegmentOffset += ImmValue * PointerSize; 3223 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3224 PointerSize); 3225 if (error) { 3226 *E = 3227 malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED " 3228 " (after adding immediate times the pointer size) " + 3229 Twine(error) + " for opcode at: 0x" + 3230 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3231 moveToEnd(); 3232 return; 3233 } 3234 DEBUG_WITH_TYPE("mach-o-rebase", 3235 dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: " 3236 << format("SegmentOffset=0x%06X", 3237 SegmentOffset) << "\n"); 3238 break; 3239 case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES: 3240 AdvanceAmount = PointerSize; 3241 Skip = 0; 3242 Count = ImmValue; 3243 if (ImmValue != 0) 3244 RemainingLoopCount = ImmValue - 1; 3245 else 3246 RemainingLoopCount = 0; 3247 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3248 PointerSize, Count, Skip); 3249 if (error) { 3250 *E = malformedError("for REBASE_OPCODE_DO_REBASE_IMM_TIMES " + 3251 Twine(error) + " for opcode at: 0x" + 3252 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3253 moveToEnd(); 3254 return; 3255 } 3256 DEBUG_WITH_TYPE( 3257 "mach-o-rebase", 3258 dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: " 3259 << format("SegmentOffset=0x%06X", SegmentOffset) 3260 << ", AdvanceAmount=" << AdvanceAmount 3261 << ", RemainingLoopCount=" << RemainingLoopCount 3262 << "\n"); 3263 return; 3264 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES: 3265 AdvanceAmount = PointerSize; 3266 Skip = 0; 3267 Count = readULEB128(&error); 3268 if (error) { 3269 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " + 3270 Twine(error) + " for opcode at: 0x" + 3271 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3272 moveToEnd(); 3273 return; 3274 } 3275 if (Count != 0) 3276 RemainingLoopCount = Count - 1; 3277 else 3278 RemainingLoopCount = 0; 3279 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3280 PointerSize, Count, Skip); 3281 if (error) { 3282 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " + 3283 Twine(error) + " for opcode at: 0x" + 3284 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3285 moveToEnd(); 3286 return; 3287 } 3288 DEBUG_WITH_TYPE( 3289 "mach-o-rebase", 3290 dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: " 3291 << format("SegmentOffset=0x%06X", SegmentOffset) 3292 << ", AdvanceAmount=" << AdvanceAmount 3293 << ", RemainingLoopCount=" << RemainingLoopCount 3294 << "\n"); 3295 return; 3296 case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: 3297 Skip = readULEB128(&error); 3298 if (error) { 3299 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " + 3300 Twine(error) + " for opcode at: 0x" + 3301 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3302 moveToEnd(); 3303 return; 3304 } 3305 AdvanceAmount = Skip + PointerSize; 3306 Count = 1; 3307 RemainingLoopCount = 0; 3308 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3309 PointerSize, Count, Skip); 3310 if (error) { 3311 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " + 3312 Twine(error) + " for opcode at: 0x" + 3313 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3314 moveToEnd(); 3315 return; 3316 } 3317 DEBUG_WITH_TYPE( 3318 "mach-o-rebase", 3319 dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: " 3320 << format("SegmentOffset=0x%06X", SegmentOffset) 3321 << ", AdvanceAmount=" << AdvanceAmount 3322 << ", RemainingLoopCount=" << RemainingLoopCount 3323 << "\n"); 3324 return; 3325 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: 3326 Count = readULEB128(&error); 3327 if (error) { 3328 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_" 3329 "ULEB " + 3330 Twine(error) + " for opcode at: 0x" + 3331 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3332 moveToEnd(); 3333 return; 3334 } 3335 if (Count != 0) 3336 RemainingLoopCount = Count - 1; 3337 else 3338 RemainingLoopCount = 0; 3339 Skip = readULEB128(&error); 3340 if (error) { 3341 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_" 3342 "ULEB " + 3343 Twine(error) + " for opcode at: 0x" + 3344 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3345 moveToEnd(); 3346 return; 3347 } 3348 AdvanceAmount = Skip + PointerSize; 3349 3350 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3351 PointerSize, Count, Skip); 3352 if (error) { 3353 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_" 3354 "ULEB " + 3355 Twine(error) + " for opcode at: 0x" + 3356 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3357 moveToEnd(); 3358 return; 3359 } 3360 DEBUG_WITH_TYPE( 3361 "mach-o-rebase", 3362 dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: " 3363 << format("SegmentOffset=0x%06X", SegmentOffset) 3364 << ", AdvanceAmount=" << AdvanceAmount 3365 << ", RemainingLoopCount=" << RemainingLoopCount 3366 << "\n"); 3367 return; 3368 default: 3369 *E = malformedError("bad rebase info (bad opcode value 0x" + 3370 Twine::utohexstr(Opcode) + " for opcode at: 0x" + 3371 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3372 moveToEnd(); 3373 return; 3374 } 3375 } 3376 } 3377 3378 uint64_t MachORebaseEntry::readULEB128(const char **error) { 3379 unsigned Count; 3380 uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error); 3381 Ptr += Count; 3382 if (Ptr > Opcodes.end()) 3383 Ptr = Opcodes.end(); 3384 return Result; 3385 } 3386 3387 int32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; } 3388 3389 uint64_t MachORebaseEntry::segmentOffset() const { return SegmentOffset; } 3390 3391 StringRef MachORebaseEntry::typeName() const { 3392 switch (RebaseType) { 3393 case MachO::REBASE_TYPE_POINTER: 3394 return "pointer"; 3395 case MachO::REBASE_TYPE_TEXT_ABSOLUTE32: 3396 return "text abs32"; 3397 case MachO::REBASE_TYPE_TEXT_PCREL32: 3398 return "text rel32"; 3399 } 3400 return "unknown"; 3401 } 3402 3403 // For use with the SegIndex of a checked Mach-O Rebase entry 3404 // to get the segment name. 3405 StringRef MachORebaseEntry::segmentName() const { 3406 return O->BindRebaseSegmentName(SegmentIndex); 3407 } 3408 3409 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry 3410 // to get the section name. 3411 StringRef MachORebaseEntry::sectionName() const { 3412 return O->BindRebaseSectionName(SegmentIndex, SegmentOffset); 3413 } 3414 3415 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry 3416 // to get the address. 3417 uint64_t MachORebaseEntry::address() const { 3418 return O->BindRebaseAddress(SegmentIndex, SegmentOffset); 3419 } 3420 3421 bool MachORebaseEntry::operator==(const MachORebaseEntry &Other) const { 3422 #ifdef EXPENSIVE_CHECKS 3423 assert(Opcodes == Other.Opcodes && "compare iterators of different files"); 3424 #else 3425 assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files"); 3426 #endif 3427 return (Ptr == Other.Ptr) && 3428 (RemainingLoopCount == Other.RemainingLoopCount) && 3429 (Done == Other.Done); 3430 } 3431 3432 iterator_range<rebase_iterator> 3433 MachOObjectFile::rebaseTable(Error &Err, MachOObjectFile *O, 3434 ArrayRef<uint8_t> Opcodes, bool is64) { 3435 if (O->BindRebaseSectionTable == nullptr) 3436 O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O); 3437 MachORebaseEntry Start(&Err, O, Opcodes, is64); 3438 Start.moveToFirst(); 3439 3440 MachORebaseEntry Finish(&Err, O, Opcodes, is64); 3441 Finish.moveToEnd(); 3442 3443 return make_range(rebase_iterator(Start), rebase_iterator(Finish)); 3444 } 3445 3446 iterator_range<rebase_iterator> MachOObjectFile::rebaseTable(Error &Err) { 3447 return rebaseTable(Err, this, getDyldInfoRebaseOpcodes(), is64Bit()); 3448 } 3449 3450 MachOBindEntry::MachOBindEntry(Error *E, const MachOObjectFile *O, 3451 ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK) 3452 : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()), 3453 PointerSize(is64Bit ? 8 : 4), TableKind(BK) {} 3454 3455 void MachOBindEntry::moveToFirst() { 3456 Ptr = Opcodes.begin(); 3457 moveNext(); 3458 } 3459 3460 void MachOBindEntry::moveToEnd() { 3461 Ptr = Opcodes.end(); 3462 RemainingLoopCount = 0; 3463 Done = true; 3464 } 3465 3466 void MachOBindEntry::moveNext() { 3467 ErrorAsOutParameter ErrAsOutParam(E); 3468 // If in the middle of some loop, move to next binding in loop. 3469 SegmentOffset += AdvanceAmount; 3470 if (RemainingLoopCount) { 3471 --RemainingLoopCount; 3472 return; 3473 } 3474 // BIND_OPCODE_DONE is only used for padding if we are not aligned to 3475 // pointer size. Therefore it is possible to reach the end without ever having 3476 // seen BIND_OPCODE_DONE. 3477 if (Ptr == Opcodes.end()) { 3478 Done = true; 3479 return; 3480 } 3481 bool More = true; 3482 while (More) { 3483 // Parse next opcode and set up next loop. 3484 const uint8_t *OpcodeStart = Ptr; 3485 uint8_t Byte = *Ptr++; 3486 uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK; 3487 uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK; 3488 int8_t SignExtended; 3489 const uint8_t *SymStart; 3490 uint32_t Count, Skip; 3491 const char *error = nullptr; 3492 switch (Opcode) { 3493 case MachO::BIND_OPCODE_DONE: 3494 if (TableKind == Kind::Lazy) { 3495 // Lazying bindings have a DONE opcode between entries. Need to ignore 3496 // it to advance to next entry. But need not if this is last entry. 3497 bool NotLastEntry = false; 3498 for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) { 3499 if (*P) { 3500 NotLastEntry = true; 3501 } 3502 } 3503 if (NotLastEntry) 3504 break; 3505 } 3506 More = false; 3507 moveToEnd(); 3508 DEBUG_WITH_TYPE("mach-o-bind", dbgs() << "BIND_OPCODE_DONE\n"); 3509 break; 3510 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: 3511 if (TableKind == Kind::Weak) { 3512 *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_IMM not allowed in " 3513 "weak bind table for opcode at: 0x" + 3514 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3515 moveToEnd(); 3516 return; 3517 } 3518 Ordinal = ImmValue; 3519 LibraryOrdinalSet = true; 3520 if (ImmValue > O->getLibraryCount()) { 3521 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad " 3522 "library ordinal: " + 3523 Twine((int)ImmValue) + " (max " + 3524 Twine((int)O->getLibraryCount()) + 3525 ") for opcode at: 0x" + 3526 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3527 moveToEnd(); 3528 return; 3529 } 3530 DEBUG_WITH_TYPE( 3531 "mach-o-bind", 3532 dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: " 3533 << "Ordinal=" << Ordinal << "\n"); 3534 break; 3535 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: 3536 if (TableKind == Kind::Weak) { 3537 *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB not allowed in " 3538 "weak bind table for opcode at: 0x" + 3539 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3540 moveToEnd(); 3541 return; 3542 } 3543 Ordinal = readULEB128(&error); 3544 LibraryOrdinalSet = true; 3545 if (error) { 3546 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB " + 3547 Twine(error) + " for opcode at: 0x" + 3548 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3549 moveToEnd(); 3550 return; 3551 } 3552 if (Ordinal > (int)O->getLibraryCount()) { 3553 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad " 3554 "library ordinal: " + 3555 Twine((int)Ordinal) + " (max " + 3556 Twine((int)O->getLibraryCount()) + 3557 ") for opcode at: 0x" + 3558 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3559 moveToEnd(); 3560 return; 3561 } 3562 DEBUG_WITH_TYPE( 3563 "mach-o-bind", 3564 dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: " 3565 << "Ordinal=" << Ordinal << "\n"); 3566 break; 3567 case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: 3568 if (TableKind == Kind::Weak) { 3569 *E = malformedError("BIND_OPCODE_SET_DYLIB_SPECIAL_IMM not allowed in " 3570 "weak bind table for opcode at: 0x" + 3571 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3572 moveToEnd(); 3573 return; 3574 } 3575 if (ImmValue) { 3576 SignExtended = MachO::BIND_OPCODE_MASK | ImmValue; 3577 Ordinal = SignExtended; 3578 if (Ordinal < MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP) { 3579 *E = malformedError("for BIND_OPCODE_SET_DYLIB_SPECIAL_IMM unknown " 3580 "special ordinal: " + 3581 Twine((int)Ordinal) + " for opcode at: 0x" + 3582 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3583 moveToEnd(); 3584 return; 3585 } 3586 } else 3587 Ordinal = 0; 3588 LibraryOrdinalSet = true; 3589 DEBUG_WITH_TYPE( 3590 "mach-o-bind", 3591 dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: " 3592 << "Ordinal=" << Ordinal << "\n"); 3593 break; 3594 case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: 3595 Flags = ImmValue; 3596 SymStart = Ptr; 3597 while (*Ptr && (Ptr < Opcodes.end())) { 3598 ++Ptr; 3599 } 3600 if (Ptr == Opcodes.end()) { 3601 *E = malformedError( 3602 "for BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM " 3603 "symbol name extends past opcodes for opcode at: 0x" + 3604 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3605 moveToEnd(); 3606 return; 3607 } 3608 SymbolName = StringRef(reinterpret_cast<const char*>(SymStart), 3609 Ptr-SymStart); 3610 ++Ptr; 3611 DEBUG_WITH_TYPE( 3612 "mach-o-bind", 3613 dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: " 3614 << "SymbolName=" << SymbolName << "\n"); 3615 if (TableKind == Kind::Weak) { 3616 if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION) 3617 return; 3618 } 3619 break; 3620 case MachO::BIND_OPCODE_SET_TYPE_IMM: 3621 BindType = ImmValue; 3622 if (ImmValue > MachO::BIND_TYPE_TEXT_PCREL32) { 3623 *E = malformedError("for BIND_OPCODE_SET_TYPE_IMM bad bind type: " + 3624 Twine((int)ImmValue) + " for opcode at: 0x" + 3625 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3626 moveToEnd(); 3627 return; 3628 } 3629 DEBUG_WITH_TYPE( 3630 "mach-o-bind", 3631 dbgs() << "BIND_OPCODE_SET_TYPE_IMM: " 3632 << "BindType=" << (int)BindType << "\n"); 3633 break; 3634 case MachO::BIND_OPCODE_SET_ADDEND_SLEB: 3635 Addend = readSLEB128(&error); 3636 if (error) { 3637 *E = malformedError("for BIND_OPCODE_SET_ADDEND_SLEB " + Twine(error) + 3638 " for opcode at: 0x" + 3639 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3640 moveToEnd(); 3641 return; 3642 } 3643 DEBUG_WITH_TYPE( 3644 "mach-o-bind", 3645 dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: " 3646 << "Addend=" << Addend << "\n"); 3647 break; 3648 case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: 3649 SegmentIndex = ImmValue; 3650 SegmentOffset = readULEB128(&error); 3651 if (error) { 3652 *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " + 3653 Twine(error) + " for opcode at: 0x" + 3654 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3655 moveToEnd(); 3656 return; 3657 } 3658 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3659 PointerSize); 3660 if (error) { 3661 *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " + 3662 Twine(error) + " for opcode at: 0x" + 3663 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3664 moveToEnd(); 3665 return; 3666 } 3667 DEBUG_WITH_TYPE( 3668 "mach-o-bind", 3669 dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: " 3670 << "SegmentIndex=" << SegmentIndex << ", " 3671 << format("SegmentOffset=0x%06X", SegmentOffset) 3672 << "\n"); 3673 break; 3674 case MachO::BIND_OPCODE_ADD_ADDR_ULEB: 3675 SegmentOffset += readULEB128(&error); 3676 if (error) { 3677 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) + 3678 " for opcode at: 0x" + 3679 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3680 moveToEnd(); 3681 return; 3682 } 3683 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3684 PointerSize); 3685 if (error) { 3686 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) + 3687 " for opcode at: 0x" + 3688 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3689 moveToEnd(); 3690 return; 3691 } 3692 DEBUG_WITH_TYPE("mach-o-bind", 3693 dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: " 3694 << format("SegmentOffset=0x%06X", 3695 SegmentOffset) << "\n"); 3696 break; 3697 case MachO::BIND_OPCODE_DO_BIND: 3698 AdvanceAmount = PointerSize; 3699 RemainingLoopCount = 0; 3700 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3701 PointerSize); 3702 if (error) { 3703 *E = malformedError("for BIND_OPCODE_DO_BIND " + Twine(error) + 3704 " for opcode at: 0x" + 3705 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3706 moveToEnd(); 3707 return; 3708 } 3709 if (SymbolName == StringRef()) { 3710 *E = malformedError( 3711 "for BIND_OPCODE_DO_BIND missing preceding " 3712 "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode at: 0x" + 3713 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3714 moveToEnd(); 3715 return; 3716 } 3717 if (!LibraryOrdinalSet && TableKind != Kind::Weak) { 3718 *E = 3719 malformedError("for BIND_OPCODE_DO_BIND missing preceding " 3720 "BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" + 3721 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3722 moveToEnd(); 3723 return; 3724 } 3725 DEBUG_WITH_TYPE("mach-o-bind", 3726 dbgs() << "BIND_OPCODE_DO_BIND: " 3727 << format("SegmentOffset=0x%06X", 3728 SegmentOffset) << "\n"); 3729 return; 3730 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: 3731 if (TableKind == Kind::Lazy) { 3732 *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB not allowed in " 3733 "lazy bind table for opcode at: 0x" + 3734 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3735 moveToEnd(); 3736 return; 3737 } 3738 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3739 PointerSize); 3740 if (error) { 3741 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " + 3742 Twine(error) + " for opcode at: 0x" + 3743 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3744 moveToEnd(); 3745 return; 3746 } 3747 if (SymbolName == StringRef()) { 3748 *E = malformedError( 3749 "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing " 3750 "preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode " 3751 "at: 0x" + 3752 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3753 moveToEnd(); 3754 return; 3755 } 3756 if (!LibraryOrdinalSet && TableKind != Kind::Weak) { 3757 *E = malformedError( 3758 "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing " 3759 "preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" + 3760 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3761 moveToEnd(); 3762 return; 3763 } 3764 AdvanceAmount = readULEB128(&error) + PointerSize; 3765 if (error) { 3766 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " + 3767 Twine(error) + " for opcode at: 0x" + 3768 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3769 moveToEnd(); 3770 return; 3771 } 3772 // Note, this is not really an error until the next bind but make no sense 3773 // for a BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB to not be followed by another 3774 // bind operation. 3775 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset + 3776 AdvanceAmount, PointerSize); 3777 if (error) { 3778 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB (after adding " 3779 "ULEB) " + 3780 Twine(error) + " for opcode at: 0x" + 3781 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3782 moveToEnd(); 3783 return; 3784 } 3785 RemainingLoopCount = 0; 3786 DEBUG_WITH_TYPE( 3787 "mach-o-bind", 3788 dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: " 3789 << format("SegmentOffset=0x%06X", SegmentOffset) 3790 << ", AdvanceAmount=" << AdvanceAmount 3791 << ", RemainingLoopCount=" << RemainingLoopCount 3792 << "\n"); 3793 return; 3794 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: 3795 if (TableKind == Kind::Lazy) { 3796 *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED not " 3797 "allowed in lazy bind table for opcode at: 0x" + 3798 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3799 moveToEnd(); 3800 return; 3801 } 3802 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3803 PointerSize); 3804 if (error) { 3805 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " + 3806 Twine(error) + " for opcode at: 0x" + 3807 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3808 moveToEnd(); 3809 return; 3810 } 3811 if (SymbolName == StringRef()) { 3812 *E = malformedError( 3813 "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " 3814 "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for " 3815 "opcode at: 0x" + 3816 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3817 moveToEnd(); 3818 return; 3819 } 3820 if (!LibraryOrdinalSet && TableKind != Kind::Weak) { 3821 *E = malformedError( 3822 "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " 3823 "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode " 3824 "at: 0x" + 3825 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3826 moveToEnd(); 3827 return; 3828 } 3829 AdvanceAmount = ImmValue * PointerSize + PointerSize; 3830 RemainingLoopCount = 0; 3831 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset + 3832 AdvanceAmount, PointerSize); 3833 if (error) { 3834 *E = 3835 malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " 3836 " (after adding immediate times the pointer size) " + 3837 Twine(error) + " for opcode at: 0x" + 3838 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3839 moveToEnd(); 3840 return; 3841 } 3842 DEBUG_WITH_TYPE("mach-o-bind", 3843 dbgs() 3844 << "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: " 3845 << format("SegmentOffset=0x%06X", SegmentOffset) << "\n"); 3846 return; 3847 case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: 3848 if (TableKind == Kind::Lazy) { 3849 *E = malformedError("BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB not " 3850 "allowed in lazy bind table for opcode at: 0x" + 3851 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3852 moveToEnd(); 3853 return; 3854 } 3855 Count = readULEB128(&error); 3856 if (Count != 0) 3857 RemainingLoopCount = Count - 1; 3858 else 3859 RemainingLoopCount = 0; 3860 if (error) { 3861 *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " 3862 " (count value) " + 3863 Twine(error) + " for opcode at: 0x" + 3864 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3865 moveToEnd(); 3866 return; 3867 } 3868 Skip = readULEB128(&error); 3869 AdvanceAmount = Skip + PointerSize; 3870 if (error) { 3871 *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " 3872 " (skip value) " + 3873 Twine(error) + " for opcode at: 0x" + 3874 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3875 moveToEnd(); 3876 return; 3877 } 3878 if (SymbolName == StringRef()) { 3879 *E = malformedError( 3880 "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " 3881 "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for " 3882 "opcode at: 0x" + 3883 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3884 moveToEnd(); 3885 return; 3886 } 3887 if (!LibraryOrdinalSet && TableKind != Kind::Weak) { 3888 *E = malformedError( 3889 "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " 3890 "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode " 3891 "at: 0x" + 3892 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3893 moveToEnd(); 3894 return; 3895 } 3896 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset, 3897 PointerSize, Count, Skip); 3898 if (error) { 3899 *E = 3900 malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " + 3901 Twine(error) + " for opcode at: 0x" + 3902 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3903 moveToEnd(); 3904 return; 3905 } 3906 DEBUG_WITH_TYPE( 3907 "mach-o-bind", 3908 dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: " 3909 << format("SegmentOffset=0x%06X", SegmentOffset) 3910 << ", AdvanceAmount=" << AdvanceAmount 3911 << ", RemainingLoopCount=" << RemainingLoopCount 3912 << "\n"); 3913 return; 3914 default: 3915 *E = malformedError("bad bind info (bad opcode value 0x" + 3916 Twine::utohexstr(Opcode) + " for opcode at: 0x" + 3917 Twine::utohexstr(OpcodeStart - Opcodes.begin())); 3918 moveToEnd(); 3919 return; 3920 } 3921 } 3922 } 3923 3924 uint64_t MachOBindEntry::readULEB128(const char **error) { 3925 unsigned Count; 3926 uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error); 3927 Ptr += Count; 3928 if (Ptr > Opcodes.end()) 3929 Ptr = Opcodes.end(); 3930 return Result; 3931 } 3932 3933 int64_t MachOBindEntry::readSLEB128(const char **error) { 3934 unsigned Count; 3935 int64_t Result = decodeSLEB128(Ptr, &Count, Opcodes.end(), error); 3936 Ptr += Count; 3937 if (Ptr > Opcodes.end()) 3938 Ptr = Opcodes.end(); 3939 return Result; 3940 } 3941 3942 int32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; } 3943 3944 uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; } 3945 3946 StringRef MachOBindEntry::typeName() const { 3947 switch (BindType) { 3948 case MachO::BIND_TYPE_POINTER: 3949 return "pointer"; 3950 case MachO::BIND_TYPE_TEXT_ABSOLUTE32: 3951 return "text abs32"; 3952 case MachO::BIND_TYPE_TEXT_PCREL32: 3953 return "text rel32"; 3954 } 3955 return "unknown"; 3956 } 3957 3958 StringRef MachOBindEntry::symbolName() const { return SymbolName; } 3959 3960 int64_t MachOBindEntry::addend() const { return Addend; } 3961 3962 uint32_t MachOBindEntry::flags() const { return Flags; } 3963 3964 int MachOBindEntry::ordinal() const { return Ordinal; } 3965 3966 // For use with the SegIndex of a checked Mach-O Bind entry 3967 // to get the segment name. 3968 StringRef MachOBindEntry::segmentName() const { 3969 return O->BindRebaseSegmentName(SegmentIndex); 3970 } 3971 3972 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry 3973 // to get the section name. 3974 StringRef MachOBindEntry::sectionName() const { 3975 return O->BindRebaseSectionName(SegmentIndex, SegmentOffset); 3976 } 3977 3978 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry 3979 // to get the address. 3980 uint64_t MachOBindEntry::address() const { 3981 return O->BindRebaseAddress(SegmentIndex, SegmentOffset); 3982 } 3983 3984 bool MachOBindEntry::operator==(const MachOBindEntry &Other) const { 3985 #ifdef EXPENSIVE_CHECKS 3986 assert(Opcodes == Other.Opcodes && "compare iterators of different files"); 3987 #else 3988 assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files"); 3989 #endif 3990 return (Ptr == Other.Ptr) && 3991 (RemainingLoopCount == Other.RemainingLoopCount) && 3992 (Done == Other.Done); 3993 } 3994 3995 // Build table of sections so SegIndex/SegOffset pairs can be translated. 3996 BindRebaseSegInfo::BindRebaseSegInfo(const object::MachOObjectFile *Obj) { 3997 uint32_t CurSegIndex = Obj->hasPageZeroSegment() ? 1 : 0; 3998 StringRef CurSegName; 3999 uint64_t CurSegAddress; 4000 for (const SectionRef &Section : Obj->sections()) { 4001 SectionInfo Info; 4002 Expected<StringRef> NameOrErr = Section.getName(); 4003 if (!NameOrErr) 4004 consumeError(NameOrErr.takeError()); 4005 else 4006 Info.SectionName = *NameOrErr; 4007 Info.Address = Section.getAddress(); 4008 Info.Size = Section.getSize(); 4009 Info.SegmentName = 4010 Obj->getSectionFinalSegmentName(Section.getRawDataRefImpl()); 4011 if (!Info.SegmentName.equals(CurSegName)) { 4012 ++CurSegIndex; 4013 CurSegName = Info.SegmentName; 4014 CurSegAddress = Info.Address; 4015 } 4016 Info.SegmentIndex = CurSegIndex - 1; 4017 Info.OffsetInSegment = Info.Address - CurSegAddress; 4018 Info.SegmentStartAddress = CurSegAddress; 4019 Sections.push_back(Info); 4020 } 4021 MaxSegIndex = CurSegIndex; 4022 } 4023 4024 // For use with a SegIndex, SegOffset, and PointerSize triple in 4025 // MachOBindEntry::moveNext() to validate a MachOBindEntry or MachORebaseEntry. 4026 // 4027 // Given a SegIndex, SegOffset, and PointerSize, verify a valid section exists 4028 // that fully contains a pointer at that location. Multiple fixups in a bind 4029 // (such as with the BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB opcode) can 4030 // be tested via the Count and Skip parameters. 4031 const char * BindRebaseSegInfo::checkSegAndOffsets(int32_t SegIndex, 4032 uint64_t SegOffset, 4033 uint8_t PointerSize, 4034 uint32_t Count, 4035 uint32_t Skip) { 4036 if (SegIndex == -1) 4037 return "missing preceding *_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB"; 4038 if (SegIndex >= MaxSegIndex) 4039 return "bad segIndex (too large)"; 4040 for (uint32_t i = 0; i < Count; ++i) { 4041 uint32_t Start = SegOffset + i * (PointerSize + Skip); 4042 uint32_t End = Start + PointerSize; 4043 bool Found = false; 4044 for (const SectionInfo &SI : Sections) { 4045 if (SI.SegmentIndex != SegIndex) 4046 continue; 4047 if ((SI.OffsetInSegment<=Start) && (Start<(SI.OffsetInSegment+SI.Size))) { 4048 if (End <= SI.OffsetInSegment + SI.Size) { 4049 Found = true; 4050 break; 4051 } 4052 else 4053 return "bad offset, extends beyond section boundary"; 4054 } 4055 } 4056 if (!Found) 4057 return "bad offset, not in section"; 4058 } 4059 return nullptr; 4060 } 4061 4062 // For use with the SegIndex of a checked Mach-O Bind or Rebase entry 4063 // to get the segment name. 4064 StringRef BindRebaseSegInfo::segmentName(int32_t SegIndex) { 4065 for (const SectionInfo &SI : Sections) { 4066 if (SI.SegmentIndex == SegIndex) 4067 return SI.SegmentName; 4068 } 4069 llvm_unreachable("invalid SegIndex"); 4070 } 4071 4072 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase 4073 // to get the SectionInfo. 4074 const BindRebaseSegInfo::SectionInfo &BindRebaseSegInfo::findSection( 4075 int32_t SegIndex, uint64_t SegOffset) { 4076 for (const SectionInfo &SI : Sections) { 4077 if (SI.SegmentIndex != SegIndex) 4078 continue; 4079 if (SI.OffsetInSegment > SegOffset) 4080 continue; 4081 if (SegOffset >= (SI.OffsetInSegment + SI.Size)) 4082 continue; 4083 return SI; 4084 } 4085 llvm_unreachable("SegIndex and SegOffset not in any section"); 4086 } 4087 4088 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase 4089 // entry to get the section name. 4090 StringRef BindRebaseSegInfo::sectionName(int32_t SegIndex, 4091 uint64_t SegOffset) { 4092 return findSection(SegIndex, SegOffset).SectionName; 4093 } 4094 4095 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase 4096 // entry to get the address. 4097 uint64_t BindRebaseSegInfo::address(uint32_t SegIndex, uint64_t OffsetInSeg) { 4098 const SectionInfo &SI = findSection(SegIndex, OffsetInSeg); 4099 return SI.SegmentStartAddress + OffsetInSeg; 4100 } 4101 4102 iterator_range<bind_iterator> 4103 MachOObjectFile::bindTable(Error &Err, MachOObjectFile *O, 4104 ArrayRef<uint8_t> Opcodes, bool is64, 4105 MachOBindEntry::Kind BKind) { 4106 if (O->BindRebaseSectionTable == nullptr) 4107 O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O); 4108 MachOBindEntry Start(&Err, O, Opcodes, is64, BKind); 4109 Start.moveToFirst(); 4110 4111 MachOBindEntry Finish(&Err, O, Opcodes, is64, BKind); 4112 Finish.moveToEnd(); 4113 4114 return make_range(bind_iterator(Start), bind_iterator(Finish)); 4115 } 4116 4117 iterator_range<bind_iterator> MachOObjectFile::bindTable(Error &Err) { 4118 return bindTable(Err, this, getDyldInfoBindOpcodes(), is64Bit(), 4119 MachOBindEntry::Kind::Regular); 4120 } 4121 4122 iterator_range<bind_iterator> MachOObjectFile::lazyBindTable(Error &Err) { 4123 return bindTable(Err, this, getDyldInfoLazyBindOpcodes(), is64Bit(), 4124 MachOBindEntry::Kind::Lazy); 4125 } 4126 4127 iterator_range<bind_iterator> MachOObjectFile::weakBindTable(Error &Err) { 4128 return bindTable(Err, this, getDyldInfoWeakBindOpcodes(), is64Bit(), 4129 MachOBindEntry::Kind::Weak); 4130 } 4131 4132 MachOObjectFile::load_command_iterator 4133 MachOObjectFile::begin_load_commands() const { 4134 return LoadCommands.begin(); 4135 } 4136 4137 MachOObjectFile::load_command_iterator 4138 MachOObjectFile::end_load_commands() const { 4139 return LoadCommands.end(); 4140 } 4141 4142 iterator_range<MachOObjectFile::load_command_iterator> 4143 MachOObjectFile::load_commands() const { 4144 return make_range(begin_load_commands(), end_load_commands()); 4145 } 4146 4147 StringRef 4148 MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const { 4149 ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec); 4150 return parseSegmentOrSectionName(Raw.data()); 4151 } 4152 4153 ArrayRef<char> 4154 MachOObjectFile::getSectionRawName(DataRefImpl Sec) const { 4155 assert(Sec.d.a < Sections.size() && "Should have detected this earlier"); 4156 const section_base *Base = 4157 reinterpret_cast<const section_base *>(Sections[Sec.d.a]); 4158 return makeArrayRef(Base->sectname); 4159 } 4160 4161 ArrayRef<char> 4162 MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const { 4163 assert(Sec.d.a < Sections.size() && "Should have detected this earlier"); 4164 const section_base *Base = 4165 reinterpret_cast<const section_base *>(Sections[Sec.d.a]); 4166 return makeArrayRef(Base->segname); 4167 } 4168 4169 bool 4170 MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE) 4171 const { 4172 if (getCPUType(*this) == MachO::CPU_TYPE_X86_64) 4173 return false; 4174 return getPlainRelocationAddress(RE) & MachO::R_SCATTERED; 4175 } 4176 4177 unsigned MachOObjectFile::getPlainRelocationSymbolNum( 4178 const MachO::any_relocation_info &RE) const { 4179 if (isLittleEndian()) 4180 return RE.r_word1 & 0xffffff; 4181 return RE.r_word1 >> 8; 4182 } 4183 4184 bool MachOObjectFile::getPlainRelocationExternal( 4185 const MachO::any_relocation_info &RE) const { 4186 if (isLittleEndian()) 4187 return (RE.r_word1 >> 27) & 1; 4188 return (RE.r_word1 >> 4) & 1; 4189 } 4190 4191 bool MachOObjectFile::getScatteredRelocationScattered( 4192 const MachO::any_relocation_info &RE) const { 4193 return RE.r_word0 >> 31; 4194 } 4195 4196 uint32_t MachOObjectFile::getScatteredRelocationValue( 4197 const MachO::any_relocation_info &RE) const { 4198 return RE.r_word1; 4199 } 4200 4201 uint32_t MachOObjectFile::getScatteredRelocationType( 4202 const MachO::any_relocation_info &RE) const { 4203 return (RE.r_word0 >> 24) & 0xf; 4204 } 4205 4206 unsigned MachOObjectFile::getAnyRelocationAddress( 4207 const MachO::any_relocation_info &RE) const { 4208 if (isRelocationScattered(RE)) 4209 return getScatteredRelocationAddress(RE); 4210 return getPlainRelocationAddress(RE); 4211 } 4212 4213 unsigned MachOObjectFile::getAnyRelocationPCRel( 4214 const MachO::any_relocation_info &RE) const { 4215 if (isRelocationScattered(RE)) 4216 return getScatteredRelocationPCRel(RE); 4217 return getPlainRelocationPCRel(*this, RE); 4218 } 4219 4220 unsigned MachOObjectFile::getAnyRelocationLength( 4221 const MachO::any_relocation_info &RE) const { 4222 if (isRelocationScattered(RE)) 4223 return getScatteredRelocationLength(RE); 4224 return getPlainRelocationLength(*this, RE); 4225 } 4226 4227 unsigned 4228 MachOObjectFile::getAnyRelocationType( 4229 const MachO::any_relocation_info &RE) const { 4230 if (isRelocationScattered(RE)) 4231 return getScatteredRelocationType(RE); 4232 return getPlainRelocationType(*this, RE); 4233 } 4234 4235 SectionRef 4236 MachOObjectFile::getAnyRelocationSection( 4237 const MachO::any_relocation_info &RE) const { 4238 if (isRelocationScattered(RE) || getPlainRelocationExternal(RE)) 4239 return *section_end(); 4240 unsigned SecNum = getPlainRelocationSymbolNum(RE); 4241 if (SecNum == MachO::R_ABS || SecNum > Sections.size()) 4242 return *section_end(); 4243 DataRefImpl DRI; 4244 DRI.d.a = SecNum - 1; 4245 return SectionRef(DRI, this); 4246 } 4247 4248 MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const { 4249 assert(DRI.d.a < Sections.size() && "Should have detected this earlier"); 4250 return getStruct<MachO::section>(*this, Sections[DRI.d.a]); 4251 } 4252 4253 MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const { 4254 assert(DRI.d.a < Sections.size() && "Should have detected this earlier"); 4255 return getStruct<MachO::section_64>(*this, Sections[DRI.d.a]); 4256 } 4257 4258 MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L, 4259 unsigned Index) const { 4260 const char *Sec = getSectionPtr(*this, L, Index); 4261 return getStruct<MachO::section>(*this, Sec); 4262 } 4263 4264 MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L, 4265 unsigned Index) const { 4266 const char *Sec = getSectionPtr(*this, L, Index); 4267 return getStruct<MachO::section_64>(*this, Sec); 4268 } 4269 4270 MachO::nlist 4271 MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const { 4272 const char *P = reinterpret_cast<const char *>(DRI.p); 4273 return getStruct<MachO::nlist>(*this, P); 4274 } 4275 4276 MachO::nlist_64 4277 MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const { 4278 const char *P = reinterpret_cast<const char *>(DRI.p); 4279 return getStruct<MachO::nlist_64>(*this, P); 4280 } 4281 4282 MachO::linkedit_data_command 4283 MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const { 4284 return getStruct<MachO::linkedit_data_command>(*this, L.Ptr); 4285 } 4286 4287 MachO::segment_command 4288 MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const { 4289 return getStruct<MachO::segment_command>(*this, L.Ptr); 4290 } 4291 4292 MachO::segment_command_64 4293 MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const { 4294 return getStruct<MachO::segment_command_64>(*this, L.Ptr); 4295 } 4296 4297 MachO::linker_option_command 4298 MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const { 4299 return getStruct<MachO::linker_option_command>(*this, L.Ptr); 4300 } 4301 4302 MachO::version_min_command 4303 MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const { 4304 return getStruct<MachO::version_min_command>(*this, L.Ptr); 4305 } 4306 4307 MachO::note_command 4308 MachOObjectFile::getNoteLoadCommand(const LoadCommandInfo &L) const { 4309 return getStruct<MachO::note_command>(*this, L.Ptr); 4310 } 4311 4312 MachO::build_version_command 4313 MachOObjectFile::getBuildVersionLoadCommand(const LoadCommandInfo &L) const { 4314 return getStruct<MachO::build_version_command>(*this, L.Ptr); 4315 } 4316 4317 MachO::build_tool_version 4318 MachOObjectFile::getBuildToolVersion(unsigned index) const { 4319 return getStruct<MachO::build_tool_version>(*this, BuildTools[index]); 4320 } 4321 4322 MachO::dylib_command 4323 MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const { 4324 return getStruct<MachO::dylib_command>(*this, L.Ptr); 4325 } 4326 4327 MachO::dyld_info_command 4328 MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const { 4329 return getStruct<MachO::dyld_info_command>(*this, L.Ptr); 4330 } 4331 4332 MachO::dylinker_command 4333 MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const { 4334 return getStruct<MachO::dylinker_command>(*this, L.Ptr); 4335 } 4336 4337 MachO::uuid_command 4338 MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const { 4339 return getStruct<MachO::uuid_command>(*this, L.Ptr); 4340 } 4341 4342 MachO::rpath_command 4343 MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const { 4344 return getStruct<MachO::rpath_command>(*this, L.Ptr); 4345 } 4346 4347 MachO::source_version_command 4348 MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const { 4349 return getStruct<MachO::source_version_command>(*this, L.Ptr); 4350 } 4351 4352 MachO::entry_point_command 4353 MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const { 4354 return getStruct<MachO::entry_point_command>(*this, L.Ptr); 4355 } 4356 4357 MachO::encryption_info_command 4358 MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const { 4359 return getStruct<MachO::encryption_info_command>(*this, L.Ptr); 4360 } 4361 4362 MachO::encryption_info_command_64 4363 MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const { 4364 return getStruct<MachO::encryption_info_command_64>(*this, L.Ptr); 4365 } 4366 4367 MachO::sub_framework_command 4368 MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const { 4369 return getStruct<MachO::sub_framework_command>(*this, L.Ptr); 4370 } 4371 4372 MachO::sub_umbrella_command 4373 MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const { 4374 return getStruct<MachO::sub_umbrella_command>(*this, L.Ptr); 4375 } 4376 4377 MachO::sub_library_command 4378 MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const { 4379 return getStruct<MachO::sub_library_command>(*this, L.Ptr); 4380 } 4381 4382 MachO::sub_client_command 4383 MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const { 4384 return getStruct<MachO::sub_client_command>(*this, L.Ptr); 4385 } 4386 4387 MachO::routines_command 4388 MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const { 4389 return getStruct<MachO::routines_command>(*this, L.Ptr); 4390 } 4391 4392 MachO::routines_command_64 4393 MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const { 4394 return getStruct<MachO::routines_command_64>(*this, L.Ptr); 4395 } 4396 4397 MachO::thread_command 4398 MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const { 4399 return getStruct<MachO::thread_command>(*this, L.Ptr); 4400 } 4401 4402 MachO::any_relocation_info 4403 MachOObjectFile::getRelocation(DataRefImpl Rel) const { 4404 uint32_t Offset; 4405 if (getHeader().filetype == MachO::MH_OBJECT) { 4406 DataRefImpl Sec; 4407 Sec.d.a = Rel.d.a; 4408 if (is64Bit()) { 4409 MachO::section_64 Sect = getSection64(Sec); 4410 Offset = Sect.reloff; 4411 } else { 4412 MachO::section Sect = getSection(Sec); 4413 Offset = Sect.reloff; 4414 } 4415 } else { 4416 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand(); 4417 if (Rel.d.a == 0) 4418 Offset = DysymtabLoadCmd.extreloff; // Offset to the external relocations 4419 else 4420 Offset = DysymtabLoadCmd.locreloff; // Offset to the local relocations 4421 } 4422 4423 auto P = reinterpret_cast<const MachO::any_relocation_info *>( 4424 getPtr(*this, Offset)) + Rel.d.b; 4425 return getStruct<MachO::any_relocation_info>( 4426 *this, reinterpret_cast<const char *>(P)); 4427 } 4428 4429 MachO::data_in_code_entry 4430 MachOObjectFile::getDice(DataRefImpl Rel) const { 4431 const char *P = reinterpret_cast<const char *>(Rel.p); 4432 return getStruct<MachO::data_in_code_entry>(*this, P); 4433 } 4434 4435 const MachO::mach_header &MachOObjectFile::getHeader() const { 4436 return Header; 4437 } 4438 4439 const MachO::mach_header_64 &MachOObjectFile::getHeader64() const { 4440 assert(is64Bit()); 4441 return Header64; 4442 } 4443 4444 uint32_t MachOObjectFile::getIndirectSymbolTableEntry( 4445 const MachO::dysymtab_command &DLC, 4446 unsigned Index) const { 4447 uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t); 4448 return getStruct<uint32_t>(*this, getPtr(*this, Offset)); 4449 } 4450 4451 MachO::data_in_code_entry 4452 MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset, 4453 unsigned Index) const { 4454 uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry); 4455 return getStruct<MachO::data_in_code_entry>(*this, getPtr(*this, Offset)); 4456 } 4457 4458 MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const { 4459 if (SymtabLoadCmd) 4460 return getStruct<MachO::symtab_command>(*this, SymtabLoadCmd); 4461 4462 // If there is no SymtabLoadCmd return a load command with zero'ed fields. 4463 MachO::symtab_command Cmd; 4464 Cmd.cmd = MachO::LC_SYMTAB; 4465 Cmd.cmdsize = sizeof(MachO::symtab_command); 4466 Cmd.symoff = 0; 4467 Cmd.nsyms = 0; 4468 Cmd.stroff = 0; 4469 Cmd.strsize = 0; 4470 return Cmd; 4471 } 4472 4473 MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const { 4474 if (DysymtabLoadCmd) 4475 return getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd); 4476 4477 // If there is no DysymtabLoadCmd return a load command with zero'ed fields. 4478 MachO::dysymtab_command Cmd; 4479 Cmd.cmd = MachO::LC_DYSYMTAB; 4480 Cmd.cmdsize = sizeof(MachO::dysymtab_command); 4481 Cmd.ilocalsym = 0; 4482 Cmd.nlocalsym = 0; 4483 Cmd.iextdefsym = 0; 4484 Cmd.nextdefsym = 0; 4485 Cmd.iundefsym = 0; 4486 Cmd.nundefsym = 0; 4487 Cmd.tocoff = 0; 4488 Cmd.ntoc = 0; 4489 Cmd.modtaboff = 0; 4490 Cmd.nmodtab = 0; 4491 Cmd.extrefsymoff = 0; 4492 Cmd.nextrefsyms = 0; 4493 Cmd.indirectsymoff = 0; 4494 Cmd.nindirectsyms = 0; 4495 Cmd.extreloff = 0; 4496 Cmd.nextrel = 0; 4497 Cmd.locreloff = 0; 4498 Cmd.nlocrel = 0; 4499 return Cmd; 4500 } 4501 4502 MachO::linkedit_data_command 4503 MachOObjectFile::getDataInCodeLoadCommand() const { 4504 if (DataInCodeLoadCmd) 4505 return getStruct<MachO::linkedit_data_command>(*this, DataInCodeLoadCmd); 4506 4507 // If there is no DataInCodeLoadCmd return a load command with zero'ed fields. 4508 MachO::linkedit_data_command Cmd; 4509 Cmd.cmd = MachO::LC_DATA_IN_CODE; 4510 Cmd.cmdsize = sizeof(MachO::linkedit_data_command); 4511 Cmd.dataoff = 0; 4512 Cmd.datasize = 0; 4513 return Cmd; 4514 } 4515 4516 MachO::linkedit_data_command 4517 MachOObjectFile::getLinkOptHintsLoadCommand() const { 4518 if (LinkOptHintsLoadCmd) 4519 return getStruct<MachO::linkedit_data_command>(*this, LinkOptHintsLoadCmd); 4520 4521 // If there is no LinkOptHintsLoadCmd return a load command with zero'ed 4522 // fields. 4523 MachO::linkedit_data_command Cmd; 4524 Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT; 4525 Cmd.cmdsize = sizeof(MachO::linkedit_data_command); 4526 Cmd.dataoff = 0; 4527 Cmd.datasize = 0; 4528 return Cmd; 4529 } 4530 4531 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const { 4532 if (!DyldInfoLoadCmd) 4533 return None; 4534 4535 auto DyldInfoOrErr = 4536 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd); 4537 if (!DyldInfoOrErr) 4538 return None; 4539 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); 4540 const uint8_t *Ptr = 4541 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.rebase_off)); 4542 return makeArrayRef(Ptr, DyldInfo.rebase_size); 4543 } 4544 4545 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const { 4546 if (!DyldInfoLoadCmd) 4547 return None; 4548 4549 auto DyldInfoOrErr = 4550 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd); 4551 if (!DyldInfoOrErr) 4552 return None; 4553 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); 4554 const uint8_t *Ptr = 4555 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.bind_off)); 4556 return makeArrayRef(Ptr, DyldInfo.bind_size); 4557 } 4558 4559 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const { 4560 if (!DyldInfoLoadCmd) 4561 return None; 4562 4563 auto DyldInfoOrErr = 4564 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd); 4565 if (!DyldInfoOrErr) 4566 return None; 4567 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); 4568 const uint8_t *Ptr = 4569 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.weak_bind_off)); 4570 return makeArrayRef(Ptr, DyldInfo.weak_bind_size); 4571 } 4572 4573 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const { 4574 if (!DyldInfoLoadCmd) 4575 return None; 4576 4577 auto DyldInfoOrErr = 4578 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd); 4579 if (!DyldInfoOrErr) 4580 return None; 4581 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); 4582 const uint8_t *Ptr = 4583 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.lazy_bind_off)); 4584 return makeArrayRef(Ptr, DyldInfo.lazy_bind_size); 4585 } 4586 4587 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const { 4588 if (!DyldInfoLoadCmd) 4589 return None; 4590 4591 auto DyldInfoOrErr = 4592 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd); 4593 if (!DyldInfoOrErr) 4594 return None; 4595 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); 4596 const uint8_t *Ptr = 4597 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.export_off)); 4598 return makeArrayRef(Ptr, DyldInfo.export_size); 4599 } 4600 4601 ArrayRef<uint8_t> MachOObjectFile::getUuid() const { 4602 if (!UuidLoadCmd) 4603 return None; 4604 // Returning a pointer is fine as uuid doesn't need endian swapping. 4605 const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid); 4606 return makeArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16); 4607 } 4608 4609 StringRef MachOObjectFile::getStringTableData() const { 4610 MachO::symtab_command S = getSymtabLoadCommand(); 4611 return getData().substr(S.stroff, S.strsize); 4612 } 4613 4614 bool MachOObjectFile::is64Bit() const { 4615 return getType() == getMachOType(false, true) || 4616 getType() == getMachOType(true, true); 4617 } 4618 4619 void MachOObjectFile::ReadULEB128s(uint64_t Index, 4620 SmallVectorImpl<uint64_t> &Out) const { 4621 DataExtractor extractor(ObjectFile::getData(), true, 0); 4622 4623 uint64_t offset = Index; 4624 uint64_t data = 0; 4625 while (uint64_t delta = extractor.getULEB128(&offset)) { 4626 data += delta; 4627 Out.push_back(data); 4628 } 4629 } 4630 4631 bool MachOObjectFile::isRelocatableObject() const { 4632 return getHeader().filetype == MachO::MH_OBJECT; 4633 } 4634 4635 Expected<std::unique_ptr<MachOObjectFile>> 4636 ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer, 4637 uint32_t UniversalCputype, 4638 uint32_t UniversalIndex) { 4639 StringRef Magic = Buffer.getBuffer().slice(0, 4); 4640 if (Magic == "\xFE\xED\xFA\xCE") 4641 return MachOObjectFile::create(Buffer, false, false, 4642 UniversalCputype, UniversalIndex); 4643 if (Magic == "\xCE\xFA\xED\xFE") 4644 return MachOObjectFile::create(Buffer, true, false, 4645 UniversalCputype, UniversalIndex); 4646 if (Magic == "\xFE\xED\xFA\xCF") 4647 return MachOObjectFile::create(Buffer, false, true, 4648 UniversalCputype, UniversalIndex); 4649 if (Magic == "\xCF\xFA\xED\xFE") 4650 return MachOObjectFile::create(Buffer, true, true, 4651 UniversalCputype, UniversalIndex); 4652 return make_error<GenericBinaryError>("Unrecognized MachO magic number", 4653 object_error::invalid_file_type); 4654 } 4655 4656 StringRef MachOObjectFile::mapDebugSectionName(StringRef Name) const { 4657 return StringSwitch<StringRef>(Name) 4658 .Case("debug_str_offs", "debug_str_offsets") 4659 .Default(Name); 4660 } 4661