int main() { pifi nfibs; int in; /* offset of the argument */ jit_insn *ref; /* to patch the forward reference */ jit_insn *mref; /* ref of move to backpatch */ jit_insn *tp; /* location to patch */ codeBuffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANON, -1, 0); if (codeBuffer == MAP_FAILED) { perror("mmap"); exit(0); } nfibs = (pifi) (jit_set_ip(codeBuffer).iptr); jit_prolog (1); in = jit_arg_ui (); jit_getarg_ui(JIT_V0, in); /* V0 = n */ mref= jit_movi_p(JIT_V2,jit_forward ()); /* Generate a dumb movi */ jit_jmpr(JIT_V2); /* generate some dump filler that will never be executed!*/ jit_addi_ui(JIT_V0,JIT_V0,1); jit_addi_ui(JIT_V0,JIT_V0,1); jit_addi_ui(JIT_V0,JIT_V0,1); jit_addi_ui(JIT_V0,JIT_V0,1); tp = jit_get_label (); ref = jit_blti_ui (jit_forward(), JIT_V0, 2); jit_subi_ui (JIT_V1, JIT_V0, 1); /* V1 = n-1 */ jit_subi_ui (JIT_V2, JIT_V0, 2); /* V2 = n-2 */ jit_prepare (1); jit_pusharg_ui(JIT_V1); jit_finish(nfibs); jit_retval(JIT_V1); /* V1 = nfibs(n-1) */ jit_prepare(1); jit_pusharg_ui(JIT_V2); jit_finish(nfibs); jit_retval(JIT_V2); /* V2 = nfibs(n-2) */ jit_addi_ui(JIT_V1, JIT_V1, 1); jit_addr_ui(JIT_RET, JIT_V1, JIT_V2); /* RET = V1 + V2 + 1 */ jit_ret(); jit_patch(ref); /* patch jump */ jit_movi_i(JIT_RET, 1); /* RET = 1 */ jit_ret(); jit_patch_movi(mref,tp); /* Ok. Do the back-patching */ /* call the generated code, passing 32 as an argument */ jit_flush_code(codeBuffer, jit_get_ip().ptr); #ifdef LIGHTNING_DISASSEMBLE disassemble(stderr, (char *)codeBuffer, jit_get_ip().ptr); #endif #ifndef LIGHTNING_CROSS printf("nfibs(%d) = %d\n", 32, nfibs(32)); #endif return 0; }
int main() { pifi nfibs = (pifi) (jit_set_ip(codeBuffer).iptr); int in; /* offset of the argument */ jit_insn *ref; /* to patch the forward reference */ jit_insn *loop; /* start of the loop */ jit_prolog (1); in = jit_arg_ui (); jit_getarg_ui(JIT_R2, in); /* V0 = n */ jit_movi_ui (JIT_R1, 1); ref = jit_blti_ui (jit_forward(), JIT_R2, 2); jit_subi_ui (JIT_R2, JIT_R2, 1); jit_movi_ui (JIT_R0, 1); loop= jit_get_label(); jit_subi_ui (JIT_R2, JIT_R2, 1); /* we'll calculate one more */ jit_addr_ui (JIT_V0, JIT_R0, JIT_R1); /* V0 = R0 + R1 */ jit_movr_ui (JIT_R0, JIT_R1); /* R0 = R1 */ jit_addi_ui (JIT_R1, JIT_V0, 1); /* R1 = V0 + 1 */ jit_bnei_ui (loop, JIT_R2, 0); /* if (R2) goto loop; */ jit_patch(ref); /* patch forward jump */ jit_movr_ui (JIT_RET, JIT_R1); /* RET = R1 */ jit_ret(); jit_flush_code(codeBuffer, jit_get_ip().ptr); #ifdef LIGHTNING_DISASSEMBLE disassemble(stderr, (char *) codeBuffer, jit_get_ip().ptr); #endif #ifndef LIGHTNING_CROSS /* call the generated code, passing 36 as an argument */ printf("nfibs(%d) = %d\n", 36, nfibs(36)); #endif return 0; }
jit_pointer_t compile(const std::vector<Oper>& ops, jit_word_t *memory, const bool flush = true) { jit_prolog(); jit_movi(JIT_V0, reinterpret_cast<jit_word_t>(memory)); jit_movi(JIT_V1, 0); std::stack<Loop> loops; jit_node_t* start = jit_note(__FILE__, __LINE__); for ( size_t n=0; n<ops.size(); ++n ) { switch ( ops[n].code ) { case '<': jit_str(JIT_V0, JIT_V1); jit_subi(JIT_V0, JIT_V0, ops[n].count * sizeof(jit_word_t)); jit_ldr(JIT_V1, JIT_V0); break; case '>': jit_str(JIT_V0, JIT_V1); jit_addi(JIT_V0, JIT_V0, ops[n].count * sizeof(jit_word_t)); jit_ldr(JIT_V1, JIT_V0); break; case 'z': jit_movi(JIT_V1, 0); break; case '+': jit_addi(JIT_V1, JIT_V1, ops[n].count); break; case '-': jit_subi(JIT_V1, JIT_V1, ops[n].count); break; case '.': jit_prepare(); jit_pushargr(JIT_V1); jit_finishi(reinterpret_cast<jit_pointer_t>(putchar)); if ( flush ) { jit_prepare(); jit_pushargi(reinterpret_cast<jit_word_t>(stdout)); jit_finishi(reinterpret_cast<jit_pointer_t>(fflush)); } break; case ',': jit_prepare(); jit_finishi(reinterpret_cast<jit_pointer_t>(getchar)); jit_retval(JIT_V1); break; case '[': { Loop loop; loop.end = jit_forward(); jit_node_t *j = jit_beqi(JIT_V1, 0); jit_patch_at(j, loop.end); loop.body = jit_label(); loops.push(loop); } break; case ']': { Loop loop = loops.top(); jit_node_t *j = jit_bnei(JIT_V1, 0); jit_patch_at(j, loop.body); jit_link(loop.end); loops.pop(); break; } default: break; } } jit_node_t* stop = jit_note(__FILE__, __LINE__); jit_ret(); jit_epilog(); jit_pointer_t r = jit_emit(); fprintf(stderr, "compiled to %zu bytes\n", (char*)jit_address(stop) - (char*)jit_address(start)); return r; }
void run_gnulightning(void) { struct bfi * n = bfprog; int maxstack = 0, stackptr = 0; char *strbuf = 0; size_t maxstrlen = 0; #ifdef GNULIGHTv1 jit_insn** loopstack = 0; jit_insn *codeBuffer; void * startptr; int argp; #endif #ifdef GNULIGHTv2 jit_node_t *start, *end; /* For size of code */ jit_node_t** loopstack = 0; jit_node_t *argp; #endif if (cell_size == 8) tape_step = 1; else tape_step = sizeof(int); #ifdef GNULIGHTv1 /* TODO: Use mmap for allocating memory, the x86 execute protection * bit is on the segment so Linux has to say thay everything below * a specific address is executable. If you ask mmap for executable * memory it can put it below the current value. The mprotect() * function can't do this. */ if (total_nodes < 4096) codeBuffer = malloc(65536); else codeBuffer = malloc(16 * total_nodes); save_ptr_for_free(codeBuffer); codeptr = (codeptr_t) jit_set_ip(codeBuffer).vptr; startptr = jit_get_ip().ptr; /* Function call prolog */ jit_prolog(1); /* Get the data area pointer */ argp = jit_arg_p(); jit_getarg_p(REG_P, argp); #endif #ifdef GNULIGHTv2 init_jit(NULL); // argv[0]); _jit = jit_new_state(); start = jit_note(__FILE__, __LINE__); jit_prolog(); /* Get the data area pointer */ argp = jit_arg(); jit_getarg(REG_P, argp); #endif while(n) { switch(n->type) { case T_MOV: if (acc_loaded) acc_offset -= n->count; jit_addi(REG_P, REG_P, n->count * tape_step); break; case T_ADD: load_acc_offset(n->offset); set_acc_offset(n->offset); jit_addi(REG_ACC, REG_ACC, n->count); break; case T_SET: set_acc_offset(n->offset); if (acc_const && acc_const_val == n->count) { ; } else if (acc_const && acc_const_val+1 == n->count) { jit_addi(REG_ACC, REG_ACC, 1); } else if (acc_const && acc_const_val-1 == n->count) { jit_addi(REG_ACC, REG_ACC, -1); } else { jit_movi(REG_ACC, n->count); } acc_const = 1; acc_const_val = n->count; break; case T_CALC: if (n->offset == n->offset2 && n->count2 == 1) { load_acc_offset(n->offset); set_acc_offset(n->offset); if (n->count) jit_addi(REG_ACC, REG_ACC, n->count); } else if (n->count2 != 0) { load_acc_offset(n->offset2); set_acc_offset(n->offset); if (n->count2 == -1) jit_negr(REG_ACC, REG_ACC); else if (n->count2 != 1) jit_muli(REG_ACC, REG_ACC, n->count2); if (n->count) jit_addi(REG_ACC, REG_ACC, n->count); } else { clean_acc(); set_acc_offset(n->offset); jit_movi(REG_ACC, n->count); if (n->count2 != 0) { if (tape_step > 1) jit_ldxi_i(REG_A1, REG_P, n->offset2 * tape_step); else jit_ldxi_uc(REG_A1, REG_P, n->offset2); if (n->count2 == -1) jit_negr(REG_A1, REG_A1); else if (n->count2 != 1) jit_muli(REG_A1, REG_A1, n->count2); jit_addr(REG_ACC, REG_ACC, REG_A1); } } if (n->count3 != 0) { if (tape_step > 1) jit_ldxi_i(REG_A1, REG_P, n->offset3 * tape_step); else jit_ldxi_uc(REG_A1, REG_P, n->offset3); if (n->count3 == -1) jit_negr(REG_A1, REG_A1); else if (n->count3 != 1) jit_muli(REG_A1, REG_A1, n->count3); jit_addr(REG_ACC, REG_ACC, REG_A1); } break; case T_IF: case T_MULT: case T_CMULT: case T_WHL: load_acc_offset(n->offset); clean_acc(); acc_const = acc_loaded = 0; if (stackptr >= maxstack) { loopstack = realloc(loopstack, ((maxstack+=32)+2)*sizeof(*loopstack)); if (loopstack == 0) { perror("loop stack realloc failure"); exit(1); } } if (cell_mask > 0 && acc_hi_dirty) { if (cell_mask == 0xFF) jit_extr_uc(REG_ACC,REG_ACC); else jit_andi(REG_ACC, REG_ACC, cell_mask); } #ifdef GNULIGHTv1 loopstack[stackptr] = jit_beqi_i(jit_forward(), REG_ACC, 0); loopstack[stackptr+1] = jit_get_label(); #endif #ifdef GNULIGHTv2 loopstack[stackptr] = jit_beqi(REG_ACC, 0); loopstack[stackptr+1] = jit_label(); #endif stackptr += 2; break; case T_END: load_acc_offset(n->offset); clean_acc(); stackptr -= 2; if (stackptr < 0) { fprintf(stderr, "Code gen failure: Stack pointer negative.\n"); exit(1); } if (cell_mask > 0 && acc_hi_dirty) { if (cell_mask == 0xFF) jit_extr_uc(REG_ACC,REG_ACC); else jit_andi(REG_ACC, REG_ACC, cell_mask); } #ifdef GNULIGHTv1 jit_bnei_i(loopstack[stackptr+1], REG_ACC, 0); jit_patch(loopstack[stackptr]); #endif #ifdef GNULIGHTv2 { jit_node_t *ref; ref = jit_bnei(REG_ACC, 0); jit_patch_at(ref, loopstack[stackptr+1]); jit_patch(loopstack[stackptr]); } #endif break; case T_ENDIF: clean_acc(); acc_const = acc_loaded = 0; stackptr -= 2; if (stackptr < 0) { fprintf(stderr, "Code gen failure: Stack pointer negative.\n"); exit(1); } jit_patch(loopstack[stackptr]); break; case T_PRT: clean_acc(); load_acc_offset(n->offset); acc_loaded = 0; #ifdef GNULIGHTv1 jit_prepare_i(1); jit_pusharg_i(REG_ACC); jit_finish(putch); #endif #ifdef GNULIGHTv2 jit_prepare(); jit_pushargr(REG_ACC); jit_finishi(putch); #endif break; case T_CHR: clean_acc(); acc_const = acc_loaded = 0; if (n->count <= 0 || (n->count >= 127 && iostyle == 1) || !n->next || n->next->type != T_CHR) { jit_movi(REG_ACC, n->count); #ifdef GNULIGHTv1 jit_prepare_i(1); jit_pusharg_i(REG_ACC); jit_finish(putch); #endif #ifdef GNULIGHTv2 jit_prepare(); jit_pushargr(REG_ACC); jit_finishi(putch); #endif } else { unsigned i = 0; struct bfi * v = n; char *s; while(v->next && v->next->type == T_CHR && v->next->count > 0 && (v->next->count < 127 || iostyle != 1)) { if (i+2 > maxstrlen) { if (maxstrlen) maxstrlen *= 2; else maxstrlen = 4096; strbuf = realloc(strbuf, maxstrlen); if (!strbuf) { fprintf(stderr, "Reallocate of string buffer failed\n"); exit(42); } } strbuf[i++] = (char) /*GCC -Wconversion*/ v->count; n = v; v = v->next; } strbuf[i] = 0; s = strdup(strbuf); if (!s) { fprintf(stderr, "Save of string failed\n"); exit(43); } save_ptr_for_free(s); #ifdef GNULIGHTv1 jit_movi_p(REG_ACC, s); jit_prepare_i(1); jit_pusharg_i(REG_ACC); jit_finish(puts_without_nl); #endif #ifdef GNULIGHTv2 jit_prepare(); jit_pushargi((jit_word_t) s); jit_finishi(puts_without_nl); #endif } break; case T_INP: load_acc_offset(n->offset); set_acc_offset(n->offset); #ifdef GNULIGHTv1 jit_prepare_i(1); jit_pusharg_i(REG_ACC); jit_finish(getch); jit_retval_i(REG_ACC); #endif #ifdef GNULIGHTv2 jit_prepare(); jit_pushargr(REG_ACC); jit_finishi(getch); jit_retval(REG_ACC); #endif break; case T_STOP: #ifdef GNULIGHTv1 jit_prepare_i(0); jit_finish(failout); #endif #ifdef GNULIGHTv2 jit_prepare(); jit_finishi(failout); #endif break; case T_NOP: case T_DUMP: fprintf(stderr, "Warning on code generation: " "%s node: ptr+%d, cnt=%d, @(%d,%d).\n", tokennames[n->type], n->offset, n->count, n->line, n->col); break; default: fprintf(stderr, "Code gen error: " "%s\t" "%d:%d, %d:%d, %d:%d\n", tokennames[n->type], n->offset, n->count, n->offset2, n->count2, n->offset3, n->count3); exit(1); } n=n->next; #if 0 /*def GNULIGHTv2 */ if(n && enable_trace) { char *p, buf[250]; clean_acc(); acc_loaded = 0; sprintf(buf, "@(%d,%d)\n", n->line, n->col); p = strdup(buf); save_ptr_for_free(p); jit_prepare(); jit_pushargi((jit_word_t) p); jit_finishi(puts_without_nl); } #endif #ifdef GNULIGHTv1 /* TODO -- Check for codeBuffer overflow (add jmp to new) */ #endif } jit_ret(); if (strbuf) { maxstrlen = 0; free(strbuf); strbuf = 0; } delete_tree(); #ifdef GNULIGHTv1 jit_flush_code(startptr, jit_get_ip().ptr); if (verbose) fprintf(stderr, "Generated %d bytes of V1 GNU Lightning code, running\n", (int)(jit_get_ip().ptr - (char*)startptr)); start_runclock(); codeptr(map_hugeram()); finish_runclock(&run_time, &io_time); #endif #ifdef GNULIGHTv2 jit_epilog(); end = jit_note(__FILE__, __LINE__); codeptr = jit_emit(); if (verbose) fprintf(stderr, "Generated %d bytes of V2 GNU Lightning code, running\n", (int)((char*)jit_address(end) - (char*)jit_address(start))); jit_clear_state(); // jit_disassemble(); start_runclock(); codeptr(map_hugeram()); finish_runclock(&run_time, &io_time); #endif #if 0 /* This code writes the generated instructions to a file * so we can disassemble it using: ndisasm -b 32/64 code.bin */ { #ifdef GNULIGHTv1 char *p = startptr; int s = jit_get_ip().ptr - p; #endif #ifdef GNULIGHTv2 char *p = (char*)jit_address(start); int s = (char*)jit_address(end) - p; #endif FILE *fp = fopen("code.bin", "w"); int i; for (i = 0; i < s; ++i) { fputc(p[i], fp); } fclose(fp); } #endif #ifdef GNULIGHTv2 jit_destroy_state(); finish_jit(); #endif codeptr = 0; if (loopstack) { free(loopstack); loopstack = 0; } free_saved_memory(); }
int scheme_inline_alloc(mz_jit_state *jitter, int amt, Scheme_Type ty, int flags, int keep_r0_r1, int keep_fpr1, int inline_retry, int keep_extfpr1) /* Puts allocated result at JIT_V1; first word is GC tag. Uses JIT_R2 as temporary. The allocated memory is "dirty" (i.e., not 0ed). Save FP0 when FP ops are enabled. */ { GC_CAN_IGNORE jit_insn *ref, *reffail; #ifdef MZ_GC_STRESS_TESTING GC_CAN_IGNORE jit_insn *refstress; #endif intptr_t a_word, sz, algn; sz = GC_compute_alloc_size(amt); algn = GC_alloc_alignment(); __START_TINY_JUMPS__(1); #ifdef MZ_GC_STRESS_TESTING refstress = jit_jmpi(jit_forward()); #endif reffail = jit_get_ip(); mz_tl_ldi_p(JIT_V1, tl_GC_gen0_alloc_page_ptr); jit_subi_l(JIT_R2, JIT_V1, 1); jit_andi_l(JIT_R2, JIT_R2, (algn - 1)); ref = jit_blti_l(jit_forward(), JIT_R2, (algn - sz)); #ifdef MZ_GC_STRESS_TESTING mz_patch_ucbranch(refstress); #endif CHECK_LIMIT(); __END_TINY_JUMPS__(1); /* Failure handling */ if (inline_retry) { int mode; if (keep_r0_r1) mode = 1; else if (keep_fpr1) mode = 2; else if (keep_extfpr1) mode = 3; else mode = 0; scheme_generate_alloc_retry(jitter, mode); CHECK_LIMIT(); } else { if (keep_r0_r1) { (void)jit_calli(sjc.retry_alloc_code_keep_r0_r1); } else if (keep_fpr1) { (void)jit_calli(sjc.retry_alloc_code_keep_fpr1); #ifdef MZ_LONG_DOUBLE } else if (keep_extfpr1) { (void)jit_calli(sjc.retry_alloc_code_keep_extfpr1); #endif } else { (void)jit_calli(sjc.retry_alloc_code); } } __START_TINY_JUMPS__(1); (void)jit_jmpi(reffail); __END_SHORT_JUMPS__(1); __START_TINY_JUMPS__(1); mz_patch_branch(ref); jit_addi_ul(JIT_R2, JIT_V1, sz); (void)mz_tl_sti_l(tl_GC_gen0_alloc_page_ptr, JIT_R2, JIT_R0); /* GC header: */ if (ty >= 0) { if ((ty == scheme_pair_type) || (ty == scheme_mutable_pair_type) || (ty == scheme_raw_pair_type)) a_word = GC_pair_initial_word(amt); else a_word = GC_initial_word(amt); jit_stir_l(JIT_V1, a_word); /* Scheme_Object header: */ a_word = initial_tag_word(ty, flags); jit_stixi_l(sizeof(intptr_t), JIT_V1, a_word); } else { /* an array of pointers */ a_word = GC_array_initial_word(amt); jit_stir_l(JIT_V1, a_word); } CHECK_LIMIT(); __END_TINY_JUMPS__(1); return 1; }
int scheme_inline_alloc(mz_jit_state *jitter, int amt, Scheme_Type ty, int immut, int keep_r0_r1, int keep_fpr1, int inline_retry) /* Puts allocated result at JIT_V1; first word is GC tag. Uses JIT_R2 as temporary. The allocated memory is "dirty" (i.e., not 0ed). Save FP0 when FP ops are enabled. */ { GC_CAN_IGNORE jit_insn *ref, *reffail; intptr_t a_word, sz, algn; sz = GC_compute_alloc_size(amt); algn = GC_alloc_alignment(); __START_TINY_JUMPS__(1); reffail = _jit.x.pc; mz_tl_ldi_p(JIT_V1, tl_GC_gen0_alloc_page_ptr); jit_subi_l(JIT_R2, JIT_V1, 1); jit_andi_l(JIT_R2, JIT_R2, (algn - 1)); ref = jit_blti_l(jit_forward(), JIT_R2, (algn - sz)); CHECK_LIMIT(); __END_TINY_JUMPS__(1); /* Failure handling */ if (keep_r0_r1) { if (inline_retry) { scheme_generate_alloc_retry(jitter, 1); CHECK_LIMIT(); } else { (void)jit_calli(sjc.retry_alloc_code_keep_r0_r1); } } else if (keep_fpr1) { (void)jit_calli(sjc.retry_alloc_code_keep_fpr1); } else { (void)jit_calli(sjc.retry_alloc_code); } __START_TINY_JUMPS__(1); (void)jit_jmpi(reffail); __END_SHORT_JUMPS__(1); __START_TINY_JUMPS__(1); mz_patch_branch(ref); jit_addi_ul(JIT_R2, JIT_V1, sz); (void)mz_tl_sti_l(tl_GC_gen0_alloc_page_ptr, JIT_R2, JIT_R0); /* GC header: */ if (ty >= 0) { a_word = GC_initial_word(amt); jit_movi_l(JIT_R2, a_word); jit_str_l(JIT_V1, JIT_R2); /* Scheme_Object header: */ a_word = initial_tag_word(ty, immut); jit_movi_l(JIT_R2, a_word); jit_stxi_l(sizeof(intptr_t), JIT_V1, JIT_R2); } else { /* an array of pointers */ a_word = GC_array_initial_word(amt); jit_movi_l(JIT_R2, a_word); jit_str_l(JIT_V1, JIT_R2); } CHECK_LIMIT(); __END_TINY_JUMPS__(1); return 1; }