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