12#include "llvm/Config/llvm-config.h"
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 auto *AtExit = addHelperAndWrapper(
198 *M,
"atexit", FunctionType::get(IntTy, {AtExitCallbackPtrTy},
false),
200 {PlatformInstanceDecl, DSOHandle});
204 AtExit->addRetAttr(AtExitExtAttr);
212 InitSymbols[&JD].add(InitSym, SymbolLookupFlags::WeaklyReferencedSymbol);
220 if ((*KV.first).starts_with(InitFunctionPrefix)) {
221 InitSymbols[&JD].add(KV.first,
222 SymbolLookupFlags::WeaklyReferencedSymbol);
223 InitFunctions[&JD].add(KV.first);
224 }
else if ((*KV.first).starts_with(DeInitFunctionPrefix)) {
225 DeInitFunctions[&JD].add(KV.first);
233 dbgs() <<
"GenericLLVMIRPlatformSupport getting initializers to run\n";
235 if (
auto Initializers = getInitializers(JD)) {
237 {
dbgs() <<
"GenericLLVMIRPlatformSupport running initializers\n"; });
238 for (
auto InitFnAddr : *Initializers) {
240 dbgs() <<
" Running init " <<
formatv(
"{0:x16}", InitFnAddr)
243 auto *InitFn = InitFnAddr.toPtr<void (*)()>();
247 return Initializers.takeError();
253 dbgs() <<
"GenericLLVMIRPlatformSupport getting deinitializers to run\n";
255 if (
auto Deinitializers = getDeinitializers(JD)) {
257 dbgs() <<
"GenericLLVMIRPlatformSupport running deinitializers\n";
259 for (
auto DeinitFnAddr : *Deinitializers) {
261 dbgs() <<
" Running deinit " <<
formatv(
"{0:x16}", DeinitFnAddr)
264 auto *DeinitFn = DeinitFnAddr.toPtr<void (*)()>();
268 return Deinitializers.takeError();
275 InitFunctions[&JD].add(InitName);
281 [&]() { DeInitFunctions[&JD].add(DeInitName); });
286 if (
auto Err = issueInitLookups(JD))
287 return std::move(Err);
290 std::vector<JITDylibSP> DFSLinkOrder;
294 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
296 return DFSLinkOrderOrErr.takeError();
298 for (
auto &NextJD : DFSLinkOrder) {
299 auto IFItr = InitFunctions.find(NextJD.get());
300 if (IFItr != InitFunctions.end()) {
301 LookupSymbols[NextJD.get()] = std::move(IFItr->second);
302 InitFunctions.erase(IFItr);
307 return std::move(Err);
310 dbgs() <<
"JITDylib init order is [ ";
314 dbgs() <<
"Looking up init functions:\n";
315 for (
auto &KV : LookupSymbols)
316 dbgs() <<
" \"" << KV.first->getName() <<
"\": " << KV.second <<
"\n";
323 return LookupResult.takeError();
325 std::vector<ExecutorAddr> Initializers;
326 while (!DFSLinkOrder.empty()) {
327 auto &NextJD = *DFSLinkOrder.back();
328 DFSLinkOrder.pop_back();
329 auto InitsItr = LookupResult->find(&NextJD);
330 if (InitsItr == LookupResult->end())
332 for (
auto &KV : InitsItr->second)
333 Initializers.push_back(KV.second.getAddress());
345 std::vector<JITDylibSP> DFSLinkOrder;
347 if (
auto Err = ES.runSessionLocked([&]() ->
Error {
348 if (auto DFSLinkOrderOrErr = JD.getDFSLinkOrder())
349 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
351 return DFSLinkOrderOrErr.takeError();
353 for (auto &NextJD : DFSLinkOrder) {
354 auto &JDLookupSymbols = LookupSymbols[NextJD.get()];
355 auto DIFItr = DeInitFunctions.find(NextJD.get());
356 if (DIFItr != DeInitFunctions.end()) {
357 LookupSymbols[NextJD.get()] = std::move(DIFItr->second);
358 DeInitFunctions.erase(DIFItr);
360 JDLookupSymbols.add(LLJITRunAtExits,
361 SymbolLookupFlags::WeaklyReferencedSymbol);
365 return std::move(Err);
368 dbgs() <<
"JITDylib deinit order is [ ";
369 for (
auto &JD : DFSLinkOrder)
372 dbgs() <<
"Looking up deinit functions:\n";
373 for (
auto &KV : LookupSymbols)
374 dbgs() <<
" \"" << KV.first->getName() <<
"\": " << KV.second <<
"\n";
380 return LookupResult.takeError();
382 std::vector<ExecutorAddr> DeInitializers;
383 for (
auto &NextJD : DFSLinkOrder) {
384 auto DeInitsItr = LookupResult->find(NextJD.get());
385 assert(DeInitsItr != LookupResult->end() &&
386 "Every JD should have at least __lljit_run_atexits");
388 auto RunAtExitsItr = DeInitsItr->second.find(LLJITRunAtExits);
389 if (RunAtExitsItr != DeInitsItr->second.end())
390 DeInitializers.push_back(RunAtExitsItr->second.getAddress());
392 for (
auto &KV : DeInitsItr->second)
393 if (KV.first != LLJITRunAtExits)
394 DeInitializers.push_back(KV.second.getAddress());
397 return DeInitializers;
404 std::vector<JITDylibSP> DFSLinkOrder;
406 if (
auto Err = getExecutionSession().runSessionLocked([&]() ->
Error {
408 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
410 return DFSLinkOrderOrErr.takeError();
412 for (
auto &NextJD : DFSLinkOrder) {
413 auto ISItr = InitSymbols.find(NextJD.get());
414 if (ISItr != InitSymbols.end()) {
415 RequiredInitSymbols[NextJD.get()] = std::move(ISItr->second);
416 InitSymbols.erase(ISItr);
428 static void registerCxaAtExitHelper(
void *Self,
void (*
F)(
void *),
void *Ctx,
431 dbgs() <<
"Registering cxa atexit function " << (
void *)
F <<
" for JD "
434 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.registerAtExit(
438 static void registerAtExitHelper(
void *Self,
void *DSOHandle,
void (*
F)()) {
440 dbgs() <<
"Registering atexit function " << (
void *)
F <<
" for JD "
443 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.registerAtExit(
444 reinterpret_cast<void (*)(
void *)
>(
F),
nullptr, DSOHandle);
447 static void runAtExitsHelper(
void *Self,
void *DSOHandle) {
449 dbgs() <<
"Running atexit functions for JD "
450 << (*
static_cast<JITDylib **
>(DSOHandle))->getName() <<
"\n";
452 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.runAtExits(
459 auto Ctx = std::make_unique<LLVMContext>();
460 auto M = std::make_unique<Module>(
"__standard_lib", *Ctx);
461 M->setDataLayout(J.getDataLayout());
463 auto *GenericIRPlatformSupportTy =
468 nullptr,
"__lljit.platform_support_instance");
473 auto *BytePtrTy = PointerType::getUnqual(Int8Ty);
474 auto *CxaAtExitCallbackTy = FunctionType::get(VoidTy, {BytePtrTy},
false);
475 auto *CxaAtExitCallbackPtrTy = PointerType::getUnqual(CxaAtExitCallbackTy);
477 auto *CxaAtExit = addHelperAndWrapper(
479 FunctionType::get(IntTy, {CxaAtExitCallbackPtrTy, BytePtrTy, BytePtrTy},
482 {PlatformInstanceDecl});
484 TargetLibraryInfo::getExtAttrForI32Return(J.getTargetTriple());
486 CxaAtExit->addRetAttr(CxaAtExitExtAttr);
492 std::string InitFunctionPrefix;
493 std::string DeInitFunctionPrefix;
501 return S.setupJITDylib(JD);
510 return S.notifyAdding(RT, MU);
517 auto &Ctx =
M.getContext();
518 auto *GlobalCtors =
M.getNamedGlobal(
"llvm.global_ctors");
519 auto *GlobalDtors =
M.getNamedGlobal(
"llvm.global_dtors");
522 bool isCtor) ->
Error {
526 std::string InitOrDeInitFunctionName;
529 << InitFunctionPrefix <<
M.getModuleIdentifier();
532 << DeInitFunctionPrefix <<
M.getModuleIdentifier();
535 auto InternedInitOrDeInitName =
Mangle(InitOrDeInitFunctionName);
536 if (
auto Err =
R.defineMaterializing(
537 {{InternedInitOrDeInitName, JITSymbolFlags::Callable}}))
544 std::vector<std::pair<Function *, unsigned>> InitsOrDeInits;
547 for (
auto E : COrDtors)
548 InitsOrDeInits.push_back(std::make_pair(E.Func, E.Priority));
551 auto *InitOrDeInitFuncEntryBlock =
554 for (
auto &KV : InitsOrDeInits)
555 IB.CreateCall(KV.first);
559 PS.registerInitFunc(
R.getTargetJITDylib(), InternedInitOrDeInitName);
561 PS.registerDeInitFunc(
R.getTargetJITDylib(), InternedInitOrDeInitName);
567 if (
auto Err = RegisterCOrDtors(GlobalCtors,
true))
569 if (
auto Err = RegisterCOrDtors(GlobalDtors,
false))
576 return std::move(Err);
578 return std::move(TSM);
587 InactivePlatformSupport() =
default;
590 LLVM_DEBUG(
dbgs() <<
"InactivePlatformSupport: no initializers running for "
597 dbgs() <<
"InactivePlatformSupport: no deinitializers running for "
611 using SPSDLOpenSig = SPSExecutorAddr(SPSString, int32_t);
612 using SPSDLUpdateSig = int32_t(SPSExecutorAddr);
613 enum dlopen_mode : int32_t {
614 ORC_RT_RTLD_LAZY = 0x1,
615 ORC_RT_RTLD_NOW = 0x2,
616 ORC_RT_RTLD_LOCAL = 0x4,
617 ORC_RT_RTLD_GLOBAL = 0x8
623 StringRef WrapperToCall =
"__orc_rt_jit_dlopen_wrapper";
624 bool dlupdate =
false;
625 const Triple &TT = ES.getTargetTriple();
626 if (TT.isOSBinFormatMachO() || TT.isOSBinFormatELF()) {
627 if (InitializedDylib.contains(&JD)) {
628 WrapperToCall =
"__orc_rt_jit_dlupdate_wrapper";
631 InitializedDylib.insert(&JD);
634 if (
auto WrapperAddr =
638 auto E = ES.callSPSWrapper<SPSDLUpdateSig>(WrapperAddr->getAddress(),
639 result, DSOHandles[&JD]);
641 return make_error<StringError>(
"dlupdate failed",
645 return ES.callSPSWrapper<SPSDLOpenSig>(WrapperAddr->getAddress(),
647 int32_t(ORC_RT_RTLD_LAZY));
649 return WrapperAddr.takeError();
654 using SPSDLCloseSig = int32_t(SPSExecutorAddr);
660 if (
auto WrapperAddr = ES.lookup(
664 WrapperAddr->getAddress(), result, DSOHandles[&JD]);
668 return make_error<StringError>(
"dlclose failed",
670 DSOHandles.erase(&JD);
671 InitializedDylib.erase(&JD);
673 return WrapperAddr.takeError();
690 dbgs() <<
" No explicitly set JITTargetMachineBuilder. "
691 "Detecting host...\n";
694 JTMB = std::move(*JTMBOrErr);
696 return JTMBOrErr.takeError();
699 if ((
ES || EPC) && NumCompileThreads)
700 return make_error<StringError>(
701 "NumCompileThreads cannot be used with a custom ExecutionSession or "
702 "ExecutorProcessControl",
705#if !LLVM_ENABLE_THREADS
706 if (NumCompileThreads)
707 return make_error<StringError>(
708 "LLJIT num-compile-threads is " +
Twine(NumCompileThreads) +
709 " but LLVM was compiled with LLVM_ENABLE_THREADS=Off",
714 [[maybe_unused]]
bool ConcurrentCompilationSettingDefaulted =
715 !SupportConcurrentCompilation;
717 if (!SupportConcurrentCompilation) {
718#if LLVM_ENABLE_THREADS
719 SupportConcurrentCompilation = NumCompileThreads ||
ES || EPC;
721 SupportConcurrentCompilation =
false;
724#if !LLVM_ENABLE_THREADS
725 if (*SupportConcurrentCompilation)
726 return make_error<StringError>(
727 "LLJIT concurrent compilation support requested, but LLVM was built "
728 "with LLVM_ENABLE_THREADS=Off",
734 dbgs() <<
" JITTargetMachineBuilder is "
736 <<
" Pre-constructed ExecutionSession: " << (
ES ?
"Yes" :
"No")
742 dbgs() <<
"None (will be created by JITTargetMachineBuilder)\n";
744 dbgs() <<
" Custom object-linking-layer creator: "
745 << (CreateObjectLinkingLayer ?
"Yes" :
"No") <<
"\n"
746 <<
" Custom compile-function creator: "
747 << (CreateCompileFunction ?
"Yes" :
"No") <<
"\n"
748 <<
" Custom platform-setup function: "
749 << (SetUpPlatform ?
"Yes" :
"No") <<
"\n"
750 <<
" Support concurrent compilation: "
751 << (*SupportConcurrentCompilation ?
"Yes" :
"No");
752 if (ConcurrentCompilationSettingDefaulted)
753 dbgs() <<
" (defaulted based on ES / EPC / NumCompileThreads)\n";
756 dbgs() <<
" Number of compile threads: " << NumCompileThreads <<
"\n";
761 if (
auto DLOrErr = JTMB->getDefaultDataLayoutForTarget())
762 DL = std::move(*DLOrErr);
764 return DLOrErr.takeError();
770 dbgs() <<
"ExecutorProcessControl not specified, "
771 "Creating SelfExecutorProcessControl instance\n";
774 std::unique_ptr<TaskDispatcher>
D =
nullptr;
775#if LLVM_ENABLE_THREADS
776 if (*SupportConcurrentCompilation) {
777 std::optional<size_t> NumThreads = std ::nullopt;
778 if (NumCompileThreads)
779 NumThreads = NumCompileThreads;
780 D = std::make_unique<DynamicThreadPoolTaskDispatcher>(NumThreads);
782 D = std::make_unique<InPlaceTaskDispatcher>();
786 EPC = std::move(*EPCOrErr);
788 return EPCOrErr.takeError();
791 dbgs() <<
"Using explicitly specified ExecutorProcessControl instance "
792 << EPC.get() <<
"\n";
796 dbgs() <<
"Using explicitly specified ExecutionSession instance "
803 if (!CreateObjectLinkingLayer) {
804 auto &
TT = JTMB->getTargetTriple();
805 bool UseJITLink =
false;
833 if (!JTMB->getCodeModel())
836 CreateObjectLinkingLayer =
842 std::make_unique<EHFrameRegistrationPlugin>(
843 ES, std::move(*EHFrameRegistrar)));
845 return EHFrameRegistrar.takeError();
853 if (!SetupProcessSymbolsJITDylib && LinkProcessSymbolsByDefault) {
854 LLVM_DEBUG(
dbgs() <<
"Creating default Process JD setup function\n");
859 J.getExecutionSession());
861 return G.takeError();
871 if (
auto Err =
ES->endSession())
872 ES->reportError(std::move(Err));
880 auto JD =
ES->createJITDylib(std::move(
Name));
882 return JD.takeError();
891 return G.takeError();
893 if (
auto *ExistingJD =
ES->getJITDylibByName(Path))
896 auto &JD =
ES->createBareJITDylib(Path);
902 std::unique_ptr<MemoryBuffer> LibBuffer) {
904 std::move(LibBuffer));
906 return G.takeError();
916 return G.takeError();
924 assert(TSM &&
"Can not add null module");
938 std::unique_ptr<MemoryBuffer> Obj) {
939 assert(Obj &&
"Can not add null object");
950 if (
auto Sym =
ES->lookup(
953 return Sym->getAddress();
955 return Sym.takeError();
967 auto GetMemMgr = []() {
return std::make_unique<SectionMemoryManager>(); };
969 std::make_unique<RTDyldObjectLinkingLayer>(
ES, std::move(GetMemMgr));
971 if (S.
JTMB->getTargetTriple().isOSBinFormatCOFF()) {
972 Layer->setOverrideObjectFlagsWithResponsibilityFlags(
true);
973 Layer->setAutoClaimResponsibilityForObjectSymbols(
true);
976 if (S.
JTMB->getTargetTriple().isOSBinFormatELF() &&
979 Layer->setAutoClaimResponsibilityForObjectSymbols(
true);
984 return std::unique_ptr<ObjectLayer>(std::move(Layer));
997 return std::make_unique<ConcurrentIRCompiler>(std::move(JTMB));
1001 return TM.takeError();
1003 return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM));
1011 assert(!(S.
EPC && S.
ES) &&
"EPC and ES should not both be set");
1014 ES = std::make_unique<ExecutionSession>(std::move(S.
EPC));
1016 ES = std::move(S.
ES);
1019 ES = std::make_unique<ExecutionSession>(std::move(*EPC));
1021 Err = EPC.takeError();
1028 Err = ObjLayer.takeError();
1037 if (!CompileFunction) {
1038 Err = CompileFunction.takeError();
1055 Err = ProcSymsJD.takeError();
1062 Err = std::move(Err2);
1076 Err = PlatformJDOrErr.takeError();
1087 Err = MainOrErr.takeError();
1093 std::string MangledName;
1102 if (M.getDataLayout().isDefault())
1103 M.setDataLayout(
DL);
1105 if (M.getDataLayout() !=
DL)
1106 return make_error<StringError>(
1107 "Added modules have incompatible data layouts: " +
1108 M.getDataLayout().getStringRepresentation() +
" (module) vs " +
1116 LLVM_DEBUG({
dbgs() <<
"Setting up orc platform support for LLJIT\n"; });
1126 return make_error<StringError>(
"DLLName not ending with .dll",
1128 auto DLLNameStr = DLLName.
str();
1131 return DLLJD.takeError();
1142 if (!ProcessSymbolsJD)
1143 return make_error<StringError>(
1144 "Native platforms require a process symbols JITDylib",
1151 if (!ObjLinkingLayer)
1152 return make_error<StringError>(
1153 "ExecutorNativePlatform requires ObjectLinkingLayer",
1156 std::unique_ptr<MemoryBuffer> RuntimeArchiveBuffer;
1157 if (OrcRuntime.index() == 0) {
1160 return A.takeError();
1161 RuntimeArchiveBuffer = std::move(*
A);
1163 RuntimeArchiveBuffer = std::move(std::get<1>(OrcRuntime));
1171 switch (TT.getObjectFormat()) {
1173 const char *VCRuntimePath =
nullptr;
1174 bool StaticVCRuntime =
false;
1176 VCRuntimePath = VCRuntime->first.c_str();
1177 StaticVCRuntime = VCRuntime->second;
1180 *ObjLinkingLayer, PlatformJD, std::move(RuntimeArchiveBuffer),
1184 return P.takeError();
1189 *ObjLinkingLayer, std::move(RuntimeArchiveBuffer));
1191 return G.takeError();
1197 return P.takeError();
1202 *ObjLinkingLayer, std::move(RuntimeArchiveBuffer));
1204 return G.takeError();
1208 ES.setPlatform(std::move(*
P));
1210 return P.takeError();
1214 return make_error<StringError>(
"Unsupported object format in triple " +
1224 {
dbgs() <<
"Setting up GenericLLVMIRPlatform support for LLJIT\n"; });
1226 if (!ProcessSymbolsJD)
1227 return make_error<StringError>(
1228 "Native platforms require a process symbols JITDylib",
1235 std::make_unique<GenericLLVMIRPlatformSupport>(J, PlatformJD));
1242 {
dbgs() <<
"Explicitly deactivated platform support for LLJIT\n"; });
1250 TT =
JTMB->getTargetTriple();
1255 assert(TSM &&
"Can not add null module");
1258 [&](
Module &M) ->
Error { return applyDataLayout(M); }))
1261 return CODLayer->add(JD, std::move(TSM));
1274 LCTMgr = std::move(S.
LCTMgr);
1278 LCTMgr = std::move(*LCTMgrOrErr);
1280 Err = LCTMgrOrErr.takeError();
1294 Err = make_error<StringError>(
"Could not construct "
1295 "IndirectStubsManagerBuilder for target " +
1305 CODLayer = std::make_unique<CompileOnDemandLayer>(*
ES, *IPLayer, *LCTMgr,
1306 std::move(ISMBuilder));
1309 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.
static StringRef getName(Value *V)
LLVM_ABI llvm::orc::shared::CWrapperFunctionResult llvm_orc_deregisterEHFrameSectionWrapper(const char *Data, uint64_t Size)
LLVM_ABI 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),...
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
@ None
No attributes have been set.
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 > > Create(ObjectLayer &L, std::unique_ptr< MemoryBuffer > ArchiveBuffer, std::unique_ptr< object::Archive > Archive, VisitMembersFunction VisitMembers=VisitMembersFunction(), GetObjectFileInterface GetObjFileInterface=GetObjectFileInterface())
Try to create a StaticLibrarySearchGenerator from the given memory buffer and Archive object.
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Load(ObjectLayer &L, const char *FileName, VisitMembersFunction VisitMembers=VisitMembersFunction(), GetObjectFileInterface GetObjFileInterface=GetObjectFileInterface())
Try to create a StaticLibraryDefinitionGenerator from the given path.
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(bool Validate, const char *Fmt, 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:...