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