include/llvm-c/OrcBindings.h

   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/Support.h"
  27 #include "llvm-c/TargetMachine.h"
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 typedef struct LLVMOrcOpaqueJITStack *LLVMOrcJITStackRef;
  34 typedef uint32_t LLVMOrcModuleHandle;
  35 typedef uint64_t LLVMOrcTargetAddress;
  36 typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name,
  37                                             void *LookupCtx);
  38
  39 /**
  40  * Create an ORC JIT stack.
  41  *
  42  * The client owns the resulting stack, and must call OrcDisposeInstance(...)
  43  * to destroy it and free its memory. The JIT stack will take ownership of the
  44  * TargetMachine, which will be destroyed when the stack is destroyed. The
  45  * client should not attempt to dispose of the Target Machine, or it will result
  46  * in a double-free.
  47  */
  48 LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM,
  49                                          LLVMContextRef Context);
  50
  51 /**
  52  * Mangle the given symbol.
  53  * Memory will be allocated for MangledSymbol to hold the result. The client
  54  */
  55 void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledSymbol,
  56                              const char *Symbol);
  57
  58 /**
  59  * Dispose of a mangled symbol.
  60  */
  61
  62 void LLVMOrcDisposeMangledSymbol(char *MangledSymbol);
  63
  64 /**
  65  * Add module to be eagerly compiled.
  66  */
  67 LLVMOrcModuleHandle
  68 LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod,
  69                             LLVMOrcSymbolResolverFn SymbolResolver,
  70                             void *SymbolResolverCtx);
  71
  72 /**
  73  * Add module to be lazily compiled one function at a time.
  74  */
  75 LLVMOrcModuleHandle
  76 LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod,
  77                            LLVMOrcSymbolResolverFn SymbolResolver,
  78                            void *SymbolResolverCtx);
  79
  80 /**
  81  * Add an object file.
  82  */
  83 LLVMOrcModuleHandle
  84 LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack, LLVMObjectFileRef Obj,
  85                      LLVMOrcSymbolResolverFn SymbolResolver,
  86                      void *SymbolResolverCtx);
  87
  88 /**
  89  * Remove a module set from the JIT.
  90  *
  91  * This works for all modules that can be added via OrcAdd*, including object
  92  * files.
  93  */
  94 void LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack, LLVMOrcModuleHandle H);
  95
  96 /**
  97  * Get symbol address from JIT instance.
  98  */
  99 LLVMOrcTargetAddress LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack,
 100                                              const char *SymbolName);
 101
 102 /**
 103  * Dispose of an ORC JIT stack.
 104  */
 105 void LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack);
 106
 107 #ifdef __cplusplus
 108 }
 109 #endif /* extern "C" */
 110
 111 #endif /* LLVM_C_ORCBINDINGS_H */