1 //===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the C bindings for the ExecutionEngine library.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "jit"
15 #include "llvm-c/ExecutionEngine.h"
16 #include "llvm/ExecutionEngine/ExecutionEngine.h"
17 #include "llvm/ExecutionEngine/GenericValue.h"
18 #include "llvm/IR/DerivedTypes.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Support/ErrorHandling.h"
25 // Wrapping the C bindings types.
26 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef)
28 inline DataLayout *unwrap(LLVMTargetDataRef P) {
29 return reinterpret_cast<DataLayout*>(P);
32 inline LLVMTargetDataRef wrap(const DataLayout *P) {
33 return reinterpret_cast<LLVMTargetDataRef>(const_cast<DataLayout*>(P));
36 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
37 return reinterpret_cast<TargetLibraryInfo*>(P);
40 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
41 TargetLibraryInfo *X = const_cast<TargetLibraryInfo*>(P);
42 return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
45 /*===-- Operations on generic values --------------------------------------===*/
47 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
50 GenericValue *GenVal = new GenericValue();
51 GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
55 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
56 GenericValue *GenVal = new GenericValue();
57 GenVal->PointerVal = P;
61 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
62 GenericValue *GenVal = new GenericValue();
63 switch (unwrap(TyRef)->getTypeID()) {
67 case Type::DoubleTyID:
68 GenVal->DoubleVal = N;
71 llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
76 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
77 return unwrap(GenValRef)->IntVal.getBitWidth();
80 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
82 GenericValue *GenVal = unwrap(GenValRef);
84 return GenVal->IntVal.getSExtValue();
86 return GenVal->IntVal.getZExtValue();
89 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
90 return unwrap(GenVal)->PointerVal;
93 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
94 switch (unwrap(TyRef)->getTypeID()) {
96 return unwrap(GenVal)->FloatVal;
97 case Type::DoubleTyID:
98 return unwrap(GenVal)->DoubleVal;
100 llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
104 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
105 delete unwrap(GenVal);
108 /*===-- Operations on execution engines -----------------------------------===*/
110 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
114 EngineBuilder builder(unwrap(M));
115 builder.setEngineKind(EngineKind::Either)
116 .setErrorStr(&Error);
117 if (ExecutionEngine *EE = builder.create()){
121 *OutError = strdup(Error.c_str());
125 LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
129 EngineBuilder builder(unwrap(M));
130 builder.setEngineKind(EngineKind::Interpreter)
131 .setErrorStr(&Error);
132 if (ExecutionEngine *Interp = builder.create()) {
133 *OutInterp = wrap(Interp);
136 *OutError = strdup(Error.c_str());
140 LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
145 EngineBuilder builder(unwrap(M));
146 builder.setEngineKind(EngineKind::JIT)
148 .setOptLevel((CodeGenOpt::Level)OptLevel);
149 if (ExecutionEngine *JIT = builder.create()) {
153 *OutError = strdup(Error.c_str());
157 void LLVMInitializeMCJITCompilerOptions(LLVMMCJITCompilerOptions *PassedOptions,
158 size_t SizeOfPassedOptions) {
159 LLVMMCJITCompilerOptions options;
160 options.OptLevel = 0;
161 options.CodeModel = LLVMCodeModelJITDefault;
162 options.NoFramePointerElim = false;
163 options.EnableFastISel = false;
165 memcpy(PassedOptions, &options,
166 std::min(sizeof(options), SizeOfPassedOptions));
169 LLVMBool LLVMCreateMCJITCompilerForModule(
170 LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
171 LLVMMCJITCompilerOptions *PassedOptions, size_t SizeOfPassedOptions,
173 LLVMMCJITCompilerOptions options;
174 // If the user passed a larger sized options struct, then they were compiled
175 // against a newer LLVM. Tell them that something is wrong.
176 if (SizeOfPassedOptions > sizeof(options)) {
178 "Refusing to use options struct that is larger than my own; assuming "
179 "LLVM library mismatch.");
183 // Defend against the user having an old version of the API by ensuring that
184 // any fields they didn't see are cleared. We must defend against fields being
185 // set to the bitwise equivalent of zero, and assume that this means "do the
186 // default" as if that option hadn't been available.
187 LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
188 memcpy(&options, PassedOptions, SizeOfPassedOptions);
190 TargetOptions targetOptions;
191 targetOptions.NoFramePointerElim = options.NoFramePointerElim;
192 targetOptions.EnableFastISel = options.EnableFastISel;
195 EngineBuilder builder(unwrap(M));
196 builder.setEngineKind(EngineKind::JIT)
199 .setOptLevel((CodeGenOpt::Level)options.OptLevel)
200 .setCodeModel(unwrap(options.CodeModel))
201 .setTargetOptions(targetOptions);
202 if (ExecutionEngine *JIT = builder.create()) {
206 *OutError = strdup(Error.c_str());
210 LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
211 LLVMModuleProviderRef MP,
213 /* The module provider is now actually a module. */
214 return LLVMCreateExecutionEngineForModule(OutEE,
215 reinterpret_cast<LLVMModuleRef>(MP),
219 LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
220 LLVMModuleProviderRef MP,
222 /* The module provider is now actually a module. */
223 return LLVMCreateInterpreterForModule(OutInterp,
224 reinterpret_cast<LLVMModuleRef>(MP),
228 LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
229 LLVMModuleProviderRef MP,
232 /* The module provider is now actually a module. */
233 return LLVMCreateJITCompilerForModule(OutJIT,
234 reinterpret_cast<LLVMModuleRef>(MP),
239 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
243 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
244 unwrap(EE)->runStaticConstructorsDestructors(false);
247 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
248 unwrap(EE)->runStaticConstructorsDestructors(true);
251 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
252 unsigned ArgC, const char * const *ArgV,
253 const char * const *EnvP) {
254 unwrap(EE)->finalizeObject();
256 std::vector<std::string> ArgVec;
257 for (unsigned I = 0; I != ArgC; ++I)
258 ArgVec.push_back(ArgV[I]);
260 return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
263 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
265 LLVMGenericValueRef *Args) {
266 unwrap(EE)->finalizeObject();
268 std::vector<GenericValue> ArgVec;
269 ArgVec.reserve(NumArgs);
270 for (unsigned I = 0; I != NumArgs; ++I)
271 ArgVec.push_back(*unwrap(Args[I]));
273 GenericValue *Result = new GenericValue();
274 *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
278 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
279 unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
282 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
283 unwrap(EE)->addModule(unwrap(M));
286 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
287 /* The module provider is now actually a module. */
288 LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP));
291 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
292 LLVMModuleRef *OutMod, char **OutError) {
293 Module *Mod = unwrap(M);
294 unwrap(EE)->removeModule(Mod);
299 LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
300 LLVMModuleProviderRef MP,
301 LLVMModuleRef *OutMod, char **OutError) {
302 /* The module provider is now actually a module. */
303 return LLVMRemoveModule(EE, reinterpret_cast<LLVMModuleRef>(MP), OutMod,
307 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
308 LLVMValueRef *OutFn) {
309 if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
316 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
318 return unwrap(EE)->recompileAndRelinkFunction(unwrap<Function>(Fn));
321 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
322 return wrap(unwrap(EE)->getDataLayout());
325 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
327 unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
330 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
331 unwrap(EE)->finalizeObject();
333 return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));