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