contrib/llvm-project/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

   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 = 0;
 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 = 0;
 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 = 0;
 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 = 0;
 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 = 0;
 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 = 0;
 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 }