contrib/llvm/lib/ExecutionEngine/Orc/OrcCBindings.cpp

   1 //===----------- OrcCBindings.cpp - C bindings for the Orc APIs -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "OrcCBindingsStack.h"
  11 #include "llvm-c/OrcBindings.h"
  12 #include "llvm/ExecutionEngine/JITEventListener.h"
  13
  14 using namespace llvm;
  15
  16 LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
  17   TargetMachine *TM2(unwrap(TM));
  18
  19   Triple T(TM2->getTargetTriple());
  20
  21   auto IndirectStubsMgrBuilder =
  22       orc::createLocalIndirectStubsManagerBuilder(T);
  23
  24   OrcCBindingsStack *JITStack =
  25       new OrcCBindingsStack(*TM2, std::move(IndirectStubsMgrBuilder));
  26
  27   return wrap(JITStack);
  28 }
  29
  30 const char *LLVMOrcGetErrorMsg(LLVMOrcJITStackRef JITStack) {
  31   OrcCBindingsStack &J = *unwrap(JITStack);
  32   return J.getErrorMessage().c_str();
  33 }
  34
  35 void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledName,
  36                              const char *SymbolName) {
  37   OrcCBindingsStack &J = *unwrap(JITStack);
  38   std::string Mangled = J.mangle(SymbolName);
  39   *MangledName = new char[Mangled.size() + 1];
  40   strcpy(*MangledName, Mangled.c_str());
  41 }
  42
  43 void LLVMOrcDisposeMangledSymbol(char *MangledName) { delete[] MangledName; }
  44
  45 LLVMErrorRef LLVMOrcCreateLazyCompileCallback(
  46     LLVMOrcJITStackRef JITStack, LLVMOrcTargetAddress *RetAddr,
  47     LLVMOrcLazyCompileCallbackFn Callback, void *CallbackCtx) {
  48   OrcCBindingsStack &J = *unwrap(JITStack);
  49   if (auto Addr = J.createLazyCompileCallback(Callback, CallbackCtx)) {
  50     *RetAddr = *Addr;
  51     return LLVMErrorSuccess;
  52   } else
  53     return wrap(Addr.takeError());
  54 }
  55
  56 LLVMErrorRef LLVMOrcCreateIndirectStub(LLVMOrcJITStackRef JITStack,
  57                                        const char *StubName,
  58                                        LLVMOrcTargetAddress InitAddr) {
  59   OrcCBindingsStack &J = *unwrap(JITStack);
  60   return wrap(J.createIndirectStub(StubName, InitAddr));
  61 }
  62
  63 LLVMErrorRef LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack,
  64                                            const char *StubName,
  65                                            LLVMOrcTargetAddress NewAddr) {
  66   OrcCBindingsStack &J = *unwrap(JITStack);
  67   return wrap(J.setIndirectStubPointer(StubName, NewAddr));
  68 }
  69
  70 LLVMErrorRef LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
  71                                          LLVMOrcModuleHandle *RetHandle,
  72                                          LLVMModuleRef Mod,
  73                                          LLVMOrcSymbolResolverFn SymbolResolver,
  74                                          void *SymbolResolverCtx) {
  75   OrcCBindingsStack &J = *unwrap(JITStack);
  76   std::unique_ptr<Module> M(unwrap(Mod));
  77   if (auto Handle =
  78           J.addIRModuleEager(std::move(M), SymbolResolver, SymbolResolverCtx)) {
  79     *RetHandle = *Handle;
  80     return LLVMErrorSuccess;
  81   } else
  82     return wrap(Handle.takeError());
  83 }
  84
  85 LLVMErrorRef LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
  86                                         LLVMOrcModuleHandle *RetHandle,
  87                                         LLVMModuleRef Mod,
  88                                         LLVMOrcSymbolResolverFn SymbolResolver,
  89                                         void *SymbolResolverCtx) {
  90   OrcCBindingsStack &J = *unwrap(JITStack);
  91   std::unique_ptr<Module> M(unwrap(Mod));
  92   if (auto Handle =
  93           J.addIRModuleLazy(std::move(M), SymbolResolver, SymbolResolverCtx)) {
  94     *RetHandle = *Handle;
  95     return LLVMErrorSuccess;
  96   } else
  97     return wrap(Handle.takeError());
  98 }
  99
 100 LLVMErrorRef LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack,
 101                                   LLVMOrcModuleHandle *RetHandle,
 102                                   LLVMMemoryBufferRef Obj,
 103                                   LLVMOrcSymbolResolverFn SymbolResolver,
 104                                   void *SymbolResolverCtx) {
 105   OrcCBindingsStack &J = *unwrap(JITStack);
 106   std::unique_ptr<MemoryBuffer> O(unwrap(Obj));
 107   if (auto Handle =
 108           J.addObject(std::move(O), SymbolResolver, SymbolResolverCtx)) {
 109     *RetHandle = *Handle;
 110     return LLVMErrorSuccess;
 111   } else
 112     return wrap(Handle.takeError());
 113 }
 114
 115 LLVMErrorRef LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack,
 116                                  LLVMOrcModuleHandle H) {
 117   OrcCBindingsStack &J = *unwrap(JITStack);
 118   return wrap(J.removeModule(H));
 119 }
 120
 121 LLVMErrorRef LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack,
 122                                      LLVMOrcTargetAddress *RetAddr,
 123                                      const char *SymbolName) {
 124   OrcCBindingsStack &J = *unwrap(JITStack);
 125   if (auto Addr = J.findSymbolAddress(SymbolName, true)) {
 126     *RetAddr = *Addr;
 127     return LLVMErrorSuccess;
 128   } else
 129     return wrap(Addr.takeError());
 130 }
 131
 132 LLVMErrorRef LLVMOrcGetSymbolAddressIn(LLVMOrcJITStackRef JITStack,
 133                                        LLVMOrcTargetAddress *RetAddr,
 134                                        LLVMOrcModuleHandle H,
 135                                        const char *SymbolName) {
 136   OrcCBindingsStack &J = *unwrap(JITStack);
 137   if (auto Addr = J.findSymbolAddressIn(H, SymbolName, true)) {
 138     *RetAddr = *Addr;
 139     return LLVMErrorSuccess;
 140   } else
 141     return wrap(Addr.takeError());
 142 }
 143
 144 LLVMErrorRef LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack) {
 145   auto *J = unwrap(JITStack);
 146   auto Err = J->shutdown();
 147   delete J;
 148   return wrap(std::move(Err));
 149 }
 150
 151 void LLVMOrcRegisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L)
 152 {
 153   unwrap(JITStack)->RegisterJITEventListener(unwrap(L));
 154 }
 155
 156 void LLVMOrcUnregisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L)
 157 {
 158   unwrap(JITStack)->UnregisterJITEventListener(unwrap(L));
 159 }