1//===--------- LLJIT.cpp - An ORC-based JIT for compiling LLVM IR ---------===//
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#include "llvm/ExecutionEngine/Orc/LLJIT.h"
10#include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
11#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
12#include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
13#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
14#include "llvm/ExecutionEngine/Orc/OrcError.h"
15#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
16#include "llvm/ExecutionEngine/SectionMemoryManager.h"
17#include "llvm/IR/GlobalVariable.h"
18#include "llvm/IR/IRBuilder.h"
19#include "llvm/IR/Mangler.h"
20#include "llvm/IR/Module.h"
21#include "llvm/Support/DynamicLibrary.h"
22
23#include <map>
24
25#define DEBUG_TYPE "orc"
26
27using namespace llvm;
28using namespace llvm::orc;
29
30namespace {
31
32/// Adds helper function decls and wrapper functions that call the helper with
33/// some additional prefix arguments.
34///
35/// E.g. For wrapper "foo" with type i8(i8, i64), helper "bar", and prefix
36/// args i32 4 and i16 12345, this function will add:
37///
38/// declare i8 @bar(i32, i16, i8, i64)
39///
40/// define i8 @foo(i8, i64) {
41/// entry:
42///   %2 = call i8 @bar(i32 4, i16 12345, i8 %0, i64 %1)
43///   ret i8 %2
44/// }
45///
46Function *addHelperAndWrapper(Module &M, StringRef WrapperName,
47                              FunctionType *WrapperFnType,
48                              GlobalValue::VisibilityTypes WrapperVisibility,
49                              StringRef HelperName,
50                              ArrayRef<Value *> HelperPrefixArgs) {
51  std::vector<Type *> HelperArgTypes;
52  for (auto *Arg : HelperPrefixArgs)
53    HelperArgTypes.push_back(Arg->getType());
54  for (auto *T : WrapperFnType->params())
55    HelperArgTypes.push_back(T);
56  auto *HelperFnType =
57      FunctionType::get(WrapperFnType->getReturnType(), HelperArgTypes, false);
58  auto *HelperFn = Function::Create(HelperFnType, GlobalValue::ExternalLinkage,
59                                    HelperName, M);
60
61  auto *WrapperFn = Function::Create(
62      WrapperFnType, GlobalValue::ExternalLinkage, WrapperName, M);
63  WrapperFn->setVisibility(WrapperVisibility);
64
65  auto *EntryBlock = BasicBlock::Create(M.getContext(), "entry", WrapperFn);
66  IRBuilder<> IB(EntryBlock);
67
68  std::vector<Value *> HelperArgs;
69  for (auto *Arg : HelperPrefixArgs)
70    HelperArgs.push_back(Arg);
71  for (auto &Arg : WrapperFn->args())
72    HelperArgs.push_back(&Arg);
73  auto *HelperResult = IB.CreateCall(HelperFn, HelperArgs);
74  if (HelperFn->getReturnType()->isVoidTy())
75    IB.CreateRetVoid();
76  else
77    IB.CreateRet(HelperResult);
78
79  return WrapperFn;
80}
81
82class GenericLLVMIRPlatformSupport;
83
84/// orc::Platform component of Generic LLVM IR Platform support.
85/// Just forwards calls to the GenericLLVMIRPlatformSupport class below.
86class GenericLLVMIRPlatform : public Platform {
87public:
88  GenericLLVMIRPlatform(GenericLLVMIRPlatformSupport &S) : S(S) {}
89  Error setupJITDylib(JITDylib &JD) override;
90  Error notifyAdding(JITDylib &JD, const MaterializationUnit &MU) override;
91  Error notifyRemoving(JITDylib &JD, VModuleKey K) override {
92    // Noop -- Nothing to do (yet).
93    return Error::success();
94  }
95
96private:
97  GenericLLVMIRPlatformSupport &S;
98};
99
100/// This transform parses llvm.global_ctors to produce a single initialization
101/// function for the module, records the function, then deletes
102/// llvm.global_ctors.
103class GlobalCtorDtorScraper {
104public:
105
106  GlobalCtorDtorScraper(GenericLLVMIRPlatformSupport &PS,
107                        StringRef InitFunctionPrefix)
108    : PS(PS), InitFunctionPrefix(InitFunctionPrefix) {}
109  Expected<ThreadSafeModule> operator()(ThreadSafeModule TSM,
110                                        MaterializationResponsibility &R);
111
112private:
113  GenericLLVMIRPlatformSupport &PS;
114  StringRef InitFunctionPrefix;
115};
116
117/// Generic IR Platform Support
118///
119/// Scrapes llvm.global_ctors and llvm.global_dtors and replaces them with
120/// specially named 'init' and 'deinit'. Injects definitions / interposes for
121/// some runtime API, including __cxa_atexit, dlopen, and dlclose.
122class GenericLLVMIRPlatformSupport : public LLJIT::PlatformSupport {
123public:
124  // GenericLLVMIRPlatform &P) : P(P) {
125  GenericLLVMIRPlatformSupport(LLJIT &J)
126      : J(J), InitFunctionPrefix(J.mangle("__orc_init_func.")) {
127
128    getExecutionSession().setPlatform(
129        std::make_unique<GenericLLVMIRPlatform>(*this));
130
131    setInitTransform(J, GlobalCtorDtorScraper(*this, InitFunctionPrefix));
132
133    SymbolMap StdInterposes;
134
135    StdInterposes[J.mangleAndIntern("__lljit.platform_support_instance")] =
136        JITEvaluatedSymbol(pointerToJITTargetAddress(this),
137                           JITSymbolFlags::Exported);
138    StdInterposes[J.mangleAndIntern("__lljit.cxa_atexit_helper")] =
139        JITEvaluatedSymbol(pointerToJITTargetAddress(registerAtExitHelper),
140                           JITSymbolFlags());
141
142    cantFail(
143        J.getMainJITDylib().define(absoluteSymbols(std::move(StdInterposes))));
144    cantFail(setupJITDylib(J.getMainJITDylib()));
145    cantFail(J.addIRModule(J.getMainJITDylib(), createPlatformRuntimeModule()));
146  }
147
148  ExecutionSession &getExecutionSession() { return J.getExecutionSession(); }
149
150  /// Adds a module that defines the __dso_handle global.
151  Error setupJITDylib(JITDylib &JD) {
152
153    // Add per-jitdylib standard interposes.
154    SymbolMap PerJDInterposes;
155    PerJDInterposes[J.mangleAndIntern("__lljit.run_atexits_helper")] =
156        JITEvaluatedSymbol(pointerToJITTargetAddress(runAtExitsHelper),
157                           JITSymbolFlags());
158    cantFail(JD.define(absoluteSymbols(std::move(PerJDInterposes))));
159
160    auto Ctx = std::make_unique<LLVMContext>();
161    auto M = std::make_unique<Module>("__standard_lib", *Ctx);
162    M->setDataLayout(J.getDataLayout());
163
164    auto *Int64Ty = Type::getInt64Ty(*Ctx);
165    auto *DSOHandle = new GlobalVariable(
166        *M, Int64Ty, true, GlobalValue::ExternalLinkage,
167        ConstantInt::get(Int64Ty, reinterpret_cast<uintptr_t>(&JD)),
168        "__dso_handle");
169    DSOHandle->setVisibility(GlobalValue::DefaultVisibility);
170    DSOHandle->setInitializer(
171        ConstantInt::get(Int64Ty, pointerToJITTargetAddress(&JD)));
172
173    auto *GenericIRPlatformSupportTy =
174        StructType::create(*Ctx, "lljit.GenericLLJITIRPlatformSupport");
175
176    auto *PlatformInstanceDecl = new GlobalVariable(
177        *M, GenericIRPlatformSupportTy, true, GlobalValue::ExternalLinkage,
178        nullptr, "__lljit.platform_support_instance");
179
180    auto *VoidTy = Type::getVoidTy(*Ctx);
181    addHelperAndWrapper(
182        *M, "__lljit_run_atexits", FunctionType::get(VoidTy, {}, false),
183        GlobalValue::HiddenVisibility, "__lljit.run_atexits_helper",
184        {PlatformInstanceDecl, DSOHandle});
185
186    return J.addIRModule(JD, ThreadSafeModule(std::move(M), std::move(Ctx)));
187  }
188
189  Error notifyAdding(JITDylib &JD, const MaterializationUnit &MU) {
190    if (auto &InitSym = MU.getInitializerSymbol())
191      InitSymbols[&JD].add(InitSym, SymbolLookupFlags::WeaklyReferencedSymbol);
192    else {
193      // If there's no identified init symbol attached, but there is a symbol
194      // with the GenericIRPlatform::InitFunctionPrefix, then treat that as
195      // an init function. Add the symbol to both the InitSymbols map (which
196      // will trigger a lookup to materialize the module) and the InitFunctions
197      // map (which holds the names of the symbols to execute).
198      for (auto &KV : MU.getSymbols())
199        if ((*KV.first).startswith(InitFunctionPrefix)) {
200          InitSymbols[&JD].add(KV.first,
201                               SymbolLookupFlags::WeaklyReferencedSymbol);
202          InitFunctions[&JD].add(KV.first);
203        }
204    }
205    return Error::success();
206  }
207
208  Error initialize(JITDylib &JD) override {
209    LLVM_DEBUG({
210      dbgs() << "GenericLLVMIRPlatformSupport getting initializers to run\n";
211    });
212    if (auto Initializers = getInitializers(JD)) {
213      LLVM_DEBUG(
214          { dbgs() << "GenericLLVMIRPlatformSupport running initializers\n"; });
215      for (auto InitFnAddr : *Initializers) {
216        LLVM_DEBUG({
217          dbgs() << "  Running init " << formatv("{0:x16}", InitFnAddr)
218                 << "...\n";
219        });
220        auto *InitFn = jitTargetAddressToFunction<void (*)()>(InitFnAddr);
221        InitFn();
222      }
223    } else
224      return Initializers.takeError();
225    return Error::success();
226  }
227
228  Error deinitialize(JITDylib &JD) override {
229    LLVM_DEBUG({
230      dbgs() << "GenericLLVMIRPlatformSupport getting deinitializers to run\n";
231    });
232    if (auto Deinitializers = getDeinitializers(JD)) {
233      LLVM_DEBUG({
234        dbgs() << "GenericLLVMIRPlatformSupport running deinitializers\n";
235      });
236      for (auto DeinitFnAddr : *Deinitializers) {
237        LLVM_DEBUG({
238          dbgs() << "  Running init " << formatv("{0:x16}", DeinitFnAddr)
239                 << "...\n";
240        });
241        auto *DeinitFn = jitTargetAddressToFunction<void (*)()>(DeinitFnAddr);
242        DeinitFn();
243      }
244    } else
245      return Deinitializers.takeError();
246
247    return Error::success();
248  }
249
250  void registerInitFunc(JITDylib &JD, SymbolStringPtr InitName) {
251    getExecutionSession().runSessionLocked([&]() {
252        InitFunctions[&JD].add(InitName);
253      });
254  }
255
256private:
257
258  Expected<std::vector<JITTargetAddress>> getInitializers(JITDylib &JD) {
259    if (auto Err = issueInitLookups(JD))
260      return std::move(Err);
261
262    DenseMap<JITDylib *, SymbolLookupSet> LookupSymbols;
263    std::vector<JITDylib *> DFSLinkOrder;
264
265    getExecutionSession().runSessionLocked([&]() {
266        DFSLinkOrder = getDFSLinkOrder(JD);
267
268        for (auto *NextJD : DFSLinkOrder) {
269          auto IFItr = InitFunctions.find(NextJD);
270          if (IFItr != InitFunctions.end()) {
271            LookupSymbols[NextJD] = std::move(IFItr->second);
272            InitFunctions.erase(IFItr);
273          }
274        }
275      });
276
277    LLVM_DEBUG({
278      dbgs() << "JITDylib init order is [ ";
279      for (auto *JD : llvm::reverse(DFSLinkOrder))
280        dbgs() << "\"" << JD->getName() << "\" ";
281      dbgs() << "]\n";
282      dbgs() << "Looking up init functions:\n";
283      for (auto &KV : LookupSymbols)
284        dbgs() << "  \"" << KV.first->getName() << "\": " << KV.second << "\n";
285    });
286
287    auto &ES = getExecutionSession();
288    auto LookupResult = Platform::lookupInitSymbols(ES, LookupSymbols);
289
290    if (!LookupResult)
291      return LookupResult.takeError();
292
293    std::vector<JITTargetAddress> Initializers;
294    while (!DFSLinkOrder.empty()) {
295      auto &NextJD = *DFSLinkOrder.back();
296      DFSLinkOrder.pop_back();
297      auto InitsItr = LookupResult->find(&NextJD);
298      if (InitsItr == LookupResult->end())
299        continue;
300      for (auto &KV : InitsItr->second)
301        Initializers.push_back(KV.second.getAddress());
302    }
303
304    return Initializers;
305  }
306
307  Expected<std::vector<JITTargetAddress>> getDeinitializers(JITDylib &JD) {
308    auto &ES = getExecutionSession();
309
310    auto LLJITRunAtExits = J.mangleAndIntern("__lljit_run_atexits");
311
312    DenseMap<JITDylib *, SymbolLookupSet> LookupSymbols;
313    std::vector<JITDylib *> DFSLinkOrder;
314
315    ES.runSessionLocked([&]() {
316        DFSLinkOrder = getDFSLinkOrder(JD);
317
318        for (auto *NextJD : DFSLinkOrder) {
319          auto &JDLookupSymbols = LookupSymbols[NextJD];
320          auto DIFItr = DeInitFunctions.find(NextJD);
321          if (DIFItr != DeInitFunctions.end()) {
322            LookupSymbols[NextJD] = std::move(DIFItr->second);
323            DeInitFunctions.erase(DIFItr);
324          }
325          JDLookupSymbols.add(LLJITRunAtExits,
326                            SymbolLookupFlags::WeaklyReferencedSymbol);
327      }
328    });
329
330    LLVM_DEBUG({
331      dbgs() << "JITDylib deinit order is [ ";
332      for (auto *JD : DFSLinkOrder)
333        dbgs() << "\"" << JD->getName() << "\" ";
334      dbgs() << "]\n";
335      dbgs() << "Looking up deinit functions:\n";
336      for (auto &KV : LookupSymbols)
337        dbgs() << "  \"" << KV.first->getName() << "\": " << KV.second << "\n";
338    });
339
340    auto LookupResult = Platform::lookupInitSymbols(ES, LookupSymbols);
341
342    if (!LookupResult)
343      return LookupResult.takeError();
344
345    std::vector<JITTargetAddress> DeInitializers;
346    for (auto *NextJD : DFSLinkOrder) {
347      auto DeInitsItr = LookupResult->find(NextJD);
348      assert(DeInitsItr != LookupResult->end() &&
349             "Every JD should have at least __lljit_run_atexits");
350
351      auto RunAtExitsItr = DeInitsItr->second.find(LLJITRunAtExits);
352      if (RunAtExitsItr != DeInitsItr->second.end())
353        DeInitializers.push_back(RunAtExitsItr->second.getAddress());
354
355      for (auto &KV : DeInitsItr->second)
356        if (KV.first != LLJITRunAtExits)
357          DeInitializers.push_back(KV.second.getAddress());
358    }
359
360    return DeInitializers;
361  }
362
363  // Returns a DFS traversal order of the JITDylibs reachable (via
364  // links-against edges) from JD, starting with JD itself.
365  static std::vector<JITDylib *> getDFSLinkOrder(JITDylib &JD) {
366    std::vector<JITDylib *> DFSLinkOrder;
367    std::vector<JITDylib *> WorkStack({&JD});
368    DenseSet<JITDylib *> Visited;
369
370    while (!WorkStack.empty()) {
371      auto &NextJD = *WorkStack.back();
372      WorkStack.pop_back();
373      if (Visited.count(&NextJD))
374        continue;
375      Visited.insert(&NextJD);
376      DFSLinkOrder.push_back(&NextJD);
377      NextJD.withLinkOrderDo([&](const JITDylibSearchOrder &LinkOrder) {
378        for (auto &KV : LinkOrder)
379          WorkStack.push_back(KV.first);
380      });
381    }
382
383    return DFSLinkOrder;
384  }
385
386  /// Issue lookups for all init symbols required to initialize JD (and any
387  /// JITDylibs that it depends on).
388  Error issueInitLookups(JITDylib &JD) {
389    DenseMap<JITDylib *, SymbolLookupSet> RequiredInitSymbols;
390    std::vector<JITDylib *> DFSLinkOrder;
391
392    getExecutionSession().runSessionLocked([&]() {
393        DFSLinkOrder = getDFSLinkOrder(JD);
394
395        for (auto *NextJD : DFSLinkOrder) {
396          auto ISItr = InitSymbols.find(NextJD);
397          if (ISItr != InitSymbols.end()) {
398            RequiredInitSymbols[NextJD] = std::move(ISItr->second);
399            InitSymbols.erase(ISItr);
400          }
401        }
402      });
403
404    return Platform::lookupInitSymbols(getExecutionSession(),
405                                       RequiredInitSymbols)
406        .takeError();
407  }
408
409  static void registerAtExitHelper(void *Self, void (*F)(void *), void *Ctx,
410                                   void *DSOHandle) {
411    LLVM_DEBUG({
412      dbgs() << "Registering atexit function " << (void *)F << " for JD "
413             << (*static_cast<JITDylib **>(DSOHandle))->getName() << "\n";
414    });
415    static_cast<GenericLLVMIRPlatformSupport *>(Self)->AtExitMgr.registerAtExit(
416        F, Ctx, DSOHandle);
417  }
418
419  static void runAtExitsHelper(void *Self, void *DSOHandle) {
420    LLVM_DEBUG({
421      dbgs() << "Running atexit functions for JD "
422             << (*static_cast<JITDylib **>(DSOHandle))->getName() << "\n";
423    });
424    static_cast<GenericLLVMIRPlatformSupport *>(Self)->AtExitMgr.runAtExits(
425        DSOHandle);
426  }
427
428  // Constructs an LLVM IR module containing platform runtime globals,
429  // functions, and interposes.
430  ThreadSafeModule createPlatformRuntimeModule() {
431    auto Ctx = std::make_unique<LLVMContext>();
432    auto M = std::make_unique<Module>("__standard_lib", *Ctx);
433    M->setDataLayout(J.getDataLayout());
434
435    auto *GenericIRPlatformSupportTy =
436        StructType::create(*Ctx, "lljit.GenericLLJITIRPlatformSupport");
437
438    auto *PlatformInstanceDecl = new GlobalVariable(
439        *M, GenericIRPlatformSupportTy, true, GlobalValue::ExternalLinkage,
440        nullptr, "__lljit.platform_support_instance");
441
442    auto *Int8Ty = Type::getInt8Ty(*Ctx);
443    auto *IntTy = Type::getIntNTy(*Ctx, sizeof(int) * CHAR_BIT);
444    auto *VoidTy = Type::getVoidTy(*Ctx);
445    auto *BytePtrTy = PointerType::getUnqual(Int8Ty);
446    auto *AtExitCallbackTy = FunctionType::get(VoidTy, {BytePtrTy}, false);
447    auto *AtExitCallbackPtrTy = PointerType::getUnqual(AtExitCallbackTy);
448
449    addHelperAndWrapper(
450        *M, "__cxa_atexit",
451        FunctionType::get(IntTy, {AtExitCallbackPtrTy, BytePtrTy, BytePtrTy},
452                          false),
453        GlobalValue::DefaultVisibility, "__lljit.cxa_atexit_helper",
454        {PlatformInstanceDecl});
455
456    return ThreadSafeModule(std::move(M), std::move(Ctx));
457  }
458
459  LLJIT &J;
460  std::string InitFunctionPrefix;
461  DenseMap<JITDylib *, SymbolLookupSet> InitSymbols;
462  DenseMap<JITDylib *, SymbolLookupSet> InitFunctions;
463  DenseMap<JITDylib *, SymbolLookupSet> DeInitFunctions;
464  ItaniumCXAAtExitSupport AtExitMgr;
465};
466
467Error GenericLLVMIRPlatform::setupJITDylib(JITDylib &JD) {
468  return S.setupJITDylib(JD);
469}
470
471Error GenericLLVMIRPlatform::notifyAdding(JITDylib &JD,
472                                          const MaterializationUnit &MU) {
473  return S.notifyAdding(JD, MU);
474}
475
476Expected<ThreadSafeModule>
477GlobalCtorDtorScraper::operator()(ThreadSafeModule TSM,
478                                  MaterializationResponsibility &R) {
479  auto Err = TSM.withModuleDo([&](Module &M) -> Error {
480    auto &Ctx = M.getContext();
481    auto *GlobalCtors = M.getNamedGlobal("llvm.global_ctors");
482
483    // If there's no llvm.global_ctors or it's just a decl then skip.
484    if (!GlobalCtors || GlobalCtors->isDeclaration())
485      return Error::success();
486
487    std::string InitFunctionName;
488    raw_string_ostream(InitFunctionName)
489        << InitFunctionPrefix << M.getModuleIdentifier();
490
491    MangleAndInterner Mangle(PS.getExecutionSession(), M.getDataLayout());
492    auto InternedName = Mangle(InitFunctionName);
493    if (auto Err =
494            R.defineMaterializing({{InternedName, JITSymbolFlags::Callable}}))
495      return Err;
496
497    auto *InitFunc =
498        Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {}, false),
499                         GlobalValue::ExternalLinkage, InitFunctionName, &M);
500    InitFunc->setVisibility(GlobalValue::HiddenVisibility);
501    std::vector<std::pair<Function *, unsigned>> Inits;
502    for (auto E : getConstructors(M))
503      Inits.push_back(std::make_pair(E.Func, E.Priority));
504    llvm::sort(Inits, [](const std::pair<Function *, unsigned> &LHS,
505                         const std::pair<Function *, unsigned> &RHS) {
506      return LHS.first < RHS.first;
507    });
508    auto *EntryBlock = BasicBlock::Create(Ctx, "entry", InitFunc);
509    IRBuilder<> IB(EntryBlock);
510    for (auto &KV : Inits)
511      IB.CreateCall(KV.first);
512    IB.CreateRetVoid();
513
514    PS.registerInitFunc(R.getTargetJITDylib(), InternedName);
515    GlobalCtors->eraseFromParent();
516    return Error::success();
517  });
518
519  if (Err)
520    return std::move(Err);
521
522  return std::move(TSM);
523}
524
525class MachOPlatformSupport : public LLJIT::PlatformSupport {
526public:
527  using DLOpenType = void *(*)(const char *Name, int Mode);
528  using DLCloseType = int (*)(void *Handle);
529  using DLSymType = void *(*)(void *Handle, const char *Name);
530  using DLErrorType = const char *(*)();
531
532  struct DlFcnValues {
533    Optional<void *> RTLDDefault;
534    DLOpenType dlopen = nullptr;
535    DLCloseType dlclose = nullptr;
536    DLSymType dlsym = nullptr;
537    DLErrorType dlerror = nullptr;
538  };
539
540  static Expected<std::unique_ptr<MachOPlatformSupport>>
541  Create(LLJIT &J, JITDylib &PlatformJITDylib) {
542
543    // Make process symbols visible.
544    {
545      std::string ErrMsg;
546      auto Lib = sys::DynamicLibrary::getPermanentLibrary(nullptr, &ErrMsg);
547      if (!Lib.isValid())
548        return make_error<StringError>(std::move(ErrMsg),
549                                       inconvertibleErrorCode());
550    }
551
552    DlFcnValues DlFcn;
553
554    // Add support for RTLDDefault on known platforms.
555#ifdef __APPLE__
556    DlFcn.RTLDDefault = reinterpret_cast<void *>(-2);
557#endif // __APPLE__
558
559    if (auto Err = hookUpFunction(DlFcn.dlopen, "dlopen"))
560      return std::move(Err);
561    if (auto Err = hookUpFunction(DlFcn.dlclose, "dlclose"))
562      return std::move(Err);
563    if (auto Err = hookUpFunction(DlFcn.dlsym, "dlsym"))
564      return std::move(Err);
565    if (auto Err = hookUpFunction(DlFcn.dlerror, "dlerror"))
566      return std::move(Err);
567
568    std::unique_ptr<MachOPlatformSupport> MP(
569        new MachOPlatformSupport(J, PlatformJITDylib, DlFcn));
570    return std::move(MP);
571  }
572
573  Error initialize(JITDylib &JD) override {
574    LLVM_DEBUG({
575      dbgs() << "MachOPlatformSupport initializing \"" << JD.getName()
576             << "\"\n";
577    });
578
579    auto InitSeq = MP.getInitializerSequence(JD);
580    if (!InitSeq)
581      return InitSeq.takeError();
582
583    // If ObjC is not enabled but there are JIT'd ObjC inits then return
584    // an error.
585    if (!objCRegistrationEnabled())
586      for (auto &KV : *InitSeq) {
587        if (!KV.second.getObjCSelRefsSections().empty() ||
588            !KV.second.getObjCClassListSections().empty())
589          return make_error<StringError>("JITDylib " + KV.first->getName() +
590                                             " contains objc metadata but objc"
591                                             " is not enabled",
592                                         inconvertibleErrorCode());
593      }
594
595    // Run the initializers.
596    for (auto &KV : *InitSeq) {
597      if (objCRegistrationEnabled()) {
598        KV.second.registerObjCSelectors();
599        if (auto Err = KV.second.registerObjCClasses()) {
600          // FIXME: Roll back registrations on error?
601          return Err;
602        }
603      }
604      KV.second.runModInits();
605    }
606
607    return Error::success();
608  }
609
610  Error deinitialize(JITDylib &JD) override {
611    auto &ES = J.getExecutionSession();
612    if (auto DeinitSeq = MP.getDeinitializerSequence(JD)) {
613      for (auto &KV : *DeinitSeq) {
614        auto DSOHandleName = ES.intern("___dso_handle");
615
616        // FIXME: Run DeInits here.
617        auto Result = ES.lookup(
618            {{KV.first, JITDylibLookupFlags::MatchAllSymbols}},
619            SymbolLookupSet(DSOHandleName,
620                            SymbolLookupFlags::WeaklyReferencedSymbol));
621        if (!Result)
622          return Result.takeError();
623        if (Result->empty())
624          continue;
625        assert(Result->count(DSOHandleName) &&
626               "Result does not contain __dso_handle");
627        auto *DSOHandle = jitTargetAddressToPointer<void *>(
628            Result->begin()->second.getAddress());
629        AtExitMgr.runAtExits(DSOHandle);
630      }
631    } else
632      return DeinitSeq.takeError();
633    return Error::success();
634  }
635
636private:
637  template <typename FunctionPtrTy>
638  static Error hookUpFunction(FunctionPtrTy &Fn, const char *Name) {
639    if (auto *FnAddr = sys::DynamicLibrary::SearchForAddressOfSymbol(Name)) {
640      Fn = reinterpret_cast<FunctionPtrTy>(Fn);
641      return Error::success();
642    }
643
644    return make_error<StringError>((Twine("Can not enable MachO JIT Platform: "
645                                          "missing function: ") +
646                                    Name)
647                                       .str(),
648                                   inconvertibleErrorCode());
649  }
650
651  MachOPlatformSupport(LLJIT &J, JITDylib &PlatformJITDylib, DlFcnValues DlFcn)
652      : J(J), MP(setupPlatform(J)), DlFcn(std::move(DlFcn)) {
653
654    SymbolMap HelperSymbols;
655
656    // platform and atexit helpers.
657    HelperSymbols[J.mangleAndIntern("__lljit.platform_support_instance")] =
658        JITEvaluatedSymbol(pointerToJITTargetAddress(this), JITSymbolFlags());
659    HelperSymbols[J.mangleAndIntern("__lljit.cxa_atexit_helper")] =
660        JITEvaluatedSymbol(pointerToJITTargetAddress(registerAtExitHelper),
661                           JITSymbolFlags());
662    HelperSymbols[J.mangleAndIntern("__lljit.run_atexits_helper")] =
663        JITEvaluatedSymbol(pointerToJITTargetAddress(runAtExitsHelper),
664                           JITSymbolFlags());
665
666    // dlfcn helpers.
667    HelperSymbols[J.mangleAndIntern("__lljit.dlopen_helper")] =
668        JITEvaluatedSymbol(pointerToJITTargetAddress(dlopenHelper),
669                           JITSymbolFlags());
670    HelperSymbols[J.mangleAndIntern("__lljit.dlclose_helper")] =
671        JITEvaluatedSymbol(pointerToJITTargetAddress(dlcloseHelper),
672                           JITSymbolFlags());
673    HelperSymbols[J.mangleAndIntern("__lljit.dlsym_helper")] =
674        JITEvaluatedSymbol(pointerToJITTargetAddress(dlsymHelper),
675                           JITSymbolFlags());
676    HelperSymbols[J.mangleAndIntern("__lljit.dlerror_helper")] =
677        JITEvaluatedSymbol(pointerToJITTargetAddress(dlerrorHelper),
678                           JITSymbolFlags());
679
680    cantFail(
681        PlatformJITDylib.define(absoluteSymbols(std::move(HelperSymbols))));
682    cantFail(MP.setupJITDylib(J.getMainJITDylib()));
683    cantFail(J.addIRModule(PlatformJITDylib, createPlatformRuntimeModule()));
684  }
685
686  static MachOPlatform &setupPlatform(LLJIT &J) {
687    auto Tmp = std::make_unique<MachOPlatform>(
688        J.getExecutionSession(),
689        static_cast<ObjectLinkingLayer &>(J.getObjLinkingLayer()),
690        createStandardSymbolsObject(J));
691    auto &MP = *Tmp;
692    J.getExecutionSession().setPlatform(std::move(Tmp));
693    return MP;
694  }
695
696  static std::unique_ptr<MemoryBuffer> createStandardSymbolsObject(LLJIT &J) {
697    LLVMContext Ctx;
698    Module M("__standard_symbols", Ctx);
699    M.setDataLayout(J.getDataLayout());
700
701    auto *Int64Ty = Type::getInt64Ty(Ctx);
702
703    auto *DSOHandle =
704        new GlobalVariable(M, Int64Ty, true, GlobalValue::ExternalLinkage,
705                           ConstantInt::get(Int64Ty, 0), "__dso_handle");
706    DSOHandle->setVisibility(GlobalValue::DefaultVisibility);
707
708    return cantFail(J.getIRCompileLayer().getCompiler()(M));
709  }
710
711  ThreadSafeModule createPlatformRuntimeModule() {
712    auto Ctx = std::make_unique<LLVMContext>();
713    auto M = std::make_unique<Module>("__standard_lib", *Ctx);
714    M->setDataLayout(J.getDataLayout());
715
716    auto *MachOPlatformSupportTy =
717        StructType::create(*Ctx, "lljit.MachOPlatformSupport");
718
719    auto *PlatformInstanceDecl = new GlobalVariable(
720        *M, MachOPlatformSupportTy, true, GlobalValue::ExternalLinkage, nullptr,
721        "__lljit.platform_support_instance");
722
723    auto *Int8Ty = Type::getInt8Ty(*Ctx);
724    auto *IntTy = Type::getIntNTy(*Ctx, sizeof(int) * CHAR_BIT);
725    auto *VoidTy = Type::getVoidTy(*Ctx);
726    auto *BytePtrTy = PointerType::getUnqual(Int8Ty);
727    auto *AtExitCallbackTy = FunctionType::get(VoidTy, {BytePtrTy}, false);
728    auto *AtExitCallbackPtrTy = PointerType::getUnqual(AtExitCallbackTy);
729
730    addHelperAndWrapper(
731        *M, "__cxa_atexit",
732        FunctionType::get(IntTy, {AtExitCallbackPtrTy, BytePtrTy, BytePtrTy},
733                          false),
734        GlobalValue::DefaultVisibility, "__lljit.cxa_atexit_helper",
735        {PlatformInstanceDecl});
736
737    addHelperAndWrapper(*M, "dlopen",
738                        FunctionType::get(BytePtrTy, {BytePtrTy, IntTy}, false),
739                        GlobalValue::DefaultVisibility, "__lljit.dlopen_helper",
740                        {PlatformInstanceDecl});
741
742    addHelperAndWrapper(*M, "dlclose",
743                        FunctionType::get(IntTy, {BytePtrTy}, false),
744                        GlobalValue::DefaultVisibility,
745                        "__lljit.dlclose_helper", {PlatformInstanceDecl});
746
747    addHelperAndWrapper(
748        *M, "dlsym",
749        FunctionType::get(BytePtrTy, {BytePtrTy, BytePtrTy}, false),
750        GlobalValue::DefaultVisibility, "__lljit.dlsym_helper",
751        {PlatformInstanceDecl});
752
753    addHelperAndWrapper(*M, "dlerror", FunctionType::get(BytePtrTy, {}, false),
754                        GlobalValue::DefaultVisibility,
755                        "__lljit.dlerror_helper", {PlatformInstanceDecl});
756
757    return ThreadSafeModule(std::move(M), std::move(Ctx));
758  }
759
760  static void registerAtExitHelper(void *Self, void (*F)(void *), void *Ctx,
761                                   void *DSOHandle) {
762    static_cast<MachOPlatformSupport *>(Self)->AtExitMgr.registerAtExit(
763        F, Ctx, DSOHandle);
764  }
765
766  static void runAtExitsHelper(void *Self, void *DSOHandle) {
767    static_cast<MachOPlatformSupport *>(Self)->AtExitMgr.runAtExits(DSOHandle);
768  }
769
770  void *jit_dlopen(const char *Path, int Mode) {
771    JITDylib *JDToOpen = nullptr;
772    // FIXME: Do the right thing with Mode flags.
773    {
774      std::lock_guard<std::mutex> Lock(PlatformSupportMutex);
775
776      // Clear any existing error messages.
777      dlErrorMsgs.erase(std::this_thread::get_id());
778
779      if (auto *JD = J.getExecutionSession().getJITDylibByName(Path)) {
780        auto I = JDRefCounts.find(JD);
781        if (I != JDRefCounts.end()) {
782          ++I->second;
783          return JD;
784        }
785
786        JDRefCounts[JD] = 1;
787        JDToOpen = JD;
788      }
789    }
790
791    if (JDToOpen) {
792      if (auto Err = initialize(*JDToOpen)) {
793        recordError(std::move(Err));
794        return 0;
795      }
796    }
797
798    // Fall through to dlopen if no JITDylib found for Path.
799    return DlFcn.dlopen(Path, Mode);
800  }
801
802  static void *dlopenHelper(void *Self, const char *Path, int Mode) {
803    return static_cast<MachOPlatformSupport *>(Self)->jit_dlopen(Path, Mode);
804  }
805
806  int jit_dlclose(void *Handle) {
807    JITDylib *JDToClose = nullptr;
808
809    {
810      std::lock_guard<std::mutex> Lock(PlatformSupportMutex);
811
812      // Clear any existing error messages.
813      dlErrorMsgs.erase(std::this_thread::get_id());
814
815      auto I = JDRefCounts.find(Handle);
816      if (I != JDRefCounts.end()) {
817        --I->second;
818        if (I->second == 0) {
819          JDRefCounts.erase(I);
820          JDToClose = static_cast<JITDylib *>(Handle);
821        } else
822          return 0;
823      }
824    }
825
826    if (JDToClose) {
827      if (auto Err = deinitialize(*JDToClose)) {
828        recordError(std::move(Err));
829        return -1;
830      }
831      return 0;
832    }
833
834    // Fall through to dlclose if no JITDylib found for Path.
835    return DlFcn.dlclose(Handle);
836  }
837
838  static int dlcloseHelper(void *Self, void *Handle) {
839    return static_cast<MachOPlatformSupport *>(Self)->jit_dlclose(Handle);
840  }
841
842  void *jit_dlsym(void *Handle, const char *Name) {
843    JITDylibSearchOrder JITSymSearchOrder;
844
845    // FIXME: RTLD_NEXT, RTLD_SELF not supported.
846    {
847      std::lock_guard<std::mutex> Lock(PlatformSupportMutex);
848
849      // Clear any existing error messages.
850      dlErrorMsgs.erase(std::this_thread::get_id());
851
852      if (JDRefCounts.count(Handle)) {
853        JITSymSearchOrder.push_back(
854            {static_cast<JITDylib *>(Handle),
855             JITDylibLookupFlags::MatchExportedSymbolsOnly});
856      } else if (Handle == DlFcn.RTLDDefault) {
857        for (auto &KV : JDRefCounts)
858          JITSymSearchOrder.push_back(
859              {static_cast<JITDylib *>(KV.first),
860               JITDylibLookupFlags::MatchExportedSymbolsOnly});
861      }
862    }
863
864    if (!JITSymSearchOrder.empty()) {
865      auto MangledName = J.mangleAndIntern(Name);
866      SymbolLookupSet Syms(MangledName,
867                           SymbolLookupFlags::WeaklyReferencedSymbol);
868      if (auto Result = J.getExecutionSession().lookup(JITSymSearchOrder, Syms,
869                                                       LookupKind::DLSym)) {
870        auto I = Result->find(MangledName);
871        if (I != Result->end())
872          return jitTargetAddressToPointer<void *>(I->second.getAddress());
873      } else {
874        recordError(Result.takeError());
875        return 0;
876      }
877    }
878
879    // Fall through to dlsym.
880    return DlFcn.dlsym(Handle, Name);
881  }
882
883  static void *dlsymHelper(void *Self, void *Handle, const char *Name) {
884    return static_cast<MachOPlatformSupport *>(Self)->jit_dlsym(Handle, Name);
885  }
886
887  const char *jit_dlerror() {
888    {
889      std::lock_guard<std::mutex> Lock(PlatformSupportMutex);
890      auto I = dlErrorMsgs.find(std::this_thread::get_id());
891      if (I != dlErrorMsgs.end())
892        return I->second->c_str();
893    }
894    return DlFcn.dlerror();
895  }
896
897  static const char *dlerrorHelper(void *Self) {
898    return static_cast<MachOPlatformSupport *>(Self)->jit_dlerror();
899  }
900
901  void recordError(Error Err) {
902    std::lock_guard<std::mutex> Lock(PlatformSupportMutex);
903    dlErrorMsgs[std::this_thread::get_id()] =
904        std::make_unique<std::string>(toString(std::move(Err)));
905  }
906
907  std::mutex PlatformSupportMutex;
908  LLJIT &J;
909  MachOPlatform &MP;
910  DlFcnValues DlFcn;
911  ItaniumCXAAtExitSupport AtExitMgr;
912  DenseMap<void *, unsigned> JDRefCounts;
913  std::map<std::thread::id, std::unique_ptr<std::string>> dlErrorMsgs;
914};
915
916} // end anonymous namespace
917
918namespace llvm {
919namespace orc {
920
921void LLJIT::PlatformSupport::setInitTransform(
922    LLJIT &J, IRTransformLayer::TransformFunction T) {
923  J.InitHelperTransformLayer->setTransform(std::move(T));
924}
925
926LLJIT::PlatformSupport::~PlatformSupport() {}
927
928Error LLJITBuilderState::prepareForConstruction() {
929
930  LLVM_DEBUG(dbgs() << "Preparing to create LLIT instance...\n");
931
932  if (!JTMB) {
933    LLVM_DEBUG({
934      dbgs() << "  No explicitly set JITTargetMachineBuilder. "
935                "Detecting host...\n";
936    });
937    if (auto JTMBOrErr = JITTargetMachineBuilder::detectHost())
938      JTMB = std::move(*JTMBOrErr);
939    else
940      return JTMBOrErr.takeError();
941  }
942
943  LLVM_DEBUG({
944    dbgs() << "  JITTargetMachineBuilder is " << JTMB << "\n"
945           << "  Pre-constructed ExecutionSession: " << (ES ? "Yes" : "No")
946           << "\n"
947           << "  DataLayout: ";
948    if (DL)
949      dbgs() << DL->getStringRepresentation() << "\n";
950    else
951      dbgs() << "None (will be created by JITTargetMachineBuilder)\n";
952
953    dbgs() << "  Custom object-linking-layer creator: "
954           << (CreateObjectLinkingLayer ? "Yes" : "No") << "\n"
955           << "  Custom compile-function creator: "
956           << (CreateCompileFunction ? "Yes" : "No") << "\n"
957           << "  Custom platform-setup function: "
958           << (SetUpPlatform ? "Yes" : "No") << "\n"
959           << "  Number of compile threads: " << NumCompileThreads;
960    if (!NumCompileThreads)
961      dbgs() << " (code will be compiled on the execution thread)\n";
962    else
963      dbgs() << "\n";
964  });
965
966  // If the client didn't configure any linker options then auto-configure the
967  // JIT linker.
968  if (!CreateObjectLinkingLayer) {
969    auto &TT = JTMB->getTargetTriple();
970    if (TT.isOSBinFormatMachO() &&
971        (TT.getArch() == Triple::aarch64 || TT.getArch() == Triple::x86_64)) {
972
973      JTMB->setRelocationModel(Reloc::PIC_);
974      JTMB->setCodeModel(CodeModel::Small);
975      CreateObjectLinkingLayer =
976          [](ExecutionSession &ES,
977             const Triple &) -> std::unique_ptr<ObjectLayer> {
978        auto ObjLinkingLayer = std::make_unique<ObjectLinkingLayer>(
979            ES, std::make_unique<jitlink::InProcessMemoryManager>());
980        ObjLinkingLayer->addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
981            jitlink::InProcessEHFrameRegistrar::getInstance()));
982        return std::move(ObjLinkingLayer);
983      };
984    }
985  }
986
987  return Error::success();
988}
989
990LLJIT::~LLJIT() {
991  if (CompileThreads)
992    CompileThreads->wait();
993}
994
995Error LLJIT::addIRModule(JITDylib &JD, ThreadSafeModule TSM) {
996  assert(TSM && "Can not add null module");
997
998  if (auto Err =
999          TSM.withModuleDo([&](Module &M) { return applyDataLayout(M); }))
1000    return Err;
1001
1002  return InitHelperTransformLayer->add(JD, std::move(TSM),
1003                                       ES->allocateVModule());
1004}
1005
1006Error LLJIT::addObjectFile(JITDylib &JD, std::unique_ptr<MemoryBuffer> Obj) {
1007  assert(Obj && "Can not add null object");
1008
1009  return ObjTransformLayer.add(JD, std::move(Obj), ES->allocateVModule());
1010}
1011
1012Expected<JITEvaluatedSymbol> LLJIT::lookupLinkerMangled(JITDylib &JD,
1013                                                        SymbolStringPtr Name) {
1014  return ES->lookup(
1015      makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols), Name);
1016}
1017
1018std::unique_ptr<ObjectLayer>
1019LLJIT::createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES) {
1020
1021  // If the config state provided an ObjectLinkingLayer factory then use it.
1022  if (S.CreateObjectLinkingLayer)
1023    return S.CreateObjectLinkingLayer(ES, S.JTMB->getTargetTriple());
1024
1025  // Otherwise default to creating an RTDyldObjectLinkingLayer that constructs
1026  // a new SectionMemoryManager for each object.
1027  auto GetMemMgr = []() { return std::make_unique<SectionMemoryManager>(); };
1028  auto ObjLinkingLayer =
1029      std::make_unique<RTDyldObjectLinkingLayer>(ES, std::move(GetMemMgr));
1030
1031  if (S.JTMB->getTargetTriple().isOSBinFormatCOFF()) {
1032    ObjLinkingLayer->setOverrideObjectFlagsWithResponsibilityFlags(true);
1033    ObjLinkingLayer->setAutoClaimResponsibilityForObjectSymbols(true);
1034  }
1035
1036  // FIXME: Explicit conversion to std::unique_ptr<ObjectLayer> added to silence
1037  //        errors from some GCC / libstdc++ bots. Remove this conversion (i.e.
1038  //        just return ObjLinkingLayer) once those bots are upgraded.
1039  return std::unique_ptr<ObjectLayer>(std::move(ObjLinkingLayer));
1040}
1041
1042Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>
1043LLJIT::createCompileFunction(LLJITBuilderState &S,
1044                             JITTargetMachineBuilder JTMB) {
1045
1046  /// If there is a custom compile function creator set then use it.
1047  if (S.CreateCompileFunction)
1048    return S.CreateCompileFunction(std::move(JTMB));
1049
1050  // Otherwise default to creating a SimpleCompiler, or ConcurrentIRCompiler,
1051  // depending on the number of threads requested.
1052  if (S.NumCompileThreads > 0)
1053    return std::make_unique<ConcurrentIRCompiler>(std::move(JTMB));
1054
1055  auto TM = JTMB.createTargetMachine();
1056  if (!TM)
1057    return TM.takeError();
1058
1059  return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM));
1060}
1061
1062LLJIT::LLJIT(LLJITBuilderState &S, Error &Err)
1063    : ES(S.ES ? std::move(S.ES) : std::make_unique<ExecutionSession>()), Main(),
1064      DL(""), TT(S.JTMB->getTargetTriple()),
1065      ObjLinkingLayer(createObjectLinkingLayer(S, *ES)),
1066      ObjTransformLayer(*this->ES, *ObjLinkingLayer) {
1067
1068  ErrorAsOutParameter _(&Err);
1069
1070  if (auto MainOrErr = this->ES->createJITDylib("main"))
1071    Main = &*MainOrErr;
1072  else {
1073    Err = MainOrErr.takeError();
1074    return;
1075  }
1076
1077  if (S.DL)
1078    DL = std::move(*S.DL);
1079  else if (auto DLOrErr = S.JTMB->getDefaultDataLayoutForTarget())
1080    DL = std::move(*DLOrErr);
1081  else {
1082    Err = DLOrErr.takeError();
1083    return;
1084  }
1085
1086  {
1087    auto CompileFunction = createCompileFunction(S, std::move(*S.JTMB));
1088    if (!CompileFunction) {
1089      Err = CompileFunction.takeError();
1090      return;
1091    }
1092    CompileLayer = std::make_unique<IRCompileLayer>(
1093        *ES, ObjTransformLayer, std::move(*CompileFunction));
1094    TransformLayer = std::make_unique<IRTransformLayer>(*ES, *CompileLayer);
1095    InitHelperTransformLayer =
1096        std::make_unique<IRTransformLayer>(*ES, *TransformLayer);
1097  }
1098
1099  if (S.NumCompileThreads > 0) {
1100    InitHelperTransformLayer->setCloneToNewContextOnEmit(true);
1101    CompileThreads =
1102        std::make_unique<ThreadPool>(hardware_concurrency(S.NumCompileThreads));
1103    ES->setDispatchMaterialization(
1104        [this](std::unique_ptr<MaterializationUnit> MU,
1105               MaterializationResponsibility MR) {
1106          // FIXME: Switch to move capture once ThreadPool uses unique_function.
1107          auto SharedMU = std::shared_ptr<MaterializationUnit>(std::move(MU));
1108          auto SharedMR =
1109              std::make_shared<MaterializationResponsibility>(std::move(MR));
1110          auto Work = [SharedMU, SharedMR]() mutable {
1111            SharedMU->materialize(std::move(*SharedMR));
1112          };
1113          CompileThreads->async(std::move(Work));
1114        });
1115  }
1116
1117  if (S.SetUpPlatform)
1118    Err = S.SetUpPlatform(*this);
1119  else
1120    setUpGenericLLVMIRPlatform(*this);
1121}
1122
1123std::string LLJIT::mangle(StringRef UnmangledName) const {
1124  std::string MangledName;
1125  {
1126    raw_string_ostream MangledNameStream(MangledName);
1127    Mangler::getNameWithPrefix(MangledNameStream, UnmangledName, DL);
1128  }
1129  return MangledName;
1130}
1131
1132Error LLJIT::applyDataLayout(Module &M) {
1133  if (M.getDataLayout().isDefault())
1134    M.setDataLayout(DL);
1135
1136  if (M.getDataLayout() != DL)
1137    return make_error<StringError>(
1138        "Added modules have incompatible data layouts: " +
1139            M.getDataLayout().getStringRepresentation() + " (module) vs " +
1140            DL.getStringRepresentation() + " (jit)",
1141        inconvertibleErrorCode());
1142
1143  return Error::success();
1144}
1145
1146void setUpGenericLLVMIRPlatform(LLJIT &J) {
1147  LLVM_DEBUG(
1148      { dbgs() << "Setting up GenericLLVMIRPlatform support for LLJIT\n"; });
1149  J.setPlatformSupport(std::make_unique<GenericLLVMIRPlatformSupport>(J));
1150}
1151
1152Error setUpMachOPlatform(LLJIT &J) {
1153  LLVM_DEBUG({ dbgs() << "Setting up MachOPlatform support for LLJIT\n"; });
1154  auto MP = MachOPlatformSupport::Create(J, J.getMainJITDylib());
1155  if (!MP)
1156    return MP.takeError();
1157  J.setPlatformSupport(std::move(*MP));
1158  return Error::success();
1159}
1160
1161Error LLLazyJITBuilderState::prepareForConstruction() {
1162  if (auto Err = LLJITBuilderState::prepareForConstruction())
1163    return Err;
1164  TT = JTMB->getTargetTriple();
1165  return Error::success();
1166}
1167
1168Error LLLazyJIT::addLazyIRModule(JITDylib &JD, ThreadSafeModule TSM) {
1169  assert(TSM && "Can not add null module");
1170
1171  if (auto Err = TSM.withModuleDo(
1172          [&](Module &M) -> Error { return applyDataLayout(M); }))
1173    return Err;
1174
1175  return CODLayer->add(JD, std::move(TSM), ES->allocateVModule());
1176}
1177
1178LLLazyJIT::LLLazyJIT(LLLazyJITBuilderState &S, Error &Err) : LLJIT(S, Err) {
1179
1180  // If LLJIT construction failed then bail out.
1181  if (Err)
1182    return;
1183
1184  ErrorAsOutParameter _(&Err);
1185
1186  /// Take/Create the lazy-compile callthrough manager.
1187  if (S.LCTMgr)
1188    LCTMgr = std::move(S.LCTMgr);
1189  else {
1190    if (auto LCTMgrOrErr = createLocalLazyCallThroughManager(
1191            S.TT, *ES, S.LazyCompileFailureAddr))
1192      LCTMgr = std::move(*LCTMgrOrErr);
1193    else {
1194      Err = LCTMgrOrErr.takeError();
1195      return;
1196    }
1197  }
1198
1199  // Take/Create the indirect stubs manager builder.
1200  auto ISMBuilder = std::move(S.ISMBuilder);
1201
1202  // If none was provided, try to build one.
1203  if (!ISMBuilder)
1204    ISMBuilder = createLocalIndirectStubsManagerBuilder(S.TT);
1205
1206  // No luck. Bail out.
1207  if (!ISMBuilder) {
1208    Err = make_error<StringError>("Could not construct "
1209                                  "IndirectStubsManagerBuilder for target " +
1210                                      S.TT.str(),
1211                                  inconvertibleErrorCode());
1212    return;
1213  }
1214
1215  // Create the COD layer.
1216  CODLayer = std::make_unique<CompileOnDemandLayer>(
1217      *ES, *InitHelperTransformLayer, *LCTMgr, std::move(ISMBuilder));
1218
1219  if (S.NumCompileThreads > 0)
1220    CODLayer->setCloneToNewContextOnEmit(true);
1221}
1222
1223} // End namespace orc.
1224} // End namespace llvm.
1225