1 //===---- MachO_x86_64.cpp -JIT linker implementation for MachO/x86-64 ----===// 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 // MachO/x86-64 jit-link implementation. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/ExecutionEngine/JITLink/MachO_x86_64.h" 14 #include "llvm/ExecutionEngine/JITLink/x86_64.h" 15 16 #include "BasicGOTAndStubsBuilder.h" 17 #include "MachOLinkGraphBuilder.h" 18 19 #define DEBUG_TYPE "jitlink" 20 21 using namespace llvm; 22 using namespace llvm::jitlink; 23 24 namespace { 25 26 class MachOLinkGraphBuilder_x86_64 : public MachOLinkGraphBuilder { 27 public: 28 MachOLinkGraphBuilder_x86_64(const object::MachOObjectFile &Obj) 29 : MachOLinkGraphBuilder(Obj, Triple("x86_64-apple-darwin"), 30 x86_64::getEdgeKindName) {} 31 32 private: 33 enum MachONormalizedRelocationType : unsigned { 34 MachOBranch32, 35 MachOPointer32, 36 MachOPointer64, 37 MachOPointer64Anon, 38 MachOPCRel32, 39 MachOPCRel32Minus1, 40 MachOPCRel32Minus2, 41 MachOPCRel32Minus4, 42 MachOPCRel32Anon, 43 MachOPCRel32Minus1Anon, 44 MachOPCRel32Minus2Anon, 45 MachOPCRel32Minus4Anon, 46 MachOPCRel32GOTLoad, 47 MachOPCRel32GOT, 48 MachOPCRel32TLV, 49 MachOSubtractor32, 50 MachOSubtractor64, 51 }; 52 53 static Expected<MachONormalizedRelocationType> 54 getRelocKind(const MachO::relocation_info &RI) { 55 switch (RI.r_type) { 56 case MachO::X86_64_RELOC_UNSIGNED: 57 if (!RI.r_pcrel) { 58 if (RI.r_length == 3) 59 return RI.r_extern ? MachOPointer64 : MachOPointer64Anon; 60 else if (RI.r_extern && RI.r_length == 2) 61 return MachOPointer32; 62 } 63 break; 64 case MachO::X86_64_RELOC_SIGNED: 65 if (RI.r_pcrel && RI.r_length == 2) 66 return RI.r_extern ? MachOPCRel32 : MachOPCRel32Anon; 67 break; 68 case MachO::X86_64_RELOC_BRANCH: 69 if (RI.r_pcrel && RI.r_extern && RI.r_length == 2) 70 return MachOBranch32; 71 break; 72 case MachO::X86_64_RELOC_GOT_LOAD: 73 if (RI.r_pcrel && RI.r_extern && RI.r_length == 2) 74 return MachOPCRel32GOTLoad; 75 break; 76 case MachO::X86_64_RELOC_GOT: 77 if (RI.r_pcrel && RI.r_extern && RI.r_length == 2) 78 return MachOPCRel32GOT; 79 break; 80 case MachO::X86_64_RELOC_SUBTRACTOR: 81 if (!RI.r_pcrel && RI.r_extern) { 82 if (RI.r_length == 2) 83 return MachOSubtractor32; 84 else if (RI.r_length == 3) 85 return MachOSubtractor64; 86 } 87 break; 88 case MachO::X86_64_RELOC_SIGNED_1: 89 if (RI.r_pcrel && RI.r_length == 2) 90 return RI.r_extern ? MachOPCRel32Minus1 : MachOPCRel32Minus1Anon; 91 break; 92 case MachO::X86_64_RELOC_SIGNED_2: 93 if (RI.r_pcrel && RI.r_length == 2) 94 return RI.r_extern ? MachOPCRel32Minus2 : MachOPCRel32Minus2Anon; 95 break; 96 case MachO::X86_64_RELOC_SIGNED_4: 97 if (RI.r_pcrel && RI.r_length == 2) 98 return RI.r_extern ? MachOPCRel32Minus4 : MachOPCRel32Minus4Anon; 99 break; 100 case MachO::X86_64_RELOC_TLV: 101 if (RI.r_pcrel && RI.r_extern && RI.r_length == 2) 102 return MachOPCRel32TLV; 103 break; 104 } 105 106 return make_error<JITLinkError>( 107 "Unsupported x86-64 relocation: address=" + 108 formatv("{0:x8}", RI.r_address) + 109 ", symbolnum=" + formatv("{0:x6}", RI.r_symbolnum) + 110 ", kind=" + formatv("{0:x1}", RI.r_type) + 111 ", pc_rel=" + (RI.r_pcrel ? "true" : "false") + 112 ", extern=" + (RI.r_extern ? "true" : "false") + 113 ", length=" + formatv("{0:d}", RI.r_length)); 114 } 115 116 using PairRelocInfo = std::tuple<Edge::Kind, Symbol *, uint64_t>; 117 118 // Parses paired SUBTRACTOR/UNSIGNED relocations and, on success, 119 // returns the edge kind and addend to be used. 120 Expected<PairRelocInfo> parsePairRelocation( 121 Block &BlockToFix, MachONormalizedRelocationType SubtractorKind, 122 const MachO::relocation_info &SubRI, JITTargetAddress FixupAddress, 123 const char *FixupContent, object::relocation_iterator &UnsignedRelItr, 124 object::relocation_iterator &RelEnd) { 125 using namespace support; 126 127 assert(((SubtractorKind == MachOSubtractor32 && SubRI.r_length == 2) || 128 (SubtractorKind == MachOSubtractor64 && SubRI.r_length == 3)) && 129 "Subtractor kind should match length"); 130 assert(SubRI.r_extern && "SUBTRACTOR reloc symbol should be extern"); 131 assert(!SubRI.r_pcrel && "SUBTRACTOR reloc should not be PCRel"); 132 133 if (UnsignedRelItr == RelEnd) 134 return make_error<JITLinkError>("x86_64 SUBTRACTOR without paired " 135 "UNSIGNED relocation"); 136 137 auto UnsignedRI = getRelocationInfo(UnsignedRelItr); 138 139 if (SubRI.r_address != UnsignedRI.r_address) 140 return make_error<JITLinkError>("x86_64 SUBTRACTOR and paired UNSIGNED " 141 "point to different addresses"); 142 143 if (SubRI.r_length != UnsignedRI.r_length) 144 return make_error<JITLinkError>("length of x86_64 SUBTRACTOR and paired " 145 "UNSIGNED reloc must match"); 146 147 Symbol *FromSymbol; 148 if (auto FromSymbolOrErr = findSymbolByIndex(SubRI.r_symbolnum)) 149 FromSymbol = FromSymbolOrErr->GraphSymbol; 150 else 151 return FromSymbolOrErr.takeError(); 152 153 // Read the current fixup value. 154 uint64_t FixupValue = 0; 155 if (SubRI.r_length == 3) 156 FixupValue = *(const little64_t *)FixupContent; 157 else 158 FixupValue = *(const little32_t *)FixupContent; 159 160 // Find 'ToSymbol' using symbol number or address, depending on whether the 161 // paired UNSIGNED relocation is extern. 162 Symbol *ToSymbol = nullptr; 163 if (UnsignedRI.r_extern) { 164 // Find target symbol by symbol index. 165 if (auto ToSymbolOrErr = findSymbolByIndex(UnsignedRI.r_symbolnum)) 166 ToSymbol = ToSymbolOrErr->GraphSymbol; 167 else 168 return ToSymbolOrErr.takeError(); 169 } else { 170 auto ToSymbolSec = findSectionByIndex(UnsignedRI.r_symbolnum - 1); 171 if (!ToSymbolSec) 172 return ToSymbolSec.takeError(); 173 ToSymbol = getSymbolByAddress(ToSymbolSec->Address); 174 assert(ToSymbol && "No symbol for section"); 175 FixupValue -= ToSymbol->getAddress(); 176 } 177 178 Edge::Kind DeltaKind; 179 Symbol *TargetSymbol; 180 uint64_t Addend; 181 if (&BlockToFix == &FromSymbol->getAddressable()) { 182 TargetSymbol = ToSymbol; 183 DeltaKind = (SubRI.r_length == 3) ? x86_64::Delta64 : x86_64::Delta32; 184 Addend = FixupValue + (FixupAddress - FromSymbol->getAddress()); 185 // FIXME: handle extern 'from'. 186 } else if (&BlockToFix == &ToSymbol->getAddressable()) { 187 TargetSymbol = FromSymbol; 188 DeltaKind = 189 (SubRI.r_length == 3) ? x86_64::NegDelta64 : x86_64::NegDelta32; 190 Addend = FixupValue - (FixupAddress - ToSymbol->getAddress()); 191 } else { 192 // BlockToFix was neither FromSymbol nor ToSymbol. 193 return make_error<JITLinkError>("SUBTRACTOR relocation must fix up " 194 "either 'A' or 'B' (or a symbol in one " 195 "of their alt-entry chains)"); 196 } 197 198 return PairRelocInfo(DeltaKind, TargetSymbol, Addend); 199 } 200 201 Error addRelocations() override { 202 using namespace support; 203 auto &Obj = getObject(); 204 205 LLVM_DEBUG(dbgs() << "Processing relocations:\n"); 206 207 for (auto &S : Obj.sections()) { 208 209 JITTargetAddress SectionAddress = S.getAddress(); 210 211 // Skip relocations virtual sections. 212 if (S.isVirtual()) { 213 if (S.relocation_begin() != S.relocation_end()) 214 return make_error<JITLinkError>("Virtual section contains " 215 "relocations"); 216 continue; 217 } 218 219 // Skip relocations for debug symbols. 220 { 221 auto &NSec = 222 getSectionByIndex(Obj.getSectionIndex(S.getRawDataRefImpl())); 223 if (!NSec.GraphSection) { 224 LLVM_DEBUG({ 225 dbgs() << " Skipping relocations for MachO section " 226 << NSec.SegName << "/" << NSec.SectName 227 << " which has no associated graph section\n"; 228 }); 229 continue; 230 } 231 } 232 233 // Add relocations for section. 234 for (auto RelItr = S.relocation_begin(), RelEnd = S.relocation_end(); 235 RelItr != RelEnd; ++RelItr) { 236 237 MachO::relocation_info RI = getRelocationInfo(RelItr); 238 239 // Find the address of the value to fix up. 240 JITTargetAddress FixupAddress = SectionAddress + (uint32_t)RI.r_address; 241 242 LLVM_DEBUG({ 243 auto &NSec = 244 getSectionByIndex(Obj.getSectionIndex(S.getRawDataRefImpl())); 245 dbgs() << " " << NSec.SectName << " + " 246 << formatv("{0:x8}", RI.r_address) << ":\n"; 247 }); 248 249 // Find the block that the fixup points to. 250 Block *BlockToFix = nullptr; 251 { 252 auto SymbolToFixOrErr = findSymbolByAddress(FixupAddress); 253 if (!SymbolToFixOrErr) 254 return SymbolToFixOrErr.takeError(); 255 BlockToFix = &SymbolToFixOrErr->getBlock(); 256 } 257 258 if (FixupAddress + static_cast<JITTargetAddress>(1ULL << RI.r_length) > 259 BlockToFix->getAddress() + BlockToFix->getContent().size()) 260 return make_error<JITLinkError>( 261 "Relocation extends past end of fixup block"); 262 263 // Get a pointer to the fixup content. 264 const char *FixupContent = BlockToFix->getContent().data() + 265 (FixupAddress - BlockToFix->getAddress()); 266 267 size_t FixupOffset = FixupAddress - BlockToFix->getAddress(); 268 269 // The target symbol and addend will be populated by the switch below. 270 Symbol *TargetSymbol = nullptr; 271 uint64_t Addend = 0; 272 273 // Sanity check the relocation kind. 274 auto MachORelocKind = getRelocKind(RI); 275 if (!MachORelocKind) 276 return MachORelocKind.takeError(); 277 278 Edge::Kind Kind = Edge::Invalid; 279 280 switch (*MachORelocKind) { 281 case MachOBranch32: 282 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum)) 283 TargetSymbol = TargetSymbolOrErr->GraphSymbol; 284 else 285 return TargetSymbolOrErr.takeError(); 286 Addend = *(const little32_t *)FixupContent; 287 Kind = x86_64::BranchPCRel32; 288 break; 289 case MachOPCRel32: 290 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum)) 291 TargetSymbol = TargetSymbolOrErr->GraphSymbol; 292 else 293 return TargetSymbolOrErr.takeError(); 294 Addend = *(const little32_t *)FixupContent - 4; 295 Kind = x86_64::Delta32; 296 break; 297 case MachOPCRel32GOTLoad: 298 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum)) 299 TargetSymbol = TargetSymbolOrErr->GraphSymbol; 300 else 301 return TargetSymbolOrErr.takeError(); 302 Addend = *(const little32_t *)FixupContent; 303 Kind = x86_64::RequestGOTAndTransformToPCRel32GOTLoadRelaxable; 304 if (FixupOffset < 3) 305 return make_error<JITLinkError>("GOTLD at invalid offset " + 306 formatv("{0}", FixupOffset)); 307 break; 308 case MachOPCRel32GOT: 309 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum)) 310 TargetSymbol = TargetSymbolOrErr->GraphSymbol; 311 else 312 return TargetSymbolOrErr.takeError(); 313 Addend = *(const little32_t *)FixupContent - 4; 314 Kind = x86_64::RequestGOTAndTransformToDelta32; 315 break; 316 case MachOPointer32: 317 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum)) 318 TargetSymbol = TargetSymbolOrErr->GraphSymbol; 319 else 320 return TargetSymbolOrErr.takeError(); 321 Addend = *(const ulittle32_t *)FixupContent; 322 Kind = x86_64::Pointer32; 323 break; 324 case MachOPointer64: 325 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum)) 326 TargetSymbol = TargetSymbolOrErr->GraphSymbol; 327 else 328 return TargetSymbolOrErr.takeError(); 329 Addend = *(const ulittle64_t *)FixupContent; 330 Kind = x86_64::Pointer64; 331 break; 332 case MachOPointer64Anon: { 333 JITTargetAddress TargetAddress = *(const ulittle64_t *)FixupContent; 334 if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress)) 335 TargetSymbol = &*TargetSymbolOrErr; 336 else 337 return TargetSymbolOrErr.takeError(); 338 Addend = TargetAddress - TargetSymbol->getAddress(); 339 Kind = x86_64::Pointer64; 340 break; 341 } 342 case MachOPCRel32Minus1: 343 case MachOPCRel32Minus2: 344 case MachOPCRel32Minus4: 345 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum)) 346 TargetSymbol = TargetSymbolOrErr->GraphSymbol; 347 else 348 return TargetSymbolOrErr.takeError(); 349 Addend = *(const little32_t *)FixupContent - 4; 350 // - 351 // (1 << (*MachORelocKind - MachOPCRel32Minus1)); 352 Kind = x86_64::Delta32; 353 break; 354 case MachOPCRel32Anon: { 355 JITTargetAddress TargetAddress = 356 FixupAddress + 4 + *(const little32_t *)FixupContent; 357 if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress)) 358 TargetSymbol = &*TargetSymbolOrErr; 359 else 360 return TargetSymbolOrErr.takeError(); 361 Addend = TargetAddress - TargetSymbol->getAddress() - 4; 362 Kind = x86_64::Delta32; 363 break; 364 } 365 case MachOPCRel32Minus1Anon: 366 case MachOPCRel32Minus2Anon: 367 case MachOPCRel32Minus4Anon: { 368 JITTargetAddress Delta = 369 4 + static_cast<JITTargetAddress>( 370 1ULL << (*MachORelocKind - MachOPCRel32Minus1Anon)); 371 JITTargetAddress TargetAddress = 372 FixupAddress + Delta + *(const little32_t *)FixupContent; 373 if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress)) 374 TargetSymbol = &*TargetSymbolOrErr; 375 else 376 return TargetSymbolOrErr.takeError(); 377 Addend = TargetAddress - TargetSymbol->getAddress() - Delta; 378 Kind = x86_64::Delta32; 379 break; 380 } 381 case MachOSubtractor32: 382 case MachOSubtractor64: { 383 // We use Delta32/Delta64 to represent SUBTRACTOR relocations. 384 // parsePairRelocation handles the paired reloc, and returns the 385 // edge kind to be used (either Delta32/Delta64, or 386 // NegDelta32/NegDelta64, depending on the direction of the 387 // subtraction) along with the addend. 388 auto PairInfo = 389 parsePairRelocation(*BlockToFix, *MachORelocKind, RI, 390 FixupAddress, FixupContent, ++RelItr, RelEnd); 391 if (!PairInfo) 392 return PairInfo.takeError(); 393 std::tie(Kind, TargetSymbol, Addend) = *PairInfo; 394 assert(TargetSymbol && "No target symbol from parsePairRelocation?"); 395 break; 396 } 397 case MachOPCRel32TLV: 398 return make_error<JITLinkError>( 399 "MachO TLV relocations not yet supported"); 400 } 401 402 LLVM_DEBUG({ 403 dbgs() << " "; 404 Edge GE(Kind, FixupAddress - BlockToFix->getAddress(), *TargetSymbol, 405 Addend); 406 printEdge(dbgs(), *BlockToFix, GE, x86_64::getEdgeKindName(Kind)); 407 dbgs() << "\n"; 408 }); 409 BlockToFix->addEdge(Kind, FixupAddress - BlockToFix->getAddress(), 410 *TargetSymbol, Addend); 411 } 412 } 413 return Error::success(); 414 } 415 }; 416 417 class MachO_x86_64_GOTAndStubsBuilder 418 : public BasicGOTAndStubsBuilder<MachO_x86_64_GOTAndStubsBuilder> { 419 public: 420 static const uint8_t NullGOTEntryContent[8]; 421 static const uint8_t StubContent[6]; 422 423 MachO_x86_64_GOTAndStubsBuilder(LinkGraph &G) 424 : BasicGOTAndStubsBuilder<MachO_x86_64_GOTAndStubsBuilder>(G) {} 425 426 bool isGOTEdgeToFix(Edge &E) const { 427 return E.getKind() == x86_64::RequestGOTAndTransformToDelta32 || 428 E.getKind() == 429 x86_64::RequestGOTAndTransformToPCRel32GOTLoadRelaxable; 430 } 431 432 Symbol &createGOTEntry(Symbol &Target) { 433 auto &GOTEntryBlock = G.createContentBlock( 434 getGOTSection(), getGOTEntryBlockContent(), 0, 8, 0); 435 GOTEntryBlock.addEdge(x86_64::Pointer64, 0, Target, 0); 436 return G.addAnonymousSymbol(GOTEntryBlock, 0, 8, false, false); 437 } 438 439 void fixGOTEdge(Edge &E, Symbol &GOTEntry) { 440 // Fix the edge kind. 441 switch (E.getKind()) { 442 case x86_64::RequestGOTAndTransformToDelta32: 443 E.setKind(x86_64::Delta32); 444 break; 445 case x86_64::RequestGOTAndTransformToPCRel32GOTLoadRelaxable: 446 E.setKind(x86_64::PCRel32GOTLoadRelaxable); 447 break; 448 default: 449 llvm_unreachable("Not a GOT transform edge"); 450 } 451 // Fix the target, leave the addend as-is. 452 E.setTarget(GOTEntry); 453 } 454 455 bool isExternalBranchEdge(Edge &E) { 456 return E.getKind() == x86_64::BranchPCRel32 && E.getTarget().isExternal(); 457 } 458 459 Symbol &createStub(Symbol &Target) { 460 auto &StubContentBlock = 461 G.createContentBlock(getStubsSection(), getStubBlockContent(), 0, 1, 0); 462 // Re-use GOT entries for stub targets. 463 auto &GOTEntrySymbol = getGOTEntrySymbol(Target); 464 StubContentBlock.addEdge(x86_64::Delta32, 2, GOTEntrySymbol, -4); 465 return G.addAnonymousSymbol(StubContentBlock, 0, 6, true, false); 466 } 467 468 void fixExternalBranchEdge(Edge &E, Symbol &Stub) { 469 assert(E.getKind() == x86_64::BranchPCRel32 && "Not a Branch32 edge?"); 470 assert(E.getAddend() == 0 && 471 "BranchPCRel32 edge has unexpected addend value"); 472 473 // Set the edge kind to BranchPCRel32ToPtrJumpStubRelaxable. We will use 474 // this to check for stub optimization opportunities in the 475 // optimizeMachO_x86_64_GOTAndStubs pass below. 476 E.setKind(x86_64::BranchPCRel32ToPtrJumpStubRelaxable); 477 E.setTarget(Stub); 478 } 479 480 private: 481 Section &getGOTSection() { 482 if (!GOTSection) 483 GOTSection = &G.createSection("$__GOT", sys::Memory::MF_READ); 484 return *GOTSection; 485 } 486 487 Section &getStubsSection() { 488 if (!StubsSection) { 489 auto StubsProt = static_cast<sys::Memory::ProtectionFlags>( 490 sys::Memory::MF_READ | sys::Memory::MF_EXEC); 491 StubsSection = &G.createSection("$__STUBS", StubsProt); 492 } 493 return *StubsSection; 494 } 495 496 StringRef getGOTEntryBlockContent() { 497 return StringRef(reinterpret_cast<const char *>(NullGOTEntryContent), 498 sizeof(NullGOTEntryContent)); 499 } 500 501 StringRef getStubBlockContent() { 502 return StringRef(reinterpret_cast<const char *>(StubContent), 503 sizeof(StubContent)); 504 } 505 506 Section *GOTSection = nullptr; 507 Section *StubsSection = nullptr; 508 }; 509 510 const uint8_t MachO_x86_64_GOTAndStubsBuilder::NullGOTEntryContent[8] = { 511 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 512 const uint8_t MachO_x86_64_GOTAndStubsBuilder::StubContent[6] = { 513 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00}; 514 } // namespace 515 516 static Error optimizeMachO_x86_64_GOTAndStubs(LinkGraph &G) { 517 LLVM_DEBUG(dbgs() << "Optimizing GOT entries and stubs:\n"); 518 519 for (auto *B : G.blocks()) 520 for (auto &E : B->edges()) 521 if (E.getKind() == x86_64::PCRel32GOTLoadRelaxable) { 522 assert(E.getOffset() >= 3 && "GOT edge occurs too early in block"); 523 524 // Optimize GOT references. 525 auto &GOTBlock = E.getTarget().getBlock(); 526 assert(GOTBlock.getSize() == G.getPointerSize() && 527 "GOT entry block should be pointer sized"); 528 assert(GOTBlock.edges_size() == 1 && 529 "GOT entry should only have one outgoing edge"); 530 531 auto &GOTTarget = GOTBlock.edges().begin()->getTarget(); 532 JITTargetAddress EdgeAddr = B->getAddress() + E.getOffset(); 533 JITTargetAddress TargetAddr = GOTTarget.getAddress(); 534 535 // Check that this is a recognized MOV instruction. 536 // FIXME: Can we assume this? 537 constexpr uint8_t MOVQRIPRel[] = {0x48, 0x8b}; 538 if (strncmp(B->getContent().data() + E.getOffset() - 3, 539 reinterpret_cast<const char *>(MOVQRIPRel), 2) != 0) 540 continue; 541 542 int64_t Displacement = TargetAddr - EdgeAddr + 4; 543 if (Displacement >= std::numeric_limits<int32_t>::min() && 544 Displacement <= std::numeric_limits<int32_t>::max()) { 545 E.setTarget(GOTTarget); 546 E.setKind(x86_64::Delta32); 547 E.setAddend(E.getAddend() - 4); 548 auto *BlockData = reinterpret_cast<uint8_t *>( 549 const_cast<char *>(B->getContent().data())); 550 BlockData[E.getOffset() - 2] = 0x8d; 551 LLVM_DEBUG({ 552 dbgs() << " Replaced GOT load wih LEA:\n "; 553 printEdge(dbgs(), *B, E, x86_64::getEdgeKindName(E.getKind())); 554 dbgs() << "\n"; 555 }); 556 } 557 } else if (E.getKind() == x86_64::BranchPCRel32ToPtrJumpStubRelaxable) { 558 auto &StubBlock = E.getTarget().getBlock(); 559 assert(StubBlock.getSize() == 560 sizeof(MachO_x86_64_GOTAndStubsBuilder::StubContent) && 561 "Stub block should be stub sized"); 562 assert(StubBlock.edges_size() == 1 && 563 "Stub block should only have one outgoing edge"); 564 565 auto &GOTBlock = StubBlock.edges().begin()->getTarget().getBlock(); 566 assert(GOTBlock.getSize() == G.getPointerSize() && 567 "GOT block should be pointer sized"); 568 assert(GOTBlock.edges_size() == 1 && 569 "GOT block should only have one outgoing edge"); 570 571 auto &GOTTarget = GOTBlock.edges().begin()->getTarget(); 572 JITTargetAddress EdgeAddr = B->getAddress() + E.getOffset(); 573 JITTargetAddress TargetAddr = GOTTarget.getAddress(); 574 575 int64_t Displacement = TargetAddr - EdgeAddr + 4; 576 if (Displacement >= std::numeric_limits<int32_t>::min() && 577 Displacement <= std::numeric_limits<int32_t>::max()) { 578 E.setKind(x86_64::BranchPCRel32); 579 E.setTarget(GOTTarget); 580 LLVM_DEBUG({ 581 dbgs() << " Replaced stub branch with direct branch:\n "; 582 printEdge(dbgs(), *B, E, x86_64::getEdgeKindName(E.getKind())); 583 dbgs() << "\n"; 584 }); 585 } 586 } 587 588 return Error::success(); 589 } 590 591 namespace llvm { 592 namespace jitlink { 593 594 class MachOJITLinker_x86_64 : public JITLinker<MachOJITLinker_x86_64> { 595 friend class JITLinker<MachOJITLinker_x86_64>; 596 597 public: 598 MachOJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx, 599 std::unique_ptr<LinkGraph> G, 600 PassConfiguration PassConfig) 601 : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {} 602 603 private: 604 Error applyFixup(LinkGraph &G, Block &B, const Edge &E, 605 char *BlockWorkingMem) const { 606 return x86_64::applyFixup(G, B, E, BlockWorkingMem); 607 } 608 }; 609 610 Expected<std::unique_ptr<LinkGraph>> 611 createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) { 612 auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer); 613 if (!MachOObj) 614 return MachOObj.takeError(); 615 return MachOLinkGraphBuilder_x86_64(**MachOObj).buildGraph(); 616 } 617 618 void link_MachO_x86_64(std::unique_ptr<LinkGraph> G, 619 std::unique_ptr<JITLinkContext> Ctx) { 620 621 PassConfiguration Config; 622 623 if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) { 624 // Add eh-frame passses. 625 Config.PrePrunePasses.push_back(EHFrameSplitter("__eh_frame")); 626 Config.PrePrunePasses.push_back( 627 EHFrameEdgeFixer("__eh_frame", G->getPointerSize(), x86_64::Delta64, 628 x86_64::Delta32, x86_64::NegDelta32)); 629 630 // Add a mark-live pass. 631 if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple())) 632 Config.PrePrunePasses.push_back(std::move(MarkLive)); 633 else 634 Config.PrePrunePasses.push_back(markAllSymbolsLive); 635 636 // Add an in-place GOT/Stubs pass. 637 Config.PostPrunePasses.push_back([](LinkGraph &G) -> Error { 638 MachO_x86_64_GOTAndStubsBuilder(G).run(); 639 return Error::success(); 640 }); 641 642 // Add GOT/Stubs optimizer pass. 643 Config.PreFixupPasses.push_back(optimizeMachO_x86_64_GOTAndStubs); 644 } 645 646 if (auto Err = Ctx->modifyPassConfig(*G, Config)) 647 return Ctx->notifyFailed(std::move(Err)); 648 649 // Construct a JITLinker and run the link function. 650 MachOJITLinker_x86_64::link(std::move(Ctx), std::move(G), std::move(Config)); 651 } 652 653 } // end namespace jitlink 654 } // end namespace llvm 655