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 109fe6060f1SDimitry Andric namespace { 110fe6060f1SDimitry Andric 111fe6060f1SDimitry Andric class OrcCAPIMaterializationUnit : public llvm::orc::MaterializationUnit { 112fe6060f1SDimitry Andric public: 113fe6060f1SDimitry Andric OrcCAPIMaterializationUnit( 114fe6060f1SDimitry Andric std::string Name, SymbolFlagsMap InitialSymbolFlags, 115fe6060f1SDimitry Andric SymbolStringPtr InitSymbol, void *Ctx, 116fe6060f1SDimitry Andric LLVMOrcMaterializationUnitMaterializeFunction Materialize, 117fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDiscardFunction Discard, 118fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDestroyFunction Destroy) 1190eae32dcSDimitry Andric : llvm::orc::MaterializationUnit( 1200eae32dcSDimitry Andric Interface(std::move(InitialSymbolFlags), std::move(InitSymbol))), 121fe6060f1SDimitry Andric Name(std::move(Name)), Ctx(Ctx), Materialize(Materialize), 122fe6060f1SDimitry Andric Discard(Discard), Destroy(Destroy) {} 123fe6060f1SDimitry Andric 124fe6060f1SDimitry Andric ~OrcCAPIMaterializationUnit() { 125fe6060f1SDimitry Andric if (Ctx) 126fe6060f1SDimitry Andric Destroy(Ctx); 127fe6060f1SDimitry Andric } 128fe6060f1SDimitry Andric 129fe6060f1SDimitry Andric StringRef getName() const override { return Name; } 130fe6060f1SDimitry Andric 131fe6060f1SDimitry Andric void materialize(std::unique_ptr<MaterializationResponsibility> R) override { 132fe6060f1SDimitry Andric void *Tmp = Ctx; 133fe6060f1SDimitry Andric Ctx = nullptr; 134fe6060f1SDimitry Andric Materialize(Tmp, wrap(R.release())); 135fe6060f1SDimitry Andric } 136fe6060f1SDimitry Andric 137fe6060f1SDimitry Andric private: 138fe6060f1SDimitry Andric void discard(const JITDylib &JD, const SymbolStringPtr &Name) override { 139fe6060f1SDimitry Andric Discard(Ctx, wrap(&JD), wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name))); 140fe6060f1SDimitry Andric } 141fe6060f1SDimitry Andric 142fe6060f1SDimitry Andric std::string Name; 143fe6060f1SDimitry Andric void *Ctx = nullptr; 144fe6060f1SDimitry Andric LLVMOrcMaterializationUnitMaterializeFunction Materialize = nullptr; 145fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDiscardFunction Discard = nullptr; 146fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDestroyFunction Destroy = nullptr; 147fe6060f1SDimitry Andric }; 148fe6060f1SDimitry Andric 149fe6060f1SDimitry Andric static JITSymbolFlags toJITSymbolFlags(LLVMJITSymbolFlags F) { 150fe6060f1SDimitry Andric 151fe6060f1SDimitry Andric JITSymbolFlags JSF; 152fe6060f1SDimitry Andric 153fe6060f1SDimitry Andric if (F.GenericFlags & LLVMJITSymbolGenericFlagsExported) 154fe6060f1SDimitry Andric JSF |= JITSymbolFlags::Exported; 155fe6060f1SDimitry Andric if (F.GenericFlags & LLVMJITSymbolGenericFlagsWeak) 156fe6060f1SDimitry Andric JSF |= JITSymbolFlags::Weak; 157fe6060f1SDimitry Andric if (F.GenericFlags & LLVMJITSymbolGenericFlagsCallable) 158fe6060f1SDimitry Andric JSF |= JITSymbolFlags::Callable; 159fe6060f1SDimitry Andric if (F.GenericFlags & LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly) 160fe6060f1SDimitry Andric JSF |= JITSymbolFlags::MaterializationSideEffectsOnly; 161fe6060f1SDimitry Andric 162fe6060f1SDimitry Andric JSF.getTargetFlags() = F.TargetFlags; 163fe6060f1SDimitry Andric 164fe6060f1SDimitry Andric return JSF; 165fe6060f1SDimitry Andric } 166fe6060f1SDimitry Andric 167fe6060f1SDimitry Andric static LLVMJITSymbolFlags fromJITSymbolFlags(JITSymbolFlags JSF) { 168fe6060f1SDimitry Andric LLVMJITSymbolFlags F = {0, 0}; 169fe6060f1SDimitry Andric if (JSF & JITSymbolFlags::Exported) 170fe6060f1SDimitry Andric F.GenericFlags |= LLVMJITSymbolGenericFlagsExported; 171fe6060f1SDimitry Andric if (JSF & JITSymbolFlags::Weak) 172fe6060f1SDimitry Andric F.GenericFlags |= LLVMJITSymbolGenericFlagsWeak; 173fe6060f1SDimitry Andric if (JSF & JITSymbolFlags::Callable) 174fe6060f1SDimitry Andric F.GenericFlags |= LLVMJITSymbolGenericFlagsCallable; 175fe6060f1SDimitry Andric if (JSF & JITSymbolFlags::MaterializationSideEffectsOnly) 176fe6060f1SDimitry Andric F.GenericFlags |= LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly; 177fe6060f1SDimitry Andric 178fe6060f1SDimitry Andric F.TargetFlags = JSF.getTargetFlags(); 179fe6060f1SDimitry Andric 180fe6060f1SDimitry Andric return F; 181fe6060f1SDimitry Andric } 182fe6060f1SDimitry Andric 183fe6060f1SDimitry Andric static SymbolMap toSymbolMap(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) { 184fe6060f1SDimitry Andric SymbolMap SM; 185fe6060f1SDimitry Andric for (size_t I = 0; I != NumPairs; ++I) { 186fe6060f1SDimitry Andric JITSymbolFlags Flags = toJITSymbolFlags(Syms[I].Sym.Flags); 187fe6060f1SDimitry Andric SM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] = 188fe6060f1SDimitry Andric JITEvaluatedSymbol(Syms[I].Sym.Address, Flags); 189fe6060f1SDimitry Andric } 190fe6060f1SDimitry Andric return SM; 191fe6060f1SDimitry Andric } 192fe6060f1SDimitry Andric 193fe6060f1SDimitry Andric static SymbolDependenceMap 194fe6060f1SDimitry Andric toSymbolDependenceMap(LLVMOrcCDependenceMapPairs Pairs, size_t NumPairs) { 195fe6060f1SDimitry Andric SymbolDependenceMap SDM; 196fe6060f1SDimitry Andric for (size_t I = 0; I != NumPairs; ++I) { 197fe6060f1SDimitry Andric JITDylib *JD = unwrap(Pairs[I].JD); 198fe6060f1SDimitry Andric SymbolNameSet Names; 199fe6060f1SDimitry Andric 200fe6060f1SDimitry Andric for (size_t J = 0; J != Pairs[I].Names.Length; ++J) { 201fe6060f1SDimitry Andric auto Sym = Pairs[I].Names.Symbols[J]; 202fe6060f1SDimitry Andric Names.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Sym))); 203fe6060f1SDimitry Andric } 204fe6060f1SDimitry Andric SDM[JD] = Names; 205fe6060f1SDimitry Andric } 206fe6060f1SDimitry Andric return SDM; 207fe6060f1SDimitry Andric } 208fe6060f1SDimitry Andric 209*81ad6265SDimitry Andric static LookupKind toLookupKind(LLVMOrcLookupKind K) { 210*81ad6265SDimitry Andric switch (K) { 211*81ad6265SDimitry Andric case LLVMOrcLookupKindStatic: 212*81ad6265SDimitry Andric return LookupKind::Static; 213*81ad6265SDimitry Andric case LLVMOrcLookupKindDLSym: 214*81ad6265SDimitry Andric return LookupKind::DLSym; 215*81ad6265SDimitry Andric } 216*81ad6265SDimitry Andric llvm_unreachable("unrecognized LLVMOrcLookupKind value"); 217*81ad6265SDimitry Andric } 218*81ad6265SDimitry Andric 219*81ad6265SDimitry Andric static LLVMOrcLookupKind fromLookupKind(LookupKind K) { 220*81ad6265SDimitry Andric switch (K) { 221*81ad6265SDimitry Andric case LookupKind::Static: 222*81ad6265SDimitry Andric return LLVMOrcLookupKindStatic; 223*81ad6265SDimitry Andric case LookupKind::DLSym: 224*81ad6265SDimitry Andric return LLVMOrcLookupKindDLSym; 225*81ad6265SDimitry Andric } 226*81ad6265SDimitry Andric llvm_unreachable("unrecognized LookupKind value"); 227*81ad6265SDimitry Andric } 228*81ad6265SDimitry Andric 229*81ad6265SDimitry Andric static JITDylibLookupFlags 230*81ad6265SDimitry Andric toJITDylibLookupFlags(LLVMOrcJITDylibLookupFlags LF) { 231*81ad6265SDimitry Andric switch (LF) { 232*81ad6265SDimitry Andric case LLVMOrcJITDylibLookupFlagsMatchExportedSymbolsOnly: 233*81ad6265SDimitry Andric return JITDylibLookupFlags::MatchExportedSymbolsOnly; 234*81ad6265SDimitry Andric case LLVMOrcJITDylibLookupFlagsMatchAllSymbols: 235*81ad6265SDimitry Andric return JITDylibLookupFlags::MatchAllSymbols; 236*81ad6265SDimitry Andric } 237*81ad6265SDimitry Andric llvm_unreachable("unrecognized LLVMOrcJITDylibLookupFlags value"); 238*81ad6265SDimitry Andric } 239*81ad6265SDimitry Andric 240*81ad6265SDimitry Andric static LLVMOrcJITDylibLookupFlags 241*81ad6265SDimitry Andric fromJITDylibLookupFlags(JITDylibLookupFlags LF) { 242*81ad6265SDimitry Andric switch (LF) { 243*81ad6265SDimitry Andric case JITDylibLookupFlags::MatchExportedSymbolsOnly: 244*81ad6265SDimitry Andric return LLVMOrcJITDylibLookupFlagsMatchExportedSymbolsOnly; 245*81ad6265SDimitry Andric case JITDylibLookupFlags::MatchAllSymbols: 246*81ad6265SDimitry Andric return LLVMOrcJITDylibLookupFlagsMatchAllSymbols; 247*81ad6265SDimitry Andric } 248*81ad6265SDimitry Andric llvm_unreachable("unrecognized JITDylibLookupFlags value"); 249*81ad6265SDimitry Andric } 250*81ad6265SDimitry Andric 251*81ad6265SDimitry Andric static SymbolLookupFlags toSymbolLookupFlags(LLVMOrcSymbolLookupFlags SLF) { 252*81ad6265SDimitry Andric switch (SLF) { 253*81ad6265SDimitry Andric case LLVMOrcSymbolLookupFlagsRequiredSymbol: 254*81ad6265SDimitry Andric return SymbolLookupFlags::RequiredSymbol; 255*81ad6265SDimitry Andric case LLVMOrcSymbolLookupFlagsWeaklyReferencedSymbol: 256*81ad6265SDimitry Andric return SymbolLookupFlags::WeaklyReferencedSymbol; 257*81ad6265SDimitry Andric } 258*81ad6265SDimitry Andric llvm_unreachable("unrecognized LLVMOrcSymbolLookupFlags value"); 259*81ad6265SDimitry Andric } 260*81ad6265SDimitry Andric 261*81ad6265SDimitry Andric static LLVMOrcSymbolLookupFlags fromSymbolLookupFlags(SymbolLookupFlags SLF) { 262*81ad6265SDimitry Andric switch (SLF) { 263*81ad6265SDimitry Andric case SymbolLookupFlags::RequiredSymbol: 264*81ad6265SDimitry Andric return LLVMOrcSymbolLookupFlagsRequiredSymbol; 265*81ad6265SDimitry Andric case SymbolLookupFlags::WeaklyReferencedSymbol: 266*81ad6265SDimitry Andric return LLVMOrcSymbolLookupFlagsWeaklyReferencedSymbol; 267*81ad6265SDimitry Andric } 268*81ad6265SDimitry Andric llvm_unreachable("unrecognized SymbolLookupFlags value"); 269*81ad6265SDimitry Andric } 270*81ad6265SDimitry Andric 271*81ad6265SDimitry Andric static LLVMJITEvaluatedSymbol 272*81ad6265SDimitry Andric fromJITEvaluatedSymbol(const JITEvaluatedSymbol &S) { 273*81ad6265SDimitry Andric return {S.getAddress(), fromJITSymbolFlags(S.getFlags())}; 274*81ad6265SDimitry Andric } 275*81ad6265SDimitry Andric 276fe6060f1SDimitry Andric } // end anonymous namespace 277fe6060f1SDimitry Andric 278*81ad6265SDimitry Andric namespace llvm { 279*81ad6265SDimitry Andric namespace orc { 280*81ad6265SDimitry Andric 281*81ad6265SDimitry Andric class CAPIDefinitionGenerator final : public DefinitionGenerator { 282*81ad6265SDimitry Andric public: 283*81ad6265SDimitry Andric CAPIDefinitionGenerator( 284*81ad6265SDimitry Andric LLVMOrcDisposeCAPIDefinitionGeneratorFunction Dispose, void *Ctx, 285*81ad6265SDimitry Andric LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate) 286*81ad6265SDimitry Andric : Dispose(Dispose), Ctx(Ctx), TryToGenerate(TryToGenerate) {} 287*81ad6265SDimitry Andric 288*81ad6265SDimitry Andric ~CAPIDefinitionGenerator() { 289*81ad6265SDimitry Andric if (Dispose) 290*81ad6265SDimitry Andric Dispose(Ctx); 291*81ad6265SDimitry Andric } 292*81ad6265SDimitry Andric 293*81ad6265SDimitry Andric Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, 294*81ad6265SDimitry Andric JITDylibLookupFlags JDLookupFlags, 295*81ad6265SDimitry Andric const SymbolLookupSet &LookupSet) override { 296*81ad6265SDimitry Andric 297*81ad6265SDimitry Andric // Take the lookup state. 298*81ad6265SDimitry Andric LLVMOrcLookupStateRef LSR = ::wrap(OrcV2CAPIHelper::extractLookupState(LS)); 299*81ad6265SDimitry Andric 300*81ad6265SDimitry Andric // Translate the lookup kind. 301*81ad6265SDimitry Andric LLVMOrcLookupKind CLookupKind = fromLookupKind(K); 302*81ad6265SDimitry Andric 303*81ad6265SDimitry Andric // Translate the JITDylibLookupFlags. 304*81ad6265SDimitry Andric LLVMOrcJITDylibLookupFlags CJDLookupFlags = 305*81ad6265SDimitry Andric fromJITDylibLookupFlags(JDLookupFlags); 306*81ad6265SDimitry Andric 307*81ad6265SDimitry Andric // Translate the lookup set. 308*81ad6265SDimitry Andric std::vector<LLVMOrcCLookupSetElement> CLookupSet; 309*81ad6265SDimitry Andric CLookupSet.reserve(LookupSet.size()); 310*81ad6265SDimitry Andric for (auto &KV : LookupSet) { 311*81ad6265SDimitry Andric LLVMOrcSymbolStringPoolEntryRef Name = 312*81ad6265SDimitry Andric ::wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(KV.first)); 313*81ad6265SDimitry Andric LLVMOrcSymbolLookupFlags SLF = fromSymbolLookupFlags(KV.second); 314*81ad6265SDimitry Andric CLookupSet.push_back({Name, SLF}); 315*81ad6265SDimitry Andric } 316*81ad6265SDimitry Andric 317*81ad6265SDimitry Andric // Run the C TryToGenerate function. 318*81ad6265SDimitry Andric auto Err = unwrap(TryToGenerate(::wrap(this), Ctx, &LSR, CLookupKind, 319*81ad6265SDimitry Andric ::wrap(&JD), CJDLookupFlags, 320*81ad6265SDimitry Andric CLookupSet.data(), CLookupSet.size())); 321*81ad6265SDimitry Andric 322*81ad6265SDimitry Andric // Restore the lookup state. 323*81ad6265SDimitry Andric OrcV2CAPIHelper::resetLookupState(LS, ::unwrap(LSR)); 324*81ad6265SDimitry Andric 325*81ad6265SDimitry Andric return Err; 326*81ad6265SDimitry Andric } 327*81ad6265SDimitry Andric 328*81ad6265SDimitry Andric private: 329*81ad6265SDimitry Andric LLVMOrcDisposeCAPIDefinitionGeneratorFunction Dispose; 330*81ad6265SDimitry Andric void *Ctx; 331*81ad6265SDimitry Andric LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction TryToGenerate; 332*81ad6265SDimitry Andric }; 333*81ad6265SDimitry Andric 334*81ad6265SDimitry Andric } // end namespace orc 335*81ad6265SDimitry Andric } // end namespace llvm 336*81ad6265SDimitry Andric 337e8d8bef9SDimitry Andric void LLVMOrcExecutionSessionSetErrorReporter( 338e8d8bef9SDimitry Andric LLVMOrcExecutionSessionRef ES, LLVMOrcErrorReporterFunction ReportError, 339e8d8bef9SDimitry Andric void *Ctx) { 340e8d8bef9SDimitry Andric unwrap(ES)->setErrorReporter( 341e8d8bef9SDimitry Andric [=](Error Err) { ReportError(Ctx, wrap(std::move(Err))); }); 342e8d8bef9SDimitry Andric } 343e8d8bef9SDimitry Andric 344e8d8bef9SDimitry Andric LLVMOrcSymbolStringPoolRef 345e8d8bef9SDimitry Andric LLVMOrcExecutionSessionGetSymbolStringPool(LLVMOrcExecutionSessionRef ES) { 346fe6060f1SDimitry Andric return wrap( 347fe6060f1SDimitry Andric unwrap(ES)->getExecutorProcessControl().getSymbolStringPool().get()); 348e8d8bef9SDimitry Andric } 349e8d8bef9SDimitry Andric 350e8d8bef9SDimitry Andric void LLVMOrcSymbolStringPoolClearDeadEntries(LLVMOrcSymbolStringPoolRef SSP) { 351e8d8bef9SDimitry Andric unwrap(SSP)->clearDeadEntries(); 352e8d8bef9SDimitry Andric } 353e8d8bef9SDimitry Andric 3545ffd83dbSDimitry Andric LLVMOrcSymbolStringPoolEntryRef 3555ffd83dbSDimitry Andric LLVMOrcExecutionSessionIntern(LLVMOrcExecutionSessionRef ES, const char *Name) { 3565ffd83dbSDimitry Andric return wrap( 357fe6060f1SDimitry Andric OrcV2CAPIHelper::moveFromSymbolStringPtr(unwrap(ES)->intern(Name))); 3585ffd83dbSDimitry Andric } 3595ffd83dbSDimitry Andric 360*81ad6265SDimitry Andric void LLVMOrcExecutionSessionLookup( 361*81ad6265SDimitry Andric LLVMOrcExecutionSessionRef ES, LLVMOrcLookupKind K, 362*81ad6265SDimitry Andric LLVMOrcCJITDylibSearchOrder SearchOrder, size_t SearchOrderSize, 363*81ad6265SDimitry Andric LLVMOrcCLookupSet Symbols, size_t SymbolsSize, 364*81ad6265SDimitry Andric LLVMOrcExecutionSessionLookupHandleResultFunction HandleResult, void *Ctx) { 365*81ad6265SDimitry Andric assert(ES && "ES cannot be null"); 366*81ad6265SDimitry Andric assert(SearchOrder && "SearchOrder cannot be null"); 367*81ad6265SDimitry Andric assert(Symbols && "Symbols cannot be null"); 368*81ad6265SDimitry Andric assert(HandleResult && "HandleResult cannot be null"); 369*81ad6265SDimitry Andric 370*81ad6265SDimitry Andric JITDylibSearchOrder SO; 371*81ad6265SDimitry Andric for (size_t I = 0; I != SearchOrderSize; ++I) 372*81ad6265SDimitry Andric SO.push_back({unwrap(SearchOrder[I].JD), 373*81ad6265SDimitry Andric toJITDylibLookupFlags(SearchOrder[I].JDLookupFlags)}); 374*81ad6265SDimitry Andric 375*81ad6265SDimitry Andric SymbolLookupSet SLS; 376*81ad6265SDimitry Andric for (size_t I = 0; I != SymbolsSize; ++I) 377*81ad6265SDimitry Andric SLS.add(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Symbols[I].Name)), 378*81ad6265SDimitry Andric toSymbolLookupFlags(Symbols[I].LookupFlags)); 379*81ad6265SDimitry Andric 380*81ad6265SDimitry Andric unwrap(ES)->lookup( 381*81ad6265SDimitry Andric toLookupKind(K), SO, std::move(SLS), SymbolState::Ready, 382*81ad6265SDimitry Andric [HandleResult, Ctx](Expected<SymbolMap> Result) { 383*81ad6265SDimitry Andric if (Result) { 384*81ad6265SDimitry Andric SmallVector<LLVMOrcCSymbolMapPair> CResult; 385*81ad6265SDimitry Andric for (auto &KV : *Result) 386*81ad6265SDimitry Andric CResult.push_back(LLVMOrcCSymbolMapPair{ 387*81ad6265SDimitry Andric wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(KV.first)), 388*81ad6265SDimitry Andric fromJITEvaluatedSymbol(KV.second)}); 389*81ad6265SDimitry Andric HandleResult(LLVMErrorSuccess, CResult.data(), CResult.size(), Ctx); 390*81ad6265SDimitry Andric } else 391*81ad6265SDimitry Andric HandleResult(wrap(Result.takeError()), nullptr, 0, Ctx); 392*81ad6265SDimitry Andric }, 393*81ad6265SDimitry Andric NoDependenciesToRegister); 394*81ad6265SDimitry Andric } 395*81ad6265SDimitry Andric 396e8d8bef9SDimitry Andric void LLVMOrcRetainSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) { 397e8d8bef9SDimitry Andric OrcV2CAPIHelper::retainPoolEntry(unwrap(S)); 398e8d8bef9SDimitry Andric } 399e8d8bef9SDimitry Andric 4005ffd83dbSDimitry Andric void LLVMOrcReleaseSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S) { 4015ffd83dbSDimitry Andric OrcV2CAPIHelper::releasePoolEntry(unwrap(S)); 4025ffd83dbSDimitry Andric } 4035ffd83dbSDimitry Andric 404e8d8bef9SDimitry Andric const char *LLVMOrcSymbolStringPoolEntryStr(LLVMOrcSymbolStringPoolEntryRef S) { 405e8d8bef9SDimitry Andric return unwrap(S)->getKey().data(); 406e8d8bef9SDimitry Andric } 407e8d8bef9SDimitry Andric 408e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef 409e8d8bef9SDimitry Andric LLVMOrcJITDylibCreateResourceTracker(LLVMOrcJITDylibRef JD) { 410e8d8bef9SDimitry Andric auto RT = unwrap(JD)->createResourceTracker(); 411e8d8bef9SDimitry Andric // Retain the pointer for the C API client. 412e8d8bef9SDimitry Andric RT->Retain(); 413e8d8bef9SDimitry Andric return wrap(RT.get()); 414e8d8bef9SDimitry Andric } 415e8d8bef9SDimitry Andric 416e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef 417e8d8bef9SDimitry Andric LLVMOrcJITDylibGetDefaultResourceTracker(LLVMOrcJITDylibRef JD) { 418e8d8bef9SDimitry Andric auto RT = unwrap(JD)->getDefaultResourceTracker(); 419e8d8bef9SDimitry Andric // Retain the pointer for the C API client. 420e8d8bef9SDimitry Andric return wrap(RT.get()); 421e8d8bef9SDimitry Andric } 422e8d8bef9SDimitry Andric 423e8d8bef9SDimitry Andric void LLVMOrcReleaseResourceTracker(LLVMOrcResourceTrackerRef RT) { 424e8d8bef9SDimitry Andric ResourceTrackerSP TmpRT(unwrap(RT)); 425e8d8bef9SDimitry Andric TmpRT->Release(); 426e8d8bef9SDimitry Andric } 427e8d8bef9SDimitry Andric 428e8d8bef9SDimitry Andric void LLVMOrcResourceTrackerTransferTo(LLVMOrcResourceTrackerRef SrcRT, 429e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef DstRT) { 430e8d8bef9SDimitry Andric ResourceTrackerSP TmpRT(unwrap(SrcRT)); 431e8d8bef9SDimitry Andric TmpRT->transferTo(*unwrap(DstRT)); 432e8d8bef9SDimitry Andric } 433e8d8bef9SDimitry Andric 434e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcResourceTrackerRemove(LLVMOrcResourceTrackerRef RT) { 435e8d8bef9SDimitry Andric ResourceTrackerSP TmpRT(unwrap(RT)); 436e8d8bef9SDimitry Andric return wrap(TmpRT->remove()); 437e8d8bef9SDimitry Andric } 438e8d8bef9SDimitry Andric 439e8d8bef9SDimitry Andric void LLVMOrcDisposeDefinitionGenerator(LLVMOrcDefinitionGeneratorRef DG) { 440e8d8bef9SDimitry Andric std::unique_ptr<DefinitionGenerator> TmpDG(unwrap(DG)); 441e8d8bef9SDimitry Andric } 442e8d8bef9SDimitry Andric 443e8d8bef9SDimitry Andric void LLVMOrcDisposeMaterializationUnit(LLVMOrcMaterializationUnitRef MU) { 444e8d8bef9SDimitry Andric std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU)); 445e8d8bef9SDimitry Andric } 446e8d8bef9SDimitry Andric 447fe6060f1SDimitry Andric LLVMOrcMaterializationUnitRef LLVMOrcCreateCustomMaterializationUnit( 448fe6060f1SDimitry Andric const char *Name, void *Ctx, LLVMOrcCSymbolFlagsMapPairs Syms, 449fe6060f1SDimitry Andric size_t NumSyms, LLVMOrcSymbolStringPoolEntryRef InitSym, 450fe6060f1SDimitry Andric LLVMOrcMaterializationUnitMaterializeFunction Materialize, 451fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDiscardFunction Discard, 452fe6060f1SDimitry Andric LLVMOrcMaterializationUnitDestroyFunction Destroy) { 453fe6060f1SDimitry Andric SymbolFlagsMap SFM; 454fe6060f1SDimitry Andric for (size_t I = 0; I != NumSyms; ++I) 455fe6060f1SDimitry Andric SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] = 456fe6060f1SDimitry Andric toJITSymbolFlags(Syms[I].Flags); 457e8d8bef9SDimitry Andric 458fe6060f1SDimitry Andric auto IS = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(InitSym)); 459e8d8bef9SDimitry Andric 460fe6060f1SDimitry Andric return wrap(new OrcCAPIMaterializationUnit( 461fe6060f1SDimitry Andric Name, std::move(SFM), std::move(IS), Ctx, Materialize, Discard, Destroy)); 462e8d8bef9SDimitry Andric } 463e8d8bef9SDimitry Andric 464fe6060f1SDimitry Andric LLVMOrcMaterializationUnitRef 465fe6060f1SDimitry Andric LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) { 466fe6060f1SDimitry Andric SymbolMap SM = toSymbolMap(Syms, NumPairs); 467e8d8bef9SDimitry Andric return wrap(absoluteSymbols(std::move(SM)).release()); 468e8d8bef9SDimitry Andric } 469e8d8bef9SDimitry Andric 470fe6060f1SDimitry Andric LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports( 471fe6060f1SDimitry Andric LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM, 472fe6060f1SDimitry Andric LLVMOrcJITDylibRef SourceJD, LLVMOrcCSymbolAliasMapPairs CallableAliases, 473fe6060f1SDimitry Andric size_t NumPairs) { 474fe6060f1SDimitry Andric 475fe6060f1SDimitry Andric SymbolAliasMap SAM; 476fe6060f1SDimitry Andric for (size_t I = 0; I != NumPairs; ++I) { 477fe6060f1SDimitry Andric auto pair = CallableAliases[I]; 478fe6060f1SDimitry Andric JITSymbolFlags Flags = toJITSymbolFlags(pair.Entry.Flags); 479fe6060f1SDimitry Andric SymbolStringPtr Name = 480fe6060f1SDimitry Andric OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Entry.Name)); 481fe6060f1SDimitry Andric SAM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Name))] = 482fe6060f1SDimitry Andric SymbolAliasMapEntry(Name, Flags); 483fe6060f1SDimitry Andric } 484fe6060f1SDimitry Andric 485fe6060f1SDimitry Andric return wrap(lazyReexports(*unwrap(LCTM), *unwrap(ISM), *unwrap(SourceJD), 486fe6060f1SDimitry Andric std::move(SAM)) 487fe6060f1SDimitry Andric .release()); 488fe6060f1SDimitry Andric } 489fe6060f1SDimitry Andric 490fe6060f1SDimitry Andric void LLVMOrcDisposeMaterializationResponsibility( 491fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 492fe6060f1SDimitry Andric std::unique_ptr<MaterializationResponsibility> TmpMR(unwrap(MR)); 493fe6060f1SDimitry Andric } 494fe6060f1SDimitry Andric 495fe6060f1SDimitry Andric LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib( 496fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 497fe6060f1SDimitry Andric return wrap(&unwrap(MR)->getTargetJITDylib()); 498fe6060f1SDimitry Andric } 499fe6060f1SDimitry Andric 500fe6060f1SDimitry Andric LLVMOrcExecutionSessionRef 501fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityGetExecutionSession( 502fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 503fe6060f1SDimitry Andric return wrap(&unwrap(MR)->getExecutionSession()); 504fe6060f1SDimitry Andric } 505fe6060f1SDimitry Andric 506fe6060f1SDimitry Andric LLVMOrcCSymbolFlagsMapPairs LLVMOrcMaterializationResponsibilityGetSymbols( 507fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, size_t *NumPairs) { 508fe6060f1SDimitry Andric 509fe6060f1SDimitry Andric auto Symbols = unwrap(MR)->getSymbols(); 510fe6060f1SDimitry Andric LLVMOrcCSymbolFlagsMapPairs Result = static_cast<LLVMOrcCSymbolFlagsMapPairs>( 511fe6060f1SDimitry Andric safe_malloc(Symbols.size() * sizeof(LLVMOrcCSymbolFlagsMapPair))); 512fe6060f1SDimitry Andric size_t I = 0; 513fe6060f1SDimitry Andric for (auto const &pair : Symbols) { 514fe6060f1SDimitry Andric auto Name = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(pair.first)); 515fe6060f1SDimitry Andric auto Flags = pair.second; 516fe6060f1SDimitry Andric Result[I] = {Name, fromJITSymbolFlags(Flags)}; 517fe6060f1SDimitry Andric I++; 518fe6060f1SDimitry Andric } 519fe6060f1SDimitry Andric *NumPairs = Symbols.size(); 520fe6060f1SDimitry Andric return Result; 521fe6060f1SDimitry Andric } 522fe6060f1SDimitry Andric 523fe6060f1SDimitry Andric void LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs) { 524fe6060f1SDimitry Andric free(Pairs); 525fe6060f1SDimitry Andric } 526fe6060f1SDimitry Andric 527fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef 528fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityGetInitializerSymbol( 529fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 530fe6060f1SDimitry Andric auto Sym = unwrap(MR)->getInitializerSymbol(); 531fe6060f1SDimitry Andric return wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Sym)); 532fe6060f1SDimitry Andric } 533fe6060f1SDimitry Andric 534fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef * 535fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityGetRequestedSymbols( 536fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols) { 537fe6060f1SDimitry Andric 538fe6060f1SDimitry Andric auto Symbols = unwrap(MR)->getRequestedSymbols(); 539fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef *Result = 540fe6060f1SDimitry Andric static_cast<LLVMOrcSymbolStringPoolEntryRef *>(safe_malloc( 541fe6060f1SDimitry Andric Symbols.size() * sizeof(LLVMOrcSymbolStringPoolEntryRef))); 542fe6060f1SDimitry Andric size_t I = 0; 543fe6060f1SDimitry Andric for (auto &Name : Symbols) { 544fe6060f1SDimitry Andric Result[I] = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)); 545fe6060f1SDimitry Andric I++; 546fe6060f1SDimitry Andric } 547fe6060f1SDimitry Andric *NumSymbols = Symbols.size(); 548fe6060f1SDimitry Andric return Result; 549fe6060f1SDimitry Andric } 550fe6060f1SDimitry Andric 551fe6060f1SDimitry Andric void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols) { 552fe6060f1SDimitry Andric free(Symbols); 553fe6060f1SDimitry Andric } 554fe6060f1SDimitry Andric 555fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved( 556fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols, 557fe6060f1SDimitry Andric size_t NumPairs) { 558fe6060f1SDimitry Andric SymbolMap SM = toSymbolMap(Symbols, NumPairs); 559fe6060f1SDimitry Andric return wrap(unwrap(MR)->notifyResolved(std::move(SM))); 560fe6060f1SDimitry Andric } 561fe6060f1SDimitry Andric 562fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted( 563fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 564fe6060f1SDimitry Andric return wrap(unwrap(MR)->notifyEmitted()); 565fe6060f1SDimitry Andric } 566fe6060f1SDimitry Andric 567fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing( 568fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 569fe6060f1SDimitry Andric LLVMOrcCSymbolFlagsMapPairs Syms, size_t NumSyms) { 570fe6060f1SDimitry Andric SymbolFlagsMap SFM; 571fe6060f1SDimitry Andric for (size_t I = 0; I != NumSyms; ++I) 572fe6060f1SDimitry Andric SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] = 573fe6060f1SDimitry Andric toJITSymbolFlags(Syms[I].Flags); 574fe6060f1SDimitry Andric 575fe6060f1SDimitry Andric return wrap(unwrap(MR)->defineMaterializing(std::move(SFM))); 576fe6060f1SDimitry Andric } 577fe6060f1SDimitry Andric 578fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace( 579fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 580fe6060f1SDimitry Andric LLVMOrcMaterializationUnitRef MU) { 581fe6060f1SDimitry Andric std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU)); 582fe6060f1SDimitry Andric return wrap(unwrap(MR)->replace(std::move(TmpMU))); 583fe6060f1SDimitry Andric } 584fe6060f1SDimitry Andric 585fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate( 586fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 587fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols, 588fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef *Result) { 589fe6060f1SDimitry Andric SymbolNameSet Syms; 590fe6060f1SDimitry Andric for (size_t I = 0; I != NumSymbols; I++) { 591fe6060f1SDimitry Andric Syms.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Symbols[I]))); 592fe6060f1SDimitry Andric } 593fe6060f1SDimitry Andric auto OtherMR = unwrap(MR)->delegate(Syms); 594fe6060f1SDimitry Andric 595fe6060f1SDimitry Andric if (!OtherMR) { 596fe6060f1SDimitry Andric return wrap(OtherMR.takeError()); 597fe6060f1SDimitry Andric } 598fe6060f1SDimitry Andric *Result = wrap(OtherMR->release()); 599fe6060f1SDimitry Andric return LLVMErrorSuccess; 600fe6060f1SDimitry Andric } 601fe6060f1SDimitry Andric 602fe6060f1SDimitry Andric void LLVMOrcMaterializationResponsibilityAddDependencies( 603fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 604fe6060f1SDimitry Andric LLVMOrcSymbolStringPoolEntryRef Name, 605fe6060f1SDimitry Andric LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) { 606fe6060f1SDimitry Andric 607fe6060f1SDimitry Andric SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs); 608fe6060f1SDimitry Andric auto Sym = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Name)); 609fe6060f1SDimitry Andric unwrap(MR)->addDependencies(Sym, SDM); 610fe6060f1SDimitry Andric } 611fe6060f1SDimitry Andric 612fe6060f1SDimitry Andric void LLVMOrcMaterializationResponsibilityAddDependenciesForAll( 613fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 614fe6060f1SDimitry Andric LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) { 615fe6060f1SDimitry Andric 616fe6060f1SDimitry Andric SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs); 617fe6060f1SDimitry Andric unwrap(MR)->addDependenciesForAll(SDM); 618fe6060f1SDimitry Andric } 619fe6060f1SDimitry Andric 620fe6060f1SDimitry Andric void LLVMOrcMaterializationResponsibilityFailMaterialization( 621fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR) { 622fe6060f1SDimitry Andric unwrap(MR)->failMaterialization(); 623fe6060f1SDimitry Andric } 624fe6060f1SDimitry Andric 625fe6060f1SDimitry Andric void LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRLayer, 626fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef MR, 627fe6060f1SDimitry Andric LLVMOrcThreadSafeModuleRef TSM) { 628fe6060f1SDimitry Andric std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM)); 629fe6060f1SDimitry Andric unwrap(IRLayer)->emit( 630fe6060f1SDimitry Andric std::unique_ptr<MaterializationResponsibility>(unwrap(MR)), 631fe6060f1SDimitry Andric std::move(*TmpTSM)); 632fe6060f1SDimitry Andric } 633fe6060f1SDimitry Andric 634e8d8bef9SDimitry Andric LLVMOrcJITDylibRef 635e8d8bef9SDimitry Andric LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES, 636e8d8bef9SDimitry Andric const char *Name) { 637e8d8bef9SDimitry Andric return wrap(&unwrap(ES)->createBareJITDylib(Name)); 638e8d8bef9SDimitry Andric } 639e8d8bef9SDimitry Andric 640e8d8bef9SDimitry Andric LLVMErrorRef 641e8d8bef9SDimitry Andric LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES, 642e8d8bef9SDimitry Andric LLVMOrcJITDylibRef *Result, 643e8d8bef9SDimitry Andric const char *Name) { 644e8d8bef9SDimitry Andric auto JD = unwrap(ES)->createJITDylib(Name); 645e8d8bef9SDimitry Andric if (!JD) 646e8d8bef9SDimitry Andric return wrap(JD.takeError()); 647e8d8bef9SDimitry Andric *Result = wrap(&*JD); 648e8d8bef9SDimitry Andric return LLVMErrorSuccess; 649e8d8bef9SDimitry Andric } 650e8d8bef9SDimitry Andric 651e8d8bef9SDimitry Andric LLVMOrcJITDylibRef 652e8d8bef9SDimitry Andric LLVMOrcExecutionSessionGetJITDylibByName(LLVMOrcExecutionSessionRef ES, 653e8d8bef9SDimitry Andric const char *Name) { 654e8d8bef9SDimitry Andric return wrap(unwrap(ES)->getJITDylibByName(Name)); 655e8d8bef9SDimitry Andric } 656e8d8bef9SDimitry Andric 657e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcJITDylibDefine(LLVMOrcJITDylibRef JD, 658e8d8bef9SDimitry Andric LLVMOrcMaterializationUnitRef MU) { 659e8d8bef9SDimitry Andric std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU)); 660e8d8bef9SDimitry Andric 661e8d8bef9SDimitry Andric if (auto Err = unwrap(JD)->define(TmpMU)) { 662e8d8bef9SDimitry Andric TmpMU.release(); 663e8d8bef9SDimitry Andric return wrap(std::move(Err)); 664e8d8bef9SDimitry Andric } 665e8d8bef9SDimitry Andric return LLVMErrorSuccess; 666e8d8bef9SDimitry Andric } 667e8d8bef9SDimitry Andric 668e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcJITDylibClear(LLVMOrcJITDylibRef JD) { 669e8d8bef9SDimitry Andric return wrap(unwrap(JD)->clear()); 6705ffd83dbSDimitry Andric } 6715ffd83dbSDimitry Andric 6725ffd83dbSDimitry Andric void LLVMOrcJITDylibAddGenerator(LLVMOrcJITDylibRef JD, 673e8d8bef9SDimitry Andric LLVMOrcDefinitionGeneratorRef DG) { 674e8d8bef9SDimitry Andric unwrap(JD)->addGenerator(std::unique_ptr<DefinitionGenerator>(unwrap(DG))); 675e8d8bef9SDimitry Andric } 676e8d8bef9SDimitry Andric 677e8d8bef9SDimitry Andric LLVMOrcDefinitionGeneratorRef LLVMOrcCreateCustomCAPIDefinitionGenerator( 678*81ad6265SDimitry Andric LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction F, void *Ctx, 679*81ad6265SDimitry Andric LLVMOrcDisposeCAPIDefinitionGeneratorFunction Dispose) { 680*81ad6265SDimitry Andric auto DG = std::make_unique<CAPIDefinitionGenerator>(Dispose, Ctx, F); 681e8d8bef9SDimitry Andric return wrap(DG.release()); 6825ffd83dbSDimitry Andric } 6835ffd83dbSDimitry Andric 684*81ad6265SDimitry Andric void LLVMOrcLookupStateContinueLookup(LLVMOrcLookupStateRef S, 685*81ad6265SDimitry Andric LLVMErrorRef Err) { 686*81ad6265SDimitry Andric LookupState LS; 687*81ad6265SDimitry Andric OrcV2CAPIHelper::resetLookupState(LS, ::unwrap(S)); 688*81ad6265SDimitry Andric LS.continueLookup(unwrap(Err)); 689*81ad6265SDimitry Andric } 690*81ad6265SDimitry Andric 6915ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess( 692e8d8bef9SDimitry Andric LLVMOrcDefinitionGeneratorRef *Result, char GlobalPrefix, 6935ffd83dbSDimitry Andric LLVMOrcSymbolPredicate Filter, void *FilterCtx) { 6945ffd83dbSDimitry Andric assert(Result && "Result can not be null"); 6955ffd83dbSDimitry Andric assert((Filter || !FilterCtx) && 6965ffd83dbSDimitry Andric "if Filter is null then FilterCtx must also be null"); 6975ffd83dbSDimitry Andric 6985ffd83dbSDimitry Andric DynamicLibrarySearchGenerator::SymbolPredicate Pred; 6995ffd83dbSDimitry Andric if (Filter) 7005ffd83dbSDimitry Andric Pred = [=](const SymbolStringPtr &Name) -> bool { 701e8d8bef9SDimitry Andric return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name))); 7025ffd83dbSDimitry Andric }; 7035ffd83dbSDimitry Andric 7045ffd83dbSDimitry Andric auto ProcessSymsGenerator = 7055ffd83dbSDimitry Andric DynamicLibrarySearchGenerator::GetForCurrentProcess(GlobalPrefix, Pred); 7065ffd83dbSDimitry Andric 7075ffd83dbSDimitry Andric if (!ProcessSymsGenerator) { 70804eeddc0SDimitry Andric *Result = nullptr; 7095ffd83dbSDimitry Andric return wrap(ProcessSymsGenerator.takeError()); 7105ffd83dbSDimitry Andric } 7115ffd83dbSDimitry Andric 7125ffd83dbSDimitry Andric *Result = wrap(ProcessSymsGenerator->release()); 7135ffd83dbSDimitry Andric return LLVMErrorSuccess; 7145ffd83dbSDimitry Andric } 7155ffd83dbSDimitry Andric 716349cc55cSDimitry Andric LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForPath( 717349cc55cSDimitry Andric LLVMOrcDefinitionGeneratorRef *Result, const char *FileName, 718349cc55cSDimitry Andric char GlobalPrefix, LLVMOrcSymbolPredicate Filter, void *FilterCtx) { 719349cc55cSDimitry Andric assert(Result && "Result can not be null"); 720349cc55cSDimitry Andric assert(FileName && "FileName can not be null"); 721349cc55cSDimitry Andric assert((Filter || !FilterCtx) && 722349cc55cSDimitry Andric "if Filter is null then FilterCtx must also be null"); 723349cc55cSDimitry Andric 724349cc55cSDimitry Andric DynamicLibrarySearchGenerator::SymbolPredicate Pred; 725349cc55cSDimitry Andric if (Filter) 726349cc55cSDimitry Andric Pred = [=](const SymbolStringPtr &Name) -> bool { 727349cc55cSDimitry Andric return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name))); 728349cc55cSDimitry Andric }; 729349cc55cSDimitry Andric 730349cc55cSDimitry Andric auto LibrarySymsGenerator = 731349cc55cSDimitry Andric DynamicLibrarySearchGenerator::Load(FileName, GlobalPrefix, Pred); 732349cc55cSDimitry Andric 733349cc55cSDimitry Andric if (!LibrarySymsGenerator) { 73404eeddc0SDimitry Andric *Result = nullptr; 735349cc55cSDimitry Andric return wrap(LibrarySymsGenerator.takeError()); 736349cc55cSDimitry Andric } 737349cc55cSDimitry Andric 738349cc55cSDimitry Andric *Result = wrap(LibrarySymsGenerator->release()); 739349cc55cSDimitry Andric return LLVMErrorSuccess; 740349cc55cSDimitry Andric } 741349cc55cSDimitry Andric 742349cc55cSDimitry Andric LLVMErrorRef LLVMOrcCreateStaticLibrarySearchGeneratorForPath( 743349cc55cSDimitry Andric LLVMOrcDefinitionGeneratorRef *Result, LLVMOrcObjectLayerRef ObjLayer, 744349cc55cSDimitry Andric const char *FileName, const char *TargetTriple) { 745349cc55cSDimitry Andric assert(Result && "Result can not be null"); 746349cc55cSDimitry Andric assert(FileName && "Filename can not be null"); 747349cc55cSDimitry Andric assert(ObjLayer && "ObjectLayer can not be null"); 748349cc55cSDimitry Andric 749349cc55cSDimitry Andric if (TargetTriple) { 750349cc55cSDimitry Andric auto TT = Triple(TargetTriple); 751349cc55cSDimitry Andric auto LibrarySymsGenerator = 752349cc55cSDimitry Andric StaticLibraryDefinitionGenerator::Load(*unwrap(ObjLayer), FileName, TT); 753349cc55cSDimitry Andric if (!LibrarySymsGenerator) { 75404eeddc0SDimitry Andric *Result = nullptr; 755349cc55cSDimitry Andric return wrap(LibrarySymsGenerator.takeError()); 756349cc55cSDimitry Andric } 757349cc55cSDimitry Andric *Result = wrap(LibrarySymsGenerator->release()); 758349cc55cSDimitry Andric return LLVMErrorSuccess; 759349cc55cSDimitry Andric } else { 760349cc55cSDimitry Andric auto LibrarySymsGenerator = 761349cc55cSDimitry Andric StaticLibraryDefinitionGenerator::Load(*unwrap(ObjLayer), FileName); 762349cc55cSDimitry Andric if (!LibrarySymsGenerator) { 76304eeddc0SDimitry Andric *Result = nullptr; 764349cc55cSDimitry Andric return wrap(LibrarySymsGenerator.takeError()); 765349cc55cSDimitry Andric } 766349cc55cSDimitry Andric *Result = wrap(LibrarySymsGenerator->release()); 767349cc55cSDimitry Andric return LLVMErrorSuccess; 768349cc55cSDimitry Andric } 769349cc55cSDimitry Andric } 770349cc55cSDimitry Andric 7715ffd83dbSDimitry Andric LLVMOrcThreadSafeContextRef LLVMOrcCreateNewThreadSafeContext(void) { 7725ffd83dbSDimitry Andric return wrap(new ThreadSafeContext(std::make_unique<LLVMContext>())); 7735ffd83dbSDimitry Andric } 7745ffd83dbSDimitry Andric 7755ffd83dbSDimitry Andric LLVMContextRef 7765ffd83dbSDimitry Andric LLVMOrcThreadSafeContextGetContext(LLVMOrcThreadSafeContextRef TSCtx) { 7775ffd83dbSDimitry Andric return wrap(unwrap(TSCtx)->getContext()); 7785ffd83dbSDimitry Andric } 7795ffd83dbSDimitry Andric 7805ffd83dbSDimitry Andric void LLVMOrcDisposeThreadSafeContext(LLVMOrcThreadSafeContextRef TSCtx) { 7815ffd83dbSDimitry Andric delete unwrap(TSCtx); 7825ffd83dbSDimitry Andric } 7835ffd83dbSDimitry Andric 784fe6060f1SDimitry Andric LLVMErrorRef 785fe6060f1SDimitry Andric LLVMOrcThreadSafeModuleWithModuleDo(LLVMOrcThreadSafeModuleRef TSM, 786fe6060f1SDimitry Andric LLVMOrcGenericIRModuleOperationFunction F, 787fe6060f1SDimitry Andric void *Ctx) { 788fe6060f1SDimitry Andric return wrap(unwrap(TSM)->withModuleDo( 789fe6060f1SDimitry Andric [&](Module &M) { return unwrap(F(Ctx, wrap(&M))); })); 790fe6060f1SDimitry Andric } 791fe6060f1SDimitry Andric 7925ffd83dbSDimitry Andric LLVMOrcThreadSafeModuleRef 7935ffd83dbSDimitry Andric LLVMOrcCreateNewThreadSafeModule(LLVMModuleRef M, 7945ffd83dbSDimitry Andric LLVMOrcThreadSafeContextRef TSCtx) { 7955ffd83dbSDimitry Andric return wrap( 7965ffd83dbSDimitry Andric new ThreadSafeModule(std::unique_ptr<Module>(unwrap(M)), *unwrap(TSCtx))); 7975ffd83dbSDimitry Andric } 7985ffd83dbSDimitry Andric 7995ffd83dbSDimitry Andric void LLVMOrcDisposeThreadSafeModule(LLVMOrcThreadSafeModuleRef TSM) { 8005ffd83dbSDimitry Andric delete unwrap(TSM); 8015ffd83dbSDimitry Andric } 8025ffd83dbSDimitry Andric 8035ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcJITTargetMachineBuilderDetectHost( 8045ffd83dbSDimitry Andric LLVMOrcJITTargetMachineBuilderRef *Result) { 8055ffd83dbSDimitry Andric assert(Result && "Result can not be null"); 8065ffd83dbSDimitry Andric 8075ffd83dbSDimitry Andric auto JTMB = JITTargetMachineBuilder::detectHost(); 8085ffd83dbSDimitry Andric if (!JTMB) { 80904eeddc0SDimitry Andric Result = nullptr; 8105ffd83dbSDimitry Andric return wrap(JTMB.takeError()); 8115ffd83dbSDimitry Andric } 8125ffd83dbSDimitry Andric 8135ffd83dbSDimitry Andric *Result = wrap(new JITTargetMachineBuilder(std::move(*JTMB))); 8145ffd83dbSDimitry Andric return LLVMErrorSuccess; 8155ffd83dbSDimitry Andric } 8165ffd83dbSDimitry Andric 8175ffd83dbSDimitry Andric LLVMOrcJITTargetMachineBuilderRef 818e8d8bef9SDimitry Andric LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(LLVMTargetMachineRef TM) { 8195ffd83dbSDimitry Andric auto *TemplateTM = unwrap(TM); 8205ffd83dbSDimitry Andric 8215ffd83dbSDimitry Andric auto JTMB = 8225ffd83dbSDimitry Andric std::make_unique<JITTargetMachineBuilder>(TemplateTM->getTargetTriple()); 8235ffd83dbSDimitry Andric 8245ffd83dbSDimitry Andric (*JTMB) 8255ffd83dbSDimitry Andric .setCPU(TemplateTM->getTargetCPU().str()) 8265ffd83dbSDimitry Andric .setRelocationModel(TemplateTM->getRelocationModel()) 8275ffd83dbSDimitry Andric .setCodeModel(TemplateTM->getCodeModel()) 8285ffd83dbSDimitry Andric .setCodeGenOptLevel(TemplateTM->getOptLevel()) 8295ffd83dbSDimitry Andric .setFeatures(TemplateTM->getTargetFeatureString()) 8305ffd83dbSDimitry Andric .setOptions(TemplateTM->Options); 8315ffd83dbSDimitry Andric 8325ffd83dbSDimitry Andric LLVMDisposeTargetMachine(TM); 8335ffd83dbSDimitry Andric 8345ffd83dbSDimitry Andric return wrap(JTMB.release()); 8355ffd83dbSDimitry Andric } 8365ffd83dbSDimitry Andric 8375ffd83dbSDimitry Andric void LLVMOrcDisposeJITTargetMachineBuilder( 8385ffd83dbSDimitry Andric LLVMOrcJITTargetMachineBuilderRef JTMB) { 8395ffd83dbSDimitry Andric delete unwrap(JTMB); 8405ffd83dbSDimitry Andric } 8415ffd83dbSDimitry Andric 842fe6060f1SDimitry Andric char *LLVMOrcJITTargetMachineBuilderGetTargetTriple( 843fe6060f1SDimitry Andric LLVMOrcJITTargetMachineBuilderRef JTMB) { 844fe6060f1SDimitry Andric auto Tmp = unwrap(JTMB)->getTargetTriple().str(); 845fe6060f1SDimitry Andric char *TargetTriple = (char *)malloc(Tmp.size() + 1); 846fe6060f1SDimitry Andric strcpy(TargetTriple, Tmp.c_str()); 847fe6060f1SDimitry Andric return TargetTriple; 848fe6060f1SDimitry Andric } 849fe6060f1SDimitry Andric 850fe6060f1SDimitry Andric void LLVMOrcJITTargetMachineBuilderSetTargetTriple( 851fe6060f1SDimitry Andric LLVMOrcJITTargetMachineBuilderRef JTMB, const char *TargetTriple) { 852fe6060f1SDimitry Andric unwrap(JTMB)->getTargetTriple() = Triple(TargetTriple); 853fe6060f1SDimitry Andric } 854fe6060f1SDimitry Andric 855fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcObjectLayerAddObjectFile(LLVMOrcObjectLayerRef ObjLayer, 856fe6060f1SDimitry Andric LLVMOrcJITDylibRef JD, 857fe6060f1SDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 858fe6060f1SDimitry Andric return wrap(unwrap(ObjLayer)->add( 859fe6060f1SDimitry Andric *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)))); 860fe6060f1SDimitry Andric } 861fe6060f1SDimitry Andric 862fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcObjectLayerRef ObjLayer, 863fe6060f1SDimitry Andric LLVMOrcResourceTrackerRef RT, 864fe6060f1SDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 865fe6060f1SDimitry Andric return wrap( 866fe6060f1SDimitry Andric unwrap(ObjLayer)->add(ResourceTrackerSP(unwrap(RT)), 867fe6060f1SDimitry Andric std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)))); 868fe6060f1SDimitry Andric } 869fe6060f1SDimitry Andric 870fe6060f1SDimitry Andric void LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer, 871fe6060f1SDimitry Andric LLVMOrcMaterializationResponsibilityRef R, 872fe6060f1SDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 873fe6060f1SDimitry Andric unwrap(ObjLayer)->emit( 874fe6060f1SDimitry Andric std::unique_ptr<MaterializationResponsibility>(unwrap(R)), 875fe6060f1SDimitry Andric std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer))); 876fe6060f1SDimitry Andric } 877fe6060f1SDimitry Andric 878d409305fSDimitry Andric void LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer) { 879e8d8bef9SDimitry Andric delete unwrap(ObjLayer); 880e8d8bef9SDimitry Andric } 881e8d8bef9SDimitry Andric 882fe6060f1SDimitry Andric void LLVMOrcIRTransformLayerSetTransform( 883fe6060f1SDimitry Andric LLVMOrcIRTransformLayerRef IRTransformLayer, 884fe6060f1SDimitry Andric LLVMOrcIRTransformLayerTransformFunction TransformFunction, void *Ctx) { 885fe6060f1SDimitry Andric unwrap(IRTransformLayer) 886fe6060f1SDimitry Andric ->setTransform( 887fe6060f1SDimitry Andric [=](ThreadSafeModule TSM, 888fe6060f1SDimitry Andric MaterializationResponsibility &R) -> Expected<ThreadSafeModule> { 889fe6060f1SDimitry Andric LLVMOrcThreadSafeModuleRef TSMRef = 890fe6060f1SDimitry Andric wrap(new ThreadSafeModule(std::move(TSM))); 891fe6060f1SDimitry Andric if (LLVMErrorRef Err = TransformFunction(Ctx, &TSMRef, wrap(&R))) { 892fe6060f1SDimitry Andric assert(!TSMRef && "TSMRef was not reset to null on error"); 893fe6060f1SDimitry Andric return unwrap(Err); 894fe6060f1SDimitry Andric } 895fe6060f1SDimitry Andric return std::move(*unwrap(TSMRef)); 896fe6060f1SDimitry Andric }); 897fe6060f1SDimitry Andric } 898fe6060f1SDimitry Andric 899fe6060f1SDimitry Andric void LLVMOrcObjectTransformLayerSetTransform( 900fe6060f1SDimitry Andric LLVMOrcObjectTransformLayerRef ObjTransformLayer, 901fe6060f1SDimitry Andric LLVMOrcObjectTransformLayerTransformFunction TransformFunction, void *Ctx) { 902fe6060f1SDimitry Andric unwrap(ObjTransformLayer) 903fe6060f1SDimitry Andric ->setTransform([TransformFunction, Ctx](std::unique_ptr<MemoryBuffer> Obj) 904fe6060f1SDimitry Andric -> Expected<std::unique_ptr<MemoryBuffer>> { 905fe6060f1SDimitry Andric LLVMMemoryBufferRef ObjBuffer = wrap(Obj.release()); 906fe6060f1SDimitry Andric if (LLVMErrorRef Err = TransformFunction(Ctx, &ObjBuffer)) { 907fe6060f1SDimitry Andric assert(!ObjBuffer && "ObjBuffer was not reset to null on error"); 908fe6060f1SDimitry Andric return unwrap(Err); 909fe6060f1SDimitry Andric } 910fe6060f1SDimitry Andric return std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)); 911fe6060f1SDimitry Andric }); 912fe6060f1SDimitry Andric } 913fe6060f1SDimitry Andric 914fe6060f1SDimitry Andric LLVMOrcDumpObjectsRef LLVMOrcCreateDumpObjects(const char *DumpDir, 915fe6060f1SDimitry Andric const char *IdentifierOverride) { 916fe6060f1SDimitry Andric assert(DumpDir && "DumpDir should not be null"); 917fe6060f1SDimitry Andric assert(IdentifierOverride && "IdentifierOverride should not be null"); 918fe6060f1SDimitry Andric return wrap(new DumpObjects(DumpDir, IdentifierOverride)); 919fe6060f1SDimitry Andric } 920fe6060f1SDimitry Andric 921fe6060f1SDimitry Andric void LLVMOrcDisposeDumpObjects(LLVMOrcDumpObjectsRef DumpObjects) { 922fe6060f1SDimitry Andric delete unwrap(DumpObjects); 923fe6060f1SDimitry Andric } 924fe6060f1SDimitry Andric 925fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcDumpObjects_CallOperator(LLVMOrcDumpObjectsRef DumpObjects, 926fe6060f1SDimitry Andric LLVMMemoryBufferRef *ObjBuffer) { 927fe6060f1SDimitry Andric std::unique_ptr<MemoryBuffer> OB(unwrap(*ObjBuffer)); 928fe6060f1SDimitry Andric if (auto Result = (*unwrap(DumpObjects))(std::move(OB))) { 929fe6060f1SDimitry Andric *ObjBuffer = wrap(Result->release()); 930fe6060f1SDimitry Andric return LLVMErrorSuccess; 931fe6060f1SDimitry Andric } else { 932fe6060f1SDimitry Andric *ObjBuffer = nullptr; 933fe6060f1SDimitry Andric return wrap(Result.takeError()); 934fe6060f1SDimitry Andric } 935fe6060f1SDimitry Andric } 936fe6060f1SDimitry Andric 9375ffd83dbSDimitry Andric LLVMOrcLLJITBuilderRef LLVMOrcCreateLLJITBuilder(void) { 9385ffd83dbSDimitry Andric return wrap(new LLJITBuilder()); 9395ffd83dbSDimitry Andric } 9405ffd83dbSDimitry Andric 9415ffd83dbSDimitry Andric void LLVMOrcDisposeLLJITBuilder(LLVMOrcLLJITBuilderRef Builder) { 9425ffd83dbSDimitry Andric delete unwrap(Builder); 9435ffd83dbSDimitry Andric } 9445ffd83dbSDimitry Andric 9455ffd83dbSDimitry Andric void LLVMOrcLLJITBuilderSetJITTargetMachineBuilder( 9465ffd83dbSDimitry Andric LLVMOrcLLJITBuilderRef Builder, LLVMOrcJITTargetMachineBuilderRef JTMB) { 947fe6060f1SDimitry Andric unwrap(Builder)->setJITTargetMachineBuilder(std::move(*unwrap(JTMB))); 948fe6060f1SDimitry Andric LLVMOrcDisposeJITTargetMachineBuilder(JTMB); 9495ffd83dbSDimitry Andric } 9505ffd83dbSDimitry Andric 951e8d8bef9SDimitry Andric void LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator( 952e8d8bef9SDimitry Andric LLVMOrcLLJITBuilderRef Builder, 953e8d8bef9SDimitry Andric LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F, void *Ctx) { 954e8d8bef9SDimitry Andric unwrap(Builder)->setObjectLinkingLayerCreator( 955e8d8bef9SDimitry Andric [=](ExecutionSession &ES, const Triple &TT) { 956e8d8bef9SDimitry Andric auto TTStr = TT.str(); 957e8d8bef9SDimitry Andric return std::unique_ptr<ObjectLayer>( 958e8d8bef9SDimitry Andric unwrap(F(Ctx, wrap(&ES), TTStr.c_str()))); 959e8d8bef9SDimitry Andric }); 960e8d8bef9SDimitry Andric } 961e8d8bef9SDimitry Andric 9625ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcCreateLLJIT(LLVMOrcLLJITRef *Result, 9635ffd83dbSDimitry Andric LLVMOrcLLJITBuilderRef Builder) { 9645ffd83dbSDimitry Andric assert(Result && "Result can not be null"); 9655ffd83dbSDimitry Andric 9665ffd83dbSDimitry Andric if (!Builder) 9675ffd83dbSDimitry Andric Builder = LLVMOrcCreateLLJITBuilder(); 9685ffd83dbSDimitry Andric 9695ffd83dbSDimitry Andric auto J = unwrap(Builder)->create(); 9705ffd83dbSDimitry Andric LLVMOrcDisposeLLJITBuilder(Builder); 9715ffd83dbSDimitry Andric 9725ffd83dbSDimitry Andric if (!J) { 97304eeddc0SDimitry Andric Result = nullptr; 9745ffd83dbSDimitry Andric return wrap(J.takeError()); 9755ffd83dbSDimitry Andric } 9765ffd83dbSDimitry Andric 9775ffd83dbSDimitry Andric *Result = wrap(J->release()); 9785ffd83dbSDimitry Andric return LLVMErrorSuccess; 9795ffd83dbSDimitry Andric } 9805ffd83dbSDimitry Andric 9815ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcDisposeLLJIT(LLVMOrcLLJITRef J) { 9825ffd83dbSDimitry Andric delete unwrap(J); 9835ffd83dbSDimitry Andric return LLVMErrorSuccess; 9845ffd83dbSDimitry Andric } 9855ffd83dbSDimitry Andric 9865ffd83dbSDimitry Andric LLVMOrcExecutionSessionRef LLVMOrcLLJITGetExecutionSession(LLVMOrcLLJITRef J) { 9875ffd83dbSDimitry Andric return wrap(&unwrap(J)->getExecutionSession()); 9885ffd83dbSDimitry Andric } 9895ffd83dbSDimitry Andric 9905ffd83dbSDimitry Andric LLVMOrcJITDylibRef LLVMOrcLLJITGetMainJITDylib(LLVMOrcLLJITRef J) { 9915ffd83dbSDimitry Andric return wrap(&unwrap(J)->getMainJITDylib()); 9925ffd83dbSDimitry Andric } 9935ffd83dbSDimitry Andric 9945ffd83dbSDimitry Andric const char *LLVMOrcLLJITGetTripleString(LLVMOrcLLJITRef J) { 9955ffd83dbSDimitry Andric return unwrap(J)->getTargetTriple().str().c_str(); 9965ffd83dbSDimitry Andric } 9975ffd83dbSDimitry Andric 9985ffd83dbSDimitry Andric char LLVMOrcLLJITGetGlobalPrefix(LLVMOrcLLJITRef J) { 9995ffd83dbSDimitry Andric return unwrap(J)->getDataLayout().getGlobalPrefix(); 10005ffd83dbSDimitry Andric } 10015ffd83dbSDimitry Andric 10025ffd83dbSDimitry Andric LLVMOrcSymbolStringPoolEntryRef 10035ffd83dbSDimitry Andric LLVMOrcLLJITMangleAndIntern(LLVMOrcLLJITRef J, const char *UnmangledName) { 1004fe6060f1SDimitry Andric return wrap(OrcV2CAPIHelper::moveFromSymbolStringPtr( 10055ffd83dbSDimitry Andric unwrap(J)->mangleAndIntern(UnmangledName))); 10065ffd83dbSDimitry Andric } 10075ffd83dbSDimitry Andric 10085ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcLLJITAddObjectFile(LLVMOrcLLJITRef J, LLVMOrcJITDylibRef JD, 10095ffd83dbSDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 10105ffd83dbSDimitry Andric return wrap(unwrap(J)->addObjectFile( 10115ffd83dbSDimitry Andric *unwrap(JD), std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)))); 10125ffd83dbSDimitry Andric } 10135ffd83dbSDimitry Andric 1014e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcLLJITAddObjectFileWithRT(LLVMOrcLLJITRef J, 1015e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef RT, 1016e8d8bef9SDimitry Andric LLVMMemoryBufferRef ObjBuffer) { 1017e8d8bef9SDimitry Andric return wrap(unwrap(J)->addObjectFile( 1018e8d8bef9SDimitry Andric ResourceTrackerSP(unwrap(RT)), 1019e8d8bef9SDimitry Andric std::unique_ptr<MemoryBuffer>(unwrap(ObjBuffer)))); 1020e8d8bef9SDimitry Andric } 1021e8d8bef9SDimitry Andric 10225ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcLLJITAddLLVMIRModule(LLVMOrcLLJITRef J, 10235ffd83dbSDimitry Andric LLVMOrcJITDylibRef JD, 10245ffd83dbSDimitry Andric LLVMOrcThreadSafeModuleRef TSM) { 1025e8d8bef9SDimitry Andric std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM)); 1026e8d8bef9SDimitry Andric return wrap(unwrap(J)->addIRModule(*unwrap(JD), std::move(*TmpTSM))); 1027e8d8bef9SDimitry Andric } 1028e8d8bef9SDimitry Andric 1029e8d8bef9SDimitry Andric LLVMErrorRef LLVMOrcLLJITAddLLVMIRModuleWithRT(LLVMOrcLLJITRef J, 1030e8d8bef9SDimitry Andric LLVMOrcResourceTrackerRef RT, 1031e8d8bef9SDimitry Andric LLVMOrcThreadSafeModuleRef TSM) { 1032e8d8bef9SDimitry Andric std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM)); 1033e8d8bef9SDimitry Andric return wrap(unwrap(J)->addIRModule(ResourceTrackerSP(unwrap(RT)), 1034e8d8bef9SDimitry Andric std::move(*TmpTSM))); 10355ffd83dbSDimitry Andric } 10365ffd83dbSDimitry Andric 10375ffd83dbSDimitry Andric LLVMErrorRef LLVMOrcLLJITLookup(LLVMOrcLLJITRef J, 10385ffd83dbSDimitry Andric LLVMOrcJITTargetAddress *Result, 10395ffd83dbSDimitry Andric const char *Name) { 10405ffd83dbSDimitry Andric assert(Result && "Result can not be null"); 10415ffd83dbSDimitry Andric 10425ffd83dbSDimitry Andric auto Sym = unwrap(J)->lookup(Name); 10435ffd83dbSDimitry Andric if (!Sym) { 10445ffd83dbSDimitry Andric *Result = 0; 10455ffd83dbSDimitry Andric return wrap(Sym.takeError()); 10465ffd83dbSDimitry Andric } 10475ffd83dbSDimitry Andric 1048*81ad6265SDimitry Andric *Result = Sym->getValue(); 10495ffd83dbSDimitry Andric return LLVMErrorSuccess; 10505ffd83dbSDimitry Andric } 1051e8d8bef9SDimitry Andric 1052fe6060f1SDimitry Andric LLVMOrcObjectLayerRef LLVMOrcLLJITGetObjLinkingLayer(LLVMOrcLLJITRef J) { 1053fe6060f1SDimitry Andric return wrap(&unwrap(J)->getObjLinkingLayer()); 1054fe6060f1SDimitry Andric } 1055fe6060f1SDimitry Andric 1056fe6060f1SDimitry Andric LLVMOrcObjectTransformLayerRef 1057fe6060f1SDimitry Andric LLVMOrcLLJITGetObjTransformLayer(LLVMOrcLLJITRef J) { 1058fe6060f1SDimitry Andric return wrap(&unwrap(J)->getObjTransformLayer()); 1059fe6060f1SDimitry Andric } 1060fe6060f1SDimitry Andric 1061e8d8bef9SDimitry Andric LLVMOrcObjectLayerRef 1062e8d8bef9SDimitry Andric LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager( 1063e8d8bef9SDimitry Andric LLVMOrcExecutionSessionRef ES) { 1064e8d8bef9SDimitry Andric assert(ES && "ES must not be null"); 1065e8d8bef9SDimitry Andric return wrap(new RTDyldObjectLinkingLayer( 1066e8d8bef9SDimitry Andric *unwrap(ES), [] { return std::make_unique<SectionMemoryManager>(); })); 1067e8d8bef9SDimitry Andric } 1068e8d8bef9SDimitry Andric 1069e8d8bef9SDimitry Andric void LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener( 1070e8d8bef9SDimitry Andric LLVMOrcObjectLayerRef RTDyldObjLinkingLayer, 1071e8d8bef9SDimitry Andric LLVMJITEventListenerRef Listener) { 1072e8d8bef9SDimitry Andric assert(RTDyldObjLinkingLayer && "RTDyldObjLinkingLayer must not be null"); 1073e8d8bef9SDimitry Andric assert(Listener && "Listener must not be null"); 1074e8d8bef9SDimitry Andric reinterpret_cast<RTDyldObjectLinkingLayer *>(unwrap(RTDyldObjLinkingLayer)) 1075e8d8bef9SDimitry Andric ->registerJITEventListener(*unwrap(Listener)); 1076e8d8bef9SDimitry Andric } 1077fe6060f1SDimitry Andric 1078fe6060f1SDimitry Andric LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J) { 1079fe6060f1SDimitry Andric return wrap(&unwrap(J)->getIRTransformLayer()); 1080fe6060f1SDimitry Andric } 1081fe6060f1SDimitry Andric 1082fe6060f1SDimitry Andric const char *LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J) { 1083fe6060f1SDimitry Andric return unwrap(J)->getDataLayout().getStringRepresentation().c_str(); 1084fe6060f1SDimitry Andric } 1085fe6060f1SDimitry Andric 1086fe6060f1SDimitry Andric LLVMOrcIndirectStubsManagerRef 1087fe6060f1SDimitry Andric LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple) { 1088fe6060f1SDimitry Andric auto builder = createLocalIndirectStubsManagerBuilder(Triple(TargetTriple)); 1089fe6060f1SDimitry Andric return wrap(builder().release()); 1090fe6060f1SDimitry Andric } 1091fe6060f1SDimitry Andric 1092fe6060f1SDimitry Andric void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM) { 1093fe6060f1SDimitry Andric std::unique_ptr<IndirectStubsManager> TmpISM(unwrap(ISM)); 1094fe6060f1SDimitry Andric } 1095fe6060f1SDimitry Andric 1096fe6060f1SDimitry Andric LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager( 1097fe6060f1SDimitry Andric const char *TargetTriple, LLVMOrcExecutionSessionRef ES, 1098fe6060f1SDimitry Andric LLVMOrcJITTargetAddress ErrorHandlerAddr, 1099fe6060f1SDimitry Andric LLVMOrcLazyCallThroughManagerRef *Result) { 1100fe6060f1SDimitry Andric auto LCTM = createLocalLazyCallThroughManager(Triple(TargetTriple), 1101fe6060f1SDimitry Andric *unwrap(ES), ErrorHandlerAddr); 1102fe6060f1SDimitry Andric 1103fe6060f1SDimitry Andric if (!LCTM) 1104fe6060f1SDimitry Andric return wrap(LCTM.takeError()); 1105fe6060f1SDimitry Andric *Result = wrap(LCTM->release()); 1106fe6060f1SDimitry Andric return LLVMErrorSuccess; 1107fe6060f1SDimitry Andric } 1108fe6060f1SDimitry Andric 1109fe6060f1SDimitry Andric void LLVMOrcDisposeLazyCallThroughManager( 1110fe6060f1SDimitry Andric LLVMOrcLazyCallThroughManagerRef LCM) { 1111fe6060f1SDimitry Andric std::unique_ptr<LazyCallThroughManager> TmpLCM(unwrap(LCM)); 1112fe6060f1SDimitry Andric } 1113