int main(int argc, char const *argv[]) {
LLVMModuleRef mod = LLVMModuleCreateWithName("sum");
LLVMTypeRef param_types[] = { LLVMInt32Type(), LLVMInt32Type() };
LLVMTypeRef ret_type = LLVMFunctionType(LLVMInt32Type(), /* ret type */
param_types, /* arg types */
2, /* arg count */
0 /* is variadic */);
LLVMValueRef sum = LLVMAddFunction(mod, "sum", ret_type);
LLVMBasicBlockRef entry = LLVMAppendBasicBlock(sum, "entry");
LLVMBuilderRef builder = LLVMCreateBuilder();
LLVMPositionBuilderAtEnd(builder, entry);
LLVMValueRef tmp = LLVMBuildAdd(builder,
LLVMGetParam(sum, 0),
LLVMGetParam(sum, 1), "tmp");
LLVMBuildRet(builder, tmp);
char *error = NULL;
LLVMVerifyModule(mod, LLVMAbortProcessAction, &error);
LLVMDisposeMessage(error);
LLVMExecutionEngineRef engine;
error = NULL;
LLVMLinkInJIT();
LLVMInitializeNativeTarget();
if (LLVMCreateExecutionEngineForModule(&engine, mod, &error) != 0) {
fprintf(stderr, "failed to create execution engine\n");
abort();
}
if (error) {
fprintf(stderr, "error: %s\n", error);
LLVMDisposeMessage(error);
exit(EXIT_FAILURE);
}
if (argc < 3) {
fprintf(stderr, "usage: %s x y\n", argv[0]);
exit(EXIT_FAILURE);
}
long long x = strtoll(argv[1], NULL, 10);
long long y = strtoll(argv[2], NULL, 10);
LLVMGenericValueRef args[] = {
LLVMCreateGenericValueOfInt(LLVMInt32Type(), x, 0),
LLVMCreateGenericValueOfInt(LLVMInt32Type(), y, 0),
};
LLVMGenericValueRef res = LLVMRunFunction(engine, sum, 2, args);
printf("%d\n", (int)LLVMGenericValueToInt(res, 0));
// write bitcode to file
if (LLVMWriteBitcodeToFile(mod, "sum.bc") != 0) {
fprintf(stderr, "error writing bitcode to file\n");
}
LLVMDisposeBuilder(builder);
LLVMDisposeExecutionEngine(engine);
}
/* llvalue -> GenericValue.t array -> ExecutionEngine.t -> GenericValue.t */
CAMLprim value llvm_ee_run_function(LLVMValueRef F, value Args,
LLVMExecutionEngineRef EE) {
unsigned NumArgs;
LLVMGenericValueRef Result, *GVArgs;
unsigned I;
NumArgs = Wosize_val(Args);
GVArgs = (LLVMGenericValueRef*) malloc(NumArgs * sizeof(LLVMGenericValueRef));
for (I = 0; I != NumArgs; ++I)
GVArgs[I] = Genericvalue_val(Field(Args, I));
Result = LLVMRunFunction(EE, F, NumArgs, GVArgs);
free(GVArgs);
return alloc_generic_value(Result);
}
SWIGEXPORT jlong JNICALL Java_org_jllvm_bindings_ExecutionEngineJNI_LLVMRunFunction(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) {
jlong jresult = 0 ;
LLVMExecutionEngineRef arg1 = (LLVMExecutionEngineRef) 0 ;
LLVMValueRef arg2 = (LLVMValueRef) 0 ;
unsigned int arg3 ;
LLVMGenericValueRef *arg4 = (LLVMGenericValueRef *) 0 ;
LLVMGenericValueRef result;
(void)jenv;
(void)jcls;
arg1 = *(LLVMExecutionEngineRef *)&jarg1;
arg2 = *(LLVMValueRef *)&jarg2;
arg3 = (unsigned int)jarg3;
arg4 = *(LLVMGenericValueRef **)&jarg4;
result = (LLVMGenericValueRef)LLVMRunFunction(arg1,arg2,arg3,arg4);
*(LLVMGenericValueRef *)&jresult = result;
return jresult;
}
int
main(int argc, char **argv)
{
int n = argc > 1 ? atol(argv[1]) : 24;
LLVMInitializeNativeTarget();
LLVMLinkInInterpreter();
LLVMContextRef Context = LLVMContextCreate();
// Create some module to put our function into it.
LLVMModuleRef M = LLVMModuleCreateWithNameInContext("test", Context);
// We are about to create the "fib" function:
LLVMValueRef FibF = CreateFibFunction(M, Context);
// Now we going to create JIT
LLVMExecutionEngineRef EE;
char * outError;
if (LLVMCreateInterpreterForModule(&EE, M, &outError) != 0) {
printf("%s\n", outError);
return 1;
}
printf("verifying...\n");
if (LLVMVerifyModule(M, LLVMReturnStatusAction, &outError) != 0) {
printf("%s\n", outError);
return 1;
}
printf("OK\n");
printf("We just constructed this LLVM module:\n\n---------\n");
printf("%s\n", LLVMPrintModuleToString(M));
LLVMGenericValueRef Args = LLVMCreateGenericValueOfInt(LLVMInt32TypeInContext(Context), n, 0);
LLVMGenericValueRef Result = LLVMRunFunction(EE, FibF, 1, &Args);
printf("Result: %llu\n", LLVMGenericValueToInt(Result, 0));
return 0;
}
int LLVM_execute(LLVMCompiledProgram program)
{
LLVMModuleRef module = program.module;
LLVMValueRef function = program.function;
char *error = NULL; // Used to retrieve messages from functions
LLVMExecutionEngineRef engine;
LLVMModuleProviderRef provider = LLVMCreateModuleProviderForExistingModule(module);
error = NULL;
if(LLVMCreateJITCompiler(&engine, provider, 2, &error) != 0) {
fprintf(stderr, "%s\n", error);
LLVMDisposeMessage(error);
abort();
}
LLVMPassManagerRef pass = LLVMCreatePassManager();
LLVMAddTargetData(LLVMGetExecutionEngineTargetData(engine), pass);
LLVMAddConstantPropagationPass(pass);
LLVMAddInstructionCombiningPass(pass);
LLVMAddPromoteMemoryToRegisterPass(pass);
LLVMAddGVNPass(pass);
LLVMAddCFGSimplificationPass(pass);
LLVMRunPassManager(pass, module);
#ifdef NDEBUG
#else
LLVMDumpModule(module);
#endif
LLVMGenericValueRef exec_args[] = {};
LLVMGenericValueRef exec_res = LLVMRunFunction(engine, function, 0, exec_args);
int result = LLVMGenericValueToInt(exec_res, 0);
LLVMDisposePassManager(pass);
LLVMDisposeExecutionEngine(engine);
return result;
}
