diff options
Diffstat (limited to 'mjit_compile.c')
-rw-r--r-- | mjit_compile.c | 158 |
1 files changed, 155 insertions, 3 deletions
diff --git a/mjit_compile.c b/mjit_compile.c index a48ae84e4c..b323192fe9 100644 --- a/mjit_compile.c +++ b/mjit_compile.c @@ -8,11 +8,163 @@ #include "internal.h" #include "vm_core.h" +#include "vm_exec.h" +#include "mjit.h" +#include "insns.inc" +#include "insns_info.inc" +#include "vm_insnhelper.h" -/* Compile ISeq to C code in F. Return TRUE if it succeeds to compile. */ +/* Storage to keep compiler's status. This should have information + which is global during one `mjit_compile` call. Ones conditional + in each branch should be stored in `compile_branch`. */ +struct compile_status { + int success; /* has TRUE if compilation has had no issue */ + int *compiled_for_pos; /* compiled_for_pos[pos] has TRUE if the pos is compiled */ +}; + +/* Storage to keep data which is consistent in each conditional branch. + This is created and used for one `compile_insns` call and its values + should be copied for extra `compile_insns` call. */ +struct compile_branch { + unsigned int stack_size; /* this simulates sp (stack pointer) of YARV */ + int finish_p; /* if TRUE, compilation in this branch should stop and let another branch to be compiled */ +}; + +struct case_dispatch_var { + FILE *f; + unsigned int base_pos; + VALUE last_value; +}; + +/* Returns iseq from cc if it's available and still not obsoleted. */ +static const rb_iseq_t * +get_iseq_if_available(CALL_CACHE cc) +{ + if (GET_GLOBAL_METHOD_STATE() == cc->method_state + && mjit_valid_class_serial_p(cc->class_serial) + && cc->me && cc->me->def->type == VM_METHOD_TYPE_ISEQ) { + return rb_iseq_check(cc->me->def->body.iseq.iseqptr); + } + return NULL; +} + +/* TODO: move to somewhere shared with vm_args.c */ +#define IS_ARGS_SPLAT(ci) ((ci)->flag & VM_CALL_ARGS_SPLAT) +#define IS_ARGS_KEYWORD(ci) ((ci)->flag & VM_CALL_KWARG) + +/* Returns TRUE if iseq is inlinable, otherwise NULL. This becomes TRUE in the same condition + as CI_SET_FASTPATH (in vm_callee_setup_arg) is called from vm_call_iseq_setup. */ +static int +inlinable_iseq_p(CALL_INFO ci, CALL_CACHE cc, const rb_iseq_t *iseq) +{ + extern int simple_iseq_p(const rb_iseq_t *iseq); + return iseq != NULL + && simple_iseq_p(iseq) && !(ci->flag & VM_CALL_KW_SPLAT) /* top of vm_callee_setup_arg */ + && (!IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) && !(METHOD_ENTRY_VISI(cc->me) == METHOD_VISI_PROTECTED)); /* CI_SET_FASTPATH */ +} + +static int +compile_case_dispatch_each(VALUE key, VALUE value, VALUE arg) +{ + struct case_dispatch_var *var = (struct case_dispatch_var *)arg; + unsigned int offset; + + if (var->last_value != value) { + offset = FIX2INT(value); + var->last_value = value; + fprintf(var->f, " case %d:\n", offset); + fprintf(var->f, " goto label_%d;\n", var->base_pos + offset); + fprintf(var->f, " break;\n"); + } + return ST_CONTINUE; +} + +static void compile_insns(FILE *f, const struct rb_iseq_constant_body *body, unsigned int stack_size, + unsigned int pos, struct compile_status *status); + +/* Main function of JIT compilation, vm_exec_core counterpart for JIT. Compile one insn to `f`, may modify + b->stack_size and return next position. + + When you add a new instruction to insns.def, it would be nice to have JIT compilation support here but + it's optional. This JIT compiler just ignores ISeq which includes unknown instruction, and ISeq which + does not have it can be compiled as usual. */ +static unsigned int +compile_insn(FILE *f, const struct rb_iseq_constant_body *body, const int insn, const VALUE *operands, + const unsigned int pos, struct compile_status *status, struct compile_branch *b) +{ + unsigned int next_pos = pos + insn_len(insn); + +/*****************/ + #include "mjit_compile.inc" +/*****************/ + + return next_pos; +} + +/* Compile one conditional branch. If it has branchXXX insn, this should be + called multiple times for each branch. */ +static void +compile_insns(FILE *f, const struct rb_iseq_constant_body *body, unsigned int stack_size, + unsigned int pos, struct compile_status *status) +{ + int insn; + struct compile_branch branch; + + branch.stack_size = stack_size; + branch.finish_p = FALSE; + + while (pos < body->iseq_size && !status->compiled_for_pos[pos] && !branch.finish_p) { +#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE + insn = rb_vm_insn_addr2insn((void *)body->iseq_encoded[pos]); +#else + insn = (int)body->iseq_encoded[pos]; +#endif + status->compiled_for_pos[pos] = TRUE; + + fprintf(f, "\nlabel_%d: /* %s */\n", pos, insn_name(insn)); + pos = compile_insn(f, body, insn, body->iseq_encoded + (pos+1), pos, status, &branch); + if (status->success && branch.stack_size > body->stack_max) { + if (mjit_opts.warnings || mjit_opts.verbose) + fprintf(stderr, "MJIT warning: JIT stack exceeded its max\n"); + status->success = FALSE; + } + if (!status->success) + break; + } +} + +/* Compile ISeq to C code in F. It returns 1 if it succeeds to compile. */ int mjit_compile(FILE *f, const struct rb_iseq_constant_body *body, const char *funcname) { - /* TODO: Write your own JIT compiler here. */ - return FALSE; + struct compile_status status; + status.success = TRUE; + status.compiled_for_pos = ZALLOC_N(int, body->iseq_size); + + fprintf(f, "VALUE %s(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp) {\n", funcname); + fprintf(f, " VALUE *stack = reg_cfp->sp;\n"); + + /* Simulate `opt_pc` in setup_parameters_complex */ + if (body->param.flags.has_opt) { + int i; + fprintf(f, "\n"); + fprintf(f, " switch (reg_cfp->pc - reg_cfp->iseq->body->iseq_encoded) {\n"); + for (i = 0; i <= body->param.opt_num; i++) { + VALUE pc_offset = body->param.opt_table[i]; + fprintf(f, " case %"PRIdVALUE":\n", pc_offset); + fprintf(f, " goto label_%"PRIdVALUE";\n", pc_offset); + } + fprintf(f, " }\n"); + } + + /* ISeq might be used for catch table too. For that usage, this code cancels JIT execution. */ + fprintf(f, " if (reg_cfp->pc != 0x%"PRIxVALUE") {\n", (VALUE)body->iseq_encoded); + fprintf(f, " return Qundef;\n"); + fprintf(f, " }\n"); + + compile_insns(f, body, 0, 0, &status); + fprintf(f, "}\n"); + + xfree(status.compiled_for_pos); + return status.success; } |