10 #ifndef LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H
11 #define LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H
25 class OrcCBindingsStack;
38 typedef std::function<std::unique_ptr<CompileCallbackMgr>()>
46 virtual ~GenericHandle() {}
48 bool ExportedSymbolsOnly) = 0;
49 virtual void removeModule() = 0;
52 template <
typename LayerT>
class GenericHandleImpl :
public GenericHandle {
54 GenericHandleImpl(LayerT &Layer,
typename LayerT::ModuleSetHandleT Handle)
55 : Layer(Layer), Handle(std::move(Handle)) {}
57 JITSymbol findSymbolIn(
const std::string &
Name,
58 bool ExportedSymbolsOnly)
override {
59 return Layer.findSymbolIn(Handle, Name, ExportedSymbolsOnly);
62 void removeModule()
override {
return Layer.removeModuleSet(Handle); }
66 typename LayerT::ModuleSetHandleT Handle;
69 template <
typename LayerT>
70 std::unique_ptr<GenericHandleImpl<LayerT>>
71 createGenericHandle(LayerT &Layer,
typename LayerT::ModuleSetHandleT Handle) {
72 return llvm::make_unique<GenericHandleImpl<LayerT>>(Layer,
83 std::unique_ptr<CompileCallbackMgr> CCMgr,
84 IndirectStubsManagerBuilder IndirectStubsMgrBuilder)
85 : DL(TM.createDataLayout()), IndirectStubsMgr(IndirectStubsMgrBuilder()),
86 CCMgr(std::move(CCMgr)), ObjectLayer(),
87 CompileLayer(ObjectLayer, orc::SimpleCompiler(TM)),
88 CODLayer(CompileLayer,
90 *this->CCMgr, std::move(IndirectStubsMgrBuilder),
false),
92 [
this](
const std::string &S) {
return mangle(S); }) {}
96 CXXRuntimeOverrides.runDestructors();
98 for (
auto &DtorRunner : IRStaticDestructorRunners)
99 DtorRunner.runViaLayer(*
this);
103 std::string MangledName;
111 template <
typename PtrTy>
113 return reinterpret_cast<PtrTy
>(
static_cast<uintptr_t
>(Addr));
119 auto CCInfo = CCMgr->getCompileCallback();
121 return Callback(
wrap(
this), CallbackCtx);
123 return CCInfo.getAddress();
134 return mapError(IndirectStubsMgr->updatePointer(Name, Addr));
137 std::unique_ptr<JITSymbolResolver>
139 void *ExternalResolverCtx) {
141 [
this, ExternalResolver, ExternalResolverCtx](
const std::string &Name)
148 if (
auto Sym = CODLayer.findSymbol(Name,
true))
150 if (
auto Sym = CXXRuntimeOverrides.searchOverrides(Name))
153 if (ExternalResolver)
155 ExternalResolver(Name.c_str(), ExternalResolverCtx),
160 [](
const std::string &
Name) {
165 template <
typename LayerT>
167 std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
169 void *ExternalResolverCtx) {
177 std::vector<std::string> CtorNames, DtorNames;
179 CtorNames.push_back(mangle(Ctor.Func->getName()));
181 DtorNames.push_back(mangle(Dtor.Func->getName()));
184 auto Resolver = createResolver(ExternalResolver, ExternalResolverCtx);
187 std::vector<Module *> S;
188 S.push_back(std::move(M));
190 auto LH = Layer.addModuleSet(std::move(S), std::move(MemMgr),
191 std::move(Resolver));
192 ModuleHandleT
H = createHandle(Layer, LH);
199 IRStaticDestructorRunners.emplace_back(std::move(DtorNames), H);
206 void *ExternalResolverCtx) {
207 return addIRModule(CompileLayer, std::move(M),
208 llvm::make_unique<SectionMemoryManager>(),
209 std::move(ExternalResolver), ExternalResolverCtx);
214 void *ExternalResolverCtx) {
215 return addIRModule(CODLayer, std::move(M),
216 llvm::make_unique<SectionMemoryManager>(),
217 std::move(ExternalResolver), ExternalResolverCtx);
221 GenericHandles[
H]->removeModule();
222 GenericHandles[
H] =
nullptr;
223 FreeHandleIndexes.push_back(H);
227 if (
auto Sym = IndirectStubsMgr->findStub(Name, ExportedSymbolsOnly))
229 return CODLayer.findSymbol(mangle(Name), ExportedSymbolsOnly);
233 bool ExportedSymbolsOnly) {
234 return GenericHandles[
H]->findSymbolIn(Name, ExportedSymbolsOnly);
240 template <
typename LayerT>
241 unsigned createHandle(LayerT &Layer,
242 typename LayerT::ModuleSetHandleT Handle) {
244 if (!FreeHandleIndexes.empty()) {
245 NewHandle = FreeHandleIndexes.back();
246 FreeHandleIndexes.pop_back();
247 GenericHandles[NewHandle] = createGenericHandle(Layer, std::move(Handle));
250 NewHandle = GenericHandles.size();
251 GenericHandles.push_back(createGenericHandle(Layer, std::move(Handle)));
262 raw_string_ostream ErrStream(ErrMsg);
269 SectionMemoryManager CCMgrMemMgr;
271 std::unique_ptr<orc::IndirectStubsManager> IndirectStubsMgr;
273 std::unique_ptr<CompileCallbackMgr> CCMgr;
274 ObjLayerT ObjectLayer;
275 CompileLayerT CompileLayer;
278 std::vector<std::unique_ptr<GenericHandle>> GenericHandles;
279 std::vector<unsigned> FreeHandleIndexes;
281 orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
282 std::vector<orc::CtorDtorRunner<OrcCBindingsStack>> IRStaticDestructorRunners;
288 #endif // LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H
uint64_t(* LLVMOrcLazyCompileCallbackFn)(LLVMOrcJITStackRef JITStack, void *CallbackCtx)
std::function< std::unique_ptr< IndirectStubsManager >)> IndirectStubsManagerBuilderT
Builder for IndirectStubsManagers.
Represents a symbol in the JIT.
A Module instance is used to store all the information related to an LLVM module. ...
LLVMOrcErrorCode setIndirectStubPointer(StringRef Name, JITTargetAddress Addr)
bool runViaLayer(JITLayerT &JITLayer) const
Run the recorded constructors/destructors through the given JIT layer.
orc::IRCompileLayer< ObjLayerT > CompileLayerT
void setDataLayout(StringRef Desc)
Set the data layout.
std::function< std::unique_ptr< CompileCallbackMgr >)> CallbackManagerBuilder
uint64_t(* LLVMOrcSymbolResolverFn)(const char *Name, void *LookupCtx)
bool isDefault() const
Test if the DataLayout was constructed from an empty string.
Target-independent base class for compile callback management.
ModuleHandleT addIRModuleLazy(Module *M, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx)
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
orc::JITCompileCallbackManager CompileCallbackMgr
struct LLVMOpaqueTargetMachine * LLVMTargetMachineRef
std::unique_ptr< LambdaResolver< DylibLookupFtorT, ExternalLookupFtorT > > createLambdaResolver(DylibLookupFtorT DylibLookupFtor, ExternalLookupFtorT ExternalLookupFtor)
void removeModule(ModuleHandleT H)
const std::string & getErrorMessage() const
Bare bones object linking layer.
std::unique_ptr< JITSymbolResolver > createResolver(LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx)
JITTargetAddress createLazyCompileCallback(LLVMOrcLazyCompileCallbackFn Callback, void *CallbackCtx)
iterator_range< CtorDtorIterator > getDestructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
OrcCBindingsStack(TargetMachine &TM, std::unique_ptr< CompileCallbackMgr > CCMgr, IndirectStubsManagerBuilder IndirectStubsMgrBuilder)
unsigned ModuleSetHandleT
CODLayerT::IndirectStubsManagerBuilderT IndirectStubsManagerBuilder
JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name, bool ExportedSymbolsOnly)
Convenience class for recording constructor/destructor names for later execution. ...
ModuleHandleT addIRModule(LayerT &Layer, Module *M, std::unique_ptr< RuntimeDyld::MemoryManager > MemMgr, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx)
LLVMOrcErrorCode createIndirectStub(StringRef StubName, JITTargetAddress Addr)
uint64_t JITTargetAddress
Represents an address in the target process's address space.
void handleAllErrors(Error E, HandlerTs &&...Handlers)
Behaves the same as handleErrors, except that it requires that all errors be handled by the given han...
std::string mangle(StringRef Name)
*this CXXRuntimeOverrides([this](const std::string &S){return mangle(S);})
orc::ObjectLinkingLayer ObjLayerT
static PtrTy fromTargetAddress(JITTargetAddress Addr)
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
LLVMAttributeRef wrap(Attribute Attr)
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
iterator_range< CtorDtorIterator > getConstructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
orc::CompileOnDemandLayer< CompileLayerT, CompileCallbackMgr > CODLayerT
A raw_ostream that writes to an std::string.
JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly)
StringRef - Represent a constant reference to a string, i.e.
struct LLVMOrcOpaqueJITStack * LLVMOrcJITStackRef
ModuleHandleT addIRModuleEager(Module *M, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx)