15ffd83dbSDimitry Andric //===--------------- OrcV2CBindings.cpp - C bindings OrcV2 APIs -----------===// 25ffd83dbSDimitry Andric // 35ffd83dbSDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 45ffd83dbSDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 55ffd83dbSDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 65ffd83dbSDimitry Andric // 75ffd83dbSDimitry Andric //===----------------------------------------------------------------------===// 85ffd83dbSDimitry Andric 9e8d8bef9SDimitry Andric #include "llvm-c/LLJIT.h" 105ffd83dbSDimitry Andric #include "llvm-c/Orc.h" 11e8d8bef9SDimitry Andric #include "llvm-c/OrcEE.h" 125ffd83dbSDimitry Andric #include "llvm-c/TargetMachine.h" 135ffd83dbSDimitry Andric 145ffd83dbSDimitry Andric #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h" 155ffd83dbSDimitry Andric #include "llvm/ExecutionEngine/Orc/LLJIT.h" 16fe6060f1SDimitry Andric #include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h" 17e8d8bef9SDimitry Andric #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h" 18e8d8bef9SDimitry Andric #include "llvm/ExecutionEngine/SectionMemoryManager.h" 195ffd83dbSDimitry Andric 205ffd83dbSDimitry Andric using namespace llvm; 215ffd83dbSDimitry Andric using namespace llvm::orc; 225ffd83dbSDimitry Andric 235ffd83dbSDimitry Andric namespace llvm { 245ffd83dbSDimitry Andric namespace orc { 255ffd83dbSDimitry Andric 26e8d8bef9SDimitry Andric class InProgressLookupState; 27e8d8bef9SDimitry Andric 285ffd83dbSDimitry Andric class OrcV2CAPIHelper { 295ffd83dbSDimitry Andric public: 305ffd83dbSDimitry Andric using PoolEntry = SymbolStringPtr::PoolEntry; 315ffd83dbSDimitry Andric using PoolEntryPtr = SymbolStringPtr::PoolEntryPtr; 325ffd83dbSDimitry Andric 33fe6060f1SDimitry Andric // Move from SymbolStringPtr to PoolEntryPtr (no change in ref count). 34fe6060f1SDimitry Andric static PoolEntryPtr moveFromSymbolStringPtr(SymbolStringPtr S) { 355ffd83dbSDimitry Andric PoolEntryPtr Result = nullptr; 365ffd83dbSDimitry Andric std::swap(Result, S.S); 375ffd83dbSDimitry Andric return Result; 385ffd83dbSDimitry Andric } 395ffd83dbSDimitry Andric 40fe6060f1SDimitry Andric // Move from a PoolEntryPtr to a SymbolStringPtr (no change in ref count). 41fe6060f1SDimitry Andric static SymbolStringPtr moveToSymbolStringPtr(PoolEntryPtr P) { 42fe6060f1SDimitry Andric SymbolStringPtr S; 43fe6060f1SDimitry Andric S.S = P; 44fe6060f1SDimitry Andric return S; 45fe6060f1SDimitry Andric } 46fe6060f1SDimitry Andric 47fe6060f1SDimitry Andric // Copy a pool entry to a SymbolStringPtr (increments ref count). 48fe6060f1SDimitry Andric static SymbolStringPtr copyToSymbolStringPtr(PoolEntryPtr P) { 49e8d8bef9SDimitry Andric return SymbolStringPtr(P); 50e8d8bef9SDimitry Andric } 51e8d8bef9SDimitry Andric 525ffd83dbSDimitry Andric static PoolEntryPtr getRawPoolEntryPtr(const SymbolStringPtr &S) { 535ffd83dbSDimitry Andric return S.S; 545ffd83dbSDimitry Andric } 555ffd83dbSDimitry Andric 56e8d8bef9SDimitry Andric static void retainPoolEntry(PoolEntryPtr P) { 57e8d8bef9SDimitry Andric SymbolStringPtr S(P); 58e8d8bef9SDimitry Andric S.S = nullptr; 59e8d8bef9SDimitry Andric } 60e8d8bef9SDimitry Andric 615ffd83dbSDimitry Andric static void releasePoolEntry(PoolEntryPtr P) { 625ffd83dbSDimitry Andric SymbolStringPtr S; 635ffd83dbSDimitry Andric S.S = P; 645ffd83dbSDimitry Andric } 65e8d8bef9SDimitry Andric 66e8d8bef9SDimitry Andric static InProgressLookupState *extractLookupState(LookupState &LS) { 67e8d8bef9SDimitry Andric return LS.IPLS.release(); 68e8d8bef9SDimitry Andric } 69e8d8bef9SDimitry Andric 70e8d8bef9SDimitry Andric static void resetLookupState(LookupState &LS, InProgressLookupState *IPLS) { 71e8d8bef9SDimitry Andric return LS.reset(IPLS); 72e8d8bef9SDimitry Andric } 735ffd83dbSDimitry Andric }; 745ffd83dbSDimitry Andric 75e8d8bef9SDimitry Andric } // namespace orc 76e8d8bef9SDimitry Andric } // namespace llvm 775ffd83dbSDimitry Andric 785ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionSession, LLVMOrcExecutionSessionRef) 79e8d8bef9SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SymbolStringPool, LLVMOrcSymbolStringPoolRef) 805ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(OrcV2CAPIHelper::PoolEntry, 815ffd83dbSDimitry Andric LLVMOrcSymbolStringPoolEntryRef) 82e8d8bef9SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MaterializationUnit, 83e8d8bef9SDimitry Andric LLVMOrcMaterializationUnitRef) 84fe6060f1SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MaterializationResponsibility, 85fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef) 865ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITDylib, LLVMOrcJITDylibRef) 87e8d8bef9SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ResourceTracker, LLVMOrcResourceTrackerRef) 88e8d8bef9SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DefinitionGenerator, 89e8d8bef9SDimitry Andric LLVMOrcDefinitionGeneratorRef) 90e8d8bef9SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(InProgressLookupState, LLVMOrcLookupStateRef) 915ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeContext, 925ffd83dbSDimitry Andric LLVMOrcThreadSafeContextRef) 935ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeModule, LLVMOrcThreadSafeModuleRef) 945ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITTargetMachineBuilder, 955ffd83dbSDimitry Andric LLVMOrcJITTargetMachineBuilderRef) 96e8d8bef9SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ObjectLayer, LLVMOrcObjectLayerRef) 97fe6060f1SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRTransformLayer, LLVMOrcIRTransformLayerRef) 98fe6060f1SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ObjectTransformLayer, 99fe6060f1SDimitry Andric LLVMOrcObjectTransformLayerRef) 100fe6060f1SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DumpObjects, LLVMOrcDumpObjectsRef) 101fe6060f1SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IndirectStubsManager, 102fe6060f1SDimitry Andric LLVMOrcIndirectStubsManagerRef) 103fe6060f1SDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LazyCallThroughManager, 104fe6060f1SDimitry Andric LLVMOrcLazyCallThroughManagerRef) 1055ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLJITBuilder, LLVMOrcLLJITBuilderRef) 1065ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLJIT, LLVMOrcLLJITRef) 1075ffd83dbSDimitry Andric DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef) 1085ffd83dbSDimitry Andric 109e8d8bef9SDimitry Andric namespace llvm { 110e8d8bef9SDimitry Andric namespace orc { 111e8d8bef9SDimitry Andric 112e8d8bef9SDimitry Andric class CAPIDefinitionGenerator final : public DefinitionGenerator { 113e8d8bef9SDimitry Andric public: 114e8d8bef9SDimitry Andric CAPIDefinitionGenerator( 115e8d8bef9SDimitry Andric void *Ctx, 116e8d8bef9SDimitry Andric LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate) 117e8d8bef9SDimitry Andric : Ctx(Ctx), TryToGenerate(TryToGenerate) {} 118e8d8bef9SDimitry Andric 119e8d8bef9SDimitry Andric Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, 120e8d8bef9SDimitry Andric JITDylibLookupFlags JDLookupFlags, 121e8d8bef9SDimitry Andric const SymbolLookupSet &LookupSet) override { 122e8d8bef9SDimitry Andric 123e8d8bef9SDimitry Andric // Take the lookup state. 124e8d8bef9SDimitry Andric LLVMOrcLookupStateRef LSR = ::wrap(OrcV2CAPIHelper::extractLookupState(LS)); 125e8d8bef9SDimitry Andric 126e8d8bef9SDimitry Andric // Translate the lookup kind. 127e8d8bef9SDimitry Andric LLVMOrcLookupKind CLookupKind; 128e8d8bef9SDimitry Andric switch (K) { 129e8d8bef9SDimitry Andric case LookupKind::Static: 130e8d8bef9SDimitry Andric CLookupKind = LLVMOrcLookupKindStatic; 131e8d8bef9SDimitry Andric break; 132e8d8bef9SDimitry Andric case LookupKind::DLSym: 133e8d8bef9SDimitry Andric CLookupKind = LLVMOrcLookupKindDLSym; 134e8d8bef9SDimitry Andric break; 135e8d8bef9SDimitry Andric } 136e8d8bef9SDimitry Andric 137e8d8bef9SDimitry Andric // Translate the JITDylibSearchFlags. 138e8d8bef9SDimitry Andric LLVMOrcJITDylibLookupFlags CJDLookupFlags; 139e8d8bef9SDimitry Andric switch (JDLookupFlags) { 140e8d8bef9SDimitry Andric case JITDylibLookupFlags::MatchExportedSymbolsOnly: 141e8d8bef9SDimitry Andric CJDLookupFlags = LLVMOrcJITDylibLookupFlagsMatchExportedSymbolsOnly; 142e8d8bef9SDimitry Andric break; 143e8d8bef9SDimitry Andric case JITDylibLookupFlags::MatchAllSymbols: 144e8d8bef9SDimitry Andric CJDLookupFlags = LLVMOrcJITDylibLookupFlagsMatchAllSymbols; 145e8d8bef9SDimitry Andric break; 146e8d8bef9SDimitry Andric } 147e8d8bef9SDimitry Andric 148e8d8bef9SDimitry Andric // Translate the lookup set. 149e8d8bef9SDimitry Andric std::vector<LLVMOrcCLookupSetElement> CLookupSet; 150e8d8bef9SDimitry Andric CLookupSet.reserve(LookupSet.size()); 151e8d8bef9SDimitry Andric for (auto &KV : LookupSet) { 152e8d8bef9SDimitry Andric LLVMOrcSymbolLookupFlags SLF; 153e8d8bef9SDimitry Andric LLVMOrcSymbolStringPoolEntryRef Name = 154e8d8bef9SDimitry Andric ::wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(KV.first)); 155e8d8bef9SDimitry Andric switch (KV.second) { 156e8d8bef9SDimitry Andric case SymbolLookupFlags::RequiredSymbol: 157e8d8bef9SDimitry Andric SLF = LLVMOrcSymbolLookupFlagsRequiredSymbol; 158e8d8bef9SDimitry Andric break; 159e8d8bef9SDimitry Andric case SymbolLookupFlags::WeaklyReferencedSymbol: 160e8d8bef9SDimitry Andric SLF = LLVMOrcSymbolLookupFlagsWeaklyReferencedSymbol; 161e8d8bef9SDimitry Andric break; 162e8d8bef9SDimitry Andric } 163e8d8bef9SDimitry Andric CLookupSet.push_back({Name, SLF}); 164e8d8bef9SDimitry Andric } 165e8d8bef9SDimitry Andric 166e8d8bef9SDimitry Andric // Run the C TryToGenerate function. 167e8d8bef9SDimitry Andric auto Err = unwrap(TryToGenerate(::wrap(this), Ctx, &LSR, CLookupKind, 168e8d8bef9SDimitry Andric ::wrap(&JD), CJDLookupFlags, 169e8d8bef9SDimitry Andric CLookupSet.data(), CLookupSet.size())); 170e8d8bef9SDimitry Andric 171e8d8bef9SDimitry Andric // Restore the lookup state. 172e8d8bef9SDimitry Andric OrcV2CAPIHelper::resetLookupState(LS, ::unwrap(LSR)); 173e8d8bef9SDimitry Andric 174e8d8bef9SDimitry Andric return Err; 175e8d8bef9SDimitry Andric } 176e8d8bef9SDimitry Andric 177e8d8bef9SDimitry Andric private: 178e8d8bef9SDimitry Andric void *Ctx; 179e8d8bef9SDimitry Andric LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate; 180e8d8bef9SDimitry Andric }; 181e8d8bef9SDimitry Andric 182e8d8bef9SDimitry Andric } // end namespace orc 183e8d8bef9SDimitry Andric } // end namespace llvm 184e8d8bef9SDimitry Andric 185fe6060f1SDimitry Andric namespace { 186fe6060f1SDimitry Andric 187fe6060f1SDimitry Andric class OrcCAPIMaterializationUnit : public llvm::orc::MaterializationUnit { 188fe6060f1SDimitry Andric public: 189fe6060f1SDimitry Andric OrcCAPIMaterializationUnit( 190fe6060f1SDimitry Andric std::string Name, SymbolFlagsMap InitialSymbolFlags, 191fe6060f1SDimitry Andric SymbolStringPtr InitSymbol, void *Ctx, 192fe6060f1SDimitry Andric LLVMOrcMaterializationUnitMaterializeFunction Materialize, 193fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDiscardFunction Discard, 194fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDestroyFunction Destroy) 1950eae32dcSDimitry Andric : llvm::orc::MaterializationUnit( 1960eae32dcSDimitry Andric Interface(std::move(InitialSymbolFlags), std::move(InitSymbol))), 197fe6060f1SDimitry Andric Name(std::move(Name)), Ctx(Ctx), Materialize(Materialize), 198fe6060f1SDimitry Andric Discard(Discard), Destroy(Destroy) {} 199fe6060f1SDimitry Andric 200fe6060f1SDimitry Andric ~OrcCAPIMaterializationUnit() { 201fe6060f1SDimitry Andric if (Ctx) 202fe6060f1SDimitry Andric Destroy(Ctx); 203fe6060f1SDimitry Andric } 204fe6060f1SDimitry Andric 205fe6060f1SDimitry Andric StringRef getName() const override { return Name; } 206fe6060f1SDimitry Andric 207fe6060f1SDimitry Andric void materialize(std::unique_ptr<MaterializationResponsibility> R) override { 208fe6060f1SDimitry Andric void *Tmp = Ctx; 209fe6060f1SDimitry Andric Ctx = nullptr; 210fe6060f1SDimitry Andric Materialize(Tmp, wrap(R.release())); 211fe6060f1SDimitry Andric } 212fe6060f1SDimitry Andric 213fe6060f1SDimitry Andric private: 214fe6060f1SDimitry Andric void discard(const JITDylib &JD, const SymbolStringPtr &Name) override { 215fe6060f1SDimitry Andric Discard(Ctx, wrap(&JD), wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name))); 216fe6060f1SDimitry Andric } 217fe6060f1SDimitry Andric 218fe6060f1SDimitry Andric std::string Name; 219fe6060f1SDimitry Andric void *Ctx = nullptr; 220fe6060f1SDimitry Andric LLVMOrcMaterializationUnitMaterializeFunction Materialize = nullptr; 221fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDiscardFunction Discard = nullptr; 222fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDestroyFunction Destroy = nullptr; 223fe6060f1SDimitry Andric }; 224fe6060f1SDimitry Andric 225fe6060f1SDimitry Andric static JITSymbolFlags toJITSymbolFlags(LLVMJITSymbolFlags F) { 226fe6060f1SDimitry Andric 227fe6060f1SDimitry Andric JITSymbolFlags JSF; 228fe6060f1SDimitry Andric 229fe6060f1SDimitry Andric if (F.GenericFlags & LLVMJITSymbolGenericFlagsExported) 230fe6060f1SDimitry Andric JSF |= JITSymbolFlags::Exported; 231fe6060f1SDimitry Andric if (F.GenericFlags & LLVMJITSymbolGenericFlagsWeak) 232fe6060f1SDimitry Andric JSF |= JITSymbolFlags::Weak; 233fe6060f1SDimitry Andric if (F.GenericFlags & LLVMJITSymbolGenericFlagsCallable) 234fe6060f1SDimitry Andric JSF |= JITSymbolFlags::Callable; 235fe6060f1SDimitry Andric if (F.GenericFlags & LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly) 236fe6060f1SDimitry Andric JSF |= JITSymbolFlags::MaterializationSideEffectsOnly; 237fe6060f1SDimitry Andric 238fe6060f1SDimitry Andric JSF.getTargetFlags() = F.TargetFlags; 239fe6060f1SDimitry Andric 240fe6060f1SDimitry Andric return JSF; 241fe6060f1SDimitry Andric } 242fe6060f1SDimitry Andric 243fe6060f1SDimitry Andric static LLVMJITSymbolFlags fromJITSymbolFlags(JITSymbolFlags JSF) { 244fe6060f1SDimitry Andric LLVMJITSymbolFlags F = {0, 0}; 245fe6060f1SDimitry Andric if (JSF & JITSymbolFlags::Exported) 246fe6060f1SDimitry Andric F.GenericFlags |= LLVMJITSymbolGenericFlagsExported; 247fe6060f1SDimitry Andric if (JSF & JITSymbolFlags::Weak) 248fe6060f1SDimitry Andric F.GenericFlags |= LLVMJITSymbolGenericFlagsWeak; 249fe6060f1SDimitry Andric if (JSF & JITSymbolFlags::Callable) 250fe6060f1SDimitry Andric F.GenericFlags |= LLVMJITSymbolGenericFlagsCallable; 251fe6060f1SDimitry Andric if (JSF & JITSymbolFlags::MaterializationSideEffectsOnly) 252fe6060f1SDimitry Andric F.GenericFlags |= LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly; 253fe6060f1SDimitry Andric 254fe6060f1SDimitry Andric F.TargetFlags = JSF.getTargetFlags(); 255fe6060f1SDimitry Andric 256fe6060f1SDimitry Andric return F; 257fe6060f1SDimitry Andric } 258fe6060f1SDimitry Andric 259fe6060f1SDimitry Andric static SymbolMap toSymbolMap(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) { 260fe6060f1SDimitry Andric SymbolMap SM; 261fe6060f1SDimitry Andric for (size_t I = 0; I != NumPairs; ++I) { 262fe6060f1SDimitry Andric JITSymbolFlags Flags = toJITSymbolFlags(Syms[I].Sym.Flags); 263fe6060f1SDimitry Andric SM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] = 264fe6060f1SDimitry Andric JITEvaluatedSymbol(Syms[I].Sym.Address, Flags); 265fe6060f1SDimitry Andric } 266fe6060f1SDimitry Andric return SM; 267fe6060f1SDimitry Andric } 268fe6060f1SDimitry Andric 269fe6060f1SDimitry Andric static SymbolDependenceMap 270fe6060f1SDimitry Andric toSymbolDependenceMap(LLVMOrcCDependenceMapPairs Pairs, size_t NumPairs) { 271fe6060f1SDimitry Andric SymbolDependenceMap SDM; 272fe6060f1SDimitry Andric for (size_t I = 0; I != NumPairs; ++I) { 273fe6060f1SDimitry Andric JITDylib *JD = unwrap(Pairs[I].JD); 274fe6060f1SDimitry Andric SymbolNameSet Names; 275fe6060f1SDimitry Andric 276fe6060f1SDimitry Andric for (size_t J = 0; J != Pairs[I].Names.Length; ++J) { 277fe6060f1SDimitry Andric auto Sym = Pairs[I].Names.Symbols[J]; 278fe6060f1SDimitry Andric Names.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Sym))); 279fe6060f1SDimitry Andric } 280fe6060f1SDimitry Andric SDM[JD] = Names; 281fe6060f1SDimitry Andric } 282fe6060f1SDimitry Andric return SDM; 283fe6060f1SDimitry Andric } 284fe6060f1SDimitry Andric 285fe6060f1SDimitry Andric } // end anonymous namespace 286fe6060f1SDimitry Andric 287e8d8bef9SDimitry Andric void LLVMOrcExecutionSessionSetErrorReporter( 288e8d8bef9SDimitry Andric LLVMOrcExecutionSessionRef ES, LLVMOrcErrorReporterFunction ReportError, 289e8d8bef9SDimitry Andric void *Ctx) { 290e8d8bef9SDimitry Andric unwrap(ES)->setErrorReporter( 291e8d8bef9SDimitry Andric [=](Error Err) { ReportError(Ctx, wrap(std::move(Err))); }); 292e8d8bef9SDimitry Andric } 293e8d8bef9SDimitry Andric 294e8d8bef9SDimitry Andric LLVMOrcSymbolStringPoolRef 295e8d8bef9SDimitry Andric LLVMOrcExecutionSessionGetSymbolStringPool(LLVMOrcExecutionSessionRef ES) { 296fe6060f1SDimitry Andric return wrap( 297fe6060f1SDimitry Andric unwrap(ES)->getExecutorProcessControl().getSymbolStringPool().get()); 298e8d8bef9SDimitry Andric } 299e8d8bef9SDimitry Andric 300e8d8bef9SDimitry Andric void LLVMOrcSymbolStringPoolClearDeadEntries(LLVMOrcSymbolStringPoolRef SSP) { 301e8d8bef9SDimitry Andric unwrap(SSP)->clearDeadEntries(); 302e8d8bef9SDimitry Andric } 303e8d8bef9SDimitry Andric 3045ffd83dbSDimitry Andric LLVMOrcSymbolStringPoolEntryRef 3055ffd83dbSDimitry Andric LLVMOrcExecutionSessionIntern(LLVMOrcExecutionSessionRef ES, const char *Name) { 3065ffd83dbSDimitry Andric return wrap( 307fe6060f1SDimitry Andric OrcV2CAPIHelper::moveFromSymbolStringPtr(unwrap(ES)->intern(Name))); 3085ffd83dbSDimitry Andric } 3095ffd83dbSDimitry Andric 310e8d8bef9SDimitry Andric void LLVMOrcRetainSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) { 311e8d8bef9SDimitry Andric OrcV2CAPIHelper::retainPoolEntry(unwrap(S)); 312e8d8bef9SDimitry Andric } 313e8d8bef9SDimitry Andric 3145ffd83dbSDimitry Andric void LLVMOrcReleaseSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) { 3155ffd83dbSDimitry Andric OrcV2CAPIHelper::releasePoolEntry(unwrap(S)); 3165ffd83dbSDimitry Andric } 3175ffd83dbSDimitry Andric 318e8d8bef9SDimitry Andric const char *LLVMOrcSymbolStringPoolEntryStr(LLVMOrcSymbolStringPoolEntryRef S) { 319e8d8bef9SDimitry Andric return unwrap(S)->getKey().data(); 320e8d8bef9SDimitry Andric } 321e8d8bef9SDimitry Andric 322e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef 323e8d8bef9SDimitry Andric LLVMOrcJITDylibCreateResourceTracker(LLVMOrcJITDylibRef JD) { 324e8d8bef9SDimitry Andric auto RT = unwrap(JD)->createResourceTracker(); 325e8d8bef9SDimitry Andric // Retain the pointer for the C API client. 326e8d8bef9SDimitry Andric RT->Retain(); 327e8d8bef9SDimitry Andric return wrap(RT.get()); 328e8d8bef9SDimitry Andric } 329e8d8bef9SDimitry Andric 330e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef 331e8d8bef9SDimitry Andric LLVMOrcJITDylibGetDefaultResourceTracker(LLVMOrcJITDylibRef JD) { 332e8d8bef9SDimitry Andric auto RT = unwrap(JD)->getDefaultResourceTracker(); 333e8d8bef9SDimitry Andric // Retain the pointer for the C API client. 334e8d8bef9SDimitry Andric return wrap(RT.get()); 335e8d8bef9SDimitry Andric } 336e8d8bef9SDimitry Andric 337e8d8bef9SDimitry Andric void LLVMOrcReleaseResourceTracker(LLVMOrcResourceTrackerRef RT) { 338e8d8bef9SDimitry Andric ResourceTrackerSP TmpRT(unwrap(RT)); 339e8d8bef9SDimitry Andric TmpRT->Release(); 340e8d8bef9SDimitry Andric } 341e8d8bef9SDimitry Andric 342e8d8bef9SDimitry Andric void LLVMOrcResourceTrackerTransferTo(LLVMOrcResourceTrackerRef SrcRT, 343e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef DstRT) { 344e8d8bef9SDimitry Andric ResourceTrackerSP TmpRT(unwrap(SrcRT)); 345e8d8bef9SDimitry Andric TmpRT->transferTo(*unwrap(DstRT)); 346e8d8bef9SDimitry Andric } 347e8d8bef9SDimitry Andric 348e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcResourceTrackerRemove(LLVMOrcResourceTrackerRef RT) { 349e8d8bef9SDimitry Andric ResourceTrackerSP TmpRT(unwrap(RT)); 350e8d8bef9SDimitry Andric return wrap(TmpRT->remove()); 351e8d8bef9SDimitry Andric } 352e8d8bef9SDimitry Andric 353e8d8bef9SDimitry Andric void LLVMOrcDisposeDefinitionGenerator(LLVMOrcDefinitionGeneratorRef DG) { 354e8d8bef9SDimitry Andric std::unique_ptr<DefinitionGenerator> TmpDG(unwrap(DG)); 355e8d8bef9SDimitry Andric } 356e8d8bef9SDimitry Andric 357e8d8bef9SDimitry Andric void LLVMOrcDisposeMaterializationUnit(LLVMOrcMaterializationUnitRef MU) { 358e8d8bef9SDimitry Andric std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU)); 359e8d8bef9SDimitry Andric } 360e8d8bef9SDimitry Andric 361fe6060f1SDimitry Andric LLVMOrcMaterializationUnitRef LLVMOrcCreateCustomMaterializationUnit( 362fe6060f1SDimitry Andric const char *Name, void *Ctx, LLVMOrcCSymbolFlagsMapPairs Syms, 363fe6060f1SDimitry Andric size_t NumSyms, LLVMOrcSymbolStringPoolEntryRef InitSym, 364fe6060f1SDimitry Andric LLVMOrcMaterializationUnitMaterializeFunction Materialize, 365fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDiscardFunction Discard, 366fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDestroyFunction Destroy) { 367fe6060f1SDimitry Andric SymbolFlagsMap SFM; 368fe6060f1SDimitry Andric for (size_t I = 0; I != NumSyms; ++I) 369fe6060f1SDimitry Andric SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] = 370fe6060f1SDimitry Andric toJITSymbolFlags(Syms[I].Flags); 371e8d8bef9SDimitry Andric 372fe6060f1SDimitry Andric auto IS = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(InitSym)); 373e8d8bef9SDimitry Andric 374fe6060f1SDimitry Andric return wrap(new OrcCAPIMaterializationUnit( 375fe6060f1SDimitry Andric Name, std::move(SFM), std::move(IS), Ctx, Materialize, Discard, Destroy)); 376e8d8bef9SDimitry Andric } 377e8d8bef9SDimitry Andric 378fe6060f1SDimitry Andric LLVMOrcMaterializationUnitRef 379fe6060f1SDimitry Andric LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) { 380fe6060f1SDimitry Andric SymbolMap SM = toSymbolMap(Syms, NumPairs); 381e8d8bef9SDimitry Andric return wrap(absoluteSymbols(std::move(SM)).release()); 382e8d8bef9SDimitry Andric } 383e8d8bef9SDimitry Andric 384fe6060f1SDimitry Andric LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports( 385fe6060f1SDimitry Andric LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM, 386fe6060f1SDimitry Andric LLVMOrcJITDylibRef SourceJD, LLVMOrcCSymbolAliasMapPairs CallableAliases, 387fe6060f1SDimitry Andric size_t NumPairs) { 388fe6060f1SDimitry Andric 389fe6060f1SDimitry Andric SymbolAliasMap SAM; 390fe6060f1SDimitry Andric for (size_t I = 0; I != NumPairs; ++I) { 391fe6060f1SDimitry Andric auto pair = CallableAliases[I]; 392fe6060f1SDimitry Andric JITSymbolFlags Flags = toJITSymbolFlags(pair.Entry.Flags); 393fe6060f1SDimitry Andric SymbolStringPtr Name = 394fe6060f1SDimitry Andric OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Entry.Name)); 395fe6060f1SDimitry Andric SAM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Name))] = 396fe6060f1SDimitry Andric SymbolAliasMapEntry(Name, Flags); 397fe6060f1SDimitry Andric } 398fe6060f1SDimitry Andric 399fe6060f1SDimitry Andric return wrap(lazyReexports(*unwrap(LCTM), *unwrap(ISM), *unwrap(SourceJD), 400fe6060f1SDimitry Andric std::move(SAM)) 401fe6060f1SDimitry Andric .release()); 402fe6060f1SDimitry Andric } 403fe6060f1SDimitry Andric 404fe6060f1SDimitry Andric void LLVMOrcDisposeMaterializationResponsibility( 405fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 406fe6060f1SDimitry Andric std::unique_ptr<MaterializationResponsibility> TmpMR(unwrap(MR)); 407fe6060f1SDimitry Andric } 408fe6060f1SDimitry Andric 409fe6060f1SDimitry Andric LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib( 410fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 411fe6060f1SDimitry Andric return wrap(&unwrap(MR)->getTargetJITDylib()); 412fe6060f1SDimitry Andric } 413fe6060f1SDimitry Andric 414fe6060f1SDimitry Andric LLVMOrcExecutionSessionRef 415fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityGetExecutionSession( 416fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 417fe6060f1SDimitry Andric return wrap(&unwrap(MR)->getExecutionSession()); 418fe6060f1SDimitry Andric } 419fe6060f1SDimitry Andric 420fe6060f1SDimitry Andric LLVMOrcCSymbolFlagsMapPairs LLVMOrcMaterializationResponsibilityGetSymbols( 421fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, size_t *NumPairs) { 422fe6060f1SDimitry Andric 423fe6060f1SDimitry Andric auto Symbols = unwrap(MR)->getSymbols(); 424fe6060f1SDimitry Andric LLVMOrcCSymbolFlagsMapPairs Result = static_cast<LLVMOrcCSymbolFlagsMapPairs>( 425fe6060f1SDimitry Andric safe_malloc(Symbols.size() * sizeof(LLVMOrcCSymbolFlagsMapPair))); 426fe6060f1SDimitry Andric size_t I = 0; 427fe6060f1SDimitry Andric for (auto const &pair : Symbols) { 428fe6060f1SDimitry Andric auto Name = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(pair.first)); 429fe6060f1SDimitry Andric auto Flags = pair.second; 430fe6060f1SDimitry Andric Result[I] = {Name, fromJITSymbolFlags(Flags)}; 431fe6060f1SDimitry Andric I++; 432fe6060f1SDimitry Andric } 433fe6060f1SDimitry Andric *NumPairs = Symbols.size(); 434fe6060f1SDimitry Andric return Result; 435fe6060f1SDimitry Andric } 436fe6060f1SDimitry Andric 437fe6060f1SDimitry Andric void LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs) { 438fe6060f1SDimitry Andric free(Pairs); 439fe6060f1SDimitry Andric } 440fe6060f1SDimitry Andric 441fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef 442fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityGetInitializerSymbol( 443fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 444fe6060f1SDimitry Andric auto Sym = unwrap(MR)->getInitializerSymbol(); 445fe6060f1SDimitry Andric return wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Sym)); 446fe6060f1SDimitry Andric } 447fe6060f1SDimitry Andric 448fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef * 449fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityGetRequestedSymbols( 450fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols) { 451fe6060f1SDimitry Andric 452fe6060f1SDimitry Andric auto Symbols = unwrap(MR)->getRequestedSymbols(); 453fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef *Result = 454fe6060f1SDimitry Andric static_cast<LLVMOrcSymbolStringPoolEntryRef *>(safe_malloc( 455fe6060f1SDimitry Andric Symbols.size() * sizeof(LLVMOrcSymbolStringPoolEntryRef))); 456fe6060f1SDimitry Andric size_t I = 0; 457fe6060f1SDimitry Andric for (auto &Name : Symbols) { 458fe6060f1SDimitry Andric Result[I] = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)); 459fe6060f1SDimitry Andric I++; 460fe6060f1SDimitry Andric } 461fe6060f1SDimitry Andric *NumSymbols = Symbols.size(); 462fe6060f1SDimitry Andric return Result; 463fe6060f1SDimitry Andric } 464fe6060f1SDimitry Andric 465fe6060f1SDimitry Andric void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols) { 466fe6060f1SDimitry Andric free(Symbols); 467fe6060f1SDimitry Andric } 468fe6060f1SDimitry Andric 469fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved( 470fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols, 471fe6060f1SDimitry Andric size_t NumPairs) { 472fe6060f1SDimitry Andric SymbolMap SM = toSymbolMap(Symbols, NumPairs); 473fe6060f1SDimitry Andric return wrap(unwrap(MR)->notifyResolved(std::move(SM))); 474fe6060f1SDimitry Andric } 475fe6060f1SDimitry Andric 476fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted( 477fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 478fe6060f1SDimitry Andric return wrap(unwrap(MR)->notifyEmitted()); 479fe6060f1SDimitry Andric } 480fe6060f1SDimitry Andric 481fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing( 482fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 483fe6060f1SDimitry Andric LLVMOrcCSymbolFlagsMapPairs Syms, size_t NumSyms) { 484fe6060f1SDimitry Andric SymbolFlagsMap SFM; 485fe6060f1SDimitry Andric for (size_t I = 0; I != NumSyms; ++I) 486fe6060f1SDimitry Andric SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] = 487fe6060f1SDimitry Andric toJITSymbolFlags(Syms[I].Flags); 488fe6060f1SDimitry Andric 489fe6060f1SDimitry Andric return wrap(unwrap(MR)->defineMaterializing(std::move(SFM))); 490fe6060f1SDimitry Andric } 491fe6060f1SDimitry Andric 492fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace( 493fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 494fe6060f1SDimitry Andric LLVMOrcMaterializationUnitRef MU) { 495fe6060f1SDimitry Andric std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU)); 496fe6060f1SDimitry Andric return wrap(unwrap(MR)->replace(std::move(TmpMU))); 497fe6060f1SDimitry Andric } 498fe6060f1SDimitry Andric 499fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate( 500fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 501fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols, 502fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef *Result) { 503fe6060f1SDimitry Andric SymbolNameSet Syms; 504fe6060f1SDimitry Andric for (size_t I = 0; I != NumSymbols; I++) { 505fe6060f1SDimitry Andric Syms.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Symbols[I]))); 506fe6060f1SDimitry Andric } 507fe6060f1SDimitry Andric auto OtherMR = unwrap(MR)->delegate(Syms); 508fe6060f1SDimitry Andric 509fe6060f1SDimitry Andric if (!OtherMR) { 510fe6060f1SDimitry Andric return wrap(OtherMR.takeError()); 511fe6060f1SDimitry Andric } 512fe6060f1SDimitry Andric *Result = wrap(OtherMR->release()); 513fe6060f1SDimitry Andric return LLVMErrorSuccess; 514fe6060f1SDimitry Andric } 515fe6060f1SDimitry Andric 516fe6060f1SDimitry Andric void LLVMOrcMaterializationResponsibilityAddDependencies( 517fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 518fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef Name, 519fe6060f1SDimitry Andric LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) { 520fe6060f1SDimitry Andric 521fe6060f1SDimitry Andric SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs); 522fe6060f1SDimitry Andric auto Sym = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Name)); 523fe6060f1SDimitry Andric unwrap(MR)->addDependencies(Sym, SDM); 524fe6060f1SDimitry Andric } 525fe6060f1SDimitry Andric 526fe6060f1SDimitry Andric void LLVMOrcMaterializationResponsibilityAddDependenciesForAll( 527fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 528fe6060f1SDimitry Andric LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) { 529fe6060f1SDimitry Andric 530fe6060f1SDimitry Andric SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs); 531fe6060f1SDimitry Andric unwrap(MR)->addDependenciesForAll(SDM); 532fe6060f1SDimitry Andric } 533fe6060f1SDimitry Andric 534fe6060f1SDimitry Andric void LLVMOrcMaterializationResponsibilityFailMaterialization( 535fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 536fe6060f1SDimitry Andric unwrap(MR)->failMaterialization(); 537fe6060f1SDimitry Andric } 538fe6060f1SDimitry Andric 539fe6060f1SDimitry Andric void LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRLayer, 540fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 541fe6060f1SDimitry Andric LLVMOrcThreadSafeModuleRef TSM) { 542fe6060f1SDimitry Andric std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM)); 543fe6060f1SDimitry Andric unwrap(IRLayer)->emit( 544fe6060f1SDimitry Andric std::unique_ptr<MaterializationResponsibility>(unwrap(MR)), 545fe6060f1SDimitry Andric std::move(*TmpTSM)); 546fe6060f1SDimitry Andric } 547fe6060f1SDimitry Andric 548e8d8bef9SDimitry Andric LLVMOrcJITDylibRef 549e8d8bef9SDimitry Andric LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES, 550e8d8bef9SDimitry Andric const char *Name) { 551e8d8bef9SDimitry Andric return wrap(&unwrap(ES)->createBareJITDylib(Name)); 552e8d8bef9SDimitry Andric } 553e8d8bef9SDimitry Andric 554e8d8bef9SDimitry Andric LLVMErrorRef 555e8d8bef9SDimitry Andric LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES, 556e8d8bef9SDimitry Andric LLVMOrcJITDylibRef *Result, 557e8d8bef9SDimitry Andric const char *Name) { 558e8d8bef9SDimitry Andric auto JD = unwrap(ES)->createJITDylib(Name); 559e8d8bef9SDimitry Andric if (!JD) 560e8d8bef9SDimitry Andric return wrap(JD.takeError()); 561e8d8bef9SDimitry Andric *Result = wrap(&*JD); 562e8d8bef9SDimitry Andric return LLVMErrorSuccess; 563e8d8bef9SDimitry Andric } 564e8d8bef9SDimitry Andric 565e8d8bef9SDimitry Andric LLVMOrcJITDylibRef 566e8d8bef9SDimitry Andric LLVMOrcExecutionSessionGetJITDylibByName(LLVMOrcExecutionSessionRef ES, 567e8d8bef9SDimitry Andric const char *Name) { 568e8d8bef9SDimitry Andric return wrap(unwrap(ES)->getJITDylibByName(Name)); 569e8d8bef9SDimitry Andric } 570e8d8bef9SDimitry Andric 571e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcJITDylibDefine(LLVMOrcJITDylibRef JD, 572e8d8bef9SDimitry Andric LLVMOrcMaterializationUnitRef MU) { 573e8d8bef9SDimitry Andric std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU)); 574e8d8bef9SDimitry Andric 575e8d8bef9SDimitry Andric if (auto Err = unwrap(JD)->define(TmpMU)) { 576e8d8bef9SDimitry Andric TmpMU.release(); 577e8d8bef9SDimitry Andric return wrap(std::move(Err)); 578e8d8bef9SDimitry Andric } 579e8d8bef9SDimitry Andric return LLVMErrorSuccess; 580e8d8bef9SDimitry Andric } 581e8d8bef9SDimitry Andric 582e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcJITDylibClear(LLVMOrcJITDylibRef JD) { 583e8d8bef9SDimitry Andric return wrap(unwrap(JD)->clear()); 5845ffd83dbSDimitry Andric } 5855ffd83dbSDimitry Andric 5865ffd83dbSDimitry Andric void LLVMOrcJITDylibAddGenerator(LLVMOrcJITDylibRef JD, 587e8d8bef9SDimitry Andric LLVMOrcDefinitionGeneratorRef DG) { 588e8d8bef9SDimitry Andric unwrap(JD)->addGenerator(std::unique_ptr<DefinitionGenerator>(unwrap(DG))); 589e8d8bef9SDimitry Andric } 590e8d8bef9SDimitry Andric 591e8d8bef9SDimitry Andric LLVMOrcDefinitionGeneratorRef LLVMOrcCreateCustomCAPIDefinitionGenerator( 592e8d8bef9SDimitry Andric LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction F, void *Ctx) { 593e8d8bef9SDimitry Andric auto DG = std::make_unique<CAPIDefinitionGenerator>(Ctx, F); 594e8d8bef9SDimitry Andric return wrap(DG.release()); 5955ffd83dbSDimitry Andric } 5965ffd83dbSDimitry Andric 5975ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess( 598e8d8bef9SDimitry Andric LLVMOrcDefinitionGeneratorRef *Result, char GlobalPrefix, 5995ffd83dbSDimitry Andric LLVMOrcSymbolPredicate Filter, void *FilterCtx) { 6005ffd83dbSDimitry Andric assert(Result && "Result can not be null"); 6015ffd83dbSDimitry Andric assert((Filter || !FilterCtx) && 6025ffd83dbSDimitry Andric "if Filter is null then FilterCtx must also be null"); 6035ffd83dbSDimitry Andric 6045ffd83dbSDimitry Andric DynamicLibrarySearchGenerator::SymbolPredicate Pred; 6055ffd83dbSDimitry Andric if (Filter) 6065ffd83dbSDimitry Andric Pred = [=](const SymbolStringPtr &Name) -> bool { 607e8d8bef9SDimitry Andric return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name))); 6085ffd83dbSDimitry Andric }; 6095ffd83dbSDimitry Andric 6105ffd83dbSDimitry Andric auto ProcessSymsGenerator = 6115ffd83dbSDimitry Andric DynamicLibrarySearchGenerator::GetForCurrentProcess(GlobalPrefix, Pred); 6125ffd83dbSDimitry Andric 6135ffd83dbSDimitry Andric if (!ProcessSymsGenerator) { 614*04eeddc0SDimitry Andric *Result = nullptr; 6155ffd83dbSDimitry Andric return wrap(ProcessSymsGenerator.takeError()); 6165ffd83dbSDimitry Andric } 6175ffd83dbSDimitry Andric 6185ffd83dbSDimitry Andric *Result = wrap(ProcessSymsGenerator->release()); 6195ffd83dbSDimitry Andric return LLVMErrorSuccess; 6205ffd83dbSDimitry Andric } 6215ffd83dbSDimitry Andric 622349cc55cSDimitry Andric LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForPath( 623349cc55cSDimitry Andric LLVMOrcDefinitionGeneratorRef *Result, const char *FileName, 624349cc55cSDimitry Andric char GlobalPrefix, LLVMOrcSymbolPredicate Filter, void *FilterCtx) { 625349cc55cSDimitry Andric assert(Result && "Result can not be null"); 626349cc55cSDimitry Andric assert(FileName && "FileName can not be null"); 627349cc55cSDimitry Andric assert((Filter || !FilterCtx) && 628349cc55cSDimitry Andric "if Filter is null then FilterCtx must also be null"); 629349cc55cSDimitry Andric 630349cc55cSDimitry Andric DynamicLibrarySearchGenerator::SymbolPredicate Pred; 631349cc55cSDimitry Andric if (Filter) 632349cc55cSDimitry Andric Pred = [=](const SymbolStringPtr &Name) -> bool { 633349cc55cSDimitry Andric return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name))); 634349cc55cSDimitry Andric }; 635349cc55cSDimitry Andric 636349cc55cSDimitry Andric auto LibrarySymsGenerator = 637349cc55cSDimitry Andric DynamicLibrarySearchGenerator::Load(FileName, GlobalPrefix, Pred); 638349cc55cSDimitry Andric 639349cc55cSDimitry Andric if (!LibrarySymsGenerator) { 640*04eeddc0SDimitry Andric *Result = nullptr; 641349cc55cSDimitry Andric return wrap(LibrarySymsGenerator.takeError()); 642349cc55cSDimitry Andric } 643349cc55cSDimitry Andric 644349cc55cSDimitry Andric *Result = wrap(LibrarySymsGenerator->release()); 645349cc55cSDimitry Andric return LLVMErrorSuccess; 646349cc55cSDimitry Andric } 647349cc55cSDimitry Andric 648349cc55cSDimitry Andric LLVMErrorRef LLVMOrcCreateStaticLibrarySearchGeneratorForPath( 649349cc55cSDimitry Andric LLVMOrcDefinitionGeneratorRef *Result, LLVMOrcObjectLayerRef ObjLayer, 650349cc55cSDimitry Andric const char *FileName, const char *TargetTriple) { 651349cc55cSDimitry Andric assert(Result && "Result can not be null"); 652349cc55cSDimitry Andric assert(FileName && "Filename can not be null"); 653349cc55cSDimitry Andric assert(ObjLayer && "ObjectLayer can not be null"); 654349cc55cSDimitry Andric 655349cc55cSDimitry Andric if (TargetTriple) { 656349cc55cSDimitry Andric auto TT = Triple(TargetTriple); 657349cc55cSDimitry Andric auto LibrarySymsGenerator = 658349cc55cSDimitry Andric StaticLibraryDefinitionGenerator::Load(*unwrap(ObjLayer), FileName, TT); 659349cc55cSDimitry Andric if (!LibrarySymsGenerator) { 660*04eeddc0SDimitry Andric *Result = nullptr; 661349cc55cSDimitry Andric return wrap(LibrarySymsGenerator.takeError()); 662349cc55cSDimitry Andric } 663349cc55cSDimitry Andric *Result = wrap(LibrarySymsGenerator->release()); 664349cc55cSDimitry Andric return LLVMErrorSuccess; 665349cc55cSDimitry Andric } else { 666349cc55cSDimitry Andric auto LibrarySymsGenerator = 667349cc55cSDimitry Andric StaticLibraryDefinitionGenerator::Load(*unwrap(ObjLayer), FileName); 668349cc55cSDimitry Andric if (!LibrarySymsGenerator) { 669*04eeddc0SDimitry Andric *Result = nullptr; 670349cc55cSDimitry Andric return wrap(LibrarySymsGenerator.takeError()); 671349cc55cSDimitry Andric } 672349cc55cSDimitry Andric *Result = wrap(LibrarySymsGenerator->release()); 673349cc55cSDimitry Andric return LLVMErrorSuccess; 674349cc55cSDimitry Andric } 675349cc55cSDimitry Andric } 676349cc55cSDimitry Andric 6775ffd83dbSDimitry Andric LLVMOrcThreadSafeContextRef LLVMOrcCreateNewThreadSafeContext(void) { 6785ffd83dbSDimitry Andric return wrap(new ThreadSafeContext(std::make_unique<LLVMContext>())); 6795ffd83dbSDimitry Andric } 6805ffd83dbSDimitry Andric 6815ffd83dbSDimitry Andric LLVMContextRef 6825ffd83dbSDimitry Andric LLVMOrcThreadSafeContextGetContext(LLVMOrcThreadSafeContextRef TSCtx) { 6835ffd83dbSDimitry Andric return wrap(unwrap(TSCtx)->getContext()); 6845ffd83dbSDimitry Andric } 6855ffd83dbSDimitry Andric 6865ffd83dbSDimitry Andric void LLVMOrcDisposeThreadSafeContext(LLVMOrcThreadSafeContextRef TSCtx) { 6875ffd83dbSDimitry Andric delete unwrap(TSCtx); 6885ffd83dbSDimitry Andric } 6895ffd83dbSDimitry Andric 690fe6060f1SDimitry Andric LLVMErrorRef 691fe6060f1SDimitry Andric LLVMOrcThreadSafeModuleWithModuleDo(LLVMOrcThreadSafeModuleRef TSM, 692fe6060f1SDimitry Andric LLVMOrcGenericIRModuleOperationFunction F, 693fe6060f1SDimitry Andric void *Ctx) { 694fe6060f1SDimitry Andric return wrap(unwrap(TSM)->withModuleDo( 695fe6060f1SDimitry Andric [&](Module &M) { return unwrap(F(Ctx, wrap(&M))); })); 696fe6060f1SDimitry Andric } 697fe6060f1SDimitry Andric 6985ffd83dbSDimitry Andric LLVMOrcThreadSafeModuleRef 6995ffd83dbSDimitry Andric LLVMOrcCreateNewThreadSafeModule(LLVMModuleRef M, 7005ffd83dbSDimitry Andric LLVMOrcThreadSafeContextRef TSCtx) { 7015ffd83dbSDimitry Andric return wrap( 7025ffd83dbSDimitry Andric new ThreadSafeModule(std::unique_ptr<Module>(unwrap(M)), *unwrap(TSCtx))); 7035ffd83dbSDimitry Andric } 7045ffd83dbSDimitry Andric 7055ffd83dbSDimitry Andric void LLVMOrcDisposeThreadSafeModule(LLVMOrcThreadSafeModuleRef TSM) { 7065ffd83dbSDimitry Andric delete unwrap(TSM); 7075ffd83dbSDimitry Andric } 7085ffd83dbSDimitry Andric 7095ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcJITTargetMachineBuilderDetectHost( 7105ffd83dbSDimitry Andric LLVMOrcJITTargetMachineBuilderRef *Result) { 7115ffd83dbSDimitry Andric assert(Result && "Result can not be null"); 7125ffd83dbSDimitry Andric 7135ffd83dbSDimitry Andric auto JTMB = JITTargetMachineBuilder::detectHost(); 7145ffd83dbSDimitry Andric if (!JTMB) { 715*04eeddc0SDimitry Andric Result = nullptr; 7165ffd83dbSDimitry Andric return wrap(JTMB.takeError()); 7175ffd83dbSDimitry Andric } 7185ffd83dbSDimitry Andric 7195ffd83dbSDimitry Andric *Result = wrap(new JITTargetMachineBuilder(std::move(*JTMB))); 7205ffd83dbSDimitry Andric return LLVMErrorSuccess; 7215ffd83dbSDimitry Andric } 7225ffd83dbSDimitry Andric 7235ffd83dbSDimitry Andric LLVMOrcJITTargetMachineBuilderRef 724e8d8bef9SDimitry Andric LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(LLVMTargetMachineRef TM) { 7255ffd83dbSDimitry Andric auto *TemplateTM = unwrap(TM); 7265ffd83dbSDimitry Andric 7275ffd83dbSDimitry Andric auto JTMB = 7285ffd83dbSDimitry Andric std::make_unique<JITTargetMachineBuilder>(TemplateTM->getTargetTriple()); 7295ffd83dbSDimitry Andric 7305ffd83dbSDimitry Andric (*JTMB) 7315ffd83dbSDimitry Andric .setCPU(TemplateTM->getTargetCPU().str()) 7325ffd83dbSDimitry Andric .setRelocationModel(TemplateTM->getRelocationModel()) 7335ffd83dbSDimitry Andric .setCodeModel(TemplateTM->getCodeModel()) 7345ffd83dbSDimitry Andric .setCodeGenOptLevel(TemplateTM->getOptLevel()) 7355ffd83dbSDimitry Andric .setFeatures(TemplateTM->getTargetFeatureString()) 7365ffd83dbSDimitry Andric .setOptions(TemplateTM->Options); 7375ffd83dbSDimitry Andric 7385ffd83dbSDimitry Andric LLVMDisposeTargetMachine(TM); 7395ffd83dbSDimitry Andric 7405ffd83dbSDimitry Andric return wrap(JTMB.release()); 7415ffd83dbSDimitry Andric } 7425ffd83dbSDimitry Andric 7435ffd83dbSDimitry Andric void LLVMOrcDisposeJITTargetMachineBuilder( 7445ffd83dbSDimitry Andric LLVMOrcJITTargetMachineBuilderRef JTMB) { 7455ffd83dbSDimitry Andric delete unwrap(JTMB); 7465ffd83dbSDimitry Andric } 7475ffd83dbSDimitry Andric 748fe6060f1SDimitry Andric char *LLVMOrcJITTargetMachineBuilderGetTargetTriple( 749fe6060f1SDimitry Andric LLVMOrcJITTargetMachineBuilderRef JTMB) { 750fe6060f1SDimitry Andric auto Tmp = unwrap(JTMB)->getTargetTriple().str(); 751fe6060f1SDimitry Andric char *TargetTriple = (char *)malloc(Tmp.size() + 1); 752fe6060f1SDimitry Andric strcpy(TargetTriple, Tmp.c_str()); 753fe6060f1SDimitry Andric return TargetTriple; 754fe6060f1SDimitry Andric } 755fe6060f1SDimitry Andric 756fe6060f1SDimitry Andric void LLVMOrcJITTargetMachineBuilderSetTargetTriple( 757fe6060f1SDimitry Andric LLVMOrcJITTargetMachineBuilderRef JTMB, const char *TargetTriple) { 758fe6060f1SDimitry Andric unwrap(JTMB)->getTargetTriple() = Triple(TargetTriple); 759fe6060f1SDimitry Andric } 760fe6060f1SDimitry Andric 761fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcObjectLayerAddObjectFile(LLVMOrcObjectLayerRef ObjLayer, 762fe6060f1SDimitry Andric LLVMOrcJITDylibRef JD, 763fe6060f1SDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 764fe6060f1SDimitry Andric return wrap(unwrap(ObjLayer)->add( 765fe6060f1SDimitry Andric *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)))); 766fe6060f1SDimitry Andric } 767fe6060f1SDimitry Andric 768fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcObjectLayerRef ObjLayer, 769fe6060f1SDimitry Andric LLVMOrcResourceTrackerRef RT, 770fe6060f1SDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 771fe6060f1SDimitry Andric return wrap( 772fe6060f1SDimitry Andric unwrap(ObjLayer)->add(ResourceTrackerSP(unwrap(RT)), 773fe6060f1SDimitry Andric std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)))); 774fe6060f1SDimitry Andric } 775fe6060f1SDimitry Andric 776fe6060f1SDimitry Andric void LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer, 777fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef R, 778fe6060f1SDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 779fe6060f1SDimitry Andric unwrap(ObjLayer)->emit( 780fe6060f1SDimitry Andric std::unique_ptr<MaterializationResponsibility>(unwrap(R)), 781fe6060f1SDimitry Andric std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))); 782fe6060f1SDimitry Andric } 783fe6060f1SDimitry Andric 784d409305fSDimitry Andric void LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer) { 785e8d8bef9SDimitry Andric delete unwrap(ObjLayer); 786e8d8bef9SDimitry Andric } 787e8d8bef9SDimitry Andric 788fe6060f1SDimitry Andric void LLVMOrcIRTransformLayerSetTransform( 789fe6060f1SDimitry Andric LLVMOrcIRTransformLayerRef IRTransformLayer, 790fe6060f1SDimitry Andric LLVMOrcIRTransformLayerTransformFunction TransformFunction, void *Ctx) { 791fe6060f1SDimitry Andric unwrap(IRTransformLayer) 792fe6060f1SDimitry Andric ->setTransform( 793fe6060f1SDimitry Andric [=](ThreadSafeModule TSM, 794fe6060f1SDimitry Andric MaterializationResponsibility &R) -> Expected<ThreadSafeModule> { 795fe6060f1SDimitry Andric LLVMOrcThreadSafeModuleRef TSMRef = 796fe6060f1SDimitry Andric wrap(new ThreadSafeModule(std::move(TSM))); 797fe6060f1SDimitry Andric if (LLVMErrorRef Err = TransformFunction(Ctx, &TSMRef, wrap(&R))) { 798fe6060f1SDimitry Andric assert(!TSMRef && "TSMRef was not reset to null on error"); 799fe6060f1SDimitry Andric return unwrap(Err); 800fe6060f1SDimitry Andric } 801fe6060f1SDimitry Andric return std::move(*unwrap(TSMRef)); 802fe6060f1SDimitry Andric }); 803fe6060f1SDimitry Andric } 804fe6060f1SDimitry Andric 805fe6060f1SDimitry Andric void LLVMOrcObjectTransformLayerSetTransform( 806fe6060f1SDimitry Andric LLVMOrcObjectTransformLayerRef ObjTransformLayer, 807fe6060f1SDimitry Andric LLVMOrcObjectTransformLayerTransformFunction TransformFunction, void *Ctx) { 808fe6060f1SDimitry Andric unwrap(ObjTransformLayer) 809fe6060f1SDimitry Andric ->setTransform([TransformFunction, Ctx](std::unique_ptr<MemoryBuffer> Obj) 810fe6060f1SDimitry Andric -> Expected<std::unique_ptr<MemoryBuffer>> { 811fe6060f1SDimitry Andric LLVMMemoryBufferRef ObjBuffer = wrap(Obj.release()); 812fe6060f1SDimitry Andric if (LLVMErrorRef Err = TransformFunction(Ctx, &ObjBuffer)) { 813fe6060f1SDimitry Andric assert(!ObjBuffer && "ObjBuffer was not reset to null on error"); 814fe6060f1SDimitry Andric return unwrap(Err); 815fe6060f1SDimitry Andric } 816fe6060f1SDimitry Andric return std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)); 817fe6060f1SDimitry Andric }); 818fe6060f1SDimitry Andric } 819fe6060f1SDimitry Andric 820fe6060f1SDimitry Andric LLVMOrcDumpObjectsRef LLVMOrcCreateDumpObjects(const char *DumpDir, 821fe6060f1SDimitry Andric const char *IdentifierOverride) { 822fe6060f1SDimitry Andric assert(DumpDir && "DumpDir should not be null"); 823fe6060f1SDimitry Andric assert(IdentifierOverride && "IdentifierOverride should not be null"); 824fe6060f1SDimitry Andric return wrap(new DumpObjects(DumpDir, IdentifierOverride)); 825fe6060f1SDimitry Andric } 826fe6060f1SDimitry Andric 827fe6060f1SDimitry Andric void LLVMOrcDisposeDumpObjects(LLVMOrcDumpObjectsRef DumpObjects) { 828fe6060f1SDimitry Andric delete unwrap(DumpObjects); 829fe6060f1SDimitry Andric } 830fe6060f1SDimitry Andric 831fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcDumpObjects_CallOperator(LLVMOrcDumpObjectsRef DumpObjects, 832fe6060f1SDimitry Andric LLVMMemoryBufferRef *ObjBuffer) { 833fe6060f1SDimitry Andric std::unique_ptr<MemoryBuffer> OB(unwrap(*ObjBuffer)); 834fe6060f1SDimitry Andric if (auto Result = (*unwrap(DumpObjects))(std::move(OB))) { 835fe6060f1SDimitry Andric *ObjBuffer = wrap(Result->release()); 836fe6060f1SDimitry Andric return LLVMErrorSuccess; 837fe6060f1SDimitry Andric } else { 838fe6060f1SDimitry Andric *ObjBuffer = nullptr; 839fe6060f1SDimitry Andric return wrap(Result.takeError()); 840fe6060f1SDimitry Andric } 841fe6060f1SDimitry Andric } 842fe6060f1SDimitry Andric 8435ffd83dbSDimitry Andric LLVMOrcLLJITBuilderRef LLVMOrcCreateLLJITBuilder(void) { 8445ffd83dbSDimitry Andric return wrap(new LLJITBuilder()); 8455ffd83dbSDimitry Andric } 8465ffd83dbSDimitry Andric 8475ffd83dbSDimitry Andric void LLVMOrcDisposeLLJITBuilder(LLVMOrcLLJITBuilderRef Builder) { 8485ffd83dbSDimitry Andric delete unwrap(Builder); 8495ffd83dbSDimitry Andric } 8505ffd83dbSDimitry Andric 8515ffd83dbSDimitry Andric void LLVMOrcLLJITBuilderSetJITTargetMachineBuilder( 8525ffd83dbSDimitry Andric LLVMOrcLLJITBuilderRef Builder, LLVMOrcJITTargetMachineBuilderRef JTMB) { 853fe6060f1SDimitry Andric unwrap(Builder)->setJITTargetMachineBuilder(std::move(*unwrap(JTMB))); 854fe6060f1SDimitry Andric LLVMOrcDisposeJITTargetMachineBuilder(JTMB); 8555ffd83dbSDimitry Andric } 8565ffd83dbSDimitry Andric 857e8d8bef9SDimitry Andric void LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator( 858e8d8bef9SDimitry Andric LLVMOrcLLJITBuilderRef Builder, 859e8d8bef9SDimitry Andric LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F, void *Ctx) { 860e8d8bef9SDimitry Andric unwrap(Builder)->setObjectLinkingLayerCreator( 861e8d8bef9SDimitry Andric [=](ExecutionSession &ES, const Triple &TT) { 862e8d8bef9SDimitry Andric auto TTStr = TT.str(); 863e8d8bef9SDimitry Andric return std::unique_ptr<ObjectLayer>( 864e8d8bef9SDimitry Andric unwrap(F(Ctx, wrap(&ES), TTStr.c_str()))); 865e8d8bef9SDimitry Andric }); 866e8d8bef9SDimitry Andric } 867e8d8bef9SDimitry Andric 8685ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcCreateLLJIT(LLVMOrcLLJITRef *Result, 8695ffd83dbSDimitry Andric LLVMOrcLLJITBuilderRef Builder) { 8705ffd83dbSDimitry Andric assert(Result && "Result can not be null"); 8715ffd83dbSDimitry Andric 8725ffd83dbSDimitry Andric if (!Builder) 8735ffd83dbSDimitry Andric Builder = LLVMOrcCreateLLJITBuilder(); 8745ffd83dbSDimitry Andric 8755ffd83dbSDimitry Andric auto J = unwrap(Builder)->create(); 8765ffd83dbSDimitry Andric LLVMOrcDisposeLLJITBuilder(Builder); 8775ffd83dbSDimitry Andric 8785ffd83dbSDimitry Andric if (!J) { 879*04eeddc0SDimitry Andric Result = nullptr; 8805ffd83dbSDimitry Andric return wrap(J.takeError()); 8815ffd83dbSDimitry Andric } 8825ffd83dbSDimitry Andric 8835ffd83dbSDimitry Andric *Result = wrap(J->release()); 8845ffd83dbSDimitry Andric return LLVMErrorSuccess; 8855ffd83dbSDimitry Andric } 8865ffd83dbSDimitry Andric 8875ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcDisposeLLJIT(LLVMOrcLLJITRef J) { 8885ffd83dbSDimitry Andric delete unwrap(J); 8895ffd83dbSDimitry Andric return LLVMErrorSuccess; 8905ffd83dbSDimitry Andric } 8915ffd83dbSDimitry Andric 8925ffd83dbSDimitry Andric LLVMOrcExecutionSessionRef LLVMOrcLLJITGetExecutionSession(LLVMOrcLLJITRef J) { 8935ffd83dbSDimitry Andric return wrap(&unwrap(J)->getExecutionSession()); 8945ffd83dbSDimitry Andric } 8955ffd83dbSDimitry Andric 8965ffd83dbSDimitry Andric LLVMOrcJITDylibRef LLVMOrcLLJITGetMainJITDylib(LLVMOrcLLJITRef J) { 8975ffd83dbSDimitry Andric return wrap(&unwrap(J)->getMainJITDylib()); 8985ffd83dbSDimitry Andric } 8995ffd83dbSDimitry Andric 9005ffd83dbSDimitry Andric const char *LLVMOrcLLJITGetTripleString(LLVMOrcLLJITRef J) { 9015ffd83dbSDimitry Andric return unwrap(J)->getTargetTriple().str().c_str(); 9025ffd83dbSDimitry Andric } 9035ffd83dbSDimitry Andric 9045ffd83dbSDimitry Andric char LLVMOrcLLJITGetGlobalPrefix(LLVMOrcLLJITRef J) { 9055ffd83dbSDimitry Andric return unwrap(J)->getDataLayout().getGlobalPrefix(); 9065ffd83dbSDimitry Andric } 9075ffd83dbSDimitry Andric 9085ffd83dbSDimitry Andric LLVMOrcSymbolStringPoolEntryRef 9095ffd83dbSDimitry Andric LLVMOrcLLJITMangleAndIntern(LLVMOrcLLJITRef J, const char *UnmangledName) { 910fe6060f1SDimitry Andric return wrap(OrcV2CAPIHelper::moveFromSymbolStringPtr( 9115ffd83dbSDimitry Andric unwrap(J)->mangleAndIntern(UnmangledName))); 9125ffd83dbSDimitry Andric } 9135ffd83dbSDimitry Andric 9145ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcLLJITAddObjectFile(LLVMOrcLLJITRef J, LLVMOrcJITDylibRef JD, 9155ffd83dbSDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 9165ffd83dbSDimitry Andric return wrap(unwrap(J)->addObjectFile( 9175ffd83dbSDimitry Andric *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)))); 9185ffd83dbSDimitry Andric } 9195ffd83dbSDimitry Andric 920e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcLLJITRef J, 921e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef RT, 922e8d8bef9SDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 923e8d8bef9SDimitry Andric return wrap(unwrap(J)->addObjectFile( 924e8d8bef9SDimitry Andric ResourceTrackerSP(unwrap(RT)), 925e8d8bef9SDimitry Andric std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)))); 926e8d8bef9SDimitry Andric } 927e8d8bef9SDimitry Andric 9285ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcLLJITAddLLVMIRModule(LLVMOrcLLJITRef J, 9295ffd83dbSDimitry Andric LLVMOrcJITDylibRef JD, 9305ffd83dbSDimitry Andric LLVMOrcThreadSafeModuleRef TSM) { 931e8d8bef9SDimitry Andric std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM)); 932e8d8bef9SDimitry Andric return wrap(unwrap(J)->addIRModule(*unwrap(JD), std::move(*TmpTSM))); 933e8d8bef9SDimitry Andric } 934e8d8bef9SDimitry Andric 935e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcLLJITAddLLVMIRModuleWithRT(LLVMOrcLLJITRef J, 936e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef RT, 937e8d8bef9SDimitry Andric LLVMOrcThreadSafeModuleRef TSM) { 938e8d8bef9SDimitry Andric std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM)); 939e8d8bef9SDimitry Andric return wrap(unwrap(J)->addIRModule(ResourceTrackerSP(unwrap(RT)), 940e8d8bef9SDimitry Andric std::move(*TmpTSM))); 9415ffd83dbSDimitry Andric } 9425ffd83dbSDimitry Andric 9435ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcLLJITLookup(LLVMOrcLLJITRef J, 9445ffd83dbSDimitry Andric LLVMOrcJITTargetAddress *Result, 9455ffd83dbSDimitry Andric const char *Name) { 9465ffd83dbSDimitry Andric assert(Result && "Result can not be null"); 9475ffd83dbSDimitry Andric 9485ffd83dbSDimitry Andric auto Sym = unwrap(J)->lookup(Name); 9495ffd83dbSDimitry Andric if (!Sym) { 9505ffd83dbSDimitry Andric *Result = 0; 9515ffd83dbSDimitry Andric return wrap(Sym.takeError()); 9525ffd83dbSDimitry Andric } 9535ffd83dbSDimitry Andric 9545ffd83dbSDimitry Andric *Result = Sym->getAddress(); 9555ffd83dbSDimitry Andric return LLVMErrorSuccess; 9565ffd83dbSDimitry Andric } 957e8d8bef9SDimitry Andric 958fe6060f1SDimitry Andric LLVMOrcObjectLayerRef LLVMOrcLLJITGetObjLinkingLayer(LLVMOrcLLJITRef J) { 959fe6060f1SDimitry Andric return wrap(&unwrap(J)->getObjLinkingLayer()); 960fe6060f1SDimitry Andric } 961fe6060f1SDimitry Andric 962fe6060f1SDimitry Andric LLVMOrcObjectTransformLayerRef 963fe6060f1SDimitry Andric LLVMOrcLLJITGetObjTransformLayer(LLVMOrcLLJITRef J) { 964fe6060f1SDimitry Andric return wrap(&unwrap(J)->getObjTransformLayer()); 965fe6060f1SDimitry Andric } 966fe6060f1SDimitry Andric 967e8d8bef9SDimitry Andric LLVMOrcObjectLayerRef 968e8d8bef9SDimitry Andric LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager( 969e8d8bef9SDimitry Andric LLVMOrcExecutionSessionRef ES) { 970e8d8bef9SDimitry Andric assert(ES && "ES must not be null"); 971e8d8bef9SDimitry Andric return wrap(new RTDyldObjectLinkingLayer( 972e8d8bef9SDimitry Andric *unwrap(ES), [] { return std::make_unique<SectionMemoryManager>(); })); 973e8d8bef9SDimitry Andric } 974e8d8bef9SDimitry Andric 975e8d8bef9SDimitry Andric void LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener( 976e8d8bef9SDimitry Andric LLVMOrcObjectLayerRef RTDyldObjLinkingLayer, 977e8d8bef9SDimitry Andric LLVMJITEventListenerRef Listener) { 978e8d8bef9SDimitry Andric assert(RTDyldObjLinkingLayer && "RTDyldObjLinkingLayer must not be null"); 979e8d8bef9SDimitry Andric assert(Listener && "Listener must not be null"); 980e8d8bef9SDimitry Andric reinterpret_cast<RTDyldObjectLinkingLayer *>(unwrap(RTDyldObjLinkingLayer)) 981e8d8bef9SDimitry Andric ->registerJITEventListener(*unwrap(Listener)); 982e8d8bef9SDimitry Andric } 983fe6060f1SDimitry Andric 984fe6060f1SDimitry Andric LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J) { 985fe6060f1SDimitry Andric return wrap(&unwrap(J)->getIRTransformLayer()); 986fe6060f1SDimitry Andric } 987fe6060f1SDimitry Andric 988fe6060f1SDimitry Andric const char *LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J) { 989fe6060f1SDimitry Andric return unwrap(J)->getDataLayout().getStringRepresentation().c_str(); 990fe6060f1SDimitry Andric } 991fe6060f1SDimitry Andric 992fe6060f1SDimitry Andric LLVMOrcIndirectStubsManagerRef 993fe6060f1SDimitry Andric LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple) { 994fe6060f1SDimitry Andric auto builder = createLocalIndirectStubsManagerBuilder(Triple(TargetTriple)); 995fe6060f1SDimitry Andric return wrap(builder().release()); 996fe6060f1SDimitry Andric } 997fe6060f1SDimitry Andric 998fe6060f1SDimitry Andric void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM) { 999fe6060f1SDimitry Andric std::unique_ptr<IndirectStubsManager> TmpISM(unwrap(ISM)); 1000fe6060f1SDimitry Andric } 1001fe6060f1SDimitry Andric 1002fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager( 1003fe6060f1SDimitry Andric const char *TargetTriple, LLVMOrcExecutionSessionRef ES, 1004fe6060f1SDimitry Andric LLVMOrcJITTargetAddress ErrorHandlerAddr, 1005fe6060f1SDimitry Andric LLVMOrcLazyCallThroughManagerRef *Result) { 1006fe6060f1SDimitry Andric auto LCTM = createLocalLazyCallThroughManager(Triple(TargetTriple), 1007fe6060f1SDimitry Andric *unwrap(ES), ErrorHandlerAddr); 1008fe6060f1SDimitry Andric 1009fe6060f1SDimitry Andric if (!LCTM) 1010fe6060f1SDimitry Andric return wrap(LCTM.takeError()); 1011fe6060f1SDimitry Andric *Result = wrap(LCTM->release()); 1012fe6060f1SDimitry Andric return LLVMErrorSuccess; 1013fe6060f1SDimitry Andric } 1014fe6060f1SDimitry Andric 1015fe6060f1SDimitry Andric void LLVMOrcDisposeLazyCallThroughManager( 1016fe6060f1SDimitry Andric LLVMOrcLazyCallThroughManagerRef LCM) { 1017fe6060f1SDimitry Andric std::unique_ptr<LazyCallThroughManager> TmpLCM(unwrap(LCM)); 1018fe6060f1SDimitry Andric } 1019