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