30#define DEBUG_TYPE "orc"
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);
62 FunctionType::get(WrapperFnType->getReturnType(), HelperArgTypes,
false);
68 WrapperFn->setVisibility(WrapperVisibility);
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())
82 IB.CreateRet(HelperResult);
87class GenericLLVMIRPlatformSupport;
91class GenericLLVMIRPlatform :
public Platform {
93 GenericLLVMIRPlatform(GenericLLVMIRPlatformSupport &S) : S(S) {}
104 GenericLLVMIRPlatformSupport &S;
110class GlobalCtorDtorScraper {
112 GlobalCtorDtorScraper(GenericLLVMIRPlatformSupport &PS,
115 : PS(PS), InitFunctionPrefix(InitFunctionPrefix),
116 DeInitFunctionPrefix(DeInitFunctionPrefix) {}
121 GenericLLVMIRPlatformSupport &PS;
134 : J(J), InitFunctionPrefix(J.
mangle(
"__orc_init_func.")),
135 DeInitFunctionPrefix(J.
mangle(
"__orc_deinit_func.")) {
138 std::make_unique<GenericLLVMIRPlatform>(*
this));
141 DeInitFunctionPrefix));
145 StdInterposes[J.
mangleAndIntern(
"__lljit.platform_support_instance")] = {
151 cantFail(setupJITDylib(PlatformJD));
168 auto Ctx = std::make_unique<LLVMContext>();
169 auto M = std::make_unique<Module>(
"__standard_lib", *Ctx);
175 ConstantInt::get(Int64Ty,
reinterpret_cast<uintptr_t
>(&JD)),
178 DSOHandle->setInitializer(
181 auto *GenericIRPlatformSupportTy =
186 nullptr,
"__lljit.platform_support_instance");
190 *M,
"__lljit_run_atexits", FunctionType::get(VoidTy, {},
false),
192 {PlatformInstanceDecl, DSOHandle});
197 addHelperAndWrapper(*M,
"atexit",
198 FunctionType::get(IntTy, {AtExitCallbackPtrTy},
false),
200 {PlatformInstanceDecl, DSOHandle});
208 InitSymbols[&JD].add(InitSym, SymbolLookupFlags::WeaklyReferencedSymbol);
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);
229 dbgs() <<
"GenericLLVMIRPlatformSupport getting initializers to run\n";
231 if (
auto Initializers = getInitializers(JD)) {
233 {
dbgs() <<
"GenericLLVMIRPlatformSupport running initializers\n"; });
234 for (
auto InitFnAddr : *Initializers) {
236 dbgs() <<
" Running init " <<
formatv(
"{0:x16}", InitFnAddr)
239 auto *InitFn = InitFnAddr.toPtr<void (*)()>();
243 return Initializers.takeError();
249 dbgs() <<
"GenericLLVMIRPlatformSupport getting deinitializers to run\n";
251 if (
auto Deinitializers = getDeinitializers(JD)) {
253 dbgs() <<
"GenericLLVMIRPlatformSupport running deinitializers\n";
255 for (
auto DeinitFnAddr : *Deinitializers) {
257 dbgs() <<
" Running deinit " <<
formatv(
"{0:x16}", DeinitFnAddr)
260 auto *DeinitFn = DeinitFnAddr.toPtr<void (*)()>();
264 return Deinitializers.takeError();
271 InitFunctions[&JD].add(InitName);
277 [&]() { DeInitFunctions[&JD].add(DeInitName); });
282 if (
auto Err = issueInitLookups(JD))
283 return std::move(Err);
286 std::vector<JITDylibSP> DFSLinkOrder;
290 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
292 return DFSLinkOrderOrErr.takeError();
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);
303 return std::move(Err);
306 dbgs() <<
"JITDylib init order is [ ";
310 dbgs() <<
"Looking up init functions:\n";
311 for (
auto &KV : LookupSymbols)
312 dbgs() <<
" \"" << KV.first->getName() <<
"\": " << KV.second <<
"\n";
319 return LookupResult.takeError();
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())
328 for (
auto &KV : InitsItr->second)
329 Initializers.push_back(KV.second.getAddress());
341 std::vector<JITDylibSP> DFSLinkOrder;
343 if (
auto Err = ES.runSessionLocked([&]() ->
Error {
344 if (auto DFSLinkOrderOrErr = JD.getDFSLinkOrder())
345 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
347 return DFSLinkOrderOrErr.takeError();
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);
356 JDLookupSymbols.add(LLJITRunAtExits,
357 SymbolLookupFlags::WeaklyReferencedSymbol);
361 return std::move(Err);
364 dbgs() <<
"JITDylib deinit order is [ ";
365 for (
auto &JD : DFSLinkOrder)
368 dbgs() <<
"Looking up deinit functions:\n";
369 for (
auto &KV : LookupSymbols)
370 dbgs() <<
" \"" << KV.first->getName() <<
"\": " << KV.second <<
"\n";
376 return LookupResult.takeError();
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");
384 auto RunAtExitsItr = DeInitsItr->second.find(LLJITRunAtExits);
385 if (RunAtExitsItr != DeInitsItr->second.end())
386 DeInitializers.push_back(RunAtExitsItr->second.getAddress());
388 for (
auto &KV : DeInitsItr->second)
389 if (KV.first != LLJITRunAtExits)
390 DeInitializers.push_back(KV.second.getAddress());
393 return DeInitializers;
400 std::vector<JITDylibSP> DFSLinkOrder;
402 if (
auto Err = getExecutionSession().runSessionLocked([&]() ->
Error {
404 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
406 return DFSLinkOrderOrErr.takeError();
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);
424 static void registerCxaAtExitHelper(
void *Self,
void (*
F)(
void *),
void *Ctx,
427 dbgs() <<
"Registering cxa atexit function " << (
void *)
F <<
" for JD "
430 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.registerAtExit(
434 static void registerAtExitHelper(
void *Self,
void *DSOHandle,
void (*
F)()) {
436 dbgs() <<
"Registering atexit function " << (
void *)
F <<
" for JD "
439 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.registerAtExit(
440 reinterpret_cast<void (*)(
void *)
>(
F),
nullptr, DSOHandle);
443 static void runAtExitsHelper(
void *Self,
void *DSOHandle) {
445 dbgs() <<
"Running atexit functions for JD "
446 << (*
static_cast<JITDylib **
>(DSOHandle))->getName() <<
"\n";
448 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.runAtExits(
455 auto Ctx = std::make_unique<LLVMContext>();
456 auto M = std::make_unique<Module>(
"__standard_lib", *Ctx);
457 M->setDataLayout(J.getDataLayout());
459 auto *GenericIRPlatformSupportTy =
464 nullptr,
"__lljit.platform_support_instance");
469 auto *BytePtrTy = PointerType::getUnqual(Int8Ty);
470 auto *CxaAtExitCallbackTy = FunctionType::get(VoidTy, {BytePtrTy},
false);
471 auto *CxaAtExitCallbackPtrTy = PointerType::getUnqual(CxaAtExitCallbackTy);
475 FunctionType::get(IntTy, {CxaAtExitCallbackPtrTy, BytePtrTy, BytePtrTy},
478 {PlatformInstanceDecl});
484 std::string InitFunctionPrefix;
485 std::string DeInitFunctionPrefix;
493 return S.setupJITDylib(JD);
502 return S.notifyAdding(RT, MU);
509 auto &Ctx =
M.getContext();
510 auto *GlobalCtors =
M.getNamedGlobal(
"llvm.global_ctors");
511 auto *GlobalDtors =
M.getNamedGlobal(
"llvm.global_dtors");
514 bool isCtor) ->
Error {
518 std::string InitOrDeInitFunctionName;
521 << InitFunctionPrefix <<
M.getModuleIdentifier();
524 << DeInitFunctionPrefix <<
M.getModuleIdentifier();
527 auto InternedInitOrDeInitName =
Mangle(InitOrDeInitFunctionName);
528 if (
auto Err =
R.defineMaterializing(
529 {{InternedInitOrDeInitName, JITSymbolFlags::Callable}}))
536 std::vector<std::pair<Function *, unsigned>> InitsOrDeInits;
539 for (
auto E : COrDtors)
540 InitsOrDeInits.push_back(std::make_pair(E.Func, E.Priority));
543 auto *InitOrDeInitFuncEntryBlock =
546 for (
auto &KV : InitsOrDeInits)
547 IB.CreateCall(KV.first);
551 PS.registerInitFunc(
R.getTargetJITDylib(), InternedInitOrDeInitName);
553 PS.registerDeInitFunc(
R.getTargetJITDylib(), InternedInitOrDeInitName);
559 if (
auto Err = RegisterCOrDtors(GlobalCtors,
true))
561 if (
auto Err = RegisterCOrDtors(GlobalDtors,
false))
568 return std::move(Err);
570 return std::move(TSM);
579 InactivePlatformSupport() =
default;
582 LLVM_DEBUG(
dbgs() <<
"InactivePlatformSupport: no initializers running for "
589 dbgs() <<
"InactivePlatformSupport: no deinitializers running for "
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
615 if (
auto WrapperAddr = ES.lookup(
617 return ES.callSPSWrapper<SPSDLOpenSig>(WrapperAddr->getAddress(),
619 int32_t(ORC_RT_RTLD_LAZY));
621 return WrapperAddr.takeError();
626 using SPSDLCloseSig = int32_t(SPSExecutorAddr);
632 if (
auto WrapperAddr = ES.lookup(
636 WrapperAddr->getAddress(), result, DSOHandles[&JD]);
640 return make_error<StringError>(
"dlclose failed",
642 DSOHandles.erase(&JD);
644 return WrapperAddr.takeError();
661 dbgs() <<
" No explicitly set JITTargetMachineBuilder. "
662 "Detecting host...\n";
665 JTMB = std::move(*JTMBOrErr);
667 return JTMBOrErr.takeError();
670 if ((
ES || EPC) && NumCompileThreads)
671 return make_error<StringError>(
672 "NumCompileThreads cannot be used with a custom ExecutionSession or "
673 "ExecutorProcessControl",
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",
685 [[maybe_unused]]
bool ConcurrentCompilationSettingDefaulted =
686 !SupportConcurrentCompilation;
688 if (!SupportConcurrentCompilation) {
689#if LLVM_ENABLE_THREADS
690 SupportConcurrentCompilation = NumCompileThreads ||
ES || EPC;
692 SupportConcurrentCompilation =
false;
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",
705 dbgs() <<
" JITTargetMachineBuilder is "
707 <<
" Pre-constructed ExecutionSession: " << (
ES ?
"Yes" :
"No")
713 dbgs() <<
"None (will be created by JITTargetMachineBuilder)\n";
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";
727 dbgs() <<
" Number of compile threads: " << NumCompileThreads <<
"\n";
732 if (
auto DLOrErr = JTMB->getDefaultDataLayoutForTarget())
733 DL = std::move(*DLOrErr);
735 return DLOrErr.takeError();
741 dbgs() <<
"ExecutorProcessControl not specified, "
742 "Creating SelfExecutorProcessControl instance\n";
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>(NumThreads);
753 D = std::make_unique<InPlaceTaskDispatcher>();
757 EPC = std::move(*EPCOrErr);
759 return EPCOrErr.takeError();
762 dbgs() <<
"Using explicitly specified ExecutorProcessControl instance "
763 << EPC.get() <<
"\n";
767 dbgs() <<
"Using explicitly specified ExecutionSession instance "
774 if (!CreateObjectLinkingLayer) {
775 auto &
TT = JTMB->getTargetTriple();
776 bool UseJITLink =
false;
804 if (!JTMB->getCodeModel())
807 CreateObjectLinkingLayer =
813 std::make_unique<EHFrameRegistrationPlugin>(
814 ES, std::move(*EHFrameRegistrar)));
816 return EHFrameRegistrar.takeError();
824 if (!SetupProcessSymbolsJITDylib && LinkProcessSymbolsByDefault) {
825 LLVM_DEBUG(
dbgs() <<
"Creating default Process JD setup function\n");
830 J.getExecutionSession());
832 return G.takeError();
842 if (
auto Err =
ES->endSession())
843 ES->reportError(std::move(Err));
851 auto JD =
ES->createJITDylib(std::move(
Name));
853 return JD.takeError();
862 return G.takeError();
864 if (
auto *ExistingJD =
ES->getJITDylibByName(Path))
867 auto &JD =
ES->createBareJITDylib(Path);
873 std::unique_ptr<MemoryBuffer> LibBuffer) {
875 std::move(LibBuffer));
877 return G.takeError();
887 return G.takeError();
895 assert(TSM &&
"Can not add null module");
909 std::unique_ptr<MemoryBuffer> Obj) {
910 assert(Obj &&
"Can not add null object");
921 if (
auto Sym =
ES->lookup(
924 return Sym->getAddress();
926 return Sym.takeError();
938 auto GetMemMgr = []() {
return std::make_unique<SectionMemoryManager>(); };
940 std::make_unique<RTDyldObjectLinkingLayer>(
ES, std::move(GetMemMgr));
942 if (S.
JTMB->getTargetTriple().isOSBinFormatCOFF()) {
943 Layer->setOverrideObjectFlagsWithResponsibilityFlags(
true);
944 Layer->setAutoClaimResponsibilityForObjectSymbols(
true);
947 if (S.
JTMB->getTargetTriple().isOSBinFormatELF() &&
950 Layer->setAutoClaimResponsibilityForObjectSymbols(
true);
955 return std::unique_ptr<ObjectLayer>(std::move(Layer));
968 return std::make_unique<ConcurrentIRCompiler>(std::move(JTMB));
972 return TM.takeError();
974 return std::make_unique<TMOwningSimpleCompiler>(std::move(*
TM));
982 assert(!(S.
EPC && S.
ES) &&
"EPC and ES should not both be set");
985 ES = std::make_unique<ExecutionSession>(std::move(S.
EPC));
987 ES = std::move(S.
ES);
990 ES = std::make_unique<ExecutionSession>(std::move(*EPC));
992 Err = EPC.takeError();
999 Err = ObjLayer.takeError();
1008 if (!CompileFunction) {
1009 Err = CompileFunction.takeError();
1026 Err = ProcSymsJD.takeError();
1033 Err = std::move(Err2);
1047 Err = PlatformJDOrErr.takeError();
1058 Err = MainOrErr.takeError();
1064 std::string MangledName;
1073 if (M.getDataLayout().isDefault())
1074 M.setDataLayout(
DL);
1076 if (M.getDataLayout() !=
DL)
1077 return make_error<StringError>(
1078 "Added modules have incompatible data layouts: " +
1079 M.getDataLayout().getStringRepresentation() +
" (module) vs " +
1087 LLVM_DEBUG({
dbgs() <<
"Setting up orc platform support for LLJIT\n"; });
1097 return make_error<StringError>(
"DLLName not ending with .dll",
1099 auto DLLNameStr = DLLName.
str();
1102 return DLLJD.takeError();
1113 if (!ProcessSymbolsJD)
1114 return make_error<StringError>(
1115 "Native platforms require a process symbols JITDylib",
1122 if (!ObjLinkingLayer)
1123 return make_error<StringError>(
1124 "ExecutorNativePlatform requires ObjectLinkingLayer",
1127 std::unique_ptr<MemoryBuffer> RuntimeArchiveBuffer;
1128 if (OrcRuntime.index() == 0) {
1131 return A.takeError();
1132 RuntimeArchiveBuffer = std::move(*
A);
1134 RuntimeArchiveBuffer = std::move(std::get<1>(OrcRuntime));
1142 switch (TT.getObjectFormat()) {
1144 const char *VCRuntimePath =
nullptr;
1145 bool StaticVCRuntime =
false;
1147 VCRuntimePath = VCRuntime->first.c_str();
1148 StaticVCRuntime = VCRuntime->second;
1151 ES, *ObjLinkingLayer, PlatformJD, std::move(RuntimeArchiveBuffer),
1155 return P.takeError();
1160 *ObjLinkingLayer, std::move(RuntimeArchiveBuffer));
1162 return G.takeError();
1168 return P.takeError();
1173 *ObjLinkingLayer, std::move(RuntimeArchiveBuffer));
1175 return G.takeError();
1179 ES.setPlatform(std::move(*
P));
1181 return P.takeError();
1185 return make_error<StringError>(
"Unsupported object format in triple " +
1195 {
dbgs() <<
"Setting up GenericLLVMIRPlatform support for LLJIT\n"; });
1197 if (!ProcessSymbolsJD)
1198 return make_error<StringError>(
1199 "Native platforms require a process symbols JITDylib",
1206 std::make_unique<GenericLLVMIRPlatformSupport>(J, PlatformJD));
1213 {
dbgs() <<
"Explicitly deactivated platform support for LLJIT\n"; });
1221 TT =
JTMB->getTargetTriple();
1226 assert(TSM &&
"Can not add null module");
1229 [&](
Module &M) ->
Error { return applyDataLayout(M); }))
1232 return CODLayer->add(JD, std::move(TSM));
1245 LCTMgr = std::move(S.
LCTMgr);
1249 LCTMgr = std::move(*LCTMgrOrErr);
1251 Err = LCTMgrOrErr.takeError();
1265 Err = make_error<StringError>(
"Could not construct "
1266 "IndirectStubsManagerBuilder for target " +
1273 CODLayer = std::make_unique<CompileOnDemandLayer>(
1277 CODLayer->setCloneToNewContextOnEmit(
true);
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define LLVM_ATTRIBUTE_USED
Module.h This file contains the declarations for the Module class.
const char LLVMTargetMachineRef TM
static StringRef getName(Value *V)
llvm::orc::shared::CWrapperFunctionResult llvm_orc_deregisterEHFrameSectionWrapper(const char *Data, uint64_t Size)
llvm::orc::shared::CWrapperFunctionResult llvm_orc_registerEHFrameSectionWrapper(const char *Data, uint64_t Size)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
const std::string & getStringRepresentation() const
Returns the string representation of the DataLayout.
Helper for Errors used as out-parameters.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
VisibilityTypes
An enumeration for the kinds of visibility of global values.
@ DefaultVisibility
The GV is visible.
@ HiddenVisibility
The GV is hidden.
@ ExternalLinkage
Externally visible function.
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Flags for symbols in the JIT.
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
A Module instance is used to store all the information related to an LLVM module.
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
StringRef - Represent a constant reference to a string, i.e.
std::string str() const
str - Get the contents as an std::string.
bool ends_with_insensitive(StringRef Suffix) const
Check if this string ends with the given Suffix, ignoring case.
static StructType * create(LLVMContext &Context, StringRef Name)
This creates an identified struct.
Triple - Helper class for working with autoconf configuration names.
bool isPPC64ELFv2ABI() const
Tests whether the target 64-bit PowerPC big endian ABI is ELFv2.
ArchType getArch() const
Get the parsed architecture type of this triple.
bool isOSBinFormatCOFF() const
Tests whether the OS uses the COFF binary format.
const std::string & str() const
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
static Type * getVoidTy(LLVMContext &C)
static IntegerType * getInt8Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
const std::string & getName() const
Get the name for this JITLinkDylib.
static Expected< std::unique_ptr< EPCDynamicLibrarySearchGenerator > > Load(ExecutionSession &ES, const char *LibraryPath, SymbolPredicate Allow=SymbolPredicate(), AddAbsoluteSymbolsFn AddAbsoluteSymbols=nullptr)
Permanently loads the library at the given path and, on success, returns a DynamicLibrarySearchGenera...
static Expected< std::unique_ptr< EPCDynamicLibrarySearchGenerator > > GetForTargetProcess(ExecutionSession &ES, SymbolPredicate Allow=SymbolPredicate(), AddAbsoluteSymbolsFn AddAbsoluteSymbols=nullptr)
Creates a EPCDynamicLibrarySearchGenerator that searches for symbols in the target process.
static Expected< std::unique_ptr< EPCEHFrameRegistrar > > Create(ExecutionSession &ES)
Create from a ExecutorProcessControl instance alone.
An ExecutionSession represents a running JIT program.
void setPlatform(std::unique_ptr< Platform > P)
Set the Platform for this ExecutionSession.
Error callSPSWrapper(ExecutorAddr WrapperFnAddr, WrapperCallArgTs &&...WrapperCallArgs)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
JITDylib & createBareJITDylib(std::string Name)
Add a new bare JITDylib to this ExecutionSession.
decltype(auto) runSessionLocked(Func &&F)
Run the given lambda with the session mutex locked.
static ExecutorAddr fromPtr(T *Ptr, UnwrapFn &&Unwrap=UnwrapFn())
Create an ExecutorAddr from the given pointer.
An interface for Itanium __cxa_atexit interposer implementations.
Represents a JIT'd dynamic library.
Error define(std::unique_ptr< MaterializationUnitType > &&MU, ResourceTrackerSP RT=nullptr)
Define all symbols provided by the materialization unit to be part of this JITDylib.
ExecutionSession & getExecutionSession() const
Get a reference to the ExecutionSession for this JITDylib.
void addToLinkOrder(const JITDylibSearchOrder &NewLinks)
Append the given JITDylibSearchOrder to the link order for this JITDylib (discarding any elements alr...
static Expected< std::vector< JITDylibSP > > getDFSLinkOrder(ArrayRef< JITDylibSP > JDs)
Returns the given JITDylibs and all of their transitive dependencies in DFS order (based on linkage r...
auto withLinkOrderDo(Func &&F) -> decltype(F(std::declval< const JITDylibSearchOrder & >()))
Do something with the link order (run under the session lock).
ResourceTrackerSP getDefaultResourceTracker()
Get the default resource tracker for this JITDylib.
GeneratorT & addGenerator(std::unique_ptr< GeneratorT > DefGenerator)
Adds a definition generator to this JITDylib and returns a referenece to it.
A utility class for building TargetMachines for JITs.
static Expected< JITTargetMachineBuilder > detectHost()
Create a JITTargetMachineBuilder for the host system.
Expected< std::unique_ptr< TargetMachine > > createTargetMachine()
Create a TargetMachine.
Error prepareForConstruction()
Called prior to JIT class construcion to fix up defaults.
ProcessSymbolsJITDylibSetupFunction SetupProcessSymbolsJITDylib
ObjectLinkingLayerCreator CreateObjectLinkingLayer
std::unique_ptr< ExecutionSession > ES
unique_function< Error(LLJIT &)> PrePlatformSetup
CompileFunctionCreator CreateCompileFunction
std::optional< bool > SupportConcurrentCompilation
bool LinkProcessSymbolsByDefault
std::unique_ptr< ExecutorProcessControl > EPC
std::optional< JITTargetMachineBuilder > JTMB
PlatformSetupFunction SetUpPlatform
A pre-fabricated ORC JIT stack that can serve as an alternative to MCJIT.
static Expected< std::unique_ptr< ObjectLayer > > createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES)
void setPlatformSupport(std::unique_ptr< PlatformSupport > PS)
Set the PlatformSupport instance.
std::unique_ptr< ExecutionSession > ES
LLJIT(LLJITBuilderState &S, Error &Err)
Create an LLJIT instance with a single compile thread.
Error addObjectFile(ResourceTrackerSP RT, std::unique_ptr< MemoryBuffer > Obj)
Adds an object file to the given JITDylib.
Expected< JITDylib & > createJITDylib(std::string Name)
Create a new JITDylib with the given name and return a reference to it.
JITDylib & getMainJITDylib()
Returns a reference to the JITDylib representing the JIT'd main program.
JITDylibSearchOrder DefaultLinks
const DataLayout & getDataLayout() const
Returns a reference to the DataLayout for this instance.
ObjectLayer & getObjLinkingLayer()
Returns a reference to the ObjLinkingLayer.
std::unique_ptr< ObjectTransformLayer > ObjTransformLayer
friend Expected< JITDylibSP > setUpGenericLLVMIRPlatform(LLJIT &J)
Configure the LLJIT instance to scrape modules for llvm.global_ctors and llvm.global_dtors variables ...
virtual ~LLJIT()
Destruct this instance.
std::string mangle(StringRef UnmangledName) const
Returns a linker-mangled version of UnmangledName.
JITDylibSP getPlatformJITDylib()
Returns the Platform JITDylib, which will contain the ORC runtime (if given) and any platform symbols...
Expected< JITDylib & > loadPlatformDynamicLibrary(const char *Path)
Load a (real) dynamic library and make its symbols available through a new JITDylib with the same nam...
std::unique_ptr< IRTransformLayer > InitHelperTransformLayer
std::unique_ptr< IRCompileLayer > CompileLayer
const Triple & getTargetTriple() const
Returns a reference to the triple for this instance.
JITDylibSP getProcessSymbolsJITDylib()
Returns the ProcessSymbols JITDylib, which by default reflects non-JIT'd symbols in the host process.
Expected< ExecutorAddr > lookupLinkerMangled(JITDylib &JD, SymbolStringPtr Name)
Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to look up symbols based on thei...
static Expected< std::unique_ptr< IRCompileLayer::IRCompiler > > createCompileFunction(LLJITBuilderState &S, JITTargetMachineBuilder JTMB)
JITDylib * ProcessSymbols
ExecutionSession & getExecutionSession()
Returns the ExecutionSession for this instance.
std::unique_ptr< IRTransformLayer > TransformLayer
SymbolStringPtr mangleAndIntern(StringRef UnmangledName) const
Returns an interned, linker-mangled version of UnmangledName.
Error linkStaticLibraryInto(JITDylib &JD, std::unique_ptr< MemoryBuffer > LibBuffer)
Link a static library into the given JITDylib.
Error applyDataLayout(Module &M)
std::unique_ptr< ObjectLayer > ObjLinkingLayer
Error addIRModule(ResourceTrackerSP RT, ThreadSafeModule TSM)
Adds an IR module with the given ResourceTracker.
ExecutorAddr LazyCompileFailureAddr
std::unique_ptr< LazyCallThroughManager > LCTMgr
Error prepareForConstruction()
IndirectStubsManagerBuilderFunction ISMBuilder
Error addLazyIRModule(JITDylib &JD, ThreadSafeModule M)
Add a module to be lazily compiled to JITDylib JD.
LoadAndLinkDynLibrary(LLJIT &J)
Error operator()(JITDylib &JD, StringRef DLLName)
Mangles symbol names then uniques them in the context of an ExecutionSession.
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
A MaterializationUnit represents a set of symbol definitions that can be materialized as a group,...
const SymbolFlagsMap & getSymbols() const
Return the set of symbols that this source provides.
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization symbol for this MaterializationUnit (if any).
An ObjectLayer implementation built on JITLink.
API to remove / transfer ownership of JIT resources.
JITDylib & getJITDylib() const
Return the JITDylib targeted by this tracker.
static Expected< std::unique_ptr< SelfExecutorProcessControl > > Create(std::shared_ptr< SymbolStringPool > SSP=nullptr, std::unique_ptr< TaskDispatcher > D=nullptr, std::unique_ptr< jitlink::JITLinkMemoryManager > MemMgr=nullptr)
Create a SelfExecutorProcessControl with the given symbol string pool and memory manager.
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Load(ObjectLayer &L, const char *FileName, GetObjectFileInterface GetObjFileInterface=GetObjectFileInterface())
Try to create a StaticLibraryDefinitionGenerator from the given path.
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Create(ObjectLayer &L, std::unique_ptr< MemoryBuffer > ArchiveBuffer, std::unique_ptr< object::Archive > Archive, GetObjectFileInterface GetObjFileInterface=GetObjectFileInterface())
Try to create a StaticLibrarySearchGenerator from the given memory buffer and Archive object.
Pointer to a pooled string representing a symbol name.
An LLVM Module together with a shared ThreadSafeContext.
decltype(auto) withModuleDo(Func &&F)
Locks the associated ThreadSafeContext and calls the given function on the contained Module.
SPS tag type for sequences.
A raw_ostream that writes to an std::string.
JITDylibSearchOrder makeJITDylibSearchOrder(ArrayRef< JITDylib * > JDs, JITDylibLookupFlags Flags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Convenience function for creating a search order from an ArrayRef of JITDylib*, all with the same fla...
iterator_range< CtorDtorIterator > getDestructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
std::vector< std::pair< JITDylib *, JITDylibLookupFlags > > JITDylibSearchOrder
A list of (JITDylib*, JITDylibLookupFlags) pairs to be used as a search order during symbol lookup.
std::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols)
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
iterator_range< CtorDtorIterator > getConstructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
@ MatchExportedSymbolsOnly
Expected< JITDylibSP > setUpInactivePlatform(LLJIT &J)
Configure the LLJIT instance to disable platform support explicitly.
LLVM_ATTRIBUTE_USED void linkComponents()
std::function< std::unique_ptr< IndirectStubsManager >()> createLocalIndirectStubsManagerBuilder(const Triple &T)
Create a local indirect stubs manager builder.
Expected< std::unique_ptr< LazyCallThroughManager > > createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES, ExecutorAddr ErrorHandlerAddr)
Create a LocalLazyCallThroughManager from the given triple and execution session.
Expected< JITDylibSP > setUpGenericLLVMIRPlatform(LLJIT &J)
Configure the LLJIT instance to scrape modules for llvm.global_ctors and llvm.global_dtors variables ...
Error setUpOrcPlatformManually(LLJIT &J)
Configure the LLJIT instance to use orc runtime support.
This is an optimization pass for GlobalISel generic memory operations.
void stable_sort(R &&Range)
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
auto reverse(ContainerTy &&C)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Expected< T > errorOrToExpected(ErrorOr< T > &&EO)
Convert an ErrorOr<T> to an Expected<T>.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Implement std::hash so that hash_code can be used in STL containers.
Function object to check whether the second component of a container supported by std::get (like std:...