1 //===--------------- OrcV2CBindings.cpp - C bindings OrcV2 APIs -----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm-c/LLJIT.h"
10 #include "llvm-c/Orc.h"
11 #include "llvm-c/OrcEE.h"
12 #include "llvm-c/TargetMachine.h"
13
14 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
15 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
16 #include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
17 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
18 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
19
20 using namespace llvm;
21 using namespace llvm::orc;
22
23 namespace llvm {
24 namespace orc {
25
26 class InProgressLookupState;
27
28 class OrcV2CAPIHelper {
29 public:
30 using PoolEntry = SymbolStringPtr::PoolEntry;
31 using PoolEntryPtr = SymbolStringPtr::PoolEntryPtr;
32
33 // Move from SymbolStringPtr to PoolEntryPtr (no change in ref count).
moveFromSymbolStringPtr(SymbolStringPtr S)34 static PoolEntryPtr moveFromSymbolStringPtr(SymbolStringPtr S) {
35 PoolEntryPtr Result = nullptr;
36 std::swap(Result, S.S);
37 return Result;
38 }
39
40 // Move from a PoolEntryPtr to a SymbolStringPtr (no change in ref count).
moveToSymbolStringPtr(PoolEntryPtr P)41 static SymbolStringPtr moveToSymbolStringPtr(PoolEntryPtr P) {
42 SymbolStringPtr S;
43 S.S = P;
44 return S;
45 }
46
47 // Copy a pool entry to a SymbolStringPtr (increments ref count).
copyToSymbolStringPtr(PoolEntryPtr P)48 static SymbolStringPtr copyToSymbolStringPtr(PoolEntryPtr P) {
49 return SymbolStringPtr(P);
50 }
51
getRawPoolEntryPtr(const SymbolStringPtr & S)52 static PoolEntryPtr getRawPoolEntryPtr(const SymbolStringPtr &S) {
53 return S.S;
54 }
55
retainPoolEntry(PoolEntryPtr P)56 static void retainPoolEntry(PoolEntryPtr P) {
57 SymbolStringPtr S(P);
58 S.S = nullptr;
59 }
60
releasePoolEntry(PoolEntryPtr P)61 static void releasePoolEntry(PoolEntryPtr P) {
62 SymbolStringPtr S;
63 S.S = P;
64 }
65
extractLookupState(LookupState & LS)66 static InProgressLookupState *extractLookupState(LookupState &LS) {
67 return LS.IPLS.release();
68 }
69
resetLookupState(LookupState & LS,InProgressLookupState * IPLS)70 static void resetLookupState(LookupState &LS, InProgressLookupState *IPLS) {
71 return LS.reset(IPLS);
72 }
73 };
74
75 } // namespace orc
76 } // namespace llvm
77
78 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionSession, LLVMOrcExecutionSessionRef)
79 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SymbolStringPool, LLVMOrcSymbolStringPoolRef)
80 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(OrcV2CAPIHelper::PoolEntry,
81 LLVMOrcSymbolStringPoolEntryRef)
82 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MaterializationUnit,
83 LLVMOrcMaterializationUnitRef)
84 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MaterializationResponsibility,
85 LLVMOrcMaterializationResponsibilityRef)
86 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITDylib, LLVMOrcJITDylibRef)
87 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ResourceTracker, LLVMOrcResourceTrackerRef)
88 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DefinitionGenerator,
89 LLVMOrcDefinitionGeneratorRef)
90 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(InProgressLookupState, LLVMOrcLookupStateRef)
91 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeContext,
92 LLVMOrcThreadSafeContextRef)
93 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeModule, LLVMOrcThreadSafeModuleRef)
94 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITTargetMachineBuilder,
95 LLVMOrcJITTargetMachineBuilderRef)
96 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ObjectLayer, LLVMOrcObjectLayerRef)
97 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRTransformLayer, LLVMOrcIRTransformLayerRef)
98 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ObjectTransformLayer,
99 LLVMOrcObjectTransformLayerRef)
100 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DumpObjects, LLVMOrcDumpObjectsRef)
101 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IndirectStubsManager,
102 LLVMOrcIndirectStubsManagerRef)
103 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LazyCallThroughManager,
104 LLVMOrcLazyCallThroughManagerRef)
105 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLJITBuilder, LLVMOrcLLJITBuilderRef)
106 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLJIT, LLVMOrcLLJITRef)
107 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
108
109 namespace llvm {
110 namespace orc {
111
112 class CAPIDefinitionGenerator final : public DefinitionGenerator {
113 public:
CAPIDefinitionGenerator(void * Ctx,LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate)114 CAPIDefinitionGenerator(
115 void *Ctx,
116 LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate)
117 : Ctx(Ctx), TryToGenerate(TryToGenerate) {}
118
tryToGenerate(LookupState & LS,LookupKind K,JITDylib & JD,JITDylibLookupFlags JDLookupFlags,const SymbolLookupSet & LookupSet)119 Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
120 JITDylibLookupFlags JDLookupFlags,
121 const SymbolLookupSet &LookupSet) override {
122
123 // Take the lookup state.
124 LLVMOrcLookupStateRef LSR = ::wrap(OrcV2CAPIHelper::extractLookupState(LS));
125
126 // Translate the lookup kind.
127 LLVMOrcLookupKind CLookupKind;
128 switch (K) {
129 case LookupKind::Static:
130 CLookupKind = LLVMOrcLookupKindStatic;
131 break;
132 case LookupKind::DLSym:
133 CLookupKind = LLVMOrcLookupKindDLSym;
134 break;
135 }
136
137 // Translate the JITDylibSearchFlags.
138 LLVMOrcJITDylibLookupFlags CJDLookupFlags;
139 switch (JDLookupFlags) {
140 case JITDylibLookupFlags::MatchExportedSymbolsOnly:
141 CJDLookupFlags = LLVMOrcJITDylibLookupFlagsMatchExportedSymbolsOnly;
142 break;
143 case JITDylibLookupFlags::MatchAllSymbols:
144 CJDLookupFlags = LLVMOrcJITDylibLookupFlagsMatchAllSymbols;
145 break;
146 }
147
148 // Translate the lookup set.
149 std::vector<LLVMOrcCLookupSetElement> CLookupSet;
150 CLookupSet.reserve(LookupSet.size());
151 for (auto &KV : LookupSet) {
152 LLVMOrcSymbolLookupFlags SLF;
153 LLVMOrcSymbolStringPoolEntryRef Name =
154 ::wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(KV.first));
155 switch (KV.second) {
156 case SymbolLookupFlags::RequiredSymbol:
157 SLF = LLVMOrcSymbolLookupFlagsRequiredSymbol;
158 break;
159 case SymbolLookupFlags::WeaklyReferencedSymbol:
160 SLF = LLVMOrcSymbolLookupFlagsWeaklyReferencedSymbol;
161 break;
162 }
163 CLookupSet.push_back({Name, SLF});
164 }
165
166 // Run the C TryToGenerate function.
167 auto Err = unwrap(TryToGenerate(::wrap(this), Ctx, &LSR, CLookupKind,
168 ::wrap(&JD), CJDLookupFlags,
169 CLookupSet.data(), CLookupSet.size()));
170
171 // Restore the lookup state.
172 OrcV2CAPIHelper::resetLookupState(LS, ::unwrap(LSR));
173
174 return Err;
175 }
176
177 private:
178 void *Ctx;
179 LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate;
180 };
181
182 } // end namespace orc
183 } // end namespace llvm
184
185 namespace {
186
187 class OrcCAPIMaterializationUnit : public llvm::orc::MaterializationUnit {
188 public:
OrcCAPIMaterializationUnit(std::string Name,SymbolFlagsMap InitialSymbolFlags,SymbolStringPtr InitSymbol,void * Ctx,LLVMOrcMaterializationUnitMaterializeFunction Materialize,LLVMOrcMaterializationUnitDiscardFunction Discard,LLVMOrcMaterializationUnitDestroyFunction Destroy)189 OrcCAPIMaterializationUnit(
190 std::string Name, SymbolFlagsMap InitialSymbolFlags,
191 SymbolStringPtr InitSymbol, void *Ctx,
192 LLVMOrcMaterializationUnitMaterializeFunction Materialize,
193 LLVMOrcMaterializationUnitDiscardFunction Discard,
194 LLVMOrcMaterializationUnitDestroyFunction Destroy)
195 : llvm::orc::MaterializationUnit(std::move(InitialSymbolFlags),
196 std::move(InitSymbol)),
197 Name(std::move(Name)), Ctx(Ctx), Materialize(Materialize),
198 Discard(Discard), Destroy(Destroy) {}
199
~OrcCAPIMaterializationUnit()200 ~OrcCAPIMaterializationUnit() {
201 if (Ctx)
202 Destroy(Ctx);
203 }
204
getName() const205 StringRef getName() const override { return Name; }
206
materialize(std::unique_ptr<MaterializationResponsibility> R)207 void materialize(std::unique_ptr<MaterializationResponsibility> R) override {
208 void *Tmp = Ctx;
209 Ctx = nullptr;
210 Materialize(Tmp, wrap(R.release()));
211 }
212
213 private:
discard(const JITDylib & JD,const SymbolStringPtr & Name)214 void discard(const JITDylib &JD, const SymbolStringPtr &Name) override {
215 Discard(Ctx, wrap(&JD), wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)));
216 }
217
218 std::string Name;
219 void *Ctx = nullptr;
220 LLVMOrcMaterializationUnitMaterializeFunction Materialize = nullptr;
221 LLVMOrcMaterializationUnitDiscardFunction Discard = nullptr;
222 LLVMOrcMaterializationUnitDestroyFunction Destroy = nullptr;
223 };
224
toJITSymbolFlags(LLVMJITSymbolFlags F)225 static JITSymbolFlags toJITSymbolFlags(LLVMJITSymbolFlags F) {
226
227 JITSymbolFlags JSF;
228
229 if (F.GenericFlags & LLVMJITSymbolGenericFlagsExported)
230 JSF |= JITSymbolFlags::Exported;
231 if (F.GenericFlags & LLVMJITSymbolGenericFlagsWeak)
232 JSF |= JITSymbolFlags::Weak;
233 if (F.GenericFlags & LLVMJITSymbolGenericFlagsCallable)
234 JSF |= JITSymbolFlags::Callable;
235 if (F.GenericFlags & LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly)
236 JSF |= JITSymbolFlags::MaterializationSideEffectsOnly;
237
238 JSF.getTargetFlags() = F.TargetFlags;
239
240 return JSF;
241 }
242
fromJITSymbolFlags(JITSymbolFlags JSF)243 static LLVMJITSymbolFlags fromJITSymbolFlags(JITSymbolFlags JSF) {
244 LLVMJITSymbolFlags F = {0, 0};
245 if (JSF & JITSymbolFlags::Exported)
246 F.GenericFlags |= LLVMJITSymbolGenericFlagsExported;
247 if (JSF & JITSymbolFlags::Weak)
248 F.GenericFlags |= LLVMJITSymbolGenericFlagsWeak;
249 if (JSF & JITSymbolFlags::Callable)
250 F.GenericFlags |= LLVMJITSymbolGenericFlagsCallable;
251 if (JSF & JITSymbolFlags::MaterializationSideEffectsOnly)
252 F.GenericFlags |= LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly;
253
254 F.TargetFlags = JSF.getTargetFlags();
255
256 return F;
257 }
258
toSymbolMap(LLVMOrcCSymbolMapPairs Syms,size_t NumPairs)259 static SymbolMap toSymbolMap(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) {
260 SymbolMap SM;
261 for (size_t I = 0; I != NumPairs; ++I) {
262 JITSymbolFlags Flags = toJITSymbolFlags(Syms[I].Sym.Flags);
263 SM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] =
264 JITEvaluatedSymbol(Syms[I].Sym.Address, Flags);
265 }
266 return SM;
267 }
268
269 static SymbolDependenceMap
toSymbolDependenceMap(LLVMOrcCDependenceMapPairs Pairs,size_t NumPairs)270 toSymbolDependenceMap(LLVMOrcCDependenceMapPairs Pairs, size_t NumPairs) {
271 SymbolDependenceMap SDM;
272 for (size_t I = 0; I != NumPairs; ++I) {
273 JITDylib *JD = unwrap(Pairs[I].JD);
274 SymbolNameSet Names;
275
276 for (size_t J = 0; J != Pairs[I].Names.Length; ++J) {
277 auto Sym = Pairs[I].Names.Symbols[J];
278 Names.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Sym)));
279 }
280 SDM[JD] = Names;
281 }
282 return SDM;
283 }
284
285 } // end anonymous namespace
286
LLVMOrcExecutionSessionSetErrorReporter(LLVMOrcExecutionSessionRef ES,LLVMOrcErrorReporterFunction ReportError,void * Ctx)287 void LLVMOrcExecutionSessionSetErrorReporter(
288 LLVMOrcExecutionSessionRef ES, LLVMOrcErrorReporterFunction ReportError,
289 void *Ctx) {
290 unwrap(ES)->setErrorReporter(
291 [=](Error Err) { ReportError(Ctx, wrap(std::move(Err))); });
292 }
293
294 LLVMOrcSymbolStringPoolRef
LLVMOrcExecutionSessionGetSymbolStringPool(LLVMOrcExecutionSessionRef ES)295 LLVMOrcExecutionSessionGetSymbolStringPool(LLVMOrcExecutionSessionRef ES) {
296 return wrap(
297 unwrap(ES)->getExecutorProcessControl().getSymbolStringPool().get());
298 }
299
LLVMOrcSymbolStringPoolClearDeadEntries(LLVMOrcSymbolStringPoolRef SSP)300 void LLVMOrcSymbolStringPoolClearDeadEntries(LLVMOrcSymbolStringPoolRef SSP) {
301 unwrap(SSP)->clearDeadEntries();
302 }
303
304 LLVMOrcSymbolStringPoolEntryRef
LLVMOrcExecutionSessionIntern(LLVMOrcExecutionSessionRef ES,const char * Name)305 LLVMOrcExecutionSessionIntern(LLVMOrcExecutionSessionRef ES, const char *Name) {
306 return wrap(
307 OrcV2CAPIHelper::moveFromSymbolStringPtr(unwrap(ES)->intern(Name)));
308 }
309
LLVMOrcRetainSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S)310 void LLVMOrcRetainSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) {
311 OrcV2CAPIHelper::retainPoolEntry(unwrap(S));
312 }
313
LLVMOrcReleaseSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S)314 void LLVMOrcReleaseSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) {
315 OrcV2CAPIHelper::releasePoolEntry(unwrap(S));
316 }
317
LLVMOrcSymbolStringPoolEntryStr(LLVMOrcSymbolStringPoolEntryRef S)318 const char *LLVMOrcSymbolStringPoolEntryStr(LLVMOrcSymbolStringPoolEntryRef S) {
319 return unwrap(S)->getKey().data();
320 }
321
322 LLVMOrcResourceTrackerRef
LLVMOrcJITDylibCreateResourceTracker(LLVMOrcJITDylibRef JD)323 LLVMOrcJITDylibCreateResourceTracker(LLVMOrcJITDylibRef JD) {
324 auto RT = unwrap(JD)->createResourceTracker();
325 // Retain the pointer for the C API client.
326 RT->Retain();
327 return wrap(RT.get());
328 }
329
330 LLVMOrcResourceTrackerRef
LLVMOrcJITDylibGetDefaultResourceTracker(LLVMOrcJITDylibRef JD)331 LLVMOrcJITDylibGetDefaultResourceTracker(LLVMOrcJITDylibRef JD) {
332 auto RT = unwrap(JD)->getDefaultResourceTracker();
333 // Retain the pointer for the C API client.
334 return wrap(RT.get());
335 }
336
LLVMOrcReleaseResourceTracker(LLVMOrcResourceTrackerRef RT)337 void LLVMOrcReleaseResourceTracker(LLVMOrcResourceTrackerRef RT) {
338 ResourceTrackerSP TmpRT(unwrap(RT));
339 TmpRT->Release();
340 }
341
LLVMOrcResourceTrackerTransferTo(LLVMOrcResourceTrackerRef SrcRT,LLVMOrcResourceTrackerRef DstRT)342 void LLVMOrcResourceTrackerTransferTo(LLVMOrcResourceTrackerRef SrcRT,
343 LLVMOrcResourceTrackerRef DstRT) {
344 ResourceTrackerSP TmpRT(unwrap(SrcRT));
345 TmpRT->transferTo(*unwrap(DstRT));
346 }
347
LLVMOrcResourceTrackerRemove(LLVMOrcResourceTrackerRef RT)348 LLVMErrorRef LLVMOrcResourceTrackerRemove(LLVMOrcResourceTrackerRef RT) {
349 ResourceTrackerSP TmpRT(unwrap(RT));
350 return wrap(TmpRT->remove());
351 }
352
LLVMOrcDisposeDefinitionGenerator(LLVMOrcDefinitionGeneratorRef DG)353 void LLVMOrcDisposeDefinitionGenerator(LLVMOrcDefinitionGeneratorRef DG) {
354 std::unique_ptr<DefinitionGenerator> TmpDG(unwrap(DG));
355 }
356
LLVMOrcDisposeMaterializationUnit(LLVMOrcMaterializationUnitRef MU)357 void LLVMOrcDisposeMaterializationUnit(LLVMOrcMaterializationUnitRef MU) {
358 std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU));
359 }
360
LLVMOrcCreateCustomMaterializationUnit(const char * Name,void * Ctx,LLVMOrcCSymbolFlagsMapPairs Syms,size_t NumSyms,LLVMOrcSymbolStringPoolEntryRef InitSym,LLVMOrcMaterializationUnitMaterializeFunction Materialize,LLVMOrcMaterializationUnitDiscardFunction Discard,LLVMOrcMaterializationUnitDestroyFunction Destroy)361 LLVMOrcMaterializationUnitRef LLVMOrcCreateCustomMaterializationUnit(
362 const char *Name, void *Ctx, LLVMOrcCSymbolFlagsMapPairs Syms,
363 size_t NumSyms, LLVMOrcSymbolStringPoolEntryRef InitSym,
364 LLVMOrcMaterializationUnitMaterializeFunction Materialize,
365 LLVMOrcMaterializationUnitDiscardFunction Discard,
366 LLVMOrcMaterializationUnitDestroyFunction Destroy) {
367 SymbolFlagsMap SFM;
368 for (size_t I = 0; I != NumSyms; ++I)
369 SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] =
370 toJITSymbolFlags(Syms[I].Flags);
371
372 auto IS = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(InitSym));
373
374 return wrap(new OrcCAPIMaterializationUnit(
375 Name, std::move(SFM), std::move(IS), Ctx, Materialize, Discard, Destroy));
376 }
377
378 LLVMOrcMaterializationUnitRef
LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms,size_t NumPairs)379 LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) {
380 SymbolMap SM = toSymbolMap(Syms, NumPairs);
381 return wrap(absoluteSymbols(std::move(SM)).release());
382 }
383
LLVMOrcLazyReexports(LLVMOrcLazyCallThroughManagerRef LCTM,LLVMOrcIndirectStubsManagerRef ISM,LLVMOrcJITDylibRef SourceJD,LLVMOrcCSymbolAliasMapPairs CallableAliases,size_t NumPairs)384 LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports(
385 LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM,
386 LLVMOrcJITDylibRef SourceJD, LLVMOrcCSymbolAliasMapPairs CallableAliases,
387 size_t NumPairs) {
388
389 SymbolAliasMap SAM;
390 for (size_t I = 0; I != NumPairs; ++I) {
391 auto pair = CallableAliases[I];
392 JITSymbolFlags Flags = toJITSymbolFlags(pair.Entry.Flags);
393 SymbolStringPtr Name =
394 OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Entry.Name));
395 SAM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Name))] =
396 SymbolAliasMapEntry(Name, Flags);
397 }
398
399 return wrap(lazyReexports(*unwrap(LCTM), *unwrap(ISM), *unwrap(SourceJD),
400 std::move(SAM))
401 .release());
402 }
403
LLVMOrcDisposeMaterializationResponsibility(LLVMOrcMaterializationResponsibilityRef MR)404 void LLVMOrcDisposeMaterializationResponsibility(
405 LLVMOrcMaterializationResponsibilityRef MR) {
406 std::unique_ptr<MaterializationResponsibility> TmpMR(unwrap(MR));
407 }
408
LLVMOrcMaterializationResponsibilityGetTargetDylib(LLVMOrcMaterializationResponsibilityRef MR)409 LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib(
410 LLVMOrcMaterializationResponsibilityRef MR) {
411 return wrap(&unwrap(MR)->getTargetJITDylib());
412 }
413
414 LLVMOrcExecutionSessionRef
LLVMOrcMaterializationResponsibilityGetExecutionSession(LLVMOrcMaterializationResponsibilityRef MR)415 LLVMOrcMaterializationResponsibilityGetExecutionSession(
416 LLVMOrcMaterializationResponsibilityRef MR) {
417 return wrap(&unwrap(MR)->getExecutionSession());
418 }
419
LLVMOrcMaterializationResponsibilityGetSymbols(LLVMOrcMaterializationResponsibilityRef MR,size_t * NumPairs)420 LLVMOrcCSymbolFlagsMapPairs LLVMOrcMaterializationResponsibilityGetSymbols(
421 LLVMOrcMaterializationResponsibilityRef MR, size_t *NumPairs) {
422
423 auto Symbols = unwrap(MR)->getSymbols();
424 LLVMOrcCSymbolFlagsMapPairs Result = static_cast<LLVMOrcCSymbolFlagsMapPairs>(
425 safe_malloc(Symbols.size() * sizeof(LLVMOrcCSymbolFlagsMapPair)));
426 size_t I = 0;
427 for (auto const &pair : Symbols) {
428 auto Name = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(pair.first));
429 auto Flags = pair.second;
430 Result[I] = {Name, fromJITSymbolFlags(Flags)};
431 I++;
432 }
433 *NumPairs = Symbols.size();
434 return Result;
435 }
436
LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs)437 void LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs) {
438 free(Pairs);
439 }
440
441 LLVMOrcSymbolStringPoolEntryRef
LLVMOrcMaterializationResponsibilityGetInitializerSymbol(LLVMOrcMaterializationResponsibilityRef MR)442 LLVMOrcMaterializationResponsibilityGetInitializerSymbol(
443 LLVMOrcMaterializationResponsibilityRef MR) {
444 auto Sym = unwrap(MR)->getInitializerSymbol();
445 return wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Sym));
446 }
447
448 LLVMOrcSymbolStringPoolEntryRef *
LLVMOrcMaterializationResponsibilityGetRequestedSymbols(LLVMOrcMaterializationResponsibilityRef MR,size_t * NumSymbols)449 LLVMOrcMaterializationResponsibilityGetRequestedSymbols(
450 LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols) {
451
452 auto Symbols = unwrap(MR)->getRequestedSymbols();
453 LLVMOrcSymbolStringPoolEntryRef *Result =
454 static_cast<LLVMOrcSymbolStringPoolEntryRef *>(safe_malloc(
455 Symbols.size() * sizeof(LLVMOrcSymbolStringPoolEntryRef)));
456 size_t I = 0;
457 for (auto &Name : Symbols) {
458 Result[I] = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name));
459 I++;
460 }
461 *NumSymbols = Symbols.size();
462 return Result;
463 }
464
LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef * Symbols)465 void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols) {
466 free(Symbols);
467 }
468
LLVMOrcMaterializationResponsibilityNotifyResolved(LLVMOrcMaterializationResponsibilityRef MR,LLVMOrcCSymbolMapPairs Symbols,size_t NumPairs)469 LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved(
470 LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols,
471 size_t NumPairs) {
472 SymbolMap SM = toSymbolMap(Symbols, NumPairs);
473 return wrap(unwrap(MR)->notifyResolved(std::move(SM)));
474 }
475
LLVMOrcMaterializationResponsibilityNotifyEmitted(LLVMOrcMaterializationResponsibilityRef MR)476 LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted(
477 LLVMOrcMaterializationResponsibilityRef MR) {
478 return wrap(unwrap(MR)->notifyEmitted());
479 }
480
LLVMOrcMaterializationResponsibilityDefineMaterializing(LLVMOrcMaterializationResponsibilityRef MR,LLVMOrcCSymbolFlagsMapPairs Syms,size_t NumSyms)481 LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
482 LLVMOrcMaterializationResponsibilityRef MR,
483 LLVMOrcCSymbolFlagsMapPairs Syms, size_t NumSyms) {
484 SymbolFlagsMap SFM;
485 for (size_t I = 0; I != NumSyms; ++I)
486 SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] =
487 toJITSymbolFlags(Syms[I].Flags);
488
489 return wrap(unwrap(MR)->defineMaterializing(std::move(SFM)));
490 }
491
LLVMOrcMaterializationResponsibilityReplace(LLVMOrcMaterializationResponsibilityRef MR,LLVMOrcMaterializationUnitRef MU)492 LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace(
493 LLVMOrcMaterializationResponsibilityRef MR,
494 LLVMOrcMaterializationUnitRef MU) {
495 std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU));
496 return wrap(unwrap(MR)->replace(std::move(TmpMU)));
497 }
498
LLVMOrcMaterializationResponsibilityDelegate(LLVMOrcMaterializationResponsibilityRef MR,LLVMOrcSymbolStringPoolEntryRef * Symbols,size_t NumSymbols,LLVMOrcMaterializationResponsibilityRef * Result)499 LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate(
500 LLVMOrcMaterializationResponsibilityRef MR,
501 LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols,
502 LLVMOrcMaterializationResponsibilityRef *Result) {
503 SymbolNameSet Syms;
504 for (size_t I = 0; I != NumSymbols; I++) {
505 Syms.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Symbols[I])));
506 }
507 auto OtherMR = unwrap(MR)->delegate(Syms);
508
509 if (!OtherMR) {
510 return wrap(OtherMR.takeError());
511 }
512 *Result = wrap(OtherMR->release());
513 return LLVMErrorSuccess;
514 }
515
LLVMOrcMaterializationResponsibilityAddDependencies(LLVMOrcMaterializationResponsibilityRef MR,LLVMOrcSymbolStringPoolEntryRef Name,LLVMOrcCDependenceMapPairs Dependencies,size_t NumPairs)516 void LLVMOrcMaterializationResponsibilityAddDependencies(
517 LLVMOrcMaterializationResponsibilityRef MR,
518 LLVMOrcSymbolStringPoolEntryRef Name,
519 LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) {
520
521 SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs);
522 auto Sym = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Name));
523 unwrap(MR)->addDependencies(Sym, SDM);
524 }
525
LLVMOrcMaterializationResponsibilityAddDependenciesForAll(LLVMOrcMaterializationResponsibilityRef MR,LLVMOrcCDependenceMapPairs Dependencies,size_t NumPairs)526 void LLVMOrcMaterializationResponsibilityAddDependenciesForAll(
527 LLVMOrcMaterializationResponsibilityRef MR,
528 LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) {
529
530 SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs);
531 unwrap(MR)->addDependenciesForAll(SDM);
532 }
533
LLVMOrcMaterializationResponsibilityFailMaterialization(LLVMOrcMaterializationResponsibilityRef MR)534 void LLVMOrcMaterializationResponsibilityFailMaterialization(
535 LLVMOrcMaterializationResponsibilityRef MR) {
536 unwrap(MR)->failMaterialization();
537 }
538
LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRLayer,LLVMOrcMaterializationResponsibilityRef MR,LLVMOrcThreadSafeModuleRef TSM)539 void LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRLayer,
540 LLVMOrcMaterializationResponsibilityRef MR,
541 LLVMOrcThreadSafeModuleRef TSM) {
542 std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
543 unwrap(IRLayer)->emit(
544 std::unique_ptr<MaterializationResponsibility>(unwrap(MR)),
545 std::move(*TmpTSM));
546 }
547
548 LLVMOrcJITDylibRef
LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES,const char * Name)549 LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES,
550 const char *Name) {
551 return wrap(&unwrap(ES)->createBareJITDylib(Name));
552 }
553
554 LLVMErrorRef
LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES,LLVMOrcJITDylibRef * Result,const char * Name)555 LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES,
556 LLVMOrcJITDylibRef *Result,
557 const char *Name) {
558 auto JD = unwrap(ES)->createJITDylib(Name);
559 if (!JD)
560 return wrap(JD.takeError());
561 *Result = wrap(&*JD);
562 return LLVMErrorSuccess;
563 }
564
565 LLVMOrcJITDylibRef
LLVMOrcExecutionSessionGetJITDylibByName(LLVMOrcExecutionSessionRef ES,const char * Name)566 LLVMOrcExecutionSessionGetJITDylibByName(LLVMOrcExecutionSessionRef ES,
567 const char *Name) {
568 return wrap(unwrap(ES)->getJITDylibByName(Name));
569 }
570
LLVMOrcJITDylibDefine(LLVMOrcJITDylibRef JD,LLVMOrcMaterializationUnitRef MU)571 LLVMErrorRef LLVMOrcJITDylibDefine(LLVMOrcJITDylibRef JD,
572 LLVMOrcMaterializationUnitRef MU) {
573 std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU));
574
575 if (auto Err = unwrap(JD)->define(TmpMU)) {
576 TmpMU.release();
577 return wrap(std::move(Err));
578 }
579 return LLVMErrorSuccess;
580 }
581
LLVMOrcJITDylibClear(LLVMOrcJITDylibRef JD)582 LLVMErrorRef LLVMOrcJITDylibClear(LLVMOrcJITDylibRef JD) {
583 return wrap(unwrap(JD)->clear());
584 }
585
LLVMOrcJITDylibAddGenerator(LLVMOrcJITDylibRef JD,LLVMOrcDefinitionGeneratorRef DG)586 void LLVMOrcJITDylibAddGenerator(LLVMOrcJITDylibRef JD,
587 LLVMOrcDefinitionGeneratorRef DG) {
588 unwrap(JD)->addGenerator(std::unique_ptr<DefinitionGenerator>(unwrap(DG)));
589 }
590
LLVMOrcCreateCustomCAPIDefinitionGenerator(LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction F,void * Ctx)591 LLVMOrcDefinitionGeneratorRef LLVMOrcCreateCustomCAPIDefinitionGenerator(
592 LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction F, void *Ctx) {
593 auto DG = std::make_unique<CAPIDefinitionGenerator>(Ctx, F);
594 return wrap(DG.release());
595 }
596
LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(LLVMOrcDefinitionGeneratorRef * Result,char GlobalPrefix,LLVMOrcSymbolPredicate Filter,void * FilterCtx)597 LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(
598 LLVMOrcDefinitionGeneratorRef *Result, char GlobalPrefix,
599 LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
600 assert(Result && "Result can not be null");
601 assert((Filter || !FilterCtx) &&
602 "if Filter is null then FilterCtx must also be null");
603
604 DynamicLibrarySearchGenerator::SymbolPredicate Pred;
605 if (Filter)
606 Pred = [=](const SymbolStringPtr &Name) -> bool {
607 return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)));
608 };
609
610 auto ProcessSymsGenerator =
611 DynamicLibrarySearchGenerator::GetForCurrentProcess(GlobalPrefix, Pred);
612
613 if (!ProcessSymsGenerator) {
614 *Result = 0;
615 return wrap(ProcessSymsGenerator.takeError());
616 }
617
618 *Result = wrap(ProcessSymsGenerator->release());
619 return LLVMErrorSuccess;
620 }
621
LLVMOrcCreateDynamicLibrarySearchGeneratorForPath(LLVMOrcDefinitionGeneratorRef * Result,const char * FileName,char GlobalPrefix,LLVMOrcSymbolPredicate Filter,void * FilterCtx)622 LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForPath(
623 LLVMOrcDefinitionGeneratorRef *Result, const char *FileName,
624 char GlobalPrefix, LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
625 assert(Result && "Result can not be null");
626 assert(FileName && "FileName can not be null");
627 assert((Filter || !FilterCtx) &&
628 "if Filter is null then FilterCtx must also be null");
629
630 DynamicLibrarySearchGenerator::SymbolPredicate Pred;
631 if (Filter)
632 Pred = [=](const SymbolStringPtr &Name) -> bool {
633 return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)));
634 };
635
636 auto LibrarySymsGenerator =
637 DynamicLibrarySearchGenerator::Load(FileName, GlobalPrefix, Pred);
638
639 if (!LibrarySymsGenerator) {
640 *Result = 0;
641 return wrap(LibrarySymsGenerator.takeError());
642 }
643
644 *Result = wrap(LibrarySymsGenerator->release());
645 return LLVMErrorSuccess;
646 }
647
LLVMOrcCreateStaticLibrarySearchGeneratorForPath(LLVMOrcDefinitionGeneratorRef * Result,LLVMOrcObjectLayerRef ObjLayer,const char * FileName,const char * TargetTriple)648 LLVMErrorRef LLVMOrcCreateStaticLibrarySearchGeneratorForPath(
649 LLVMOrcDefinitionGeneratorRef *Result, LLVMOrcObjectLayerRef ObjLayer,
650 const char *FileName, const char *TargetTriple) {
651 assert(Result && "Result can not be null");
652 assert(FileName && "Filename can not be null");
653 assert(ObjLayer && "ObjectLayer can not be null");
654
655 if (TargetTriple) {
656 auto TT = Triple(TargetTriple);
657 auto LibrarySymsGenerator =
658 StaticLibraryDefinitionGenerator::Load(*unwrap(ObjLayer), FileName, TT);
659 if (!LibrarySymsGenerator) {
660 *Result = 0;
661 return wrap(LibrarySymsGenerator.takeError());
662 }
663 *Result = wrap(LibrarySymsGenerator->release());
664 return LLVMErrorSuccess;
665 } else {
666 auto LibrarySymsGenerator =
667 StaticLibraryDefinitionGenerator::Load(*unwrap(ObjLayer), FileName);
668 if (!LibrarySymsGenerator) {
669 *Result = 0;
670 return wrap(LibrarySymsGenerator.takeError());
671 }
672 *Result = wrap(LibrarySymsGenerator->release());
673 return LLVMErrorSuccess;
674 }
675 }
676
LLVMOrcCreateNewThreadSafeContext(void)677 LLVMOrcThreadSafeContextRef LLVMOrcCreateNewThreadSafeContext(void) {
678 return wrap(new ThreadSafeContext(std::make_unique<LLVMContext>()));
679 }
680
681 LLVMContextRef
LLVMOrcThreadSafeContextGetContext(LLVMOrcThreadSafeContextRef TSCtx)682 LLVMOrcThreadSafeContextGetContext(LLVMOrcThreadSafeContextRef TSCtx) {
683 return wrap(unwrap(TSCtx)->getContext());
684 }
685
LLVMOrcDisposeThreadSafeContext(LLVMOrcThreadSafeContextRef TSCtx)686 void LLVMOrcDisposeThreadSafeContext(LLVMOrcThreadSafeContextRef TSCtx) {
687 delete unwrap(TSCtx);
688 }
689
690 LLVMErrorRef
LLVMOrcThreadSafeModuleWithModuleDo(LLVMOrcThreadSafeModuleRef TSM,LLVMOrcGenericIRModuleOperationFunction F,void * Ctx)691 LLVMOrcThreadSafeModuleWithModuleDo(LLVMOrcThreadSafeModuleRef TSM,
692 LLVMOrcGenericIRModuleOperationFunction F,
693 void *Ctx) {
694 return wrap(unwrap(TSM)->withModuleDo(
695 [&](Module &M) { return unwrap(F(Ctx, wrap(&M))); }));
696 }
697
698 LLVMOrcThreadSafeModuleRef
LLVMOrcCreateNewThreadSafeModule(LLVMModuleRef M,LLVMOrcThreadSafeContextRef TSCtx)699 LLVMOrcCreateNewThreadSafeModule(LLVMModuleRef M,
700 LLVMOrcThreadSafeContextRef TSCtx) {
701 return wrap(
702 new ThreadSafeModule(std::unique_ptr<Module>(unwrap(M)), *unwrap(TSCtx)));
703 }
704
LLVMOrcDisposeThreadSafeModule(LLVMOrcThreadSafeModuleRef TSM)705 void LLVMOrcDisposeThreadSafeModule(LLVMOrcThreadSafeModuleRef TSM) {
706 delete unwrap(TSM);
707 }
708
LLVMOrcJITTargetMachineBuilderDetectHost(LLVMOrcJITTargetMachineBuilderRef * Result)709 LLVMErrorRef LLVMOrcJITTargetMachineBuilderDetectHost(
710 LLVMOrcJITTargetMachineBuilderRef *Result) {
711 assert(Result && "Result can not be null");
712
713 auto JTMB = JITTargetMachineBuilder::detectHost();
714 if (!JTMB) {
715 Result = 0;
716 return wrap(JTMB.takeError());
717 }
718
719 *Result = wrap(new JITTargetMachineBuilder(std::move(*JTMB)));
720 return LLVMErrorSuccess;
721 }
722
723 LLVMOrcJITTargetMachineBuilderRef
LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(LLVMTargetMachineRef TM)724 LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(LLVMTargetMachineRef TM) {
725 auto *TemplateTM = unwrap(TM);
726
727 auto JTMB =
728 std::make_unique<JITTargetMachineBuilder>(TemplateTM->getTargetTriple());
729
730 (*JTMB)
731 .setCPU(TemplateTM->getTargetCPU().str())
732 .setRelocationModel(TemplateTM->getRelocationModel())
733 .setCodeModel(TemplateTM->getCodeModel())
734 .setCodeGenOptLevel(TemplateTM->getOptLevel())
735 .setFeatures(TemplateTM->getTargetFeatureString())
736 .setOptions(TemplateTM->Options);
737
738 LLVMDisposeTargetMachine(TM);
739
740 return wrap(JTMB.release());
741 }
742
LLVMOrcDisposeJITTargetMachineBuilder(LLVMOrcJITTargetMachineBuilderRef JTMB)743 void LLVMOrcDisposeJITTargetMachineBuilder(
744 LLVMOrcJITTargetMachineBuilderRef JTMB) {
745 delete unwrap(JTMB);
746 }
747
LLVMOrcJITTargetMachineBuilderGetTargetTriple(LLVMOrcJITTargetMachineBuilderRef JTMB)748 char *LLVMOrcJITTargetMachineBuilderGetTargetTriple(
749 LLVMOrcJITTargetMachineBuilderRef JTMB) {
750 auto Tmp = unwrap(JTMB)->getTargetTriple().str();
751 char *TargetTriple = (char *)malloc(Tmp.size() + 1);
752 strcpy(TargetTriple, Tmp.c_str());
753 return TargetTriple;
754 }
755
LLVMOrcJITTargetMachineBuilderSetTargetTriple(LLVMOrcJITTargetMachineBuilderRef JTMB,const char * TargetTriple)756 void LLVMOrcJITTargetMachineBuilderSetTargetTriple(
757 LLVMOrcJITTargetMachineBuilderRef JTMB, const char *TargetTriple) {
758 unwrap(JTMB)->getTargetTriple() = Triple(TargetTriple);
759 }
760
LLVMOrcObjectLayerAddObjectFile(LLVMOrcObjectLayerRef ObjLayer,LLVMOrcJITDylibRef JD,LLVMMemoryBufferRef ObjBuffer)761 LLVMErrorRef LLVMOrcObjectLayerAddObjectFile(LLVMOrcObjectLayerRef ObjLayer,
762 LLVMOrcJITDylibRef JD,
763 LLVMMemoryBufferRef ObjBuffer) {
764 return wrap(unwrap(ObjLayer)->add(
765 *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
766 }
767
LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcObjectLayerRef ObjLayer,LLVMOrcResourceTrackerRef RT,LLVMMemoryBufferRef ObjBuffer)768 LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcObjectLayerRef ObjLayer,
769 LLVMOrcResourceTrackerRef RT,
770 LLVMMemoryBufferRef ObjBuffer) {
771 return wrap(
772 unwrap(ObjLayer)->add(ResourceTrackerSP(unwrap(RT)),
773 std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
774 }
775
LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer,LLVMOrcMaterializationResponsibilityRef R,LLVMMemoryBufferRef ObjBuffer)776 void LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer,
777 LLVMOrcMaterializationResponsibilityRef R,
778 LLVMMemoryBufferRef ObjBuffer) {
779 unwrap(ObjLayer)->emit(
780 std::unique_ptr<MaterializationResponsibility>(unwrap(R)),
781 std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)));
782 }
783
LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer)784 void LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer) {
785 delete unwrap(ObjLayer);
786 }
787
LLVMOrcIRTransformLayerSetTransform(LLVMOrcIRTransformLayerRef IRTransformLayer,LLVMOrcIRTransformLayerTransformFunction TransformFunction,void * Ctx)788 void LLVMOrcIRTransformLayerSetTransform(
789 LLVMOrcIRTransformLayerRef IRTransformLayer,
790 LLVMOrcIRTransformLayerTransformFunction TransformFunction, void *Ctx) {
791 unwrap(IRTransformLayer)
792 ->setTransform(
793 [=](ThreadSafeModule TSM,
794 MaterializationResponsibility &R) -> Expected<ThreadSafeModule> {
795 LLVMOrcThreadSafeModuleRef TSMRef =
796 wrap(new ThreadSafeModule(std::move(TSM)));
797 if (LLVMErrorRef Err = TransformFunction(Ctx, &TSMRef, wrap(&R))) {
798 assert(!TSMRef && "TSMRef was not reset to null on error");
799 return unwrap(Err);
800 }
801 return std::move(*unwrap(TSMRef));
802 });
803 }
804
LLVMOrcObjectTransformLayerSetTransform(LLVMOrcObjectTransformLayerRef ObjTransformLayer,LLVMOrcObjectTransformLayerTransformFunction TransformFunction,void * Ctx)805 void LLVMOrcObjectTransformLayerSetTransform(
806 LLVMOrcObjectTransformLayerRef ObjTransformLayer,
807 LLVMOrcObjectTransformLayerTransformFunction TransformFunction, void *Ctx) {
808 unwrap(ObjTransformLayer)
809 ->setTransform([TransformFunction, Ctx](std::unique_ptr<MemoryBuffer> Obj)
810 -> Expected<std::unique_ptr<MemoryBuffer>> {
811 LLVMMemoryBufferRef ObjBuffer = wrap(Obj.release());
812 if (LLVMErrorRef Err = TransformFunction(Ctx, &ObjBuffer)) {
813 assert(!ObjBuffer && "ObjBuffer was not reset to null on error");
814 return unwrap(Err);
815 }
816 return std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer));
817 });
818 }
819
LLVMOrcCreateDumpObjects(const char * DumpDir,const char * IdentifierOverride)820 LLVMOrcDumpObjectsRef LLVMOrcCreateDumpObjects(const char *DumpDir,
821 const char *IdentifierOverride) {
822 assert(DumpDir && "DumpDir should not be null");
823 assert(IdentifierOverride && "IdentifierOverride should not be null");
824 return wrap(new DumpObjects(DumpDir, IdentifierOverride));
825 }
826
LLVMOrcDisposeDumpObjects(LLVMOrcDumpObjectsRef DumpObjects)827 void LLVMOrcDisposeDumpObjects(LLVMOrcDumpObjectsRef DumpObjects) {
828 delete unwrap(DumpObjects);
829 }
830
LLVMOrcDumpObjects_CallOperator(LLVMOrcDumpObjectsRef DumpObjects,LLVMMemoryBufferRef * ObjBuffer)831 LLVMErrorRef LLVMOrcDumpObjects_CallOperator(LLVMOrcDumpObjectsRef DumpObjects,
832 LLVMMemoryBufferRef *ObjBuffer) {
833 std::unique_ptr<MemoryBuffer> OB(unwrap(*ObjBuffer));
834 if (auto Result = (*unwrap(DumpObjects))(std::move(OB))) {
835 *ObjBuffer = wrap(Result->release());
836 return LLVMErrorSuccess;
837 } else {
838 *ObjBuffer = nullptr;
839 return wrap(Result.takeError());
840 }
841 }
842
LLVMOrcCreateLLJITBuilder(void)843 LLVMOrcLLJITBuilderRef LLVMOrcCreateLLJITBuilder(void) {
844 return wrap(new LLJITBuilder());
845 }
846
LLVMOrcDisposeLLJITBuilder(LLVMOrcLLJITBuilderRef Builder)847 void LLVMOrcDisposeLLJITBuilder(LLVMOrcLLJITBuilderRef Builder) {
848 delete unwrap(Builder);
849 }
850
LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(LLVMOrcLLJITBuilderRef Builder,LLVMOrcJITTargetMachineBuilderRef JTMB)851 void LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(
852 LLVMOrcLLJITBuilderRef Builder, LLVMOrcJITTargetMachineBuilderRef JTMB) {
853 unwrap(Builder)->setJITTargetMachineBuilder(std::move(*unwrap(JTMB)));
854 LLVMOrcDisposeJITTargetMachineBuilder(JTMB);
855 }
856
LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(LLVMOrcLLJITBuilderRef Builder,LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F,void * Ctx)857 void LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(
858 LLVMOrcLLJITBuilderRef Builder,
859 LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F, void *Ctx) {
860 unwrap(Builder)->setObjectLinkingLayerCreator(
861 [=](ExecutionSession &ES, const Triple &TT) {
862 auto TTStr = TT.str();
863 return std::unique_ptr<ObjectLayer>(
864 unwrap(F(Ctx, wrap(&ES), TTStr.c_str())));
865 });
866 }
867
LLVMOrcCreateLLJIT(LLVMOrcLLJITRef * Result,LLVMOrcLLJITBuilderRef Builder)868 LLVMErrorRef LLVMOrcCreateLLJIT(LLVMOrcLLJITRef *Result,
869 LLVMOrcLLJITBuilderRef Builder) {
870 assert(Result && "Result can not be null");
871
872 if (!Builder)
873 Builder = LLVMOrcCreateLLJITBuilder();
874
875 auto J = unwrap(Builder)->create();
876 LLVMOrcDisposeLLJITBuilder(Builder);
877
878 if (!J) {
879 Result = 0;
880 return wrap(J.takeError());
881 }
882
883 *Result = wrap(J->release());
884 return LLVMErrorSuccess;
885 }
886
LLVMOrcDisposeLLJIT(LLVMOrcLLJITRef J)887 LLVMErrorRef LLVMOrcDisposeLLJIT(LLVMOrcLLJITRef J) {
888 delete unwrap(J);
889 return LLVMErrorSuccess;
890 }
891
LLVMOrcLLJITGetExecutionSession(LLVMOrcLLJITRef J)892 LLVMOrcExecutionSessionRef LLVMOrcLLJITGetExecutionSession(LLVMOrcLLJITRef J) {
893 return wrap(&unwrap(J)->getExecutionSession());
894 }
895
LLVMOrcLLJITGetMainJITDylib(LLVMOrcLLJITRef J)896 LLVMOrcJITDylibRef LLVMOrcLLJITGetMainJITDylib(LLVMOrcLLJITRef J) {
897 return wrap(&unwrap(J)->getMainJITDylib());
898 }
899
LLVMOrcLLJITGetTripleString(LLVMOrcLLJITRef J)900 const char *LLVMOrcLLJITGetTripleString(LLVMOrcLLJITRef J) {
901 return unwrap(J)->getTargetTriple().str().c_str();
902 }
903
LLVMOrcLLJITGetGlobalPrefix(LLVMOrcLLJITRef J)904 char LLVMOrcLLJITGetGlobalPrefix(LLVMOrcLLJITRef J) {
905 return unwrap(J)->getDataLayout().getGlobalPrefix();
906 }
907
908 LLVMOrcSymbolStringPoolEntryRef
LLVMOrcLLJITMangleAndIntern(LLVMOrcLLJITRef J,const char * UnmangledName)909 LLVMOrcLLJITMangleAndIntern(LLVMOrcLLJITRef J, const char *UnmangledName) {
910 return wrap(OrcV2CAPIHelper::moveFromSymbolStringPtr(
911 unwrap(J)->mangleAndIntern(UnmangledName)));
912 }
913
LLVMOrcLLJITAddObjectFile(LLVMOrcLLJITRef J,LLVMOrcJITDylibRef JD,LLVMMemoryBufferRef ObjBuffer)914 LLVMErrorRef LLVMOrcLLJITAddObjectFile(LLVMOrcLLJITRef J, LLVMOrcJITDylibRef JD,
915 LLVMMemoryBufferRef ObjBuffer) {
916 return wrap(unwrap(J)->addObjectFile(
917 *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
918 }
919
LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcLLJITRef J,LLVMOrcResourceTrackerRef RT,LLVMMemoryBufferRef ObjBuffer)920 LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcLLJITRef J,
921 LLVMOrcResourceTrackerRef RT,
922 LLVMMemoryBufferRef ObjBuffer) {
923 return wrap(unwrap(J)->addObjectFile(
924 ResourceTrackerSP(unwrap(RT)),
925 std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
926 }
927
LLVMOrcLLJITAddLLVMIRModule(LLVMOrcLLJITRef J,LLVMOrcJITDylibRef JD,LLVMOrcThreadSafeModuleRef TSM)928 LLVMErrorRef LLVMOrcLLJITAddLLVMIRModule(LLVMOrcLLJITRef J,
929 LLVMOrcJITDylibRef JD,
930 LLVMOrcThreadSafeModuleRef TSM) {
931 std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
932 return wrap(unwrap(J)->addIRModule(*unwrap(JD), std::move(*TmpTSM)));
933 }
934
LLVMOrcLLJITAddLLVMIRModuleWithRT(LLVMOrcLLJITRef J,LLVMOrcResourceTrackerRef RT,LLVMOrcThreadSafeModuleRef TSM)935 LLVMErrorRef LLVMOrcLLJITAddLLVMIRModuleWithRT(LLVMOrcLLJITRef J,
936 LLVMOrcResourceTrackerRef RT,
937 LLVMOrcThreadSafeModuleRef TSM) {
938 std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
939 return wrap(unwrap(J)->addIRModule(ResourceTrackerSP(unwrap(RT)),
940 std::move(*TmpTSM)));
941 }
942
LLVMOrcLLJITLookup(LLVMOrcLLJITRef J,LLVMOrcJITTargetAddress * Result,const char * Name)943 LLVMErrorRef LLVMOrcLLJITLookup(LLVMOrcLLJITRef J,
944 LLVMOrcJITTargetAddress *Result,
945 const char *Name) {
946 assert(Result && "Result can not be null");
947
948 auto Sym = unwrap(J)->lookup(Name);
949 if (!Sym) {
950 *Result = 0;
951 return wrap(Sym.takeError());
952 }
953
954 *Result = Sym->getAddress();
955 return LLVMErrorSuccess;
956 }
957
LLVMOrcLLJITGetObjLinkingLayer(LLVMOrcLLJITRef J)958 LLVMOrcObjectLayerRef LLVMOrcLLJITGetObjLinkingLayer(LLVMOrcLLJITRef J) {
959 return wrap(&unwrap(J)->getObjLinkingLayer());
960 }
961
962 LLVMOrcObjectTransformLayerRef
LLVMOrcLLJITGetObjTransformLayer(LLVMOrcLLJITRef J)963 LLVMOrcLLJITGetObjTransformLayer(LLVMOrcLLJITRef J) {
964 return wrap(&unwrap(J)->getObjTransformLayer());
965 }
966
967 LLVMOrcObjectLayerRef
LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(LLVMOrcExecutionSessionRef ES)968 LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(
969 LLVMOrcExecutionSessionRef ES) {
970 assert(ES && "ES must not be null");
971 return wrap(new RTDyldObjectLinkingLayer(
972 *unwrap(ES), [] { return std::make_unique<SectionMemoryManager>(); }));
973 }
974
LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(LLVMOrcObjectLayerRef RTDyldObjLinkingLayer,LLVMJITEventListenerRef Listener)975 void LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(
976 LLVMOrcObjectLayerRef RTDyldObjLinkingLayer,
977 LLVMJITEventListenerRef Listener) {
978 assert(RTDyldObjLinkingLayer && "RTDyldObjLinkingLayer must not be null");
979 assert(Listener && "Listener must not be null");
980 reinterpret_cast<RTDyldObjectLinkingLayer *>(unwrap(RTDyldObjLinkingLayer))
981 ->registerJITEventListener(*unwrap(Listener));
982 }
983
LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J)984 LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J) {
985 return wrap(&unwrap(J)->getIRTransformLayer());
986 }
987
LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J)988 const char *LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J) {
989 return unwrap(J)->getDataLayout().getStringRepresentation().c_str();
990 }
991
992 LLVMOrcIndirectStubsManagerRef
LLVMOrcCreateLocalIndirectStubsManager(const char * TargetTriple)993 LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple) {
994 auto builder = createLocalIndirectStubsManagerBuilder(Triple(TargetTriple));
995 return wrap(builder().release());
996 }
997
LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM)998 void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM) {
999 std::unique_ptr<IndirectStubsManager> TmpISM(unwrap(ISM));
1000 }
1001
LLVMOrcCreateLocalLazyCallThroughManager(const char * TargetTriple,LLVMOrcExecutionSessionRef ES,LLVMOrcJITTargetAddress ErrorHandlerAddr,LLVMOrcLazyCallThroughManagerRef * Result)1002 LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
1003 const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
1004 LLVMOrcJITTargetAddress ErrorHandlerAddr,
1005 LLVMOrcLazyCallThroughManagerRef *Result) {
1006 auto LCTM = createLocalLazyCallThroughManager(Triple(TargetTriple),
1007 *unwrap(ES), ErrorHandlerAddr);
1008
1009 if (!LCTM)
1010 return wrap(LCTM.takeError());
1011 *Result = wrap(LCTM->release());
1012 return LLVMErrorSuccess;
1013 }
1014
LLVMOrcDisposeLazyCallThroughManager(LLVMOrcLazyCallThroughManagerRef LCM)1015 void LLVMOrcDisposeLazyCallThroughManager(
1016 LLVMOrcLazyCallThroughManagerRef LCM) {
1017 std::unique_ptr<LazyCallThroughManager> TmpLCM(unwrap(LCM));
1018 }
1019