llvm/lib/ExecutionEngine/Orc/OrcCBindings.cpp

//===----------- OrcCBindings.cpp - C bindings for the Orc APIs -----------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "OrcCBindingsStack.h"
#include "llvm-c/OrcBindings.h"

using namespace llvm;

LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM,
                                         LLVMContextRef Context) {
  TargetMachine *TM2(unwrap(TM));
  LLVMContext &Ctx = *unwrap(Context);

  Triple T(TM2->getTargetTriple());

  auto CallbackMgrBuilder = OrcCBindingsStack::createCallbackManagerBuilder(T);
  auto IndirectStubsMgrBuilder =
    OrcCBindingsStack::createIndirectStubsMgrBuilder(T);

  OrcCBindingsStack *JITStack =
    new OrcCBindingsStack(*TM2, Ctx, CallbackMgrBuilder,
                          IndirectStubsMgrBuilder);

  return wrap(JITStack);
}

void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledName,
                             const char *SymbolName) {
  OrcCBindingsStack &J = *unwrap(JITStack);
  std::string Mangled = J.mangle(SymbolName);
  *MangledName = new char[Mangled.size() + 1];
  strcpy(*MangledName, Mangled.c_str());
}

void LLVMOrcDisposeMangledSymbol(char *MangledName) {
  delete[] MangledName;
}

LLVMOrcTargetAddress
LLVMOrcCreateLazyCompileCallback(LLVMOrcJITStackRef JITStack,
                                 LLVMOrcLazyCompileCallbackFn Callback,
                                 void *CallbackCtx) {
  OrcCBindingsStack &J = *unwrap(JITStack);
  return J.createLazyCompileCallback(Callback, CallbackCtx);
}

void LLVMOrcCreateIndirectStub(LLVMOrcJITStackRef JITStack,
                               const char *StubName,
                               LLVMOrcTargetAddress InitAddr) {
  OrcCBindingsStack &J = *unwrap(JITStack);
  J.createIndirectStub(StubName, InitAddr);
}

void LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack,
                                   const char *StubName,
                                   LLVMOrcTargetAddress NewAddr) {
  OrcCBindingsStack &J = *unwrap(JITStack);
  J.setIndirectStubPointer(StubName, NewAddr);
}

LLVMOrcModuleHandle
LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod,
                            LLVMOrcSymbolResolverFn SymbolResolver,
                            void *SymbolResolverCtx) {
  OrcCBindingsStack &J = *unwrap(JITStack);
  Module *M(unwrap(Mod));
  return J.addIRModuleEager(M, SymbolResolver, SymbolResolverCtx);
}

LLVMOrcModuleHandle
LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod,
                           LLVMOrcSymbolResolverFn SymbolResolver,
                           void *SymbolResolverCtx) {
  OrcCBindingsStack &J = *unwrap(JITStack);
  Module *M(unwrap(Mod));
  return J.addIRModuleLazy(M, SymbolResolver, SymbolResolverCtx);
}

void LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack, LLVMOrcModuleHandle H) {
  OrcCBindingsStack &J = *unwrap(JITStack);
  J.removeModule(H);
}

LLVMOrcTargetAddress LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack,
                                             const char *SymbolName) {
  OrcCBindingsStack &J = *unwrap(JITStack);
  auto Sym = J.findSymbol(SymbolName, true);
  return Sym.getAddress();
}

void LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack) {
  delete unwrap(JITStack);
}