mjit_compile.c: merge initial JIT compiler

which has been developed by Takashi Kokubun <takashikkbn@gmail> as
YARV-MJIT. Many of its bugs are fixed by wanabe <s.wanabe@gmail.com>.

This JIT compiler is designed to be a safe migration path to introduce
JIT compiler to MRI. So this commit does not include any bytecode
changes or dynamic instruction modifications, which are done in original
MJIT.

This commit even strips off some aggressive optimizations from
YARV-MJIT, and thus it's slower than YARV-MJIT too. But it's still
fairly faster than Ruby 2.5 in some benchmarks (attached below).

Note that this JIT compiler passes `make test`, `make test-all`, `make
test-spec` without JIT, and even with JIT. Not only it's perfectly safe
with JIT disabled because it does not replace VM instructions unlike
MJIT, but also with JIT enabled it stably runs Ruby applications
including Rails applications.

I'm expecting this version as just "initial" JIT compiler. I have many
optimization ideas which are skipped for initial merging, and you may
easily replace this JIT compiler with a faster one by just replacing
mjit_compile.c. `mjit_compile` interface is designed for the purpose.

common.mk: update dependencies for mjit_compile.c.

internal.h: declare `rb_vm_insn_addr2insn` for MJIT.

vm.c: exclude some definitions if `-DMJIT_HEADER` is provided to
compiler. This avoids to include some functions which take a long time
to compile, e.g. vm_exec_core. Some of the purpose is achieved in
transform_mjit_header.rb (see `IGNORED_FUNCTIONS`) but others are
manually resolved for now. Load mjit_helper.h for MJIT header.
mjit_helper.h: New. This is a file used only by JIT-ed code. I'll
refactor `mjit_call_cfunc` later.
vm_eval.c: add some #ifdef switches to skip compiling some functions
like Init_vm_eval.

win32/mkexports.rb: export thread/ec functions, which are used by MJIT.

include/ruby/defines.h: add MJIT_FUNC_EXPORTED macro alis to clarify
that a function is exported only for MJIT.

array.c: export a function used by MJIT.
bignum.c: ditto.
class.c: ditto.
compile.c: ditto.
error.c: ditto.
gc.c: ditto.
hash.c: ditto.
iseq.c: ditto.
numeric.c: ditto.
object.c: ditto.
proc.c: ditto.
re.c: ditto.
st.c: ditto.
string.c: ditto.
thread.c: ditto.
variable.c: ditto.
vm_backtrace.c: ditto.
vm_insnhelper.c: ditto.
vm_method.c: ditto.

I would like to improve maintainability of function exports, but I
believe this way is acceptable as initial merging if we clarify the
new exports are for MJIT (so that we can use them as TODO list to fix)
and add unit tests to detect unresolved symbols.
I'll add unit tests of JIT compilations in succeeding commits.

Author: Takashi Kokubun <takashikkbn@gmail.com>
Contributor: wanabe <s.wanabe@gmail.com>

Part of [Feature #14235]

---

* Known issues
  * Code generated by gcc is faster than clang. The benchmark may be worse
    in macOS. Following benchmark result is provided by gcc w/ Linux.
  * Performance is decreased when Google Chrome is running
  * JIT can work on MinGW, but it doesn't improve performance at least
    in short running benchmark.
  * Currently it doesn't perform well with Rails. We'll try to fix this
    before release.

---

* Benchmark reslts

Benchmarked with:
Intel 4.0GHz i7-4790K with 16GB memory under x86-64 Ubuntu 8 Cores

- 2.0.0-p0: Ruby 2.0.0-p0
- r62186: Ruby trunk (early 2.6.0), before MJIT changes
- JIT off: On this commit, but without `--jit` option
- JIT on: On this commit, and with `--jit` option

** Optcarrot fps

Benchmark: https://github.com/mame/optcarrot

|         |2.0.0-p0 |r62186   |JIT off  |JIT on   |
|:--------|:--------|:--------|:--------|:--------|
|fps      |37.32    |51.46    |51.31    |58.88    |
|vs 2.0.0 |1.00x    |1.38x    |1.37x    |1.58x    |

** MJIT benchmarks

Benchmark: https://github.com/benchmark-driver/mjit-benchmarks
(Original: https://github.com/vnmakarov/ruby/tree/rtl_mjit_branch/MJIT-benchmarks)

|           |2.0.0-p0 |r62186   |JIT off  |JIT on   |
|:----------|:--------|:--------|:--------|:--------|
|aread      |1.00     |1.09     |1.07     |2.19     |
|aref       |1.00     |1.13     |1.11     |2.22     |
|aset       |1.00     |1.50     |1.45     |2.64     |
|awrite     |1.00     |1.17     |1.13     |2.20     |
|call       |1.00     |1.29     |1.26     |2.02     |
|const2     |1.00     |1.10     |1.10     |2.19     |
|const      |1.00     |1.11     |1.10     |2.19     |
|fannk      |1.00     |1.04     |1.02     |1.00     |
|fib        |1.00     |1.32     |1.31     |1.84     |
|ivread     |1.00     |1.13     |1.12     |2.43     |
|ivwrite    |1.00     |1.23     |1.21     |2.40     |
|mandelbrot |1.00     |1.13     |1.16     |1.28     |
|meteor     |1.00     |2.97     |2.92     |3.17     |
|nbody      |1.00     |1.17     |1.15     |1.49     |
|nest-ntimes|1.00     |1.22     |1.20     |1.39     |
|nest-while |1.00     |1.10     |1.10     |1.37     |
|norm       |1.00     |1.18     |1.16     |1.24     |
|nsvb       |1.00     |1.16     |1.16     |1.17     |
|red-black  |1.00     |1.02     |0.99     |1.12     |
|sieve      |1.00     |1.30     |1.28     |1.62     |
|trees      |1.00     |1.14     |1.13     |1.19     |
|while      |1.00     |1.12     |1.11     |2.41     |

** Discourse's script/bench.rb

Benchmark: https://github.com/discourse/discourse/blob/v1.8.7/script/bench.rb

NOTE: Rails performance was somehow a little degraded with JIT for now.
We should fix this.
(At least I know opt_aref is performing badly in JIT and I have an idea
 to fix it. Please wait for the fix.)

*** JIT off
Your Results: (note for timings- percentile is first, duration is second in millisecs)

categories_admin:
  50: 17
  75: 18
  90: 22
  99: 29
home_admin:
  50: 21
  75: 21
  90: 27
  99: 40
topic_admin:
  50: 17
  75: 18
  90: 22
  99: 32
categories:
  50: 35
  75: 41
  90: 43
  99: 77
home:
  50: 39
  75: 46
  90: 49
  99: 95
topic:
  50: 46
  75: 52
  90: 56
  99: 101

*** JIT on
Your Results: (note for timings- percentile is first, duration is second in millisecs)

categories_admin:
  50: 19
  75: 21
  90: 25
  99: 33
home_admin:
  50: 24
  75: 26
  90: 30
  99: 35
topic_admin:
  50: 19
  75: 20
  90: 25
  99: 30
categories:
  50: 40
  75: 44
  90: 48
  99: 76
home:
  50: 42
  75: 48
  90: 51
  99: 89
topic:
  50: 49
  75: 55
  90: 58
  99: 99

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@62197 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

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