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