1 //===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the C bindings for the ExecutionEngine library.
12 //===----------------------------------------------------------------------===//
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"
25 #define DEBUG_TYPE "jit"
27 // Wrapping the C bindings types.
28 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef)
31 inline LLVMTargetMachineRef wrap(const TargetMachine *P) {
33 reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine*>(P));
36 /*===-- Operations on generic values --------------------------------------===*/
38 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
41 GenericValue *GenVal = new GenericValue();
42 GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
46 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
47 GenericValue *GenVal = new GenericValue();
48 GenVal->PointerVal = P;
52 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
53 GenericValue *GenVal = new GenericValue();
54 switch (unwrap(TyRef)->getTypeID()) {
58 case Type::DoubleTyID:
59 GenVal->DoubleVal = N;
62 llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
67 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
68 return unwrap(GenValRef)->IntVal.getBitWidth();
71 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
73 GenericValue *GenVal = unwrap(GenValRef);
75 return GenVal->IntVal.getSExtValue();
77 return GenVal->IntVal.getZExtValue();
80 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
81 return unwrap(GenVal)->PointerVal;
84 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
85 switch (unwrap(TyRef)->getTypeID()) {
87 return unwrap(GenVal)->FloatVal;
88 case Type::DoubleTyID:
89 return unwrap(GenVal)->DoubleVal;
91 llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
95 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
96 delete unwrap(GenVal);
99 /*===-- Operations on execution engines -----------------------------------===*/
101 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
105 EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
106 builder.setEngineKind(EngineKind::Either)
107 .setErrorStr(&Error);
108 if (ExecutionEngine *EE = builder.create()){
112 *OutError = strdup(Error.c_str());
116 LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
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);
127 *OutError = strdup(Error.c_str());
131 LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
136 EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
137 builder.setEngineKind(EngineKind::JIT)
139 .setOptLevel((CodeGenOpt::Level)OptLevel);
140 if (ExecutionEngine *JIT = builder.create()) {
144 *OutError = strdup(Error.c_str());
148 void 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;
154 memcpy(PassedOptions, &options,
155 std::min(sizeof(options), SizeOfPassedOptions));
158 LLVMBool LLVMCreateMCJITCompilerForModule(
159 LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
160 LLVMMCJITCompilerOptions *PassedOptions, size_t SizeOfPassedOptions,
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)) {
167 "Refusing to use options struct that is larger than my own; assuming "
168 "LLVM library mismatch.");
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);
179 TargetOptions targetOptions;
180 targetOptions.EnableFastISel = options.EnableFastISel;
181 std::unique_ptr<Module> Mod(unwrap(M));
184 // Set function attribute "no-frame-pointer-elim" based on
185 // NoFramePointerElim.
186 for (auto &F : *Mod) {
187 auto Attrs = F.getAttributes();
188 auto Value = options.NoFramePointerElim ? "true" : "false";
189 Attrs = Attrs.addAttribute(F.getContext(), AttributeSet::FunctionIndex,
190 "no-frame-pointer-elim", Value);
191 F.setAttributes(Attrs);
195 EngineBuilder builder(std::move(Mod));
196 builder.setEngineKind(EngineKind::JIT)
198 .setOptLevel((CodeGenOpt::Level)options.OptLevel)
199 .setCodeModel(unwrap(options.CodeModel))
200 .setTargetOptions(targetOptions);
202 builder.setMCJITMemoryManager(
203 std::unique_ptr<RTDyldMemoryManager>(unwrap(options.MCJMM)));
204 if (ExecutionEngine *JIT = builder.create()) {
208 *OutError = strdup(Error.c_str());
212 LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
213 LLVMModuleProviderRef MP,
215 /* The module provider is now actually a module. */
216 return LLVMCreateExecutionEngineForModule(OutEE,
217 reinterpret_cast<LLVMModuleRef>(MP),
221 LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
222 LLVMModuleProviderRef MP,
224 /* The module provider is now actually a module. */
225 return LLVMCreateInterpreterForModule(OutInterp,
226 reinterpret_cast<LLVMModuleRef>(MP),
230 LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
231 LLVMModuleProviderRef MP,
234 /* The module provider is now actually a module. */
235 return LLVMCreateJITCompilerForModule(OutJIT,
236 reinterpret_cast<LLVMModuleRef>(MP),
241 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
245 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
246 unwrap(EE)->runStaticConstructorsDestructors(false);
249 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
250 unwrap(EE)->runStaticConstructorsDestructors(true);
253 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
254 unsigned ArgC, const char * const *ArgV,
255 const char * const *EnvP) {
256 unwrap(EE)->finalizeObject();
258 std::vector<std::string> ArgVec;
259 for (unsigned I = 0; I != ArgC; ++I)
260 ArgVec.push_back(ArgV[I]);
262 return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
265 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
267 LLVMGenericValueRef *Args) {
268 unwrap(EE)->finalizeObject();
270 std::vector<GenericValue> ArgVec;
271 ArgVec.reserve(NumArgs);
272 for (unsigned I = 0; I != NumArgs; ++I)
273 ArgVec.push_back(*unwrap(Args[I]));
275 GenericValue *Result = new GenericValue();
276 *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
280 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
283 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
284 unwrap(EE)->addModule(std::unique_ptr<Module>(unwrap(M)));
287 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
288 /* The module provider is now actually a module. */
289 LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP));
292 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
293 LLVMModuleRef *OutMod, char **OutError) {
294 Module *Mod = unwrap(M);
295 unwrap(EE)->removeModule(Mod);
300 LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
301 LLVMModuleProviderRef MP,
302 LLVMModuleRef *OutMod, char **OutError) {
303 /* The module provider is now actually a module. */
304 return LLVMRemoveModule(EE, reinterpret_cast<LLVMModuleRef>(MP), OutMod,
308 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
309 LLVMValueRef *OutFn) {
310 if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
317 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
322 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
323 return wrap(unwrap(EE)->getDataLayout());
327 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE) {
328 return wrap(unwrap(EE)->getTargetMachine());
331 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
333 unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
336 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
337 unwrap(EE)->finalizeObject();
339 return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
342 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name) {
343 return unwrap(EE)->getGlobalValueAddress(Name);
346 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name) {
347 return unwrap(EE)->getFunctionAddress(Name);
350 /*===-- Operations on memory managers -------------------------------------===*/
354 struct SimpleBindingMMFunctions {
355 LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection;
356 LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection;
357 LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory;
358 LLVMMemoryManagerDestroyCallback Destroy;
361 class SimpleBindingMemoryManager : public RTDyldMemoryManager {
363 SimpleBindingMemoryManager(const SimpleBindingMMFunctions& Functions,
365 ~SimpleBindingMemoryManager() override;
367 uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
369 StringRef SectionName) override;
371 uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
372 unsigned SectionID, StringRef SectionName,
373 bool isReadOnly) override;
375 bool finalizeMemory(std::string *ErrMsg) override;
378 SimpleBindingMMFunctions Functions;
382 SimpleBindingMemoryManager::SimpleBindingMemoryManager(
383 const SimpleBindingMMFunctions& Functions,
385 : Functions(Functions), Opaque(Opaque) {
386 assert(Functions.AllocateCodeSection &&
387 "No AllocateCodeSection function provided!");
388 assert(Functions.AllocateDataSection &&
389 "No AllocateDataSection function provided!");
390 assert(Functions.FinalizeMemory &&
391 "No FinalizeMemory function provided!");
392 assert(Functions.Destroy &&
393 "No Destroy function provided!");
396 SimpleBindingMemoryManager::~SimpleBindingMemoryManager() {
397 Functions.Destroy(Opaque);
400 uint8_t *SimpleBindingMemoryManager::allocateCodeSection(
401 uintptr_t Size, unsigned Alignment, unsigned SectionID,
402 StringRef SectionName) {
403 return Functions.AllocateCodeSection(Opaque, Size, Alignment, SectionID,
404 SectionName.str().c_str());
407 uint8_t *SimpleBindingMemoryManager::allocateDataSection(
408 uintptr_t Size, unsigned Alignment, unsigned SectionID,
409 StringRef SectionName, bool isReadOnly) {
410 return Functions.AllocateDataSection(Opaque, Size, Alignment, SectionID,
411 SectionName.str().c_str(),
415 bool SimpleBindingMemoryManager::finalizeMemory(std::string *ErrMsg) {
416 char *errMsgCString = nullptr;
417 bool result = Functions.FinalizeMemory(Opaque, &errMsgCString);
418 assert((result || !errMsgCString) &&
419 "Did not expect an error message if FinalizeMemory succeeded");
422 *ErrMsg = errMsgCString;
428 } // anonymous namespace
430 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
432 LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
433 LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
434 LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
435 LLVMMemoryManagerDestroyCallback Destroy) {
437 if (!AllocateCodeSection || !AllocateDataSection || !FinalizeMemory ||
441 SimpleBindingMMFunctions functions;
442 functions.AllocateCodeSection = AllocateCodeSection;
443 functions.AllocateDataSection = AllocateDataSection;
444 functions.FinalizeMemory = FinalizeMemory;
445 functions.Destroy = Destroy;
446 return wrap(new SimpleBindingMemoryManager(functions, Opaque));
449 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM) {