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  }
80}
81
82void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
83  delete unwrap(GenVal);
84}
85
86/*===-- Operations on execution engines -----------------------------------===*/
87
88LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
89                                            LLVMModuleRef M,
90                                            char **OutError) {
91  std::string Error;
92  EngineBuilder builder(unwrap(M));
93  builder.setEngineKind(EngineKind::Either)
94         .setErrorStr(&Error);
95  if (ExecutionEngine *EE = builder.create()){
96    *OutEE = wrap(EE);
97    return 0;
98  }
99  *OutError = strdup(Error.c_str());
100  return 1;
101}
102
103LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
104                                        LLVMModuleRef M,
105                                        char **OutError) {
106  std::string Error;
107  EngineBuilder builder(unwrap(M));
108  builder.setEngineKind(EngineKind::Interpreter)
109         .setErrorStr(&Error);
110  if (ExecutionEngine *Interp = builder.create()) {
111    *OutInterp = wrap(Interp);
112    return 0;
113  }
114  *OutError = strdup(Error.c_str());
115  return 1;
116}
117
118LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
119                                        LLVMModuleRef M,
120                                        unsigned OptLevel,
121                                        char **OutError) {
122  std::string Error;
123  EngineBuilder builder(unwrap(M));
124  builder.setEngineKind(EngineKind::JIT)
125         .setErrorStr(&Error)
126         .setOptLevel((CodeGenOpt::Level)OptLevel);
127  if (ExecutionEngine *JIT = builder.create()) {
128    *OutJIT = wrap(JIT);
129    return 0;
130  }
131  *OutError = strdup(Error.c_str());
132  return 1;
133}
134
135LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
136                                   LLVMModuleProviderRef MP,
137                                   char **OutError) {
138  /* The module provider is now actually a module. */
139  return LLVMCreateExecutionEngineForModule(OutEE,
140                                            reinterpret_cast<LLVMModuleRef>(MP),
141                                            OutError);
142}
143
144LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
145                               LLVMModuleProviderRef MP,
146                               char **OutError) {
147  /* The module provider is now actually a module. */
148  return LLVMCreateInterpreterForModule(OutInterp,
149                                        reinterpret_cast<LLVMModuleRef>(MP),
150                                        OutError);
151}
152
153LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
154                               LLVMModuleProviderRef MP,
155                               unsigned OptLevel,
156                               char **OutError) {
157  /* The module provider is now actually a module. */
158  return LLVMCreateJITCompilerForModule(OutJIT,
159                                        reinterpret_cast<LLVMModuleRef>(MP),
160                                        OptLevel, OutError);
161}
162
163
164void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
165  delete unwrap(EE);
166}
167
168void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
169  unwrap(EE)->runStaticConstructorsDestructors(false);
170}
171
172void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
173  unwrap(EE)->runStaticConstructorsDestructors(true);
174}
175
176int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
177                          unsigned ArgC, const char * const *ArgV,
178                          const char * const *EnvP) {
179  std::vector<std::string> ArgVec;
180  for (unsigned I = 0; I != ArgC; ++I)
181    ArgVec.push_back(ArgV[I]);
182
183  return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
184}
185
186LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
187                                    unsigned NumArgs,
188                                    LLVMGenericValueRef *Args) {
189  std::vector<GenericValue> ArgVec;
190  ArgVec.reserve(NumArgs);
191  for (unsigned I = 0; I != NumArgs; ++I)
192    ArgVec.push_back(*unwrap(Args[I]));
193
194  GenericValue *Result = new GenericValue();
195  *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
196  return wrap(Result);
197}
198
199void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
200  unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
201}
202
203void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
204  unwrap(EE)->addModule(unwrap(M));
205}
206
207void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
208  /* The module provider is now actually a module. */
209  LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP));
210}
211
212LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
213                          LLVMModuleRef *OutMod, char **OutError) {
214  Module *Mod = unwrap(M);
215  unwrap(EE)->removeModule(Mod);
216  *OutMod = wrap(Mod);
217  return 0;
218}
219
220LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
221                                  LLVMModuleProviderRef MP,
222                                  LLVMModuleRef *OutMod, char **OutError) {
223  /* The module provider is now actually a module. */
224  return LLVMRemoveModule(EE, reinterpret_cast<LLVMModuleRef>(MP), OutMod,
225                          OutError);
226}
227
228LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
229                          LLVMValueRef *OutFn) {
230  if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
231    *OutFn = wrap(F);
232    return 0;
233  }
234  return 1;
235}
236
237void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, LLVMValueRef Fn) {
238  return unwrap(EE)->recompileAndRelinkFunction(unwrap<Function>(Fn));
239}
240
241LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
242  return wrap(unwrap(EE)->getTargetData());
243}
244
245void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
246                          void* Addr) {
247  unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
248}
249
250void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
251  return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
252}
253