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/JITLink/JITLinkMemoryManager.h"
15#include "llvm/ExecutionEngine/Orc/AbsoluteSymbols.h"
16#include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
17#include "llvm/ExecutionEngine/Orc/LLJIT.h"
18#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
19#include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
20#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
21#include "llvm/ExecutionEngine/SectionMemoryManager.h"
22
23using namespace llvm;
24using namespace llvm::orc;
25
26namespace llvm {
27namespace orc {
28
29class InProgressLookupState;
30
31class OrcV2CAPIHelper {
32public:
33 static InProgressLookupState *extractLookupState(LookupState &LS) {
34 return LS.IPLS.release();
35 }
36
37 static void resetLookupState(LookupState &LS, InProgressLookupState *IPLS) {
38 return LS.reset(IPLS);
39 }
40};
41
42} // namespace orc
43} // namespace llvm
44
45inline LLVMOrcSymbolStringPoolEntryRef wrap(SymbolStringPoolEntryUnsafe E) {
46 return reinterpret_cast<LLVMOrcSymbolStringPoolEntryRef>(E.rawPtr());
47}
48
49inline SymbolStringPoolEntryUnsafe unwrap(LLVMOrcSymbolStringPoolEntryRef E) {
50 return reinterpret_cast<SymbolStringPoolEntryUnsafe::PoolEntry *>(E);
51}
52
53DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionSession, LLVMOrcExecutionSessionRef)
54DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SymbolStringPool, LLVMOrcSymbolStringPoolRef)
55DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MaterializationUnit,
56 LLVMOrcMaterializationUnitRef)
57DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MaterializationResponsibility,
58 LLVMOrcMaterializationResponsibilityRef)
59DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITDylib, LLVMOrcJITDylibRef)
60DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ResourceTracker, LLVMOrcResourceTrackerRef)
61DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DefinitionGenerator,
62 LLVMOrcDefinitionGeneratorRef)
63DEFINE_SIMPLE_CONVERSION_FUNCTIONS(InProgressLookupState, LLVMOrcLookupStateRef)
64DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeContext,
65 LLVMOrcThreadSafeContextRef)
66DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeModule, LLVMOrcThreadSafeModuleRef)
67DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITTargetMachineBuilder,
68 LLVMOrcJITTargetMachineBuilderRef)
69DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ObjectLayer, LLVMOrcObjectLayerRef)
70DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRTransformLayer, LLVMOrcIRTransformLayerRef)
71DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ObjectTransformLayer,
72 LLVMOrcObjectTransformLayerRef)
73DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DumpObjects, LLVMOrcDumpObjectsRef)
74DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IndirectStubsManager,
75 LLVMOrcIndirectStubsManagerRef)
76DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LazyCallThroughManager,
77 LLVMOrcLazyCallThroughManagerRef)
78DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLJITBuilder, LLVMOrcLLJITBuilderRef)
79DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLJIT, LLVMOrcLLJITRef)
80DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
81
82namespace {
83
84class OrcCAPIMaterializationUnit : public llvm::orc::MaterializationUnit {
85public:
86 OrcCAPIMaterializationUnit(
87 std::string Name, SymbolFlagsMap InitialSymbolFlags,
88 SymbolStringPtr InitSymbol, void *Ctx,
89 LLVMOrcMaterializationUnitMaterializeFunction Materialize,
90 LLVMOrcMaterializationUnitDiscardFunction Discard,
91 LLVMOrcMaterializationUnitDestroyFunction Destroy)
92 : llvm::orc::MaterializationUnit(
93 Interface(std::move(InitialSymbolFlags), std::move(InitSymbol))),
94 Name(std::move(Name)), Ctx(Ctx), Materialize(Materialize),
95 Discard(Discard), Destroy(Destroy) {}
96
97 ~OrcCAPIMaterializationUnit() override {
98 if (Ctx)
99 Destroy(Ctx);
100 }
101
102 StringRef getName() const override { return Name; }
103
104 void materialize(std::unique_ptr<MaterializationResponsibility> R) override {
105 void *Tmp = Ctx;
106 Ctx = nullptr;
107 Materialize(Tmp, wrap(P: R.release()));
108 }
109
110private:
111 void discard(const JITDylib &JD, const SymbolStringPtr &Name) override {
112 Discard(Ctx, wrap(P: &JD), wrap(E: SymbolStringPoolEntryUnsafe::from(S: Name)));
113 }
114
115 std::string Name;
116 void *Ctx = nullptr;
117 LLVMOrcMaterializationUnitMaterializeFunction Materialize = nullptr;
118 LLVMOrcMaterializationUnitDiscardFunction Discard = nullptr;
119 LLVMOrcMaterializationUnitDestroyFunction Destroy = nullptr;
120};
121
122static JITSymbolFlags toJITSymbolFlags(LLVMJITSymbolFlags F) {
123
124 JITSymbolFlags JSF;
125
126 if (F.GenericFlags & LLVMJITSymbolGenericFlagsExported)
127 JSF |= JITSymbolFlags::Exported;
128 if (F.GenericFlags & LLVMJITSymbolGenericFlagsWeak)
129 JSF |= JITSymbolFlags::Weak;
130 if (F.GenericFlags & LLVMJITSymbolGenericFlagsCallable)
131 JSF |= JITSymbolFlags::Callable;
132 if (F.GenericFlags & LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly)
133 JSF |= JITSymbolFlags::MaterializationSideEffectsOnly;
134
135 JSF.getTargetFlags() = F.TargetFlags;
136
137 return JSF;
138}
139
140static LLVMJITSymbolFlags fromJITSymbolFlags(JITSymbolFlags JSF) {
141 LLVMJITSymbolFlags F = {.GenericFlags: 0, .TargetFlags: 0};
142 if (JSF & JITSymbolFlags::Exported)
143 F.GenericFlags |= LLVMJITSymbolGenericFlagsExported;
144 if (JSF & JITSymbolFlags::Weak)
145 F.GenericFlags |= LLVMJITSymbolGenericFlagsWeak;
146 if (JSF & JITSymbolFlags::Callable)
147 F.GenericFlags |= LLVMJITSymbolGenericFlagsCallable;
148 if (JSF & JITSymbolFlags::MaterializationSideEffectsOnly)
149 F.GenericFlags |= LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly;
150
151 F.TargetFlags = JSF.getTargetFlags();
152
153 return F;
154}
155
156static SymbolNameSet toSymbolNameSet(LLVMOrcCSymbolsList Symbols) {
157 SymbolNameSet Result;
158 Result.reserve(Size: Symbols.Length);
159 for (size_t I = 0; I != Symbols.Length; ++I)
160 Result.insert(V: unwrap(E: Symbols.Symbols[I]).moveToSymbolStringPtr());
161 return Result;
162}
163
164static SymbolMap toSymbolMap(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) {
165 SymbolMap SM;
166 for (size_t I = 0; I != NumPairs; ++I) {
167 JITSymbolFlags Flags = toJITSymbolFlags(F: Syms[I].Sym.Flags);
168 SM[unwrap(E: Syms[I].Name).moveToSymbolStringPtr()] = {
169 ExecutorAddr(Syms[I].Sym.Address), Flags};
170 }
171 return SM;
172}
173
174static SymbolDependenceMap
175toSymbolDependenceMap(LLVMOrcCDependenceMapPairs Pairs, size_t NumPairs) {
176 SymbolDependenceMap SDM;
177 for (size_t I = 0; I != NumPairs; ++I) {
178 JITDylib *JD = unwrap(P: Pairs[I].JD);
179 SymbolNameSet Names;
180
181 for (size_t J = 0; J != Pairs[I].Names.Length; ++J) {
182 auto Sym = Pairs[I].Names.Symbols[J];
183 Names.insert(V: unwrap(E: Sym).moveToSymbolStringPtr());
184 }
185 SDM[JD] = Names;
186 }
187 return SDM;
188}
189
190static LookupKind toLookupKind(LLVMOrcLookupKind K) {
191 switch (K) {
192 case LLVMOrcLookupKindStatic:
193 return LookupKind::Static;
194 case LLVMOrcLookupKindDLSym:
195 return LookupKind::DLSym;
196 }
197 llvm_unreachable("unrecognized LLVMOrcLookupKind value");
198}
199
200static LLVMOrcLookupKind fromLookupKind(LookupKind K) {
201 switch (K) {
202 case LookupKind::Static:
203 return LLVMOrcLookupKindStatic;
204 case LookupKind::DLSym:
205 return LLVMOrcLookupKindDLSym;
206 }
207 llvm_unreachable("unrecognized LookupKind value");
208}
209
210static JITDylibLookupFlags
211toJITDylibLookupFlags(LLVMOrcJITDylibLookupFlags LF) {
212 switch (LF) {
213 case LLVMOrcJITDylibLookupFlagsMatchExportedSymbolsOnly:
214 return JITDylibLookupFlags::MatchExportedSymbolsOnly;
215 case LLVMOrcJITDylibLookupFlagsMatchAllSymbols:
216 return JITDylibLookupFlags::MatchAllSymbols;
217 }
218 llvm_unreachable("unrecognized LLVMOrcJITDylibLookupFlags value");
219}
220
221static LLVMOrcJITDylibLookupFlags
222fromJITDylibLookupFlags(JITDylibLookupFlags LF) {
223 switch (LF) {
224 case JITDylibLookupFlags::MatchExportedSymbolsOnly:
225 return LLVMOrcJITDylibLookupFlagsMatchExportedSymbolsOnly;
226 case JITDylibLookupFlags::MatchAllSymbols:
227 return LLVMOrcJITDylibLookupFlagsMatchAllSymbols;
228 }
229 llvm_unreachable("unrecognized JITDylibLookupFlags value");
230}
231
232static SymbolLookupFlags toSymbolLookupFlags(LLVMOrcSymbolLookupFlags SLF) {
233 switch (SLF) {
234 case LLVMOrcSymbolLookupFlagsRequiredSymbol:
235 return SymbolLookupFlags::RequiredSymbol;
236 case LLVMOrcSymbolLookupFlagsWeaklyReferencedSymbol:
237 return SymbolLookupFlags::WeaklyReferencedSymbol;
238 }
239 llvm_unreachable("unrecognized LLVMOrcSymbolLookupFlags value");
240}
241
242static LLVMOrcSymbolLookupFlags fromSymbolLookupFlags(SymbolLookupFlags SLF) {
243 switch (SLF) {
244 case SymbolLookupFlags::RequiredSymbol:
245 return LLVMOrcSymbolLookupFlagsRequiredSymbol;
246 case SymbolLookupFlags::WeaklyReferencedSymbol:
247 return LLVMOrcSymbolLookupFlagsWeaklyReferencedSymbol;
248 }
249 llvm_unreachable("unrecognized SymbolLookupFlags value");
250}
251
252static LLVMJITEvaluatedSymbol
253fromExecutorSymbolDef(const ExecutorSymbolDef &S) {
254 return {.Address: S.getAddress().getValue(), .Flags: fromJITSymbolFlags(JSF: S.getFlags())};
255}
256
257} // end anonymous namespace
258
259namespace llvm {
260namespace orc {
261
262class CAPIDefinitionGenerator final : public DefinitionGenerator {
263public:
264 CAPIDefinitionGenerator(
265 LLVMOrcDisposeCAPIDefinitionGeneratorFunction Dispose, void *Ctx,
266 LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate)
267 : Dispose(Dispose), Ctx(Ctx), TryToGenerate(TryToGenerate) {}
268
269 ~CAPIDefinitionGenerator() override {
270 if (Dispose)
271 Dispose(Ctx);
272 }
273
274 Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
275 JITDylibLookupFlags JDLookupFlags,
276 const SymbolLookupSet &LookupSet) override {
277
278 // Take the lookup state.
279 LLVMOrcLookupStateRef LSR = ::wrap(P: OrcV2CAPIHelper::extractLookupState(LS));
280
281 // Translate the lookup kind.
282 LLVMOrcLookupKind CLookupKind = fromLookupKind(K);
283
284 // Translate the JITDylibLookupFlags.
285 LLVMOrcJITDylibLookupFlags CJDLookupFlags =
286 fromJITDylibLookupFlags(LF: JDLookupFlags);
287
288 // Translate the lookup set.
289 std::vector<LLVMOrcCLookupSetElement> CLookupSet;
290 CLookupSet.reserve(n: LookupSet.size());
291 for (auto &KV : LookupSet) {
292 LLVMOrcSymbolStringPoolEntryRef Name =
293 ::wrap(E: SymbolStringPoolEntryUnsafe::from(S: KV.first));
294 LLVMOrcSymbolLookupFlags SLF = fromSymbolLookupFlags(SLF: KV.second);
295 CLookupSet.push_back(x: {.Name: Name, .LookupFlags: SLF});
296 }
297
298 // Run the C TryToGenerate function.
299 auto Err = unwrap(ErrRef: TryToGenerate(::wrap(P: this), Ctx, &LSR, CLookupKind,
300 ::wrap(P: &JD), CJDLookupFlags,
301 CLookupSet.data(), CLookupSet.size()));
302
303 // Restore the lookup state.
304 OrcV2CAPIHelper::resetLookupState(LS, IPLS: ::unwrap(P: LSR));
305
306 return Err;
307 }
308
309private:
310 LLVMOrcDisposeCAPIDefinitionGeneratorFunction Dispose;
311 void *Ctx;
312 LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate;
313};
314
315} // end namespace orc
316} // end namespace llvm
317
318void LLVMOrcExecutionSessionSetErrorReporter(
319 LLVMOrcExecutionSessionRef ES, LLVMOrcErrorReporterFunction ReportError,
320 void *Ctx) {
321 unwrap(P: ES)->setErrorReporter(
322 [=](Error Err) { ReportError(Ctx, wrap(Err: std::move(Err))); });
323}
324
325LLVMOrcSymbolStringPoolRef
326LLVMOrcExecutionSessionGetSymbolStringPool(LLVMOrcExecutionSessionRef ES) {
327 return wrap(
328 P: unwrap(P: ES)->getExecutorProcessControl().getSymbolStringPool().get());
329}
330
331void LLVMOrcSymbolStringPoolClearDeadEntries(LLVMOrcSymbolStringPoolRef SSP) {
332 unwrap(P: SSP)->clearDeadEntries();
333}
334
335LLVMOrcSymbolStringPoolEntryRef
336LLVMOrcExecutionSessionIntern(LLVMOrcExecutionSessionRef ES, const char *Name) {
337 return wrap(E: SymbolStringPoolEntryUnsafe::take(S: unwrap(P: ES)->intern(SymName: Name)));
338}
339
340void LLVMOrcExecutionSessionLookup(
341 LLVMOrcExecutionSessionRef ES, LLVMOrcLookupKind K,
342 LLVMOrcCJITDylibSearchOrder SearchOrder, size_t SearchOrderSize,
343 LLVMOrcCLookupSet Symbols, size_t SymbolsSize,
344 LLVMOrcExecutionSessionLookupHandleResultFunction HandleResult, void *Ctx) {
345 assert(ES && "ES cannot be null");
346 assert(SearchOrder && "SearchOrder cannot be null");
347 assert(Symbols && "Symbols cannot be null");
348 assert(HandleResult && "HandleResult cannot be null");
349
350 JITDylibSearchOrder SO;
351 for (size_t I = 0; I != SearchOrderSize; ++I)
352 SO.push_back(x: {unwrap(P: SearchOrder[I].JD),
353 toJITDylibLookupFlags(LF: SearchOrder[I].JDLookupFlags)});
354
355 SymbolLookupSet SLS;
356 for (size_t I = 0; I != SymbolsSize; ++I)
357 SLS.add(Name: unwrap(E: Symbols[I].Name).moveToSymbolStringPtr(),
358 Flags: toSymbolLookupFlags(SLF: Symbols[I].LookupFlags));
359
360 unwrap(P: ES)->lookup(
361 K: toLookupKind(K), SearchOrder: SO, Symbols: std::move(SLS), RequiredState: SymbolState::Ready,
362 NotifyComplete: [HandleResult, Ctx](Expected<SymbolMap> Result) {
363 if (Result) {
364 SmallVector<LLVMOrcCSymbolMapPair> CResult;
365 for (auto &KV : *Result)
366 CResult.push_back(Elt: LLVMOrcCSymbolMapPair{
367 .Name: wrap(E: SymbolStringPoolEntryUnsafe::from(S: KV.first)),
368 .Sym: fromExecutorSymbolDef(S: KV.second)});
369 HandleResult(LLVMErrorSuccess, CResult.data(), CResult.size(), Ctx);
370 } else
371 HandleResult(wrap(Err: Result.takeError()), nullptr, 0, Ctx);
372 },
373 RegisterDependencies: NoDependenciesToRegister);
374}
375
376void LLVMOrcRetainSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) {
377 unwrap(E: S).retain();
378}
379
380void LLVMOrcReleaseSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) {
381 unwrap(E: S).release();
382}
383
384const char *LLVMOrcSymbolStringPoolEntryStr(LLVMOrcSymbolStringPoolEntryRef S) {
385 return unwrap(E: S).rawPtr()->getKey().data();
386}
387
388LLVMOrcResourceTrackerRef
389LLVMOrcJITDylibCreateResourceTracker(LLVMOrcJITDylibRef JD) {
390 auto RT = unwrap(P: JD)->createResourceTracker();
391 // Retain the pointer for the C API client.
392 RT->Retain();
393 return wrap(P: RT.get());
394}
395
396LLVMOrcResourceTrackerRef
397LLVMOrcJITDylibGetDefaultResourceTracker(LLVMOrcJITDylibRef JD) {
398 auto RT = unwrap(P: JD)->getDefaultResourceTracker();
399 // Retain the pointer for the C API client.
400 return wrap(P: RT.get());
401}
402
403void LLVMOrcReleaseResourceTracker(LLVMOrcResourceTrackerRef RT) {
404 ResourceTrackerSP TmpRT(unwrap(P: RT));
405 TmpRT->Release();
406}
407
408void LLVMOrcResourceTrackerTransferTo(LLVMOrcResourceTrackerRef SrcRT,
409 LLVMOrcResourceTrackerRef DstRT) {
410 ResourceTrackerSP TmpRT(unwrap(P: SrcRT));
411 TmpRT->transferTo(DstRT&: *unwrap(P: DstRT));
412}
413
414LLVMErrorRef LLVMOrcResourceTrackerRemove(LLVMOrcResourceTrackerRef RT) {
415 ResourceTrackerSP TmpRT(unwrap(P: RT));
416 return wrap(Err: TmpRT->remove());
417}
418
419void LLVMOrcDisposeDefinitionGenerator(LLVMOrcDefinitionGeneratorRef DG) {
420 std::unique_ptr<DefinitionGenerator> TmpDG(unwrap(P: DG));
421}
422
423void LLVMOrcDisposeMaterializationUnit(LLVMOrcMaterializationUnitRef MU) {
424 std::unique_ptr<MaterializationUnit> TmpMU(unwrap(P: MU));
425}
426
427LLVMOrcMaterializationUnitRef LLVMOrcCreateCustomMaterializationUnit(
428 const char *Name, void *Ctx, LLVMOrcCSymbolFlagsMapPairs Syms,
429 size_t NumSyms, LLVMOrcSymbolStringPoolEntryRef InitSym,
430 LLVMOrcMaterializationUnitMaterializeFunction Materialize,
431 LLVMOrcMaterializationUnitDiscardFunction Discard,
432 LLVMOrcMaterializationUnitDestroyFunction Destroy) {
433 SymbolFlagsMap SFM;
434 for (size_t I = 0; I != NumSyms; ++I)
435 SFM[unwrap(E: Syms[I].Name).moveToSymbolStringPtr()] =
436 toJITSymbolFlags(F: Syms[I].Flags);
437
438 auto IS = unwrap(E: InitSym).moveToSymbolStringPtr();
439
440 return wrap(P: new OrcCAPIMaterializationUnit(
441 Name, std::move(SFM), std::move(IS), Ctx, Materialize, Discard, Destroy));
442}
443
444LLVMOrcMaterializationUnitRef
445LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) {
446 SymbolMap SM = toSymbolMap(Syms, NumPairs);
447 return wrap(P: absoluteSymbols(Symbols: std::move(SM)).release());
448}
449
450LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports(
451 LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM,
452 LLVMOrcJITDylibRef SourceJD, LLVMOrcCSymbolAliasMapPairs CallableAliases,
453 size_t NumPairs) {
454
455 SymbolAliasMap SAM;
456 for (size_t I = 0; I != NumPairs; ++I) {
457 auto pair = CallableAliases[I];
458 JITSymbolFlags Flags = toJITSymbolFlags(F: pair.Entry.Flags);
459 SymbolStringPtr Name = unwrap(E: pair.Entry.Name).moveToSymbolStringPtr();
460 SAM[unwrap(E: pair.Name).moveToSymbolStringPtr()] =
461 SymbolAliasMapEntry(Name, Flags);
462 }
463
464 return wrap(P: lazyReexports(LCTManager&: *unwrap(P: LCTM), RSManager&: *unwrap(P: ISM), SourceJD&: *unwrap(P: SourceJD),
465 CallableAliases: std::move(SAM))
466 .release());
467}
468
469void LLVMOrcDisposeMaterializationResponsibility(
470 LLVMOrcMaterializationResponsibilityRef MR) {
471 std::unique_ptr<MaterializationResponsibility> TmpMR(unwrap(P: MR));
472}
473
474LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib(
475 LLVMOrcMaterializationResponsibilityRef MR) {
476 return wrap(P: &unwrap(P: MR)->getTargetJITDylib());
477}
478
479LLVMOrcExecutionSessionRef
480LLVMOrcMaterializationResponsibilityGetExecutionSession(
481 LLVMOrcMaterializationResponsibilityRef MR) {
482 return wrap(P: &unwrap(P: MR)->getExecutionSession());
483}
484
485LLVMOrcCSymbolFlagsMapPairs LLVMOrcMaterializationResponsibilityGetSymbols(
486 LLVMOrcMaterializationResponsibilityRef MR, size_t *NumPairs) {
487
488 auto Symbols = unwrap(P: MR)->getSymbols();
489 LLVMOrcCSymbolFlagsMapPairs Result = static_cast<LLVMOrcCSymbolFlagsMapPairs>(
490 safe_malloc(Sz: Symbols.size() * sizeof(LLVMOrcCSymbolFlagsMapPair)));
491 size_t I = 0;
492 for (auto const &pair : Symbols) {
493 auto Name = wrap(E: SymbolStringPoolEntryUnsafe::from(S: pair.first));
494 auto Flags = pair.second;
495 Result[I] = {.Name: Name, .Flags: fromJITSymbolFlags(JSF: Flags)};
496 I++;
497 }
498 *NumPairs = Symbols.size();
499 return Result;
500}
501
502void LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs) {
503 free(ptr: Pairs);
504}
505
506LLVMOrcSymbolStringPoolEntryRef
507LLVMOrcMaterializationResponsibilityGetInitializerSymbol(
508 LLVMOrcMaterializationResponsibilityRef MR) {
509 auto Sym = unwrap(P: MR)->getInitializerSymbol();
510 return wrap(E: SymbolStringPoolEntryUnsafe::from(S: Sym));
511}
512
513LLVMOrcSymbolStringPoolEntryRef *
514LLVMOrcMaterializationResponsibilityGetRequestedSymbols(
515 LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols) {
516
517 auto Symbols = unwrap(P: MR)->getRequestedSymbols();
518 LLVMOrcSymbolStringPoolEntryRef *Result =
519 static_cast<LLVMOrcSymbolStringPoolEntryRef *>(safe_malloc(
520 Sz: Symbols.size() * sizeof(LLVMOrcSymbolStringPoolEntryRef)));
521 size_t I = 0;
522 for (auto &Name : Symbols) {
523 Result[I] = wrap(E: SymbolStringPoolEntryUnsafe::from(S: Name));
524 I++;
525 }
526 *NumSymbols = Symbols.size();
527 return Result;
528}
529
530void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols) {
531 free(ptr: Symbols);
532}
533
534LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved(
535 LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols,
536 size_t NumSymbols) {
537 SymbolMap SM = toSymbolMap(Syms: Symbols, NumPairs: NumSymbols);
538 return wrap(Err: unwrap(P: MR)->notifyResolved(Symbols: std::move(SM)));
539}
540
541LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted(
542 LLVMOrcMaterializationResponsibilityRef MR,
543 LLVMOrcCSymbolDependenceGroup *SymbolDepGroups, size_t NumSymbolDepGroups) {
544 std::vector<SymbolDependenceGroup> SDGs;
545 SDGs.reserve(n: NumSymbolDepGroups);
546 for (size_t I = 0; I != NumSymbolDepGroups; ++I) {
547 SDGs.push_back(x: SymbolDependenceGroup());
548 auto &SDG = SDGs.back();
549 SDG.Symbols = toSymbolNameSet(Symbols: SymbolDepGroups[I].Symbols);
550 SDG.Dependencies = toSymbolDependenceMap(
551 Pairs: SymbolDepGroups[I].Dependencies, NumPairs: SymbolDepGroups[I].NumDependencies);
552 }
553 return wrap(Err: unwrap(P: MR)->notifyEmitted(EmittedDeps: SDGs));
554}
555
556LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
557 LLVMOrcMaterializationResponsibilityRef MR,
558 LLVMOrcCSymbolFlagsMapPairs Syms, size_t NumSyms) {
559 SymbolFlagsMap SFM;
560 for (size_t I = 0; I != NumSyms; ++I)
561 SFM[unwrap(E: Syms[I].Name).moveToSymbolStringPtr()] =
562 toJITSymbolFlags(F: Syms[I].Flags);
563
564 return wrap(Err: unwrap(P: MR)->defineMaterializing(SymbolFlags: std::move(SFM)));
565}
566
567LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace(
568 LLVMOrcMaterializationResponsibilityRef MR,
569 LLVMOrcMaterializationUnitRef MU) {
570 std::unique_ptr<MaterializationUnit> TmpMU(unwrap(P: MU));
571 return wrap(Err: unwrap(P: MR)->replace(MU: std::move(TmpMU)));
572}
573
574LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate(
575 LLVMOrcMaterializationResponsibilityRef MR,
576 LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols,
577 LLVMOrcMaterializationResponsibilityRef *Result) {
578 SymbolNameSet Syms;
579 for (size_t I = 0; I != NumSymbols; I++) {
580 Syms.insert(V: unwrap(E: Symbols[I]).moveToSymbolStringPtr());
581 }
582 auto OtherMR = unwrap(P: MR)->delegate(Symbols: Syms);
583
584 if (!OtherMR) {
585 return wrap(Err: OtherMR.takeError());
586 }
587 *Result = wrap(P: OtherMR->release());
588 return LLVMErrorSuccess;
589}
590
591void LLVMOrcMaterializationResponsibilityFailMaterialization(
592 LLVMOrcMaterializationResponsibilityRef MR) {
593 unwrap(P: MR)->failMaterialization();
594}
595
596void LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRLayer,
597 LLVMOrcMaterializationResponsibilityRef MR,
598 LLVMOrcThreadSafeModuleRef TSM) {
599 std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(P: TSM));
600 unwrap(P: IRLayer)->emit(
601 R: std::unique_ptr<MaterializationResponsibility>(unwrap(P: MR)),
602 TSM: std::move(*TmpTSM));
603}
604
605LLVMOrcJITDylibRef
606LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES,
607 const char *Name) {
608 return wrap(P: &unwrap(P: ES)->createBareJITDylib(Name));
609}
610
611LLVMErrorRef
612LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES,
613 LLVMOrcJITDylibRef *Result,
614 const char *Name) {
615 auto JD = unwrap(P: ES)->createJITDylib(Name);
616 if (!JD)
617 return wrap(Err: JD.takeError());
618 *Result = wrap(P: &*JD);
619 return LLVMErrorSuccess;
620}
621
622LLVMOrcJITDylibRef
623LLVMOrcExecutionSessionGetJITDylibByName(LLVMOrcExecutionSessionRef ES,
624 const char *Name) {
625 return wrap(P: unwrap(P: ES)->getJITDylibByName(Name));
626}
627
628LLVMErrorRef LLVMOrcJITDylibDefine(LLVMOrcJITDylibRef JD,
629 LLVMOrcMaterializationUnitRef MU) {
630 std::unique_ptr<MaterializationUnit> TmpMU(unwrap(P: MU));
631
632 if (auto Err = unwrap(P: JD)->define(MU&: TmpMU)) {
633 TmpMU.release();
634 return wrap(Err: std::move(Err));
635 }
636 return LLVMErrorSuccess;
637}
638
639LLVMErrorRef LLVMOrcJITDylibClear(LLVMOrcJITDylibRef JD) {
640 return wrap(Err: unwrap(P: JD)->clear());
641}
642
643void LLVMOrcJITDylibAddGenerator(LLVMOrcJITDylibRef JD,
644 LLVMOrcDefinitionGeneratorRef DG) {
645 unwrap(P: JD)->addGenerator(DefGenerator: std::unique_ptr<DefinitionGenerator>(unwrap(P: DG)));
646}
647
648LLVMOrcDefinitionGeneratorRef LLVMOrcCreateCustomCAPIDefinitionGenerator(
649 LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction F, void *Ctx,
650 LLVMOrcDisposeCAPIDefinitionGeneratorFunction Dispose) {
651 auto DG = std::make_unique<CAPIDefinitionGenerator>(args&: Dispose, args&: Ctx, args&: F);
652 return wrap(P: DG.release());
653}
654
655void LLVMOrcLookupStateContinueLookup(LLVMOrcLookupStateRef S,
656 LLVMErrorRef Err) {
657 LookupState LS;
658 OrcV2CAPIHelper::resetLookupState(LS, IPLS: ::unwrap(P: S));
659 LS.continueLookup(Err: unwrap(ErrRef: Err));
660}
661
662LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(
663 LLVMOrcDefinitionGeneratorRef *Result, char GlobalPrefix,
664 LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
665 assert(Result && "Result can not be null");
666 assert((Filter || !FilterCtx) &&
667 "if Filter is null then FilterCtx must also be null");
668
669 DynamicLibrarySearchGenerator::SymbolPredicate Pred;
670 if (Filter)
671 Pred = [=](const SymbolStringPtr &Name) -> bool {
672 return Filter(FilterCtx, wrap(E: SymbolStringPoolEntryUnsafe::from(S: Name)));
673 };
674
675 auto ProcessSymsGenerator =
676 DynamicLibrarySearchGenerator::GetForCurrentProcess(GlobalPrefix, Allow: Pred);
677
678 if (!ProcessSymsGenerator) {
679 *Result = nullptr;
680 return wrap(Err: ProcessSymsGenerator.takeError());
681 }
682
683 *Result = wrap(P: ProcessSymsGenerator->release());
684 return LLVMErrorSuccess;
685}
686
687LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForPath(
688 LLVMOrcDefinitionGeneratorRef *Result, const char *FileName,
689 char GlobalPrefix, LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
690 assert(Result && "Result can not be null");
691 assert(FileName && "FileName can not be null");
692 assert((Filter || !FilterCtx) &&
693 "if Filter is null then FilterCtx must also be null");
694
695 DynamicLibrarySearchGenerator::SymbolPredicate Pred;
696 if (Filter)
697 Pred = [=](const SymbolStringPtr &Name) -> bool {
698 return Filter(FilterCtx, wrap(E: SymbolStringPoolEntryUnsafe::from(S: Name)));
699 };
700
701 auto LibrarySymsGenerator =
702 DynamicLibrarySearchGenerator::Load(FileName, GlobalPrefix, Allow: Pred);
703
704 if (!LibrarySymsGenerator) {
705 *Result = nullptr;
706 return wrap(Err: LibrarySymsGenerator.takeError());
707 }
708
709 *Result = wrap(P: LibrarySymsGenerator->release());
710 return LLVMErrorSuccess;
711}
712
713LLVMErrorRef LLVMOrcCreateStaticLibrarySearchGeneratorForPath(
714 LLVMOrcDefinitionGeneratorRef *Result, LLVMOrcObjectLayerRef ObjLayer,
715 const char *FileName) {
716 assert(Result && "Result can not be null");
717 assert(FileName && "Filename can not be null");
718 assert(ObjLayer && "ObjectLayer can not be null");
719
720 auto LibrarySymsGenerator =
721 StaticLibraryDefinitionGenerator::Load(L&: *unwrap(P: ObjLayer), FileName);
722 if (!LibrarySymsGenerator) {
723 *Result = nullptr;
724 return wrap(Err: LibrarySymsGenerator.takeError());
725 }
726 *Result = wrap(P: LibrarySymsGenerator->release());
727 return LLVMErrorSuccess;
728}
729
730LLVMOrcThreadSafeContextRef LLVMOrcCreateNewThreadSafeContext(void) {
731 return wrap(P: new ThreadSafeContext(std::make_unique<LLVMContext>()));
732}
733
734LLVMOrcThreadSafeContextRef
735LLVMOrcCreateNewThreadSafeContextFromLLVMContext(LLVMContextRef Ctx) {
736 return wrap(P: new ThreadSafeContext(std::unique_ptr<LLVMContext>(unwrap(P: Ctx))));
737}
738
739void LLVMOrcDisposeThreadSafeContext(LLVMOrcThreadSafeContextRef TSCtx) {
740 delete unwrap(P: TSCtx);
741}
742
743LLVMErrorRef
744LLVMOrcThreadSafeModuleWithModuleDo(LLVMOrcThreadSafeModuleRef TSM,
745 LLVMOrcGenericIRModuleOperationFunction F,
746 void *Ctx) {
747 return wrap(Err: unwrap(P: TSM)->withModuleDo(
748 F: [&](Module &M) { return unwrap(ErrRef: F(Ctx, wrap(P: &M))); }));
749}
750
751LLVMOrcThreadSafeModuleRef
752LLVMOrcCreateNewThreadSafeModule(LLVMModuleRef M,
753 LLVMOrcThreadSafeContextRef TSCtx) {
754 return wrap(
755 P: new ThreadSafeModule(std::unique_ptr<Module>(unwrap(P: M)), *unwrap(P: TSCtx)));
756}
757
758void LLVMOrcDisposeThreadSafeModule(LLVMOrcThreadSafeModuleRef TSM) {
759 delete unwrap(P: TSM);
760}
761
762LLVMErrorRef LLVMOrcJITTargetMachineBuilderDetectHost(
763 LLVMOrcJITTargetMachineBuilderRef *Result) {
764 assert(Result && "Result can not be null");
765
766 auto JTMB = JITTargetMachineBuilder::detectHost();
767 if (!JTMB) {
768 Result = nullptr;
769 return wrap(Err: JTMB.takeError());
770 }
771
772 *Result = wrap(P: new JITTargetMachineBuilder(std::move(*JTMB)));
773 return LLVMErrorSuccess;
774}
775
776LLVMOrcJITTargetMachineBuilderRef
777LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(LLVMTargetMachineRef TM) {
778 auto *TemplateTM = unwrap(P: TM);
779
780 auto JTMB =
781 std::make_unique<JITTargetMachineBuilder>(args: TemplateTM->getTargetTriple());
782
783 (*JTMB)
784 .setCPU(TemplateTM->getTargetCPU().str())
785 .setRelocationModel(TemplateTM->getRelocationModel())
786 .setCodeModel(TemplateTM->getCodeModel())
787 .setCodeGenOptLevel(TemplateTM->getOptLevel())
788 .setFeatures(TemplateTM->getTargetFeatureString())
789 .setOptions(TemplateTM->Options);
790
791 LLVMDisposeTargetMachine(T: TM);
792
793 return wrap(P: JTMB.release());
794}
795
796void LLVMOrcDisposeJITTargetMachineBuilder(
797 LLVMOrcJITTargetMachineBuilderRef JTMB) {
798 delete unwrap(P: JTMB);
799}
800
801char *LLVMOrcJITTargetMachineBuilderGetTargetTriple(
802 LLVMOrcJITTargetMachineBuilderRef JTMB) {
803 auto Tmp = unwrap(P: JTMB)->getTargetTriple().str();
804 char *TargetTriple = (char *)malloc(size: Tmp.size() + 1);
805 strcpy(dest: TargetTriple, src: Tmp.c_str());
806 return TargetTriple;
807}
808
809void LLVMOrcJITTargetMachineBuilderSetTargetTriple(
810 LLVMOrcJITTargetMachineBuilderRef JTMB, const char *TargetTriple) {
811 unwrap(P: JTMB)->getTargetTriple() = Triple(TargetTriple);
812}
813
814LLVMErrorRef LLVMOrcObjectLayerAddObjectFile(LLVMOrcObjectLayerRef ObjLayer,
815 LLVMOrcJITDylibRef JD,
816 LLVMMemoryBufferRef ObjBuffer) {
817 return wrap(Err: unwrap(P: ObjLayer)->add(
818 JD&: *unwrap(P: JD), O: std::unique_ptr<MemoryBuffer>(unwrap(P: ObjBuffer))));
819}
820
821LLVMErrorRef LLVMOrcObjectLayerAddObjectFileWithRT(LLVMOrcObjectLayerRef ObjLayer,
822 LLVMOrcResourceTrackerRef RT,
823 LLVMMemoryBufferRef ObjBuffer) {
824 return wrap(
825 Err: unwrap(P: ObjLayer)->add(RT: ResourceTrackerSP(unwrap(P: RT)),
826 O: std::unique_ptr<MemoryBuffer>(unwrap(P: ObjBuffer))));
827}
828
829void LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer,
830 LLVMOrcMaterializationResponsibilityRef R,
831 LLVMMemoryBufferRef ObjBuffer) {
832 unwrap(P: ObjLayer)->emit(
833 R: std::unique_ptr<MaterializationResponsibility>(unwrap(P: R)),
834 O: std::unique_ptr<MemoryBuffer>(unwrap(P: ObjBuffer)));
835}
836
837void LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer) {
838 delete unwrap(P: ObjLayer);
839}
840
841void LLVMOrcIRTransformLayerSetTransform(
842 LLVMOrcIRTransformLayerRef IRTransformLayer,
843 LLVMOrcIRTransformLayerTransformFunction TransformFunction, void *Ctx) {
844 unwrap(P: IRTransformLayer)
845 ->setTransform(
846 [=](ThreadSafeModule TSM,
847 MaterializationResponsibility &R) -> Expected<ThreadSafeModule> {
848 LLVMOrcThreadSafeModuleRef TSMRef =
849 wrap(P: new ThreadSafeModule(std::move(TSM)));
850 if (LLVMErrorRef Err = TransformFunction(Ctx, &TSMRef, wrap(P: &R))) {
851 assert(!TSMRef && "TSMRef was not reset to null on error");
852 return unwrap(ErrRef: Err);
853 }
854 assert(TSMRef && "Transform succeeded, but TSMRef was set to null");
855 ThreadSafeModule Result = std::move(*unwrap(P: TSMRef));
856 LLVMOrcDisposeThreadSafeModule(TSM: TSMRef);
857 return std::move(Result);
858 });
859}
860
861void LLVMOrcObjectTransformLayerSetTransform(
862 LLVMOrcObjectTransformLayerRef ObjTransformLayer,
863 LLVMOrcObjectTransformLayerTransformFunction TransformFunction, void *Ctx) {
864 unwrap(P: ObjTransformLayer)
865 ->setTransform([TransformFunction, Ctx](std::unique_ptr<MemoryBuffer> Obj)
866 -> Expected<std::unique_ptr<MemoryBuffer>> {
867 LLVMMemoryBufferRef ObjBuffer = wrap(P: Obj.release());
868 if (LLVMErrorRef Err = TransformFunction(Ctx, &ObjBuffer)) {
869 assert(!ObjBuffer && "ObjBuffer was not reset to null on error");
870 return unwrap(ErrRef: Err);
871 }
872 return std::unique_ptr<MemoryBuffer>(unwrap(P: ObjBuffer));
873 });
874}
875
876LLVMOrcDumpObjectsRef LLVMOrcCreateDumpObjects(const char *DumpDir,
877 const char *IdentifierOverride) {
878 assert(DumpDir && "DumpDir should not be null");
879 assert(IdentifierOverride && "IdentifierOverride should not be null");
880 return wrap(P: new DumpObjects(DumpDir, IdentifierOverride));
881}
882
883void LLVMOrcDisposeDumpObjects(LLVMOrcDumpObjectsRef DumpObjects) {
884 delete unwrap(P: DumpObjects);
885}
886
887LLVMErrorRef LLVMOrcDumpObjects_CallOperator(LLVMOrcDumpObjectsRef DumpObjects,
888 LLVMMemoryBufferRef *ObjBuffer) {
889 std::unique_ptr<MemoryBuffer> OB(unwrap(P: *ObjBuffer));
890 if (auto Result = (*unwrap(P: DumpObjects))(std::move(OB))) {
891 *ObjBuffer = wrap(P: Result->release());
892 return LLVMErrorSuccess;
893 } else {
894 *ObjBuffer = nullptr;
895 return wrap(Err: Result.takeError());
896 }
897}
898
899LLVMOrcLLJITBuilderRef LLVMOrcCreateLLJITBuilder(void) {
900 return wrap(P: new LLJITBuilder());
901}
902
903void LLVMOrcDisposeLLJITBuilder(LLVMOrcLLJITBuilderRef Builder) {
904 delete unwrap(P: Builder);
905}
906
907void LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(
908 LLVMOrcLLJITBuilderRef Builder, LLVMOrcJITTargetMachineBuilderRef JTMB) {
909 unwrap(P: Builder)->setJITTargetMachineBuilder(std::move(*unwrap(P: JTMB)));
910 LLVMOrcDisposeJITTargetMachineBuilder(JTMB);
911}
912
913void LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(
914 LLVMOrcLLJITBuilderRef Builder,
915 LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F, void *Ctx) {
916 unwrap(P: Builder)->setObjectLinkingLayerCreator([=](ExecutionSession &ES) {
917 auto TTStr = ES.getTargetTriple().str();
918 return std::unique_ptr<ObjectLayer>(
919 unwrap(P: F(Ctx, wrap(P: &ES), TTStr.c_str())));
920 });
921}
922
923LLVMErrorRef LLVMOrcCreateLLJIT(LLVMOrcLLJITRef *Result,
924 LLVMOrcLLJITBuilderRef Builder) {
925 assert(Result && "Result can not be null");
926
927 if (!Builder)
928 Builder = LLVMOrcCreateLLJITBuilder();
929
930 auto J = unwrap(P: Builder)->create();
931 LLVMOrcDisposeLLJITBuilder(Builder);
932
933 if (!J) {
934 Result = nullptr;
935 return wrap(Err: J.takeError());
936 }
937
938 *Result = wrap(P: J->release());
939 return LLVMErrorSuccess;
940}
941
942LLVMErrorRef LLVMOrcDisposeLLJIT(LLVMOrcLLJITRef J) {
943 delete unwrap(P: J);
944 return LLVMErrorSuccess;
945}
946
947LLVMOrcExecutionSessionRef LLVMOrcLLJITGetExecutionSession(LLVMOrcLLJITRef J) {
948 return wrap(P: &unwrap(P: J)->getExecutionSession());
949}
950
951LLVMOrcJITDylibRef LLVMOrcLLJITGetMainJITDylib(LLVMOrcLLJITRef J) {
952 return wrap(P: &unwrap(P: J)->getMainJITDylib());
953}
954
955const char *LLVMOrcLLJITGetTripleString(LLVMOrcLLJITRef J) {
956 return unwrap(P: J)->getTargetTriple().str().c_str();
957}
958
959char LLVMOrcLLJITGetGlobalPrefix(LLVMOrcLLJITRef J) {
960 return unwrap(P: J)->getDataLayout().getGlobalPrefix();
961}
962
963LLVMOrcSymbolStringPoolEntryRef
964LLVMOrcLLJITMangleAndIntern(LLVMOrcLLJITRef J, const char *UnmangledName) {
965 return wrap(E: SymbolStringPoolEntryUnsafe::take(
966 S: unwrap(P: J)->mangleAndIntern(UnmangledName)));
967}
968
969LLVMErrorRef LLVMOrcLLJITAddObjectFile(LLVMOrcLLJITRef J, LLVMOrcJITDylibRef JD,
970 LLVMMemoryBufferRef ObjBuffer) {
971 return wrap(Err: unwrap(P: J)->addObjectFile(
972 JD&: *unwrap(P: JD), Obj: std::unique_ptr<MemoryBuffer>(unwrap(P: ObjBuffer))));
973}
974
975LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcLLJITRef J,
976 LLVMOrcResourceTrackerRef RT,
977 LLVMMemoryBufferRef ObjBuffer) {
978 return wrap(Err: unwrap(P: J)->addObjectFile(
979 RT: ResourceTrackerSP(unwrap(P: RT)),
980 Obj: std::unique_ptr<MemoryBuffer>(unwrap(P: ObjBuffer))));
981}
982
983LLVMErrorRef LLVMOrcLLJITAddLLVMIRModule(LLVMOrcLLJITRef J,
984 LLVMOrcJITDylibRef JD,
985 LLVMOrcThreadSafeModuleRef TSM) {
986 std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(P: TSM));
987 return wrap(Err: unwrap(P: J)->addIRModule(JD&: *unwrap(P: JD), TSM: std::move(*TmpTSM)));
988}
989
990LLVMErrorRef LLVMOrcLLJITAddLLVMIRModuleWithRT(LLVMOrcLLJITRef J,
991 LLVMOrcResourceTrackerRef RT,
992 LLVMOrcThreadSafeModuleRef TSM) {
993 std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(P: TSM));
994 return wrap(Err: unwrap(P: J)->addIRModule(RT: ResourceTrackerSP(unwrap(P: RT)),
995 TSM: std::move(*TmpTSM)));
996}
997
998LLVMErrorRef LLVMOrcLLJITLookup(LLVMOrcLLJITRef J,
999 LLVMOrcJITTargetAddress *Result,
1000 const char *Name) {
1001 assert(Result && "Result can not be null");
1002
1003 auto Sym = unwrap(P: J)->lookup(UnmangledName: Name);
1004 if (!Sym) {
1005 *Result = 0;
1006 return wrap(Err: Sym.takeError());
1007 }
1008
1009 *Result = Sym->getValue();
1010 return LLVMErrorSuccess;
1011}
1012
1013LLVMOrcObjectLayerRef LLVMOrcLLJITGetObjLinkingLayer(LLVMOrcLLJITRef J) {
1014 return wrap(P: &unwrap(P: J)->getObjLinkingLayer());
1015}
1016
1017LLVMOrcObjectTransformLayerRef
1018LLVMOrcLLJITGetObjTransformLayer(LLVMOrcLLJITRef J) {
1019 return wrap(P: &unwrap(P: J)->getObjTransformLayer());
1020}
1021
1022LLVMErrorRef LLVMOrcCreateObjectLinkingLayerWithInProcessMemoryManager(
1023 LLVMOrcObjectLayerRef *Result, LLVMOrcExecutionSessionRef ES) {
1024 assert(Result && "Result must not be null");
1025 assert(ES && "ES must not be null");
1026 auto MM = jitlink::InProcessMemoryManager::Create();
1027 if (!MM)
1028 return wrap(Err: MM.takeError());
1029 *Result = wrap(P: new ObjectLinkingLayer(*unwrap(P: ES), std::move(*MM)));
1030 return LLVMErrorSuccess;
1031}
1032
1033LLVMOrcObjectLayerRef
1034LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(
1035 LLVMOrcExecutionSessionRef ES) {
1036 assert(ES && "ES must not be null");
1037 return wrap(
1038 P: new RTDyldObjectLinkingLayer(*unwrap(P: ES), [](const MemoryBuffer &) {
1039 return std::make_unique<SectionMemoryManager>();
1040 }));
1041}
1042
1043LLVMOrcObjectLayerRef
1044LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManagerReserveAlloc(
1045 LLVMOrcExecutionSessionRef ES, LLVMBool ReserveAlloc) {
1046 assert(ES && "ES must not be null");
1047 return wrap(P: new RTDyldObjectLinkingLayer(
1048 *unwrap(P: ES), [ReserveAlloc](const MemoryBuffer &) {
1049 return std::make_unique<SectionMemoryManager>(args: nullptr, args: ReserveAlloc);
1050 }));
1051}
1052
1053LLVMOrcObjectLayerRef
1054LLVMOrcCreateRTDyldObjectLinkingLayerWithMCJITMemoryManagerLikeCallbacks(
1055 LLVMOrcExecutionSessionRef ES, void *CreateContextCtx,
1056 LLVMMemoryManagerCreateContextCallback CreateContext,
1057 LLVMMemoryManagerNotifyTerminatingCallback NotifyTerminating,
1058 LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
1059 LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
1060 LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
1061 LLVMMemoryManagerDestroyCallback Destroy) {
1062
1063 struct MCJITMemoryManagerLikeCallbacks {
1064 MCJITMemoryManagerLikeCallbacks() = default;
1065 MCJITMemoryManagerLikeCallbacks(
1066 void *CreateContextCtx,
1067 LLVMMemoryManagerCreateContextCallback CreateContext,
1068 LLVMMemoryManagerNotifyTerminatingCallback NotifyTerminating,
1069 LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
1070 LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
1071 LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
1072 LLVMMemoryManagerDestroyCallback Destroy)
1073 : CreateContextCtx(CreateContextCtx), CreateContext(CreateContext),
1074 NotifyTerminating(NotifyTerminating),
1075 AllocateCodeSection(AllocateCodeSection),
1076 AllocateDataSection(AllocateDataSection),
1077 FinalizeMemory(FinalizeMemory), Destroy(Destroy) {}
1078
1079 MCJITMemoryManagerLikeCallbacks(MCJITMemoryManagerLikeCallbacks &&Other) {
1080 std::swap(a&: CreateContextCtx, b&: Other.CreateContextCtx);
1081 std::swap(a&: CreateContext, b&: Other.CreateContext);
1082 std::swap(a&: NotifyTerminating, b&: Other.NotifyTerminating);
1083 std::swap(a&: AllocateCodeSection, b&: Other.AllocateCodeSection);
1084 std::swap(a&: AllocateDataSection, b&: Other.AllocateDataSection);
1085 std::swap(a&: FinalizeMemory, b&: Other.FinalizeMemory);
1086 std::swap(a&: Destroy, b&: Other.Destroy);
1087 }
1088
1089 ~MCJITMemoryManagerLikeCallbacks() {
1090 if (NotifyTerminating)
1091 NotifyTerminating(CreateContextCtx);
1092 }
1093
1094 void *CreateContextCtx = nullptr;
1095 LLVMMemoryManagerCreateContextCallback CreateContext = nullptr;
1096 LLVMMemoryManagerNotifyTerminatingCallback NotifyTerminating = nullptr;
1097 LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection = nullptr;
1098 LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection = nullptr;
1099 LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory = nullptr;
1100 LLVMMemoryManagerDestroyCallback Destroy = nullptr;
1101 };
1102
1103 class MCJITMemoryManagerLikeCallbacksMemMgr : public RTDyldMemoryManager {
1104 public:
1105 MCJITMemoryManagerLikeCallbacksMemMgr(
1106 const MCJITMemoryManagerLikeCallbacks &CBs)
1107 : CBs(CBs) {
1108 Opaque = CBs.CreateContext(CBs.CreateContextCtx);
1109 }
1110 ~MCJITMemoryManagerLikeCallbacksMemMgr() override { CBs.Destroy(Opaque); }
1111
1112 uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
1113 unsigned SectionID,
1114 StringRef SectionName) override {
1115 return CBs.AllocateCodeSection(Opaque, Size, Alignment, SectionID,
1116 SectionName.str().c_str());
1117 }
1118
1119 uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
1120 unsigned SectionID, StringRef SectionName,
1121 bool isReadOnly) override {
1122 return CBs.AllocateDataSection(Opaque, Size, Alignment, SectionID,
1123 SectionName.str().c_str(), isReadOnly);
1124 }
1125
1126 bool finalizeMemory(std::string *ErrMsg) override {
1127 char *ErrMsgCString = nullptr;
1128 bool Result = CBs.FinalizeMemory(Opaque, &ErrMsgCString);
1129 assert((Result || !ErrMsgCString) &&
1130 "Did not expect an error message if FinalizeMemory succeeded");
1131 if (ErrMsgCString) {
1132 if (ErrMsg)
1133 *ErrMsg = ErrMsgCString;
1134 free(ptr: ErrMsgCString);
1135 }
1136 return Result;
1137 }
1138
1139 private:
1140 const MCJITMemoryManagerLikeCallbacks &CBs;
1141 void *Opaque = nullptr;
1142 };
1143
1144 assert(ES && "ES must not be null");
1145 assert(CreateContext && "CreateContext must not be null");
1146 assert(NotifyTerminating && "NotifyTerminating must not be null");
1147 assert(AllocateCodeSection && "AllocateCodeSection must not be null");
1148 assert(AllocateDataSection && "AllocateDataSection must not be null");
1149 assert(FinalizeMemory && "FinalizeMemory must not be null");
1150 assert(Destroy && "Destroy must not be null");
1151
1152 MCJITMemoryManagerLikeCallbacks CBs(
1153 CreateContextCtx, CreateContext, NotifyTerminating, AllocateCodeSection,
1154 AllocateDataSection, FinalizeMemory, Destroy);
1155
1156 return wrap(P: new RTDyldObjectLinkingLayer(
1157 *unwrap(P: ES), [CBs = std::move(CBs)](const MemoryBuffer &) {
1158 return std::make_unique<MCJITMemoryManagerLikeCallbacksMemMgr>(args: CBs);
1159 }));
1160
1161 return nullptr;
1162}
1163
1164void LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(
1165 LLVMOrcObjectLayerRef RTDyldObjLinkingLayer,
1166 LLVMJITEventListenerRef Listener) {
1167 assert(RTDyldObjLinkingLayer && "RTDyldObjLinkingLayer must not be null");
1168 assert(Listener && "Listener must not be null");
1169 reinterpret_cast<RTDyldObjectLinkingLayer *>(unwrap(P: RTDyldObjLinkingLayer))
1170 ->registerJITEventListener(L&: *unwrap(P: Listener));
1171}
1172
1173LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J) {
1174 return wrap(P: &unwrap(P: J)->getIRTransformLayer());
1175}
1176
1177const char *LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J) {
1178 return unwrap(P: J)->getDataLayout().getStringRepresentation().c_str();
1179}
1180
1181LLVMOrcIndirectStubsManagerRef
1182LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple) {
1183 auto builder = createLocalIndirectStubsManagerBuilder(T: Triple(TargetTriple));
1184 return wrap(P: builder().release());
1185}
1186
1187void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM) {
1188 std::unique_ptr<IndirectStubsManager> TmpISM(unwrap(P: ISM));
1189}
1190
1191LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
1192 const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
1193 LLVMOrcJITTargetAddress ErrorHandlerAddr,
1194 LLVMOrcLazyCallThroughManagerRef *Result) {
1195 auto LCTM = createLocalLazyCallThroughManager(
1196 T: Triple(TargetTriple), ES&: *unwrap(P: ES), ErrorHandlerAddr: ExecutorAddr(ErrorHandlerAddr));
1197
1198 if (!LCTM)
1199 return wrap(Err: LCTM.takeError());
1200 *Result = wrap(P: LCTM->release());
1201 return LLVMErrorSuccess;
1202}
1203
1204void LLVMOrcDisposeLazyCallThroughManager(
1205 LLVMOrcLazyCallThroughManagerRef LCM) {
1206 std::unique_ptr<LazyCallThroughManager> TmpLCM(unwrap(P: LCM));
1207}
1208