kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Split out context object into jitstate_t and ctx_t

Browse source
This commit is contained in:
Maxime Chevalier-Boisvert 2020-12-18 15:02:43 -05:00 • committed by Alan Wu
parent 5e39d83fbd
commit df16bf97ec
5 changed files with 111 additions and 114 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
ujit_codegen.c
View file

@ -26,7 +26,31 @@ codeblock_t* cb = NULL;
static codeblock_t outline_block; static codeblock_t outline_block;
codeblock_t* ocb = NULL; codeblock_t* ocb = NULL;
// Ruby instruction entry // Get the current instruction's opcode
static int
jit_get_opcode(jitstate_t* jit)
{
return opcode_at_pc(jit->iseq, jit->pc);
}
// Get the index of the next instruction
static uint32_t
jit_next_idx(jitstate_t* jit)
{
return jit->insn_idx + insn_len(jit_get_opcode(jit));
}
// Get an instruction argument by index
static VALUE
jit_get_arg(jitstate_t* jit, size_t arg_idx)
{
assert (arg_idx + 1 < insn_len(jit_get_opcode(jit)));
return *(jit->pc + arg_idx + 1);
}
/**
Generate code to enter from the Ruby interpreter into ujit code
*/
static void static void
ujit_gen_entry(codeblock_t* cb) ujit_gen_entry(codeblock_t* cb)
{ {
@ -40,7 +64,7 @@ ujit_gen_entry(codeblock_t* cb)
Generate an inline exit to return to the interpreter Generate an inline exit to return to the interpreter
*/ */
static void static void
ujit_gen_exit(codeblock_t* cb, ctx_t* ctx, VALUE* exit_pc) ujit_gen_exit(jitstate_t* jit, ctx_t* ctx, codeblock_t* cb, VALUE* exit_pc)
{ {
// Write the adjusted SP back into the CFP // Write the adjusted SP back into the CFP
if (ctx->stack_size != 0) if (ctx->stack_size != 0)
@ -62,9 +86,9 @@ ujit_gen_exit(codeblock_t* cb, ctx_t* ctx, VALUE* exit_pc)
Generate an out-of-line exit to return to the interpreter Generate an out-of-line exit to return to the interpreter
*/ */
static uint8_t * static uint8_t *
ujit_side_exit(codeblock_t* cb, ctx_t* ctx) ujit_side_exit(jitstate_t* jit, ctx_t* ctx)
{ {
uint8_t* code_ptr = cb_get_ptr(cb, cb->write_pos); uint8_t* code_ptr = cb_get_ptr(ocb, cb->write_pos);
// Table mapping opcodes to interpreter handlers // Table mapping opcodes to interpreter handlers
const void * const *table = rb_vm_get_insns_address_table(); const void * const *table = rb_vm_get_insns_address_table();
@ -72,15 +96,15 @@ ujit_side_exit(codeblock_t* cb, ctx_t* ctx)
// Write back the old instruction at the exit PC // Write back the old instruction at the exit PC
// Otherwise the interpreter may jump right back to the // Otherwise the interpreter may jump right back to the
// JITted code we're trying to exit // JITted code we're trying to exit
VALUE* exit_pc = &ctx->iseq->body->iseq_encoded[ctx->insn_idx]; VALUE* exit_pc = &jit->iseq->body->iseq_encoded[jit->insn_idx];
int exit_opcode = opcode_at_pc(ctx->iseq, exit_pc); int exit_opcode = opcode_at_pc(jit->iseq, exit_pc);
void* exit_instr = (void*)table[exit_opcode]; void* exit_instr = (void*)table[exit_opcode];
mov(cb, RAX, const_ptr_opnd(exit_pc)); mov(ocb, RAX, const_ptr_opnd(exit_pc));
mov(cb, RCX, const_ptr_opnd(exit_instr)); mov(ocb, RCX, const_ptr_opnd(exit_instr));
mov(cb, mem_opnd(64, RAX, 0), RCX); mov(ocb, mem_opnd(64, RAX, 0), RCX);
// Generate the code to exit to the interpreters // Generate the code to exit to the interpreters
ujit_gen_exit(cb, ctx, exit_pc); ujit_gen_exit(jit, ctx, ocb, exit_pc);
return code_ptr; return code_ptr;
} }
@ -146,20 +170,24 @@ ujit_compile_block(const rb_iseq_t *iseq, uint32_t insn_idx, uint32_t* num_instr
// Get a pointer to the current write position in the code block // Get a pointer to the current write position in the code block
uint8_t *code_ptr = cb_get_ptr(cb, cb->write_pos); uint8_t *code_ptr = cb_get_ptr(cb, cb->write_pos);
// Initialize JIT state object
jitstate_t jit = { 0 };
jit.iseq = iseq;
jit.start_idx = insn_idx;
// Create codegen context // Create codegen context
ctx_t ctx = { 0 }; ctx_t ctx = { 0 };
ctx.iseq = iseq;
ctx.code_ptr = code_ptr;
ctx.start_idx = insn_idx;
// For each instruction to compile // For each instruction to compile
for (;;) { for (;;) {
// Set the current instruction // Set the current instruction
ctx.insn_idx = insn_idx; jit.insn_idx = insn_idx;
ctx.pc = &encoded[insn_idx]; jit.pc = &encoded[insn_idx];
// Get the current opcode // Get the current opcode
int opcode = ctx_get_opcode(&ctx); int opcode = jit_get_opcode(&jit);
//fprintf(stderr, "compiling %s\n", insn_name(opcode));
// Lookup the codegen function for this instruction // Lookup the codegen function for this instruction
st_data_t st_gen_fn; st_data_t st_gen_fn;
@ -169,12 +197,11 @@ ujit_compile_block(const rb_iseq_t *iseq, uint32_t insn_idx, uint32_t* num_instr
break; break;
} }
//fprintf(stderr, "compiling %s\n", insn_name(opcode));
//print_str(cb, insn_name(opcode)); //print_str(cb, insn_name(opcode));
// Call the code generation function // Call the code generation function
codegen_fn gen_fn = (codegen_fn)st_gen_fn; codegen_fn gen_fn = (codegen_fn)st_gen_fn;
if (!gen_fn(cb, ocb, &ctx)) { if (!gen_fn(&jit, &ctx)) {
break; break;
} }
@ -195,12 +222,12 @@ ujit_compile_block(const rb_iseq_t *iseq, uint32_t insn_idx, uint32_t* num_instr
// FIXME: we only need to generate an exit if an instruction fails to compile // FIXME: we only need to generate an exit if an instruction fails to compile
// //
// Generate code to exit to the interpreter // Generate code to exit to the interpreter
ujit_gen_exit(cb, &ctx, &encoded[insn_idx]); ujit_gen_exit(&jit, &ctx, cb, &encoded[insn_idx]);
if (UJIT_DUMP_MODE >= 2) { if (UJIT_DUMP_MODE >= 2) {
// Dump list of compiled instrutions // Dump list of compiled instrutions
fprintf(stderr, "Compiled the following for iseq=%p:\n", (void *)iseq); fprintf(stderr, "Compiled the following for iseq=%p:\n", (void *)iseq);
VALUE *pc = &encoded[ctx.start_idx]; VALUE *pc = &encoded[jit.start_idx];
VALUE *end_pc = &encoded[insn_idx]; VALUE *end_pc = &encoded[insn_idx];
while (pc < end_pc) { while (pc < end_pc) {
int opcode = opcode_at_pc(iseq, pc); int opcode = opcode_at_pc(iseq, pc);
@ -213,7 +240,7 @@ ujit_compile_block(const rb_iseq_t *iseq, uint32_t insn_idx, uint32_t* num_instr
} }
static bool static bool
gen_dup(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_dup(jitstate_t* jit, ctx_t* ctx)
{ {
x86opnd_t dup_val = ctx_stack_pop(ctx, 1); x86opnd_t dup_val = ctx_stack_pop(ctx, 1);
x86opnd_t loc0 = ctx_stack_push(ctx, 1); x86opnd_t loc0 = ctx_stack_push(ctx, 1);
@ -225,14 +252,14 @@ gen_dup(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_nop(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_nop(jitstate_t* jit, ctx_t* ctx)
{ {
// Do nothing // Do nothing
return true; return true;
} }
static bool static bool
gen_pop(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_pop(jitstate_t* jit, ctx_t* ctx)
{ {
// Decrement SP // Decrement SP
ctx_stack_pop(ctx, 1); ctx_stack_pop(ctx, 1);
@ -240,7 +267,7 @@ gen_pop(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_putnil(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_putnil(jitstate_t* jit, ctx_t* ctx)
{ {
// Write constant at SP // Write constant at SP
x86opnd_t stack_top = ctx_stack_push(ctx, 1); x86opnd_t stack_top = ctx_stack_push(ctx, 1);
@ -249,11 +276,11 @@ gen_putnil(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_putobject(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_putobject(jitstate_t* jit, ctx_t* ctx)
{ {
// Load the argument from the bytecode sequence. // Load the argument from the bytecode sequence.
// We need to do this as the argument can change due to GC compaction. // We need to do this as the argument can change due to GC compaction.
x86opnd_t pc_imm = const_ptr_opnd((void*)ctx->pc); x86opnd_t pc_imm = const_ptr_opnd((void*)jit->pc);
mov(cb, RAX, pc_imm); mov(cb, RAX, pc_imm);
mov(cb, RAX, mem_opnd(64, RAX, 8)); // One after the opcode mov(cb, RAX, mem_opnd(64, RAX, 8)); // One after the opcode
@ -265,9 +292,9 @@ gen_putobject(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_putobject_int2fix(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_putobject_int2fix(jitstate_t* jit, ctx_t* ctx)
{ {
int opcode = ctx_get_opcode(ctx); int opcode = jit_get_opcode(jit);
int cst_val = (opcode == BIN(putobject_INT2FIX_0_))? 0:1; int cst_val = (opcode == BIN(putobject_INT2FIX_0_))? 0:1;
// Write constant at SP // Write constant at SP
@ -278,7 +305,7 @@ gen_putobject_int2fix(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_putself(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_putself(jitstate_t* jit, ctx_t* ctx)
{ {
// Load self from CFP // Load self from CFP
mov(cb, RAX, member_opnd(REG_CFP, rb_control_frame_t, self)); mov(cb, RAX, member_opnd(REG_CFP, rb_control_frame_t, self));
@ -291,13 +318,13 @@ gen_putself(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_getlocal_wc0(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_getlocal_wc0(jitstate_t* jit, ctx_t* ctx)
{ {
// Load environment pointer EP from CFP // Load environment pointer EP from CFP
mov(cb, REG0, member_opnd(REG_CFP, rb_control_frame_t, ep)); mov(cb, REG0, member_opnd(REG_CFP, rb_control_frame_t, ep));
// Compute the offset from BP to the local // Compute the offset from BP to the local
int32_t local_idx = (int32_t)ctx_get_arg(ctx, 0); int32_t local_idx = (int32_t)jit_get_arg(jit, 0);
const int32_t offs = -8 * local_idx; const int32_t offs = -8 * local_idx;
// Load the local from the block // Load the local from the block
@ -311,7 +338,7 @@ gen_getlocal_wc0(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_setlocal_wc0(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_setlocal_wc0(jitstate_t* jit, ctx_t* ctx)
{ {
/* /*
vm_env_write(const VALUE *ep, int index, VALUE v) vm_env_write(const VALUE *ep, int index, VALUE v)
@ -334,7 +361,7 @@ gen_setlocal_wc0(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
test(cb, flags_opnd, imm_opnd(VM_ENV_FLAG_WB_REQUIRED)); test(cb, flags_opnd, imm_opnd(VM_ENV_FLAG_WB_REQUIRED));
// Create a size-exit to fall back to the interpreter // Create a size-exit to fall back to the interpreter
uint8_t* side_exit = ujit_side_exit(ocb, ctx); uint8_t* side_exit = ujit_side_exit(jit, ctx);
// if (flags & VM_ENV_FLAG_WB_REQUIRED) != 0 // if (flags & VM_ENV_FLAG_WB_REQUIRED) != 0
jnz_ptr(cb, side_exit); jnz_ptr(cb, side_exit);
@ -344,7 +371,7 @@ gen_setlocal_wc0(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
mov(cb, REG1, stack_top); mov(cb, REG1, stack_top);
// Write the value at the environment pointer // Write the value at the environment pointer
int32_t local_idx = (int32_t)ctx_get_arg(ctx, 0); int32_t local_idx = (int32_t)jit_get_arg(jit, 0);
const int32_t offs = -8 * local_idx; const int32_t offs = -8 * local_idx;
mov(cb, mem_opnd(64, REG0, offs), REG1); mov(cb, mem_opnd(64, REG0, offs), REG1);
@ -368,9 +395,9 @@ guard_self_is_object(codeblock_t *cb, x86opnd_t self_opnd, uint8_t *side_exit, c
} }
static bool static bool
gen_getinstancevariable(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_getinstancevariable(jitstate_t* jit, ctx_t* ctx)
{ {
IVC ic = (IVC)ctx_get_arg(ctx, 1); IVC ic = (IVC)jit_get_arg(jit, 1);
// Check that the inline cache has been set, slot index is known // Check that the inline cache has been set, slot index is known
if (!ic->entry) if (!ic->entry)
@ -390,7 +417,7 @@ gen_getinstancevariable(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
uint32_t ivar_index = ic->entry->index; uint32_t ivar_index = ic->entry->index;
// Create a size-exit to fall back to the interpreter // Create a size-exit to fall back to the interpreter
uint8_t* side_exit = ujit_side_exit(ocb, ctx); uint8_t* side_exit = ujit_side_exit(jit, ctx);
// Load self from CFP // Load self from CFP
mov(cb, REG0, member_opnd(REG_CFP, rb_control_frame_t, self)); mov(cb, REG0, member_opnd(REG_CFP, rb_control_frame_t, self));
@ -430,9 +457,9 @@ gen_getinstancevariable(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_setinstancevariable(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_setinstancevariable(jitstate_t* jit, ctx_t* ctx)
{ {
IVC ic = (IVC)ctx_get_arg(ctx, 1); IVC ic = (IVC)jit_get_arg(jit, 1);
// Check that the inline cache has been set, slot index is known // Check that the inline cache has been set, slot index is known
if (!ic->entry) if (!ic->entry)
@ -452,7 +479,7 @@ gen_setinstancevariable(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
uint32_t ivar_index = ic->entry->index; uint32_t ivar_index = ic->entry->index;
// Create a size-exit to fall back to the interpreter // Create a size-exit to fall back to the interpreter
uint8_t* side_exit = ujit_side_exit(ocb, ctx); uint8_t* side_exit = ujit_side_exit(jit, ctx);
// Load self from CFP // Load self from CFP
mov(cb, REG0, member_opnd(REG_CFP, rb_control_frame_t, self)); mov(cb, REG0, member_opnd(REG_CFP, rb_control_frame_t, self));
@ -501,11 +528,11 @@ gen_setinstancevariable(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_opt_lt(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_opt_lt(jitstate_t* jit, ctx_t* ctx)
{ {
// Create a size-exit to fall back to the interpreter // Create a size-exit to fall back to the interpreter
// Note: we generate the side-exit before popping operands from the stack // Note: we generate the side-exit before popping operands from the stack
uint8_t* side_exit = ujit_side_exit(ocb, ctx); uint8_t* side_exit = ujit_side_exit(jit, ctx);
// TODO: make a helper function for guarding on op-not-redefined // TODO: make a helper function for guarding on op-not-redefined
// Make sure that minus isn't redefined for integers // Make sure that minus isn't redefined for integers
@ -542,11 +569,11 @@ gen_opt_lt(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_opt_minus(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_opt_minus(jitstate_t* jit, ctx_t* ctx)
{ {
// Create a size-exit to fall back to the interpreter // Create a size-exit to fall back to the interpreter
// Note: we generate the side-exit before popping operands from the stack // Note: we generate the side-exit before popping operands from the stack
uint8_t* side_exit = ujit_side_exit(ocb, ctx); uint8_t* side_exit = ujit_side_exit(jit, ctx);
// TODO: make a helper function for guarding on op-not-redefined // TODO: make a helper function for guarding on op-not-redefined
// Make sure that minus isn't redefined for integers // Make sure that minus isn't redefined for integers
@ -582,11 +609,11 @@ gen_opt_minus(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
static bool static bool
gen_opt_plus(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_opt_plus(jitstate_t* jit, ctx_t* ctx)
{ {
// Create a size-exit to fall back to the interpreter // Create a size-exit to fall back to the interpreter
// Note: we generate the side-exit before popping operands from the stack // Note: we generate the side-exit before popping operands from the stack
uint8_t* side_exit = ujit_side_exit(ocb, ctx); uint8_t* side_exit = ujit_side_exit(jit, ctx);
// TODO: make a helper function for guarding on op-not-redefined // TODO: make a helper function for guarding on op-not-redefined
// Make sure that plus isn't redefined for integers // Make sure that plus isn't redefined for integers
@ -658,7 +685,7 @@ cfunc_needs_frame(const rb_method_cfunc_t *cfunc)
} }
static bool static bool
gen_opt_send_without_block(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_opt_send_without_block(jitstate_t* jit, ctx_t* ctx)
{ {
// Relevant definitions: // Relevant definitions:
// rb_execution_context_t : vm_core.h // rb_execution_context_t : vm_core.h
@ -667,7 +694,7 @@ gen_opt_send_without_block(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
// vm_call_cfunc_with_frame : vm_insnhelper.c // vm_call_cfunc_with_frame : vm_insnhelper.c
// rb_callcache : vm_callinfo.h // rb_callcache : vm_callinfo.h
struct rb_call_data * cd = (struct rb_call_data *)ctx_get_arg(ctx, 0); struct rb_call_data * cd = (struct rb_call_data *)jit_get_arg(jit, 0);
int32_t argc = (int32_t)vm_ci_argc(cd->ci); int32_t argc = (int32_t)vm_ci_argc(cd->ci);
// Don't JIT calls with keyword splat // Don't JIT calls with keyword splat
@ -715,7 +742,7 @@ gen_opt_send_without_block(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
} }
// Create a size-exit to fall back to the interpreter // Create a size-exit to fall back to the interpreter
uint8_t* side_exit = ujit_side_exit(ocb, ctx); uint8_t* side_exit = ujit_side_exit(jit, ctx);
// Check for interrupts // Check for interrupts
// RUBY_VM_CHECK_INTS(ec) // RUBY_VM_CHECK_INTS(ec)
@ -754,7 +781,7 @@ gen_opt_send_without_block(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
jne_ptr(cb, side_exit); jne_ptr(cb, side_exit);
// Store incremented PC into current control frame in case callee raises. // Store incremented PC into current control frame in case callee raises.
mov(cb, REG0, const_ptr_opnd(ctx->pc + insn_len(BIN(opt_send_without_block)))); mov(cb, REG0, const_ptr_opnd(jit->pc + insn_len(BIN(opt_send_without_block))));
mov(cb, mem_opnd(64, REG_CFP, offsetof(rb_control_frame_t, pc)), REG0); mov(cb, mem_opnd(64, REG_CFP, offsetof(rb_control_frame_t, pc)), REG0);
// If this function needs a Ruby stack frame // If this function needs a Ruby stack frame
@ -865,7 +892,8 @@ gen_opt_send_without_block(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
//print_str(cb, "before C call"); //print_str(cb, "before C call");
assume_method_lookup_stable(cd->cc, cme, ctx); // FIXME
//assume_method_lookup_stable(cd->cc, cme, ctx);
// Call the C function // Call the C function
// VALUE ret = (cfunc->func)(recv, argv[0], argv[1]); // VALUE ret = (cfunc->func)(recv, argv[0], argv[1]);
@ -909,7 +937,7 @@ gen_branchunless_branch(codeblock_t* cb, uint8_t* target0, uint8_t* target1, uin
} }
static bool static bool
gen_branchunless(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx) gen_branchunless(jitstate_t* jit, ctx_t* ctx)
{ {
// TODO: we need to eventually do an interrupt check when jumping/branching // TODO: we need to eventually do an interrupt check when jumping/branching
// How can we do this while keeping the check logic out of line? // How can we do this while keeping the check logic out of line?
@ -924,10 +952,10 @@ gen_branchunless(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
test(cb, val_opnd, imm_opnd(~Qnil)); test(cb, val_opnd, imm_opnd(~Qnil));
// Get the branch target instruction offsets // Get the branch target instruction offsets
uint32_t next_idx = ctx_next_idx(ctx); uint32_t next_idx = jit_next_idx(jit);
uint32_t jump_idx = next_idx + (uint32_t)ctx_get_arg(ctx, 0); uint32_t jump_idx = next_idx + (uint32_t)jit_get_arg(jit, 0);
blockid_t next_block = { ctx->iseq, next_idx }; blockid_t next_block = { jit->iseq, next_idx };
blockid_t jump_block = { ctx->iseq, jump_idx }; blockid_t jump_block = { jit->iseq, jump_idx };
// Generate the branch instructions // Generate the branch instructions
gen_branch(cb, ocb, jump_block, next_block, gen_branchunless_branch); gen_branch(cb, ocb, jump_block, next_block, gen_branchunless_branch);
@ -965,6 +993,6 @@ ujit_init_codegen(void)
st_insert(gen_fns, (st_data_t)BIN(opt_lt), (st_data_t)&gen_opt_lt); st_insert(gen_fns, (st_data_t)BIN(opt_lt), (st_data_t)&gen_opt_lt);
st_insert(gen_fns, (st_data_t)BIN(opt_minus), (st_data_t)&gen_opt_minus); st_insert(gen_fns, (st_data_t)BIN(opt_minus), (st_data_t)&gen_opt_minus);
st_insert(gen_fns, (st_data_t)BIN(opt_plus), (st_data_t)&gen_opt_plus); st_insert(gen_fns, (st_data_t)BIN(opt_plus), (st_data_t)&gen_opt_plus);
st_insert(gen_fns, (st_data_t)BIN(opt_send_without_block), (st_data_t)&gen_opt_send_without_block); //st_insert(gen_fns, (st_data_t)BIN(opt_send_without_block), (st_data_t)&gen_opt_send_without_block);
//st_insert(gen_fns, (st_data_t)BIN(branchunless), (st_data_t)&gen_branchunless); st_insert(gen_fns, (st_data_t)BIN(branchunless), (st_data_t)&gen_branchunless);
} }

19
ujit_codegen.h
View file

@ -7,8 +7,25 @@
codeblock_t* cb; codeblock_t* cb;
codeblock_t* ocb; codeblock_t* ocb;
// Code generation state
typedef struct JITState
{
// Instruction sequence this is associated with
const rb_iseq_t *iseq;
// Index in the iseq of the opcode we are replacing
uint32_t start_idx;
// Index of the current instruction being compiled
uint32_t insn_idx;
// Current PC
VALUE *pc;
} jitstate_t;
// Code generation function signature // Code generation function signature
typedef bool (*codegen_fn)(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx); typedef bool (*codegen_fn)(jitstate_t* jit, ctx_t* ctx);
uint8_t* ujit_compile_entry(const rb_iseq_t *iseq, uint32_t insn_idx); uint8_t* ujit_compile_entry(const rb_iseq_t *iseq, uint32_t insn_idx);

22
ujit_core.c
View file

@ -19,28 +19,6 @@ st_table * version_tbl;
branch_t branch_entries[MAX_BRANCHES]; branch_t branch_entries[MAX_BRANCHES];
uint32_t num_branches = 0; uint32_t num_branches = 0;
// Get the current instruction opcode from the context object
int
ctx_get_opcode(ctx_t *ctx)
{
return opcode_at_pc(ctx->iseq, ctx->pc);
}
// Get the index of the next instruction
uint32_t
ctx_next_idx(ctx_t* ctx)
{
return ctx->insn_idx + insn_len(ctx_get_opcode(ctx));
}
// Get an instruction argument from the context object
VALUE
ctx_get_arg(ctx_t* ctx, size_t arg_idx)
{
assert (arg_idx + 1 < insn_len(ctx_get_opcode(ctx)));
return *(ctx->pc + arg_idx + 1);
}
/* /*
Get an operand for the adjusted stack pointer address Get an operand for the adjusted stack pointer address
*/ */

32
ujit_core.h
View file

@ -20,41 +20,9 @@
// Maximum number of versions per block // Maximum number of versions per block
#define MAX_VERSIONS 5 #define MAX_VERSIONS 5
// Code generation state
typedef struct JITState
{
} jitstate_t;
// Code generation context // Code generation context
typedef struct CtxStruct typedef struct CtxStruct
{ {
// TODO: we may want to remove information that is not
// strictly necessary for versioning from this struct
// Some of the information here is only needed during
// code generation, eg: current pc
// FIXME: we probably don't need this? we just need to
// know which initial bytecode we're replacing
// The start of the generated code
uint8_t *code_ptr;
// Instruction sequence this is associated with
const rb_iseq_t *iseq;
// Index in the iseq of the opcode we are replacing
uint32_t start_idx;
// Index of the current instruction being compiled
uint32_t insn_idx;
// Current PC
VALUE *pc;
// Number of values pushed on the temporary stack // Number of values pushed on the temporary stack
uint32_t stack_size; uint32_t stack_size;

6
ujit_iface.c
View file

@ -63,6 +63,7 @@ opcode_at_pc(const rb_iseq_t *iseq, const VALUE *pc)
} }
} }
/*
// GC root for interacting with the GC // GC root for interacting with the GC
struct ujit_root_struct {}; struct ujit_root_struct {};
@ -193,11 +194,13 @@ static const rb_data_type_t ujit_root_type = {
{ujit_root_mark, ujit_root_free, ujit_root_memsize, }, {ujit_root_mark, ujit_root_free, ujit_root_memsize, },
0, 0, RUBY_TYPED_FREE_IMMEDIATELY 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
}; };
*/
// Callback when cme or cc become invalid // Callback when cme or cc become invalid
void void
rb_ujit_method_lookup_change(VALUE cme_or_cc) rb_ujit_method_lookup_change(VALUE cme_or_cc)
{ {
/*
if (!method_lookup_dependency) return; if (!method_lookup_dependency) return;
RUBY_ASSERT(IMEMO_TYPE_P(cme_or_cc, imemo_ment) || IMEMO_TYPE_P(cme_or_cc, imemo_callcache)); RUBY_ASSERT(IMEMO_TYPE_P(cme_or_cc, imemo_ment) || IMEMO_TYPE_P(cme_or_cc, imemo_callcache));
@ -223,6 +226,7 @@ rb_ujit_method_lookup_change(VALUE cme_or_cc)
array->size = 0; array->size = 0;
} }
*/
} }
void void
@ -256,9 +260,11 @@ rb_ujit_init(void)
ujit_init_core(); ujit_init_core();
ujit_init_codegen(); ujit_init_codegen();
/*
// Initialize the GC hooks // Initialize the GC hooks
method_lookup_dependency = st_init_numtable(); method_lookup_dependency = st_init_numtable();
struct ujit_root_struct *root; struct ujit_root_struct *root;
VALUE ujit_root = TypedData_Make_Struct(0, struct ujit_root_struct, &ujit_root_type, root); VALUE ujit_root = TypedData_Make_Struct(0, struct ujit_root_struct, &ujit_root_type, root);
rb_gc_register_mark_object(ujit_root); rb_gc_register_mark_object(ujit_root);
*/
} }