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