12#include "llvm/Config/llvm-config.h"
31#define DEBUG_TYPE "orc"
57 std::vector<Type *> HelperArgTypes;
58 for (
auto *Arg : HelperPrefixArgs)
59 HelperArgTypes.push_back(Arg->getType());
60 for (
auto *
T : WrapperFnType->params())
61 HelperArgTypes.push_back(
T);
63 FunctionType::get(WrapperFnType->getReturnType(), HelperArgTypes,
false);
69 WrapperFn->setVisibility(WrapperVisibility);
74 std::vector<Value *> HelperArgs;
75 for (
auto *Arg : HelperPrefixArgs)
76 HelperArgs.push_back(Arg);
77 for (
auto &Arg : WrapperFn->args())
78 HelperArgs.push_back(&Arg);
79 auto *HelperResult = IB.CreateCall(HelperFn, HelperArgs);
80 if (HelperFn->getReturnType()->isVoidTy())
83 IB.CreateRet(HelperResult);
88class GenericLLVMIRPlatformSupport;
92class GenericLLVMIRPlatform :
public Platform {
94 GenericLLVMIRPlatform(GenericLLVMIRPlatformSupport &S) : S(S) {}
105 GenericLLVMIRPlatformSupport &S;
111class GlobalCtorDtorScraper {
113 GlobalCtorDtorScraper(GenericLLVMIRPlatformSupport &PS,
116 : PS(PS), InitFunctionPrefix(InitFunctionPrefix),
117 DeInitFunctionPrefix(DeInitFunctionPrefix) {}
122 GenericLLVMIRPlatformSupport &PS;
135 : J(J), InitFunctionPrefix(J.
mangle(
"__orc_init_func.")),
136 DeInitFunctionPrefix(J.
mangle(
"__orc_deinit_func.")) {
139 std::make_unique<GenericLLVMIRPlatform>(*
this));
142 DeInitFunctionPrefix));
146 StdInterposes[J.
mangleAndIntern(
"__lljit.platform_support_instance")] = {
152 cantFail(setupJITDylib(PlatformJD));
169 auto Ctx = std::make_unique<LLVMContext>();
170 auto M = std::make_unique<Module>(
"__standard_lib", *Ctx);
176 ConstantInt::get(Int64Ty,
reinterpret_cast<uintptr_t
>(&JD)),
179 DSOHandle->setInitializer(
182 auto *GenericIRPlatformSupportTy =
187 nullptr,
"__lljit.platform_support_instance");
191 *M,
"__lljit_run_atexits", FunctionType::get(VoidTy, {},
false),
193 {PlatformInstanceDecl, DSOHandle});
198 auto *AtExit = addHelperAndWrapper(
199 *M,
"atexit", FunctionType::get(IntTy, {AtExitCallbackPtrTy},
false),
201 {PlatformInstanceDecl, DSOHandle});
205 AtExit->addRetAttr(AtExitExtAttr);
213 InitSymbols[&JD].add(InitSym, SymbolLookupFlags::WeaklyReferencedSymbol);
221 if ((*KV.first).starts_with(InitFunctionPrefix)) {
222 InitSymbols[&JD].add(KV.first,
223 SymbolLookupFlags::WeaklyReferencedSymbol);
224 InitFunctions[&JD].add(KV.first);
225 }
else if ((*KV.first).starts_with(DeInitFunctionPrefix)) {
226 DeInitFunctions[&JD].add(KV.first);
234 dbgs() <<
"GenericLLVMIRPlatformSupport getting initializers to run\n";
236 if (
auto Initializers = getInitializers(JD)) {
238 {
dbgs() <<
"GenericLLVMIRPlatformSupport running initializers\n"; });
239 for (
auto InitFnAddr : *Initializers) {
241 dbgs() <<
" Running init " <<
formatv(
"{0:x16}", InitFnAddr)
244 auto *InitFn = InitFnAddr.toPtr<void (*)()>();
248 return Initializers.takeError();
254 dbgs() <<
"GenericLLVMIRPlatformSupport getting deinitializers to run\n";
256 if (
auto Deinitializers = getDeinitializers(JD)) {
258 dbgs() <<
"GenericLLVMIRPlatformSupport running deinitializers\n";
260 for (
auto DeinitFnAddr : *Deinitializers) {
262 dbgs() <<
" Running deinit " <<
formatv(
"{0:x16}", DeinitFnAddr)
265 auto *DeinitFn = DeinitFnAddr.toPtr<void (*)()>();
269 return Deinitializers.takeError();
276 InitFunctions[&JD].add(InitName);
282 [&]() { DeInitFunctions[&JD].add(DeInitName); });
287 if (
auto Err = issueInitLookups(JD))
288 return std::move(Err);
291 std::vector<JITDylibSP> DFSLinkOrder;
295 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
297 return DFSLinkOrderOrErr.takeError();
299 for (
auto &NextJD : DFSLinkOrder) {
300 auto IFItr = InitFunctions.find(NextJD.get());
301 if (IFItr != InitFunctions.end()) {
302 LookupSymbols[NextJD.get()] = std::move(IFItr->second);
303 InitFunctions.erase(IFItr);
308 return std::move(Err);
311 dbgs() <<
"JITDylib init order is [ ";
315 dbgs() <<
"Looking up init functions:\n";
316 for (
auto &KV : LookupSymbols)
317 dbgs() <<
" \"" << KV.first->getName() <<
"\": " << KV.second <<
"\n";
324 return LookupResult.takeError();
326 std::vector<ExecutorAddr> Initializers;
327 while (!DFSLinkOrder.empty()) {
328 auto &NextJD = *DFSLinkOrder.back();
329 DFSLinkOrder.pop_back();
330 auto InitsItr = LookupResult->find(&NextJD);
331 if (InitsItr == LookupResult->end())
333 for (
auto &KV : InitsItr->second)
334 Initializers.push_back(KV.second.getAddress());
346 std::vector<JITDylibSP> DFSLinkOrder;
348 if (
auto Err = ES.runSessionLocked([&]() ->
Error {
349 if (auto DFSLinkOrderOrErr = JD.getDFSLinkOrder())
350 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
352 return DFSLinkOrderOrErr.takeError();
354 for (auto &NextJD : DFSLinkOrder) {
355 auto &JDLookupSymbols = LookupSymbols[NextJD.get()];
356 auto DIFItr = DeInitFunctions.find(NextJD.get());
357 if (DIFItr != DeInitFunctions.end()) {
358 LookupSymbols[NextJD.get()] = std::move(DIFItr->second);
359 DeInitFunctions.erase(DIFItr);
361 JDLookupSymbols.add(LLJITRunAtExits,
362 SymbolLookupFlags::WeaklyReferencedSymbol);
366 return std::move(Err);
369 dbgs() <<
"JITDylib deinit order is [ ";
370 for (
auto &JD : DFSLinkOrder)
373 dbgs() <<
"Looking up deinit functions:\n";
374 for (
auto &KV : LookupSymbols)
375 dbgs() <<
" \"" << KV.first->getName() <<
"\": " << KV.second <<
"\n";
381 return LookupResult.takeError();
383 std::vector<ExecutorAddr> DeInitializers;
384 for (
auto &NextJD : DFSLinkOrder) {
385 auto DeInitsItr = LookupResult->find(NextJD.get());
386 assert(DeInitsItr != LookupResult->end() &&
387 "Every JD should have at least __lljit_run_atexits");
389 auto RunAtExitsItr = DeInitsItr->second.find(LLJITRunAtExits);
390 if (RunAtExitsItr != DeInitsItr->second.end())
391 DeInitializers.push_back(RunAtExitsItr->second.getAddress());
393 for (
auto &KV : DeInitsItr->second)
394 if (KV.first != LLJITRunAtExits)
395 DeInitializers.push_back(KV.second.getAddress());
398 return DeInitializers;
405 std::vector<JITDylibSP> DFSLinkOrder;
407 if (
auto Err = getExecutionSession().runSessionLocked([&]() ->
Error {
409 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
411 return DFSLinkOrderOrErr.takeError();
413 for (
auto &NextJD : DFSLinkOrder) {
414 auto ISItr = InitSymbols.find(NextJD.get());
415 if (ISItr != InitSymbols.end()) {
416 RequiredInitSymbols[NextJD.get()] = std::move(ISItr->second);
417 InitSymbols.erase(ISItr);
429 static void registerCxaAtExitHelper(
void *Self,
void (*
F)(
void *),
void *Ctx,
432 dbgs() <<
"Registering cxa atexit function " << (
void *)
F <<
" for JD "
435 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.registerAtExit(
439 static void registerAtExitHelper(
void *Self,
void *DSOHandle,
void (*
F)()) {
441 dbgs() <<
"Registering atexit function " << (
void *)
F <<
" for JD "
444 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.registerAtExit(
445 reinterpret_cast<void (*)(
void *)
>(
F),
nullptr, DSOHandle);
448 static void runAtExitsHelper(
void *Self,
void *DSOHandle) {
450 dbgs() <<
"Running atexit functions for JD "
451 << (*
static_cast<JITDylib **
>(DSOHandle))->getName() <<
"\n";
453 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.runAtExits(
460 auto Ctx = std::make_unique<LLVMContext>();
461 auto M = std::make_unique<Module>(
"__standard_lib", *Ctx);
462 M->setDataLayout(J.getDataLayout());
464 auto *GenericIRPlatformSupportTy =
469 nullptr,
"__lljit.platform_support_instance");
474 auto *BytePtrTy = PointerType::getUnqual(Int8Ty);
475 auto *CxaAtExitCallbackTy = FunctionType::get(VoidTy, {BytePtrTy},
false);
476 auto *CxaAtExitCallbackPtrTy = PointerType::getUnqual(CxaAtExitCallbackTy);
478 auto *CxaAtExit = addHelperAndWrapper(
480 FunctionType::get(IntTy, {CxaAtExitCallbackPtrTy, BytePtrTy, BytePtrTy},
483 {PlatformInstanceDecl});
485 TargetLibraryInfo::getExtAttrForI32Return(J.getTargetTriple());
487 CxaAtExit->addRetAttr(CxaAtExitExtAttr);
493 std::string InitFunctionPrefix;
494 std::string DeInitFunctionPrefix;
502 return S.setupJITDylib(JD);
511 return S.notifyAdding(RT, MU);
518 auto &Ctx =
M.getContext();
519 auto *GlobalCtors =
M.getNamedGlobal(
"llvm.global_ctors");
520 auto *GlobalDtors =
M.getNamedGlobal(
"llvm.global_dtors");
523 bool isCtor) ->
Error {
527 std::string InitOrDeInitFunctionName;
530 << InitFunctionPrefix <<
M.getModuleIdentifier();
533 << DeInitFunctionPrefix <<
M.getModuleIdentifier();
536 auto InternedInitOrDeInitName =
Mangle(InitOrDeInitFunctionName);
537 if (
auto Err =
R.defineMaterializing(
538 {{InternedInitOrDeInitName, JITSymbolFlags::Callable}}))
545 std::vector<std::pair<Function *, unsigned>> InitsOrDeInits;
548 for (
auto E : COrDtors)
549 InitsOrDeInits.push_back(std::make_pair(E.Func, E.Priority));
552 auto *InitOrDeInitFuncEntryBlock =
555 for (
auto &KV : InitsOrDeInits)
556 IB.CreateCall(KV.first);
560 PS.registerInitFunc(
R.getTargetJITDylib(), InternedInitOrDeInitName);
562 PS.registerDeInitFunc(
R.getTargetJITDylib(), InternedInitOrDeInitName);
568 if (
auto Err = RegisterCOrDtors(GlobalCtors,
true))
570 if (
auto Err = RegisterCOrDtors(GlobalDtors,
false))
577 return std::move(Err);
579 return std::move(TSM);
588 InactivePlatformSupport() =
default;
591 LLVM_DEBUG(
dbgs() <<
"InactivePlatformSupport: no initializers running for "
598 dbgs() <<
"InactivePlatformSupport: no deinitializers running for "
612 using SPSDLOpenSig = SPSExecutorAddr(SPSString, int32_t);
613 using SPSDLUpdateSig = int32_t(SPSExecutorAddr);
614 enum dlopen_mode : int32_t {
615 ORC_RT_RTLD_LAZY = 0x1,
616 ORC_RT_RTLD_NOW = 0x2,
617 ORC_RT_RTLD_LOCAL = 0x4,
618 ORC_RT_RTLD_GLOBAL = 0x8
624 StringRef WrapperToCall =
"__orc_rt_jit_dlopen_wrapper";
625 bool dlupdate =
false;
626 const Triple &TT = ES.getTargetTriple();
627 if (TT.isOSBinFormatMachO() || TT.isOSBinFormatELF()) {
628 if (InitializedDylib.contains(&JD)) {
629 WrapperToCall =
"__orc_rt_jit_dlupdate_wrapper";
632 InitializedDylib.insert(&JD);
635 if (
auto WrapperAddr =
639 auto E = ES.callSPSWrapper<SPSDLUpdateSig>(WrapperAddr->getAddress(),
640 result, DSOHandles[&JD]);
642 return make_error<StringError>(
"dlupdate failed",
646 return ES.callSPSWrapper<SPSDLOpenSig>(WrapperAddr->getAddress(),
648 int32_t(ORC_RT_RTLD_LAZY));
650 return WrapperAddr.takeError();
655 using SPSDLCloseSig = int32_t(SPSExecutorAddr);
661 if (
auto WrapperAddr = ES.lookup(
665 WrapperAddr->getAddress(), result, DSOHandles[&JD]);
669 return make_error<StringError>(
"dlclose failed",
671 DSOHandles.erase(&JD);
672 InitializedDylib.erase(&JD);
674 return WrapperAddr.takeError();
691 dbgs() <<
" No explicitly set JITTargetMachineBuilder. "
692 "Detecting host...\n";
695 JTMB = std::move(*JTMBOrErr);
697 return JTMBOrErr.takeError();
700 if ((
ES || EPC) && NumCompileThreads)
701 return make_error<StringError>(
702 "NumCompileThreads cannot be used with a custom ExecutionSession or "
703 "ExecutorProcessControl",
706#if !LLVM_ENABLE_THREADS
707 if (NumCompileThreads)
708 return make_error<StringError>(
709 "LLJIT num-compile-threads is " +
Twine(NumCompileThreads) +
710 " but LLVM was compiled with LLVM_ENABLE_THREADS=Off",
715 [[maybe_unused]]
bool ConcurrentCompilationSettingDefaulted =
716 !SupportConcurrentCompilation;
718 if (!SupportConcurrentCompilation) {
719#if LLVM_ENABLE_THREADS
720 SupportConcurrentCompilation = NumCompileThreads ||
ES || EPC;
722 SupportConcurrentCompilation =
false;
725#if !LLVM_ENABLE_THREADS
726 if (*SupportConcurrentCompilation)
727 return make_error<StringError>(
728 "LLJIT concurrent compilation support requested, but LLVM was built "
729 "with LLVM_ENABLE_THREADS=Off",
735 dbgs() <<
" JITTargetMachineBuilder is "
737 <<
" Pre-constructed ExecutionSession: " << (
ES ?
"Yes" :
"No")
743 dbgs() <<
"None (will be created by JITTargetMachineBuilder)\n";
745 dbgs() <<
" Custom object-linking-layer creator: "
746 << (CreateObjectLinkingLayer ?
"Yes" :
"No") <<
"\n"
747 <<
" Custom compile-function creator: "
748 << (CreateCompileFunction ?
"Yes" :
"No") <<
"\n"
749 <<
" Custom platform-setup function: "
750 << (SetUpPlatform ?
"Yes" :
"No") <<
"\n"
751 <<
" Support concurrent compilation: "
752 << (*SupportConcurrentCompilation ?
"Yes" :
"No");
753 if (ConcurrentCompilationSettingDefaulted)
754 dbgs() <<
" (defaulted based on ES / EPC / NumCompileThreads)\n";
757 dbgs() <<
" Number of compile threads: " << NumCompileThreads <<
"\n";
762 if (
auto DLOrErr = JTMB->getDefaultDataLayoutForTarget())
763 DL = std::move(*DLOrErr);
765 return DLOrErr.takeError();
771 dbgs() <<
"ExecutorProcessControl not specified, "
772 "Creating SelfExecutorProcessControl instance\n";
775 std::unique_ptr<TaskDispatcher>
D =
nullptr;
776#if LLVM_ENABLE_THREADS
777 if (*SupportConcurrentCompilation) {
778 std::optional<size_t> NumThreads = std ::nullopt;
779 if (NumCompileThreads)
780 NumThreads = NumCompileThreads;
781 D = std::make_unique<DynamicThreadPoolTaskDispatcher>(NumThreads);
783 D = std::make_unique<InPlaceTaskDispatcher>();
787 EPC = std::move(*EPCOrErr);
789 return EPCOrErr.takeError();
792 dbgs() <<
"Using explicitly specified ExecutorProcessControl instance "
793 << EPC.get() <<
"\n";
797 dbgs() <<
"Using explicitly specified ExecutionSession instance "
804 if (!CreateObjectLinkingLayer) {
805 auto &
TT = JTMB->getTargetTriple();
806 bool UseJITLink =
false;
834 if (!JTMB->getCodeModel())
837 CreateObjectLinkingLayer =
843 std::make_unique<EHFrameRegistrationPlugin>(
844 ES, std::move(*EHFrameRegistrar)));
846 return EHFrameRegistrar.takeError();
854 if (!SetupProcessSymbolsJITDylib && LinkProcessSymbolsByDefault) {
855 LLVM_DEBUG(
dbgs() <<
"Creating default Process JD setup function\n");
860 J.getExecutionSession());
862 return G.takeError();
872 if (
auto Err =
ES->endSession())
873 ES->reportError(std::move(Err));
881 auto JD =
ES->createJITDylib(std::move(
Name));
883 return JD.takeError();
892 return G.takeError();
894 if (
auto *ExistingJD =
ES->getJITDylibByName(Path))
897 auto &JD =
ES->createBareJITDylib(Path);
903 std::unique_ptr<MemoryBuffer> LibBuffer) {
905 std::move(LibBuffer));
907 return G.takeError();
917 return G.takeError();
925 assert(TSM &&
"Can not add null module");
939 std::unique_ptr<MemoryBuffer> Obj) {
940 assert(Obj &&
"Can not add null object");
951 if (
auto Sym =
ES->lookup(
954 return Sym->getAddress();
956 return Sym.takeError();
968 auto GetMemMgr = []() {
return std::make_unique<SectionMemoryManager>(); };
970 std::make_unique<RTDyldObjectLinkingLayer>(
ES, std::move(GetMemMgr));
972 if (S.
JTMB->getTargetTriple().isOSBinFormatCOFF()) {
973 Layer->setOverrideObjectFlagsWithResponsibilityFlags(
true);
974 Layer->setAutoClaimResponsibilityForObjectSymbols(
true);
977 if (S.
JTMB->getTargetTriple().isOSBinFormatELF() &&
980 Layer->setAutoClaimResponsibilityForObjectSymbols(
true);
985 return std::unique_ptr<ObjectLayer>(std::move(Layer));
998 return std::make_unique<ConcurrentIRCompiler>(std::move(JTMB));
1002 return TM.takeError();
1004 return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM));
1012 assert(!(S.
EPC && S.
ES) &&
"EPC and ES should not both be set");
1015 ES = std::make_unique<ExecutionSession>(std::move(S.
EPC));
1017 ES = std::move(S.
ES);
1020 ES = std::make_unique<ExecutionSession>(std::move(*EPC));
1022 Err = EPC.takeError();
1029 Err = ObjLayer.takeError();
1038 if (!CompileFunction) {
1039 Err = CompileFunction.takeError();
1056 Err = ProcSymsJD.takeError();
1063 Err = std::move(Err2);
1077 Err = PlatformJDOrErr.takeError();
1088 Err = MainOrErr.takeError();
1094 std::string MangledName;
1103 if (M.getDataLayout().isDefault())
1104 M.setDataLayout(
DL);
1106 if (M.getDataLayout() !=
DL)
1107 return make_error<StringError>(
1108 "Added modules have incompatible data layouts: " +
1109 M.getDataLayout().getStringRepresentation() +
" (module) vs " +
1117 LLVM_DEBUG({
dbgs() <<
"Setting up orc platform support for LLJIT\n"; });
1127 return make_error<StringError>(
"DLLName not ending with .dll",
1129 auto DLLNameStr = DLLName.
str();
1132 return DLLJD.takeError();
1143 if (!ProcessSymbolsJD)
1144 return make_error<StringError>(
1145 "Native platforms require a process symbols JITDylib",
1152 if (!ObjLinkingLayer)
1153 return make_error<StringError>(
1154 "ExecutorNativePlatform requires ObjectLinkingLayer",
1157 std::unique_ptr<MemoryBuffer> RuntimeArchiveBuffer;
1158 if (OrcRuntime.index() == 0) {
1161 return A.takeError();
1162 RuntimeArchiveBuffer = std::move(*
A);
1164 RuntimeArchiveBuffer = std::move(std::get<1>(OrcRuntime));
1172 switch (TT.getObjectFormat()) {
1174 const char *VCRuntimePath =
nullptr;
1175 bool StaticVCRuntime =
false;
1177 VCRuntimePath = VCRuntime->first.c_str();
1178 StaticVCRuntime = VCRuntime->second;
1181 *ObjLinkingLayer, PlatformJD, std::move(RuntimeArchiveBuffer),
1185 return P.takeError();
1190 *ObjLinkingLayer, std::move(RuntimeArchiveBuffer));
1192 return G.takeError();
1198 return P.takeError();
1203 *ObjLinkingLayer, std::move(RuntimeArchiveBuffer));
1205 return G.takeError();
1209 ES.setPlatform(std::move(*
P));
1211 return P.takeError();
1215 return make_error<StringError>(
"Unsupported object format in triple " +
1225 {
dbgs() <<
"Setting up GenericLLVMIRPlatform support for LLJIT\n"; });
1227 if (!ProcessSymbolsJD)
1228 return make_error<StringError>(
1229 "Native platforms require a process symbols JITDylib",
1236 std::make_unique<GenericLLVMIRPlatformSupport>(J, PlatformJD));
1243 {
dbgs() <<
"Explicitly deactivated platform support for LLJIT\n"; });
1251 TT =
JTMB->getTargetTriple();
1256 assert(TSM &&
"Can not add null module");
1259 [&](
Module &M) ->
Error { return applyDataLayout(M); }))
1262 return CODLayer->add(JD, std::move(TSM));
1275 LCTMgr = std::move(S.
LCTMgr);
1279 LCTMgr = std::move(*LCTMgrOrErr);
1281 Err = LCTMgrOrErr.takeError();
1295 Err = make_error<StringError>(
"Could not construct "
1296 "IndirectStubsManagerBuilder for target " +
1306 CODLayer = std::make_unique<CompileOnDemandLayer>(*
ES, *IPLayer, *LCTMgr,
1307 std::move(ISMBuilder));
1310 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:...