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