Home | History | Annotate | Download | only in llvm-c 
      1 /*===----------- llvm-c/OrcBindings.h - Orc Lib C Iface ---------*- C++ -*-===*\
      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 |* This header declares the C interface to libLLVMOrcJIT.a, which implements  *|
     11 |* JIT compilation of LLVM IR.                                                *|
     12 |*                                                                            *|
     13 |* Many exotic languages can interoperate with C code but have a harder time  *|
     14 |* with C++ due to name mangling. So in addition to C, this interface enables *|
     15 |* tools written in such languages.                                           *|
     16 |*                                                                            *|
     17 |* Note: This interface is experimental. It is *NOT* stable, and may be       *|
     18 |*       changed without warning.                                             *|
     19 |*                                                                            *|
     20 \*===----------------------------------------------------------------------===*/
     21 
     22 #ifndef LLVM_C_ORCBINDINGS_H
     23 #define LLVM_C_ORCBINDINGS_H
     24 
     25 #include "llvm-c/Object.h"
     26 #include "llvm-c/TargetMachine.h"
     27 
     28 #ifdef __cplusplus
     29 extern "C" {
     30 #endif
     31 
     32 typedef struct LLVMOrcOpaqueJITStack *LLVMOrcJITStackRef;
     33 typedef uint32_t LLVMOrcModuleHandle;
     34 typedef uint64_t LLVMOrcTargetAddress;
     35 typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name, void *LookupCtx);
     36 typedef uint64_t (*LLVMOrcLazyCompileCallbackFn)(LLVMOrcJITStackRef JITStack,
     37                                                  void *CallbackCtx);
     38 
     39 typedef enum { LLVMOrcErrSuccess = 0, LLVMOrcErrGeneric } LLVMOrcErrorCode;
     40 
     41 /**
     42  * Create an ORC JIT stack.
     43  *
     44  * The client owns the resulting stack, and must call OrcDisposeInstance(...)
     45  * to destroy it and free its memory. The JIT stack will take ownership of the
     46  * TargetMachine, which will be destroyed when the stack is destroyed. The
     47  * client should not attempt to dispose of the Target Machine, or it will result
     48  * in a double-free.
     49  */
     50 LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM);
     51 
     52 /**
     53  * Get the error message for the most recent error (if any).
     54  *
     55  * This message is owned by the ORC JIT Stack and will be freed when the stack
     56  * is disposed of by LLVMOrcDisposeInstance.
     57  */
     58 const char *LLVMOrcGetErrorMsg(LLVMOrcJITStackRef JITStack);
     59 
     60 /**
     61  * Mangle the given symbol.
     62  * Memory will be allocated for MangledSymbol to hold the result. The client
     63  */
     64 void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledSymbol,
     65                              const char *Symbol);
     66 
     67 /**
     68  * Dispose of a mangled symbol.
     69  */
     70 void LLVMOrcDisposeMangledSymbol(char *MangledSymbol);
     71 
     72 /**
     73  * Create a lazy compile callback.
     74  */
     75 LLVMOrcTargetAddress
     76 LLVMOrcCreateLazyCompileCallback(LLVMOrcJITStackRef JITStack,
     77                                  LLVMOrcLazyCompileCallbackFn Callback,
     78                                  void *CallbackCtx);
     79 
     80 /**
     81  * Create a named indirect call stub.
     82  */
     83 LLVMOrcErrorCode LLVMOrcCreateIndirectStub(LLVMOrcJITStackRef JITStack,
     84                                            const char *StubName,
     85                                            LLVMOrcTargetAddress InitAddr);
     86 
     87 /**
     88  * Set the pointer for the given indirect stub.
     89  */
     90 LLVMOrcErrorCode LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack,
     91                                                const char *StubName,
     92                                                LLVMOrcTargetAddress NewAddr);
     93 
     94 /**
     95  * Add module to be eagerly compiled.
     96  */
     97 LLVMOrcModuleHandle
     98 LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod,
     99                             LLVMOrcSymbolResolverFn SymbolResolver,
    100                             void *SymbolResolverCtx);
    101 
    102 /**
    103  * Add module to be lazily compiled one function at a time.
    104  */
    105 LLVMOrcModuleHandle
    106 LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod,
    107                            LLVMOrcSymbolResolverFn SymbolResolver,
    108                            void *SymbolResolverCtx);
    109 
    110 /**
    111  * Add an object file.
    112  */
    113 LLVMOrcModuleHandle LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack,
    114                                          LLVMObjectFileRef Obj,
    115                                          LLVMOrcSymbolResolverFn SymbolResolver,
    116                                          void *SymbolResolverCtx);
    117 
    118 /**
    119  * Remove a module set from the JIT.
    120  *
    121  * This works for all modules that can be added via OrcAdd*, including object
    122  * files.
    123  */
    124 void LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack, LLVMOrcModuleHandle H);
    125 
    126 /**
    127  * Get symbol address from JIT instance.
    128  */
    129 LLVMOrcTargetAddress LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack,
    130                                              const char *SymbolName);
    131 
    132 /**
    133  * Dispose of an ORC JIT stack.
    134  */
    135 void LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack);
    136 
    137 #ifdef __cplusplus
    138 }
    139 #endif /* extern "C" */
    140 
    141 #endif /* LLVM_C_ORCBINDINGS_H */
    142