xref: /freebsd/contrib/llvm-project/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp (revision 093cf790569775b80662926efea6d9d3464bde94) 
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(
297       unwrap(ES)->getExecutorProcessControl().getSymbolStringPool().get());
298 }
299 
300 void LLVMOrcSymbolStringPoolClearDeadEntries(LLVMOrcSymbolStringPoolRef SSP) {
301   unwrap(SSP)->clearDeadEntries();
302 }
303 
304 LLVMOrcSymbolStringPoolEntryRef
305 LLVMOrcExecutionSessionIntern(LLVMOrcExecutionSessionRef ES, const char *Name) {
306   return wrap(
307       OrcV2CAPIHelper::moveFromSymbolStringPtr(unwrap(ES)->intern(Name)));
308 }
309 
310 void LLVMOrcRetainSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) {
311   OrcV2CAPIHelper::retainPoolEntry(unwrap(S));
312 }
313 
314 void LLVMOrcReleaseSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) {
315   OrcV2CAPIHelper::releasePoolEntry(unwrap(S));
316 }
317 
318 const char *LLVMOrcSymbolStringPoolEntryStr(LLVMOrcSymbolStringPoolEntryRef S) {
319   return unwrap(S)->getKey().data();
320 }
321 
322 LLVMOrcResourceTrackerRef
323 LLVMOrcJITDylibCreateResourceTracker(LLVMOrcJITDylibRef JD) {
324   auto RT = unwrap(JD)->createResourceTracker();
325   // Retain the pointer for the C API client.
326   RT->Retain();
327   return wrap(RT.get());
328 }
329 
330 LLVMOrcResourceTrackerRef
331 LLVMOrcJITDylibGetDefaultResourceTracker(LLVMOrcJITDylibRef JD) {
332   auto RT = unwrap(JD)->getDefaultResourceTracker();
333   // Retain the pointer for the C API client.
334   return wrap(RT.get());
335 }
336 
337 void LLVMOrcReleaseResourceTracker(LLVMOrcResourceTrackerRef RT) {
338   ResourceTrackerSP TmpRT(unwrap(RT));
339   TmpRT->Release();
340 }
341 
342 void LLVMOrcResourceTrackerTransferTo(LLVMOrcResourceTrackerRef SrcRT,
343                                       LLVMOrcResourceTrackerRef DstRT) {
344   ResourceTrackerSP TmpRT(unwrap(SrcRT));
345   TmpRT->transferTo(*unwrap(DstRT));
346 }
347 
348 LLVMErrorRef LLVMOrcResourceTrackerRemove(LLVMOrcResourceTrackerRef RT) {
349   ResourceTrackerSP TmpRT(unwrap(RT));
350   return wrap(TmpRT->remove());
351 }
352 
353 void LLVMOrcDisposeDefinitionGenerator(LLVMOrcDefinitionGeneratorRef DG) {
354   std::unique_ptr<DefinitionGenerator> TmpDG(unwrap(DG));
355 }
356 
357 void LLVMOrcDisposeMaterializationUnit(LLVMOrcMaterializationUnitRef MU) {
358   std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU));
359 }
360 
361 LLVMOrcMaterializationUnitRef LLVMOrcCreateCustomMaterializationUnit(
362     const char *Name, void *Ctx, LLVMOrcCSymbolFlagsMapPairs Syms,
363     size_t NumSyms, LLVMOrcSymbolStringPoolEntryRef InitSym,
364     LLVMOrcMaterializationUnitMaterializeFunction Materialize,
365     LLVMOrcMaterializationUnitDiscardFunction Discard,
366     LLVMOrcMaterializationUnitDestroyFunction Destroy) {
367   SymbolFlagsMap SFM;
368   for (size_t I = 0; I != NumSyms; ++I)
369     SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] =
370         toJITSymbolFlags(Syms[I].Flags);
371 
372   auto IS = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(InitSym));
373 
374   return wrap(new OrcCAPIMaterializationUnit(
375       Name, std::move(SFM), std::move(IS), Ctx, Materialize, Discard, Destroy));
376 }
377 
378 LLVMOrcMaterializationUnitRef
379 LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) {
380   SymbolMap SM = toSymbolMap(Syms, NumPairs);
381   return wrap(absoluteSymbols(std::move(SM)).release());
382 }
383 
384 LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports(
385     LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM,
386     LLVMOrcJITDylibRef SourceJD, LLVMOrcCSymbolAliasMapPairs CallableAliases,
387     size_t NumPairs) {
388 
389   SymbolAliasMap SAM;
390   for (size_t I = 0; I != NumPairs; ++I) {
391     auto pair = CallableAliases[I];
392     JITSymbolFlags Flags = toJITSymbolFlags(pair.Entry.Flags);
393     SymbolStringPtr Name =
394         OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Entry.Name));
395     SAM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Name))] =
396         SymbolAliasMapEntry(Name, Flags);
397   }
398 
399   return wrap(lazyReexports(*unwrap(LCTM), *unwrap(ISM), *unwrap(SourceJD),
400                             std::move(SAM))
401                   .release());
402 }
403 
404 void LLVMOrcDisposeMaterializationResponsibility(
405     LLVMOrcMaterializationResponsibilityRef MR) {
406   std::unique_ptr<MaterializationResponsibility> TmpMR(unwrap(MR));
407 }
408 
409 LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib(
410     LLVMOrcMaterializationResponsibilityRef MR) {
411   return wrap(&unwrap(MR)->getTargetJITDylib());
412 }
413 
414 LLVMOrcExecutionSessionRef
415 LLVMOrcMaterializationResponsibilityGetExecutionSession(
416     LLVMOrcMaterializationResponsibilityRef MR) {
417   return wrap(&unwrap(MR)->getExecutionSession());
418 }
419 
420 LLVMOrcCSymbolFlagsMapPairs LLVMOrcMaterializationResponsibilityGetSymbols(
421     LLVMOrcMaterializationResponsibilityRef MR, size_t *NumPairs) {
422 
423   auto Symbols = unwrap(MR)->getSymbols();
424   LLVMOrcCSymbolFlagsMapPairs Result = static_cast<LLVMOrcCSymbolFlagsMapPairs>(
425       safe_malloc(Symbols.size() * sizeof(LLVMOrcCSymbolFlagsMapPair)));
426   size_t I = 0;
427   for (auto const &pair : Symbols) {
428     auto Name = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(pair.first));
429     auto Flags = pair.second;
430     Result[I] = {Name, fromJITSymbolFlags(Flags)};
431     I++;
432   }
433   *NumPairs = Symbols.size();
434   return Result;
435 }
436 
437 void LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs) {
438   free(Pairs);
439 }
440 
441 LLVMOrcSymbolStringPoolEntryRef
442 LLVMOrcMaterializationResponsibilityGetInitializerSymbol(
443     LLVMOrcMaterializationResponsibilityRef MR) {
444   auto Sym = unwrap(MR)->getInitializerSymbol();
445   return wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Sym));
446 }
447 
448 LLVMOrcSymbolStringPoolEntryRef *
449 LLVMOrcMaterializationResponsibilityGetRequestedSymbols(
450     LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols) {
451 
452   auto Symbols = unwrap(MR)->getRequestedSymbols();
453   LLVMOrcSymbolStringPoolEntryRef *Result =
454       static_cast<LLVMOrcSymbolStringPoolEntryRef *>(safe_malloc(
455           Symbols.size() * sizeof(LLVMOrcSymbolStringPoolEntryRef)));
456   size_t I = 0;
457   for (auto &Name : Symbols) {
458     Result[I] = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name));
459     I++;
460   }
461   *NumSymbols = Symbols.size();
462   return Result;
463 }
464 
465 void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols) {
466   free(Symbols);
467 }
468 
469 LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved(
470     LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols,
471     size_t NumPairs) {
472   SymbolMap SM = toSymbolMap(Symbols, NumPairs);
473   return wrap(unwrap(MR)->notifyResolved(std::move(SM)));
474 }
475 
476 LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted(
477     LLVMOrcMaterializationResponsibilityRef MR) {
478   return wrap(unwrap(MR)->notifyEmitted());
479 }
480 
481 LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
482     LLVMOrcMaterializationResponsibilityRef MR,
483     LLVMOrcCSymbolFlagsMapPairs Syms, size_t NumSyms) {
484   SymbolFlagsMap SFM;
485   for (size_t I = 0; I != NumSyms; ++I)
486     SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] =
487         toJITSymbolFlags(Syms[I].Flags);
488 
489   return wrap(unwrap(MR)->defineMaterializing(std::move(SFM)));
490 }
491 
492 LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace(
493     LLVMOrcMaterializationResponsibilityRef MR,
494     LLVMOrcMaterializationUnitRef MU) {
495   std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU));
496   return wrap(unwrap(MR)->replace(std::move(TmpMU)));
497 }
498 
499 LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate(
500     LLVMOrcMaterializationResponsibilityRef MR,
501     LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols,
502     LLVMOrcMaterializationResponsibilityRef *Result) {
503   SymbolNameSet Syms;
504   for (size_t I = 0; I != NumSymbols; I++) {
505     Syms.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Symbols[I])));
506   }
507   auto OtherMR = unwrap(MR)->delegate(Syms);
508 
509   if (!OtherMR) {
510     return wrap(OtherMR.takeError());
511   }
512   *Result = wrap(OtherMR->release());
513   return LLVMErrorSuccess;
514 }
515 
516 void LLVMOrcMaterializationResponsibilityAddDependencies(
517     LLVMOrcMaterializationResponsibilityRef MR,
518     LLVMOrcSymbolStringPoolEntryRef Name,
519     LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) {
520 
521   SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs);
522   auto Sym = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Name));
523   unwrap(MR)->addDependencies(Sym, SDM);
524 }
525 
526 void LLVMOrcMaterializationResponsibilityAddDependenciesForAll(
527     LLVMOrcMaterializationResponsibilityRef MR,
528     LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) {
529 
530   SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs);
531   unwrap(MR)->addDependenciesForAll(SDM);
532 }
533 
534 void LLVMOrcMaterializationResponsibilityFailMaterialization(
535     LLVMOrcMaterializationResponsibilityRef MR) {
536   unwrap(MR)->failMaterialization();
537 }
538 
539 void LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRLayer,
540                                  LLVMOrcMaterializationResponsibilityRef MR,
541                                  LLVMOrcThreadSafeModuleRef TSM) {
542   std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
543   unwrap(IRLayer)->emit(
544       std::unique_ptr<MaterializationResponsibility>(unwrap(MR)),
545       std::move(*TmpTSM));
546 }
547 
548 LLVMOrcJITDylibRef
549 LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES,
550                                           const char *Name) {
551   return wrap(&unwrap(ES)->createBareJITDylib(Name));
552 }
553 
554 LLVMErrorRef
555 LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES,
556                                       LLVMOrcJITDylibRef *Result,
557                                       const char *Name) {
558   auto JD = unwrap(ES)->createJITDylib(Name);
559   if (!JD)
560     return wrap(JD.takeError());
561   *Result = wrap(&*JD);
562   return LLVMErrorSuccess;
563 }
564 
565 LLVMOrcJITDylibRef
566 LLVMOrcExecutionSessionGetJITDylibByName(LLVMOrcExecutionSessionRef ES,
567                                          const char *Name) {
568   return wrap(unwrap(ES)->getJITDylibByName(Name));
569 }
570 
571 LLVMErrorRef LLVMOrcJITDylibDefine(LLVMOrcJITDylibRef JD,
572                                    LLVMOrcMaterializationUnitRef MU) {
573   std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU));
574 
575   if (auto Err = unwrap(JD)->define(TmpMU)) {
576     TmpMU.release();
577     return wrap(std::move(Err));
578   }
579   return LLVMErrorSuccess;
580 }
581 
582 LLVMErrorRef LLVMOrcJITDylibClear(LLVMOrcJITDylibRef JD) {
583   return wrap(unwrap(JD)->clear());
584 }
585 
586 void LLVMOrcJITDylibAddGenerator(LLVMOrcJITDylibRef JD,
587                                  LLVMOrcDefinitionGeneratorRef DG) {
588   unwrap(JD)->addGenerator(std::unique_ptr<DefinitionGenerator>(unwrap(DG)));
589 }
590 
591 LLVMOrcDefinitionGeneratorRef LLVMOrcCreateCustomCAPIDefinitionGenerator(
592     LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction F, void *Ctx) {
593   auto DG = std::make_unique<CAPIDefinitionGenerator>(Ctx, F);
594   return wrap(DG.release());
595 }
596 
597 LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(
598     LLVMOrcDefinitionGeneratorRef *Result, char GlobalPrefix,
599     LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
600   assert(Result && "Result can not be null");
601   assert((Filter || !FilterCtx) &&
602          "if Filter is null then FilterCtx must also be null");
603 
604   DynamicLibrarySearchGenerator::SymbolPredicate Pred;
605   if (Filter)
606     Pred = [=](const SymbolStringPtr &Name) -> bool {
607       return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)));
608     };
609 
610   auto ProcessSymsGenerator =
611       DynamicLibrarySearchGenerator::GetForCurrentProcess(GlobalPrefix, Pred);
612 
613   if (!ProcessSymsGenerator) {
614     *Result = 0;
615     return wrap(ProcessSymsGenerator.takeError());
616   }
617 
618   *Result = wrap(ProcessSymsGenerator->release());
619   return LLVMErrorSuccess;
620 }
621 
622 LLVMOrcThreadSafeContextRef LLVMOrcCreateNewThreadSafeContext(void) {
623   return wrap(new ThreadSafeContext(std::make_unique<LLVMContext>()));
624 }
625 
626 LLVMContextRef
627 LLVMOrcThreadSafeContextGetContext(LLVMOrcThreadSafeContextRef TSCtx) {
628   return wrap(unwrap(TSCtx)->getContext());
629 }
630 
631 void LLVMOrcDisposeThreadSafeContext(LLVMOrcThreadSafeContextRef TSCtx) {
632   delete unwrap(TSCtx);
633 }
634 
635 LLVMErrorRef
636 LLVMOrcThreadSafeModuleWithModuleDo(LLVMOrcThreadSafeModuleRef TSM,
637                                     LLVMOrcGenericIRModuleOperationFunction F,
638                                     void *Ctx) {
639   return wrap(unwrap(TSM)->withModuleDo(
640       [&](Module &M) { return unwrap(F(Ctx, wrap(&M))); }));
641 }
642 
643 LLVMOrcThreadSafeModuleRef
644 LLVMOrcCreateNewThreadSafeModule(LLVMModuleRef M,
645                                  LLVMOrcThreadSafeContextRef TSCtx) {
646   return wrap(
647       new ThreadSafeModule(std::unique_ptr<Module>(unwrap(M)), *unwrap(TSCtx)));
648 }
649 
650 void LLVMOrcDisposeThreadSafeModule(LLVMOrcThreadSafeModuleRef TSM) {
651   delete unwrap(TSM);
652 }
653 
654 LLVMErrorRef LLVMOrcJITTargetMachineBuilderDetectHost(
655     LLVMOrcJITTargetMachineBuilderRef *Result) {
656   assert(Result && "Result can not be null");
657 
658   auto JTMB = JITTargetMachineBuilder::detectHost();
659   if (!JTMB) {
660     Result = 0;
661     return wrap(JTMB.takeError());
662   }
663 
664   *Result = wrap(new JITTargetMachineBuilder(std::move(*JTMB)));
665   return LLVMErrorSuccess;
666 }
667 
668 LLVMOrcJITTargetMachineBuilderRef
669 LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(LLVMTargetMachineRef TM) {
670   auto *TemplateTM = unwrap(TM);
671 
672   auto JTMB =
673       std::make_unique<JITTargetMachineBuilder>(TemplateTM->getTargetTriple());
674 
675   (*JTMB)
676       .setCPU(TemplateTM->getTargetCPU().str())
677       .setRelocationModel(TemplateTM->getRelocationModel())
678       .setCodeModel(TemplateTM->getCodeModel())
679       .setCodeGenOptLevel(TemplateTM->getOptLevel())
680       .setFeatures(TemplateTM->getTargetFeatureString())
681       .setOptions(TemplateTM->Options);
682 
683   LLVMDisposeTargetMachine(TM);
684 
685   return wrap(JTMB.release());
686 }
687 
688 void LLVMOrcDisposeJITTargetMachineBuilder(
689     LLVMOrcJITTargetMachineBuilderRef JTMB) {
690   delete unwrap(JTMB);
691 }
692 
693 char *LLVMOrcJITTargetMachineBuilderGetTargetTriple(
694     LLVMOrcJITTargetMachineBuilderRef JTMB) {
695   auto Tmp = unwrap(JTMB)->getTargetTriple().str();
696   char *TargetTriple = (char *)malloc(Tmp.size() + 1);
697   strcpy(TargetTriple, Tmp.c_str());
698   return TargetTriple;
699 }
700 
701 void LLVMOrcJITTargetMachineBuilderSetTargetTriple(
702     LLVMOrcJITTargetMachineBuilderRef JTMB, const char *TargetTriple) {
703   unwrap(JTMB)->getTargetTriple() = Triple(TargetTriple);
704 }
705 
706 LLVMErrorRef LLVMOrcObjectLayerAddObjectFile(LLVMOrcObjectLayerRef ObjLayer,
707                                              LLVMOrcJITDylibRef JD,
708                                              LLVMMemoryBufferRef ObjBuffer) {
709   return wrap(unwrap(ObjLayer)->add(
710       *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
711 }
712 
713 LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcObjectLayerRef ObjLayer,
714                                              LLVMOrcResourceTrackerRef RT,
715                                              LLVMMemoryBufferRef ObjBuffer) {
716   return wrap(
717       unwrap(ObjLayer)->add(ResourceTrackerSP(unwrap(RT)),
718                             std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
719 }
720 
721 void LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer,
722                             LLVMOrcMaterializationResponsibilityRef R,
723                             LLVMMemoryBufferRef ObjBuffer) {
724   unwrap(ObjLayer)->emit(
725       std::unique_ptr<MaterializationResponsibility>(unwrap(R)),
726       std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)));
727 }
728 
729 void LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer) {
730   delete unwrap(ObjLayer);
731 }
732 
733 void LLVMOrcIRTransformLayerSetTransform(
734     LLVMOrcIRTransformLayerRef IRTransformLayer,
735     LLVMOrcIRTransformLayerTransformFunction TransformFunction, void *Ctx) {
736   unwrap(IRTransformLayer)
737       ->setTransform(
738           [=](ThreadSafeModule TSM,
739               MaterializationResponsibility &R) -> Expected<ThreadSafeModule> {
740             LLVMOrcThreadSafeModuleRef TSMRef =
741                 wrap(new ThreadSafeModule(std::move(TSM)));
742             if (LLVMErrorRef Err = TransformFunction(Ctx, &TSMRef, wrap(&R))) {
743               assert(!TSMRef && "TSMRef was not reset to null on error");
744               return unwrap(Err);
745             }
746             return std::move(*unwrap(TSMRef));
747           });
748 }
749 
750 void LLVMOrcObjectTransformLayerSetTransform(
751     LLVMOrcObjectTransformLayerRef ObjTransformLayer,
752     LLVMOrcObjectTransformLayerTransformFunction TransformFunction, void *Ctx) {
753   unwrap(ObjTransformLayer)
754       ->setTransform([TransformFunction, Ctx](std::unique_ptr<MemoryBuffer> Obj)
755                          -> Expected<std::unique_ptr<MemoryBuffer>> {
756         LLVMMemoryBufferRef ObjBuffer = wrap(Obj.release());
757         if (LLVMErrorRef Err = TransformFunction(Ctx, &ObjBuffer)) {
758           assert(!ObjBuffer && "ObjBuffer was not reset to null on error");
759           return unwrap(Err);
760         }
761         return std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer));
762       });
763 }
764 
765 LLVMOrcDumpObjectsRef LLVMOrcCreateDumpObjects(const char *DumpDir,
766                                                const char *IdentifierOverride) {
767   assert(DumpDir && "DumpDir should not be null");
768   assert(IdentifierOverride && "IdentifierOverride should not be null");
769   return wrap(new DumpObjects(DumpDir, IdentifierOverride));
770 }
771 
772 void LLVMOrcDisposeDumpObjects(LLVMOrcDumpObjectsRef DumpObjects) {
773   delete unwrap(DumpObjects);
774 }
775 
776 LLVMErrorRef LLVMOrcDumpObjects_CallOperator(LLVMOrcDumpObjectsRef DumpObjects,
777                                              LLVMMemoryBufferRef *ObjBuffer) {
778   std::unique_ptr<MemoryBuffer> OB(unwrap(*ObjBuffer));
779   if (auto Result = (*unwrap(DumpObjects))(std::move(OB))) {
780     *ObjBuffer = wrap(Result->release());
781     return LLVMErrorSuccess;
782   } else {
783     *ObjBuffer = nullptr;
784     return wrap(Result.takeError());
785   }
786 }
787 
788 LLVMOrcLLJITBuilderRef LLVMOrcCreateLLJITBuilder(void) {
789   return wrap(new LLJITBuilder());
790 }
791 
792 void LLVMOrcDisposeLLJITBuilder(LLVMOrcLLJITBuilderRef Builder) {
793   delete unwrap(Builder);
794 }
795 
796 void LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(
797     LLVMOrcLLJITBuilderRef Builder, LLVMOrcJITTargetMachineBuilderRef JTMB) {
798   unwrap(Builder)->setJITTargetMachineBuilder(std::move(*unwrap(JTMB)));
799   LLVMOrcDisposeJITTargetMachineBuilder(JTMB);
800 }
801 
802 void LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(
803     LLVMOrcLLJITBuilderRef Builder,
804     LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F, void *Ctx) {
805   unwrap(Builder)->setObjectLinkingLayerCreator(
806       [=](ExecutionSession &ES, const Triple &TT) {
807         auto TTStr = TT.str();
808         return std::unique_ptr<ObjectLayer>(
809             unwrap(F(Ctx, wrap(&ES), TTStr.c_str())));
810       });
811 }
812 
813 LLVMErrorRef LLVMOrcCreateLLJIT(LLVMOrcLLJITRef *Result,
814                                 LLVMOrcLLJITBuilderRef Builder) {
815   assert(Result && "Result can not be null");
816 
817   if (!Builder)
818     Builder = LLVMOrcCreateLLJITBuilder();
819 
820   auto J = unwrap(Builder)->create();
821   LLVMOrcDisposeLLJITBuilder(Builder);
822 
823   if (!J) {
824     Result = 0;
825     return wrap(J.takeError());
826   }
827 
828   *Result = wrap(J->release());
829   return LLVMErrorSuccess;
830 }
831 
832 LLVMErrorRef LLVMOrcDisposeLLJIT(LLVMOrcLLJITRef J) {
833   delete unwrap(J);
834   return LLVMErrorSuccess;
835 }
836 
837 LLVMOrcExecutionSessionRef LLVMOrcLLJITGetExecutionSession(LLVMOrcLLJITRef J) {
838   return wrap(&unwrap(J)->getExecutionSession());
839 }
840 
841 LLVMOrcJITDylibRef LLVMOrcLLJITGetMainJITDylib(LLVMOrcLLJITRef J) {
842   return wrap(&unwrap(J)->getMainJITDylib());
843 }
844 
845 const char *LLVMOrcLLJITGetTripleString(LLVMOrcLLJITRef J) {
846   return unwrap(J)->getTargetTriple().str().c_str();
847 }
848 
849 char LLVMOrcLLJITGetGlobalPrefix(LLVMOrcLLJITRef J) {
850   return unwrap(J)->getDataLayout().getGlobalPrefix();
851 }
852 
853 LLVMOrcSymbolStringPoolEntryRef
854 LLVMOrcLLJITMangleAndIntern(LLVMOrcLLJITRef J, const char *UnmangledName) {
855   return wrap(OrcV2CAPIHelper::moveFromSymbolStringPtr(
856       unwrap(J)->mangleAndIntern(UnmangledName)));
857 }
858 
859 LLVMErrorRef LLVMOrcLLJITAddObjectFile(LLVMOrcLLJITRef J, LLVMOrcJITDylibRef JD,
860                                        LLVMMemoryBufferRef ObjBuffer) {
861   return wrap(unwrap(J)->addObjectFile(
862       *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
863 }
864 
865 LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcLLJITRef J,
866                                              LLVMOrcResourceTrackerRef RT,
867                                              LLVMMemoryBufferRef ObjBuffer) {
868   return wrap(unwrap(J)->addObjectFile(
869       ResourceTrackerSP(unwrap(RT)),
870       std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
871 }
872 
873 LLVMErrorRef LLVMOrcLLJITAddLLVMIRModule(LLVMOrcLLJITRef J,
874                                          LLVMOrcJITDylibRef JD,
875                                          LLVMOrcThreadSafeModuleRef TSM) {
876   std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
877   return wrap(unwrap(J)->addIRModule(*unwrap(JD), std::move(*TmpTSM)));
878 }
879 
880 LLVMErrorRef LLVMOrcLLJITAddLLVMIRModuleWithRT(LLVMOrcLLJITRef J,
881                                                LLVMOrcResourceTrackerRef RT,
882                                                LLVMOrcThreadSafeModuleRef TSM) {
883   std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
884   return wrap(unwrap(J)->addIRModule(ResourceTrackerSP(unwrap(RT)),
885                                      std::move(*TmpTSM)));
886 }
887 
888 LLVMErrorRef LLVMOrcLLJITLookup(LLVMOrcLLJITRef J,
889                                 LLVMOrcJITTargetAddress *Result,
890                                 const char *Name) {
891   assert(Result && "Result can not be null");
892 
893   auto Sym = unwrap(J)->lookup(Name);
894   if (!Sym) {
895     *Result = 0;
896     return wrap(Sym.takeError());
897   }
898 
899   *Result = Sym->getAddress();
900   return LLVMErrorSuccess;
901 }
902 
903 LLVMOrcObjectLayerRef LLVMOrcLLJITGetObjLinkingLayer(LLVMOrcLLJITRef J) {
904   return wrap(&unwrap(J)->getObjLinkingLayer());
905 }
906 
907 LLVMOrcObjectTransformLayerRef
908 LLVMOrcLLJITGetObjTransformLayer(LLVMOrcLLJITRef J) {
909   return wrap(&unwrap(J)->getObjTransformLayer());
910 }
911 
912 LLVMOrcObjectLayerRef
913 LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(
914     LLVMOrcExecutionSessionRef ES) {
915   assert(ES && "ES must not be null");
916   return wrap(new RTDyldObjectLinkingLayer(
917       *unwrap(ES), [] { return std::make_unique<SectionMemoryManager>(); }));
918 }
919 
920 void LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(
921     LLVMOrcObjectLayerRef RTDyldObjLinkingLayer,
922     LLVMJITEventListenerRef Listener) {
923   assert(RTDyldObjLinkingLayer && "RTDyldObjLinkingLayer must not be null");
924   assert(Listener && "Listener must not be null");
925   reinterpret_cast<RTDyldObjectLinkingLayer *>(unwrap(RTDyldObjLinkingLayer))
926       ->registerJITEventListener(*unwrap(Listener));
927 }
928 
929 LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J) {
930   return wrap(&unwrap(J)->getIRTransformLayer());
931 }
932 
933 const char *LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J) {
934   return unwrap(J)->getDataLayout().getStringRepresentation().c_str();
935 }
936 
937 LLVMOrcIndirectStubsManagerRef
938 LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple) {
939   auto builder = createLocalIndirectStubsManagerBuilder(Triple(TargetTriple));
940   return wrap(builder().release());
941 }
942 
943 void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM) {
944   std::unique_ptr<IndirectStubsManager> TmpISM(unwrap(ISM));
945 }
946 
947 LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
948     const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
949     LLVMOrcJITTargetAddress ErrorHandlerAddr,
950     LLVMOrcLazyCallThroughManagerRef *Result) {
951   auto LCTM = createLocalLazyCallThroughManager(Triple(TargetTriple),
952                                                 *unwrap(ES), ErrorHandlerAddr);
953 
954   if (!LCTM)
955     return wrap(LCTM.takeError());
956   *Result = wrap(LCTM->release());
957   return LLVMErrorSuccess;
958 }
959 
960 void LLVMOrcDisposeLazyCallThroughManager(
961     LLVMOrcLazyCallThroughManagerRef LCM) {
962   std::unique_ptr<LazyCallThroughManager> TmpLCM(unwrap(LCM));
963 }
964