int main()
{
jit_context_t ctx = jit_context_create();
while (1)
{
func_t func;
double x;
int a;
char buf[1024];
printf("jitcalc> ");
if (!fgets(buf, sizeof(buf), stdin))
break;
if (strchr("\r\n", buf[0]))
continue;
func = compile(ctx, buf, strlen(buf));
for (a = 0; a < 3; ++a)
{
x = func((double)a, (double)2, (double)7);
printf("func(%lf, 2, 7) = %lf\n", (double)a, x);
}
}
jit_context_destroy(ctx);
return 0;
}
int main() {
jit_context_t ctx;
// Create a context to hold the JIT's primary stats
ctx = jit_context_create();
// Lock the context while we build and compile the function
jit_context_build_start(ctx);
// Build the function signature
jit_function_t function;
jit_type_t params[3];
jit_type_t signature;
params[0] = jit_type_int;
params[1] = jit_type_int;
params[2] = jit_type_int;
signature =
jit_type_create_signature(jit_abi_cdecl, jit_type_int, params, 3, 1);
// Create the function object
function = jit_function_create(ctx, signature);
jit_type_free(signature);
// Construct the function body
jit_value_t x, y, z;
x = jit_value_get_param(function, 0);
y = jit_value_get_param(function, 1);
z = jit_value_get_param(function, 2);
jit_value_t temp1, temp2;
temp1 = jit_insn_mul(function, x, y);
temp2 = jit_insn_add(function, temp1, z);
jit_insn_return(function, temp2);
// Compile the function
jit_function_compile(function);
// Unlock the context
jit_context_build_end(ctx);
// Execute the function and print the result
jit_int arg1, arg2, arg3;
jit_int result;
void *args[3];
arg1 = 3;
arg2 = 5;
arg3 = 2;
args[0] = &arg1;
args[1] = &arg2;
args[2] = &arg3;
jit_function_apply(function, args, &result);
printf("mul_add(3,5,2) = %d\n", (int)result);
// Clean up
jit_context_destroy(ctx);
return 0;
}
void init_decompiler() {
context = jit_context_create();
jit_context_build_start(context);
jit_type_t s5params[5];
s5params[0] = jit_type_uint;
s5params[1] = jit_type_uint;
s5params[2] = jit_type_uint;
s5params[3] = jit_type_uint;
s5params[4] = jit_type_uint;
sig_5 = jit_type_create_signature(jit_abi_cdecl, jit_type_uint, s5params, 5, 1);
jit_type_t s4params[4];
s4params[0] = jit_type_uint;
s4params[1] = jit_type_uint;
s4params[2] = jit_type_uint;
s4params[3] = jit_type_uint;
sig_4 = jit_type_create_signature(jit_abi_cdecl, jit_type_uint, s4params, 4, 1);
jit_type_t s3params[3];
s3params[0] = jit_type_uint;
s3params[1] = jit_type_uint;
s3params[2] = jit_type_uint;
sig_3 = jit_type_create_signature(jit_abi_cdecl, jit_type_uint, s3params, 3, 1);
jit_type_t sparams[2];
sparams[0] = jit_type_uint;
sparams[1] = jit_type_uint;
sig_2 = jit_type_create_signature(jit_abi_cdecl, jit_type_uint, sparams, 2, 1);
jit_type_t lparams[1];
lparams[0] = jit_type_uint;
sig_1 = jit_type_create_signature(jit_abi_cdecl, jit_type_uint, lparams, 1, 1);
jit_type_t pparams[1];
pparams[0] = jit_type_void_ptr;
sig_1_ptr = jit_type_create_signature(jit_abi_cdecl, jit_type_void, pparams, 1, 1);
sig_0 = jit_type_create_signature(jit_abi_cdecl, jit_type_void, NULL, 0, 1);
jit_type_t params[7];
params[0] = jit_type_create_pointer(jit_type_uint, 0); // State
params[1] = jit_type_create_pointer(jit_type_ubyte, 0); // ReadAbsorb
params[2] = jit_type_create_pointer(jit_type_ubyte, 0); // ReadAbsorbWhich
params[3] = jit_type_create_pointer(jit_type_ubyte, 0); // ReadFudge
params[4] = jit_type_create_pointer(jit_type_uint, 0); // LDWhich
params[5] = jit_type_create_pointer(jit_type_uint, 0); // LDValue
params[6] = jit_type_create_pointer(jit_type_uint, 0); // LDAbsorb
block_sig = jit_type_create_signature(jit_abi_cdecl, jit_type_void, params, 7, 1);
}
int main(int argc, char const *argv[]) {
jit_context_t cx = jit_context_create();
char *data = calloc(50000, sizeof(char));
jit_ptr arg1;
void *args[1];
FILE *fp = fopen(argv[1], "rb");
jit_function_t function = bf_compile(cx, fp);
fclose(fp);
jit_context_build_end(cx);
arg1 = data;
args[0] = &arg1;
jit_function_apply(function, args, NULL);
jit_context_destroy(cx);
return 0;
}
bool LibJITFormula::buildFunction ()
{
// Create a context
jit_context_t context;
context = jit_context_create ();
jit_context_build_start (context);
// Create a signature for double (*func)();
jit_type_t signature;
signature = jit_type_create_signature (jit_abi_cdecl, jit_type_float64,
NULL, 0, 1);
// Create a function
function = jit_function_create (context, signature);
// Return the result of compiling the whole mess
jit_value_t val;
val = (jit_value_t)parseTree->generate (this);
if (!val)
return false;
jit_insn_return (function, val);
jit_context_build_end (context);
if (!jit_function_compile (function))
{
jit_function_abandon (function);
return false;
}
func = (FunctionPointer)jit_function_to_closure (function);
if (!func)
{
jit_function_abandon (function);
return false;
}
return true;
}
/* TODO: Make jit_context_t interpreter-local */
void
pj_init_global_state(pTHX)
{
/* Setup our new peephole optimizer */
PJ_orig_peepp = PL_peepp;
PL_peepp = pj_jit_peep;
/* Set up JIT compiler */
PJ_jit_context = jit_context_create();
/* Setup our callback for cleaning up JIT OPs during global cleanup */
PJ_orig_opfreehook = PL_opfreehook;
PL_opfreehook = pj_jitop_free_hook;
/* Setup our custom op */
XopENTRY_set(&PJ_xop_jitop, xop_name, "jitop");
XopENTRY_set(&PJ_xop_jitop, xop_desc, "a just-in-time compiled composite operation");
XopENTRY_set(&PJ_xop_jitop, xop_class, OA_LISTOP);
Perl_custom_op_register(aTHX_ pj_pp_jit, &PJ_xop_jitop);
/* Register super-late global cleanup hook for global JIT state */
Perl_call_atexit(aTHX_ pj_global_state_final_cleanup, NULL);
}
int main(int argc, char **argv) {
if (argc < 4) {
LOGF("you must provide 3 arguments to function: F, X, LEN");
return 0;
}
jit_context = jit_context_create();
jit_context_build_start(jit_context);
jit_function_t func = parse_function();
jit_context_build_end(jit_context);
jit_float64 result,
f = atof(argv[1]);
jit_nuint x = atoi(argv[2]),
len = atoi(argv[3]);
void *args[3] = {&f, &x, &len};
jit_function_apply(func, args, &result);
LOGF("f(%f, %i, %i) = %f", f, x, len, result);
jit_context_destroy(jit_context);
return 0;
}
int main(int argc, char **argv)
{
jit_context_t context;
jit_type_t params[2];
jit_type_t signature;
jit_function_t function;
jit_value_t x, y;
jit_value_t temp1, temp2;
jit_value_t temp3, temp4;
jit_value_t temp_args[2];
jit_label_t label1 = jit_label_undefined;
jit_label_t label2 = jit_label_undefined;
jit_uint arg1, arg2;
void *args[2];
jit_uint result;
/* Create a context to hold the JIT's primary state */
context = jit_context_create();
/* Lock the context while we build and compile the function */
jit_context_build_start(context);
/* Build the function signature */
params[0] = jit_type_uint;
params[1] = jit_type_uint;
signature = jit_type_create_signature
(jit_abi_cdecl, jit_type_uint, params, 2, 1);
/* Create the function object */
function = jit_function_create(context, signature);
/* Check the condition "if(x == y)" */
x = jit_value_get_param(function, 0);
y = jit_value_get_param(function, 1);
temp1 = jit_insn_eq(function, x, y);
jit_insn_branch_if_not(function, temp1, &label1);
/* Implement "return x" */
jit_insn_return(function, x);
/* Set "label1" at this position */
jit_insn_label(function, &label1);
/* Check the condition "if(x < y)" */
temp2 = jit_insn_lt(function, x, y);
jit_insn_branch_if_not(function, temp2, &label2);
/* Implement "return gcd(x, y - x)" */
temp_args[0] = x;
temp_args[1] = jit_insn_sub(function, y, x);
temp3 = jit_insn_call
(function, "gcd", function, 0, temp_args, 2, 0);
jit_insn_return(function, temp3);
/* Set "label2" at this position */
jit_insn_label(function, &label2);
/* Implement "return gcd(x - y, y)" */
temp_args[0] = jit_insn_sub(function, x, y);
temp_args[1] = y;
temp4 = jit_insn_call
(function, "gcd", function, 0, temp_args, 2, 0);
jit_insn_return(function, temp4);
/* Compile the function */
jit_function_compile(function);
/* Unlock the context */
jit_context_build_end(context);
/* Execute the function and print the result */
arg1 = 27;
arg2 = 14;
args[0] = &arg1;
args[1] = &arg2;
jit_function_apply(function, args, &result);
printf("gcd(27, 14) = %u\n", (unsigned int)result);
/* Clean up */
jit_context_destroy(context);
/* Finished */
return 0;
}
int __cdecl main(int argc, char **argv)
{
jit_context_t context;
jit_type_t params[5];
jit_type_t signature;
jit_function_t function;
void* _this;
bool a = true;
bool b = true;
bool c = true;
bool d = true;
void *args[5];
//jit_int result;`
MyClass* pMyClass = new MyClass;
void*** pMyClassCasted = (void***)pMyClass;
void ** vtable_ptr = *pMyClassCasted;
std::cout<<vtable_ptr[0]<<std::endl;
typedef void (*void_method)();
void** new_vtable = (void**)malloc(sizeof(void*)*2);
*pMyClassCasted = new_vtable;
memcpy(new_vtable, vtable_ptr, NativeVTableIndexInspector::getVirtualMethodCount<MySubClass>()*sizeof(void*));
auto method_ptr = &MyClass::doSmth;
auto method_ptr2 = &MyClass::doSmthElse;
//std::cout<< "index of MyClass::doSmth"<< NativeVTableIndexInspector::getIndexOf(&MyClass::doSmth) <<std::endl;
/* Create a context to hold the JIT's primary state */
context = jit_context_create();
// DEBUGGER
debugger = jit_debugger_create(context);
jit_debugger_set_hook(context, debugger_hook);
/*
// Create threads
pthread_t thread0;
pthread_t thread1;
pthread_create(&thread0, NULL, thread0_func, NULL);
pthread_create(&thread1, NULL, thread1_func, NULL);*/
/* Lock the context while we construct the function */
jit_context_build_start(context);
/* Build the function signature */
params[0] = jit_type_void_ptr; // this
params[1] = jit_type_sys_bool; // a
params[2] = jit_type_sys_bool; // b
params[3] = jit_type_sys_bool; // c
params[4] = jit_type_sys_bool; // d
signature = jit_type_create_signature(jit_abi_thiscall, jit_type_void_ptr, params, 1, 1);
/* Create the function object */
function = jit_function_create(context, signature);
//Expression* expression = new Or(new And(new ArgumentAccess(0), new ArgumentAccess(1))
// , new And(new ArgumentAccess(2), new NativeMethodCall(native_method)));
void* hacked_ptr = *reinterpret_cast<void**>(&method_ptr);
signature = jit_type_create_signature(jit_abi_thiscall, jit_type_void, params, 1, 1);
jit_value_t args_this = jit_value_create_nint_constant(function, jit_type_void_ptr, 0);
jit_insn_call_native(function, "doSmth", hacked_ptr, signature, &args_this, 1, 0);
jit_insn_mark_breakpoint (function, JIT_DEBUGGER_DATA1_LINE, 0);
jit_insn_return(function, jit_value_get_param(function, 0));
jit_insn_mark_breakpoint (function, JIT_DEBUGGER_DATA1_LINE, 1);
/* Unlock the context. It will be automatically locked for
us when the on-demand compiler is called */
jit_context_build_end(context);
/* Execute the function and print the result. This will arrange
to call the on-demand compiler to build the function's body */
jit_function_compile(function);
_this = (void*)10;
void* result;
args[0] = &pMyClass;
args[1] = &a;
args[2] = &b;
args[3] = &c;
args[4] = &d;
/*__asm
{
mov ecx, pMyClass
};*/
jit_function_apply(function, args, &result);
printf("(a && b) || (c && call) = %d\n", result);
new_vtable[1] = jit_function_to_vtable_pointer(function);
result = pMyClass->doSmthElse();
printf("(a && b) || (c && call) = %d\n", result);
/* Execute the function again, to demonstrate that the
on-demand compiler is not invoked a second time */
/*arg1 = 13;
arg2 = 5;
arg3 = 7;
args[0] = &arg1;
args[1] = &arg2;
args[2] = &arg3;
jit_function_apply(function, args, &result);
printf("mul_add(13, 5, 7) = %d\n", (int)result);*/
/* Execute the function a third time, after it is recompiled */
/*arg1 = 2;
arg2 = 18;
arg3 = -3;
args[0] = &arg1;
args[1] = &arg2;
args[2] = &arg3;
jit_function_apply(function, args, &result);
printf("mul_add(2, 18, -3) = %d\n", (int)result);*/
/* Clean up */
jit_context_destroy(context);
system("pause");
/* Finished */
return 0;
}
void function_init() {
funclist = list_new(funclist);
jit_context = jit_context_create();
jit_context_build_start(jit_context);
}
jit_function_t GPerlJITCompiler::compile(JITParam *param)
{
GPerlVirtualMachineCode *pc = param->mtd;
jit_context_t ctx = jit_context_create();
jit_context_build_start(ctx);
int argc = param->argc;
jit_type_t _params[argc];
for (int i = 0; i < argc; i++) {
_params[i] = getJitType(param->arg_types[i]);
}
jit_type_t rtype = getJitType(param->return_type);
jit_value_t curstack[32] = {0};
jit_value_t argstack[MAX_ARGSTACK_SIZE] = {0};
jit_type_t signature = jit_type_create_signature(jit_abi_fastcall, rtype, _params, argc, 0);
jit_function_t func = jit_function_create(ctx, signature);
jit_value_t _v[MAX_REG_SIZE] = {0};
GPerlJmpStack *jmp_stack = new GPerlJmpStack();
argc = 0;
for (; pc->op != UNDEF; pc++) {
if (jmp_stack->isJmp()) {
GPerlJmpInfo *inf = jmp_stack->pop();
jit_insn_label(func, &inf->label);
}
switch (pc->op) {
case LET:
DBG_PL("COMPILE LET");
curstack[pc->dst] = _v[pc->src];
break;
case MOV:
DBG_PL("COMPILE MOV");
_v[pc->dst] = compileMOV(pc, &func);
break;
case ARRAY_ARGAT: {
DBG_PL("COMPILE ARGAT");
jit_value_t arg = jit_value_get_param(func, pc->src);
jit_nint offset = 48;
jit_value_t list = jit_insn_load_relative(func, arg, offset, object_ptr_type);
jit_value_t idx = jit_value_create_nint_constant(func, jit_type_int, pc->idx);
jit_value_t elem = jit_insn_load_elem(func, list, idx, value_type);
_v[pc->dst] = elem;
break;
}
case vMOV:
DBG_PL("COMPILE vMOV");
_v[pc->dst] = curstack[pc->src];
break;
case gMOV:
break;
case ARGMOV:
DBG_PL("COMPILE ARGMOV");
_v[pc->dst] = jit_value_get_param(func, pc->src);
break;
case ADD:
DBG_PL("COMPILE ADD");
_v[pc->dst] = jit_insn_add(func, _v[pc->dst], _v[pc->src]);
break;
case SUB:
DBG_PL("COMPILE SUB");
_v[pc->dst] = jit_insn_sub(func, _v[pc->dst], _v[pc->src]);
break;
case iADDC: {
DBG_PL("COMPILE iADDC");
jit_value_t c = jit_value_create_nint_constant(func, jit_type_int, pc->v.ivalue);
_v[pc->dst] = jit_insn_add(func, _v[pc->dst], c);
break;
}
case iSUBC: {
DBG_PL("COMPILE iSUBC");
jit_value_t c = jit_value_create_nint_constant(func, jit_type_int, pc->v.ivalue);
_v[pc->dst] = jit_insn_sub(func, _v[pc->dst], c);
break;
}
case IS: {
DBG_PL("COMPILE IS");
jit_value_t c = jit_value_create_nint_constant(func, jit_type_int, 1);
jit_value_t tmp = jit_insn_eq(func, _v[pc->dst], c);
GPerlJmpInfo *inf = new GPerlJmpInfo(pc->jmp);
jmp_stack->push(inf);
jit_insn_branch_if_not(func, tmp, &inf->label);
break;
}
case iJLC: {
DBG_PL("COMPILE iJLC");
jit_value_t c = jit_value_create_nint_constant(func, jit_type_int, pc->v.ivalue);
jit_value_t tmp = jit_insn_lt(func, _v[pc->dst], c);
GPerlJmpInfo *inf = new GPerlJmpInfo(pc->jmp);
jmp_stack->push(inf);
jit_insn_branch_if_not(func, tmp, &inf->label);
break;
}
case iJLEC: {
DBG_PL("COMPILE iJLEC");
jit_value_t c = jit_value_create_nint_constant(func, jit_type_int, pc->v.ivalue);
jit_value_t tmp = jit_insn_le(func, _v[pc->dst], c);
GPerlJmpInfo *inf = new GPerlJmpInfo(pc->jmp);
jmp_stack->push(inf);
jit_insn_branch_if_not(func, tmp, &inf->label);
break;
}
case JE: {
DBG_PL("COMPILE JE");
jit_value_t tmp = jit_insn_eq(func, _v[pc->dst], _v[pc->src]);
GPerlJmpInfo *inf = new GPerlJmpInfo(pc->jmp);
jmp_stack->push(inf);
jit_insn_branch_if_not(func, tmp, &inf->label);
break;
}
case JLE: {
DBG_PL("COMPILE JLE");
jit_value_t tmp = jit_insn_le(func, _v[pc->dst], _v[pc->src]);
GPerlJmpInfo *inf = new GPerlJmpInfo(pc->jmp);
jmp_stack->push(inf);
jit_insn_branch_if_not(func, tmp, &inf->label);
break;
}
case PUSH:
DBG_PL("COMPILE PUSH");
argstack[pc->src] = _v[pc->dst];
argc++;
break;
case SELFCALL: {
DBG_PL("COMPILE SELFCALL");
_v[pc->dst] = jit_insn_call(func, "", func, NULL, argstack, argc, 0);//JIT_CALL_TAIL);
argc = 0;
break;
}
case SELF_FASTCALL0: {
DBG_PL("COMPILE SELF_FASTCALL0");
argstack[0] = _v[pc->arg0];
_v[pc->dst] = jit_insn_call(func, "", func, NULL, argstack, 1, 0);//JIT_CALL_TAIL);
break;
}
case SELF_FASTCALL1: {
DBG_PL("COMPILE SELF_FASTCALL1");
argstack[0] = _v[pc->arg0];
argstack[1] = _v[pc->arg1];
_v[pc->dst] = jit_insn_call(func, "", func, NULL, argstack, 2, 0);//JIT_CALL_TAIL);
break;
}
case SELF_FASTCALL2: {
DBG_PL("COMPILE SELF_FASTCALL2");
argstack[0] = _v[pc->arg0];
argstack[1] = _v[pc->arg1];
argstack[2] = _v[pc->arg2];
_v[pc->dst] = jit_insn_call(func, "", func, NULL, argstack, 3, 0);//JIT_CALL_TAIL);
break;
}
case SELF_FASTCALL3: {
DBG_PL("COMPILE SELF_FASTCALL3");
argstack[0] = _v[pc->arg0];
argstack[1] = _v[pc->arg1];
argstack[2] = _v[pc->arg2];
argstack[3] = _v[pc->arg3];
_v[pc->dst] = jit_insn_call(func, "", func, NULL, argstack, 4, 0);//JIT_CALL_TAIL);
break;
}
case REF: {
//int ret = 0;
//if (TYPE_CHECK(v) > 1) {
//GPerlObject *o = (GPerlObject *)getObject(v);
//if (o->h.type == ArrayRef) {
//ret = 1;
//}
//}
//INT_init(reg[0], ret);
break;
}
case RET: case JIT_COUNTDOWN_RET:
DBG_PL("COMPILE RET");
_v[0] = _v[pc->src];
jit_insn_return(func, _v[0]);
break;
default:
DBG_PL("COMPILE DEFALUT");
break;
}
}
jit_function_compile(func);
jit_context_build_end(ctx);
return func;
}
// LIBJIT
void vm_cpu_4(uint32_t newPC,int opt, int size)
{
int i;
PC = newPC;
nPC = 4;
RF[0] = 0; //Register $zero must always be zero
RF[31] = 1; //Return default (if the program does not set to zero, should put error)
uint32_t HI = 0, LO = 0;
uint32_t offset = 4;
uint8_t halted = 0;
uint32_t instr;
uint8_t op;
uint8_t rs;
uint8_t rt;
uint8_t rd;
int16_t immediate;
uint32_t address;
uint8_t shamt;
uint8_t funct;
uint64_t mult;
/*lib jit variables */
jit_context_t context;
jit_type_t signature;
jit_function_t function;
jit_type_t params[VM_MEMORY_SZ+2];
jit_int result;
jit_value_t constant_sum;
jit_value_t constant_while;
jit_value_t v_it;
jit_value_t constant_update;
jit_value_t compare;
jit_value_t reg[32]; /* Reg */
jit_value_t mem[VM_MEMORY_SZ]; /* Memory */
jit_label_t labels[10]; /* Labs for jumping :D */
jit_value_t sum, t_sum;
void *args[VM_MEMORY_SZ+2]; /* Args */
jit_int arg_uint[VM_MEMORY_SZ+2];
/* Create a context to hold the JIT's primary state */
context = jit_context_create();
/* Lock the context while we build and compile the function */
jit_context_build_start(context);
for(i=0; i<(VM_MEMORY_SZ+2); i++) {
params[i] = jit_type_int;
}
signature = jit_type_create_signature(jit_abi_cdecl, jit_type_int, params, VM_MEMORY_SZ+2, 1);
/* Create the function object */
function = jit_function_create(context, signature);
jit_type_free(signature);
// Read memory and start registers
for(i=0; i<VM_MEMORY_SZ; i++) {
//printf("%d\n",i);
mem[i] = jit_value_get_param(function, i);
}
reg[0] = jit_value_get_param(function, VM_MEMORY_SZ);
reg[31] = jit_value_get_param(function, VM_MEMORY_SZ+1);
/*int verify = 0 - 1;
for (i=1; i<VM_MEMORY_SZ; i++) {
if((i%2)==0) {
verify = verify + (i);
}
else {
verify = verify - i;
}
}
printf("verify %d\n", verify); */
int l_index;
// Only doing the micro benchmark, for analysis
// Addiu
#define loopSize 10000
#define smallerLoopSize 1000
#define opPerLoop 100
// v_it = 0 ; constant_while = loopSize ; constant_update = 1
v_it = jit_value_create(function, jit_type_uint);
constant_update = jit_value_create_nint_constant(function, jit_type_int, (int)0);
jit_insn_store(function, v_it, constant_update);
reg[2] = jit_value_create(function, jit_type_uint);
constant_while = jit_value_create_nint_constant(function, jit_type_int, 0);
jit_insn_store(function, reg[2], constant_while);
reg[3] = jit_value_create(function, jit_type_uint);
constant_while = jit_value_create_nint_constant(function, jit_type_int, 1);
jit_insn_store(function, reg[3], constant_while);
// do while (v_it < constant_while) {
jit_insn_label(function, &labels[0]);
if (opt == 0) {
constant_update = jit_insn_add(function, reg[2], reg[3]);
}
else if(opt == 1) {
constant_update = jit_insn_xor(function, reg[2], reg[3]);
}
else if(opt == 2) {
constant_update = jit_insn_load(function, mem[0]);
}
for (l_index = 1; l_index < opPerLoop; l_index++) {
if (opt == 0) {
constant_update = jit_insn_add(function, constant_update, reg[3]);
}
else if(opt == 1) {
constant_update = jit_insn_xor(function, constant_update, reg[3]);
}
else if(opt == 2) {
constant_update = jit_insn_load(function, mem[l_index % 5]);
}
}
jit_insn_store(function, reg[2], constant_update);
// do while
constant_update = jit_value_create_nint_constant(function, jit_type_uint, 1);
constant_sum = jit_insn_add(function, v_it, constant_update);
jit_insn_store(function, v_it, constant_sum);
if(size > 0) {
constant_while = jit_value_create_nint_constant(function, jit_type_uint, loopSize);
}
else {
constant_while = jit_value_create_nint_constant(function, jit_type_uint, smallerLoopSize);
}
compare = jit_insn_gt(function, constant_while, v_it);
jit_insn_branch_if(function, compare, &labels[0]);
// Return
//jit_insn_return(function, reg[2]);
jit_insn_return(function, reg[2]);
// START OF FINAL PART
/* Compile the function */
jit_function_compile(function);
/* Unlock the context */
jit_context_build_end(context);
// Put memory and first registers
for (i=0; i<VM_MEMORY_SZ; i++) {
arg_uint[i] = (int) VM_memory[i];
//arg_uint[i] = (int)i;
args[i] = &(arg_uint[i]);
}
arg_uint[VM_MEMORY_SZ] = 0;
args[VM_MEMORY_SZ] = &(arg_uint[VM_MEMORY_SZ]);
arg_uint[VM_MEMORY_SZ+1] = 1;
args[VM_MEMORY_SZ+1] = &(arg_uint[VM_MEMORY_SZ+1]);
jit_function_apply(function, args, &result);
//printf("%d\n", result);
return;
/* end lib jit variables */
}
