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