Line data Source code
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 : #include "llvm/ExecutionEngine/JITEventListener.h"
13 :
14 : using namespace llvm;
15 :
16 4 : LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
17 : TargetMachine *TM2(unwrap(TM));
18 :
19 4 : Triple T(TM2->getTargetTriple());
20 :
21 : auto IndirectStubsMgrBuilder =
22 4 : orc::createLocalIndirectStubsManagerBuilder(T);
23 :
24 : OrcCBindingsStack *JITStack =
25 8 : new OrcCBindingsStack(*TM2, std::move(IndirectStubsMgrBuilder));
26 :
27 4 : return wrap(JITStack);
28 : }
29 :
30 0 : const char *LLVMOrcGetErrorMsg(LLVMOrcJITStackRef JITStack) {
31 : OrcCBindingsStack &J = *unwrap(JITStack);
32 0 : return J.getErrorMessage().c_str();
33 : }
34 :
35 4 : void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledName,
36 : const char *SymbolName) {
37 : OrcCBindingsStack &J = *unwrap(JITStack);
38 4 : std::string Mangled = J.mangle(SymbolName);
39 4 : *MangledName = new char[Mangled.size() + 1];
40 4 : strcpy(*MangledName, Mangled.c_str());
41 4 : }
42 :
43 4 : void LLVMOrcDisposeMangledSymbol(char *MangledName) { delete[] MangledName; }
44 :
45 1 : LLVMErrorRef LLVMOrcCreateLazyCompileCallback(
46 : LLVMOrcJITStackRef JITStack, LLVMOrcTargetAddress *RetAddr,
47 : LLVMOrcLazyCompileCallbackFn Callback, void *CallbackCtx) {
48 : OrcCBindingsStack &J = *unwrap(JITStack);
49 1 : if (auto Addr = J.createLazyCompileCallback(Callback, CallbackCtx)) {
50 1 : *RetAddr = *Addr;
51 1 : return LLVMErrorSuccess;
52 : } else
53 : return wrap(Addr.takeError());
54 : }
55 :
56 1 : LLVMErrorRef LLVMOrcCreateIndirectStub(LLVMOrcJITStackRef JITStack,
57 : const char *StubName,
58 : LLVMOrcTargetAddress InitAddr) {
59 : OrcCBindingsStack &J = *unwrap(JITStack);
60 2 : return wrap(J.createIndirectStub(StubName, InitAddr));
61 : }
62 :
63 1 : LLVMErrorRef LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack,
64 : const char *StubName,
65 : LLVMOrcTargetAddress NewAddr) {
66 : OrcCBindingsStack &J = *unwrap(JITStack);
67 2 : return wrap(J.setIndirectStubPointer(StubName, NewAddr));
68 : }
69 :
70 2 : LLVMErrorRef LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
71 : LLVMOrcModuleHandle *RetHandle,
72 : LLVMModuleRef Mod,
73 : LLVMOrcSymbolResolverFn SymbolResolver,
74 : void *SymbolResolverCtx) {
75 : OrcCBindingsStack &J = *unwrap(JITStack);
76 2 : std::unique_ptr<Module> M(unwrap(Mod));
77 2 : if (auto Handle =
78 4 : J.addIRModuleEager(std::move(M), SymbolResolver, SymbolResolverCtx)) {
79 2 : *RetHandle = *Handle;
80 2 : return LLVMErrorSuccess;
81 : } else
82 : return wrap(Handle.takeError());
83 : }
84 :
85 1 : LLVMErrorRef LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
86 : LLVMOrcModuleHandle *RetHandle,
87 : LLVMModuleRef Mod,
88 : LLVMOrcSymbolResolverFn SymbolResolver,
89 : void *SymbolResolverCtx) {
90 : OrcCBindingsStack &J = *unwrap(JITStack);
91 1 : std::unique_ptr<Module> M(unwrap(Mod));
92 1 : if (auto Handle =
93 2 : J.addIRModuleLazy(std::move(M), SymbolResolver, SymbolResolverCtx)) {
94 1 : *RetHandle = *Handle;
95 1 : return LLVMErrorSuccess;
96 : } else
97 : return wrap(Handle.takeError());
98 : }
99 :
100 1 : LLVMErrorRef LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack,
101 : LLVMOrcModuleHandle *RetHandle,
102 : LLVMMemoryBufferRef Obj,
103 : LLVMOrcSymbolResolverFn SymbolResolver,
104 : void *SymbolResolverCtx) {
105 : OrcCBindingsStack &J = *unwrap(JITStack);
106 : std::unique_ptr<MemoryBuffer> O(unwrap(Obj));
107 1 : if (auto Handle =
108 2 : J.addObject(std::move(O), SymbolResolver, SymbolResolverCtx)) {
109 1 : *RetHandle = *Handle;
110 1 : return LLVMErrorSuccess;
111 : } else
112 : return wrap(Handle.takeError());
113 : }
114 :
115 4 : LLVMErrorRef LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack,
116 : LLVMOrcModuleHandle H) {
117 : OrcCBindingsStack &J = *unwrap(JITStack);
118 4 : return wrap(J.removeModule(H));
119 : }
120 :
121 5 : LLVMErrorRef LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack,
122 : LLVMOrcTargetAddress *RetAddr,
123 : const char *SymbolName) {
124 : OrcCBindingsStack &J = *unwrap(JITStack);
125 15 : if (auto Addr = J.findSymbolAddress(SymbolName, true)) {
126 5 : *RetAddr = *Addr;
127 5 : return LLVMErrorSuccess;
128 : } else
129 : return wrap(Addr.takeError());
130 : }
131 :
132 1 : LLVMErrorRef LLVMOrcGetSymbolAddressIn(LLVMOrcJITStackRef JITStack,
133 : LLVMOrcTargetAddress *RetAddr,
134 : LLVMOrcModuleHandle H,
135 : const char *SymbolName) {
136 : OrcCBindingsStack &J = *unwrap(JITStack);
137 3 : if (auto Addr = J.findSymbolAddressIn(H, SymbolName, true)) {
138 1 : *RetAddr = *Addr;
139 1 : return LLVMErrorSuccess;
140 : } else
141 : return wrap(Addr.takeError());
142 : }
143 :
144 4 : LLVMErrorRef LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack) {
145 : auto *J = unwrap(JITStack);
146 4 : auto Err = J->shutdown();
147 4 : delete J;
148 4 : return wrap(std::move(Err));
149 : }
150 :
151 0 : void LLVMOrcRegisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L)
152 : {
153 0 : unwrap(JITStack)->RegisterJITEventListener(unwrap(L));
154 0 : }
155 :
156 0 : void LLVMOrcUnregisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L)
157 : {
158 0 : unwrap(JITStack)->UnregisterJITEventListener(unwrap(L));
159 0 : }
|
