LCOV - code coverage report
Current view: top level - lib/ExecutionEngine/Orc - OrcCBindings.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 47 55 85.5 %
Date: 2017-09-14 15:23:50 Functions: 13 16 81.2 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : 
      13             : using namespace llvm;
      14             : 
      15           3 : LLVMSharedModuleRef LLVMOrcMakeSharedModule(LLVMModuleRef Mod) {
      16           6 :   return wrap(new std::shared_ptr<Module>(unwrap(Mod)));
      17             : }
      18             : 
      19           3 : void LLVMOrcDisposeSharedModuleRef(LLVMSharedModuleRef SharedMod) {
      20           6 :   delete unwrap(SharedMod);
      21           3 : }
      22             : 
      23             : LLVMSharedObjectBufferRef
      24           0 : LLVMOrcMakeSharedObjectBuffer(LLVMMemoryBufferRef ObjBuffer) {
      25           0 :   return wrap(new std::shared_ptr<MemoryBuffer>(unwrap(ObjBuffer)));
      26             : }
      27             : 
      28             : void
      29           0 : LLVMOrcDisposeSharedObjectBufferRef(LLVMSharedObjectBufferRef SharedObjBuffer) {
      30           0 :   delete unwrap(SharedObjBuffer);
      31           0 : }
      32             : 
      33           3 : LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
      34           3 :   TargetMachine *TM2(unwrap(TM));
      35             : 
      36           6 :   Triple T(TM2->getTargetTriple());
      37             : 
      38           6 :   auto CompileCallbackMgr = orc::createLocalCompileCallbackManager(T, 0);
      39             :   auto IndirectStubsMgrBuilder =
      40           6 :       orc::createLocalIndirectStubsManagerBuilder(T);
      41             : 
      42             :   OrcCBindingsStack *JITStack = new OrcCBindingsStack(
      43          15 :       *TM2, std::move(CompileCallbackMgr), IndirectStubsMgrBuilder);
      44             : 
      45           6 :   return wrap(JITStack);
      46             : }
      47             : 
      48           0 : const char *LLVMOrcGetErrorMsg(LLVMOrcJITStackRef JITStack) {
      49           0 :   OrcCBindingsStack &J = *unwrap(JITStack);
      50           0 :   return J.getErrorMessage().c_str();
      51             : }
      52             : 
      53           3 : void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledName,
      54             :                              const char *SymbolName) {
      55           3 :   OrcCBindingsStack &J = *unwrap(JITStack);
      56           6 :   std::string Mangled = J.mangle(SymbolName);
      57           3 :   *MangledName = new char[Mangled.size() + 1];
      58           3 :   strcpy(*MangledName, Mangled.c_str());
      59           3 : }
      60             : 
      61           3 : void LLVMOrcDisposeMangledSymbol(char *MangledName) { delete[] MangledName; }
      62             : 
      63             : LLVMOrcErrorCode
      64           1 : LLVMOrcCreateLazyCompileCallback(LLVMOrcJITStackRef JITStack,
      65             :                                  LLVMOrcTargetAddress *RetAddr,
      66             :                                  LLVMOrcLazyCompileCallbackFn Callback,
      67             :                                  void *CallbackCtx) {
      68           1 :   OrcCBindingsStack &J = *unwrap(JITStack);
      69           1 :   return J.createLazyCompileCallback(*RetAddr, Callback, CallbackCtx);
      70             : }
      71             : 
      72           1 : LLVMOrcErrorCode LLVMOrcCreateIndirectStub(LLVMOrcJITStackRef JITStack,
      73             :                                            const char *StubName,
      74             :                                            LLVMOrcTargetAddress InitAddr) {
      75           1 :   OrcCBindingsStack &J = *unwrap(JITStack);
      76           1 :   return J.createIndirectStub(StubName, InitAddr);
      77             : }
      78             : 
      79           1 : LLVMOrcErrorCode LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack,
      80             :                                                const char *StubName,
      81             :                                                LLVMOrcTargetAddress NewAddr) {
      82           1 :   OrcCBindingsStack &J = *unwrap(JITStack);
      83           1 :   return J.setIndirectStubPointer(StubName, NewAddr);
      84             : }
      85             : 
      86             : LLVMOrcErrorCode
      87           2 : LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
      88             :                             LLVMOrcModuleHandle *RetHandle,
      89             :                             LLVMSharedModuleRef Mod,
      90             :                             LLVMOrcSymbolResolverFn SymbolResolver,
      91             :                             void *SymbolResolverCtx) {
      92           2 :   OrcCBindingsStack &J = *unwrap(JITStack);
      93           2 :   std::shared_ptr<Module> *M(unwrap(Mod));
      94           4 :   return J.addIRModuleEager(*RetHandle, *M, SymbolResolver, SymbolResolverCtx);
      95             : }
      96             : 
      97             : LLVMOrcErrorCode
      98           1 : LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
      99             :                            LLVMOrcModuleHandle *RetHandle,
     100             :                            LLVMSharedModuleRef Mod,
     101             :                            LLVMOrcSymbolResolverFn SymbolResolver,
     102             :                            void *SymbolResolverCtx) {
     103           1 :   OrcCBindingsStack &J = *unwrap(JITStack);
     104           1 :   std::shared_ptr<Module> *M(unwrap(Mod));
     105           2 :   return J.addIRModuleLazy(*RetHandle, *M, SymbolResolver, SymbolResolverCtx);
     106             : }
     107             : 
     108           3 : LLVMOrcErrorCode LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack,
     109             :                                      LLVMOrcModuleHandle H) {
     110           3 :   OrcCBindingsStack &J = *unwrap(JITStack);
     111           3 :   return J.removeModule(H);
     112             : }
     113             : 
     114           4 : LLVMOrcErrorCode LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack,
     115             :                                          LLVMOrcTargetAddress *RetAddr,
     116             :                                          const char *SymbolName) {
     117           4 :   OrcCBindingsStack &J = *unwrap(JITStack);
     118          16 :   return J.findSymbolAddress(*RetAddr, SymbolName, true);
     119             : }
     120             : 
     121           3 : LLVMOrcErrorCode LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack) {
     122           3 :   auto *J = unwrap(JITStack);
     123           3 :   auto Err = J->shutdown();
     124           3 :   delete J;
     125           3 :   return Err;
     126             : }

Generated by: LCOV version 1.13