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