diff options
Diffstat (limited to 'tool')
| -rw-r--r-- | tool/ruby_vm/views/_mjit_compile_insn.erb | 133 | ||||
| -rw-r--r-- | tool/ruby_vm/views/_mjit_compile_send.erb | 74 | ||||
| -rw-r--r-- | tool/ruby_vm/views/mjit_compile.inc.erb | 66 | ||||
| -rw-r--r-- | tool/transform_mjit_header.rb | 1 | ||||
| -rwxr-xr-x | tool/update-deps | 1 |
5 files changed, 275 insertions, 0 deletions
diff --git a/tool/ruby_vm/views/_mjit_compile_insn.erb b/tool/ruby_vm/views/_mjit_compile_insn.erb new file mode 100644 index 0000000000..60ba2505d2 --- /dev/null +++ b/tool/ruby_vm/views/_mjit_compile_insn.erb @@ -0,0 +1,133 @@ +% # -*- mode:c; style:ruby; coding: utf-8; indent-tabs-mode: nil -*- +% # Copyright (c) 2018 Takashi Kokubun. All rights reserved. +% # +% # This file is a part of the programming language Ruby. Permission is hereby +% # granted, to either redistribute and/or modify this file, provided that the +% # conditions mentioned in the file COPYING are met. Consult the file for +% # details. +% +% trace_enablable_insns = [ +% 'opt_send_without_block', +% 'send', +% 'invokeblock', +% 'invokesuper', +% ] +% +% to_cstr = lambda do |line| +% normalized = line.gsub(/\t/, ' ' * 8) +% indented = normalized.sub(/\A(?!#)/, ' ') # avoid indenting preprocessor +% rstring2cstr(indented.rstrip).sub(/"\z/, '\\n"') +% end +% + fprintf(f, "{\n"); + { +% # compiler: Prepare operands which may be used by `insn.call_attribute` +% insn.opes.each_with_index do |ope, i| + MAYBE_UNUSED(<%= ope.fetch(:decl) %>) = (<%= ope.fetch(:type) %>)operands[<%= i %>]; +% end +% +% # JIT: Declare variables for operands, popped values and return values +% ret_decls = insn.rets.map { |r| "MAYBE_UNUSED(#{r.fetch(:type)}) #{r.fetch(:name)}"} # TODO: fix #declarations to return Hash... +% insn.declarations.each do |decl| +% next if dispatched && ret_decls.include?(decl) # return value should be propagated to dispatcher. TODO: assert it's the same as dispatcher + fprintf(f, " <%= decl %>;\n"); +% end + +% # JIT: Set const expressions for `RubyVM::OperandsUnifications` insn +% insn.preamble.each do |amble| + fprintf(f, "<%= amble.expr %>\n"); +% end +% +% # JIT: Initialize operands +% insn.opes.each_with_index do |ope, i| + fprintf(f, " <%= ope.fetch(:name) %> = (<%= ope.fetch(:type) %>)0x%"PRIxVALUE";\n", operands[<%= i %>]); +% end +% +% # JIT: Initialize popped values +% insn.pops.reverse_each.with_index.reverse_each do |pop, i| + fprintf(f, " <%= pop.fetch(:name) %> = stack[%d];\n", b->stack_size - <%= i + 1 %>); +% end +% +% # JIT: move sp and pc if necessary +% if insn.handles_frame? + fprintf(f, " reg_cfp->pc = (VALUE *)0x%"PRIxVALUE";\n", (VALUE)(body->iseq_encoded + next_pos)); /* ADD_PC(INSN_ATTR(width)); */ + fprintf(f, " reg_cfp->sp = reg_cfp->bp + %d;\n", b->stack_size + 1 - <%= insn.pops.size %>); /* POPN(INSN_ATTR(popn)); */ +% else + fprintf(f, " reg_cfp->pc = (VALUE *)0x%"PRIxVALUE";\n", (VALUE)(body->iseq_encoded + pos)); + fprintf(f, " reg_cfp->sp = reg_cfp->bp + %d;\n", b->stack_size + 1); +% end +% +% # JIT: Print insn body in insns.def +% insn.expr.expr.each_line do |line| +% # Special macro expansion for ones that can't be resolved by macro redefinition. +% if line =~ /\A\s+DISPATCH_ORIGINAL_INSN\((?<insn_name>[^)]+)\);\s+\z/ + fprintf(f, " return Qundef; /* cancel JIT */\n"); +% elsif line =~ /\A\s+JUMP\((?<dest>[^)]+)\);\s+\z/ +% # Before we `goto` next insn, we need to set return values, especially for getinlinecache +% insn.rets.reverse_each.with_index do |ret, i| +% # TOPN(n) = ... + fprintf(f, " stack[%d] = <%= ret.fetch(:name) %>;\n", b->stack_size + (int)<%= insn.call_attribute('sp_inc') %> - <%= i + 1 %>); +% end +% +% dest = Regexp.last_match[:dest] +% if insn.name == 'opt_case_dispatch' # special case... TODO: use another macro to avoid checking name + { + struct case_dispatch_var arg; + arg.f = f; + arg.base_pos = pos + insn_len(insn); + arg.last_value = Qundef; + + fprintf(f, " switch (<%= dest %>) {\n"); + st_foreach(RHASH_TBL_RAW(hash), compile_case_dispatch_each, (VALUE)&arg); + fprintf(f, " case %lu:\n", else_offset); + fprintf(f, " goto label_%lu;\n", arg.base_pos + else_offset); + fprintf(f, " }\n"); + } +% else + next_pos = pos + insn_len(insn) + (unsigned int)<%= dest %>; + fprintf(f, " goto label_%d;\n", next_pos); +% end +% elsif line =~ /\A\s+RESTORE_REGS\(\);\s+\z/ # for `leave` only +#if OPT_CALL_THREADED_CODE + fprintf(f, " rb_ec_thread_ptr(ec)->retval = val;\n"); + fprintf(f, " return 0;\n"); +#else + fprintf(f, " return val;\n"); +#endif +% else + fprintf(f, <%= to_cstr.call(line) %>); +% end +% end +% +% # JIT: Set return values +% unless dispatched +% insn.rets.reverse_each.with_index do |ret, i| +% # TOPN(n) = ... + fprintf(f, " stack[%d] = <%= ret.fetch(:name) %>;\n", b->stack_size + (int)<%= insn.call_attribute('sp_inc') %> - <%= i + 1 %>); +% end +% end +% +% # JIT: We should evaluate ISeq modified for TracePoint if it's enabled. Note: This is slow. +% if trace_enablable_insns.include?(insn.name) + fprintf(f, " if (UNLIKELY(ruby_vm_event_enabled_flags & ISEQ_TRACE_EVENTS)) {\n"); + fprintf(f, " reg_cfp->sp = reg_cfp->bp + %d;\n", b->stack_size + (int)<%= insn.call_attribute('sp_inc') %> + 1); + fprintf(f, " return Qundef; /* cancel JIT */\n"); + fprintf(f, " }\n"); +% end +% +% # compiler: Move JIT compiler's internal stack pointer +% unless dispatched + b->stack_size += <%= insn.call_attribute('sp_inc') %>; +% end + } + fprintf(f, "}\n"); +% +% # compiler: If insn has conditional JUMP, the branch which is not targeted by JUMP should be compiled too. +% if insn.expr.expr =~ /if\s+\([^{}]+\)\s+\{[^{}]+JUMP\([^)]+\);[^{}]+\}/ + compile_insns(f, body, b->stack_size, pos + insn_len(insn), status); +% end +% +% # compiler: If insn returns (leave) or does longjmp (throw), the branch should no longer be compieled. TODO: create attr for it? +% if insn.expr.expr =~ /\sTHROW_EXCEPTION\([^)]+\);/ || insn.expr.expr =~ /\sRESTORE_REGS\(\);/ + b->finish_p = TRUE; +% end diff --git a/tool/ruby_vm/views/_mjit_compile_send.erb b/tool/ruby_vm/views/_mjit_compile_send.erb new file mode 100644 index 0000000000..6624cfe7db --- /dev/null +++ b/tool/ruby_vm/views/_mjit_compile_send.erb @@ -0,0 +1,74 @@ +% # -*- mode:c; style:ruby; coding: utf-8; indent-tabs-mode: nil -*- +% # Copyright (c) 2018 Takashi Kokubun. All rights reserved. +% # +% # This file is a part of the programming language Ruby. Permission is hereby +% # granted, to either redistribute and/or modify this file, provided that the +% # conditions mentioned in the file COPYING are met. Consult the file for +% # details. +% +% # Optimized case of send / opt_send_without_block instructions. + { +% # compiler: Prepare operands which may be used by `insn.call_attribute` +% insn.opes.each_with_index do |ope, i| + MAYBE_UNUSED(<%= ope.fetch(:decl) %>) = (<%= ope.fetch(:type) %>)operands[<%= i %>]; +% end +% + const rb_iseq_t *iseq; + unsigned int argc = ci->orig_argc; /* unlike `ci->orig_argc`, `argc` may include blockarg */ +% if insn.name == 'send' + argc += ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0); +% end + + if (inlinable_iseq_p(ci, cc, iseq = get_iseq_if_available(cc))) { + int param_size = iseq->body->param.size; /* TODO: check calling->argc for argument_arity_error */ + +% # JIT: move sp and pc if necessary + fprintf(f, " reg_cfp->pc = (VALUE *)0x%"PRIxVALUE";\n", (VALUE)(body->iseq_encoded + next_pos)); /* ADD_PC(INSN_ATTR(width)); */ + fprintf(f, " reg_cfp->sp = reg_cfp->bp + %d;\n", b->stack_size + 1 - <%= insn.pops.size %>); /* POPN(INSN_ATTR(popn)); */ + +% # JIT: Invalidate call cache if it requires vm_search_method. This allows to inline some of following things. + fprintf(f, " if (UNLIKELY(GET_GLOBAL_METHOD_STATE() != %llu || RCLASS_SERIAL(CLASS_OF(stack[%d])) != %llu)) {\n", cc->method_state, b->stack_size - 1 - argc, cc->class_serial); + fprintf(f, " reg_cfp->pc = (VALUE *)0x%"PRIxVALUE";\n", (VALUE)(body->iseq_encoded + pos)); + fprintf(f, " return Qundef; /* cancel JIT */\n"); + fprintf(f, " }\n"); + +% # JIT: Print insn body in insns.def + fprintf(f, " {\n"); + fprintf(f, " struct rb_calling_info calling;\n"); +% if insn.name == 'send' + fprintf(f, " vm_caller_setup_arg_block(ec, reg_cfp, &calling, 0x%"PRIxVALUE", 0x%"PRIxVALUE", FALSE);\n", operands[0], operands[2]); +% else + fprintf(f, " calling.block_handler = VM_BLOCK_HANDLER_NONE;\n"); +% end + fprintf(f, " calling.argc = %d;\n", ci->orig_argc); + fprintf(f, " calling.recv = stack[%d];\n", b->stack_size - 1 - argc); + +% # JIT: Special CALL_METHOD. Inline vm_call_iseq_setup_normal for vm_call_iseq_setup_func FASTPATH. TODO: modify VM to share code with here + fprintf(f, " {\n"); + fprintf(f, " VALUE v;\n"); + fprintf(f, " VALUE *argv = reg_cfp->sp - calling.argc;\n"); + fprintf(f, " reg_cfp->sp = argv - 1;\n"); /* recv */ + fprintf(f, " vm_push_frame(ec, 0x%"PRIxVALUE", VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL, calling.recv, " + "calling.block_handler, 0x%"PRIxVALUE", 0x%"PRIxVALUE", argv + %d, %d, %d);\n", + (VALUE)iseq, (VALUE)cc->me, (VALUE)iseq->body->iseq_encoded, param_size, iseq->body->local_table_size - param_size, iseq->body->stack_max); + fprintf(f, " if ((v = mjit_exec(ec)) == Qundef) {\n"); + fprintf(f, " VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);\n"); /* This is vm_call0_body's code after vm_call_iseq_setup */ + fprintf(f, " v = vm_exec(ec);\n"); + fprintf(f, " }\n"); + fprintf(f, " stack[%d] = v;\n", b->stack_size - argc - 1); + fprintf(f, " }\n"); + + fprintf(f, " }\n"); + +% # JIT: We should evaluate ISeq modified for TracePoint if it's enabled. Note: This is slow. + fprintf(f, " if (UNLIKELY(ruby_vm_event_enabled_flags & ISEQ_TRACE_EVENTS)) {\n"); + fprintf(f, " reg_cfp->sp = reg_cfp->bp + %d;\n", b->stack_size + (int)<%= insn.call_attribute('sp_inc') %> + 1); + fprintf(f, " return Qundef; /* cancel JIT */\n"); + fprintf(f, " }\n"); + +% # compiler: Move JIT compiler's internal stack pointer + b->stack_size += <%= insn.call_attribute('sp_inc') %>; + + break; + } + } diff --git a/tool/ruby_vm/views/mjit_compile.inc.erb b/tool/ruby_vm/views/mjit_compile.inc.erb new file mode 100644 index 0000000000..7437a44855 --- /dev/null +++ b/tool/ruby_vm/views/mjit_compile.inc.erb @@ -0,0 +1,66 @@ +/* -*- mode:c; style:ruby; coding: utf-8; indent-tabs-mode: nil -*- */ + +% # Copyright (c) 2018 Takashi Kokubun. All rights reserved. +% # +% # This file is a part of the programming language Ruby. Permission is hereby +% # granted, to either redistribute and/or modify this file, provided that the +% # conditions mentioned in the file COPYING are met. Consult the file for +% # details. +<%= render 'copyright' %> +% +% # This is an ERB template that generates Ruby code that generates C code that +% # generates JIT-ed C code. +<%= render 'notice', locals: { + this_file: 'is the main part of compile_insn() in mjit_compile.c', + edit: __FILE__, +} -%> +% +% unsupported_insns = [ +% 'getblockparamproxy', # TODO: support this +% 'defineclass', # low priority +% 'opt_call_c_function', # low priority +% ] +% +% # Available variables and macros in JIT-ed function: +% # ec: the first argument of _mjitXXX +% # reg_cfp: the second argument of _mjitXXX +% # GET_CFP(): refers to `reg_cfp` +% # GET_EP(): refers to `reg_cfp->ep` +% # GET_SP(): refers to `reg_cfp->sp` +% # INC_SP(): refers to `reg_cfp->sp` +% # SET_SV(): refers to `reg_cfp->sp` +% # PUSH(): refers to `SET_SV()`, `INC_SP()` +% # GET_SELF(): refers to `reg_cfp->self` +% # GET_LEP(): refers to `VM_EP_LEP(reg_cfp->ep)` +% # EXEC_EC_CFP(): refers to `val = vm_exec(ec)` with frame setup +% # CALL_METHOD(): using `GET_CFP()` and `EXEC_EC_CFP()` +% # TOPN(): refers to `reg_cfp->sp`, which needs to have correct sp (of course) +% # STACK_ADDR_FROM_TOP(): refers to `reg_cfp->sp`, same problem here +% # DISPATCH_ORIGINAL_INSN(): expanded in _mjit_compile_insn.erb +% # THROW_EXCEPTION(): specially defined for JIT +% # RESTORE_REGS(): specially defined for `leave` + +switch (insn) { +% (RubyVM::BareInstructions.to_a + RubyVM::OperandsUnifications.to_a).each do |insn| +% next if unsupported_insns.include?(insn.name) + case BIN(<%= insn.name %>): +% if %w[opt_send_without_block send].include?(insn.name) +<%= render 'mjit_compile_send', locals: { insn: insn } -%> +% end +<%= render 'mjit_compile_insn', locals: { insn: insn, dispatched: false } -%> + break; +% end +% # We don't support InstructionsUnifications yet because it's not used for now. +% # We don't support TraceInstructions yet. There is no blocker for it but it's just not implemented. + default: + if (mjit_opts.warnings || mjit_opts.verbose >= 3) + /* passing excessive arguments to suppress warning in insns_info.inc as workaround... */ + fprintf(stderr, "MJIT warning: Failed to compile instruction: %s (%s: %d...)\n", + insn_name(insn), insn_op_types(insn), insn_len(insn) > 0 ? insn_op_type(insn, 0) : 0); + status->success = FALSE; + break; +} + +/* if next_pos is already compiled, next instruction won't be compiled in C code and needs `goto`. */ +if ((next_pos < body->iseq_size && status->compiled_for_pos[next_pos])) + fprintf(f, " goto label_%d;\n", next_pos); diff --git a/tool/transform_mjit_header.rb b/tool/transform_mjit_header.rb index 308379123b..4c3377b18f 100644 --- a/tool/transform_mjit_header.rb +++ b/tool/transform_mjit_header.rb @@ -17,6 +17,7 @@ module MJITHeader ] IGNORED_FUNCTIONS = [ + 'vm_search_method_slowpath', # This increases the time to compile when inlined. So we use it as external function. 'rb_equal_opt', # Not used from VM and not compilable ] diff --git a/tool/update-deps b/tool/update-deps index ccfc160e42..200afe7ca0 100755 --- a/tool/update-deps +++ b/tool/update-deps @@ -120,6 +120,7 @@ FILES_NEED_VPATH = %w[ known_errors.inc lex.c miniprelude.c + mjit_compile.inc newline.c node_name.inc opt_sc.inc |