[autoconf] Detect OLE32 for mingw.
[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/Core.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 /** Deprecated: Use LLVMCreateExecutionEngineForModule instead. */
114 LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
115                                    LLVMModuleProviderRef MP,
116                                    char **OutError);
117
118 /** Deprecated: Use LLVMCreateInterpreterForModule instead. */
119 LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
120                                LLVMModuleProviderRef MP,
121                                char **OutError);
122
123 /** Deprecated: Use LLVMCreateJITCompilerForModule instead. */
124 LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
125                                LLVMModuleProviderRef MP,
126                                unsigned OptLevel,
127                                char **OutError);
128
129 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
130
131 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
132
133 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
134
135 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
136                           unsigned ArgC, const char * const *ArgV,
137                           const char * const *EnvP);
138
139 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
140                                     unsigned NumArgs,
141                                     LLVMGenericValueRef *Args);
142
143 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
144
145 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
146
147 /** Deprecated: Use LLVMAddModule instead. */
148 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP);
149
150 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
151                           LLVMModuleRef *OutMod, char **OutError);
152
153 /** Deprecated: Use LLVMRemoveModule instead. */
154 LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
155                                   LLVMModuleProviderRef MP,
156                                   LLVMModuleRef *OutMod, char **OutError);
157
158 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
159                           LLVMValueRef *OutFn);
160
161 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
162                                      LLVMValueRef Fn);
163
164 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
165 LLVMTargetMachineRef
166 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
167
168 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
169                           void* Addr);
170
171 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
172
173 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
174
175 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
176
177 /*===-- Operations on memory managers -------------------------------------===*/
178
179 typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
180   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
181   const char *SectionName);
182 typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
183   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
184   const char *SectionName, LLVMBool IsReadOnly);
185 typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
186   void *Opaque, char **ErrMsg);
187 typedef void (*LLVMMemoryManagerDestroyCallback)(void *Opaque);
188
189 /**
190  * Create a simple custom MCJIT memory manager. This memory manager can
191  * intercept allocations in a module-oblivious way. This will return NULL
192  * if any of the passed functions are NULL.
193  *
194  * @param Opaque An opaque client object to pass back to the callbacks.
195  * @param AllocateCodeSection Allocate a block of memory for executable code.
196  * @param AllocateDataSection Allocate a block of memory for data.
197  * @param FinalizeMemory Set page permissions and flush cache. Return 0 on
198  *   success, 1 on error.
199  */
200 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
201   void *Opaque,
202   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
203   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
204   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
205   LLVMMemoryManagerDestroyCallback Destroy);
206
207 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
208
209 /**
210  * @}
211  */
212
213 #ifdef __cplusplus
214 }
215 #endif /* defined(__cplusplus) */
216
217 #endif