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); }
SWIGEXPORT jobject JNICALL Java_org_jllvm_bindings_ExecutionEngineJNI_LLVMGenericValueToInt(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { jobject jresult = 0 ; LLVMGenericValueRef arg1 = (LLVMGenericValueRef) 0 ; LLVMBool arg2 ; unsigned long long result; (void)jenv; (void)jcls; arg1 = *(LLVMGenericValueRef *)&jarg1; arg2 = (LLVMBool)jarg2; result = (unsigned long long)LLVMGenericValueToInt(arg1,arg2); { jbyteArray ba = (*jenv)->NewByteArray(jenv, 9); jbyte* bae = (*jenv)->GetByteArrayElements(jenv, ba, 0); jclass clazz = (*jenv)->FindClass(jenv, "java/math/BigInteger"); jmethodID mid = (*jenv)->GetMethodID(jenv, clazz, "<init>", "([B)V"); jobject bigint; int i; bae[0] = 0; for(i=1; i<9; i++ ) { bae[i] = (jbyte)(result>>8*(8-i)); } (*jenv)->ReleaseByteArrayElements(jenv, ba, bae, 0); bigint = (*jenv)->NewObject(jenv, clazz, mid, ba); jresult = bigint; } 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; }
/* t -> nativeint */ CAMLprim value llvm_genericvalue_as_nativeint(value GenVal) { CAMLparam1(GenVal); assert(LLVMGenericValueIntWidth(Genericvalue_val(GenVal)) <= 8 * sizeof(value) && "Generic value too wide to treat as a nativeint!"); CAMLreturn(copy_nativeint(LLVMGenericValueToInt(Genericvalue_val(GenVal),1))); }
/* t -> int64 */ CAMLprim value llvm_genericvalue_as_int64(value GenVal) { CAMLparam1(GenVal); assert(LLVMGenericValueIntWidth(Genericvalue_val(GenVal)) <= 64 && "Generic value too wide to treat as an int64!"); CAMLreturn(copy_int64(LLVMGenericValueToInt(Genericvalue_val(GenVal), 1))); }
/* t -> int */ CAMLprim value llvm_genericvalue_as_int(value GenVal) { assert(LLVMGenericValueIntWidth(Genericvalue_val(GenVal)) <= 8 * sizeof(value) && "Generic value too wide to treat as an int!"); return Val_int(LLVMGenericValueToInt(Genericvalue_val(GenVal), 1)); }