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#include "llvm-c/ExecutionEngine.h"
15#include "llvm/ExecutionEngine/ExecutionEngine.h"
16#include "llvm/ExecutionEngine/GenericValue.h"
17#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
18#include "llvm/IR/DerivedTypes.h"
19#include "llvm/IR/Module.h"
20#include "llvm/Support/ErrorHandling.h"
21#include <cstring>
22
23using namespace llvm;
24
25#define DEBUG_TYPE "jit"
26
27// Wrapping the C bindings types.
28DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef)
29
30
31inline LLVMTargetMachineRef wrap(const TargetMachine *P) {
32  return
33  reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine*>(P));
34}
35
36/*===-- Operations on generic values --------------------------------------===*/
37
38LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
39                                                unsigned long long N,
40                                                LLVMBool IsSigned) {
41  GenericValue *GenVal = new GenericValue();
42  GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
43  return wrap(GenVal);
44}
45
46LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
47  GenericValue *GenVal = new GenericValue();
48  GenVal->PointerVal = P;
49  return wrap(GenVal);
50}
51
52LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
53  GenericValue *GenVal = new GenericValue();
54  switch (unwrap(TyRef)->getTypeID()) {
55  case Type::FloatTyID:
56    GenVal->FloatVal = N;
57    break;
58  case Type::DoubleTyID:
59    GenVal->DoubleVal = N;
60    break;
61  default:
62    llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
63  }
64  return wrap(GenVal);
65}
66
67unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
68  return unwrap(GenValRef)->IntVal.getBitWidth();
69}
70
71unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
72                                         LLVMBool IsSigned) {
73  GenericValue *GenVal = unwrap(GenValRef);
74  if (IsSigned)
75    return GenVal->IntVal.getSExtValue();
76  else
77    return GenVal->IntVal.getZExtValue();
78}
79
80void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
81  return unwrap(GenVal)->PointerVal;
82}
83
84double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
85  switch (unwrap(TyRef)->getTypeID()) {
86  case Type::FloatTyID:
87    return unwrap(GenVal)->FloatVal;
88  case Type::DoubleTyID:
89    return unwrap(GenVal)->DoubleVal;
90  default:
91    llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
92  }
93}
94
95void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
96  delete unwrap(GenVal);
97}
98
99/*===-- Operations on execution engines -----------------------------------===*/
100
101LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
102                                            LLVMModuleRef M,
103                                            char **OutError) {
104  std::string Error;
105  EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
106  builder.setEngineKind(EngineKind::Either)
107         .setErrorStr(&Error);
108  if (ExecutionEngine *EE = builder.create()){
109    *OutEE = wrap(EE);
110    return 0;
111  }
112  *OutError = strdup(Error.c_str());
113  return 1;
114}
115
116LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
117                                        LLVMModuleRef M,
118                                        char **OutError) {
119  std::string Error;
120  EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
121  builder.setEngineKind(EngineKind::Interpreter)
122         .setErrorStr(&Error);
123  if (ExecutionEngine *Interp = builder.create()) {
124    *OutInterp = wrap(Interp);
125    return 0;
126  }
127  *OutError = strdup(Error.c_str());
128  return 1;
129}
130
131LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
132                                        LLVMModuleRef M,
133                                        unsigned OptLevel,
134                                        char **OutError) {
135  std::string Error;
136  EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
137  builder.setEngineKind(EngineKind::JIT)
138         .setErrorStr(&Error)
139         .setOptLevel((CodeGenOpt::Level)OptLevel);
140  if (ExecutionEngine *JIT = builder.create()) {
141    *OutJIT = wrap(JIT);
142    return 0;
143  }
144  *OutError = strdup(Error.c_str());
145  return 1;
146}
147
148void LLVMInitializeMCJITCompilerOptions(LLVMMCJITCompilerOptions *PassedOptions,
149                                        size_t SizeOfPassedOptions) {
150  LLVMMCJITCompilerOptions options;
151  memset(&options, 0, sizeof(options)); // Most fields are zero by default.
152  options.CodeModel = LLVMCodeModelJITDefault;
153
154  memcpy(PassedOptions, &options,
155         std::min(sizeof(options), SizeOfPassedOptions));
156}
157
158LLVMBool LLVMCreateMCJITCompilerForModule(
159    LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
160    LLVMMCJITCompilerOptions *PassedOptions, size_t SizeOfPassedOptions,
161    char **OutError) {
162  LLVMMCJITCompilerOptions options;
163  // If the user passed a larger sized options struct, then they were compiled
164  // against a newer LLVM. Tell them that something is wrong.
165  if (SizeOfPassedOptions > sizeof(options)) {
166    *OutError = strdup(
167      "Refusing to use options struct that is larger than my own; assuming "
168      "LLVM library mismatch.");
169    return 1;
170  }
171
172  // Defend against the user having an old version of the API by ensuring that
173  // any fields they didn't see are cleared. We must defend against fields being
174  // set to the bitwise equivalent of zero, and assume that this means "do the
175  // default" as if that option hadn't been available.
176  LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
177  memcpy(&options, PassedOptions, SizeOfPassedOptions);
178
179  TargetOptions targetOptions;
180  targetOptions.NoFramePointerElim = options.NoFramePointerElim;
181  targetOptions.EnableFastISel = options.EnableFastISel;
182
183  std::string Error;
184  EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
185  builder.setEngineKind(EngineKind::JIT)
186         .setErrorStr(&Error)
187         .setOptLevel((CodeGenOpt::Level)options.OptLevel)
188         .setCodeModel(unwrap(options.CodeModel))
189         .setTargetOptions(targetOptions);
190  if (options.MCJMM)
191    builder.setMCJITMemoryManager(
192      std::unique_ptr<RTDyldMemoryManager>(unwrap(options.MCJMM)));
193  if (ExecutionEngine *JIT = builder.create()) {
194    *OutJIT = wrap(JIT);
195    return 0;
196  }
197  *OutError = strdup(Error.c_str());
198  return 1;
199}
200
201LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
202                                   LLVMModuleProviderRef MP,
203                                   char **OutError) {
204  /* The module provider is now actually a module. */
205  return LLVMCreateExecutionEngineForModule(OutEE,
206                                            reinterpret_cast<LLVMModuleRef>(MP),
207                                            OutError);
208}
209
210LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
211                               LLVMModuleProviderRef MP,
212                               char **OutError) {
213  /* The module provider is now actually a module. */
214  return LLVMCreateInterpreterForModule(OutInterp,
215                                        reinterpret_cast<LLVMModuleRef>(MP),
216                                        OutError);
217}
218
219LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
220                               LLVMModuleProviderRef MP,
221                               unsigned OptLevel,
222                               char **OutError) {
223  /* The module provider is now actually a module. */
224  return LLVMCreateJITCompilerForModule(OutJIT,
225                                        reinterpret_cast<LLVMModuleRef>(MP),
226                                        OptLevel, OutError);
227}
228
229
230void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
231  delete unwrap(EE);
232}
233
234void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
235  unwrap(EE)->runStaticConstructorsDestructors(false);
236}
237
238void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
239  unwrap(EE)->runStaticConstructorsDestructors(true);
240}
241
242int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
243                          unsigned ArgC, const char * const *ArgV,
244                          const char * const *EnvP) {
245  unwrap(EE)->finalizeObject();
246
247  std::vector<std::string> ArgVec;
248  for (unsigned I = 0; I != ArgC; ++I)
249    ArgVec.push_back(ArgV[I]);
250
251  return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
252}
253
254LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
255                                    unsigned NumArgs,
256                                    LLVMGenericValueRef *Args) {
257  unwrap(EE)->finalizeObject();
258
259  std::vector<GenericValue> ArgVec;
260  ArgVec.reserve(NumArgs);
261  for (unsigned I = 0; I != NumArgs; ++I)
262    ArgVec.push_back(*unwrap(Args[I]));
263
264  GenericValue *Result = new GenericValue();
265  *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
266  return wrap(Result);
267}
268
269void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
270}
271
272void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
273  unwrap(EE)->addModule(std::unique_ptr<Module>(unwrap(M)));
274}
275
276void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
277  /* The module provider is now actually a module. */
278  LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP));
279}
280
281LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
282                          LLVMModuleRef *OutMod, char **OutError) {
283  Module *Mod = unwrap(M);
284  unwrap(EE)->removeModule(Mod);
285  *OutMod = wrap(Mod);
286  return 0;
287}
288
289LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
290                                  LLVMModuleProviderRef MP,
291                                  LLVMModuleRef *OutMod, char **OutError) {
292  /* The module provider is now actually a module. */
293  return LLVMRemoveModule(EE, reinterpret_cast<LLVMModuleRef>(MP), OutMod,
294                          OutError);
295}
296
297LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
298                          LLVMValueRef *OutFn) {
299  if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
300    *OutFn = wrap(F);
301    return 0;
302  }
303  return 1;
304}
305
306void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
307                                     LLVMValueRef Fn) {
308  return nullptr;
309}
310
311LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
312  return wrap(unwrap(EE)->getDataLayout());
313}
314
315LLVMTargetMachineRef
316LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE) {
317  return wrap(unwrap(EE)->getTargetMachine());
318}
319
320void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
321                          void* Addr) {
322  unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
323}
324
325void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
326  unwrap(EE)->finalizeObject();
327
328  return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
329}
330
331uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name) {
332  return unwrap(EE)->getGlobalValueAddress(Name);
333}
334
335uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name) {
336  return unwrap(EE)->getFunctionAddress(Name);
337}
338
339/*===-- Operations on memory managers -------------------------------------===*/
340
341namespace {
342
343struct SimpleBindingMMFunctions {
344  LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection;
345  LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection;
346  LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory;
347  LLVMMemoryManagerDestroyCallback Destroy;
348};
349
350class SimpleBindingMemoryManager : public RTDyldMemoryManager {
351public:
352  SimpleBindingMemoryManager(const SimpleBindingMMFunctions& Functions,
353                             void *Opaque);
354  ~SimpleBindingMemoryManager() override;
355
356  uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
357                               unsigned SectionID,
358                               StringRef SectionName) override;
359
360  uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
361                               unsigned SectionID, StringRef SectionName,
362                               bool isReadOnly) override;
363
364  bool finalizeMemory(std::string *ErrMsg) override;
365
366private:
367  SimpleBindingMMFunctions Functions;
368  void *Opaque;
369};
370
371SimpleBindingMemoryManager::SimpleBindingMemoryManager(
372  const SimpleBindingMMFunctions& Functions,
373  void *Opaque)
374  : Functions(Functions), Opaque(Opaque) {
375  assert(Functions.AllocateCodeSection &&
376         "No AllocateCodeSection function provided!");
377  assert(Functions.AllocateDataSection &&
378         "No AllocateDataSection function provided!");
379  assert(Functions.FinalizeMemory &&
380         "No FinalizeMemory function provided!");
381  assert(Functions.Destroy &&
382         "No Destroy function provided!");
383}
384
385SimpleBindingMemoryManager::~SimpleBindingMemoryManager() {
386  Functions.Destroy(Opaque);
387}
388
389uint8_t *SimpleBindingMemoryManager::allocateCodeSection(
390  uintptr_t Size, unsigned Alignment, unsigned SectionID,
391  StringRef SectionName) {
392  return Functions.AllocateCodeSection(Opaque, Size, Alignment, SectionID,
393                                       SectionName.str().c_str());
394}
395
396uint8_t *SimpleBindingMemoryManager::allocateDataSection(
397  uintptr_t Size, unsigned Alignment, unsigned SectionID,
398  StringRef SectionName, bool isReadOnly) {
399  return Functions.AllocateDataSection(Opaque, Size, Alignment, SectionID,
400                                       SectionName.str().c_str(),
401                                       isReadOnly);
402}
403
404bool SimpleBindingMemoryManager::finalizeMemory(std::string *ErrMsg) {
405  char *errMsgCString = nullptr;
406  bool result = Functions.FinalizeMemory(Opaque, &errMsgCString);
407  assert((result || !errMsgCString) &&
408         "Did not expect an error message if FinalizeMemory succeeded");
409  if (errMsgCString) {
410    if (ErrMsg)
411      *ErrMsg = errMsgCString;
412    free(errMsgCString);
413  }
414  return result;
415}
416
417} // anonymous namespace
418
419LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
420  void *Opaque,
421  LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
422  LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
423  LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
424  LLVMMemoryManagerDestroyCallback Destroy) {
425
426  if (!AllocateCodeSection || !AllocateDataSection || !FinalizeMemory ||
427      !Destroy)
428    return nullptr;
429
430  SimpleBindingMMFunctions functions;
431  functions.AllocateCodeSection = AllocateCodeSection;
432  functions.AllocateDataSection = AllocateDataSection;
433  functions.FinalizeMemory = FinalizeMemory;
434  functions.Destroy = Destroy;
435  return wrap(new SimpleBindingMemoryManager(functions, Opaque));
436}
437
438void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM) {
439  delete unwrap(MM);
440}
441
442