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);
}
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;
}
SWIGEXPORT jlong JNICALL Java_org_jllvm_bindings_ExecutionEngineJNI_LLVMCreateGenericValueOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg2, jint jarg3) {
jlong jresult = 0 ;
LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
unsigned long long arg2 ;
LLVMBool arg3 ;
LLVMGenericValueRef result;
(void)jenv;
(void)jcls;
arg1 = *(LLVMTypeRef *)&jarg1;
{
jclass clazz;
jmethodID mid;
jbyteArray ba;
jbyte* bae;
jsize sz;
int i;
if (!jarg2) {
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
return 0;
}
clazz = (*jenv)->GetObjectClass(jenv, jarg2);
mid = (*jenv)->GetMethodID(jenv, clazz, "toByteArray", "()[B");
ba = (jbyteArray)(*jenv)->CallObjectMethod(jenv, jarg2, mid);
bae = (*jenv)->GetByteArrayElements(jenv, ba, 0);
sz = (*jenv)->GetArrayLength(jenv, ba);
arg2 = 0;
for(i=0; i<sz; i++) {
arg2 = (arg2 << 8) | (unsigned long long)(unsigned char)bae[i];
}
(*jenv)->ReleaseByteArrayElements(jenv, ba, bae, 0);
}
arg3 = (LLVMBool)jarg3;
result = (LLVMGenericValueRef)LLVMCreateGenericValueOfInt(arg1,arg2,arg3);
*(LLVMGenericValueRef *)&jresult = result;
return jresult;
}
/* Llvm.lltype -> int64 -> t */
CAMLprim value llvm_genericvalue_of_int64(LLVMTypeRef Ty, value Int64) {
CAMLparam1(Int64);
CAMLreturn(alloc_generic_value(
LLVMCreateGenericValueOfInt(Ty, Int64_val(Int64), 1)));
}
/* Llvm.lltype -> nativeint -> t */
CAMLprim value llvm_genericvalue_of_nativeint(LLVMTypeRef Ty, value NatInt) {
CAMLparam1(NatInt);
CAMLreturn(alloc_generic_value(
LLVMCreateGenericValueOfInt(Ty, Nativeint_val(NatInt), 1)));
}
/* Llvm.lltype -> int -> t */
CAMLprim value llvm_genericvalue_of_int(LLVMTypeRef Ty, value Int) {
return alloc_generic_value(LLVMCreateGenericValueOfInt(Ty, Int_val(Int), 1));
}
