xref: /freebsd/contrib/llvm-project/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp (revision a2464ee12761660f50d0b6f59f233949ebcacc87) 
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(
196             Interface(std::move(InitialSymbolFlags), 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 = nullptr;
615     return wrap(ProcessSymsGenerator.takeError());
616   }
617 
618   *Result = wrap(ProcessSymsGenerator->release());
619   return LLVMErrorSuccess;
620 }
621 
622 LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForPath(
623     LLVMOrcDefinitionGeneratorRef *Result, const char *FileName,
624     char GlobalPrefix, LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
625   assert(Result && "Result can not be null");
626   assert(FileName && "FileName can not be null");
627   assert((Filter || !FilterCtx) &&
628          "if Filter is null then FilterCtx must also be null");
629 
630   DynamicLibrarySearchGenerator::SymbolPredicate Pred;
631   if (Filter)
632     Pred = [=](const SymbolStringPtr &Name) -> bool {
633       return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)));
634     };
635 
636   auto LibrarySymsGenerator =
637       DynamicLibrarySearchGenerator::Load(FileName, GlobalPrefix, Pred);
638 
639   if (!LibrarySymsGenerator) {
640     *Result = nullptr;
641     return wrap(LibrarySymsGenerator.takeError());
642   }
643 
644   *Result = wrap(LibrarySymsGenerator->release());
645   return LLVMErrorSuccess;
646 }
647 
648 LLVMErrorRef LLVMOrcCreateStaticLibrarySearchGeneratorForPath(
649     LLVMOrcDefinitionGeneratorRef *Result, LLVMOrcObjectLayerRef ObjLayer,
650     const char *FileName, const char *TargetTriple) {
651   assert(Result && "Result can not be null");
652   assert(FileName && "Filename can not be null");
653   assert(ObjLayer && "ObjectLayer can not be null");
654 
655   if (TargetTriple) {
656     auto TT = Triple(TargetTriple);
657     auto LibrarySymsGenerator =
658         StaticLibraryDefinitionGenerator::Load(*unwrap(ObjLayer), FileName, TT);
659     if (!LibrarySymsGenerator) {
660       *Result = nullptr;
661       return wrap(LibrarySymsGenerator.takeError());
662     }
663     *Result = wrap(LibrarySymsGenerator->release());
664     return LLVMErrorSuccess;
665   } else {
666     auto LibrarySymsGenerator =
667         StaticLibraryDefinitionGenerator::Load(*unwrap(ObjLayer), FileName);
668     if (!LibrarySymsGenerator) {
669       *Result = nullptr;
670       return wrap(LibrarySymsGenerator.takeError());
671     }
672     *Result = wrap(LibrarySymsGenerator->release());
673     return LLVMErrorSuccess;
674   }
675 }
676 
677 LLVMOrcThreadSafeContextRef LLVMOrcCreateNewThreadSafeContext(void) {
678   return wrap(new ThreadSafeContext(std::make_unique<LLVMContext>()));
679 }
680 
681 LLVMContextRef
682 LLVMOrcThreadSafeContextGetContext(LLVMOrcThreadSafeContextRef TSCtx) {
683   return wrap(unwrap(TSCtx)->getContext());
684 }
685 
686 void LLVMOrcDisposeThreadSafeContext(LLVMOrcThreadSafeContextRef TSCtx) {
687   delete unwrap(TSCtx);
688 }
689 
690 LLVMErrorRef
691 LLVMOrcThreadSafeModuleWithModuleDo(LLVMOrcThreadSafeModuleRef TSM,
692                                     LLVMOrcGenericIRModuleOperationFunction F,
693                                     void *Ctx) {
694   return wrap(unwrap(TSM)->withModuleDo(
695       [&](Module &M) { return unwrap(F(Ctx, wrap(&M))); }));
696 }
697 
698 LLVMOrcThreadSafeModuleRef
699 LLVMOrcCreateNewThreadSafeModule(LLVMModuleRef M,
700                                  LLVMOrcThreadSafeContextRef TSCtx) {
701   return wrap(
702       new ThreadSafeModule(std::unique_ptr<Module>(unwrap(M)), *unwrap(TSCtx)));
703 }
704 
705 void LLVMOrcDisposeThreadSafeModule(LLVMOrcThreadSafeModuleRef TSM) {
706   delete unwrap(TSM);
707 }
708 
709 LLVMErrorRef LLVMOrcJITTargetMachineBuilderDetectHost(
710     LLVMOrcJITTargetMachineBuilderRef *Result) {
711   assert(Result && "Result can not be null");
712 
713   auto JTMB = JITTargetMachineBuilder::detectHost();
714   if (!JTMB) {
715     Result = nullptr;
716     return wrap(JTMB.takeError());
717   }
718 
719   *Result = wrap(new JITTargetMachineBuilder(std::move(*JTMB)));
720   return LLVMErrorSuccess;
721 }
722 
723 LLVMOrcJITTargetMachineBuilderRef
724 LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(LLVMTargetMachineRef TM) {
725   auto *TemplateTM = unwrap(TM);
726 
727   auto JTMB =
728       std::make_unique<JITTargetMachineBuilder>(TemplateTM->getTargetTriple());
729 
730   (*JTMB)
731       .setCPU(TemplateTM->getTargetCPU().str())
732       .setRelocationModel(TemplateTM->getRelocationModel())
733       .setCodeModel(TemplateTM->getCodeModel())
734       .setCodeGenOptLevel(TemplateTM->getOptLevel())
735       .setFeatures(TemplateTM->getTargetFeatureString())
736       .setOptions(TemplateTM->Options);
737 
738   LLVMDisposeTargetMachine(TM);
739 
740   return wrap(JTMB.release());
741 }
742 
743 void LLVMOrcDisposeJITTargetMachineBuilder(
744     LLVMOrcJITTargetMachineBuilderRef JTMB) {
745   delete unwrap(JTMB);
746 }
747 
748 char *LLVMOrcJITTargetMachineBuilderGetTargetTriple(
749     LLVMOrcJITTargetMachineBuilderRef JTMB) {
750   auto Tmp = unwrap(JTMB)->getTargetTriple().str();
751   char *TargetTriple = (char *)malloc(Tmp.size() + 1);
752   strcpy(TargetTriple, Tmp.c_str());
753   return TargetTriple;
754 }
755 
756 void LLVMOrcJITTargetMachineBuilderSetTargetTriple(
757     LLVMOrcJITTargetMachineBuilderRef JTMB, const char *TargetTriple) {
758   unwrap(JTMB)->getTargetTriple() = Triple(TargetTriple);
759 }
760 
761 LLVMErrorRef LLVMOrcObjectLayerAddObjectFile(LLVMOrcObjectLayerRef ObjLayer,
762                                              LLVMOrcJITDylibRef JD,
763                                              LLVMMemoryBufferRef ObjBuffer) {
764   return wrap(unwrap(ObjLayer)->add(
765       *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
766 }
767 
768 LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcObjectLayerRef ObjLayer,
769                                              LLVMOrcResourceTrackerRef RT,
770                                              LLVMMemoryBufferRef ObjBuffer) {
771   return wrap(
772       unwrap(ObjLayer)->add(ResourceTrackerSP(unwrap(RT)),
773                             std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
774 }
775 
776 void LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer,
777                             LLVMOrcMaterializationResponsibilityRef R,
778                             LLVMMemoryBufferRef ObjBuffer) {
779   unwrap(ObjLayer)->emit(
780       std::unique_ptr<MaterializationResponsibility>(unwrap(R)),
781       std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)));
782 }
783 
784 void LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer) {
785   delete unwrap(ObjLayer);
786 }
787 
788 void LLVMOrcIRTransformLayerSetTransform(
789     LLVMOrcIRTransformLayerRef IRTransformLayer,
790     LLVMOrcIRTransformLayerTransformFunction TransformFunction, void *Ctx) {
791   unwrap(IRTransformLayer)
792       ->setTransform(
793           [=](ThreadSafeModule TSM,
794               MaterializationResponsibility &R) -> Expected<ThreadSafeModule> {
795             LLVMOrcThreadSafeModuleRef TSMRef =
796                 wrap(new ThreadSafeModule(std::move(TSM)));
797             if (LLVMErrorRef Err = TransformFunction(Ctx, &TSMRef, wrap(&R))) {
798               assert(!TSMRef && "TSMRef was not reset to null on error");
799               return unwrap(Err);
800             }
801             return std::move(*unwrap(TSMRef));
802           });
803 }
804 
805 void LLVMOrcObjectTransformLayerSetTransform(
806     LLVMOrcObjectTransformLayerRef ObjTransformLayer,
807     LLVMOrcObjectTransformLayerTransformFunction TransformFunction, void *Ctx) {
808   unwrap(ObjTransformLayer)
809       ->setTransform([TransformFunction, Ctx](std::unique_ptr<MemoryBuffer> Obj)
810                          -> Expected<std::unique_ptr<MemoryBuffer>> {
811         LLVMMemoryBufferRef ObjBuffer = wrap(Obj.release());
812         if (LLVMErrorRef Err = TransformFunction(Ctx, &ObjBuffer)) {
813           assert(!ObjBuffer && "ObjBuffer was not reset to null on error");
814           return unwrap(Err);
815         }
816         return std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer));
817       });
818 }
819 
820 LLVMOrcDumpObjectsRef LLVMOrcCreateDumpObjects(const char *DumpDir,
821                                                const char *IdentifierOverride) {
822   assert(DumpDir && "DumpDir should not be null");
823   assert(IdentifierOverride && "IdentifierOverride should not be null");
824   return wrap(new DumpObjects(DumpDir, IdentifierOverride));
825 }
826 
827 void LLVMOrcDisposeDumpObjects(LLVMOrcDumpObjectsRef DumpObjects) {
828   delete unwrap(DumpObjects);
829 }
830 
831 LLVMErrorRef LLVMOrcDumpObjects_CallOperator(LLVMOrcDumpObjectsRef DumpObjects,
832                                              LLVMMemoryBufferRef *ObjBuffer) {
833   std::unique_ptr<MemoryBuffer> OB(unwrap(*ObjBuffer));
834   if (auto Result = (*unwrap(DumpObjects))(std::move(OB))) {
835     *ObjBuffer = wrap(Result->release());
836     return LLVMErrorSuccess;
837   } else {
838     *ObjBuffer = nullptr;
839     return wrap(Result.takeError());
840   }
841 }
842 
843 LLVMOrcLLJITBuilderRef LLVMOrcCreateLLJITBuilder(void) {
844   return wrap(new LLJITBuilder());
845 }
846 
847 void LLVMOrcDisposeLLJITBuilder(LLVMOrcLLJITBuilderRef Builder) {
848   delete unwrap(Builder);
849 }
850 
851 void LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(
852     LLVMOrcLLJITBuilderRef Builder, LLVMOrcJITTargetMachineBuilderRef JTMB) {
853   unwrap(Builder)->setJITTargetMachineBuilder(std::move(*unwrap(JTMB)));
854   LLVMOrcDisposeJITTargetMachineBuilder(JTMB);
855 }
856 
857 void LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(
858     LLVMOrcLLJITBuilderRef Builder,
859     LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F, void *Ctx) {
860   unwrap(Builder)->setObjectLinkingLayerCreator(
861       [=](ExecutionSession &ES, const Triple &TT) {
862         auto TTStr = TT.str();
863         return std::unique_ptr<ObjectLayer>(
864             unwrap(F(Ctx, wrap(&ES), TTStr.c_str())));
865       });
866 }
867 
868 LLVMErrorRef LLVMOrcCreateLLJIT(LLVMOrcLLJITRef *Result,
869                                 LLVMOrcLLJITBuilderRef Builder) {
870   assert(Result && "Result can not be null");
871 
872   if (!Builder)
873     Builder = LLVMOrcCreateLLJITBuilder();
874 
875   auto J = unwrap(Builder)->create();
876   LLVMOrcDisposeLLJITBuilder(Builder);
877 
878   if (!J) {
879     Result = nullptr;
880     return wrap(J.takeError());
881   }
882 
883   *Result = wrap(J->release());
884   return LLVMErrorSuccess;
885 }
886 
887 LLVMErrorRef LLVMOrcDisposeLLJIT(LLVMOrcLLJITRef J) {
888   delete unwrap(J);
889   return LLVMErrorSuccess;
890 }
891 
892 LLVMOrcExecutionSessionRef LLVMOrcLLJITGetExecutionSession(LLVMOrcLLJITRef J) {
893   return wrap(&unwrap(J)->getExecutionSession());
894 }
895 
896 LLVMOrcJITDylibRef LLVMOrcLLJITGetMainJITDylib(LLVMOrcLLJITRef J) {
897   return wrap(&unwrap(J)->getMainJITDylib());
898 }
899 
900 const char *LLVMOrcLLJITGetTripleString(LLVMOrcLLJITRef J) {
901   return unwrap(J)->getTargetTriple().str().c_str();
902 }
903 
904 char LLVMOrcLLJITGetGlobalPrefix(LLVMOrcLLJITRef J) {
905   return unwrap(J)->getDataLayout().getGlobalPrefix();
906 }
907 
908 LLVMOrcSymbolStringPoolEntryRef
909 LLVMOrcLLJITMangleAndIntern(LLVMOrcLLJITRef J, const char *UnmangledName) {
910   return wrap(OrcV2CAPIHelper::moveFromSymbolStringPtr(
911       unwrap(J)->mangleAndIntern(UnmangledName)));
912 }
913 
914 LLVMErrorRef LLVMOrcLLJITAddObjectFile(LLVMOrcLLJITRef J, LLVMOrcJITDylibRef JD,
915                                        LLVMMemoryBufferRef ObjBuffer) {
916   return wrap(unwrap(J)->addObjectFile(
917       *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
918 }
919 
920 LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcLLJITRef J,
921                                              LLVMOrcResourceTrackerRef RT,
922                                              LLVMMemoryBufferRef ObjBuffer) {
923   return wrap(unwrap(J)->addObjectFile(
924       ResourceTrackerSP(unwrap(RT)),
925       std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))));
926 }
927 
928 LLVMErrorRef LLVMOrcLLJITAddLLVMIRModule(LLVMOrcLLJITRef J,
929                                          LLVMOrcJITDylibRef JD,
930                                          LLVMOrcThreadSafeModuleRef TSM) {
931   std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
932   return wrap(unwrap(J)->addIRModule(*unwrap(JD), std::move(*TmpTSM)));
933 }
934 
935 LLVMErrorRef LLVMOrcLLJITAddLLVMIRModuleWithRT(LLVMOrcLLJITRef J,
936                                                LLVMOrcResourceTrackerRef RT,
937                                                LLVMOrcThreadSafeModuleRef TSM) {
938   std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
939   return wrap(unwrap(J)->addIRModule(ResourceTrackerSP(unwrap(RT)),
940                                      std::move(*TmpTSM)));
941 }
942 
943 LLVMErrorRef LLVMOrcLLJITLookup(LLVMOrcLLJITRef J,
944                                 LLVMOrcJITTargetAddress *Result,
945                                 const char *Name) {
946   assert(Result && "Result can not be null");
947 
948   auto Sym = unwrap(J)->lookup(Name);
949   if (!Sym) {
950     *Result = 0;
951     return wrap(Sym.takeError());
952   }
953 
954   *Result = Sym->getAddress();
955   return LLVMErrorSuccess;
956 }
957 
958 LLVMOrcObjectLayerRef LLVMOrcLLJITGetObjLinkingLayer(LLVMOrcLLJITRef J) {
959   return wrap(&unwrap(J)->getObjLinkingLayer());
960 }
961 
962 LLVMOrcObjectTransformLayerRef
963 LLVMOrcLLJITGetObjTransformLayer(LLVMOrcLLJITRef J) {
964   return wrap(&unwrap(J)->getObjTransformLayer());
965 }
966 
967 LLVMOrcObjectLayerRef
968 LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(
969     LLVMOrcExecutionSessionRef ES) {
970   assert(ES && "ES must not be null");
971   return wrap(new RTDyldObjectLinkingLayer(
972       *unwrap(ES), [] { return std::make_unique<SectionMemoryManager>(); }));
973 }
974 
975 void LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(
976     LLVMOrcObjectLayerRef RTDyldObjLinkingLayer,
977     LLVMJITEventListenerRef Listener) {
978   assert(RTDyldObjLinkingLayer && "RTDyldObjLinkingLayer must not be null");
979   assert(Listener && "Listener must not be null");
980   reinterpret_cast<RTDyldObjectLinkingLayer *>(unwrap(RTDyldObjLinkingLayer))
981       ->registerJITEventListener(*unwrap(Listener));
982 }
983 
984 LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J) {
985   return wrap(&unwrap(J)->getIRTransformLayer());
986 }
987 
988 const char *LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J) {
989   return unwrap(J)->getDataLayout().getStringRepresentation().c_str();
990 }
991 
992 LLVMOrcIndirectStubsManagerRef
993 LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple) {
994   auto builder = createLocalIndirectStubsManagerBuilder(Triple(TargetTriple));
995   return wrap(builder().release());
996 }
997 
998 void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM) {
999   std::unique_ptr<IndirectStubsManager> TmpISM(unwrap(ISM));
1000 }
1001 
1002 LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
1003     const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
1004     LLVMOrcJITTargetAddress ErrorHandlerAddr,
1005     LLVMOrcLazyCallThroughManagerRef *Result) {
1006   auto LCTM = createLocalLazyCallThroughManager(Triple(TargetTriple),
1007                                                 *unwrap(ES), ErrorHandlerAddr);
1008 
1009   if (!LCTM)
1010     return wrap(LCTM.takeError());
1011   *Result = wrap(LCTM->release());
1012   return LLVMErrorSuccess;
1013 }
1014 
1015 void LLVMOrcDisposeLazyCallThroughManager(
1016     LLVMOrcLazyCallThroughManagerRef LCM) {
1017   std::unique_ptr<LazyCallThroughManager> TmpLCM(unwrap(LCM));
1018 }
1019