LLVM  4.0.0
OrcCBindings.cpp
Go to the documentation of this file.
1 //===----------- OrcCBindings.cpp - C bindings for the Orc APIs -----------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "OrcCBindingsStack.h"
11 #include "llvm-c/OrcBindings.h"
12 
13 using namespace llvm;
14 
16  TargetMachine *TM2(unwrap(TM));
17 
18  Triple T(TM2->getTargetTriple());
19 
20  auto CompileCallbackMgr = orc::createLocalCompileCallbackManager(T, 0);
21  auto IndirectStubsMgrBuilder =
23 
24  OrcCBindingsStack *JITStack = new OrcCBindingsStack(
25  *TM2, std::move(CompileCallbackMgr), IndirectStubsMgrBuilder);
26 
27  return wrap(JITStack);
28 }
29 
30 const char *LLVMOrcGetErrorMsg(LLVMOrcJITStackRef JITStack) {
31  OrcCBindingsStack &J = *unwrap(JITStack);
32  return J.getErrorMessage().c_str();
33 }
34 
35 void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledName,
36  const char *SymbolName) {
37  OrcCBindingsStack &J = *unwrap(JITStack);
38  std::string Mangled = J.mangle(SymbolName);
39  *MangledName = new char[Mangled.size() + 1];
40  strcpy(*MangledName, Mangled.c_str());
41 }
42 
43 void LLVMOrcDisposeMangledSymbol(char *MangledName) { delete[] MangledName; }
44 
48  void *CallbackCtx) {
49  OrcCBindingsStack &J = *unwrap(JITStack);
50  return J.createLazyCompileCallback(Callback, CallbackCtx);
51 }
52 
54  const char *StubName,
55  LLVMOrcTargetAddress InitAddr) {
56  OrcCBindingsStack &J = *unwrap(JITStack);
57  return J.createIndirectStub(StubName, InitAddr);
58 }
59 
61  const char *StubName,
62  LLVMOrcTargetAddress NewAddr) {
63  OrcCBindingsStack &J = *unwrap(JITStack);
64  return J.setIndirectStubPointer(StubName, NewAddr);
65 }
66 
69  LLVMOrcSymbolResolverFn SymbolResolver,
70  void *SymbolResolverCtx) {
71  OrcCBindingsStack &J = *unwrap(JITStack);
72  Module *M(unwrap(Mod));
73  return J.addIRModuleEager(M, SymbolResolver, SymbolResolverCtx);
74 }
75 
78  LLVMOrcSymbolResolverFn SymbolResolver,
79  void *SymbolResolverCtx) {
80  OrcCBindingsStack &J = *unwrap(JITStack);
81  Module *M(unwrap(Mod));
82  return J.addIRModuleLazy(M, SymbolResolver, SymbolResolverCtx);
83 }
84 
86  OrcCBindingsStack &J = *unwrap(JITStack);
87  J.removeModule(H);
88 }
89 
91  const char *SymbolName) {
92  OrcCBindingsStack &J = *unwrap(JITStack);
93  auto Sym = J.findSymbol(SymbolName, true);
94  return Sym.getAddress();
95 }
96 
98  delete unwrap(JITStack);
99 }
uint64_t(* LLVMOrcLazyCompileCallbackFn)(LLVMOrcJITStackRef JITStack, void *CallbackCtx)
Definition: OrcBindings.h:36
JITTargetAddress getAddress()
Get the address of the symbol in the target address space.
Definition: JITSymbol.h:147
std::function< std::unique_ptr< IndirectStubsManager >)> createLocalIndirectStubsManagerBuilder(const Triple &T)
Create a local indriect stubs manager builder.
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: c/Types.h:62
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
LLVMOrcErrorCode setIndirectStubPointer(StringRef Name, JITTargetAddress Addr)
uint64_t(* LLVMOrcSymbolResolverFn)(const char *Name, void *LookupCtx)
Definition: OrcBindings.h:35
ModuleHandleT addIRModuleLazy(Module *M, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx)
const Triple & getTargetTriple() const
struct LLVMOpaqueTargetMachine * LLVMTargetMachineRef
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:191
LLVMOrcModuleHandle LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod, LLVMOrcSymbolResolverFn SymbolResolver, void *SymbolResolverCtx)
Add module to be eagerly compiled.
std::unique_ptr< JITCompileCallbackManager > createLocalCompileCallbackManager(const Triple &T, JITTargetAddress ErrorHandlerAddress)
Create a local compile callback manager.
void removeModule(ModuleHandleT H)
const std::string & getErrorMessage() const
JITTargetAddress createLazyCompileCallback(LLVMOrcLazyCompileCallbackFn Callback, void *CallbackCtx)
#define T
void LLVMOrcDisposeMangledSymbol(char *MangledName)
Dispose of a mangled symbol.
LLVMOrcErrorCode LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack, const char *StubName, LLVMOrcTargetAddress NewAddr)
Set the pointer for the given indirect stub.
LLVMOrcErrorCode
Definition: OrcBindings.h:39
uint64_t LLVMOrcTargetAddress
Definition: OrcBindings.h:34
void LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack, LLVMOrcModuleHandle H)
Remove a module set from the JIT.
LLVMOrcModuleHandle LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod, LLVMOrcSymbolResolverFn SymbolResolver, void *SymbolResolverCtx)
Add module to be lazily compiled one function at a time.
#define H(x, y, z)
Definition: MD5.cpp:53
LLVMOrcErrorCode createIndirectStub(StringRef StubName, JITTargetAddress Addr)
LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM)
Create an ORC JIT stack.
const char * LLVMOrcGetErrorMsg(LLVMOrcJITStackRef JITStack)
Get the error message for the most recent error (if any).
void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledName, const char *SymbolName)
Mangle the given symbol.
LLVMOrcErrorCode LLVMOrcCreateIndirectStub(LLVMOrcJITStackRef JITStack, const char *StubName, LLVMOrcTargetAddress InitAddr)
Create a named indirect call stub.
std::string mangle(StringRef Name)
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
void LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack)
Dispose of an ORC JIT stack.
LLVMOrcTargetAddress LLVMOrcCreateLazyCompileCallback(LLVMOrcJITStackRef JITStack, LLVMOrcLazyCompileCallbackFn Callback, void *CallbackCtx)
Create a lazy compile callback.
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:186
LLVMOrcTargetAddress LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack, const char *SymbolName)
Get symbol address from JIT instance.
JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly)
Primary interface to the complete machine description for the target machine.
struct LLVMOrcOpaqueJITStack * LLVMOrcJITStackRef
Definition: OrcBindings.h:32
ModuleHandleT addIRModuleEager(Module *M, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx)