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);
94 using SPSDLOpenSig = SPSExecutorAddr(SPSString, int32_t);
95 enum dlopen_mode : int32_t {
96 ORC_RT_RTLD_LAZY = 0x1,
97 ORC_RT_RTLD_NOW = 0x2,
98 ORC_RT_RTLD_LOCAL = 0x4,
99 ORC_RT_RTLD_GLOBAL = 0x8
102 if (
auto WrapperAddr = J.
lookup(
"__orc_rt_jit_dlopen_wrapper")) {
104 *WrapperAddr, DSOHandles[&JD], JD.
getName(),
105 int32_t(ORC_RT_RTLD_LAZY));
107 return WrapperAddr.takeError();
112 using SPSDLCloseSig = int32_t(SPSExecutorAddr);
114 if (
auto WrapperAddr = J.
lookup(
"__orc_rt_jit_dlclose_wrapper")) {
117 *WrapperAddr, result, DSOHandles[&JD]);
121 return make_error<StringError>(
"dlclose failed",
123 DSOHandles.erase(&JD);
125 return WrapperAddr.takeError();
134class GenericLLVMIRPlatformSupport;
138class GenericLLVMIRPlatform :
public Platform {
140 GenericLLVMIRPlatform(GenericLLVMIRPlatformSupport &S) : S(S) {}
151 GenericLLVMIRPlatformSupport &S;
157class GlobalCtorDtorScraper {
159 GlobalCtorDtorScraper(GenericLLVMIRPlatformSupport &PS,
162 : PS(PS), InitFunctionPrefix(InitFunctionPrefix),
163 DeInitFunctionPrefix(DeInitFunctionPrefix) {}
168 GenericLLVMIRPlatformSupport &PS;
180 GenericLLVMIRPlatformSupport(
LLJIT &J)
181 : J(J), InitFunctionPrefix(J.
mangle(
"__orc_init_func.")),
182 DeInitFunctionPrefix(J.
mangle(
"__orc_deinit_func.")) {
185 std::make_unique<GenericLLVMIRPlatform>(*
this));
188 DeInitFunctionPrefix));
192 StdInterposes[J.
mangleAndIntern(
"__lljit.platform_support_instance")] = {
216 auto Ctx = std::make_unique<LLVMContext>();
217 auto M = std::make_unique<Module>(
"__standard_lib", *Ctx);
226 DSOHandle->setInitializer(
229 auto *GenericIRPlatformSupportTy =
234 nullptr,
"__lljit.platform_support_instance");
238 *M,
"__lljit_run_atexits", FunctionType::get(VoidTy, {},
false),
240 {PlatformInstanceDecl, DSOHandle});
245 addHelperAndWrapper(*M,
"atexit",
246 FunctionType::get(IntTy, {AtExitCallbackPtrTy},
false),
248 {PlatformInstanceDecl, DSOHandle});
256 InitSymbols[&JD].add(InitSym, SymbolLookupFlags::WeaklyReferencedSymbol);
264 if ((*KV.first).startswith(InitFunctionPrefix)) {
265 InitSymbols[&JD].add(KV.first,
266 SymbolLookupFlags::WeaklyReferencedSymbol);
267 InitFunctions[&JD].add(KV.first);
268 }
else if ((*KV.first).startswith(DeInitFunctionPrefix)) {
269 DeInitFunctions[&JD].add(KV.first);
277 dbgs() <<
"GenericLLVMIRPlatformSupport getting initializers to run\n";
279 if (
auto Initializers = getInitializers(JD)) {
281 {
dbgs() <<
"GenericLLVMIRPlatformSupport running initializers\n"; });
282 for (
auto InitFnAddr : *Initializers) {
284 dbgs() <<
" Running init " <<
formatv(
"{0:x16}", InitFnAddr)
287 auto *InitFn = InitFnAddr.toPtr<void (*)()>();
291 return Initializers.takeError();
297 dbgs() <<
"GenericLLVMIRPlatformSupport getting deinitializers to run\n";
299 if (
auto Deinitializers = getDeinitializers(JD)) {
301 dbgs() <<
"GenericLLVMIRPlatformSupport running deinitializers\n";
303 for (
auto DeinitFnAddr : *Deinitializers) {
305 dbgs() <<
" Running deinit " <<
formatv(
"{0:x16}", DeinitFnAddr)
308 auto *DeinitFn = DeinitFnAddr.toPtr<void (*)()>();
312 return Deinitializers.takeError();
319 InitFunctions[&JD].add(InitName);
325 [&]() { DeInitFunctions[&JD].add(DeInitName); });
330 if (
auto Err = issueInitLookups(JD))
331 return std::move(Err);
334 std::vector<JITDylibSP> DFSLinkOrder;
338 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
340 return DFSLinkOrderOrErr.takeError();
342 for (
auto &NextJD : DFSLinkOrder) {
343 auto IFItr = InitFunctions.find(NextJD.get());
344 if (IFItr != InitFunctions.end()) {
345 LookupSymbols[NextJD.get()] = std::move(IFItr->second);
346 InitFunctions.erase(IFItr);
351 return std::move(Err);
354 dbgs() <<
"JITDylib init order is [ ";
358 dbgs() <<
"Looking up init functions:\n";
359 for (
auto &KV : LookupSymbols)
360 dbgs() <<
" \"" << KV.first->getName() <<
"\": " << KV.second <<
"\n";
367 return LookupResult.takeError();
369 std::vector<ExecutorAddr> Initializers;
370 while (!DFSLinkOrder.empty()) {
371 auto &NextJD = *DFSLinkOrder.back();
372 DFSLinkOrder.pop_back();
373 auto InitsItr = LookupResult->find(&NextJD);
374 if (InitsItr == LookupResult->end())
376 for (
auto &KV : InitsItr->second)
377 Initializers.push_back(KV.second.getAddress());
389 std::vector<JITDylibSP> DFSLinkOrder;
391 if (
auto Err = ES.runSessionLocked([&]() ->
Error {
392 if (auto DFSLinkOrderOrErr = JD.getDFSLinkOrder())
393 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
395 return DFSLinkOrderOrErr.takeError();
397 for (auto &NextJD : DFSLinkOrder) {
398 auto &JDLookupSymbols = LookupSymbols[NextJD.get()];
399 auto DIFItr = DeInitFunctions.find(NextJD.get());
400 if (DIFItr != DeInitFunctions.end()) {
401 LookupSymbols[NextJD.get()] = std::move(DIFItr->second);
402 DeInitFunctions.erase(DIFItr);
404 JDLookupSymbols.add(LLJITRunAtExits,
405 SymbolLookupFlags::WeaklyReferencedSymbol);
409 return std::move(Err);
412 dbgs() <<
"JITDylib deinit order is [ ";
413 for (
auto &JD : DFSLinkOrder)
416 dbgs() <<
"Looking up deinit functions:\n";
417 for (
auto &KV : LookupSymbols)
418 dbgs() <<
" \"" << KV.first->getName() <<
"\": " << KV.second <<
"\n";
424 return LookupResult.takeError();
426 std::vector<ExecutorAddr> DeInitializers;
427 for (
auto &NextJD : DFSLinkOrder) {
428 auto DeInitsItr = LookupResult->find(NextJD.get());
429 assert(DeInitsItr != LookupResult->end() &&
430 "Every JD should have at least __lljit_run_atexits");
432 auto RunAtExitsItr = DeInitsItr->second.find(LLJITRunAtExits);
433 if (RunAtExitsItr != DeInitsItr->second.end())
434 DeInitializers.push_back(RunAtExitsItr->second.getAddress());
436 for (
auto &KV : DeInitsItr->second)
437 if (KV.first != LLJITRunAtExits)
438 DeInitializers.push_back(KV.second.getAddress());
441 return DeInitializers;
448 std::vector<JITDylibSP> DFSLinkOrder;
450 if (
auto Err = getExecutionSession().runSessionLocked([&]() ->
Error {
452 DFSLinkOrder = std::move(*DFSLinkOrderOrErr);
454 return DFSLinkOrderOrErr.takeError();
456 for (
auto &NextJD : DFSLinkOrder) {
457 auto ISItr = InitSymbols.find(NextJD.get());
458 if (ISItr != InitSymbols.end()) {
459 RequiredInitSymbols[NextJD.get()] = std::move(ISItr->second);
460 InitSymbols.erase(ISItr);
472 static void registerCxaAtExitHelper(
void *Self,
void (*
F)(
void *),
void *Ctx,
475 dbgs() <<
"Registering cxa atexit function " << (
void *)
F <<
" for JD "
478 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.registerAtExit(
482 static void registerAtExitHelper(
void *Self,
void *DSOHandle,
void (*
F)()) {
484 dbgs() <<
"Registering atexit function " << (
void *)
F <<
" for JD "
487 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.registerAtExit(
488 reinterpret_cast<void (*)(
void *)
>(
F),
nullptr, DSOHandle);
491 static void runAtExitsHelper(
void *Self,
void *DSOHandle) {
493 dbgs() <<
"Running atexit functions for JD "
494 << (*
static_cast<JITDylib **
>(DSOHandle))->getName() <<
"\n";
496 static_cast<GenericLLVMIRPlatformSupport *
>(Self)->AtExitMgr.runAtExits(
503 auto Ctx = std::make_unique<LLVMContext>();
504 auto M = std::make_unique<Module>(
"__standard_lib", *Ctx);
505 M->setDataLayout(J.getDataLayout());
507 auto *GenericIRPlatformSupportTy =
512 nullptr,
"__lljit.platform_support_instance");
517 auto *BytePtrTy = PointerType::getUnqual(Int8Ty);
518 auto *CxaAtExitCallbackTy = FunctionType::get(VoidTy, {BytePtrTy},
false);
519 auto *CxaAtExitCallbackPtrTy = PointerType::getUnqual(CxaAtExitCallbackTy);
523 FunctionType::get(IntTy, {CxaAtExitCallbackPtrTy, BytePtrTy, BytePtrTy},
526 {PlatformInstanceDecl});
532 std::string InitFunctionPrefix;
533 std::string DeInitFunctionPrefix;
541 return S.setupJITDylib(JD);
550 return S.notifyAdding(RT, MU);
557 auto &Ctx =
M.getContext();
558 auto *GlobalCtors =
M.getNamedGlobal(
"llvm.global_ctors");
559 auto *GlobalDtors =
M.getNamedGlobal(
"llvm.global_dtors");
562 bool isCtor) ->
Error {
566 std::string InitOrDeInitFunctionName;
569 << InitFunctionPrefix <<
M.getModuleIdentifier();
572 << DeInitFunctionPrefix <<
M.getModuleIdentifier();
575 auto InternedInitOrDeInitName =
Mangle(InitOrDeInitFunctionName);
576 if (
auto Err =
R.defineMaterializing(
577 {{InternedInitOrDeInitName, JITSymbolFlags::Callable}}))
584 std::vector<std::pair<Function *, unsigned>> InitsOrDeInits;
587 for (
auto E : COrDtors)
588 InitsOrDeInits.push_back(std::make_pair(
E.Func,
E.Priority));
591 auto *InitOrDeInitFuncEntryBlock =
594 for (
auto &KV : InitsOrDeInits)
595 IB.CreateCall(KV.first);
599 PS.registerInitFunc(
R.getTargetJITDylib(), InternedInitOrDeInitName);
601 PS.registerDeInitFunc(
R.getTargetJITDylib(), InternedInitOrDeInitName);
607 if (
auto Err = RegisterCOrDtors(GlobalCtors,
true))
609 if (
auto Err = RegisterCOrDtors(GlobalDtors,
false))
616 return std::move(Err);
618 return std::move(TSM);
627 InactivePlatformSupport() =
default;
630 LLVM_DEBUG(
dbgs() <<
"InactivePlatformSupport: no initializers running for "
637 dbgs() <<
"InactivePlatformSupport: no deinitializers running for "
661 dbgs() <<
" No explicitly set JITTargetMachineBuilder. "
662 "Detecting host...\n";
665 JTMB = std::move(*JTMBOrErr);
667 return JTMBOrErr.takeError();
671 dbgs() <<
" JITTargetMachineBuilder is "
673 <<
" Pre-constructed ExecutionSession: " << (
ES ?
"Yes" :
"No")
679 dbgs() <<
"None (will be created by JITTargetMachineBuilder)\n";
681 dbgs() <<
" Custom object-linking-layer creator: "
682 << (CreateObjectLinkingLayer ?
"Yes" :
"No") <<
"\n"
683 <<
" Custom compile-function creator: "
684 << (CreateCompileFunction ?
"Yes" :
"No") <<
"\n"
685 <<
" Custom platform-setup function: "
686 << (SetUpPlatform ?
"Yes" :
"No") <<
"\n"
687 <<
" Number of compile threads: " << NumCompileThreads;
688 if (!NumCompileThreads)
689 dbgs() <<
" (code will be compiled on the execution thread)\n";
697 dbgs() <<
"ExecutorProcessControl not specified, "
698 "Creating SelfExecutorProcessControl instance\n";
701 EPC = std::move(*EPCOrErr);
703 return EPCOrErr.takeError();
706 dbgs() <<
"Using explicitly specified ExecutorProcessControl instance "
707 << EPC.get() <<
"\n";
712 if (!CreateObjectLinkingLayer) {
713 auto &
TT = JTMB->getTargetTriple();
714 bool UseJITLink =
false;
732 CreateObjectLinkingLayer =
738 std::make_unique<EHFrameRegistrationPlugin>(
739 ES, std::move(*EHFrameRegistrar)));
741 return EHFrameRegistrar.takeError();
753 if (
auto Err =
ES->endSession())
754 ES->reportError(std::move(Err));
760 return G.takeError();
762 if (
auto *ExistingJD =
ES->getJITDylibByName(Path))
765 auto &JD =
ES->createBareJITDylib(Path);
771 std::unique_ptr<MemoryBuffer> LibBuffer) {
773 std::move(LibBuffer));
775 return G.takeError();
785 return G.takeError();
793 assert(TSM &&
"Can not add null module");
807 std::unique_ptr<MemoryBuffer> Obj) {
808 assert(Obj &&
"Can not add null object");
819 if (
auto Sym =
ES->lookup(
824 return Sym.takeError();
836 auto GetMemMgr = []() {
return std::make_unique<SectionMemoryManager>(); };
838 std::make_unique<RTDyldObjectLinkingLayer>(
ES, std::move(GetMemMgr));
840 if (S.
JTMB->getTargetTriple().isOSBinFormatCOFF()) {
841 Layer->setOverrideObjectFlagsWithResponsibilityFlags(
true);
842 Layer->setAutoClaimResponsibilityForObjectSymbols(
true);
845 if (S.
JTMB->getTargetTriple().isOSBinFormatELF() &&
848 Layer->setAutoClaimResponsibilityForObjectSymbols(
true);
853 return std::unique_ptr<ObjectLayer>(std::move(Layer));
867 return std::make_unique<ConcurrentIRCompiler>(std::move(JTMB));
871 return TM.takeError();
873 return std::make_unique<TMOwningSimpleCompiler>(std::move(*
TM));
881 assert(!(S.
EPC && S.
ES) &&
"EPC and ES should not both be set");
884 ES = std::make_unique<ExecutionSession>(std::move(S.
EPC));
886 ES = std::move(S.
ES);
889 ES = std::make_unique<ExecutionSession>(std::move(*EPC));
891 Err = EPC.takeError();
896 if (
auto MainOrErr = this->
ES->createJITDylib(
"main"))
899 Err = MainOrErr.takeError();
904 DL = std::move(*S.
DL);
905 else if (
auto DLOrErr = S.
JTMB->getDefaultDataLayoutForTarget())
906 DL = std::move(*DLOrErr);
908 Err = DLOrErr.takeError();
914 Err = ObjLayer.takeError();
923 if (!CompileFunction) {
924 Err = CompileFunction.takeError();
938 ES->setDispatchTask([
this](std::unique_ptr<Task>
T) {
944 std::unique_ptr<Task> T(UnownedT);
957 std::string MangledName;
966 if (M.getDataLayout().isDefault())
969 if (M.getDataLayout() !=
DL)
970 return make_error<StringError>(
971 "Added modules have incompatible data layouts: " +
972 M.getDataLayout().getStringRepresentation() +
" (module) vs " +
981 {
dbgs() <<
"Setting up orc platform support for LLJIT\n"; });
988 {
dbgs() <<
"Setting up GenericLLVMIRPlatform support for LLJIT\n"; });
994 {
dbgs() <<
"Explicitly deactivated platform support for LLJIT\n"; });
1002 TT =
JTMB->getTargetTriple();
1007 assert(TSM &&
"Can not add null module");
1010 [&](
Module &M) ->
Error { return applyDataLayout(M); }))
1013 return CODLayer->add(JD, std::move(TSM));
1026 LCTMgr = std::move(S.
LCTMgr);
1030 LCTMgr = std::move(*LCTMgrOrErr);
1032 Err = LCTMgrOrErr.takeError();
1046 Err = make_error<StringError>(
"Could not construct "
1047 "IndirectStubsManagerBuilder for target " +
1054 CODLayer = std::make_unique<CompileOnDemandLayer>(
1058 CODLayer->setCloneToNewContextOnEmit(
true);
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#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.
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
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.
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.
static StructType * create(LLVMContext &Context, StringRef Name)
This creates an identified struct.
Triple - Helper class for working with autoconf configuration names.
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
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
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())
Permanently loads the library at the given path and, on success, returns a DynamicLibrarySearchGenera...
static Expected< std::unique_ptr< EPCEHFrameRegistrar > > Create(ExecutionSession &ES, std::optional< ExecutorAddr > RegistrationFunctionsDylib=std::nullopt)
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.
decltype(auto) runSessionLocked(Func &&F)
Run the given lambda with the session mutex locked.
Represents an address in the executor process.
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.
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...
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.
ObjectLinkingLayerCreator CreateObjectLinkingLayer
unsigned NumCompileThreads
std::unique_ptr< ExecutionSession > ES
CompileFunctionCreator CreateCompileFunction
std::unique_ptr< ExecutorProcessControl > EPC
std::optional< DataLayout > DL
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.
JITDylib & getMainJITDylib()
Returns a reference to the JITDylib representing the JIT'd main program.
const DataLayout & getDataLayout() const
Returns a reference to the DataLayout for this instance.
std::unique_ptr< ObjectTransformLayer > ObjTransformLayer
virtual ~LLJIT()
Destruct this instance.
std::string mangle(StringRef UnmangledName) const
Returns a linker-mangled version of UnmangledName.
Expected< ExecutorAddr > lookup(JITDylib &JD, StringRef UnmangledName)
Look up a symbol in JITDylib JD based on its IR symbol name.
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.
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)
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.
friend void setUpGenericLLVMIRPlatform(LLJIT &J)
Configure the LLJIT instance to scrape modules for llvm.global_ctors and llvm.global_dtors variables ...
Error applyDataLayout(Module &M)
std::unique_ptr< ThreadPool > CompileThreads
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.
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).
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::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols)
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
Error setUpOrcPlatform(LLJIT &J)
Configure the LLJIT instance to use orc runtime support.
iterator_range< CtorDtorIterator > getConstructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
LLVM_ATTRIBUTE_USED void linkComponents()
std::function< std::unique_ptr< IndirectStubsManager >()> createLocalIndirectStubsManagerBuilder(const Triple &T)
Create a local indriect stubs manager builder.
void setUpGenericLLVMIRPlatform(LLJIT &J)
Configure the LLJIT instance to scrape modules for llvm.global_ctors and llvm.global_dtors variables ...
Expected< std::unique_ptr< LazyCallThroughManager > > createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES, ExecutorAddr ErrorHandlerAddr)
Create a LocalLazyCallThroughManager from the given triple and execution session.
Error setUpInactivePlatform(LLJIT &J)
Configure the LLJIT instance to disable platform support explicitly.
This is an optimization pass for GlobalISel generic memory operations.
ThreadPoolStrategy hardware_concurrency(unsigned ThreadCount=0)
Returns a default thread strategy where all available hardware resources are to be used,...
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
auto reverse(ContainerTy &&C)
void sort(IteratorTy Start, IteratorTy End)
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.
Function object to check whether the second component of a container supported by std::get (like std:...