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 "MachOLinkGraphBuilder.h"
17 #include "PerGraphGOTAndPLTStubsBuilder.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::RequestGOTAndTransformToPCRel32GOTLoadREXRelaxable;
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 MachOPCRel32TLV:
317           if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
318             TargetSymbol = TargetSymbolOrErr->GraphSymbol;
319           else
320             return TargetSymbolOrErr.takeError();
321           Addend = *(const little32_t *)FixupContent;
322           Kind = x86_64::RequestTLVPAndTransformToPCRel32TLVPLoadREXRelaxable;
323           if (FixupOffset < 3)
324             return make_error<JITLinkError>("TLV at invalid offset " +
325                                             formatv("{0}", FixupOffset));
326           break;
327         case MachOPointer32:
328           if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
329             TargetSymbol = TargetSymbolOrErr->GraphSymbol;
330           else
331             return TargetSymbolOrErr.takeError();
332           Addend = *(const ulittle32_t *)FixupContent;
333           Kind = x86_64::Pointer32;
334           break;
335         case MachOPointer64:
336           if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
337             TargetSymbol = TargetSymbolOrErr->GraphSymbol;
338           else
339             return TargetSymbolOrErr.takeError();
340           Addend = *(const ulittle64_t *)FixupContent;
341           Kind = x86_64::Pointer64;
342           break;
343         case MachOPointer64Anon: {
344           JITTargetAddress TargetAddress = *(const ulittle64_t *)FixupContent;
345           if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress))
346             TargetSymbol = &*TargetSymbolOrErr;
347           else
348             return TargetSymbolOrErr.takeError();
349           Addend = TargetAddress - TargetSymbol->getAddress();
350           Kind = x86_64::Pointer64;
351           break;
352         }
353         case MachOPCRel32Minus1:
354         case MachOPCRel32Minus2:
355         case MachOPCRel32Minus4:
356           if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
357             TargetSymbol = TargetSymbolOrErr->GraphSymbol;
358           else
359             return TargetSymbolOrErr.takeError();
360           Addend = *(const little32_t *)FixupContent - 4;
361           Kind = x86_64::Delta32;
362           break;
363         case MachOPCRel32Anon: {
364           JITTargetAddress TargetAddress =
365               FixupAddress + 4 + *(const little32_t *)FixupContent;
366           if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress))
367             TargetSymbol = &*TargetSymbolOrErr;
368           else
369             return TargetSymbolOrErr.takeError();
370           Addend = TargetAddress - TargetSymbol->getAddress() - 4;
371           Kind = x86_64::Delta32;
372           break;
373         }
374         case MachOPCRel32Minus1Anon:
375         case MachOPCRel32Minus2Anon:
376         case MachOPCRel32Minus4Anon: {
377           JITTargetAddress Delta =
378               4 + static_cast<JITTargetAddress>(
379                       1ULL << (*MachORelocKind - MachOPCRel32Minus1Anon));
380           JITTargetAddress TargetAddress =
381               FixupAddress + Delta + *(const little32_t *)FixupContent;
382           if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress))
383             TargetSymbol = &*TargetSymbolOrErr;
384           else
385             return TargetSymbolOrErr.takeError();
386           Addend = TargetAddress - TargetSymbol->getAddress() - Delta;
387           Kind = x86_64::Delta32;
388           break;
389         }
390         case MachOSubtractor32:
391         case MachOSubtractor64: {
392           // We use Delta32/Delta64 to represent SUBTRACTOR relocations.
393           // parsePairRelocation handles the paired reloc, and returns the
394           // edge kind to be used (either Delta32/Delta64, or
395           // NegDelta32/NegDelta64, depending on the direction of the
396           // subtraction) along with the addend.
397           auto PairInfo =
398               parsePairRelocation(*BlockToFix, *MachORelocKind, RI,
399                                   FixupAddress, FixupContent, ++RelItr, RelEnd);
400           if (!PairInfo)
401             return PairInfo.takeError();
402           std::tie(Kind, TargetSymbol, Addend) = *PairInfo;
403           assert(TargetSymbol && "No target symbol from parsePairRelocation?");
404           break;
405         }
406         }
407 
408         LLVM_DEBUG({
409           dbgs() << "    ";
410           Edge GE(Kind, FixupAddress - BlockToFix->getAddress(), *TargetSymbol,
411                   Addend);
412           printEdge(dbgs(), *BlockToFix, GE, x86_64::getEdgeKindName(Kind));
413           dbgs() << "\n";
414         });
415         BlockToFix->addEdge(Kind, FixupAddress - BlockToFix->getAddress(),
416                             *TargetSymbol, Addend);
417       }
418     }
419     return Error::success();
420   }
421 };
422 
423 class PerGraphGOTAndPLTStubsBuilder_MachO_x86_64
424     : public PerGraphGOTAndPLTStubsBuilder<
425           PerGraphGOTAndPLTStubsBuilder_MachO_x86_64> {
426 public:
427 
428   using PerGraphGOTAndPLTStubsBuilder<
429       PerGraphGOTAndPLTStubsBuilder_MachO_x86_64>::
430       PerGraphGOTAndPLTStubsBuilder;
431 
432   bool isGOTEdgeToFix(Edge &E) const {
433     return E.getKind() == x86_64::RequestGOTAndTransformToDelta32 ||
434            E.getKind() ==
435                x86_64::RequestGOTAndTransformToPCRel32GOTLoadREXRelaxable;
436   }
437 
438   Symbol &createGOTEntry(Symbol &Target) {
439     return x86_64::createAnonymousPointer(G, getGOTSection(), &Target);
440   }
441 
442   void fixGOTEdge(Edge &E, Symbol &GOTEntry) {
443     // Fix the edge kind.
444     switch (E.getKind()) {
445     case x86_64::RequestGOTAndTransformToDelta32:
446       E.setKind(x86_64::Delta32);
447       break;
448     case x86_64::RequestGOTAndTransformToPCRel32GOTLoadREXRelaxable:
449       E.setKind(x86_64::PCRel32GOTLoadREXRelaxable);
450       break;
451     default:
452       llvm_unreachable("Not a GOT transform edge");
453     }
454     // Fix the target, leave the addend as-is.
455     E.setTarget(GOTEntry);
456   }
457 
458   bool isExternalBranchEdge(Edge &E) {
459     return E.getKind() == x86_64::BranchPCRel32 && E.getTarget().isExternal();
460   }
461 
462   Symbol &createPLTStub(Symbol &Target) {
463     return x86_64::createAnonymousPointerJumpStub(G, getStubsSection(),
464                                                   getGOTEntry(Target));
465   }
466 
467   void fixPLTEdge(Edge &E, Symbol &Stub) {
468     assert(E.getKind() == x86_64::BranchPCRel32 && "Not a Branch32 edge?");
469     assert(E.getAddend() == 0 &&
470            "BranchPCRel32 edge has unexpected addend value");
471 
472     // Set the edge kind to BranchPCRel32ToPtrJumpStubBypassable. We will use
473     // this to check for stub optimization opportunities in the
474     // optimizeMachO_x86_64_GOTAndStubs pass below.
475     E.setKind(x86_64::BranchPCRel32ToPtrJumpStubBypassable);
476     E.setTarget(Stub);
477   }
478 
479 private:
480   Section &getGOTSection() {
481     if (!GOTSection)
482       GOTSection = &G.createSection("$__GOT", sys::Memory::MF_READ);
483     return *GOTSection;
484   }
485 
486   Section &getStubsSection() {
487     if (!StubsSection) {
488       auto StubsProt = static_cast<sys::Memory::ProtectionFlags>(
489           sys::Memory::MF_READ | sys::Memory::MF_EXEC);
490       StubsSection = &G.createSection("$__STUBS", StubsProt);
491     }
492     return *StubsSection;
493   }
494 
495   Section *GOTSection = nullptr;
496   Section *StubsSection = nullptr;
497 };
498 
499 } // namespace
500 
501 namespace llvm {
502 namespace jitlink {
503 
504 class MachOJITLinker_x86_64 : public JITLinker<MachOJITLinker_x86_64> {
505   friend class JITLinker<MachOJITLinker_x86_64>;
506 
507 public:
508   MachOJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
509                         std::unique_ptr<LinkGraph> G,
510                         PassConfiguration PassConfig)
511       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}
512 
513 private:
514   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
515     return x86_64::applyFixup(G, B, E, nullptr);
516   }
517 };
518 
519 Expected<std::unique_ptr<LinkGraph>>
520 createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) {
521   auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
522   if (!MachOObj)
523     return MachOObj.takeError();
524   return MachOLinkGraphBuilder_x86_64(**MachOObj).buildGraph();
525 }
526 
527 void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
528                        std::unique_ptr<JITLinkContext> Ctx) {
529 
530   PassConfiguration Config;
531 
532   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
533     // Add eh-frame passses.
534     Config.PrePrunePasses.push_back(createEHFrameSplitterPass_MachO_x86_64());
535     Config.PrePrunePasses.push_back(createEHFrameEdgeFixerPass_MachO_x86_64());
536 
537     // Add a mark-live pass.
538     if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
539       Config.PrePrunePasses.push_back(std::move(MarkLive));
540     else
541       Config.PrePrunePasses.push_back(markAllSymbolsLive);
542 
543     // Add an in-place GOT/Stubs pass.
544     Config.PostPrunePasses.push_back(
545         PerGraphGOTAndPLTStubsBuilder_MachO_x86_64::asPass);
546 
547     // Add GOT/Stubs optimizer pass.
548     Config.PreFixupPasses.push_back(x86_64::optimize_x86_64_GOTAndStubs);
549   }
550 
551   if (auto Err = Ctx->modifyPassConfig(*G, Config))
552     return Ctx->notifyFailed(std::move(Err));
553 
554   // Construct a JITLinker and run the link function.
555   MachOJITLinker_x86_64::link(std::move(Ctx), std::move(G), std::move(Config));
556 }
557 
558 LinkGraphPassFunction createEHFrameSplitterPass_MachO_x86_64() {
559   return EHFrameSplitter("__TEXT,__eh_frame");
560 }
561 
562 LinkGraphPassFunction createEHFrameEdgeFixerPass_MachO_x86_64() {
563   return EHFrameEdgeFixer("__TEXT,__eh_frame", x86_64::PointerSize,
564                           x86_64::Delta64, x86_64::Delta32, x86_64::NegDelta32);
565 }
566 
567 } // end namespace jitlink
568 } // end namespace llvm
569