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
27extern "C" {
28#endif
29
30/**
31 * @defgroup LLVMCExecutionEngine Execution Engine
32 * @ingroup LLVMC
33 *
34 * @{
35 */
36
37void LLVMLinkInMCJIT(void);
38void LLVMLinkInInterpreter(void);
39
40typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
41typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
42typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
43
44struct LLVMMCJITCompilerOptions {
45  unsigned OptLevel;
46  LLVMCodeModel CodeModel;
47  LLVMBool NoFramePointerElim;
48  LLVMBool EnableFastISel;
49  LLVMMCJITMemoryManagerRef MCJMM;
50};
51
52/*===-- Operations on generic values --------------------------------------===*/
53
54LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
55                                                unsigned long long N,
56                                                LLVMBool IsSigned);
57
58LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
59
60LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
61
62unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
63
64unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
65                                         LLVMBool IsSigned);
66
67void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
68
69double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
70
71void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
72
73/*===-- Operations on execution engines -----------------------------------===*/
74
75LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
76                                            LLVMModuleRef M,
77                                            char **OutError);
78
79LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
80                                        LLVMModuleRef M,
81                                        char **OutError);
82
83LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
84                                        LLVMModuleRef M,
85                                        unsigned OptLevel,
86                                        char **OutError);
87
88void 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 */
108LLVMBool LLVMCreateMCJITCompilerForModule(
109  LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
110  struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
111  char **OutError);
112
113void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
114
115void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
116
117void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
118
119int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
120                          unsigned ArgC, const char * const *ArgV,
121                          const char * const *EnvP);
122
123LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
124                                    unsigned NumArgs,
125                                    LLVMGenericValueRef *Args);
126
127void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
128
129void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
130
131LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
132                          LLVMModuleRef *OutMod, char **OutError);
133
134LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
135                          LLVMValueRef *OutFn);
136
137void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
138                                     LLVMValueRef Fn);
139
140LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
141LLVMTargetMachineRef
142LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
143
144void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
145                          void* Addr);
146
147void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
148
149uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
150
151uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
152
153/*===-- Operations on memory managers -------------------------------------===*/
154
155typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
156  void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
157  const char *SectionName);
158typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
159  void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
160  const char *SectionName, LLVMBool IsReadOnly);
161typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
162  void *Opaque, char **ErrMsg);
163typedef 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 */
176LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
177  void *Opaque,
178  LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
179  LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
180  LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
181  LLVMMemoryManagerDestroyCallback Destroy);
182
183void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
184
185/**
186 * @}
187 */
188
189#ifdef __cplusplus
190}
191#endif /* defined(__cplusplus) */
192
193#endif
194