Ruby MJIT (#6028)

10 files changed, 57 insertions, 657 deletions

diff --git a/tool/ruby_vm/views/_mjit_compile_getconstant_path.erb b/tool/ruby_vm/views/_mjit_compile_getconstant_path.erb
deleted file mode 100644
index c321da9a52..0000000000
--- a/tool/ruby_vm/views/_mjit_compile_getconstant_path.erb
+++ /dev/null
@@ -1,30 +0,0 @@
-% # -*- C -*-
-% # Copyright (c) 2020 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.
-%
-% # compiler: Declare dst and ic
-% insn.opes.each_with_index do |ope, i|
-    <%= ope.fetch(:decl) %> = (<%= ope.fetch(:type) %>)operands[<%= i %>];
-% end
-
-% # compiler: Capture IC values, locking getinlinecache
-    struct iseq_inline_constant_cache_entry *ice = ic->entry;
-    if (ice != NULL && !status->compile_info->disable_const_cache) {
-%       # JIT: Inline everything in IC, and cancel the slow path
-        fprintf(f, "    if (vm_inlined_ic_hit_p(0x%"PRIxVALUE", 0x%"PRIxVALUE", (const rb_cref_t *)0x%"PRIxVALUE", reg_cfp->ep)) {", ice->flags, ice->value, (VALUE)ice->ic_cref);
-        fprintf(f, "        stack[%d] = 0x%"PRIxVALUE";\n", b->stack_size, ice->value);
-        fprintf(f, "    }");
-        fprintf(f, "    else {");
-        fprintf(f, "        reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);
-        fprintf(f, "        reg_cfp->pc = original_body_iseq + %d;\n", pos);
-        fprintf(f, "        goto const_cancel;\n");
-        fprintf(f, "    }");
-
-%       # 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_insn.erb b/tool/ruby_vm/views/_mjit_compile_insn.erb
deleted file mode 100644
index f54d1b0e0e..0000000000
--- a/tool/ruby_vm/views/_mjit_compile_insn.erb
+++ /dev/null
@@ -1,92 +0,0 @@
-% # -*- C -*-
-% # 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.
-    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 stack_size to be used in some macro of _mjit_compile_insn_body.erb
-        if (status->local_stack_p) {
-            fprintf(f, "    MAYBE_UNUSED(unsigned int) stack_size = %u;\n", b->stack_size);
-        }
-%
-% # JIT: Declare variables for operands, popped values and return values
-% insn.declarations.each do |decl|
-        fprintf(f, "    <%= decl %>;\n");
-% end
-
-% # JIT: Set const expressions for `RubyVM::OperandsUnifications` insn
-% insn.preamble.each do |amble|
-        fprintf(f, "<%= amble.expr.sub(/const \S+\s+/, '') %>\n");
-% end
-%
-% # JIT: Initialize operands
-% insn.opes.each_with_index do |ope, i|
-        fprintf(f, "    <%= ope.fetch(:name) %> = (<%= ope.fetch(:type) %>)0x%"PRIxVALUE";", operands[<%= i %>]);
-%   case ope.fetch(:type)
-%   when 'ID'
-        comment_id(f, (ID)operands[<%= i %>]);
-%   when 'CALL_DATA'
-        comment_id(f, vm_ci_mid(((CALL_DATA)operands[<%= i %>])->ci));
-%   when 'VALUE'
-        if (SYMBOL_P((VALUE)operands[<%= i %>])) comment_id(f, SYM2ID((VALUE)operands[<%= i %>]));
-%   end
-        fprintf(f, "\n");
-% 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
-<%= render 'mjit_compile_pc_and_sp', locals: { insn: insn } -%>
-%
-% # JIT: Print insn body in insns.def
-<%= render 'mjit_compile_insn_body', locals: { insn: insn } -%>
-%
-% # JIT: Set return values
-% 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
-%
-% # JIT: We should evaluate ISeq modified for TracePoint if it's enabled. Note: This is slow.
-% #      leaf insn may not cancel JIT. leaf_without_check_ints is covered in RUBY_VM_CHECK_INTS of _mjit_compile_insn_body.erb.
-% unless insn.always_leaf? || insn.leaf_without_check_ints?
-        fprintf(f, "    if (UNLIKELY(!mjit_call_p)) {\n");
-        fprintf(f, "        reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size + (int)<%= insn.call_attribute('sp_inc') %>);
-        if (!pc_moved_p) {
-            fprintf(f, "        reg_cfp->pc = original_body_iseq + %d;\n", next_pos);
-        }
-        fprintf(f, "        RB_DEBUG_COUNTER_INC(mjit_cancel_invalidate_all);\n");
-        fprintf(f, "        goto cancel;\n");
-        fprintf(f, "    }\n");
-% end
-%
-% # compiler: Move JIT compiler's internal stack pointer
-        b->stack_size += <%= insn.call_attribute('sp_inc') %>;
-    }
-    fprintf(f, "}\n");
-%
-% # compiler: If insn has conditional JUMP, the code should go to the branch not targeted by JUMP next.
-% if insn.expr.expr =~ /if\s+\([^{}]+\)\s+\{[^{}]+JUMP\([^)]+\);[^{}]+\}/
-    if (ALREADY_COMPILED_P(status, pos + insn_len(insn))) {
-        fprintf(f, "goto label_%d;\n", pos + insn_len(insn));
-    }
-    else {
-        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 compiled. TODO: create attr for it?
-% if insn.expr.expr =~ /\sTHROW_EXCEPTION\([^)]+\);/ || insn.expr.expr =~ /\bvm_pop_frame\(/
-    b->finish_p = TRUE;
-% end
diff --git a/tool/ruby_vm/views/_mjit_compile_insn_body.erb b/tool/ruby_vm/views/_mjit_compile_insn_body.erb
deleted file mode 100644
index 187e043837..0000000000
--- a/tool/ruby_vm/views/_mjit_compile_insn_body.erb
+++ /dev/null
@@ -1,129 +0,0 @@
-% # -*- C -*-
-% # 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.
-%
-% to_cstr = lambda do |line|
-%   normalized = line.gsub(/\t/, ' ' * 8)
-%   indented = normalized.sub(/\A(?!#)/, '    ') # avoid indenting preprocessor
-%   rstring2cstr(indented.rstrip).sub(/"\z/, '\\n"')
-% end
-%
-% #
-% # Expand simple macro, which doesn't require dynamic C code.
-% #
-% expand_simple_macros = lambda do |arg_expr|
-%   arg_expr.dup.tap do |expr|
-%     # For `leave`. We can't proceed next ISeq in the same JIT function.
-%     expr.gsub!(/^(?<indent>\s*)RESTORE_REGS\(\);\n/) do
-%       indent = Regexp.last_match[:indent]
-%       <<-end.gsub(/^ +/, '')
-%         #if OPT_CALL_THREADED_CODE
-%         #{indent}rb_ec_thread_ptr(ec)->retval = val;
-%         #{indent}return 0;
-%         #else
-%         #{indent}return val;
-%         #endif
-%       end
-%     end
-%     expr.gsub!(/^(?<indent>\s*)NEXT_INSN\(\);\n/) do
-%       indent = Regexp.last_match[:indent]
-%       <<-end.gsub(/^ +/, '')
-%         #{indent}UNREACHABLE_RETURN(Qundef);
-%       end
-%     end
-%   end
-% end
-%
-% #
-% # Print a body of insn, but with macro expansion.
-% #
-% expand_simple_macros.call(insn.expr.expr).each_line do |line|
-%   #
-%   # Expand dynamic macro here (only JUMP for now)
-%   #
-%   # TODO: support combination of following macros in the same line
-%   case line
-%   when /\A\s+RUBY_VM_CHECK_INTS\(ec\);\s+\z/
-%     if insn.leaf_without_check_ints? # lazily move PC and optionalize mjit_call_p here
-        fprintf(f, "            if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(ec))) {\n");
-        fprintf(f, "                reg_cfp->pc = original_body_iseq + %d;\n", next_pos); /* ADD_PC(INSN_ATTR(width)); */
-        fprintf(f, "                rb_threadptr_execute_interrupts(rb_ec_thread_ptr(ec), 0);\n");
-        fprintf(f, "                if (UNLIKELY(!mjit_call_p)) {\n");
-        fprintf(f, "                    reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);
-        fprintf(f, "                    RB_DEBUG_COUNTER_INC(mjit_cancel_invalidate_all);\n");
-        fprintf(f, "                    goto cancel;\n");
-        fprintf(f, "                }\n");
-        fprintf(f, "            }\n");
-%     else
-        fprintf(f, <%= to_cstr.call(line) %>);
-%     end
-%   when /\A\s+JUMP\((?<dest>[^)]+)\);\s+\z/
-%     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
-%       # 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
-%
-        next_pos = pos + insn_len(insn) + (unsigned int)<%= dest %>;
-        fprintf(f, "            goto label_%d;\n", next_pos);
-%     end
-%   when /\A\s+CALL_SIMPLE_METHOD\(\);\s+\z/
-%     # For `opt_xxx`'s fallbacks.
-        if (status->local_stack_p) {
-            fprintf(f, "            reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);
-        }
-        fprintf(f, "            reg_cfp->pc = original_body_iseq + %d;\n", pos);
-        fprintf(f, "            RB_DEBUG_COUNTER_INC(mjit_cancel_opt_insn);\n");
-        fprintf(f, "            goto cancel;\n");
-%   when /\A(?<prefix>.+\b)INSN_LABEL\((?<name>[^)]+)\)(?<suffix>.+)\z/m
-%     prefix, name, suffix = Regexp.last_match[:prefix], Regexp.last_match[:name], Regexp.last_match[:suffix]
-        fprintf(f, "    <%= prefix.gsub(/\t/, ' ' * 8) %>INSN_LABEL(<%= name %>_%d)<%= suffix.sub(/\n/, '\n') %>", pos);
-%   else
-%     if insn.handles_sp?
-%       # If insn.handles_sp? is true, cfp->sp might be changed inside insns (like vm_caller_setup_arg_block)
-%       # and thus we need to use cfp->sp, even when local_stack_p is TRUE. When insn.handles_sp? is true,
-%       # cfp->sp should be available too because _mjit_compile_pc_and_sp.erb sets it.
-        fprintf(f, <%= to_cstr.call(line) %>);
-%     else
-%       # If local_stack_p is TRUE and insn.handles_sp? is false, stack values are only available in local variables
-%       # for stack. So we need to replace those macros if local_stack_p is TRUE here.
-%       case line
-%       when /\bGET_SP\(\)/
-%         # reg_cfp->sp
-        fprintf(f, <%= to_cstr.call(line.sub(/\bGET_SP\(\)/, '%s')) %>, (status->local_stack_p ? "(stack + stack_size)" : "GET_SP()"));
-%       when /\bSTACK_ADDR_FROM_TOP\((?<num>[^)]+)\)/
-%         # #define STACK_ADDR_FROM_TOP(n) (GET_SP()-(n))
-%         num = Regexp.last_match[:num]
-        fprintf(f, <%= to_cstr.call(line.sub(/\bSTACK_ADDR_FROM_TOP\(([^)]+)\)/, '%s')) %>,
-                (status->local_stack_p ? "(stack + (stack_size - (<%= num %>)))" : "STACK_ADDR_FROM_TOP(<%= num %>)"));
-%       when /\bTOPN\((?<num>[^)]+)\)/
-%         # #define TOPN(n) (*(GET_SP()-(n)-1))
-%         num = Regexp.last_match[:num]
-        fprintf(f, <%= to_cstr.call(line.sub(/\bTOPN\(([^)]+)\)/, '%s')) %>,
-              (status->local_stack_p ? "*(stack + (stack_size - (<%= num %>) - 1))" : "TOPN(<%= num %>)"));
-%       else
-        fprintf(f, <%= to_cstr.call(line) %>);
-%       end
-%     end
-%   end
-% end
diff --git a/tool/ruby_vm/views/_mjit_compile_invokebuiltin.erb b/tool/ruby_vm/views/_mjit_compile_invokebuiltin.erb
deleted file mode 100644
index a3796ffc5e..0000000000
--- a/tool/ruby_vm/views/_mjit_compile_invokebuiltin.erb
+++ /dev/null
@@ -1,29 +0,0 @@
-% # -*- C -*-
-% # Copyright (c) 2020 Urabe, Shyouhei.  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.
-%
-% insn.opes.each_with_index do |ope, i|
-        <%= ope.fetch(:decl) %> = (<%= ope.fetch(:type) %>)operands[<%= i %>];
-% end
-        rb_snum_t sp_inc = <%= insn.call_attribute('sp_inc') %>;
-        unsigned sp = b->stack_size + (unsigned)sp_inc;
-        VM_ASSERT(b->stack_size > -sp_inc);
-        VM_ASSERT(sp_inc < UINT_MAX - b->stack_size);
-
-        if (bf->compiler) {
-            fprintf(f, "{\n");
-            fprintf(f, "    VALUE val;\n");
-            bf->compiler(f, <%=
-                insn.name == 'invokebuiltin' ? '-1' : '(rb_num_t)operands[1]'
-            %>, b->stack_size, body->builtin_inline_p);
-            fprintf(f, "    stack[%u] = val;\n", sp - 1);
-            fprintf(f, "}\n");
-% if insn.name != 'opt_invokebuiltin_delegate_leave'
-            b->stack_size = sp;
-            break;
-% end
-        }
diff --git a/tool/ruby_vm/views/_mjit_compile_ivar.erb b/tool/ruby_vm/views/_mjit_compile_ivar.erb
deleted file mode 100644
index 1425b3b055..0000000000
--- a/tool/ruby_vm/views/_mjit_compile_ivar.erb
+++ /dev/null
@@ -1,110 +0,0 @@
-% # -*- C -*-
-% # 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 get_instancevariable instruction.
-#if OPT_IC_FOR_IVAR
-{
-% # 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
-% # compiler: Use copied IVC to avoid race condition
-    IVC ic_copy = &(status->is_entries + ((union iseq_inline_storage_entry *)ic - body->is_entries))->iv_cache;
-%
-    if (!status->compile_info->disable_ivar_cache && ic_copy->entry) { // Only ic_copy is enabled.
-% # JIT: optimize away motion of sp and pc. This path does not call rb_warning() and so it's always leaf and not `handles_sp`.
-% # <%= render 'mjit_compile_pc_and_sp', locals: { insn: insn } -%>
-%
-% # JIT: prepare vm_getivar/vm_setivar arguments and variables
-        fprintf(f, "{\n");
-        fprintf(f, "    VALUE obj = GET_SELF();\n");
-        fprintf(f, "    const uint32_t index = %u;\n", (ic_copy->entry->index));
-        if (status->merge_ivar_guards_p) {
-% # JIT: Access ivar without checking these VM_ASSERTed prerequisites as we checked them in the beginning of `mjit_compile_body`
-            fprintf(f, "    VM_ASSERT(RB_TYPE_P(obj, T_OBJECT));\n");
-            fprintf(f, "    VM_ASSERT((rb_serial_t)%"PRI_SERIALT_PREFIX"u == RCLASS_SERIAL(RBASIC(obj)->klass));\n", ic_copy->entry->class_serial);
-            fprintf(f, "    VM_ASSERT(index < ROBJECT_NUMIV(obj));\n");
-% if insn.name == 'setinstancevariable'
-#if USE_RVARGC
-            fprintf(f, "    if (LIKELY(!RB_OBJ_FROZEN_RAW(obj) && index < ROBJECT_NUMIV(obj))) {\n");
-            fprintf(f, "        RB_OBJ_WRITE(obj, &ROBJECT_IVPTR(obj)[index], stack[%d]);\n", b->stack_size - 1);
-#else
-            fprintf(f, "    if (LIKELY(!RB_OBJ_FROZEN_RAW(obj) && %s)) {\n", status->max_ivar_index >= ROBJECT_EMBED_LEN_MAX ? "true" : "RB_FL_ANY_RAW(obj, ROBJECT_EMBED)");
-            fprintf(f, "        RB_OBJ_WRITE(obj, &ROBJECT(obj)->as.%s, stack[%d]);\n",
-                    status->max_ivar_index >= ROBJECT_EMBED_LEN_MAX ? "heap.ivptr[index]" : "ary[index]", b->stack_size - 1);
-#endif
-            fprintf(f, "    }\n");
-% else
-            fprintf(f, "    VALUE val;\n");
-#if USE_RVARGC
-            fprintf(f, "    if (LIKELY(index < ROBJECT_NUMIV(obj) && (val = ROBJECT_IVPTR(obj)[index]) != Qundef)) {\n");
-#else
-            fprintf(f, "    if (LIKELY(%s && (val = ROBJECT(obj)->as.%s) != Qundef)) {\n",
-                    status->max_ivar_index >= ROBJECT_EMBED_LEN_MAX ? "true" : "RB_FL_ANY_RAW(obj, ROBJECT_EMBED)",
-                    status->max_ivar_index >= ROBJECT_EMBED_LEN_MAX ? "heap.ivptr[index]" : "ary[index]");
-#endif
-            fprintf(f, "        stack[%d] = val;\n", b->stack_size);
-            fprintf(f, "    }\n");
-%end
-        }
-        else {
-            fprintf(f, "    const rb_serial_t ic_serial = (rb_serial_t)%"PRI_SERIALT_PREFIX"u;\n", ic_copy->entry->class_serial);
-% # JIT: cache hit path of vm_getivar/vm_setivar, or cancel JIT (recompile it with exivar)
-% if insn.name == 'setinstancevariable'
-            fprintf(f, "    if (LIKELY(RB_TYPE_P(obj, T_OBJECT) && ic_serial == RCLASS_SERIAL(RBASIC(obj)->klass) && index < ROBJECT_NUMIV(obj) && !RB_OBJ_FROZEN_RAW(obj))) {\n");
-            fprintf(f, "        VALUE *ptr = ROBJECT_IVPTR(obj);\n");
-            fprintf(f, "        RB_OBJ_WRITE(obj, &ptr[index], stack[%d]);\n", b->stack_size - 1);
-            fprintf(f, "    }\n");
-% else
-            fprintf(f, "    VALUE val;\n");
-            fprintf(f, "    if (LIKELY(RB_TYPE_P(obj, T_OBJECT) && ic_serial == RCLASS_SERIAL(RBASIC(obj)->klass) && index < ROBJECT_NUMIV(obj) && (val = ROBJECT_IVPTR(obj)[index]) != Qundef)) {\n");
-            fprintf(f, "        stack[%d] = val;\n", b->stack_size);
-            fprintf(f, "    }\n");
-% end
-        }
-        fprintf(f, "    else {\n");
-        fprintf(f, "        reg_cfp->pc = original_body_iseq + %d;\n", pos);
-        fprintf(f, "        reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);
-        fprintf(f, "        goto ivar_cancel;\n");
-        fprintf(f, "    }\n");
-
-% # compiler: Move JIT compiler's internal stack pointer
-        b->stack_size += <%= insn.call_attribute('sp_inc') %>;
-        fprintf(f, "}\n");
-        break;
-    }
-% if insn.name == 'getinstancevariable'
-    else if (!status->compile_info->disable_exivar_cache && ic_copy->entry) {
-% # JIT: optimize away motion of sp and pc. This path does not call rb_warning() and so it's always leaf and not `handles_sp`.
-% # <%= render 'mjit_compile_pc_and_sp', locals: { insn: insn } -%>
-%
-% # JIT: prepare vm_getivar's arguments and variables
-        fprintf(f, "{\n");
-        fprintf(f, "    VALUE obj = GET_SELF();\n");
-        fprintf(f, "    const rb_serial_t ic_serial = (rb_serial_t)%"PRI_SERIALT_PREFIX"u;\n", ic_copy->entry->class_serial);
-        fprintf(f, "    const uint32_t index = %u;\n", ic_copy->entry->index);
-% # JIT: cache hit path of vm_getivar, or cancel JIT (recompile it without any ivar optimization)
-        fprintf(f, "    struct gen_ivtbl *ivtbl;\n");
-        fprintf(f, "    VALUE val;\n");
-        fprintf(f, "    if (LIKELY(FL_TEST_RAW(obj, FL_EXIVAR) && ic_serial == RCLASS_SERIAL(RBASIC(obj)->klass) && rb_ivar_generic_ivtbl_lookup(obj, &ivtbl) && index < ivtbl->numiv && (val = ivtbl->ivptr[index]) != Qundef)) {\n");
-        fprintf(f, "        stack[%d] = val;\n", b->stack_size);
-        fprintf(f, "    }\n");
-        fprintf(f, "    else {\n");
-        fprintf(f, "        reg_cfp->pc = original_body_iseq + %d;\n", pos);
-        fprintf(f, "        reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);
-        fprintf(f, "        goto exivar_cancel;\n");
-        fprintf(f, "    }\n");
-
-% # compiler: Move JIT compiler's internal stack pointer
-        b->stack_size += <%= insn.call_attribute('sp_inc') %>;
-        fprintf(f, "}\n");
-        break;
-    }
-% end
-}
-#endif // OPT_IC_FOR_IVAR
diff --git a/tool/ruby_vm/views/_mjit_compile_pc_and_sp.erb b/tool/ruby_vm/views/_mjit_compile_pc_and_sp.erb
deleted file mode 100644
index 390b3ce525..0000000000
--- a/tool/ruby_vm/views/_mjit_compile_pc_and_sp.erb
+++ /dev/null
@@ -1,38 +0,0 @@
-% # 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.
-%
-% # JIT: When an insn is leaf, we don't need to Move pc for a catch table on catch_except_p, #caller_locations,
-% #      and rb_profile_frames. For check_ints, we lazily move PC when we have interruptions.
-        MAYBE_UNUSED(bool pc_moved_p) = false;
-        if (<%= !(insn.always_leaf? || insn.leaf_without_check_ints?) %>) {
-            fprintf(f, "    reg_cfp->pc = original_body_iseq + %d;\n", next_pos); /* ADD_PC(INSN_ATTR(width)); */
-            pc_moved_p = true;
-        }
-%
-% # JIT: move sp to use or preserve stack variables
-        if (status->local_stack_p) {
-% # sp motion is optimized away for `handles_sp? #=> false` case.
-% # Thus sp should be set properly before `goto cancel`.
-% if insn.handles_sp?
-%           # JIT-only behavior (pushing JIT's local variables to VM's stack):
-            {
-                rb_snum_t i, push_size;
-                push_size = -<%= insn.call_attribute('sp_inc') %> + <%= insn.rets.size %> - <%= insn.pops.size %>;
-                fprintf(f, "    reg_cfp->sp = vm_base_ptr(reg_cfp) + %ld;\n", push_size); /* POPN(INSN_ATTR(popn)); */
-                for (i = 0; i < push_size; i++) {
-                    fprintf(f, "    *(reg_cfp->sp + %ld) = stack[%ld];\n", i - push_size, (rb_snum_t)b->stack_size - push_size + i);
-                }
-            }
-% end
-        }
-        else {
-% if insn.handles_sp?
-            fprintf(f, "    reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size - <%= insn.pops.size %>); /* POPN(INSN_ATTR(popn)); */
-% else
-            fprintf(f, "    reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);
-% end
-        }
diff --git a/tool/ruby_vm/views/_mjit_compile_send.erb b/tool/ruby_vm/views/_mjit_compile_send.erb
deleted file mode 100644
index 316974a7e6..0000000000
--- a/tool/ruby_vm/views/_mjit_compile_send.erb
+++ /dev/null
@@ -1,119 +0,0 @@
-% # -*- C -*-
-% # 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
-% # compiler: Use captured cc to avoid race condition
-    size_t cd_index = call_data_index(cd, body);
-    const struct rb_callcache **cc_entries = captured_cc_entries(status);
-    const struct rb_callcache *captured_cc = cc_entries[cd_index];
-%
-% # compiler: Inline send insn where some supported fastpath is used.
-    const rb_iseq_t *iseq = NULL;
-    const CALL_INFO ci = cd->ci;
-    int kw_splat = IS_ARGS_KW_SPLAT(ci) > 0;
-    extern bool rb_splat_or_kwargs_p(const struct rb_callinfo *restrict ci);
-    if (!status->compile_info->disable_send_cache && has_valid_method_type(captured_cc) && (
-%       # `CC_SET_FASTPATH(cd->cc, vm_call_cfunc_with_frame, ...)` in `vm_call_cfunc`
-        (vm_cc_cme(captured_cc)->def->type == VM_METHOD_TYPE_CFUNC
-         && !rb_splat_or_kwargs_p(ci) && !kw_splat)
-%       # `CC_SET_FASTPATH(cc, vm_call_iseq_setup_func(...), vm_call_iseq_optimizable_p(...))` in `vm_callee_setup_arg`,
-%       # and support only non-VM_CALL_TAILCALL path inside it
-        || (vm_cc_cme(captured_cc)->def->type == VM_METHOD_TYPE_ISEQ
-            && fastpath_applied_iseq_p(ci, captured_cc, iseq = def_iseq_ptr(vm_cc_cme(captured_cc)->def))
-            && !(vm_ci_flag(ci) & VM_CALL_TAILCALL))
-    )) {
-        const bool cfunc_debug = false; // Set true when you want to see inlined cfunc
-        if (cfunc_debug && vm_cc_cme(captured_cc)->def->type == VM_METHOD_TYPE_CFUNC)
-            fprintf(stderr, "  * %s\n", rb_id2name(vm_ci_mid(ci)));
-
-        int sp_inc = (int)sp_inc_of_sendish(ci);
-        fprintf(f, "{\n");
-
-% # JIT: Invalidate call cache if it requires vm_search_method. This allows to inline some of following things.
-        bool opt_class_of = !maybe_special_const_class_p(captured_cc->klass); // If true, use RBASIC_CLASS instead of CLASS_OF to reduce code size
-        fprintf(f, "    const struct rb_callcache *cc = (const struct rb_callcache *)0x%"PRIxVALUE";\n", (VALUE)captured_cc);
-        fprintf(f, "    const rb_callable_method_entry_t *cc_cme = (const rb_callable_method_entry_t *)0x%"PRIxVALUE";\n", (VALUE)vm_cc_cme(captured_cc));
-        fprintf(f, "    const VALUE recv = stack[%d];\n", b->stack_size + sp_inc - 1);
-        fprintf(f, "    if (UNLIKELY(%s || !vm_cc_valid_p(cc, cc_cme, %s(recv)))) {\n", opt_class_of ? "RB_SPECIAL_CONST_P(recv)" : "false", opt_class_of ? "RBASIC_CLASS" : "CLASS_OF");
-        fprintf(f, "        reg_cfp->pc = original_body_iseq + %d;\n", pos);
-        fprintf(f, "        reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);
-        fprintf(f, "        goto send_cancel;\n");
-        fprintf(f, "    }\n");
-
-% # JIT: move sp and pc if necessary
-<%= render 'mjit_compile_pc_and_sp', locals: { insn: insn } -%>
-
-% # JIT: If ISeq is inlinable, call the inlined method without pushing a frame.
-        if (iseq && status->inlined_iseqs != NULL && ISEQ_BODY(iseq) == status->inlined_iseqs[pos]) {
-            fprintf(f, "    {\n");
-            fprintf(f, "        VALUE orig_self = reg_cfp->self;\n");
-            fprintf(f, "        reg_cfp->self = stack[%d];\n", b->stack_size + sp_inc - 1);
-            fprintf(f, "        stack[%d] = _mjit%d_inlined_%d(ec, reg_cfp, orig_self, original_iseq);\n", b->stack_size + sp_inc - 1, status->compiled_id, pos);
-            fprintf(f, "        reg_cfp->self = orig_self;\n");
-            fprintf(f, "    }\n");
-        }
-        else {
-% # JIT: Forked `vm_sendish` (except method_explorer = vm_search_method_wrap) to inline various things
-            fprintf(f, "    {\n");
-            fprintf(f, "        VALUE val;\n");
-            fprintf(f, "        struct rb_calling_info calling;\n");
-% if insn.name == 'send'
-            fprintf(f, "        calling.block_handler = vm_caller_setup_arg_block(ec, reg_cfp, (const struct rb_callinfo *)0x%"PRIxVALUE", (rb_iseq_t *)0x%"PRIxVALUE", FALSE);\n", (VALUE)ci, (VALUE)blockiseq);
-% else
-            fprintf(f, "        calling.block_handler = VM_BLOCK_HANDLER_NONE;\n");
-% end
-            fprintf(f, "        calling.kw_splat = %d;\n", kw_splat);
-            fprintf(f, "        calling.recv = stack[%d];\n", b->stack_size + sp_inc - 1);
-            fprintf(f, "        calling.argc = %d;\n", vm_ci_argc(ci));
-
-            if (vm_cc_cme(captured_cc)->def->type == VM_METHOD_TYPE_CFUNC) {
-%               # TODO: optimize this more
-                fprintf(f, "        calling.ci = (CALL_INFO)0x%"PRIxVALUE";\n", (VALUE)ci); // creating local cd here because operand's cd->cc may not be the same as inlined cc.
-                fprintf(f, "        calling.cc = cc;");
-                fprintf(f, "        val = vm_call_cfunc_with_frame(ec, reg_cfp, &calling);\n");
-            }
-            else { // VM_METHOD_TYPE_ISEQ
-%               # fastpath_applied_iseq_p checks rb_simple_iseq_p, which ensures has_opt == FALSE
-                fprintf(f, "        vm_call_iseq_setup_normal(ec, reg_cfp, &calling, cc_cme, 0, %d, %d);\n", ISEQ_BODY(iseq)->param.size, ISEQ_BODY(iseq)->local_table_size);
-                if (ISEQ_BODY(iseq)->catch_except_p) {
-                    fprintf(f, "        VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);\n");
-                    fprintf(f, "        val = vm_exec(ec, true);\n");
-                }
-                else {
-                    fprintf(f, "        if ((val = jit_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, "            val = vm_exec(ec, false);\n");
-                    fprintf(f, "        }\n");
-                }
-            }
-            fprintf(f, "        stack[%d] = val;\n", b->stack_size + sp_inc - 1);
-            fprintf(f, "    }\n");
-
-% # JIT: We should evaluate ISeq modified for TracePoint if it's enabled. Note: This is slow.
-            fprintf(f, "    if (UNLIKELY(!mjit_call_p)) {\n");
-            fprintf(f, "        reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size + (int)<%= insn.call_attribute('sp_inc') %>);
-            if (!pc_moved_p) {
-                fprintf(f, "        reg_cfp->pc = original_body_iseq + %d;\n", next_pos);
-            }
-            fprintf(f, "        RB_DEBUG_COUNTER_INC(mjit_cancel_invalidate_all);\n");
-            fprintf(f, "        goto cancel;\n");
-            fprintf(f, "    }\n");
-        }
-
-% # compiler: Move JIT compiler's internal stack pointer
-        b->stack_size += <%= insn.call_attribute('sp_inc') %>;
-
-        fprintf(f, "}\n");
-        break;
-    }
-}
diff --git a/tool/ruby_vm/views/mjit_compile.inc.erb b/tool/ruby_vm/views/mjit_compile.inc.erb
deleted file mode 100644
index 00808b21ff..0000000000
--- a/tool/ruby_vm/views/mjit_compile.inc.erb
+++ /dev/null
@@ -1,110 +0,0 @@
-/* -*- C -*- */
-
-% # 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_compiler.c',
-    edit: __FILE__,
-} -%>
-%
-% unsupported_insns = [
-%   'defineclass', # low priority
-% ]
-%
-% opt_send_without_block = RubyVM::Instructions.find { |i| i.name == 'opt_send_without_block' }
-% if opt_send_without_block.nil?
-%   raise 'opt_send_without_block not found'
-% end
-%
-% send_compatible_opt_insns = RubyVM::BareInstructions.to_a.select do |insn|
-%   insn.name.start_with?('opt_') && opt_send_without_block.opes == insn.opes &&
-%     insn.expr.expr.lines.any? { |l| l.match(/\A\s+CALL_SIMPLE_METHOD\(\);\s+\z/) }
-% end.map(&:name)
-%
-% # 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`, or `(stack + stack_size)` if local_stack_p
-% #   GET_SELF(): refers to `cfp_self`
-% #   GET_LEP(): refers to `VM_EP_LEP(reg_cfp->ep)`
-% #   EXEC_EC_CFP(): refers to `val = vm_exec(ec, true)` with frame setup
-% #   CALL_METHOD(): using `GET_CFP()` and `EXEC_EC_CFP()`
-% #   TOPN(): refers to `reg_cfp->sp`, or `*(stack + (stack_size - num - 1))` if local_stack_p
-% #   STACK_ADDR_FROM_TOP(): refers to `reg_cfp->sp`, or `stack + (stack_size - num)` if local_stack_p
-% #   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 %>): {
-%   # Instruction-specific behavior in JIT
-%   case insn.name
-%   when 'opt_send_without_block', 'send'
-<%=   render 'mjit_compile_send', locals: { insn: insn } -%>
-%   when *send_compatible_opt_insns
-%     # To avoid cancel, just emit `opt_send_without_block` instead of `opt_*` insn if call cache is populated.
-%     cd_index = insn.opes.index { |o| o.fetch(:type) == 'CALL_DATA' }
-    if (has_cache_for_send(captured_cc_entries(status)[call_data_index((CALL_DATA)operands[<%= cd_index %>], body)], BIN(<%= insn.name %>))) {
-<%=   render 'mjit_compile_send', locals: { insn: opt_send_without_block } -%>
-<%=   render 'mjit_compile_insn', locals: { insn: opt_send_without_block } -%>
-        break;
-    }
-%   when 'getinstancevariable', 'setinstancevariable'
-<%=   render 'mjit_compile_ivar', locals: { insn: insn } -%>
-%   when 'invokebuiltin', 'opt_invokebuiltin_delegate'
-<%=   render 'mjit_compile_invokebuiltin', locals: { insn: insn } -%>
-%   when 'opt_getconstant_path'
-<%=   render 'mjit_compile_getconstant_path', locals: { insn: insn } -%>
-%   when 'leave', 'opt_invokebuiltin_delegate_leave'
-%     # opt_invokebuiltin_delegate_leave also implements leave insn. We need to handle it here for inlining.
-%     if insn.name == 'opt_invokebuiltin_delegate_leave'
-<%=     render 'mjit_compile_invokebuiltin', locals: { insn: insn } -%>
-%     else
-    if (b->stack_size != 1) {
-        if (mjit_opts.warnings || mjit_opts.verbose)
-            fprintf(stderr, "MJIT warning: Unexpected JIT stack_size on leave: %d\n", b->stack_size);
-        status->success = false;
-    }
-%     end
-%   # Skip vm_pop_frame for inlined call
-    if (status->inlined_iseqs != NULL) { // the current ISeq is NOT being inlined
-%       # Cancel on interrupts to make leave insn leaf
-        fprintf(f, "    if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(ec))) {\n");
-        fprintf(f, "        reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);
-        fprintf(f, "        reg_cfp->pc = original_body_iseq + %d;\n", pos);
-        fprintf(f, "        rb_threadptr_execute_interrupts(rb_ec_thread_ptr(ec), 0);\n");
-        fprintf(f, "    }\n");
-        fprintf(f, "    ec->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(reg_cfp);\n"); // vm_pop_frame
-    }
-    fprintf(f, "    return stack[0];\n");
-    b->stack_size += <%= insn.call_attribute('sp_inc') %>;
-    b->finish_p = TRUE;
-    break;
-%   end
-%
-%   # Main insn implementation generated by insns.def
-<%= render 'mjit_compile_insn', locals: { insn: insn } -%>
-    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)
-        fprintf(stderr, "MJIT warning: Skipped to compile unsupported instruction: %s\n", insn_name(insn));
-    status->success = false;
-    break;
-}
diff --git a/tool/ruby_vm/views/mjit_compile_attr.inc.erb b/tool/ruby_vm/views/mjit_compile_attr.inc.erb
new file mode 100644
index 0000000000..7b925420dd
--- /dev/null
+++ b/tool/ruby_vm/views/mjit_compile_attr.inc.erb
@@ -0,0 +1,17 @@
+static rb_snum_t
+mjit_call_attribute_sp_inc(const int insn, const VALUE *operands)
+{
+    switch (insn) {
+% (RubyVM::BareInstructions.to_a + RubyVM::OperandsUnifications.to_a).each do |insn|
+      case BIN(<%= insn.name %>): {
+% # 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
+        return <%= insn.call_attribute('sp_inc') %>;
+      }
+% end
+      default:
+        rb_bug("unexpected insn in mjit_call_attribute_sp_inc");
+    }
+}
diff --git a/tool/ruby_vm/views/mjit_instruction.rb.erb b/tool/ruby_vm/views/mjit_instruction.rb.erb
new file mode 100644
index 0000000000..1f49669fa5
--- /dev/null
+++ b/tool/ruby_vm/views/mjit_instruction.rb.erb
@@ -0,0 +1,40 @@
+module RubyVM::MJIT
+  Instruction = Struct.new(
+    :name,
+    :bin,
+    :len,
+    :expr,
+    :declarations,
+    :preamble,
+    :opes,
+    :pops,
+    :rets,
+    :always_leaf?,
+    :leaf_without_check_ints?,
+    :handles_sp?,
+  )
+
+  INSNS = {
+% RubyVM::Instructions.each_with_index do |insn, i|
+%   next if insn.name.start_with?('trace_')
+    <%= i %> => Instruction.new(
+      name: :<%= insn.name %>,
+      bin: <%= i %>, # BIN(<%= insn.name %>)
+      len: <%= insn.width %>, # insn_len
+      expr: <<-EXPR,
+<%= insn.expr.expr.dump.sub(/\A"/, '').sub(/"\z/, '').gsub(/\\n/, "\n").gsub(/\\t/, ' ' * 8) %>
+      EXPR
+      declarations: <%= insn.declarations.inspect %>,
+      preamble: <%= insn.preamble.map(&:expr).inspect %>,
+      opes: <%= insn.opes.inspect %>,
+      pops: <%= insn.pops.inspect %>,
+      rets: <%= insn.rets.inspect %>,
+      always_leaf?: <%= insn.always_leaf? %>,
+      leaf_without_check_ints?: <%= insn.leaf_without_check_ints? %>,
+      handles_sp?: <%= insn.handles_sp? %>,
+    ),
+% end
+  }
+
+  private_constant *constants
+end if RubyVM::MJIT.enabled?