ExecutionEngineBindings.cpp revision e602f473062a91e6ac9aa17097de8b5cd75b0852 
1//===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===//
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 file defines the C bindings for the ExecutionEngine library.
11//
12//===----------------------------------------------------------------------===//
13
14#define DEBUG_TYPE "jit"
15#include "llvm-c/ExecutionEngine.h"
16#include "llvm/ExecutionEngine/GenericValue.h"
17#include "llvm/ExecutionEngine/ExecutionEngine.h"
18#include "llvm/Support/ErrorHandling.h"
19#include <cstring>
20
21using namespace llvm;
22
23/*===-- Operations on generic values --------------------------------------===*/
24
25LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
26                                                unsigned long long N,
27                                                LLVMBool IsSigned) {
28  GenericValue *GenVal = new GenericValue();
29  GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
30  return wrap(GenVal);
31}
32
33LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
34  GenericValue *GenVal = new GenericValue();
35  GenVal->PointerVal = P;
36  return wrap(GenVal);
37}
38
39LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
40  GenericValue *GenVal = new GenericValue();
41  switch (unwrap(TyRef)->getTypeID()) {
42  case Type::FloatTyID:
43    GenVal->FloatVal = N;
44    break;
45  case Type::DoubleTyID:
46    GenVal->DoubleVal = N;
47    break;
48  default:
49    llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
50  }
51  return wrap(GenVal);
52}
53
54unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
55  return unwrap(GenValRef)->IntVal.getBitWidth();
56}
57
58unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
59                                         LLVMBool IsSigned) {
60  GenericValue *GenVal = unwrap(GenValRef);
61  if (IsSigned)
62    return GenVal->IntVal.getSExtValue();
63  else
64    return GenVal->IntVal.getZExtValue();
65}
66
67void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
68  return unwrap(GenVal)->PointerVal;
69}
70
71double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
72  switch (unwrap(TyRef)->getTypeID()) {
73  case Type::FloatTyID:
74    return unwrap(GenVal)->FloatVal;
75  case Type::DoubleTyID:
76    return unwrap(GenVal)->DoubleVal;
77  default:
78    llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
79    break;
80  }
81  return 0; // Not reached
82}
83
84void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
85  delete unwrap(GenVal);
86}
87
88/*===-- Operations on execution engines -----------------------------------===*/
89
90LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
91                                            LLVMModuleRef M,
92                                            char **OutError) {
93  std::string Error;
94  EngineBuilder builder(unwrap(M));
95  builder.setEngineKind(EngineKind::Either)
96         .setErrorStr(&Error);
97  if (ExecutionEngine *EE = builder.create()){
98    *OutEE = wrap(EE);
99    return 0;
100  }
101  *OutError = strdup(Error.c_str());
102  return 1;
103}
104
105LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
106                                        LLVMModuleRef M,
107                                        char **OutError) {
108  std::string Error;
109  EngineBuilder builder(unwrap(M));
110  builder.setEngineKind(EngineKind::Interpreter)
111         .setErrorStr(&Error);
112  if (ExecutionEngine *Interp = builder.create()) {
113    *OutInterp = wrap(Interp);
114    return 0;
115  }
116  *OutError = strdup(Error.c_str());
117  return 1;
118}
119
120LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
121                                        LLVMModuleRef M,
122                                        unsigned OptLevel,
123                                        char **OutError) {
124  std::string Error;
125  EngineBuilder builder(unwrap(M));
126  builder.setEngineKind(EngineKind::JIT)
127         .setErrorStr(&Error)
128         .setOptLevel((CodeGenOpt::Level)OptLevel);
129  if (ExecutionEngine *JIT = builder.create()) {
130    *OutJIT = wrap(JIT);
131    return 0;
132  }
133  *OutError = strdup(Error.c_str());
134  return 1;
135}
136
137LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
138                                   LLVMModuleProviderRef MP,
139                                   char **OutError) {
140  /* The module provider is now actually a module. */
141  return LLVMCreateExecutionEngineForModule(OutEE,
142                                            reinterpret_cast<LLVMModuleRef>(MP),
143                                            OutError);
144}
145
146LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
147                               LLVMModuleProviderRef MP,
148                               char **OutError) {
149  /* The module provider is now actually a module. */
150  return LLVMCreateInterpreterForModule(OutInterp,
151                                        reinterpret_cast<LLVMModuleRef>(MP),
152                                        OutError);
153}
154
155LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
156                               LLVMModuleProviderRef MP,
157                               unsigned OptLevel,
158                               char **OutError) {
159  /* The module provider is now actually a module. */
160  return LLVMCreateJITCompilerForModule(OutJIT,
161                                        reinterpret_cast<LLVMModuleRef>(MP),
162                                        OptLevel, OutError);
163}
164
165
166void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
167  delete unwrap(EE);
168}
169
170void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
171  unwrap(EE)->runStaticConstructorsDestructors(false);
172}
173
174void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
175  unwrap(EE)->runStaticConstructorsDestructors(true);
176}
177
178int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
179                          unsigned ArgC, const char * const *ArgV,
180                          const char * const *EnvP) {
181  std::vector<std::string> ArgVec;
182  for (unsigned I = 0; I != ArgC; ++I)
183    ArgVec.push_back(ArgV[I]);
184
185  return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
186}
187
188LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
189                                    unsigned NumArgs,
190                                    LLVMGenericValueRef *Args) {
191  std::vector<GenericValue> ArgVec;
192  ArgVec.reserve(NumArgs);
193  for (unsigned I = 0; I != NumArgs; ++I)
194    ArgVec.push_back(*unwrap(Args[I]));
195
196  GenericValue *Result = new GenericValue();
197  *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
198  return wrap(Result);
199}
200
201void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
202  unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
203}
204
205void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
206  unwrap(EE)->addModule(unwrap(M));
207}
208
209void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
210  /* The module provider is now actually a module. */
211  LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP));
212}
213
214LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
215                          LLVMModuleRef *OutMod, char **OutError) {
216  Module *Mod = unwrap(M);
217  unwrap(EE)->removeModule(Mod);
218  *OutMod = wrap(Mod);
219  return 0;
220}
221
222LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
223                                  LLVMModuleProviderRef MP,
224                                  LLVMModuleRef *OutMod, char **OutError) {
225  /* The module provider is now actually a module. */
226  return LLVMRemoveModule(EE, reinterpret_cast<LLVMModuleRef>(MP), OutMod,
227                          OutError);
228}
229
230LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
231                          LLVMValueRef *OutFn) {
232  if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
233    *OutFn = wrap(F);
234    return 0;
235  }
236  return 1;
237}
238
239void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, LLVMValueRef Fn) {
240  return unwrap(EE)->recompileAndRelinkFunction(unwrap<Function>(Fn));
241}
242
243LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
244  return wrap(unwrap(EE)->getTargetData());
245}
246
247void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
248                          void* Addr) {
249  unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
250}
251
252void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
253  return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
254}
255