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(x: Arg->getType());
59 for (auto *T : WrapperFnType->params())
60 HelperArgTypes.push_back(x: T);
61 auto *HelperFnType =
62 FunctionType::get(Result: WrapperFnType->getReturnType(), Params: HelperArgTypes, isVarArg: false);
63 auto *HelperFn = Function::Create(Ty: HelperFnType, Linkage: GlobalValue::ExternalLinkage,
64 N: HelperName, M);
65
66 auto *WrapperFn = Function::Create(
67 Ty: WrapperFnType, Linkage: GlobalValue::ExternalLinkage, N: WrapperName, M);
68 WrapperFn->setVisibility(WrapperVisibility);
69
70 auto *EntryBlock = BasicBlock::Create(Context&: M.getContext(), Name: "entry", Parent: WrapperFn);
71 IRBuilder<> IB(EntryBlock);
72
73 std::vector<Value *> HelperArgs;
74 for (auto *Arg : HelperPrefixArgs)
75 HelperArgs.push_back(x: Arg);
76 for (auto &Arg : WrapperFn->args())
77 HelperArgs.push_back(x: &Arg);
78 auto *HelperResult = IB.CreateCall(Callee: HelperFn, Args: HelperArgs);
79 if (HelperFn->getReturnType()->isVoidTy())
80 IB.CreateRetVoid();
81 else
82 IB.CreateRet(V: 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(UnmangledName: "__orc_init_func.")),
135 DeInitFunctionPrefix(J.mangle(UnmangledName: "__orc_deinit_func.")) {
136
137 getExecutionSession().setPlatform(
138 std::make_unique<GenericLLVMIRPlatform>(args&: *this));
139
140 setInitTransform(J, T: GlobalCtorDtorScraper(*this, InitFunctionPrefix,
141 DeInitFunctionPrefix));
142
143 SymbolMap StdInterposes;
144
145 StdInterposes[J.mangleAndIntern(UnmangledName: "__lljit.platform_support_instance")] = {
146 ExecutorAddr::fromPtr(Ptr: this), JITSymbolFlags::Exported};
147 StdInterposes[J.mangleAndIntern(UnmangledName: "__lljit.cxa_atexit_helper")] = {
148 ExecutorAddr::fromPtr(Ptr: registerCxaAtExitHelper), JITSymbolFlags()};
149
150 cantFail(Err: PlatformJD.define(MU: absoluteSymbols(Symbols: std::move(StdInterposes))));
151 cantFail(Err: setupJITDylib(PlatformJD));
152 cantFail(Err: J.addIRModule(JD&: PlatformJD, TSM: 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(UnmangledName: "__lljit.run_atexits_helper")] = {
163 ExecutorAddr::fromPtr(Ptr: runAtExitsHelper), JITSymbolFlags()};
164 PerJDInterposes[J.mangleAndIntern(UnmangledName: "__lljit.atexit_helper")] = {
165 ExecutorAddr::fromPtr(Ptr: registerAtExitHelper), JITSymbolFlags()};
166 cantFail(Err: JD.define(MU: absoluteSymbols(Symbols: std::move(PerJDInterposes))));
167
168 auto Ctx = std::make_unique<LLVMContext>();
169 auto M = std::make_unique<Module>(args: "__standard_lib", args&: *Ctx);
170 M->setDataLayout(J.getDataLayout());
171
172 auto *Int64Ty = Type::getInt64Ty(C&: *Ctx);
173 auto *DSOHandle = new GlobalVariable(
174 *M, Int64Ty, true, GlobalValue::ExternalLinkage,
175 ConstantInt::get(Ty: Int64Ty, V: reinterpret_cast<uintptr_t>(&JD)),
176 "__dso_handle");
177 DSOHandle->setVisibility(GlobalValue::DefaultVisibility);
178 DSOHandle->setInitializer(
179 ConstantInt::get(Ty: Int64Ty, V: ExecutorAddr::fromPtr(Ptr: &JD).getValue()));
180
181 auto *GenericIRPlatformSupportTy =
182 StructType::create(Context&: *Ctx, Name: "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(C&: *Ctx);
189 addHelperAndWrapper(
190 M&: *M, WrapperName: "__lljit_run_atexits", WrapperFnType: FunctionType::get(Result: VoidTy, Params: {}, isVarArg: false),
191 WrapperVisibility: GlobalValue::HiddenVisibility, HelperName: "__lljit.run_atexits_helper",
192 HelperPrefixArgs: {PlatformInstanceDecl, DSOHandle});
193
194 auto *IntTy = Type::getIntNTy(C&: *Ctx, N: sizeof(int) * CHAR_BIT);
195 auto *AtExitCallbackTy = FunctionType::get(Result: VoidTy, Params: {}, isVarArg: false);
196 auto *AtExitCallbackPtrTy = PointerType::getUnqual(ElementType: AtExitCallbackTy);
197 addHelperAndWrapper(M&: *M, WrapperName: "atexit",
198 WrapperFnType: FunctionType::get(Result: IntTy, Params: {AtExitCallbackPtrTy}, isVarArg: false),
199 WrapperVisibility: GlobalValue::HiddenVisibility, HelperName: "__lljit.atexit_helper",
200 HelperPrefixArgs: {PlatformInstanceDecl, DSOHandle});
201
202 return J.addIRModule(JD, TSM: 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(Name: InitSym, Flags: 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(Prefix: InitFunctionPrefix)) {
217 InitSymbols[&JD].add(Name: KV.first,
218 Flags: SymbolLookupFlags::WeaklyReferencedSymbol);
219 InitFunctions[&JD].add(Name: KV.first);
220 } else if ((*KV.first).starts_with(Prefix: DeInitFunctionPrefix)) {
221 DeInitFunctions[&JD].add(Name: 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(F: [&]() {
271 InitFunctions[&JD].add(Name: InitName);
272 });
273 }
274
275 void registerDeInitFunc(JITDylib &JD, SymbolStringPtr DeInitName) {
276 getExecutionSession().runSessionLocked(
277 F: [&]() { DeInitFunctions[&JD].add(Name: 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(F: [&]() -> 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(Val: NextJD.get());
296 if (IFItr != InitFunctions.end()) {
297 LookupSymbols[NextJD.get()] = std::move(IFItr->second);
298 InitFunctions.erase(I: 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, InitSyms: 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(Val: &NextJD);
326 if (InitsItr == LookupResult->end())
327 continue;
328 for (auto &KV : InitsItr->second)
329 Initializers.push_back(x: 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(UnmangledName: "__lljit_run_atexits");
339
340 DenseMap<JITDylib *, SymbolLookupSet> LookupSymbols;
341 std::vector<JITDylibSP> DFSLinkOrder;
342
343 if (auto Err = ES.runSessionLocked(F: [&]() -> 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(Val: NextJD.get());
352 if (DIFItr != DeInitFunctions.end()) {
353 LookupSymbols[NextJD.get()] = std::move(DIFItr->second);
354 DeInitFunctions.erase(I: DIFItr);
355 }
356 JDLookupSymbols.add(Name: LLJITRunAtExits,
357 Flags: 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, InitSyms: 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(Val: NextJD.get());
381 assert(DeInitsItr != LookupResult->end() &&
382 "Every JD should have at least __lljit_run_atexits");
383
384 auto RunAtExitsItr = DeInitsItr->second.find(Val: LLJITRunAtExits);
385 if (RunAtExitsItr != DeInitsItr->second.end())
386 DeInitializers.push_back(x: RunAtExitsItr->second.getAddress());
387
388 for (auto &KV : DeInitsItr->second)
389 if (KV.first != LLJITRunAtExits)
390 DeInitializers.push_back(x: 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(F: [&]() -> 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(Val: NextJD.get());
410 if (ISItr != InitSymbols.end()) {
411 RequiredInitSymbols[NextJD.get()] = std::move(ISItr->second);
412 InitSymbols.erase(I: ISItr);
413 }
414 }
415 return Error::success();
416 }))
417 return Err;
418
419 return Platform::lookupInitSymbols(ES&: getExecutionSession(),
420 InitSyms: 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 F: reinterpret_cast<void (*)(void *)>(F), Ctx: 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>(args: "__standard_lib", args&: *Ctx);
457 M->setDataLayout(J.getDataLayout());
458
459 auto *GenericIRPlatformSupportTy =
460 StructType::create(Context&: *Ctx, Name: "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(C&: *Ctx);
467 auto *IntTy = Type::getIntNTy(C&: *Ctx, N: sizeof(int) * CHAR_BIT);
468 auto *VoidTy = Type::getVoidTy(C&: *Ctx);
469 auto *BytePtrTy = PointerType::getUnqual(ElementType: Int8Ty);
470 auto *CxaAtExitCallbackTy = FunctionType::get(Result: VoidTy, Params: {BytePtrTy}, isVarArg: false);
471 auto *CxaAtExitCallbackPtrTy = PointerType::getUnqual(ElementType: CxaAtExitCallbackTy);
472
473 addHelperAndWrapper(
474 M&: *M, WrapperName: "__cxa_atexit",
475 WrapperFnType: FunctionType::get(Result: IntTy, Params: {CxaAtExitCallbackPtrTy, BytePtrTy, BytePtrTy},
476 isVarArg: false),
477 WrapperVisibility: GlobalValue::DefaultVisibility, HelperName: "__lljit.cxa_atexit_helper",
478 HelperPrefixArgs: {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(F: [&](Module &M) -> Error {
509 auto &Ctx = M.getContext();
510 auto *GlobalCtors = M.getNamedGlobal(Name: "llvm.global_ctors");
511 auto *GlobalDtors = M.getNamedGlobal(Name: "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 SymbolFlags: {{InternedInitOrDeInitName, JITSymbolFlags::Callable}}))
530 return Err;
531
532 auto *InitOrDeInitFunc = Function::Create(
533 Ty: FunctionType::get(Result: Type::getVoidTy(C&: Ctx), Params: {}, isVarArg: false),
534 Linkage: GlobalValue::ExternalLinkage, N: InitOrDeInitFunctionName, M: &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(x: std::make_pair(x&: E.Func, y&: E.Priority));
541 llvm::sort(C&: InitsOrDeInits, Comp: llvm::less_second());
542
543 auto *InitOrDeInitFuncEntryBlock =
544 BasicBlock::Create(Context&: Ctx, Name: "entry", Parent: InitOrDeInitFunc);
545 IRBuilder<> IB(InitOrDeInitFuncEntryBlock);
546 for (auto &KV : InitsOrDeInits)
547 IB.CreateCall(Callee: KV.first);
548 IB.CreateRetVoid();
549
550 if (isCtor)
551 PS.registerInitFunc(JD&: R.getTargetJITDylib(), InitName: InternedInitOrDeInitName);
552 else
553 PS.registerDeInitFunc(JD&: R.getTargetJITDylib(), DeInitName: 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 F: [](const JITDylibSearchOrder &SO) { return SO; });
614
615 if (auto WrapperAddr = ES.lookup(
616 SearchOrder: MainSearchOrder, Symbol: J.mangleAndIntern(UnmangledName: "__orc_rt_jit_dlopen_wrapper"))) {
617 return ES.callSPSWrapper<SPSDLOpenSig>(WrapperFnAddr: WrapperAddr->getAddress(),
618 WrapperCallArgs&: DSOHandles[&JD], WrapperCallArgs: JD.getName(),
619 WrapperCallArgs: 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 F: [](const JITDylibSearchOrder &SO) { return SO; });
631
632 if (auto WrapperAddr = ES.lookup(
633 SearchOrder: MainSearchOrder, Symbol: J.mangleAndIntern(UnmangledName: "__orc_rt_jit_dlclose_wrapper"))) {
634 int32_t result;
635 auto E = J.getExecutionSession().callSPSWrapper<SPSDLCloseSig>(
636 WrapperFnAddr: WrapperAddr->getAddress(), WrapperCallArgs&: result, WrapperCallArgs&: DSOHandles[&JD]);
637 if (E)
638 return E;
639 else if (result)
640 return make_error<StringError>(Args: "dlclose failed",
641 Args: inconvertibleErrorCode());
642 DSOHandles.erase(Val: &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 if ((ES || EPC) && NumCompileThreads)
671 return make_error<StringError>(
672 Args: "NumCompileThreads cannot be used with a custom ExecutionSession or "
673 "ExecutorProcessControl",
674 Args: inconvertibleErrorCode());
675
676#if !LLVM_ENABLE_THREADS
677 if (NumCompileThreads)
678 return make_error<StringError>(
679 "LLJIT num-compile-threads is " + Twine(NumCompileThreads) +
680 " but LLVM was compiled with LLVM_ENABLE_THREADS=Off",
681 inconvertibleErrorCode());
682#endif // !LLVM_ENABLE_THREADS
683
684 // Only used in debug builds.
685 [[maybe_unused]] bool ConcurrentCompilationSettingDefaulted =
686 !SupportConcurrentCompilation;
687
688 if (!SupportConcurrentCompilation) {
689#if LLVM_ENABLE_THREADS
690 SupportConcurrentCompilation = NumCompileThreads || ES || EPC;
691#else
692 SupportConcurrentCompilation = false;
693#endif // LLVM_ENABLE_THREADS
694 } else {
695#if !LLVM_ENABLE_THREADS
696 if (*SupportConcurrentCompilation)
697 return make_error<StringError>(
698 "LLJIT concurrent compilation support requested, but LLVM was built "
699 "with LLVM_ENABLE_THREADS=Off",
700 inconvertibleErrorCode());
701#endif // !LLVM_ENABLE_THREADS
702 }
703
704 LLVM_DEBUG({
705 dbgs() << " JITTargetMachineBuilder is "
706 << JITTargetMachineBuilderPrinter(*JTMB, " ")
707 << " Pre-constructed ExecutionSession: " << (ES ? "Yes" : "No")
708 << "\n"
709 << " DataLayout: ";
710 if (DL)
711 dbgs() << DL->getStringRepresentation() << "\n";
712 else
713 dbgs() << "None (will be created by JITTargetMachineBuilder)\n";
714
715 dbgs() << " Custom object-linking-layer creator: "
716 << (CreateObjectLinkingLayer ? "Yes" : "No") << "\n"
717 << " Custom compile-function creator: "
718 << (CreateCompileFunction ? "Yes" : "No") << "\n"
719 << " Custom platform-setup function: "
720 << (SetUpPlatform ? "Yes" : "No") << "\n"
721 << " Support concurrent compilation: "
722 << (*SupportConcurrentCompilation ? "Yes" : "No");
723 if (ConcurrentCompilationSettingDefaulted)
724 dbgs() << " (defaulted based on ES / EPC / NumCompileThreads)\n";
725 else
726 dbgs() << "\n";
727 dbgs() << " Number of compile threads: " << NumCompileThreads << "\n";
728 });
729
730 // Create DL if not specified.
731 if (!DL) {
732 if (auto DLOrErr = JTMB->getDefaultDataLayoutForTarget())
733 DL = std::move(*DLOrErr);
734 else
735 return DLOrErr.takeError();
736 }
737
738 // If neither ES nor EPC has been set then create an EPC instance.
739 if (!ES && !EPC) {
740 LLVM_DEBUG({
741 dbgs() << "ExecutorProcessControl not specified, "
742 "Creating SelfExecutorProcessControl instance\n";
743 });
744
745 std::unique_ptr<TaskDispatcher> D = nullptr;
746#if LLVM_ENABLE_THREADS
747 if (*SupportConcurrentCompilation) {
748 std::optional<size_t> NumThreads = std ::nullopt;
749 if (NumCompileThreads)
750 NumThreads = NumCompileThreads;
751 D = std::make_unique<DynamicThreadPoolTaskDispatcher>(args&: NumThreads);
752 } else
753 D = std::make_unique<InPlaceTaskDispatcher>();
754#endif // LLVM_ENABLE_THREADS
755 if (auto EPCOrErr =
756 SelfExecutorProcessControl::Create(SSP: nullptr, D: std::move(D), MemMgr: nullptr))
757 EPC = std::move(*EPCOrErr);
758 else
759 return EPCOrErr.takeError();
760 } else if (EPC) {
761 LLVM_DEBUG({
762 dbgs() << "Using explicitly specified ExecutorProcessControl instance "
763 << EPC.get() << "\n";
764 });
765 } else {
766 LLVM_DEBUG({
767 dbgs() << "Using explicitly specified ExecutionSession instance "
768 << ES.get() << "\n";
769 });
770 }
771
772 // If the client didn't configure any linker options then auto-configure the
773 // JIT linker.
774 if (!CreateObjectLinkingLayer) {
775 auto &TT = JTMB->getTargetTriple();
776 bool UseJITLink = false;
777 switch (TT.getArch()) {
778 case Triple::riscv64:
779 case Triple::loongarch64:
780 UseJITLink = true;
781 break;
782 case Triple::aarch64:
783 UseJITLink = !TT.isOSBinFormatCOFF();
784 break;
785 case Triple::arm:
786 case Triple::armeb:
787 case Triple::thumb:
788 case Triple::thumbeb:
789 UseJITLink = TT.isOSBinFormatELF();
790 break;
791 case Triple::x86_64:
792 UseJITLink = !TT.isOSBinFormatCOFF();
793 break;
794 case Triple::ppc64:
795 UseJITLink = TT.isPPC64ELFv2ABI();
796 break;
797 case Triple::ppc64le:
798 UseJITLink = TT.isOSBinFormatELF();
799 break;
800 default:
801 break;
802 }
803 if (UseJITLink) {
804 JTMB->setRelocationModel(Reloc::PIC_);
805 JTMB->setCodeModel(CodeModel::Small);
806 CreateObjectLinkingLayer =
807 [](ExecutionSession &ES,
808 const Triple &) -> Expected<std::unique_ptr<ObjectLayer>> {
809 auto ObjLinkingLayer = std::make_unique<ObjectLinkingLayer>(args&: ES);
810 if (auto EHFrameRegistrar = EPCEHFrameRegistrar::Create(ES))
811 ObjLinkingLayer->addPlugin(
812 P: std::make_unique<EHFrameRegistrationPlugin>(
813 args&: ES, args: std::move(*EHFrameRegistrar)));
814 else
815 return EHFrameRegistrar.takeError();
816 return std::move(ObjLinkingLayer);
817 };
818 }
819 }
820
821 // If we need a process JITDylib but no setup function has been given then
822 // create a default one.
823 if (!SetupProcessSymbolsJITDylib && LinkProcessSymbolsByDefault) {
824 LLVM_DEBUG(dbgs() << "Creating default Process JD setup function\n");
825 SetupProcessSymbolsJITDylib = [](LLJIT &J) -> Expected<JITDylibSP> {
826 auto &JD =
827 J.getExecutionSession().createBareJITDylib(Name: "<Process Symbols>");
828 auto G = EPCDynamicLibrarySearchGenerator::GetForTargetProcess(
829 ES&: J.getExecutionSession());
830 if (!G)
831 return G.takeError();
832 JD.addGenerator(DefGenerator: std::move(*G));
833 return &JD;
834 };
835 }
836
837 return Error::success();
838}
839
840LLJIT::~LLJIT() {
841 if (auto Err = ES->endSession())
842 ES->reportError(Err: std::move(Err));
843}
844
845JITDylibSP LLJIT::getProcessSymbolsJITDylib() { return ProcessSymbols; }
846
847JITDylibSP LLJIT::getPlatformJITDylib() { return Platform; }
848
849Expected<JITDylib &> LLJIT::createJITDylib(std::string Name) {
850 auto JD = ES->createJITDylib(Name: std::move(Name));
851 if (!JD)
852 return JD.takeError();
853
854 JD->addToLinkOrder(NewLinks: DefaultLinks);
855 return JD;
856}
857
858Expected<JITDylib &> LLJIT::loadPlatformDynamicLibrary(const char *Path) {
859 auto G = EPCDynamicLibrarySearchGenerator::Load(ES&: *ES, LibraryPath: Path);
860 if (!G)
861 return G.takeError();
862
863 if (auto *ExistingJD = ES->getJITDylibByName(Name: Path))
864 return *ExistingJD;
865
866 auto &JD = ES->createBareJITDylib(Name: Path);
867 JD.addGenerator(DefGenerator: std::move(*G));
868 return JD;
869}
870
871Error LLJIT::linkStaticLibraryInto(JITDylib &JD,
872 std::unique_ptr<MemoryBuffer> LibBuffer) {
873 auto G = StaticLibraryDefinitionGenerator::Create(L&: *ObjLinkingLayer,
874 ArchiveBuffer: std::move(LibBuffer));
875 if (!G)
876 return G.takeError();
877
878 JD.addGenerator(DefGenerator: std::move(*G));
879
880 return Error::success();
881}
882
883Error LLJIT::linkStaticLibraryInto(JITDylib &JD, const char *Path) {
884 auto G = StaticLibraryDefinitionGenerator::Load(L&: *ObjLinkingLayer, FileName: Path);
885 if (!G)
886 return G.takeError();
887
888 JD.addGenerator(DefGenerator: std::move(*G));
889
890 return Error::success();
891}
892
893Error LLJIT::addIRModule(ResourceTrackerSP RT, ThreadSafeModule TSM) {
894 assert(TSM && "Can not add null module");
895
896 if (auto Err =
897 TSM.withModuleDo(F: [&](Module &M) { return applyDataLayout(M); }))
898 return Err;
899
900 return InitHelperTransformLayer->add(RT: std::move(RT), TSM: std::move(TSM));
901}
902
903Error LLJIT::addIRModule(JITDylib &JD, ThreadSafeModule TSM) {
904 return addIRModule(RT: JD.getDefaultResourceTracker(), TSM: std::move(TSM));
905}
906
907Error LLJIT::addObjectFile(ResourceTrackerSP RT,
908 std::unique_ptr<MemoryBuffer> Obj) {
909 assert(Obj && "Can not add null object");
910
911 return ObjTransformLayer->add(RT: std::move(RT), O: std::move(Obj));
912}
913
914Error LLJIT::addObjectFile(JITDylib &JD, std::unique_ptr<MemoryBuffer> Obj) {
915 return addObjectFile(RT: JD.getDefaultResourceTracker(), Obj: std::move(Obj));
916}
917
918Expected<ExecutorAddr> LLJIT::lookupLinkerMangled(JITDylib &JD,
919 SymbolStringPtr Name) {
920 if (auto Sym = ES->lookup(
921 SearchOrder: makeJITDylibSearchOrder(JDs: &JD, Flags: JITDylibLookupFlags::MatchAllSymbols),
922 Symbol: Name))
923 return Sym->getAddress();
924 else
925 return Sym.takeError();
926}
927
928Expected<std::unique_ptr<ObjectLayer>>
929LLJIT::createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES) {
930
931 // If the config state provided an ObjectLinkingLayer factory then use it.
932 if (S.CreateObjectLinkingLayer)
933 return S.CreateObjectLinkingLayer(ES, S.JTMB->getTargetTriple());
934
935 // Otherwise default to creating an RTDyldObjectLinkingLayer that constructs
936 // a new SectionMemoryManager for each object.
937 auto GetMemMgr = []() { return std::make_unique<SectionMemoryManager>(); };
938 auto Layer =
939 std::make_unique<RTDyldObjectLinkingLayer>(args&: ES, args: std::move(GetMemMgr));
940
941 if (S.JTMB->getTargetTriple().isOSBinFormatCOFF()) {
942 Layer->setOverrideObjectFlagsWithResponsibilityFlags(true);
943 Layer->setAutoClaimResponsibilityForObjectSymbols(true);
944 }
945
946 if (S.JTMB->getTargetTriple().isOSBinFormatELF() &&
947 (S.JTMB->getTargetTriple().getArch() == Triple::ArchType::ppc64 ||
948 S.JTMB->getTargetTriple().getArch() == Triple::ArchType::ppc64le))
949 Layer->setAutoClaimResponsibilityForObjectSymbols(true);
950
951 // FIXME: Explicit conversion to std::unique_ptr<ObjectLayer> added to silence
952 // errors from some GCC / libstdc++ bots. Remove this conversion (i.e.
953 // just return ObjLinkingLayer) once those bots are upgraded.
954 return std::unique_ptr<ObjectLayer>(std::move(Layer));
955}
956
957Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>
958LLJIT::createCompileFunction(LLJITBuilderState &S,
959 JITTargetMachineBuilder JTMB) {
960
961 /// If there is a custom compile function creator set then use it.
962 if (S.CreateCompileFunction)
963 return S.CreateCompileFunction(std::move(JTMB));
964
965 // If using a custom EPC then use a ConcurrentIRCompiler by default.
966 if (*S.SupportConcurrentCompilation)
967 return std::make_unique<ConcurrentIRCompiler>(args: std::move(JTMB));
968
969 auto TM = JTMB.createTargetMachine();
970 if (!TM)
971 return TM.takeError();
972
973 return std::make_unique<TMOwningSimpleCompiler>(args: std::move(*TM));
974}
975
976LLJIT::LLJIT(LLJITBuilderState &S, Error &Err)
977 : DL(std::move(*S.DL)), TT(S.JTMB->getTargetTriple()) {
978
979 ErrorAsOutParameter _(&Err);
980
981 assert(!(S.EPC && S.ES) && "EPC and ES should not both be set");
982
983 if (S.EPC) {
984 ES = std::make_unique<ExecutionSession>(args: std::move(S.EPC));
985 } else if (S.ES)
986 ES = std::move(S.ES);
987 else {
988 if (auto EPC = SelfExecutorProcessControl::Create()) {
989 ES = std::make_unique<ExecutionSession>(args: std::move(*EPC));
990 } else {
991 Err = EPC.takeError();
992 return;
993 }
994 }
995
996 auto ObjLayer = createObjectLinkingLayer(S, ES&: *ES);
997 if (!ObjLayer) {
998 Err = ObjLayer.takeError();
999 return;
1000 }
1001 ObjLinkingLayer = std::move(*ObjLayer);
1002 ObjTransformLayer =
1003 std::make_unique<ObjectTransformLayer>(args&: *ES, args&: *ObjLinkingLayer);
1004
1005 {
1006 auto CompileFunction = createCompileFunction(S, JTMB: std::move(*S.JTMB));
1007 if (!CompileFunction) {
1008 Err = CompileFunction.takeError();
1009 return;
1010 }
1011 CompileLayer = std::make_unique<IRCompileLayer>(
1012 args&: *ES, args&: *ObjTransformLayer, args: std::move(*CompileFunction));
1013 TransformLayer = std::make_unique<IRTransformLayer>(args&: *ES, args&: *CompileLayer);
1014 InitHelperTransformLayer =
1015 std::make_unique<IRTransformLayer>(args&: *ES, args&: *TransformLayer);
1016 }
1017
1018 if (*S.SupportConcurrentCompilation)
1019 InitHelperTransformLayer->setCloneToNewContextOnEmit(true);
1020
1021 if (S.SetupProcessSymbolsJITDylib) {
1022 if (auto ProcSymsJD = S.SetupProcessSymbolsJITDylib(*this)) {
1023 ProcessSymbols = ProcSymsJD->get();
1024 } else {
1025 Err = ProcSymsJD.takeError();
1026 return;
1027 }
1028 }
1029
1030 if (S.PrePlatformSetup) {
1031 if (auto Err2 = S.PrePlatformSetup(*this)) {
1032 Err = std::move(Err2);
1033 return;
1034 }
1035 }
1036
1037 if (!S.SetUpPlatform)
1038 S.SetUpPlatform = setUpGenericLLVMIRPlatform;
1039
1040 if (auto PlatformJDOrErr = S.SetUpPlatform(*this)) {
1041 Platform = PlatformJDOrErr->get();
1042 if (Platform)
1043 DefaultLinks.push_back(
1044 x: {Platform, JITDylibLookupFlags::MatchExportedSymbolsOnly});
1045 } else {
1046 Err = PlatformJDOrErr.takeError();
1047 return;
1048 }
1049
1050 if (S.LinkProcessSymbolsByDefault)
1051 DefaultLinks.push_back(
1052 x: {ProcessSymbols, JITDylibLookupFlags::MatchExportedSymbolsOnly});
1053
1054 if (auto MainOrErr = createJITDylib(Name: "main"))
1055 Main = &*MainOrErr;
1056 else {
1057 Err = MainOrErr.takeError();
1058 return;
1059 }
1060}
1061
1062std::string LLJIT::mangle(StringRef UnmangledName) const {
1063 std::string MangledName;
1064 {
1065 raw_string_ostream MangledNameStream(MangledName);
1066 Mangler::getNameWithPrefix(OS&: MangledNameStream, GVName: UnmangledName, DL);
1067 }
1068 return MangledName;
1069}
1070
1071Error LLJIT::applyDataLayout(Module &M) {
1072 if (M.getDataLayout().isDefault())
1073 M.setDataLayout(DL);
1074
1075 if (M.getDataLayout() != DL)
1076 return make_error<StringError>(
1077 Args: "Added modules have incompatible data layouts: " +
1078 M.getDataLayout().getStringRepresentation() + " (module) vs " +
1079 DL.getStringRepresentation() + " (jit)",
1080 Args: inconvertibleErrorCode());
1081
1082 return Error::success();
1083}
1084
1085Error setUpOrcPlatformManually(LLJIT &J) {
1086 LLVM_DEBUG({ dbgs() << "Setting up orc platform support for LLJIT\n"; });
1087 J.setPlatformSupport(std::make_unique<ORCPlatformSupport>(args&: J));
1088 return Error::success();
1089}
1090
1091class LoadAndLinkDynLibrary {
1092public:
1093 LoadAndLinkDynLibrary(LLJIT &J) : J(J) {}
1094 Error operator()(JITDylib &JD, StringRef DLLName) {
1095 if (!DLLName.ends_with_insensitive(Suffix: ".dll"))
1096 return make_error<StringError>(Args: "DLLName not ending with .dll",
1097 Args: inconvertibleErrorCode());
1098 auto DLLNameStr = DLLName.str(); // Guarantees null-termination.
1099 auto DLLJD = J.loadPlatformDynamicLibrary(Path: DLLNameStr.c_str());
1100 if (!DLLJD)
1101 return DLLJD.takeError();
1102 JD.addToLinkOrder(JD&: *DLLJD);
1103 return Error::success();
1104 }
1105
1106private:
1107 LLJIT &J;
1108};
1109
1110Expected<JITDylibSP> ExecutorNativePlatform::operator()(LLJIT &J) {
1111 auto ProcessSymbolsJD = J.getProcessSymbolsJITDylib();
1112 if (!ProcessSymbolsJD)
1113 return make_error<StringError>(
1114 Args: "Native platforms require a process symbols JITDylib",
1115 Args: inconvertibleErrorCode());
1116
1117 const Triple &TT = J.getTargetTriple();
1118 ObjectLinkingLayer *ObjLinkingLayer =
1119 dyn_cast<ObjectLinkingLayer>(Val: &J.getObjLinkingLayer());
1120
1121 if (!ObjLinkingLayer)
1122 return make_error<StringError>(
1123 Args: "ExecutorNativePlatform requires ObjectLinkingLayer",
1124 Args: inconvertibleErrorCode());
1125
1126 std::unique_ptr<MemoryBuffer> RuntimeArchiveBuffer;
1127 if (OrcRuntime.index() == 0) {
1128 auto A = errorOrToExpected(EO: MemoryBuffer::getFile(Filename: std::get<0>(v&: OrcRuntime)));
1129 if (!A)
1130 return A.takeError();
1131 RuntimeArchiveBuffer = std::move(*A);
1132 } else
1133 RuntimeArchiveBuffer = std::move(std::get<1>(v&: OrcRuntime));
1134
1135 auto &ES = J.getExecutionSession();
1136 auto &PlatformJD = ES.createBareJITDylib(Name: "<Platform>");
1137 PlatformJD.addToLinkOrder(JD&: *ProcessSymbolsJD);
1138
1139 J.setPlatformSupport(std::make_unique<ORCPlatformSupport>(args&: J));
1140
1141 switch (TT.getObjectFormat()) {
1142 case Triple::COFF: {
1143 const char *VCRuntimePath = nullptr;
1144 bool StaticVCRuntime = false;
1145 if (VCRuntime) {
1146 VCRuntimePath = VCRuntime->first.c_str();
1147 StaticVCRuntime = VCRuntime->second;
1148 }
1149 if (auto P = COFFPlatform::Create(
1150 ES, ObjLinkingLayer&: *ObjLinkingLayer, PlatformJD, OrcRuntimeArchiveBuffer: std::move(RuntimeArchiveBuffer),
1151 LoadDynLibrary: LoadAndLinkDynLibrary(J), StaticVCRuntime, VCRuntimePath))
1152 J.getExecutionSession().setPlatform(std::move(*P));
1153 else
1154 return P.takeError();
1155 break;
1156 }
1157 case Triple::ELF: {
1158 auto G = StaticLibraryDefinitionGenerator::Create(
1159 L&: *ObjLinkingLayer, ArchiveBuffer: std::move(RuntimeArchiveBuffer));
1160 if (!G)
1161 return G.takeError();
1162
1163 if (auto P = ELFNixPlatform::Create(ES, ObjLinkingLayer&: *ObjLinkingLayer, PlatformJD,
1164 OrcRuntime: std::move(*G)))
1165 J.getExecutionSession().setPlatform(std::move(*P));
1166 else
1167 return P.takeError();
1168 break;
1169 }
1170 case Triple::MachO: {
1171 auto G = StaticLibraryDefinitionGenerator::Create(
1172 L&: *ObjLinkingLayer, ArchiveBuffer: std::move(RuntimeArchiveBuffer));
1173 if (!G)
1174 return G.takeError();
1175
1176 if (auto P = MachOPlatform::Create(ES, ObjLinkingLayer&: *ObjLinkingLayer, PlatformJD,
1177 OrcRuntime: std::move(*G)))
1178 ES.setPlatform(std::move(*P));
1179 else
1180 return P.takeError();
1181 break;
1182 }
1183 default:
1184 return make_error<StringError>(Args: "Unsupported object format in triple " +
1185 TT.str(),
1186 Args: inconvertibleErrorCode());
1187 }
1188
1189 return &PlatformJD;
1190}
1191
1192Expected<JITDylibSP> setUpGenericLLVMIRPlatform(LLJIT &J) {
1193 LLVM_DEBUG(
1194 { dbgs() << "Setting up GenericLLVMIRPlatform support for LLJIT\n"; });
1195 auto ProcessSymbolsJD = J.getProcessSymbolsJITDylib();
1196 if (!ProcessSymbolsJD)
1197 return make_error<StringError>(
1198 Args: "Native platforms require a process symbols JITDylib",
1199 Args: inconvertibleErrorCode());
1200
1201 auto &PlatformJD = J.getExecutionSession().createBareJITDylib(Name: "<Platform>");
1202 PlatformJD.addToLinkOrder(JD&: *ProcessSymbolsJD);
1203
1204 J.setPlatformSupport(
1205 std::make_unique<GenericLLVMIRPlatformSupport>(args&: J, args&: PlatformJD));
1206
1207 return &PlatformJD;
1208}
1209
1210Expected<JITDylibSP> setUpInactivePlatform(LLJIT &J) {
1211 LLVM_DEBUG(
1212 { dbgs() << "Explicitly deactivated platform support for LLJIT\n"; });
1213 J.setPlatformSupport(std::make_unique<InactivePlatformSupport>());
1214 return nullptr;
1215}
1216
1217Error LLLazyJITBuilderState::prepareForConstruction() {
1218 if (auto Err = LLJITBuilderState::prepareForConstruction())
1219 return Err;
1220 TT = JTMB->getTargetTriple();
1221 return Error::success();
1222}
1223
1224Error LLLazyJIT::addLazyIRModule(JITDylib &JD, ThreadSafeModule TSM) {
1225 assert(TSM && "Can not add null module");
1226
1227 if (auto Err = TSM.withModuleDo(
1228 F: [&](Module &M) -> Error { return applyDataLayout(M); }))
1229 return Err;
1230
1231 return CODLayer->add(JD, TSM: std::move(TSM));
1232}
1233
1234LLLazyJIT::LLLazyJIT(LLLazyJITBuilderState &S, Error &Err) : LLJIT(S, Err) {
1235
1236 // If LLJIT construction failed then bail out.
1237 if (Err)
1238 return;
1239
1240 ErrorAsOutParameter _(&Err);
1241
1242 /// Take/Create the lazy-compile callthrough manager.
1243 if (S.LCTMgr)
1244 LCTMgr = std::move(S.LCTMgr);
1245 else {
1246 if (auto LCTMgrOrErr = createLocalLazyCallThroughManager(
1247 T: S.TT, ES&: *ES, ErrorHandlerAddr: S.LazyCompileFailureAddr))
1248 LCTMgr = std::move(*LCTMgrOrErr);
1249 else {
1250 Err = LCTMgrOrErr.takeError();
1251 return;
1252 }
1253 }
1254
1255 // Take/Create the indirect stubs manager builder.
1256 auto ISMBuilder = std::move(S.ISMBuilder);
1257
1258 // If none was provided, try to build one.
1259 if (!ISMBuilder)
1260 ISMBuilder = createLocalIndirectStubsManagerBuilder(T: S.TT);
1261
1262 // No luck. Bail out.
1263 if (!ISMBuilder) {
1264 Err = make_error<StringError>(Args: "Could not construct "
1265 "IndirectStubsManagerBuilder for target " +
1266 S.TT.str(),
1267 Args: inconvertibleErrorCode());
1268 return;
1269 }
1270
1271 // Create the COD layer.
1272 CODLayer = std::make_unique<CompileOnDemandLayer>(
1273 args&: *ES, args&: *InitHelperTransformLayer, args&: *LCTMgr, args: std::move(ISMBuilder));
1274
1275 if (*S.SupportConcurrentCompilation)
1276 CODLayer->setCloneToNewContextOnEmit(true);
1277}
1278
1279// In-process LLJIT uses eh-frame section wrappers via EPC, so we need to force
1280// them to be linked in.
1281LLVM_ATTRIBUTE_USED void linkComponents() {
1282 errs() << (void *)&llvm_orc_registerEHFrameSectionWrapper
1283 << (void *)&llvm_orc_deregisterEHFrameSectionWrapper;
1284}
1285
1286} // End namespace orc.
1287} // End namespace llvm.
1288

source code of llvm/lib/ExecutionEngine/Orc/LLJIT.cpp