Delete APIs that have been deprecated since 2010.
[oota-llvm.git] / include / llvm-c / ExecutionEngine.h
1 /*===-- llvm-c/ExecutionEngine.h - ExecutionEngine 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 libLLVMExecutionEngine.o, which    *|
11 |* implements various analyses of the 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 \*===----------------------------------------------------------------------===*/
18
19 #ifndef LLVM_C_EXECUTIONENGINE_H
20 #define LLVM_C_EXECUTIONENGINE_H
21
22 #include "llvm-c/Types.h"
23 #include "llvm-c/Target.h"
24 #include "llvm-c/TargetMachine.h"
25
26 #ifdef __cplusplus
27 extern "C" {
28 #endif
29
30 /**
31  * @defgroup LLVMCExecutionEngine Execution Engine
32  * @ingroup LLVMC
33  *
34  * @{
35  */
36
37 void LLVMLinkInMCJIT(void);
38 void LLVMLinkInInterpreter(void);
39
40 typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
41 typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
42 typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
43
44 struct LLVMMCJITCompilerOptions {
45   unsigned OptLevel;
46   LLVMCodeModel CodeModel;
47   LLVMBool NoFramePointerElim;
48   LLVMBool EnableFastISel;
49   LLVMMCJITMemoryManagerRef MCJMM;
50 };
51
52 /*===-- Operations on generic values --------------------------------------===*/
53
54 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
55                                                 unsigned long long N,
56                                                 LLVMBool IsSigned);
57
58 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
59
60 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
61
62 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
63
64 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
65                                          LLVMBool IsSigned);
66
67 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
68
69 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
70
71 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
72
73 /*===-- Operations on execution engines -----------------------------------===*/
74
75 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
76                                             LLVMModuleRef M,
77                                             char **OutError);
78
79 LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
80                                         LLVMModuleRef M,
81                                         char **OutError);
82
83 LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
84                                         LLVMModuleRef M,
85                                         unsigned OptLevel,
86                                         char **OutError);
87
88 void LLVMInitializeMCJITCompilerOptions(
89   struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions);
90
91 /**
92  * Create an MCJIT execution engine for a module, with the given options. It is
93  * the responsibility of the caller to ensure that all fields in Options up to
94  * the given SizeOfOptions are initialized. It is correct to pass a smaller
95  * value of SizeOfOptions that omits some fields. The canonical way of using
96  * this is:
97  *
98  * LLVMMCJITCompilerOptions options;
99  * LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
100  * ... fill in those options you care about
101  * LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
102  *                                  &error);
103  *
104  * Note that this is also correct, though possibly suboptimal:
105  *
106  * LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
107  */
108 LLVMBool LLVMCreateMCJITCompilerForModule(
109   LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
110   struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
111   char **OutError);
112
113 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
114
115 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
116
117 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
118
119 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
120                           unsigned ArgC, const char * const *ArgV,
121                           const char * const *EnvP);
122
123 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
124                                     unsigned NumArgs,
125                                     LLVMGenericValueRef *Args);
126
127 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
128
129 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
130
131 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
132                           LLVMModuleRef *OutMod, char **OutError);
133
134 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
135                           LLVMValueRef *OutFn);
136
137 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
138                                      LLVMValueRef Fn);
139
140 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
141 LLVMTargetMachineRef
142 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
143
144 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
145                           void* Addr);
146
147 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
148
149 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
150
151 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
152
153 /*===-- Operations on memory managers -------------------------------------===*/
154
155 typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
156   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
157   const char *SectionName);
158 typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
159   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
160   const char *SectionName, LLVMBool IsReadOnly);
161 typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
162   void *Opaque, char **ErrMsg);
163 typedef void (*LLVMMemoryManagerDestroyCallback)(void *Opaque);
164
165 /**
166  * Create a simple custom MCJIT memory manager. This memory manager can
167  * intercept allocations in a module-oblivious way. This will return NULL
168  * if any of the passed functions are NULL.
169  *
170  * @param Opaque An opaque client object to pass back to the callbacks.
171  * @param AllocateCodeSection Allocate a block of memory for executable code.
172  * @param AllocateDataSection Allocate a block of memory for data.
173  * @param FinalizeMemory Set page permissions and flush cache. Return 0 on
174  *   success, 1 on error.
175  */
176 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
177   void *Opaque,
178   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
179   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
180   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
181   LLVMMemoryManagerDestroyCallback Destroy);
182
183 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
184
185 /**
186  * @}
187  */
188
189 #ifdef __cplusplus
190 }
191 #endif /* defined(__cplusplus) */
192
193 #endif