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

Yet Another Ruby JIT!

Browse source 
Renaming uJIT to YJIT. AKA s/ujit/yjit/g.
This commit is contained in:
Jose Narvaez 2021-03-06 23:46:56 +00:00 • committed by Alan Wu
parent 7f7e79d802
commit 4e2eb7695e
36 changed files with 1312 additions and 1320 deletions
Download patch file Download diff file Expand all files Collapse all files

4
.gitignore vendored
View file

@ -229,5 +229,5 @@ lcov*.info
/mjit_config.h /mjit_config.h
/include/ruby-*/*/rb_mjit_min_header-*.h /include/ruby-*/*/rb_mjit_min_header-*.h
# UJIT # YJIT
/ujit_hooks.inc /yjit_hooks.inc

1644
common.mk
View file

File diff suppressed because it is too large Load diff

2
inits.c
View file

@ -99,7 +99,7 @@ rb_call_builtin_inits(void)
BUILTIN(timev); BUILTIN(timev);
BUILTIN(nilclass); BUILTIN(nilclass);
BUILTIN(marshal); BUILTIN(marshal);
BUILTIN(ujit); BUILTIN(yjit);
Init_builtin_prelude(); Init_builtin_prelude();
} }
#undef CALL #undef CALL

12
iseq.c
View file

@ -38,7 +38,7 @@
#include "ruby/util.h" #include "ruby/util.h"
#include "vm_core.h" #include "vm_core.h"
#include "vm_callinfo.h" #include "vm_callinfo.h"
#include "ujit.h" #include "yjit.h"
#include "builtin.h" #include "builtin.h"
#include "insns.inc" #include "insns.inc"
@ -110,7 +110,7 @@ rb_iseq_free(const rb_iseq_t *iseq)
if (iseq && iseq->body) { if (iseq && iseq->body) {
struct rb_iseq_constant_body *const body = iseq->body; struct rb_iseq_constant_body *const body = iseq->body;
mjit_free_iseq(iseq); /* Notify MJIT */ mjit_free_iseq(iseq); /* Notify MJIT */
rb_ujit_iseq_free(body); rb_yjit_iseq_free(body);
ruby_xfree((void *)body->iseq_encoded); ruby_xfree((void *)body->iseq_encoded);
ruby_xfree((void *)body->insns_info.body); ruby_xfree((void *)body->insns_info.body);
if (body->insns_info.positions) ruby_xfree((void *)body->insns_info.positions); if (body->insns_info.positions) ruby_xfree((void *)body->insns_info.positions);
@ -323,7 +323,7 @@ rb_iseq_update_references(rb_iseq_t *iseq)
#if USE_MJIT #if USE_MJIT
mjit_update_references(iseq); mjit_update_references(iseq);
#endif #endif
rb_ujit_iseq_update_references(body); rb_yjit_iseq_update_references(body);
} }
} }
@ -404,7 +404,7 @@ rb_iseq_mark(const rb_iseq_t *iseq)
#if USE_MJIT #if USE_MJIT
mjit_mark_cc_entries(body); mjit_mark_cc_entries(body);
#endif #endif
rb_ujit_iseq_mark(body); rb_yjit_iseq_mark(body);
} }
if (FL_TEST_RAW((VALUE)iseq, ISEQ_NOT_LOADED_YET)) { if (FL_TEST_RAW((VALUE)iseq, ISEQ_NOT_LOADED_YET)) {
@ -3184,7 +3184,7 @@ static insn_data_t insn_data[VM_INSTRUCTION_SIZE/2];
#include "ujit_asm.h" #include "yjit_asm.h"
@ -3490,7 +3490,7 @@ trace_set_i(void *vstart, void *vend, size_t stride, void *data)
} }
void void
rb_ujit_empty_func_with_ec(rb_control_frame_t *cfp, rb_execution_context_t *ec) rb_yjit_empty_func_with_ec(rb_control_frame_t *cfp, rb_execution_context_t *ec)
{ {
// it's put in this file instead of say, compile.c to dodge long C compile time. // it's put in this file instead of say, compile.c to dodge long C compile time.
// it just needs to be in a different unit from vm.o so the compiler can't see the definition // it just needs to be in a different unit from vm.o so the compiler can't see the definition

2
iseq.h
View file

@ -315,7 +315,7 @@ VALUE rb_iseq_defined_string(enum defined_type type);
/* vm.c */ /* vm.c */
VALUE rb_iseq_local_variables(const rb_iseq_t *iseq); VALUE rb_iseq_local_variables(const rb_iseq_t *iseq);
NOINLINE(void rb_ujit_empty_func_with_ec(rb_control_frame_t *cfp, rb_execution_context_t *ec)); NOINLINE(void rb_yjit_empty_func_with_ec(rb_control_frame_t *cfp, rb_execution_context_t *ec));
RUBY_SYMBOL_EXPORT_END RUBY_SYMBOL_EXPORT_END

9
mjit.h
View file

@ -16,7 +16,8 @@
#include "debug_counter.h" #include "debug_counter.h"
#include "ruby.h" #include "ruby.h"
#include "ujit.h" #include "vm_core.h"
#include "yjit.h"
// Special address values of a function generated from the // Special address values of a function generated from the
// corresponding iseq by MJIT: // corresponding iseq by MJIT:
@ -143,15 +144,15 @@ mjit_exec(rb_execution_context_t *ec)
const rb_iseq_t *iseq; const rb_iseq_t *iseq;
struct rb_iseq_constant_body *body; struct rb_iseq_constant_body *body;
if (mjit_call_p || rb_ujit_enabled_p()) { if (mjit_call_p || rb_yjit_enabled_p()) {
iseq = ec->cfp->iseq; iseq = ec->cfp->iseq;
body = iseq->body; body = iseq->body;
body->total_calls++; body->total_calls++;
} }
#ifndef MJIT_HEADER #ifndef MJIT_HEADER
if (rb_ujit_enabled_p() && !mjit_call_p && body->total_calls == rb_ujit_call_threshold()) { if (rb_yjit_enabled_p() && !mjit_call_p && body->total_calls == rb_yjit_call_threshold()) {
rb_ujit_compile_iseq(iseq, ec); rb_yjit_compile_iseq(iseq, ec);
return Qundef; return Qundef;
} }
#endif #endif

4
ractor.c
View file

@ -16,7 +16,7 @@
#include "variable.h" #include "variable.h"
#include "gc.h" #include "gc.h"
#include "transient_heap.h" #include "transient_heap.h"
#include "ujit.h" #include "yjit.h"
VALUE rb_cRactor; VALUE rb_cRactor;
@ -1605,7 +1605,7 @@ ractor_create(rb_execution_context_t *ec, VALUE self, VALUE loc, VALUE name, VAL
r->verbose = cr->verbose; r->verbose = cr->verbose;
r->debug = cr->debug; r->debug = cr->debug;
rb_ujit_before_ractor_spawn(); rb_yjit_before_ractor_spawn();
rb_thread_create_ractor(r, args, block); rb_thread_create_ractor(r, args, block);
RB_GC_GUARD(rv); RB_GC_GUARD(rv);

28
ruby.c
View file

@ -59,7 +59,7 @@
#include "internal/process.h" #include "internal/process.h"
#include "internal/variable.h" #include "internal/variable.h"
#include "mjit.h" #include "mjit.h"
#include "ujit.h" #include "yjit.h"
#include "ruby/encoding.h" #include "ruby/encoding.h"
#include "ruby/thread.h" #include "ruby/thread.h"
#include "ruby/util.h" #include "ruby/util.h"
@ -105,7 +105,7 @@ void rb_warning_category_update(unsigned int mask, unsigned int bits);
SEP \ SEP \
X(jit) \ X(jit) \
SEP \ SEP \
X(ujit) X(yjit)
/* END OF FEATURES */ /* END OF FEATURES */
#define EACH_DEBUG_FEATURES(X, SEP) \ #define EACH_DEBUG_FEATURES(X, SEP) \
X(frozen_string_literal) \ X(frozen_string_literal) \
@ -189,7 +189,7 @@ struct ruby_cmdline_options {
#if USE_MJIT #if USE_MJIT
struct mjit_options mjit; struct mjit_options mjit;
#endif #endif
struct rb_ujit_options ujit; struct rb_yjit_options yjit;
int sflag, xflag; int sflag, xflag;
unsigned int warning: 1; unsigned int warning: 1;
@ -234,7 +234,7 @@ cmdline_options_init(ruby_cmdline_options_t *opt)
#ifdef MJIT_FORCE_ENABLE /* to use with: ./configure cppflags="-DMJIT_FORCE_ENABLE" */ #ifdef MJIT_FORCE_ENABLE /* to use with: ./configure cppflags="-DMJIT_FORCE_ENABLE" */
opt->features.set |= FEATURE_BIT(jit); opt->features.set |= FEATURE_BIT(jit);
#endif #endif
opt->features.set |= FEATURE_BIT(ujit); opt->features.set |= FEATURE_BIT(yjit);
return opt; return opt;
} }
@ -333,7 +333,7 @@ usage(const char *name, int help, int highlight, int columns)
M("rubyopt", "", "RUBYOPT environment variable (default: enabled)"), M("rubyopt", "", "RUBYOPT environment variable (default: enabled)"),
M("frozen-string-literal", "", "freeze all string literals (default: disabled)"), M("frozen-string-literal", "", "freeze all string literals (default: disabled)"),
M("jit", "", "JIT compiler (default: disabled)"), M("jit", "", "JIT compiler (default: disabled)"),
M("ujit", "", "in-process JIT compiler (default: enabled)"), M("yjit", "", "in-process JIT compiler (default: enabled)"),
}; };
static const struct message warn_categories[] = { static const struct message warn_categories[] = {
M("deprecated", "", "deprecated features"), M("deprecated", "", "deprecated features"),
@ -1031,20 +1031,20 @@ set_option_encoding_once(const char *type, VALUE *name, const char *e, long elen
opt_match(s, l, name) && (*(s) ? 1 : (rb_raise(rb_eRuntimeError, "--jit-" name " needs an argument"), 0)) opt_match(s, l, name) && (*(s) ? 1 : (rb_raise(rb_eRuntimeError, "--jit-" name " needs an argument"), 0))
static void static void
setup_ujit_options(const char *s, struct rb_ujit_options *ujit_opt) setup_yjit_options(const char *s, struct rb_yjit_options *yjit_opt)
{ {
if (*s != '-') return; if (*s != '-') return;
const size_t l = strlen(++s); const size_t l = strlen(++s);
if (opt_match_arg(s, l, "call-threshold")) { if (opt_match_arg(s, l, "call-threshold")) {
ujit_opt->call_threshold = atoi(s + 1); yjit_opt->call_threshold = atoi(s + 1);
} }
else if (opt_match_noarg(s, l, "stats")) { else if (opt_match_noarg(s, l, "stats")) {
ujit_opt->gen_stats = true; yjit_opt->gen_stats = true;
} }
else { else {
rb_raise(rb_eRuntimeError, rb_raise(rb_eRuntimeError,
"invalid ujit option `%s' (--help will show valid ujit options)", s); "invalid yjit option `%s' (--help will show valid yjit options)", s);
} }
} }
@ -1461,9 +1461,9 @@ proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt)
rb_warn("MJIT support is disabled."); rb_warn("MJIT support is disabled.");
#endif #endif
} }
else if (strncmp("ujit", s, 4) == 0) { else if (strncmp("yjit", s, 4) == 0) {
FEATURE_SET(opt->features, FEATURE_BIT(ujit)); FEATURE_SET(opt->features, FEATURE_BIT(yjit));
setup_ujit_options(s + 4, &opt->ujit); setup_yjit_options(s + 4, &opt->yjit);
} }
else if (strcmp("yydebug", s) == 0) { else if (strcmp("yydebug", s) == 0) {
if (envopt) goto noenvopt_long; if (envopt) goto noenvopt_long;
@ -1825,8 +1825,8 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
*/ */
rb_warning("-K is specified; it is for 1.8 compatibility and may cause odd behavior"); rb_warning("-K is specified; it is for 1.8 compatibility and may cause odd behavior");
if (opt->features.set & FEATURE_BIT(ujit)) if (opt->features.set & FEATURE_BIT(yjit))
rb_ujit_init(&opt->ujit); rb_yjit_init(&opt->yjit);
#if USE_MJIT #if USE_MJIT
if (opt->features.set & FEATURE_BIT(jit)) { if (opt->features.set & FEATURE_BIT(jit)) {
opt->mjit.on = TRUE; /* set mjit.on for ruby_show_version() API and check to call mjit_init() */ opt->mjit.on = TRUE; /* set mjit.on for ruby_show_version() API and check to call mjit_init() */

2
template/Makefile.in
View file

@ -590,7 +590,7 @@ update-known-errors:
$(IFCHANGE) $(srcdir)/defs/known_errors.def - $(IFCHANGE) $(srcdir)/defs/known_errors.def -
INSNS = opt_sc.inc optinsn.inc optunifs.inc insns.inc insns_info.inc \ INSNS = opt_sc.inc optinsn.inc optunifs.inc insns.inc insns_info.inc \
vmtc.inc vm.inc mjit_compile.inc ujit_hooks.inc vmtc.inc vm.inc mjit_compile.inc yjit_hooks.inc
$(INSNS): $(srcdir)/insns.def vm_opts.h \ $(INSNS): $(srcdir)/insns.def vm_opts.h \
$(srcdir)/defs/opt_operand.def $(srcdir)/defs/opt_insn_unif.def \ $(srcdir)/defs/opt_operand.def $(srcdir)/defs/opt_insn_unif.def \

2
test_asm.sh
View file

@ -3,7 +3,7 @@
clear clear
clang -std=gnu99 -Wall -Werror -Wshorten-64-to-32 ujit_asm.c ujit_asm_tests.c -o asm_test clang -std=gnu99 -Wall -Werror -Wshorten-64-to-32 yjit_asm.c yjit_asm_tests.c -o asm_test
./asm_test ./asm_test

6
tool/ruby_vm/models/micro_jit.rb
View file

@ -179,7 +179,7 @@ module RubyVM::MicroJIT
def make_result(success, with_pc) def make_result(success, with_pc)
[success ? 1 : 0, [success ? 1 : 0,
[ [
['ujit_with_ec', with_pc], ['yjit_with_ec', with_pc],
] ]
] ]
end end
@ -197,7 +197,7 @@ module RubyVM::MicroJIT
end end
def scrape def scrape
with_ec = scrape_instruction(RubyVM::Instructions.find_index { |insn| insn.name == 'ujit_call_example_with_ec' }) with_ec = scrape_instruction(RubyVM::Instructions.find_index { |insn| insn.name == 'yjit_call_example_with_ec' })
make_result(true, with_ec) make_result(true, with_ec)
rescue => e rescue => e
print_warning("scrape failed: #{e.message}") print_warning("scrape failed: #{e.message}")
@ -207,7 +207,7 @@ module RubyVM::MicroJIT
end end
def print_warning(text) def print_warning(text)
text = "ujit warning: #{text}" text = "yjit warning: #{text}"
text = "\x1b[1m#{text}\x1b[0m" if STDOUT.tty? text = "\x1b[1m#{text}\x1b[0m" if STDOUT.tty?
STDOUT.puts(text) STDOUT.puts(text)
end end

2
tool/ruby_vm/models/micro_jit/example_instructions.rb
View file

@ -64,6 +64,6 @@ class RubyVM::MicroJIT::ExampleInstructions
end end
def self.to_a def self.to_a
[new('ujit_call_example_with_ec')] [new('yjit_call_example_with_ec')]
end end
end end

8
tool/ruby_vm/views/vm.inc.erb
View file

@ -26,16 +26,16 @@
% end % end
% %
% RubyVM::MicroJIT::ExampleInstructions.to_a.each do |insn| % RubyVM::MicroJIT::ExampleInstructions.to_a.each do |insn|
INSN_ENTRY(ujit_call_example_with_ec) INSN_ENTRY(yjit_call_example_with_ec)
{ {
START_OF_ORIGINAL_INSN(ujit_call_example_with_ec); START_OF_ORIGINAL_INSN(yjit_call_example_with_ec);
#if USE_MACHINE_REGS #if USE_MACHINE_REGS
// assumes USE_MACHINE_REGS, aka reg_pc setup, // assumes USE_MACHINE_REGS, aka reg_pc setup,
// aka #define SET_PC(x) (reg_cfp->pc = reg_pc = (x)) // aka #define SET_PC(x) (reg_cfp->pc = reg_pc = (x))
rb_ujit_empty_func_with_ec(GET_CFP(), ec); rb_yjit_empty_func_with_ec(GET_CFP(), ec);
RESTORE_REGS(); RESTORE_REGS();
#endif #endif
END_INSN(ujit_call_example_with_ec); END_INSN(yjit_call_example_with_ec);
} }
% end % end
% %

2
tool/ruby_vm/views/ujit_hooks.inc.erb → tool/ruby_vm/views/yjit_hooks.inc.erb
View file

@ -13,7 +13,7 @@
} -%> } -%>
% success, byte_arrays = RubyVM::MicroJIT.scrape % success, byte_arrays = RubyVM::MicroJIT.scrape
static const uint8_t ujit_scrape_successful = <%= success %>; static const uint8_t yjit_scrape_successful = <%= success %>;
% byte_arrays.each do |(prefix, scrape_result)| % byte_arrays.each do |(prefix, scrape_result)|
// Disassembly: // Disassembly:
% scrape_result.disassembly_lines.each do |line| % scrape_result.disassembly_lines.each do |line|

8
tool/runruby.rb
View file

@ -11,8 +11,8 @@ when ENV['RUNRUBY_USE_GDB'] == 'true'
debugger = :gdb debugger = :gdb
when ENV['RUNRUBY_USE_LLDB'] == 'true' when ENV['RUNRUBY_USE_LLDB'] == 'true'
debugger = :lldb debugger = :lldb
when ENV['RUNRUBY_UJIT_STATS'] when ENV['RUNRUBY_YJIT_STATS']
use_ujit_stat = true use_yjit_stat = true
end end
while arg = ARGV[0] while arg = ARGV[0]
break ARGV.shift if arg == '--' break ARGV.shift if arg == '--'
@ -166,8 +166,8 @@ if debugger
end end
cmd = [runner || ruby] cmd = [runner || ruby]
if use_ujit_stat if use_yjit_stat
cmd << '--ujit-stats' cmd << '--yjit-stats'
end end
cmd.concat(ARGV) cmd.concat(ARGV)
cmd.unshift(*precommand) unless precommand.empty? cmd.unshift(*precommand) unless precommand.empty?

61
ujit.h
View file

@ -1,61 +0,0 @@
//
// This file contains definitions uJIT exposes to the CRuby codebase
//
#ifndef UJIT_H
#define UJIT_H 1
#include "stddef.h"
#include "stdint.h"
#include "stdbool.h"
#include "method.h"
#ifdef _WIN32
#define PLATFORM_SUPPORTED_P 0
#else
#define PLATFORM_SUPPORTED_P 1
#endif
#ifndef UJIT_CHECK_MODE
#define UJIT_CHECK_MODE 0
#endif
// >= 1: print when output code invalidation happens
// >= 2: dump list of instructions when regions compile
#ifndef UJIT_DUMP_MODE
#define UJIT_DUMP_MODE 0
#endif
#ifndef rb_iseq_t
typedef struct rb_iseq_struct rb_iseq_t;
#define rb_iseq_t rb_iseq_t
#endif
struct rb_ujit_options {
bool ujit_enabled;
// Number of method calls after which to start generating code
// Threshold==1 means compile on first execution
unsigned call_threshold;
// Capture and print out stats
bool gen_stats;
};
RUBY_SYMBOL_EXPORT_BEGIN
bool rb_ujit_enabled_p(void);
unsigned rb_ujit_call_threshold(void);
RUBY_SYMBOL_EXPORT_END
void rb_ujit_collect_vm_usage_insn(int insn);
void rb_ujit_method_lookup_change(VALUE cme_or_cc);
void rb_ujit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec);
void rb_ujit_init(struct rb_ujit_options *options);
void rb_ujit_bop_redefined(VALUE klass, const rb_method_entry_t *me, enum ruby_basic_operators bop);
void rb_ujit_constant_state_changed(void);
void rb_ujit_iseq_mark(const struct rb_iseq_constant_body *body);
void rb_ujit_iseq_update_references(const struct rb_iseq_constant_body *body);
void rb_ujit_iseq_free(const struct rb_iseq_constant_body *body);
void rb_ujit_before_ractor_spawn(void);
#endif // #ifndef UJIT_H

4
version.c
View file

@ -13,7 +13,7 @@
#include "version.h" #include "version.h"
#include "vm_core.h" #include "vm_core.h"
#include "mjit.h" #include "mjit.h"
#include "ujit.h" #include "yjit.h"
#include <stdio.h> #include <stdio.h>
#ifndef EXIT_SUCCESS #ifndef EXIT_SUCCESS
@ -125,7 +125,7 @@ ruby_show_version(void)
PRINT(description); PRINT(description);
} }
if (rb_ujit_enabled_p()) { if (rb_yjit_enabled_p()) {
fputs("YJIT is enabled\n", stdout); fputs("YJIT is enabled\n", stdout);
} }
#ifdef RUBY_LAST_COMMIT_TITLE #ifdef RUBY_LAST_COMMIT_TITLE

12
vm.c
View file

@ -37,7 +37,7 @@
#include "vm_insnhelper.h" #include "vm_insnhelper.h"
#include "ractor_core.h" #include "ractor_core.h"
#include "vm_sync.h" #include "vm_sync.h"
#include "ujit.h" #include "yjit.h"
#include "builtin.h" #include "builtin.h"
@ -346,7 +346,7 @@ static void vm_collect_usage_register(int reg, int isset);
#endif #endif
#if RUBY_DEBUG #if RUBY_DEBUG
static void vm_ujit_collect_usage_insn(int insn); static void vm_yjit_collect_usage_insn(int insn);
#endif #endif
static VALUE vm_make_env_object(const rb_execution_context_t *ec, rb_control_frame_t *cfp); static VALUE vm_make_env_object(const rb_execution_context_t *ec, rb_control_frame_t *cfp);
@ -1854,9 +1854,9 @@ rb_vm_check_redefinition_opt_method(const rb_method_entry_t *me, VALUE klass)
klass = RBASIC_CLASS(klass); klass = RBASIC_CLASS(klass);
} }
if (vm_redefinition_check_method_type(me->def)) { if (vm_redefinition_check_method_type(me->def)) {
if (st_lookup(vm_opt_method_def_table, (st_data_t)me->def, &bop)) { if (st_lookup(vm_opt_method_table, (st_data_t)me, &bop)) {
int flag = vm_redefinition_check_flag(klass); int flag = vm_redefinition_check_flag(klass);
rb_ujit_bop_redefined(klass, me, (enum ruby_basic_operators)bop); rb_yjit_bop_redefined(klass, me, (enum ruby_basic_operators)bop);
ruby_vm_redefined_flag[bop] |= flag; ruby_vm_redefined_flag[bop] |= flag;
} }
@ -4063,9 +4063,9 @@ MAYBE_UNUSED(static void (*ruby_vm_collect_usage_func_register)(int reg, int iss
#if RUBY_DEBUG #if RUBY_DEBUG
static void static void
vm_ujit_collect_usage_insn(int insn) vm_yjit_collect_usage_insn(int insn)
{ {
rb_ujit_collect_vm_usage_insn(insn); rb_yjit_collect_vm_usage_insn(insn);
} }
#endif #endif

8
vm_core.h
View file

@ -313,8 +313,8 @@ pathobj_realpath(VALUE pathobj)
struct rb_mjit_unit; struct rb_mjit_unit;
// List of YJIT block versions // List of YJIT block versions
typedef rb_darray(struct ujit_block_version *) rb_ujit_block_array_t; typedef rb_darray(struct yjit_block_version *) rb_yjit_block_array_t;
typedef rb_darray(rb_ujit_block_array_t) rb_ujit_block_array_array_t; typedef rb_darray(rb_yjit_block_array_t) rb_yjit_block_array_array_t;
struct rb_iseq_constant_body { struct rb_iseq_constant_body {
enum iseq_type { enum iseq_type {
@ -455,7 +455,7 @@ struct rb_iseq_constant_body {
struct rb_mjit_unit *jit_unit; struct rb_mjit_unit *jit_unit;
#endif #endif
rb_ujit_block_array_array_t ujit_blocks; // empty, or has a size equal to iseq_size rb_yjit_block_array_array_t yjit_blocks; // empty, or has a size equal to iseq_size
}; };
/* T_IMEMO/iseq */ /* T_IMEMO/iseq */
@ -797,7 +797,7 @@ typedef struct rb_control_frame_struct {
#if VM_DEBUG_BP_CHECK #if VM_DEBUG_BP_CHECK
VALUE *bp_check; /* cfp[7] */ VALUE *bp_check; /* cfp[7] */
#endif #endif
// Return address for uJIT code // Return address for YJIT code
void *jit_return; void *jit_return;
} rb_control_frame_t; } rb_control_frame_t;

2
vm_exec.h
View file

@ -81,7 +81,7 @@ error !
RSTRING_PTR(rb_iseq_path(reg_cfp->iseq)), \ RSTRING_PTR(rb_iseq_path(reg_cfp->iseq)), \
rb_iseq_line_no(reg_cfp->iseq, reg_pc - reg_cfp->iseq->body->iseq_encoded)); \ rb_iseq_line_no(reg_cfp->iseq, reg_pc - reg_cfp->iseq->body->iseq_encoded)); \
} \ } \
if (USE_INSNS_COUNTER && BIN(insn) != BIN(ujit_call_example_with_ec)) vm_insns_counter_count_insn(BIN(insn)); if (USE_INSNS_COUNTER && BIN(insn) != BIN(yjit_call_example_with_ec)) vm_insns_counter_count_insn(BIN(insn));
#define INSN_DISPATCH_SIG(insn) #define INSN_DISPATCH_SIG(insn)

4
vm_insnhelper.h
View file

@ -26,8 +26,8 @@ MJIT_SYMBOL_EXPORT_END
#define COLLECT_USAGE_REGISTER(reg, s) vm_collect_usage_register((reg), (s)) #define COLLECT_USAGE_REGISTER(reg, s) vm_collect_usage_register((reg), (s))
#elif RUBY_DEBUG #elif RUBY_DEBUG
/* for --ujit-stats */ /* for --yjit-stats */
#define COLLECT_USAGE_INSN(insn) vm_ujit_collect_usage_insn(insn) #define COLLECT_USAGE_INSN(insn) vm_yjit_collect_usage_insn(insn)
#define COLLECT_USAGE_OPERAND(insn, n, op) /* none */ #define COLLECT_USAGE_OPERAND(insn, n, op) /* none */
#define COLLECT_USAGE_REGISTER(reg, s) /* none */ #define COLLECT_USAGE_REGISTER(reg, s) /* none */
#else #else

8
vm_method.c
View file

@ -3,7 +3,7 @@
*/ */
#include "id_table.h" #include "id_table.h"
#include "ujit.h" #include "yjit.h"
#define METHOD_DEBUG 0 #define METHOD_DEBUG 0
@ -123,7 +123,7 @@ rb_vm_cc_invalidate(const struct rb_callcache *cc)
VM_ASSERT(cc->klass != 0); // should be enable VM_ASSERT(cc->klass != 0); // should be enable
*(VALUE *)&cc->klass = 0; *(VALUE *)&cc->klass = 0;
rb_ujit_method_lookup_change((VALUE)cc); rb_yjit_method_lookup_change((VALUE)cc);
RB_DEBUG_COUNTER_INC(cc_ent_invalidate); RB_DEBUG_COUNTER_INC(cc_ent_invalidate);
} }
@ -135,13 +135,13 @@ vm_cme_invalidate(rb_callable_method_entry_t *cme)
VM_ASSERT(callable_method_entry_p(cme)); VM_ASSERT(callable_method_entry_p(cme));
METHOD_ENTRY_INVALIDATED_SET(cme); METHOD_ENTRY_INVALIDATED_SET(cme);
RB_DEBUG_COUNTER_INC(cc_cme_invalidate); RB_DEBUG_COUNTER_INC(cc_cme_invalidate);
rb_ujit_method_lookup_change((VALUE)cme); rb_yjit_method_lookup_change((VALUE)cme);
} }
void void
rb_clear_constant_cache(void) rb_clear_constant_cache(void)
{ {
rb_ujit_constant_state_changed(); rb_yjit_constant_state_changed();
INC_GLOBAL_CONSTANT_STATE(); INC_GLOBAL_CONSTANT_STATE();
} }

2
win32/Makefile.sub
View file

@ -1347,7 +1347,7 @@ $(MJIT_PRECOMPILED_HEADER): $(MJIT_PRECOMPILED_HEADER_NAME)
$(Q) $(MAKE_LINK) $(MJIT_PRECOMPILED_HEADER_NAME:.pch=.pdb) $(arch_hdrdir)/$(MJIT_PRECOMPILED_HEADER_NAME:.pch=.pdb) $(Q) $(MAKE_LINK) $(MJIT_PRECOMPILED_HEADER_NAME:.pch=.pdb) $(arch_hdrdir)/$(MJIT_PRECOMPILED_HEADER_NAME:.pch=.pdb)
INSNS = opt_sc.inc optinsn.inc optunifs.inc insns.inc insns_info.inc \ INSNS = opt_sc.inc optinsn.inc optunifs.inc insns.inc insns_info.inc \
vmtc.inc vm.inc mjit_compile.inc ujit_hooks.inc vmtc.inc vm.inc mjit_compile.inc yjit_hooks.inc
!if [exit > insns_rules.mk] !if [exit > insns_rules.mk]
!else if [for %I in ($(INSNS)) do \ !else if [for %I in ($(INSNS)) do \

61
yjit.h Normal file
View file

@ -0,0 +1,61 @@
//
// This file contains definitions YJIT exposes to the CRuby codebase
//
#ifndef YJIT_H
#define YJIT_H 1
#include "stddef.h"
#include "stdint.h"
#include "stdbool.h"
#include "method.h"
#ifdef _WIN32
#define PLATFORM_SUPPORTED_P 0
#else
#define PLATFORM_SUPPORTED_P 1
#endif
#ifndef YJIT_CHECK_MODE
#define YJIT_CHECK_MODE 0
#endif
// >= 1: print when output code invalidation happens
// >= 2: dump list of instructions when regions compile
#ifndef YJIT_DUMP_MODE
#define YJIT_DUMP_MODE 0
#endif
#ifndef rb_iseq_t
typedef struct rb_iseq_struct rb_iseq_t;
#define rb_iseq_t rb_iseq_t
#endif
struct rb_yjit_options {
bool yjit_enabled;
// Number of method calls after which to start generating code
// Threshold==1 means compile on first execution
unsigned call_threshold;
// Capture and print out stats
bool gen_stats;
};
RUBY_SYMBOL_EXPORT_BEGIN
bool rb_yjit_enabled_p(void);
unsigned rb_yjit_call_threshold(void);
RUBY_SYMBOL_EXPORT_END
void rb_yjit_collect_vm_usage_insn(int insn);
void rb_yjit_method_lookup_change(VALUE cme_or_cc);
void rb_yjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec);
void rb_yjit_init(struct rb_yjit_options *options);
void rb_yjit_bop_redefined(VALUE klass, const rb_method_entry_t *me, enum ruby_basic_operators bop);
void rb_yjit_constant_state_changed(void);
void rb_yjit_iseq_mark(const struct rb_iseq_constant_body *body);
void rb_yjit_iseq_update_references(const struct rb_iseq_constant_body *body);
void rb_yjit_iseq_free(const struct rb_iseq_constant_body *body);
void rb_yjit_before_ractor_spawn(void);
#endif // #ifndef YJIT_H

16
ujit.rb → yjit.rb
View file

@ -1,13 +1,13 @@
module UJIT module YJIT
def self.disasm(iseq) def self.disasm(iseq)
iseq = RubyVM::InstructionSequence.of(iseq) iseq = RubyVM::InstructionSequence.of(iseq)
blocks = UJIT.blocks_for(iseq) blocks = YJIT.blocks_for(iseq)
return if blocks.empty? return if blocks.empty?
str = "" str = ""
cs = UJIT::Disasm.new cs = YJIT::Disasm.new
str << iseq.disasm str << iseq.disasm
str << "\n" str << "\n"
@ -36,16 +36,16 @@ module UJIT
str str
end if defined?(Disasm) end if defined?(Disasm)
# Return a hash for statistics generated for the --ujit-stats command line option. # Return a hash for statistics generated for the --yjit-stats command line option.
# Return nil when option is not passed or unavailable. # Return nil when option is not passed or unavailable.
def self.runtime_stats def self.runtime_stats
# defined in ujit_iface.c # defined in yjit_iface.c
Primitive.get_stat_counters Primitive.get_stat_counters
end end
# Discard statistics collected for --ujit-stats. # Discard statistics collected for --yjit-stats.
def self.reset_stats! def self.reset_stats!
# defined in ujit_iface.c # defined in yjit_iface.c
Primitive.reset_stats_bang Primitive.reset_stats_bang
end end
@ -58,7 +58,7 @@ module UJIT
return unless counters return unless counters
$stderr.puts("***uJIT: Printing runtime counters from ujit.rb***") $stderr.puts("***YJIT: Printing runtime counters from yjit.rb***")
print_counters(counters, prefix: 'oswb_', prompt: 'opt_send_without_block exit reasons: ') print_counters(counters, prefix: 'oswb_', prompt: 'opt_send_without_block exit reasons: ')
print_counters(counters, prefix: 'leave_', prompt: 'leave exit reasons: ') print_counters(counters, prefix: 'leave_', prompt: 'leave exit reasons: ')

2
ujit_asm.c → yjit_asm.c
View file

@ -11,7 +11,7 @@
#include <sys/mman.h> #include <sys/mman.h>
#endif #endif
#include "ujit_asm.h" #include "yjit_asm.h"
// Compute the number of bits needed to encode a signed value // Compute the number of bits needed to encode a signed value
uint32_t sig_imm_size(int64_t imm) uint32_t sig_imm_size(int64_t imm)

4
ujit_asm.h → yjit_asm.h
View file

@ -1,5 +1,5 @@
#ifndef UJIT_ASM_H #ifndef YJIT_ASM_H
#define UJIT_ASM_H 1 #define YJIT_ASM_H 1
#include <stdint.h> #include <stdint.h>
#include <stddef.h> #include <stddef.h>

2
ujit_asm_tests.c → yjit_asm_tests.c
View file

@ -2,7 +2,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
#include "ujit_asm.h" #include "yjit_asm.h"
// Print the bytes in a code block // Print the bytes in a code block
void print_bytes(codeblock_t* cb) void print_bytes(codeblock_t* cb)

307
ujit_codegen.c → yjit_codegen.c
View file

@ -8,12 +8,12 @@
#include "internal/compile.h" #include "internal/compile.h"
#include "internal/class.h" #include "internal/class.h"
#include "insns_info.inc" #include "insns_info.inc"
#include "ujit.h" #include "yjit.h"
#include "ujit_iface.h" #include "yjit_iface.h"
#include "ujit_core.h" #include "yjit_core.h"
#include "ujit_codegen.h" #include "yjit_codegen.h"
#include "ujit_asm.h" #include "yjit_asm.h"
#include "ujit_utils.h" #include "yjit_utils.h"
// Map from YARV opcodes to code generation functions // Map from YARV opcodes to code generation functions
static st_table *gen_fns; static st_table *gen_fns;
@ -99,9 +99,9 @@ jit_peek_at_stack(jitstate_t* jit, ctx_t* ctx)
return *(sp - 1); return *(sp - 1);
} }
// Save uJIT registers prior to a C call // Save YJIT registers prior to a C call
static void static void
ujit_save_regs(codeblock_t* cb) yjit_save_regs(codeblock_t* cb)
{ {
push(cb, REG_CFP); push(cb, REG_CFP);
push(cb, REG_EC); push(cb, REG_EC);
@ -109,9 +109,9 @@ ujit_save_regs(codeblock_t* cb)
push(cb, REG_SP); // Maintain 16-byte RSP alignment push(cb, REG_SP); // Maintain 16-byte RSP alignment
} }
// Restore uJIT registers after a C call // Restore YJIT registers after a C call
static void static void
ujit_load_regs(codeblock_t* cb) yjit_load_regs(codeblock_t* cb)
{ {
pop(cb, REG_SP); // Maintain 16-byte RSP alignment pop(cb, REG_SP); // Maintain 16-byte RSP alignment
pop(cb, REG_SP); pop(cb, REG_SP);
@ -123,7 +123,7 @@ ujit_load_regs(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(jitstate_t* jit, ctx_t* ctx, codeblock_t* cb, VALUE* exit_pc) yjit_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->sp_offset != 0) if (ctx->sp_offset != 0)
@ -142,9 +142,9 @@ ujit_gen_exit(jitstate_t* jit, ctx_t* ctx, codeblock_t* cb, VALUE* exit_pc)
// Accumulate stats about interpreter exits // Accumulate stats about interpreter exits
#if RUBY_DEBUG #if RUBY_DEBUG
if (rb_ujit_opts.gen_stats) { if (rb_yjit_opts.gen_stats) {
mov(cb, RDI, const_ptr_opnd(exit_pc)); mov(cb, RDI, const_ptr_opnd(exit_pc));
call_ptr(cb, RSI, (void *)&rb_ujit_count_side_exit_op); call_ptr(cb, RSI, (void *)&rb_yjit_count_side_exit_op);
} }
#endif #endif
@ -156,7 +156,7 @@ ujit_gen_exit(jitstate_t* jit, ctx_t* ctx, codeblock_t* cb, 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(jitstate_t* jit, ctx_t* ctx) yjit_side_exit(jitstate_t* jit, ctx_t* ctx)
{ {
uint8_t* code_ptr = cb_get_ptr(ocb, ocb->write_pos); uint8_t* code_ptr = cb_get_ptr(ocb, ocb->write_pos);
@ -177,7 +177,7 @@ ujit_side_exit(jitstate_t* jit, ctx_t* ctx)
mov(ocb, 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(jit, ctx, ocb, exit_pc); yjit_gen_exit(jit, ctx, ocb, exit_pc);
return code_ptr; return code_ptr;
} }
@ -185,22 +185,22 @@ ujit_side_exit(jitstate_t* jit, ctx_t* ctx)
#if RUBY_DEBUG #if RUBY_DEBUG
// Increment a profiling counter with counter_name // Increment a profiling counter with counter_name
#define GEN_COUNTER_INC(cb, counter_name) _gen_counter_inc(cb, &(ujit_runtime_counters . counter_name)) #define GEN_COUNTER_INC(cb, counter_name) _gen_counter_inc(cb, &(yjit_runtime_counters . counter_name))
static void static void
_gen_counter_inc(codeblock_t *cb, int64_t *counter) _gen_counter_inc(codeblock_t *cb, int64_t *counter)
{ {
if (!rb_ujit_opts.gen_stats) return; if (!rb_yjit_opts.gen_stats) return;
mov(cb, REG0, const_ptr_opnd(counter)); mov(cb, REG0, const_ptr_opnd(counter));
cb_write_lock_prefix(cb); // for ractors. cb_write_lock_prefix(cb); // for ractors.
add(cb, mem_opnd(64, REG0, 0), imm_opnd(1)); add(cb, mem_opnd(64, REG0, 0), imm_opnd(1));
} }
// Increment a counter then take an existing side exit. // Increment a counter then take an existing side exit.
#define COUNTED_EXIT(side_exit, counter_name) _counted_side_exit(side_exit, &(ujit_runtime_counters . counter_name)) #define COUNTED_EXIT(side_exit, counter_name) _counted_side_exit(side_exit, &(yjit_runtime_counters . counter_name))
static uint8_t * static uint8_t *
_counted_side_exit(uint8_t *existing_side_exit, int64_t *counter) _counted_side_exit(uint8_t *existing_side_exit, int64_t *counter)
{ {
if (!rb_ujit_opts.gen_stats) return existing_side_exit; if (!rb_yjit_opts.gen_stats) return existing_side_exit;
uint8_t *start = cb_get_ptr(ocb, ocb->write_pos); uint8_t *start = cb_get_ptr(ocb, ocb->write_pos);
_gen_counter_inc(ocb, counter); _gen_counter_inc(ocb, counter);
@ -218,7 +218,7 @@ Compile an interpreter entry block to be inserted into an iseq
Returns `NULL` if compilation fails. Returns `NULL` if compilation fails.
*/ */
uint8_t* uint8_t*
ujit_entry_prologue(void) yjit_entry_prologue(void)
{ {
RUBY_ASSERT(cb != NULL); RUBY_ASSERT(cb != NULL);
@ -244,7 +244,7 @@ ujit_entry_prologue(void)
Generate code to check for interrupts and take a side-exit Generate code to check for interrupts and take a side-exit
*/ */
static void static void
ujit_check_ints(codeblock_t* cb, uint8_t* side_exit) yjit_check_ints(codeblock_t* cb, uint8_t* side_exit)
{ {
// Check for interrupts // Check for interrupts
// see RUBY_VM_CHECK_INTS(ec) macro // see RUBY_VM_CHECK_INTS(ec) macro
@ -258,7 +258,7 @@ ujit_check_ints(codeblock_t* cb, uint8_t* side_exit)
Compile a sequence of bytecode instructions for a given basic block version Compile a sequence of bytecode instructions for a given basic block version
*/ */
void void
ujit_gen_block(ctx_t* ctx, block_t* block, rb_execution_context_t* ec) yjit_gen_block(ctx_t* ctx, block_t* block, rb_execution_context_t* ec)
{ {
RUBY_ASSERT(cb != NULL); RUBY_ASSERT(cb != NULL);
RUBY_ASSERT(block != NULL); RUBY_ASSERT(block != NULL);
@ -302,7 +302,7 @@ ujit_gen_block(ctx_t* ctx, block_t* block, rb_execution_context_t* ec)
if (!rb_st_lookup(gen_fns, opcode, (st_data_t*)&gen_fn)) { if (!rb_st_lookup(gen_fns, opcode, (st_data_t*)&gen_fn)) {
// If we reach an unknown instruction, // If we reach an unknown instruction,
// exit to the interpreter and stop compiling // exit to the interpreter and stop compiling
ujit_gen_exit(&jit, ctx, cb, jit.pc); yjit_gen_exit(&jit, ctx, cb, jit.pc);
break; break;
} }
@ -322,8 +322,8 @@ ujit_gen_block(ctx_t* ctx, block_t* block, rb_execution_context_t* ec)
// If we can't compile this instruction // If we can't compile this instruction
// exit to the interpreter and stop compiling // exit to the interpreter and stop compiling
if (status == UJIT_CANT_COMPILE) { if (status == YJIT_CANT_COMPILE) {
ujit_gen_exit(&jit, ctx, cb, jit.pc); yjit_gen_exit(&jit, ctx, cb, jit.pc);
break; break;
} }
@ -332,7 +332,7 @@ ujit_gen_block(ctx_t* ctx, block_t* block, rb_execution_context_t* ec)
insn_idx += insn_len(opcode); insn_idx += insn_len(opcode);
// If the instruction terminates this block // If the instruction terminates this block
if (status == UJIT_END_BLOCK) { if (status == YJIT_END_BLOCK) {
break; break;
} }
} }
@ -343,7 +343,7 @@ ujit_gen_block(ctx_t* ctx, block_t* block, rb_execution_context_t* ec)
// Store the index of the last instruction in the block // Store the index of the last instruction in the block
block->end_idx = insn_idx; block->end_idx = insn_idx;
if (UJIT_DUMP_MODE >= 2) { if (YJIT_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);
for (uint32_t idx = block->blockid.idx; idx < insn_idx;) for (uint32_t idx = block->blockid.idx; idx < insn_idx;)
@ -367,14 +367,14 @@ gen_dup(jitstate_t* jit, ctx_t* ctx)
mov(cb, REG0, dup_val); mov(cb, REG0, dup_val);
mov(cb, loc0, REG0); mov(cb, loc0, REG0);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
gen_nop(jitstate_t* jit, ctx_t* ctx) gen_nop(jitstate_t* jit, ctx_t* ctx)
{ {
// Do nothing // Do nothing
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -382,7 +382,7 @@ gen_pop(jitstate_t* jit, ctx_t* ctx)
{ {
// Decrement SP // Decrement SP
ctx_stack_pop(ctx, 1); ctx_stack_pop(ctx, 1);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -391,7 +391,7 @@ gen_putnil(jitstate_t* jit, ctx_t* ctx)
// Write constant at SP // Write constant at SP
x86opnd_t stack_top = ctx_stack_push(ctx, T_NIL); x86opnd_t stack_top = ctx_stack_push(ctx, T_NIL);
mov(cb, stack_top, imm_opnd(Qnil)); mov(cb, stack_top, imm_opnd(Qnil));
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -435,7 +435,7 @@ gen_putobject(jitstate_t* jit, ctx_t* ctx)
mov(cb, stack_top, RAX); mov(cb, stack_top, RAX);
} }
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -448,7 +448,7 @@ gen_putobject_int2fix(jitstate_t* jit, ctx_t* ctx)
x86opnd_t stack_top = ctx_stack_push(ctx, T_FIXNUM); x86opnd_t stack_top = ctx_stack_push(ctx, T_FIXNUM);
mov(cb, stack_top, imm_opnd(INT2FIX(cst_val))); mov(cb, stack_top, imm_opnd(INT2FIX(cst_val)));
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -461,7 +461,7 @@ gen_putself(jitstate_t* jit, ctx_t* ctx)
x86opnd_t stack_top = ctx_stack_push(ctx, T_NONE); x86opnd_t stack_top = ctx_stack_push(ctx, T_NONE);
mov(cb, stack_top, RAX); mov(cb, stack_top, RAX);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -481,7 +481,7 @@ gen_getlocal_wc0(jitstate_t* jit, ctx_t* ctx)
x86opnd_t stack_top = ctx_stack_push(ctx, T_NONE); x86opnd_t stack_top = ctx_stack_push(ctx, T_NONE);
mov(cb, stack_top, REG0); mov(cb, stack_top, REG0);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -508,7 +508,7 @@ gen_getlocal_wc1(jitstate_t* jit, ctx_t* ctx)
x86opnd_t stack_top = ctx_stack_push(ctx, T_NONE); x86opnd_t stack_top = ctx_stack_push(ctx, T_NONE);
mov(cb, stack_top, REG0); mov(cb, stack_top, REG0);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -535,7 +535,7 @@ gen_setlocal_wc0(jitstate_t* jit, 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(jit, ctx); uint8_t* side_exit = yjit_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);
@ -549,7 +549,7 @@ gen_setlocal_wc0(jitstate_t* jit, ctx_t* ctx)
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);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
// Check that `self` is a pointer to an object on the GC heap // Check that `self` is a pointer to an object on the GC heap
@ -575,14 +575,14 @@ gen_getinstancevariable(jitstate_t* jit, ctx_t* ctx)
// 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) {
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
// Defer compilation so we can peek at the topmost object // Defer compilation so we can peek at the topmost object
if (!jit_at_current_insn(jit)) if (!jit_at_current_insn(jit))
{ {
defer_compilation(jit->block, jit->insn_idx, ctx); defer_compilation(jit->block, jit->insn_idx, ctx);
return UJIT_END_BLOCK; return YJIT_END_BLOCK;
} }
// Peek at the topmost value on the stack at compilation time // Peek at the topmost value on the stack at compilation time
@ -609,13 +609,13 @@ gen_getinstancevariable(jitstate_t* jit, ctx_t* ctx)
// Eventually, we can encode whether an object is T_OBJECT or not // Eventually, we can encode whether an object is T_OBJECT or not
// inside object shapes. // inside object shapes.
if (rb_get_alloc_func(ic->entry->class_value) != rb_class_allocate_instance) { if (rb_get_alloc_func(ic->entry->class_value) != rb_class_allocate_instance) {
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
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(jit, ctx); uint8_t* side_exit = yjit_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));
@ -659,7 +659,7 @@ gen_getinstancevariable(jitstate_t* jit, ctx_t* ctx)
x86opnd_t out_opnd = ctx_stack_push(ctx, T_NONE); x86opnd_t out_opnd = ctx_stack_push(ctx, T_NONE);
mov(cb, out_opnd, REG0); mov(cb, out_opnd, REG0);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -669,7 +669,7 @@ gen_setinstancevariable(jitstate_t* jit, ctx_t* ctx)
// 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) {
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
// If the class uses the default allocator, instances should all be T_OBJECT // If the class uses the default allocator, instances should all be T_OBJECT
@ -677,13 +677,13 @@ gen_setinstancevariable(jitstate_t* jit, ctx_t* ctx)
// Eventually, we can encode whether an object is T_OBJECT or not // Eventually, we can encode whether an object is T_OBJECT or not
// inside object shapes. // inside object shapes.
if (rb_get_alloc_func(ic->entry->class_value) != rb_class_allocate_instance) { if (rb_get_alloc_func(ic->entry->class_value) != rb_class_allocate_instance) {
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
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(jit, ctx); uint8_t* side_exit = yjit_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));
@ -727,7 +727,7 @@ gen_setinstancevariable(jitstate_t* jit, ctx_t* ctx)
x86opnd_t ivar_opnd = mem_opnd(64, REG0, sizeof(VALUE) * ivar_index); x86opnd_t ivar_opnd = mem_opnd(64, REG0, sizeof(VALUE) * ivar_index);
mov(cb, ivar_opnd, REG1); mov(cb, ivar_opnd, REG1);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
// Conditional move operation used by comparison operators // Conditional move operation used by comparison operators
@ -738,7 +738,7 @@ gen_fixnum_cmp(jitstate_t* jit, ctx_t* ctx, cmov_fn cmov_op)
{ {
// 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(jit, ctx); uint8_t* side_exit = yjit_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
@ -777,7 +777,7 @@ gen_fixnum_cmp(jitstate_t* jit, ctx_t* ctx, cmov_fn cmov_op)
x86opnd_t dst = ctx_stack_push(ctx, T_NONE); x86opnd_t dst = ctx_stack_push(ctx, T_NONE);
mov(cb, dst, REG0); mov(cb, dst, REG0);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -806,7 +806,7 @@ gen_opt_aref(jitstate_t* jit, ctx_t* ctx)
// Only JIT one arg calls like `ary[6]` // Only JIT one arg calls like `ary[6]`
if (argc != 1) { if (argc != 1) {
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
const rb_callable_method_entry_t *cme = vm_cc_cme(cd->cc); const rb_callable_method_entry_t *cme = vm_cc_cme(cd->cc);
@ -815,11 +815,11 @@ gen_opt_aref(jitstate_t* jit, ctx_t* ctx)
// (including arrays) don't use the inline cache, so if the inline cache // (including arrays) don't use the inline cache, so if the inline cache
// has an entry, then this must be used by some other type. // has an entry, then this must be used by some other type.
if (cme) { if (cme) {
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
// 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(jit, ctx); uint8_t* side_exit = yjit_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 aref isn't redefined for arrays. // Make sure that aref isn't redefined for arrays.
@ -857,21 +857,21 @@ gen_opt_aref(jitstate_t* jit, ctx_t* ctx)
test(cb, REG1, imm_opnd(RUBY_FIXNUM_FLAG)); test(cb, REG1, imm_opnd(RUBY_FIXNUM_FLAG));
jz_ptr(cb, side_exit); jz_ptr(cb, side_exit);
// Save uJIT registers // Save YJIT registers
ujit_save_regs(cb); yjit_save_regs(cb);
mov(cb, RDI, recv_opnd); mov(cb, RDI, recv_opnd);
sar(cb, REG1, imm_opnd(1)); // Convert fixnum to int sar(cb, REG1, imm_opnd(1)); // Convert fixnum to int
mov(cb, RSI, REG1); mov(cb, RSI, REG1);
call_ptr(cb, REG0, (void *)rb_ary_entry_internal); call_ptr(cb, REG0, (void *)rb_ary_entry_internal);
// Restore uJIT registers // Restore YJIT registers
ujit_load_regs(cb); yjit_load_regs(cb);
x86opnd_t stack_ret = ctx_stack_push(ctx, T_NONE); x86opnd_t stack_ret = ctx_stack_push(ctx, T_NONE);
mov(cb, stack_ret, RAX); mov(cb, stack_ret, RAX);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -879,7 +879,7 @@ gen_opt_and(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(jit, ctx); uint8_t* side_exit = yjit_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
@ -915,7 +915,7 @@ gen_opt_and(jitstate_t* jit, ctx_t* ctx)
x86opnd_t dst = ctx_stack_push(ctx, T_FIXNUM); x86opnd_t dst = ctx_stack_push(ctx, T_FIXNUM);
mov(cb, dst, REG0); mov(cb, dst, REG0);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -923,7 +923,7 @@ 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(jit, ctx); uint8_t* side_exit = yjit_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
@ -955,7 +955,7 @@ gen_opt_minus(jitstate_t* jit, ctx_t* ctx)
x86opnd_t dst = ctx_stack_push(ctx, T_FIXNUM); x86opnd_t dst = ctx_stack_push(ctx, T_FIXNUM);
mov(cb, dst, REG0); mov(cb, dst, REG0);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
static codegen_status_t static codegen_status_t
@ -963,7 +963,7 @@ 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(jit, ctx); uint8_t* side_exit = yjit_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
@ -1001,7 +1001,7 @@ gen_opt_plus(jitstate_t* jit, ctx_t* ctx)
x86opnd_t dst = ctx_stack_push(ctx, T_FIXNUM); x86opnd_t dst = ctx_stack_push(ctx, T_FIXNUM);
mov(cb, dst, REG0); mov(cb, dst, REG0);
return UJIT_KEEP_COMPILING; return YJIT_KEEP_COMPILING;
} }
void void
@ -1029,8 +1029,8 @@ gen_branchif(jitstate_t* jit, ctx_t* ctx)
{ {
// FIXME: eventually, put VM_CHECK_INTS() only on backward branch targets // FIXME: eventually, put VM_CHECK_INTS() only on backward branch targets
// Check for interrupts // Check for interrupts
uint8_t* side_exit = ujit_side_exit(jit, ctx); uint8_t* side_exit = yjit_side_exit(jit, ctx);
ujit_check_ints(cb, side_exit); yjit_check_ints(cb, side_exit);
// Test if any bit (outside of the Qnil bit) is on // Test if any bit (outside of the Qnil bit) is on
// RUBY_Qfalse /* ...0000 0000 */ // RUBY_Qfalse /* ...0000 0000 */
@ -1054,7 +1054,7 @@ gen_branchif(jitstate_t* jit, ctx_t* ctx)
gen_branchif_branch gen_branchif_branch
); );
return UJIT_END_BLOCK; return YJIT_END_BLOCK;
} }
void void
@ -1082,8 +1082,8 @@ gen_branchunless(jitstate_t* jit, ctx_t* ctx)
{ {
// FIXME: eventually, put VM_CHECK_INTS() only on backward branch targets // FIXME: eventually, put VM_CHECK_INTS() only on backward branch targets
// Check for interrupts // Check for interrupts
uint8_t* side_exit = ujit_side_exit(jit, ctx); uint8_t* side_exit = yjit_side_exit(jit, ctx);
ujit_check_ints(cb, side_exit); yjit_check_ints(cb, side_exit);
// Test if any bit (outside of the Qnil bit) is on // Test if any bit (outside of the Qnil bit) is on
// RUBY_Qfalse /* ...0000 0000 */ // RUBY_Qfalse /* ...0000 0000 */
@ -1107,7 +1107,7 @@ gen_branchunless(jitstate_t* jit, ctx_t* ctx)
gen_branchunless_branch gen_branchunless_branch
); );
return UJIT_END_BLOCK; return YJIT_END_BLOCK;
} }
static codegen_status_t static codegen_status_t
@ -1115,8 +1115,8 @@ gen_jump(jitstate_t* jit, ctx_t* ctx)
{ {
// FIXME: eventually, put VM_CHECK_INTS() only on backward branch targets // FIXME: eventually, put VM_CHECK_INTS() only on backward branch targets
// Check for interrupts // Check for interrupts
uint8_t* side_exit = ujit_side_exit(jit, ctx); uint8_t* side_exit = yjit_side_exit(jit, ctx);
ujit_check_ints(cb, side_exit); yjit_check_ints(cb, side_exit);
// Get the branch target instruction offsets // Get the branch target instruction offsets
uint32_t jump_idx = jit_next_idx(jit) + (int32_t)jit_get_arg(jit, 0); uint32_t jump_idx = jit_next_idx(jit) + (int32_t)jit_get_arg(jit, 0);
@ -1128,7 +1128,7 @@ gen_jump(jitstate_t* jit, ctx_t* ctx)
jump_block jump_block
); );
return UJIT_END_BLOCK; return YJIT_END_BLOCK;
} }
static void static void
@ -1136,13 +1136,13 @@ jit_protected_guard(jitstate_t *jit, codeblock_t *cb, const rb_callable_method_e
{ {
// Callee is protected. Generate ancestry guard. // Callee is protected. Generate ancestry guard.
// See vm_call_method(). // See vm_call_method().
ujit_save_regs(cb); yjit_save_regs(cb);
mov(cb, C_ARG_REGS[0], member_opnd(REG_CFP, rb_control_frame_t, self)); mov(cb, C_ARG_REGS[0], member_opnd(REG_CFP, rb_control_frame_t, self));
jit_mov_gc_ptr(jit, cb, C_ARG_REGS[1], cme->defined_class); jit_mov_gc_ptr(jit, cb, C_ARG_REGS[1], cme->defined_class);
// Note: PC isn't written to current control frame as rb_is_kind_of() shouldn't raise. // Note: PC isn't written to current control frame as rb_is_kind_of() shouldn't raise.
// VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass); // VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass);
call_ptr(cb, REG0, (void *)&rb_obj_is_kind_of); call_ptr(cb, REG0, (void *)&rb_obj_is_kind_of);
ujit_load_regs(cb); yjit_load_regs(cb);
test(cb, RAX, RAX); test(cb, RAX, RAX);
jz_ptr(cb, COUNTED_EXIT(side_exit, oswb_se_protected_check_failed)); jz_ptr(cb, COUNTED_EXIT(side_exit, oswb_se_protected_check_failed));
} }
@ -1156,27 +1156,27 @@ gen_oswb_cfunc(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_c
if (cfunc->argc < 0 && cfunc->argc != -1) if (cfunc->argc < 0 && cfunc->argc != -1)
{ {
GEN_COUNTER_INC(cb, oswb_cfunc_ruby_array_varg); GEN_COUNTER_INC(cb, oswb_cfunc_ruby_array_varg);
return false; return YJIT_CANT_COMPILE;
} }
// If the argument count doesn't match // If the argument count doesn't match
if (cfunc->argc >= 0 && cfunc->argc != argc) if (cfunc->argc >= 0 && cfunc->argc != argc)
{ {
GEN_COUNTER_INC(cb, oswb_cfunc_argc_mismatch); GEN_COUNTER_INC(cb, oswb_cfunc_argc_mismatch);
return false; return YJIT_CANT_COMPILE;
} }
// Don't JIT functions that need C stack arguments for now // Don't JIT functions that need C stack arguments for now
if (argc + 1 > NUM_C_ARG_REGS) { if (argc + 1 > NUM_C_ARG_REGS) {
GEN_COUNTER_INC(cb, oswb_cfunc_toomany_args); GEN_COUNTER_INC(cb, oswb_cfunc_toomany_args);
return false; return YJIT_CANT_COMPILE;
} }
// 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(jit, ctx); uint8_t *side_exit = yjit_side_exit(jit, ctx);
// Check for interrupts // Check for interrupts
ujit_check_ints(cb, side_exit); yjit_check_ints(cb, side_exit);
// Points to the receiver operand on the stack // Points to the receiver operand on the stack
x86opnd_t recv = ctx_stack_opnd(ctx, argc); x86opnd_t recv = ctx_stack_opnd(ctx, argc);
@ -1237,7 +1237,7 @@ gen_oswb_cfunc(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_c
lea(cb, REG0, ctx_sp_opnd(ctx, sizeof(VALUE) * 3)); lea(cb, REG0, ctx_sp_opnd(ctx, sizeof(VALUE) * 3));
// Put compile time cme into REG1. It's assumed to be valid because we are notified when // Put compile time cme into REG1. It's assumed to be valid because we are notified when
// any cme we depend on become outdated. See rb_ujit_method_lookup_change(). // any cme we depend on become outdated. See rb_yjit_method_lookup_change().
jit_mov_gc_ptr(jit, cb, REG1, (VALUE)cme); jit_mov_gc_ptr(jit, cb, REG1, (VALUE)cme);
// Write method entry at sp[-3] // Write method entry at sp[-3]
// sp[-3] = me; // sp[-3] = me;
@ -1282,9 +1282,9 @@ gen_oswb_cfunc(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_c
} }
// Verify that we are calling the right function // Verify that we are calling the right function
if (UJIT_CHECK_MODE > 0) { if (YJIT_CHECK_MODE > 0) {
// Save uJIT registers // Save YJIT registers
ujit_save_regs(cb); yjit_save_regs(cb);
// Call check_cfunc_dispatch // Call check_cfunc_dispatch
mov(cb, RDI, recv); mov(cb, RDI, recv);
@ -1293,12 +1293,12 @@ gen_oswb_cfunc(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_c
jit_mov_gc_ptr(jit, cb, RCX, (VALUE)cme); jit_mov_gc_ptr(jit, cb, RCX, (VALUE)cme);
call_ptr(cb, REG0, (void *)&check_cfunc_dispatch); call_ptr(cb, REG0, (void *)&check_cfunc_dispatch);
// Load uJIT registers // Load YJIT registers
ujit_load_regs(cb); yjit_load_regs(cb);
} }
// Save uJIT registers // Save YJIT registers
ujit_save_regs(cb); yjit_save_regs(cb);
// Copy SP into RAX because REG_SP will get overwritten // Copy SP into RAX because REG_SP will get overwritten
lea(cb, RAX, ctx_sp_opnd(ctx, 0)); lea(cb, RAX, ctx_sp_opnd(ctx, 0));
@ -1331,11 +1331,11 @@ gen_oswb_cfunc(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_c
// 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]);
// cfunc comes from compile-time cme->def, which we assume to be stable. // cfunc comes from compile-time cme->def, which we assume to be stable.
// Invalidation logic is in rb_ujit_method_lookup_change() // Invalidation logic is in rb_yjit_method_lookup_change()
call_ptr(cb, REG0, (void*)cfunc->func); call_ptr(cb, REG0, (void*)cfunc->func);
// Load uJIT registers // Load YJIT registers
ujit_load_regs(cb); yjit_load_regs(cb);
// Push the return value on the Ruby stack // Push the return value on the Ruby stack
x86opnd_t stack_ret = ctx_stack_push(ctx, T_NONE); x86opnd_t stack_ret = ctx_stack_push(ctx, T_NONE);
@ -1360,7 +1360,7 @@ gen_oswb_cfunc(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_c
cont_block cont_block
); );
return UJIT_END_BLOCK; return YJIT_END_BLOCK;
} }
bool rb_simple_iseq_p(const rb_iseq_t *iseq); bool rb_simple_iseq_p(const rb_iseq_t *iseq);
@ -1392,27 +1392,27 @@ gen_oswb_iseq(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_ca
if (num_params != argc) { if (num_params != argc) {
GEN_COUNTER_INC(cb, oswb_iseq_argc_mismatch); GEN_COUNTER_INC(cb, oswb_iseq_argc_mismatch);
return false; return YJIT_CANT_COMPILE;
} }
if (!rb_simple_iseq_p(iseq)) { if (!rb_simple_iseq_p(iseq)) {
// Only handle iseqs that have simple parameters. // Only handle iseqs that have simple parameters.
// See vm_callee_setup_arg(). // See vm_callee_setup_arg().
GEN_COUNTER_INC(cb, oswb_iseq_not_simple); GEN_COUNTER_INC(cb, oswb_iseq_not_simple);
return false; return YJIT_CANT_COMPILE;
} }
if (vm_ci_flag(cd->ci) & VM_CALL_TAILCALL) { if (vm_ci_flag(cd->ci) & VM_CALL_TAILCALL) {
// We can't handle tailcalls // We can't handle tailcalls
GEN_COUNTER_INC(cb, oswb_iseq_tailcall); GEN_COUNTER_INC(cb, oswb_iseq_tailcall);
return false; return YJIT_CANT_COMPILE;
} }
// 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(jit, ctx); uint8_t* side_exit = yjit_side_exit(jit, ctx);
// Check for interrupts // Check for interrupts
ujit_check_ints(cb, side_exit); yjit_check_ints(cb, side_exit);
// Points to the receiver operand on the stack // Points to the receiver operand on the stack
x86opnd_t recv = ctx_stack_opnd(ctx, argc); x86opnd_t recv = ctx_stack_opnd(ctx, argc);
@ -1474,7 +1474,7 @@ gen_oswb_iseq(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_ca
} }
// Put compile time cme into REG1. It's assumed to be valid because we are notified when // Put compile time cme into REG1. It's assumed to be valid because we are notified when
// any cme we depend on become outdated. See rb_ujit_method_lookup_change(). // any cme we depend on become outdated. See rb_yjit_method_lookup_change().
jit_mov_gc_ptr(jit, cb, REG1, (VALUE)cme); jit_mov_gc_ptr(jit, cb, REG1, (VALUE)cme);
// Write method entry at sp[-3] // Write method entry at sp[-3]
// sp[-3] = me; // sp[-3] = me;
@ -1547,16 +1547,7 @@ gen_oswb_iseq(jitstate_t* jit, ctx_t* ctx, struct rb_call_data * cd, const rb_ca
(blockid_t){ iseq, 0 } (blockid_t){ iseq, 0 }
); );
// TODO: create stub for call continuation return true;
// TODO: need to pop args in the caller ctx
// TODO: stub so we can return to JITted code
//blockid_t cont_block = { jit->iseq, jit_next_insn_idx(jit) };
return UJIT_END_BLOCK;
} }
static codegen_status_t static codegen_status_t
@ -1575,19 +1566,19 @@ gen_opt_send_without_block(jitstate_t* jit, ctx_t* ctx)
// Don't JIT calls with keyword splat // Don't JIT calls with keyword splat
if (vm_ci_flag(cd->ci) & VM_CALL_KW_SPLAT) { if (vm_ci_flag(cd->ci) & VM_CALL_KW_SPLAT) {
GEN_COUNTER_INC(cb, oswb_kw_splat); GEN_COUNTER_INC(cb, oswb_kw_splat);
return false; return YJIT_CANT_COMPILE;
} }
// Don't JIT calls that aren't simple // Don't JIT calls that aren't simple
if (!(vm_ci_flag(cd->ci) & VM_CALL_ARGS_SIMPLE)) { if (!(vm_ci_flag(cd->ci) & VM_CALL_ARGS_SIMPLE)) {
GEN_COUNTER_INC(cb, oswb_callsite_not_simple); GEN_COUNTER_INC(cb, oswb_callsite_not_simple);
return false; return YJIT_CANT_COMPILE;
} }
// Don't JIT if the inline cache is not set // Don't JIT if the inline cache is not set
if (!cd->cc || !cd->cc->klass) { if (!cd->cc || !cd->cc->klass) {
GEN_COUNTER_INC(cb, oswb_ic_empty); GEN_COUNTER_INC(cb, oswb_ic_empty);
return false; return YJIT_CANT_COMPILE;
} }
const rb_callable_method_entry_t *cme = vm_cc_cme(cd->cc); const rb_callable_method_entry_t *cme = vm_cc_cme(cd->cc);
@ -1595,7 +1586,7 @@ gen_opt_send_without_block(jitstate_t* jit, ctx_t* ctx)
// Don't JIT if the method entry is out of date // Don't JIT if the method entry is out of date
if (METHOD_ENTRY_INVALIDATED(cme)) { if (METHOD_ENTRY_INVALIDATED(cme)) {
GEN_COUNTER_INC(cb, oswb_invalid_cme); GEN_COUNTER_INC(cb, oswb_invalid_cme);
return false; return YJIT_CANT_COMPILE;
} }
switch (cme->def->type) { switch (cme->def->type) {
@ -1605,34 +1596,34 @@ gen_opt_send_without_block(jitstate_t* jit, ctx_t* ctx)
return gen_oswb_cfunc(jit, ctx, cd, cme, argc); return gen_oswb_cfunc(jit, ctx, cd, cme, argc);
case VM_METHOD_TYPE_ATTRSET: case VM_METHOD_TYPE_ATTRSET:
GEN_COUNTER_INC(cb, oswb_ivar_set_method); GEN_COUNTER_INC(cb, oswb_ivar_set_method);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_BMETHOD: case VM_METHOD_TYPE_BMETHOD:
GEN_COUNTER_INC(cb, oswb_bmethod); GEN_COUNTER_INC(cb, oswb_bmethod);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_IVAR: case VM_METHOD_TYPE_IVAR:
GEN_COUNTER_INC(cb, oswb_ivar_get_method); GEN_COUNTER_INC(cb, oswb_ivar_get_method);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_ZSUPER: case VM_METHOD_TYPE_ZSUPER:
GEN_COUNTER_INC(cb, oswb_zsuper_method); GEN_COUNTER_INC(cb, oswb_zsuper_method);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_ALIAS: case VM_METHOD_TYPE_ALIAS:
GEN_COUNTER_INC(cb, oswb_alias_method); GEN_COUNTER_INC(cb, oswb_alias_method);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_UNDEF: case VM_METHOD_TYPE_UNDEF:
GEN_COUNTER_INC(cb, oswb_undef_method); GEN_COUNTER_INC(cb, oswb_undef_method);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_NOTIMPLEMENTED: case VM_METHOD_TYPE_NOTIMPLEMENTED:
GEN_COUNTER_INC(cb, oswb_not_implemented_method); GEN_COUNTER_INC(cb, oswb_not_implemented_method);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_OPTIMIZED: case VM_METHOD_TYPE_OPTIMIZED:
GEN_COUNTER_INC(cb, oswb_optimized_method); GEN_COUNTER_INC(cb, oswb_optimized_method);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_MISSING: case VM_METHOD_TYPE_MISSING:
GEN_COUNTER_INC(cb, oswb_missing_method); GEN_COUNTER_INC(cb, oswb_missing_method);
return false; return YJIT_CANT_COMPILE;
case VM_METHOD_TYPE_REFINED: case VM_METHOD_TYPE_REFINED:
GEN_COUNTER_INC(cb, oswb_refined_method); GEN_COUNTER_INC(cb, oswb_refined_method);
return false; return YJIT_CANT_COMPILE;
// no default case so compiler issues a warning if this is not exhaustive // no default case so compiler issues a warning if this is not exhaustive
} }
} }
@ -1644,7 +1635,7 @@ gen_leave(jitstate_t* jit, ctx_t* ctx)
RUBY_ASSERT(ctx->stack_size == 1); RUBY_ASSERT(ctx->stack_size == 1);
// 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(jit, ctx); uint8_t* side_exit = yjit_side_exit(jit, 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));
@ -1655,7 +1646,7 @@ gen_leave(jitstate_t* jit, ctx_t* ctx)
jnz_ptr(cb, COUNTED_EXIT(side_exit, leave_se_finish_frame)); jnz_ptr(cb, COUNTED_EXIT(side_exit, leave_se_finish_frame));
// Check for interrupts // Check for interrupts
ujit_check_ints(cb, COUNTED_EXIT(side_exit, leave_se_interrupt)); yjit_check_ints(cb, COUNTED_EXIT(side_exit, leave_se_interrupt));
// Load the return value // Load the return value
mov(cb, REG0, ctx_stack_pop(ctx, 1)); mov(cb, REG0, ctx_stack_pop(ctx, 1));
@ -1687,7 +1678,7 @@ gen_leave(jitstate_t* jit, ctx_t* ctx)
cb_link_labels(cb); cb_link_labels(cb);
cb_write_post_call_bytes(cb); cb_write_post_call_bytes(cb);
return UJIT_END_BLOCK; return YJIT_END_BLOCK;
} }
RUBY_EXTERN rb_serial_t ruby_vm_global_constant_state; RUBY_EXTERN rb_serial_t ruby_vm_global_constant_state;
@ -1702,24 +1693,24 @@ gen_opt_getinlinecache(jitstate_t *jit, ctx_t *ctx)
struct iseq_inline_constant_cache_entry *ice = ic->entry; struct iseq_inline_constant_cache_entry *ice = ic->entry;
if (!ice) { if (!ice) {
// Cache not filled // Cache not filled
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
if (ice->ic_serial != ruby_vm_global_constant_state) { if (ice->ic_serial != ruby_vm_global_constant_state) {
// Cache miss at compile time. // Cache miss at compile time.
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
if (ice->ic_cref) { if (ice->ic_cref) {
// Only compile for caches that don't care about lexical scope. // Only compile for caches that don't care about lexical scope.
return UJIT_CANT_COMPILE; return YJIT_CANT_COMPILE;
} }
// Optimize for single ractor mode. // Optimize for single ractor mode.
// FIXME: This leaks when st_insert raises NoMemoryError // FIXME: This leaks when st_insert raises NoMemoryError
if (!assume_single_ractor_mode(jit->block)) return UJIT_CANT_COMPILE; if (!assume_single_ractor_mode(jit->block)) return YJIT_CANT_COMPILE;
// Invalidate output code on any and all constant writes // Invalidate output code on any and all constant writes
// FIXME: This leaks when st_insert raises NoMemoryError // FIXME: This leaks when st_insert raises NoMemoryError
if (!assume_stable_global_constant_state(jit->block)) return UJIT_CANT_COMPILE; if (!assume_stable_global_constant_state(jit->block)) return YJIT_CANT_COMPILE;
x86opnd_t stack_top = ctx_stack_push(ctx, T_NONE); x86opnd_t stack_top = ctx_stack_push(ctx, T_NONE);
jit_mov_gc_ptr(jit, cb, REG0, ice->value); jit_mov_gc_ptr(jit, cb, REG0, ice->value);
@ -1732,10 +1723,10 @@ gen_opt_getinlinecache(jitstate_t *jit, ctx_t *ctx)
(blockid_t){ .iseq = jit->iseq, .idx = jump_idx } (blockid_t){ .iseq = jit->iseq, .idx = jump_idx }
); );
return UJIT_END_BLOCK; return YJIT_END_BLOCK;
} }
void ujit_reg_op(int opcode, codegen_fn gen_fn) void yjit_reg_op(int opcode, codegen_fn gen_fn)
{ {
// Check that the op wasn't previously registered // Check that the op wasn't previously registered
st_data_t st_gen; st_data_t st_gen;
@ -1747,7 +1738,7 @@ void ujit_reg_op(int opcode, codegen_fn gen_fn)
} }
void void
ujit_init_codegen(void) yjit_init_codegen(void)
{ {
// Initialize the code blocks // Initialize the code blocks
uint32_t mem_size = 128 * 1024 * 1024; uint32_t mem_size = 128 * 1024 * 1024;
@ -1761,32 +1752,32 @@ ujit_init_codegen(void)
gen_fns = rb_st_init_numtable(); gen_fns = rb_st_init_numtable();
// Map YARV opcodes to the corresponding codegen functions // Map YARV opcodes to the corresponding codegen functions
ujit_reg_op(BIN(dup), gen_dup); yjit_reg_op(BIN(dup), gen_dup);
ujit_reg_op(BIN(nop), gen_nop); yjit_reg_op(BIN(nop), gen_nop);
ujit_reg_op(BIN(pop), gen_pop); yjit_reg_op(BIN(pop), gen_pop);
ujit_reg_op(BIN(putnil), gen_putnil); yjit_reg_op(BIN(putnil), gen_putnil);
ujit_reg_op(BIN(putobject), gen_putobject); yjit_reg_op(BIN(putobject), gen_putobject);
ujit_reg_op(BIN(putobject_INT2FIX_0_), gen_putobject_int2fix); yjit_reg_op(BIN(putobject_INT2FIX_0_), gen_putobject_int2fix);
ujit_reg_op(BIN(putobject_INT2FIX_1_), gen_putobject_int2fix); yjit_reg_op(BIN(putobject_INT2FIX_1_), gen_putobject_int2fix);
ujit_reg_op(BIN(putself), gen_putself); yjit_reg_op(BIN(putself), gen_putself);
ujit_reg_op(BIN(getlocal_WC_0), gen_getlocal_wc0); yjit_reg_op(BIN(getlocal_WC_0), gen_getlocal_wc0);
ujit_reg_op(BIN(getlocal_WC_1), gen_getlocal_wc1); yjit_reg_op(BIN(getlocal_WC_1), gen_getlocal_wc1);
ujit_reg_op(BIN(setlocal_WC_0), gen_setlocal_wc0); yjit_reg_op(BIN(setlocal_WC_0), gen_setlocal_wc0);
ujit_reg_op(BIN(getinstancevariable), gen_getinstancevariable); yjit_reg_op(BIN(getinstancevariable), gen_getinstancevariable);
ujit_reg_op(BIN(setinstancevariable), gen_setinstancevariable); yjit_reg_op(BIN(setinstancevariable), gen_setinstancevariable);
ujit_reg_op(BIN(opt_lt), gen_opt_lt); yjit_reg_op(BIN(opt_lt), gen_opt_lt);
ujit_reg_op(BIN(opt_le), gen_opt_le); yjit_reg_op(BIN(opt_le), gen_opt_le);
ujit_reg_op(BIN(opt_ge), gen_opt_ge); yjit_reg_op(BIN(opt_ge), gen_opt_ge);
ujit_reg_op(BIN(opt_aref), gen_opt_aref); yjit_reg_op(BIN(opt_aref), gen_opt_aref);
ujit_reg_op(BIN(opt_and), gen_opt_and); yjit_reg_op(BIN(opt_and), gen_opt_and);
ujit_reg_op(BIN(opt_minus), gen_opt_minus); yjit_reg_op(BIN(opt_minus), gen_opt_minus);
ujit_reg_op(BIN(opt_plus), gen_opt_plus); yjit_reg_op(BIN(opt_plus), gen_opt_plus);
// Map branch instruction opcodes to codegen functions // Map branch instruction opcodes to codegen functions
ujit_reg_op(BIN(opt_getinlinecache), gen_opt_getinlinecache); yjit_reg_op(BIN(opt_getinlinecache), gen_opt_getinlinecache);
ujit_reg_op(BIN(branchif), gen_branchif); yjit_reg_op(BIN(branchif), gen_branchif);
ujit_reg_op(BIN(branchunless), gen_branchunless); yjit_reg_op(BIN(branchunless), gen_branchunless);
ujit_reg_op(BIN(jump), gen_jump); yjit_reg_op(BIN(jump), gen_jump);
ujit_reg_op(BIN(opt_send_without_block), gen_opt_send_without_block); yjit_reg_op(BIN(opt_send_without_block), gen_opt_send_without_block);
ujit_reg_op(BIN(leave), gen_leave); yjit_reg_op(BIN(leave), gen_leave);
} }

20
ujit_codegen.h → yjit_codegen.h
View file

@ -1,8 +1,8 @@
#ifndef UJIT_CODEGEN_H #ifndef YJIT_CODEGEN_H
#define UJIT_CODEGEN_H 1 #define YJIT_CODEGEN_H 1
#include "stddef.h" #include "stddef.h"
#include "ujit_core.h" #include "yjit_core.h"
// Code blocks we generate code into // Code blocks we generate code into
extern codeblock_t *cb; extern codeblock_t *cb;
@ -30,18 +30,18 @@ typedef struct JITState
} jitstate_t; } jitstate_t;
typedef enum codegen_status { typedef enum codegen_status {
UJIT_END_BLOCK, YJIT_END_BLOCK,
UJIT_KEEP_COMPILING, YJIT_KEEP_COMPILING,
UJIT_CANT_COMPILE YJIT_CANT_COMPILE
} codegen_status_t; } codegen_status_t;
// Code generation function signature // Code generation function signature
typedef codegen_status_t (*codegen_fn)(jitstate_t* jit, ctx_t* ctx); typedef codegen_status_t (*codegen_fn)(jitstate_t* jit, ctx_t* ctx);
uint8_t* ujit_entry_prologue(); uint8_t* yjit_entry_prologue();
void ujit_gen_block(ctx_t* ctx, block_t* block, rb_execution_context_t* ec); void yjit_gen_block(ctx_t* ctx, block_t* block, rb_execution_context_t* ec);
void ujit_init_codegen(void); void yjit_init_codegen(void);
#endif // #ifndef UJIT_CODEGEN_H #endif // #ifndef YJIT_CODEGEN_H

62
ujit_core.c → yjit_core.c
View file

@ -4,11 +4,11 @@
#include "insns.inc" #include "insns.inc"
#include "insns_info.inc" #include "insns_info.inc"
#include "vm_sync.h" #include "vm_sync.h"
#include "ujit_asm.h" #include "yjit_asm.h"
#include "ujit_utils.h" #include "yjit_utils.h"
#include "ujit_iface.h" #include "yjit_iface.h"
#include "ujit_core.h" #include "yjit_core.h"
#include "ujit_codegen.h" #include "yjit_codegen.h"
// Maximum number of versions per block // Maximum number of versions per block
#define MAX_VERSIONS 4 #define MAX_VERSIONS 4
@ -154,17 +154,17 @@ int ctx_diff(const ctx_t* src, const ctx_t* dst)
} }
// Get all blocks for a particular place in an iseq. // Get all blocks for a particular place in an iseq.
static rb_ujit_block_array_t static rb_yjit_block_array_t
get_version_array(const rb_iseq_t *iseq, unsigned idx) get_version_array(const rb_iseq_t *iseq, unsigned idx)
{ {
struct rb_iseq_constant_body *body = iseq->body; struct rb_iseq_constant_body *body = iseq->body;
if (rb_darray_size(body->ujit_blocks) == 0) { if (rb_darray_size(body->yjit_blocks) == 0) {
return NULL; return NULL;
} }
RUBY_ASSERT((unsigned)rb_darray_size(body->ujit_blocks) == body->iseq_size); RUBY_ASSERT((unsigned)rb_darray_size(body->yjit_blocks) == body->iseq_size);
return rb_darray_get(body->ujit_blocks, idx); return rb_darray_get(body->yjit_blocks, idx);
} }
// Count the number of block versions matching a given blockid // Count the number of block versions matching a given blockid
@ -182,14 +182,14 @@ add_block_version(blockid_t blockid, block_t* block)
const rb_iseq_t *iseq = block->blockid.iseq; const rb_iseq_t *iseq = block->blockid.iseq;
struct rb_iseq_constant_body *body = iseq->body; struct rb_iseq_constant_body *body = iseq->body;
// Ensure ujit_blocks is initialized for this iseq // Ensure yjit_blocks is initialized for this iseq
if (rb_darray_size(body->ujit_blocks) == 0) { if (rb_darray_size(body->yjit_blocks) == 0) {
// Initialize ujit_blocks to be as wide as body->iseq_encoded // Initialize yjit_blocks to be as wide as body->iseq_encoded
int32_t casted = (int32_t)body->iseq_size; int32_t casted = (int32_t)body->iseq_size;
if ((unsigned)casted != body->iseq_size) { if ((unsigned)casted != body->iseq_size) {
rb_bug("iseq too large"); rb_bug("iseq too large");
} }
if (!rb_darray_make(&body->ujit_blocks, casted)) { if (!rb_darray_make(&body->yjit_blocks, casted)) {
rb_bug("allocation failed"); rb_bug("allocation failed");
} }
@ -199,8 +199,8 @@ add_block_version(blockid_t blockid, block_t* block)
#endif #endif
} }
RUBY_ASSERT((int32_t)blockid.idx < rb_darray_size(body->ujit_blocks)); RUBY_ASSERT((int32_t)blockid.idx < rb_darray_size(body->yjit_blocks));
rb_ujit_block_array_t *block_array_ref = rb_darray_ref(body->ujit_blocks, blockid.idx); rb_yjit_block_array_t *block_array_ref = rb_darray_ref(body->yjit_blocks, blockid.idx);
// Add the new block // Add the new block
if (!rb_darray_append(block_array_ref, block)) { if (!rb_darray_append(block_array_ref, block)) {
@ -229,7 +229,7 @@ add_block_version(blockid_t blockid, block_t* block)
// Retrieve a basic block version for an (iseq, idx) tuple // Retrieve a basic block version for an (iseq, idx) tuple
block_t* find_block_version(blockid_t blockid, const ctx_t* ctx) block_t* find_block_version(blockid_t blockid, const ctx_t* ctx)
{ {
rb_ujit_block_array_t versions = get_version_array(blockid.iseq, blockid.idx); rb_yjit_block_array_t versions = get_version_array(blockid.iseq, blockid.idx);
// Best match found // Best match found
block_t* best_version = NULL; block_t* best_version = NULL;
@ -252,7 +252,7 @@ block_t* find_block_version(blockid_t blockid, const ctx_t* ctx)
} }
void void
ujit_branches_update_references(void) yjit_branches_update_references(void)
{ {
for (uint32_t i = 0; i < num_branches; i++) { for (uint32_t i = 0; i < num_branches; i++) {
branch_entries[i].targets[0].iseq = (const void *)rb_gc_location((VALUE)branch_entries[i].targets[0].iseq); branch_entries[i].targets[0].iseq = (const void *)rb_gc_location((VALUE)branch_entries[i].targets[0].iseq);
@ -276,7 +276,7 @@ block_t* gen_block_version(blockid_t blockid, const ctx_t* start_ctx, rb_executi
block_t* block = first_block; block_t* block = first_block;
// Generate code for the first block // Generate code for the first block
ujit_gen_block(ctx, block, ec); yjit_gen_block(ctx, block, ec);
// Keep track of the new block version // Keep track of the new block version
add_block_version(block->blockid, block); add_block_version(block->blockid, block);
@ -310,7 +310,7 @@ block_t* gen_block_version(blockid_t blockid, const ctx_t* start_ctx, rb_executi
memcpy(&block->ctx, ctx, sizeof(ctx_t)); memcpy(&block->ctx, ctx, sizeof(ctx_t));
// Generate code for the current block // Generate code for the current block
ujit_gen_block(ctx, block, ec); yjit_gen_block(ctx, block, ec);
// Keep track of the new block version // Keep track of the new block version
add_block_version(block->blockid, block); add_block_version(block->blockid, block);
@ -332,7 +332,7 @@ uint8_t* gen_entry_point(const rb_iseq_t *iseq, uint32_t insn_idx, rb_execution_
blockid_t blockid = { iseq, insn_idx }; blockid_t blockid = { iseq, insn_idx };
// Write the interpreter entry prologue // Write the interpreter entry prologue
uint8_t* code_ptr = ujit_entry_prologue(); uint8_t* code_ptr = yjit_entry_prologue();
// Try to generate code for the entry block // Try to generate code for the entry block
block_t* block = gen_block_version(blockid, &DEFAULT_CTX, ec); block_t* block = gen_block_version(blockid, &DEFAULT_CTX, ec);
@ -446,7 +446,7 @@ uint8_t* get_branch_target(
// branch_stub_hit(uint32_t branch_idx, uint32_t target_idx) // branch_stub_hit(uint32_t branch_idx, uint32_t target_idx)
uint8_t* stub_addr = cb_get_ptr(ocb, ocb->write_pos); uint8_t* stub_addr = cb_get_ptr(ocb, ocb->write_pos);
// Save the ujit registers // Save the yjit registers
push(ocb, REG_CFP); push(ocb, REG_CFP);
push(ocb, REG_EC); push(ocb, REG_EC);
push(ocb, REG_SP); push(ocb, REG_SP);
@ -458,7 +458,7 @@ uint8_t* get_branch_target(
mov(ocb, C_ARG_REGS[0], imm_opnd(branch_idx)); mov(ocb, C_ARG_REGS[0], imm_opnd(branch_idx));
call_ptr(ocb, REG0, (void *)&branch_stub_hit); call_ptr(ocb, REG0, (void *)&branch_stub_hit);
// Restore the ujit registers // Restore the yjit registers
pop(ocb, REG_SP); pop(ocb, REG_SP);
pop(ocb, REG_SP); pop(ocb, REG_SP);
pop(ocb, REG_EC); pop(ocb, REG_EC);
@ -646,10 +646,10 @@ void defer_compilation(
// Remove all references to a block then free it. // Remove all references to a block then free it.
void void
ujit_free_block(block_t *block) yjit_free_block(block_t *block)
{ {
ujit_unlink_method_lookup_dependency(block); yjit_unlink_method_lookup_dependency(block);
ujit_block_assumptions_free(block); yjit_block_assumptions_free(block);
rb_darray_free(block->incoming); rb_darray_free(block->incoming);
rb_darray_free(block->gc_object_offsets); rb_darray_free(block->gc_object_offsets);
@ -659,7 +659,7 @@ ujit_free_block(block_t *block)
// Remove a block version without reordering the version array // Remove a block version without reordering the version array
static bool static bool
block_array_remove(rb_ujit_block_array_t block_array, block_t *block) block_array_remove(rb_yjit_block_array_t block_array, block_t *block)
{ {
bool after_target = false; bool after_target = false;
block_t **element; block_t **element;
@ -687,7 +687,7 @@ invalidate_block_version(block_t* block)
// fprintf(stderr, "block=%p\n", block); // fprintf(stderr, "block=%p\n", block);
// Remove this block from the version array // Remove this block from the version array
rb_ujit_block_array_t versions = get_version_array(iseq, block->blockid.idx); rb_yjit_block_array_t versions = get_version_array(iseq, block->blockid.idx);
RB_UNUSED_VAR(bool removed); RB_UNUSED_VAR(bool removed);
removed = block_array_remove(versions, block); removed = block_array_remove(versions, block);
RUBY_ASSERT(removed); RUBY_ASSERT(removed);
@ -732,7 +732,7 @@ invalidate_block_version(block_t* block)
if (target_next && branch->end_pos > block->end_pos) if (target_next && branch->end_pos > block->end_pos)
{ {
rb_bug("ujit invalidate rewrote branch past block end"); rb_bug("yjit invalidate rewrote branch past block end");
} }
} }
@ -742,7 +742,7 @@ invalidate_block_version(block_t* block)
VALUE* entry_pc = iseq_pc_at_idx(iseq, idx); VALUE* entry_pc = iseq_pc_at_idx(iseq, idx);
int entry_opcode = opcode_at_pc(iseq, entry_pc); int entry_opcode = opcode_at_pc(iseq, entry_pc);
// TODO: unmap_addr2insn in ujit_iface.c? Maybe we can write a function to encompass this logic? // TODO: unmap_addr2insn in yjit_iface.c? Maybe we can write a function to encompass this logic?
// Should check how it's used in exit and side-exit // Should check how it's used in exit and side-exit
const void * const *handler_table = rb_vm_get_insns_address_table(); const void * const *handler_table = rb_vm_get_insns_address_table();
void* handler_addr = (void*)handler_table[entry_opcode]; void* handler_addr = (void*)handler_table[entry_opcode];
@ -755,13 +755,13 @@ invalidate_block_version(block_t* block)
// FIXME: // FIXME:
// Call continuation addresses on the stack can also be atomically replaced by jumps going to the stub. // Call continuation addresses on the stack can also be atomically replaced by jumps going to the stub.
ujit_free_block(block); yjit_free_block(block);
// fprintf(stderr, "invalidation done\n"); // fprintf(stderr, "invalidation done\n");
} }
void void
ujit_init_core(void) yjit_init_core(void)
{ {
// Nothing yet // Nothing yet
} }

22
ujit_core.h → yjit_core.h
View file

@ -1,17 +1,17 @@
#ifndef UJIT_CORE_H #ifndef YJIT_CORE_H
#define UJIT_CORE_H 1 #define YJIT_CORE_H 1
#include "stddef.h" #include "stddef.h"
#include "ujit_asm.h" #include "yjit_asm.h"
// Register uJIT receives the CFP and EC into // Register YJIT receives the CFP and EC into
#define REG_CFP RDI #define REG_CFP RDI
#define REG_EC RSI #define REG_EC RSI
// Register uJIT loads the SP into // Register YJIT loads the SP into
#define REG_SP RDX #define REG_SP RDX
// Scratch registers used by uJIT // Scratch registers used by YJIT
#define REG0 RAX #define REG0 RAX
#define REG1 RCX #define REG1 RCX
#define REG0_32 EAX #define REG0_32 EAX
@ -109,7 +109,7 @@ Basic block version
Represents a portion of an iseq compiled with a given context Represents a portion of an iseq compiled with a given context
Note: care must be taken to minimize the size of block_t objects Note: care must be taken to minimize the size of block_t objects
*/ */
typedef struct ujit_block_version typedef struct yjit_block_version
{ {
// Bytecode sequence (iseq, idx) this is a version of // Bytecode sequence (iseq, idx) this is a version of
blockid_t blockid; blockid_t blockid;
@ -148,8 +148,8 @@ int ctx_diff(const ctx_t* src, const ctx_t* dst);
block_t* find_block_version(blockid_t blockid, const ctx_t* ctx); block_t* find_block_version(blockid_t blockid, const ctx_t* ctx);
block_t* gen_block_version(blockid_t blockid, const ctx_t* ctx, rb_execution_context_t *ec); block_t* gen_block_version(blockid_t blockid, const ctx_t* ctx, rb_execution_context_t *ec);
uint8_t* gen_entry_point(const rb_iseq_t *iseq, uint32_t insn_idx, rb_execution_context_t *ec); uint8_t* gen_entry_point(const rb_iseq_t *iseq, uint32_t insn_idx, rb_execution_context_t *ec);
void ujit_free_block(block_t *block); void yjit_free_block(block_t *block);
void ujit_branches_update_references(void); void yjit_branches_update_references(void);
void gen_branch( void gen_branch(
const ctx_t* src_ctx, const ctx_t* src_ctx,
@ -173,6 +173,6 @@ void defer_compilation(
void invalidate_block_version(block_t* block); void invalidate_block_version(block_t* block);
void ujit_init_core(void); void yjit_init_core(void);
#endif // #ifndef UJIT_CORE_H #endif // #ifndef YJIT_CORE_H

258
ujit_iface.c → yjit_iface.c
View file

@ -8,27 +8,27 @@
#include "internal/compile.h" #include "internal/compile.h"
#include "internal/class.h" #include "internal/class.h"
#include "insns_info.inc" #include "insns_info.inc"
#include "ujit.h" #include "yjit.h"
#include "ujit_iface.h" #include "yjit_iface.h"
#include "ujit_codegen.h" #include "yjit_codegen.h"
#include "ujit_core.h" #include "yjit_core.h"
#include "ujit_hooks.inc" #include "yjit_hooks.inc"
#include "darray.h" #include "darray.h"
#if HAVE_LIBCAPSTONE #if HAVE_LIBCAPSTONE
#include <capstone/capstone.h> #include <capstone/capstone.h>
#endif #endif
static VALUE mUjit; static VALUE mYjit;
static VALUE cUjitBlock; static VALUE cYjitBlock;
static VALUE cUjitDisasm; static VALUE cYjitDisasm;
static VALUE cUjitDisasmInsn; static VALUE cYjitDisasmInsn;
#if RUBY_DEBUG #if RUBY_DEBUG
static int64_t vm_insns_count = 0; static int64_t vm_insns_count = 0;
static int64_t exit_op_count[VM_INSTRUCTION_SIZE] = { 0 }; static int64_t exit_op_count[VM_INSTRUCTION_SIZE] = { 0 };
int64_t rb_compiled_iseq_count = 0; int64_t rb_compiled_iseq_count = 0;
struct rb_ujit_runtime_counters ujit_runtime_counters = { 0 }; struct rb_yjit_runtime_counters yjit_runtime_counters = { 0 };
#endif #endif
// Machine code blocks (executable memory) // Machine code blocks (executable memory)
@ -38,28 +38,28 @@ extern codeblock_t *ocb;
// Hash table of encoded instructions // Hash table of encoded instructions
extern st_table *rb_encoded_insn_data; extern st_table *rb_encoded_insn_data;
struct rb_ujit_options rb_ujit_opts; struct rb_yjit_options rb_yjit_opts;
static const rb_data_type_t ujit_block_type = { static const rb_data_type_t yjit_block_type = {
"UJIT/Block", "YJIT/Block",
{0, 0, 0, }, {0, 0, 0, },
0, 0, RUBY_TYPED_FREE_IMMEDIATELY 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
}; };
// Write the uJIT entry point pre-call bytes // Write the YJIT entry point pre-call bytes
void void
cb_write_pre_call_bytes(codeblock_t* cb) cb_write_pre_call_bytes(codeblock_t* cb)
{ {
for (size_t i = 0; i < sizeof(ujit_with_ec_pre_call_bytes); ++i) for (size_t i = 0; i < sizeof(yjit_with_ec_pre_call_bytes); ++i)
cb_write_byte(cb, ujit_with_ec_pre_call_bytes[i]); cb_write_byte(cb, yjit_with_ec_pre_call_bytes[i]);
} }
// Write the uJIT exit post-call bytes // Write the YJIT exit post-call bytes
void void
cb_write_post_call_bytes(codeblock_t* cb) cb_write_post_call_bytes(codeblock_t* cb)
{ {
for (size_t i = 0; i < sizeof(ujit_with_ec_post_call_bytes); ++i) for (size_t i = 0; i < sizeof(yjit_with_ec_post_call_bytes); ++i)
cb_write_byte(cb, ujit_with_ec_post_call_bytes[i]); cb_write_byte(cb, yjit_with_ec_post_call_bytes[i]);
} }
// Get the PC for a given index in an iseq // Get the PC for a given index in an iseq
@ -84,7 +84,7 @@ map_addr2insn(void *code_ptr, int insn)
st_insert(rb_encoded_insn_data, (st_data_t)code_ptr, encoded_insn_data); st_insert(rb_encoded_insn_data, (st_data_t)code_ptr, encoded_insn_data);
} }
else { else {
rb_bug("ujit: failed to find info for original instruction while dealing with addr2insn"); rb_bug("yjit: failed to find info for original instruction while dealing with addr2insn");
} }
} }
@ -105,7 +105,7 @@ void
check_cfunc_dispatch(VALUE receiver, struct rb_call_data *cd, void *callee, rb_callable_method_entry_t *compile_time_cme) check_cfunc_dispatch(VALUE receiver, struct rb_call_data *cd, void *callee, rb_callable_method_entry_t *compile_time_cme)
{ {
if (METHOD_ENTRY_INVALIDATED(compile_time_cme)) { if (METHOD_ENTRY_INVALIDATED(compile_time_cme)) {
rb_bug("ujit: output code uses invalidated cme %p", (void *)compile_time_cme); rb_bug("yjit: output code uses invalidated cme %p", (void *)compile_time_cme);
} }
bool callee_correct = false; bool callee_correct = false;
@ -117,7 +117,7 @@ check_cfunc_dispatch(VALUE receiver, struct rb_call_data *cd, void *callee, rb_c
} }
} }
if (!callee_correct) { if (!callee_correct) {
rb_bug("ujit: output code calls wrong method cd->cc->klass: %p", (void *)cd->cc->klass); rb_bug("yjit: output code calls wrong method cd->cc->klass: %p", (void *)cd->cc->klass);
} }
} }
@ -137,12 +137,12 @@ cfunc_needs_frame(const rb_method_cfunc_t *cfunc)
} }
// GC root for interacting with the GC // GC root for interacting with the GC
struct ujit_root_struct { struct yjit_root_struct {
int unused; // empty structs are not legal in C99 int unused; // empty structs are not legal in C99
}; };
static void static void
block_array_shuffle_remove(rb_ujit_block_array_t blocks, block_t *to_remove) { block_array_shuffle_remove(rb_yjit_block_array_t blocks, block_t *to_remove) {
block_t **elem; block_t **elem;
rb_darray_foreach(blocks, i, elem) { rb_darray_foreach(blocks, i, elem) {
if (*elem == to_remove) { if (*elem == to_remove) {
@ -162,12 +162,12 @@ add_lookup_dependency_i(st_data_t *key, st_data_t *value, st_data_t data, int ex
{ {
block_t *new_block = (block_t *)data; block_t *new_block = (block_t *)data;
rb_ujit_block_array_t blocks = NULL; rb_yjit_block_array_t blocks = NULL;
if (existing) { if (existing) {
blocks = (rb_ujit_block_array_t)*value; blocks = (rb_yjit_block_array_t)*value;
} }
if (!rb_darray_append(&blocks, new_block)) { if (!rb_darray_append(&blocks, new_block)) {
rb_bug("ujit: failed to add method lookup dependency"); // TODO: we could bail out of compiling instead rb_bug("yjit: failed to add method lookup dependency"); // TODO: we could bail out of compiling instead
} }
*value = (st_data_t)blocks; *value = (st_data_t)blocks;
@ -210,7 +210,7 @@ assume_stable_global_constant_state(block_t *block) {
} }
static int static int
ujit_root_mark_i(st_data_t k, st_data_t v, st_data_t ignore) yjit_root_mark_i(st_data_t k, st_data_t v, st_data_t ignore)
{ {
// Lifetime notes: cc and cme get added in pairs into the table. One of // Lifetime notes: cc and cme get added in pairs into the table. One of
// them should become invalid before dying. When one of them invalidate we // them should become invalid before dying. When one of them invalidate we
@ -237,7 +237,7 @@ replace_all(st_data_t key, st_data_t value, st_data_t argp, int error)
// GC callback during compaction // GC callback during compaction
static void static void
ujit_root_update_references(void *ptr) yjit_root_update_references(void *ptr)
{ {
if (method_lookup_dependency) { if (method_lookup_dependency) {
if (st_foreach_with_replace(method_lookup_dependency, replace_all, method_lookup_dep_table_update_keys, 0)) { if (st_foreach_with_replace(method_lookup_dependency, replace_all, method_lookup_dep_table_update_keys, 0)) {
@ -245,26 +245,26 @@ ujit_root_update_references(void *ptr)
} }
} }
ujit_branches_update_references(); yjit_branches_update_references();
} }
// GC callback during mark phase // GC callback during mark phase
static void static void
ujit_root_mark(void *ptr) yjit_root_mark(void *ptr)
{ {
if (method_lookup_dependency) { if (method_lookup_dependency) {
st_foreach(method_lookup_dependency, ujit_root_mark_i, 0); st_foreach(method_lookup_dependency, yjit_root_mark_i, 0);
} }
} }
static void static void
ujit_root_free(void *ptr) yjit_root_free(void *ptr)
{ {
// Do nothing. The root lives as long as the process. // Do nothing. The root lives as long as the process.
} }
static size_t static size_t
ujit_root_memsize(const void *ptr) yjit_root_memsize(const void *ptr)
{ {
// Count off-gc-heap allocation size of the dependency table // Count off-gc-heap allocation size of the dependency table
return st_memsize(method_lookup_dependency); // TODO: more accurate accounting return st_memsize(method_lookup_dependency); // TODO: more accurate accounting
@ -273,15 +273,15 @@ ujit_root_memsize(const void *ptr)
// Custom type for interacting with the GC // Custom type for interacting with the GC
// TODO: compaction support // TODO: compaction support
// TODO: make this write barrier protected // TODO: make this write barrier protected
static const rb_data_type_t ujit_root_type = { static const rb_data_type_t yjit_root_type = {
"ujit_root", "yjit_root",
{ujit_root_mark, ujit_root_free, ujit_root_memsize, ujit_root_update_references}, {yjit_root_mark, yjit_root_free, yjit_root_memsize, yjit_root_update_references},
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_yjit_method_lookup_change(VALUE cme_or_cc)
{ {
if (!method_lookup_dependency) if (!method_lookup_dependency)
return; return;
@ -293,7 +293,7 @@ rb_ujit_method_lookup_change(VALUE cme_or_cc)
// Invalidate all regions that depend on the cme or cc // Invalidate all regions that depend on the cme or cc
st_data_t key = (st_data_t)cme_or_cc, image; st_data_t key = (st_data_t)cme_or_cc, image;
if (st_delete(method_lookup_dependency, &key, &image)) { if (st_delete(method_lookup_dependency, &key, &image)) {
rb_ujit_block_array_t array = (void *)image; rb_yjit_block_array_t array = (void *)image;
block_t **elem; block_t **elem;
rb_darray_foreach(array, i, elem) { rb_darray_foreach(array, i, elem) {
@ -312,7 +312,7 @@ remove_method_lookup_dependency(VALUE cc_or_cme, block_t *block)
{ {
st_data_t key = (st_data_t)cc_or_cme, image; st_data_t key = (st_data_t)cc_or_cme, image;
if (st_lookup(method_lookup_dependency, key, &image)) { if (st_lookup(method_lookup_dependency, key, &image)) {
rb_ujit_block_array_t array = (void *)image; rb_yjit_block_array_t array = (void *)image;
block_array_shuffle_remove(array, block); block_array_shuffle_remove(array, block);
@ -324,14 +324,14 @@ remove_method_lookup_dependency(VALUE cc_or_cme, block_t *block)
} }
void void
ujit_unlink_method_lookup_dependency(block_t *block) yjit_unlink_method_lookup_dependency(block_t *block)
{ {
if (block->dependencies.cc) remove_method_lookup_dependency(block->dependencies.cc, block); if (block->dependencies.cc) remove_method_lookup_dependency(block->dependencies.cc, block);
if (block->dependencies.cme) remove_method_lookup_dependency(block->dependencies.cme, block); if (block->dependencies.cme) remove_method_lookup_dependency(block->dependencies.cme, block);
} }
void void
ujit_block_assumptions_free(block_t *block) yjit_block_assumptions_free(block_t *block)
{ {
st_data_t as_st_data = (st_data_t)block; st_data_t as_st_data = (st_data_t)block;
if (blocks_assuming_stable_global_constant_state) { if (blocks_assuming_stable_global_constant_state) {
@ -344,7 +344,7 @@ ujit_block_assumptions_free(block_t *block)
} }
void void
rb_ujit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec) rb_yjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec)
{ {
#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE #if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE
RB_VM_LOCK_ENTER(); RB_VM_LOCK_ENTER();
@ -365,14 +365,14 @@ rb_ujit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec)
#endif #endif
} }
struct ujit_block_itr { struct yjit_block_itr {
const rb_iseq_t *iseq; const rb_iseq_t *iseq;
VALUE list; VALUE list;
}; };
/* Get a list of the UJIT blocks associated with `rb_iseq` */ /* Get a list of the YJIT blocks associated with `rb_iseq` */
static VALUE static VALUE
ujit_blocks_for(VALUE mod, VALUE rb_iseq) yjit_blocks_for(VALUE mod, VALUE rb_iseq)
{ {
if (CLASS_OF(rb_iseq) != rb_cISeq) { if (CLASS_OF(rb_iseq) != rb_cISeq) {
return rb_ary_new(); return rb_ary_new();
@ -381,13 +381,13 @@ ujit_blocks_for(VALUE mod, VALUE rb_iseq)
const rb_iseq_t *iseq = rb_iseqw_to_iseq(rb_iseq); const rb_iseq_t *iseq = rb_iseqw_to_iseq(rb_iseq);
VALUE all_versions = rb_ary_new(); VALUE all_versions = rb_ary_new();
rb_darray_for(iseq->body->ujit_blocks, version_array_idx) { rb_darray_for(iseq->body->yjit_blocks, version_array_idx) {
rb_ujit_block_array_t versions = rb_darray_get(iseq->body->ujit_blocks, version_array_idx); rb_yjit_block_array_t versions = rb_darray_get(iseq->body->yjit_blocks, version_array_idx);
rb_darray_for(versions, block_idx) { rb_darray_for(versions, block_idx) {
block_t *block = rb_darray_get(versions, block_idx); block_t *block = rb_darray_get(versions, block_idx);
VALUE rb_block = TypedData_Wrap_Struct(cUjitBlock, &ujit_block_type, block); VALUE rb_block = TypedData_Wrap_Struct(cYjitBlock, &yjit_block_type, block);
rb_ary_push(all_versions, rb_block); rb_ary_push(all_versions, rb_block);
} }
} }
@ -395,22 +395,22 @@ ujit_blocks_for(VALUE mod, VALUE rb_iseq)
return all_versions; return all_versions;
} }
/* Get the address of the the code associated with a UJIT::Block */ /* Get the address of the the code associated with a YJIT::Block */
static VALUE static VALUE
block_address(VALUE self) block_address(VALUE self)
{ {
block_t * block; block_t * block;
TypedData_Get_Struct(self, block_t, &ujit_block_type, block); TypedData_Get_Struct(self, block_t, &yjit_block_type, block);
uint8_t* code_addr = cb_get_ptr(cb, block->start_pos); uint8_t* code_addr = cb_get_ptr(cb, block->start_pos);
return LONG2NUM((intptr_t)code_addr); return LONG2NUM((intptr_t)code_addr);
} }
/* Get the machine code for UJIT::Block as a binary string */ /* Get the machine code for YJIT::Block as a binary string */
static VALUE static VALUE
block_code(VALUE self) block_code(VALUE self)
{ {
block_t * block; block_t * block;
TypedData_Get_Struct(self, block_t, &ujit_block_type, block); TypedData_Get_Struct(self, block_t, &yjit_block_type, block);
return (VALUE)rb_str_new( return (VALUE)rb_str_new(
(const char*)cb->mem_block + block->start_pos, (const char*)cb->mem_block + block->start_pos,
@ -419,30 +419,30 @@ block_code(VALUE self)
} }
/* Get the start index in the Instruction Sequence that corresponds to this /* Get the start index in the Instruction Sequence that corresponds to this
* UJIT::Block */ * YJIT::Block */
static VALUE static VALUE
iseq_start_index(VALUE self) iseq_start_index(VALUE self)
{ {
block_t * block; block_t * block;
TypedData_Get_Struct(self, block_t, &ujit_block_type, block); TypedData_Get_Struct(self, block_t, &yjit_block_type, block);
return INT2NUM(block->blockid.idx); return INT2NUM(block->blockid.idx);
} }
/* Get the end index in the Instruction Sequence that corresponds to this /* Get the end index in the Instruction Sequence that corresponds to this
* UJIT::Block */ * YJIT::Block */
static VALUE static VALUE
iseq_end_index(VALUE self) iseq_end_index(VALUE self)
{ {
block_t * block; block_t * block;
TypedData_Get_Struct(self, block_t, &ujit_block_type, block); TypedData_Get_Struct(self, block_t, &yjit_block_type, block);
return INT2NUM(block->end_idx); return INT2NUM(block->end_idx);
} }
/* Called when a basic operation is redefined */ /* Called when a basic operation is redefined */
void void
rb_ujit_bop_redefined(VALUE klass, const rb_method_entry_t *me, enum ruby_basic_operators bop) rb_yjit_bop_redefined(VALUE klass, const rb_method_entry_t *me, enum ruby_basic_operators bop)
{ {
//fprintf(stderr, "bop redefined\n"); //fprintf(stderr, "bop redefined\n");
} }
@ -456,7 +456,7 @@ block_invalidation_iterator(st_data_t key, st_data_t value, st_data_t data) {
/* Called when the constant state changes */ /* Called when the constant state changes */
void void
rb_ujit_constant_state_changed(void) rb_yjit_constant_state_changed(void)
{ {
if (blocks_assuming_stable_global_constant_state) { if (blocks_assuming_stable_global_constant_state) {
st_foreach(blocks_assuming_stable_global_constant_state, block_invalidation_iterator, 0); st_foreach(blocks_assuming_stable_global_constant_state, block_invalidation_iterator, 0);
@ -464,7 +464,7 @@ rb_ujit_constant_state_changed(void)
} }
void void
rb_ujit_before_ractor_spawn(void) rb_yjit_before_ractor_spawn(void)
{ {
if (blocks_assuming_single_ractor_mode) { if (blocks_assuming_single_ractor_mode) {
st_foreach(blocks_assuming_single_ractor_mode, block_invalidation_iterator, 0); st_foreach(blocks_assuming_single_ractor_mode, block_invalidation_iterator, 0);
@ -472,29 +472,29 @@ rb_ujit_before_ractor_spawn(void)
} }
#if HAVE_LIBCAPSTONE #if HAVE_LIBCAPSTONE
static const rb_data_type_t ujit_disasm_type = { static const rb_data_type_t yjit_disasm_type = {
"UJIT/Disasm", "YJIT/Disasm",
{0, (void(*)(void *))cs_close, 0, }, {0, (void(*)(void *))cs_close, 0, },
0, 0, RUBY_TYPED_FREE_IMMEDIATELY 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
}; };
static VALUE static VALUE
ujit_disasm_init(VALUE klass) yjit_disasm_init(VALUE klass)
{ {
csh * handle; csh * handle;
VALUE disasm = TypedData_Make_Struct(klass, csh, &ujit_disasm_type, handle); VALUE disasm = TypedData_Make_Struct(klass, csh, &yjit_disasm_type, handle);
cs_open(CS_ARCH_X86, CS_MODE_64, handle); cs_open(CS_ARCH_X86, CS_MODE_64, handle);
return disasm; return disasm;
} }
static VALUE static VALUE
ujit_disasm(VALUE self, VALUE code, VALUE from) yjit_disasm(VALUE self, VALUE code, VALUE from)
{ {
size_t count; size_t count;
csh * handle; csh * handle;
cs_insn *insns; cs_insn *insns;
TypedData_Get_Struct(self, csh, &ujit_disasm_type, handle); TypedData_Get_Struct(self, csh, &yjit_disasm_type, handle);
count = cs_disasm(*handle, (uint8_t*)StringValuePtr(code), RSTRING_LEN(code), NUM2INT(from), 0, &insns); count = cs_disasm(*handle, (uint8_t*)StringValuePtr(code), RSTRING_LEN(code), NUM2INT(from), 0, &insns);
VALUE insn_list = rb_ary_new_capa(count); VALUE insn_list = rb_ary_new_capa(count);
@ -502,7 +502,7 @@ ujit_disasm(VALUE self, VALUE code, VALUE from)
VALUE vals = rb_ary_new_from_args(3, LONG2NUM(insns[i].address), VALUE vals = rb_ary_new_from_args(3, LONG2NUM(insns[i].address),
rb_str_new2(insns[i].mnemonic), rb_str_new2(insns[i].mnemonic),
rb_str_new2(insns[i].op_str)); rb_str_new2(insns[i].op_str));
rb_ary_push(insn_list, rb_struct_alloc(cUjitDisasmInsn, vals)); rb_ary_push(insn_list, rb_struct_alloc(cYjitDisasmInsn, vals));
} }
cs_free(insns, count); cs_free(insns, count);
return insn_list; return insn_list;
@ -512,27 +512,27 @@ ujit_disasm(VALUE self, VALUE code, VALUE from)
static VALUE static VALUE
at_exit_print_stats(RB_BLOCK_CALL_FUNC_ARGLIST(yieldarg, data)) at_exit_print_stats(RB_BLOCK_CALL_FUNC_ARGLIST(yieldarg, data))
{ {
// Defined in ujit.rb // Defined in yjit.rb
rb_funcall(mUjit, rb_intern("_print_stats"), 0); rb_funcall(mYjit, rb_intern("_print_stats"), 0);
return Qnil; return Qnil;
} }
// Primitive called in ujit.rb. Export all runtime counters as a Ruby hash. // Primitive called in yjit.rb. Export all runtime counters as a Ruby hash.
static VALUE static VALUE
get_stat_counters(rb_execution_context_t *ec, VALUE self) get_stat_counters(rb_execution_context_t *ec, VALUE self)
{ {
#if RUBY_DEBUG #if RUBY_DEBUG
if (!rb_ujit_opts.gen_stats) return Qnil; if (!rb_yjit_opts.gen_stats) return Qnil;
VALUE hash = rb_hash_new(); VALUE hash = rb_hash_new();
RB_VM_LOCK_ENTER(); RB_VM_LOCK_ENTER();
{ {
int64_t *counter_reader = (int64_t *)&ujit_runtime_counters; int64_t *counter_reader = (int64_t *)&yjit_runtime_counters;
int64_t *counter_reader_end = &ujit_runtime_counters.last_member; int64_t *counter_reader_end = &yjit_runtime_counters.last_member;
// Iterate through comma separated counter name list // Iterate through comma separated counter name list
char *name_reader = ujit_counter_names; char *name_reader = yjit_counter_names;
char *counter_name_end = ujit_counter_names + sizeof(ujit_counter_names); char *counter_name_end = yjit_counter_names + sizeof(yjit_counter_names);
while (name_reader < counter_name_end && counter_reader < counter_reader_end) { while (name_reader < counter_name_end && counter_reader < counter_reader_end) {
if (*name_reader == ',' || *name_reader == ' ') { if (*name_reader == ',' || *name_reader == ' ') {
name_reader++; name_reader++;
@ -564,7 +564,7 @@ get_stat_counters(rb_execution_context_t *ec, VALUE self)
#endif // if RUBY_DEBUG #endif // if RUBY_DEBUG
} }
// Primitive called in ujit.rb. Zero out all the counters. // Primitive called in yjit.rb. Zero out all the counters.
static VALUE static VALUE
reset_stats_bang(rb_execution_context_t *ec, VALUE self) reset_stats_bang(rb_execution_context_t *ec, VALUE self)
{ {
@ -572,24 +572,24 @@ reset_stats_bang(rb_execution_context_t *ec, VALUE self)
vm_insns_count = 0; vm_insns_count = 0;
rb_compiled_iseq_count = 0; rb_compiled_iseq_count = 0;
memset(&exit_op_count, 0, sizeof(exit_op_count)); memset(&exit_op_count, 0, sizeof(exit_op_count));
memset(&ujit_runtime_counters, 0, sizeof(ujit_runtime_counters)); memset(&yjit_runtime_counters, 0, sizeof(yjit_runtime_counters));
#endif // if RUBY_DEBUG #endif // if RUBY_DEBUG
return Qnil; return Qnil;
} }
#include "ujit.rbinc" #include "yjit.rbinc"
#if RUBY_DEBUG #if RUBY_DEBUG
// implementation for --ujit-stats // implementation for --yjit-stats
void void
rb_ujit_collect_vm_usage_insn(int insn) rb_yjit_collect_vm_usage_insn(int insn)
{ {
vm_insns_count++; vm_insns_count++;
} }
const VALUE * const VALUE *
rb_ujit_count_side_exit_op(const VALUE *exit_pc) rb_yjit_count_side_exit_op(const VALUE *exit_pc)
{ {
int insn = rb_vm_insn_addr2opcode((const void *)*exit_pc); int insn = rb_vm_insn_addr2opcode((const void *)*exit_pc);
exit_op_count[insn]++; exit_op_count[insn]++;
@ -657,31 +657,31 @@ print_insn_count_buffer(const struct insn_count *buffer, int how_many, int left_
__attribute__((destructor)) __attribute__((destructor))
static void static void
print_ujit_stats(void) print_yjit_stats(void)
{ {
if (!rb_ujit_opts.gen_stats) return; if (!rb_yjit_opts.gen_stats) return;
const struct insn_count *sorted_exit_ops = sort_insn_count_array(exit_op_count); const struct insn_count *sorted_exit_ops = sort_insn_count_array(exit_op_count);
double total_insns_count = vm_insns_count + ujit_runtime_counters.exec_instruction; double total_insns_count = vm_insns_count + yjit_runtime_counters.exec_instruction;
double ratio = ujit_runtime_counters.exec_instruction / total_insns_count; double ratio = yjit_runtime_counters.exec_instruction / total_insns_count;
fprintf(stderr, "compiled_iseq_count: %10" PRId64 "\n", rb_compiled_iseq_count); fprintf(stderr, "compiled_iseq_count: %10" PRId64 "\n", rb_compiled_iseq_count);
fprintf(stderr, "main_block_code_size: %6.1f MiB\n", ((double)cb->write_pos) / 1048576.0); fprintf(stderr, "main_block_code_size: %6.1f MiB\n", ((double)cb->write_pos) / 1048576.0);
fprintf(stderr, "side_block_code_size: %6.1f MiB\n", ((double)ocb->write_pos) / 1048576.0); fprintf(stderr, "side_block_code_size: %6.1f MiB\n", ((double)ocb->write_pos) / 1048576.0);
fprintf(stderr, "vm_insns_count: %10" PRId64 "\n", vm_insns_count); fprintf(stderr, "vm_insns_count: %10" PRId64 "\n", vm_insns_count);
fprintf(stderr, "ujit_exec_insns_count: %10" PRId64 "\n", ujit_runtime_counters.exec_instruction); fprintf(stderr, "yjit_exec_insns_count: %10" PRId64 "\n", yjit_runtime_counters.exec_instruction);
fprintf(stderr, "ratio_in_ujit: %9.1f%%\n", ratio * 100); fprintf(stderr, "ratio_in_yjit: %9.1f%%\n", ratio * 100);
print_insn_count_buffer(sorted_exit_ops, 10, 4); print_insn_count_buffer(sorted_exit_ops, 10, 4);
//print_runtime_counters(); //print_runtime_counters();
} }
#endif // if RUBY_DEBUG #endif // if RUBY_DEBUG
void void
rb_ujit_iseq_mark(const struct rb_iseq_constant_body *body) rb_yjit_iseq_mark(const struct rb_iseq_constant_body *body)
{ {
rb_darray_for(body->ujit_blocks, version_array_idx) { rb_darray_for(body->yjit_blocks, version_array_idx) {
rb_ujit_block_array_t version_array = rb_darray_get(body->ujit_blocks, version_array_idx); rb_yjit_block_array_t version_array = rb_darray_get(body->yjit_blocks, version_array_idx);
rb_darray_for(version_array, block_idx) { rb_darray_for(version_array, block_idx) {
block_t *block = rb_darray_get(version_array, block_idx); block_t *block = rb_darray_get(version_array, block_idx);
@ -705,10 +705,10 @@ rb_ujit_iseq_mark(const struct rb_iseq_constant_body *body)
} }
void void
rb_ujit_iseq_update_references(const struct rb_iseq_constant_body *body) rb_yjit_iseq_update_references(const struct rb_iseq_constant_body *body)
{ {
rb_darray_for(body->ujit_blocks, version_array_idx) { rb_darray_for(body->yjit_blocks, version_array_idx) {
rb_ujit_block_array_t version_array = rb_darray_get(body->ujit_blocks, version_array_idx); rb_yjit_block_array_t version_array = rb_darray_get(body->yjit_blocks, version_array_idx);
rb_darray_for(version_array, block_idx) { rb_darray_for(version_array, block_idx) {
block_t *block = rb_darray_get(version_array, block_idx); block_t *block = rb_darray_get(version_array, block_idx);
@ -736,83 +736,83 @@ rb_ujit_iseq_update_references(const struct rb_iseq_constant_body *body)
} }
} }
// Free the yjit resources associated with an iseq
void void
rb_ujit_iseq_free(const struct rb_iseq_constant_body *body) rb_yjit_iseq_free(const struct rb_iseq_constant_body *body)
{ {
rb_darray_for(body->ujit_blocks, version_array_idx) { rb_darray_for(body->yjit_blocks, version_array_idx) {
rb_ujit_block_array_t version_array = rb_darray_get(body->ujit_blocks, version_array_idx); rb_yjit_block_array_t version_array = rb_darray_get(body->yjit_blocks, version_array_idx);
rb_darray_for(version_array, block_idx) { rb_darray_for(version_array, block_idx) {
block_t *block = rb_darray_get(version_array, block_idx); block_t *block = rb_darray_get(version_array, block_idx);
ujit_free_block(block); yjit_free_block(block);
} }
rb_darray_free(version_array); rb_darray_free(version_array);
} }
rb_darray_free(body->ujit_blocks); rb_darray_free(body->yjit_blocks);
} }
bool rb_ujit_enabled_p(void) bool rb_yjit_enabled_p(void)
{ {
return rb_ujit_opts.ujit_enabled; return rb_yjit_opts.yjit_enabled;
} }
unsigned rb_ujit_call_threshold(void) unsigned rb_yjit_call_threshold(void)
{ {
return rb_ujit_opts.call_threshold; return rb_yjit_opts.call_threshold;
} }
void void
rb_ujit_init(struct rb_ujit_options *options) rb_yjit_init(struct rb_yjit_options *options)
{ {
if (!ujit_scrape_successful || !PLATFORM_SUPPORTED_P) if (!yjit_scrape_successful || !PLATFORM_SUPPORTED_P)
{ {
return; return;
} }
rb_ujit_opts = *options; rb_yjit_opts = *options;
rb_ujit_opts.ujit_enabled = true; rb_yjit_opts.yjit_enabled = true;
// Normalize options // Normalize options
if (rb_ujit_opts.call_threshold < 1) { if (rb_yjit_opts.call_threshold < 1) {
rb_ujit_opts.call_threshold = 2; rb_yjit_opts.call_threshold = 2;
} }
blocks_assuming_stable_global_constant_state = st_init_numtable(); blocks_assuming_stable_global_constant_state = st_init_numtable();
blocks_assuming_single_ractor_mode = st_init_numtable(); blocks_assuming_single_ractor_mode = st_init_numtable();
ujit_init_core(); yjit_init_core();
ujit_init_codegen(); yjit_init_codegen();
// UJIT Ruby module // YJIT Ruby module
mUjit = rb_define_module("UJIT"); mYjit = rb_define_module("YJIT");
rb_define_module_function(mUjit, "install_entry", ujit_install_entry, 1); rb_define_module_function(mYjit, "blocks_for", yjit_blocks_for, 1);
rb_define_module_function(mUjit, "blocks_for", ujit_blocks_for, 1);
// UJIT::Block (block version, code block) // YJIT::Block (block version, code block)
cUjitBlock = rb_define_class_under(mUjit, "Block", rb_cObject); cYjitBlock = rb_define_class_under(mYjit, "Block", rb_cObject);
rb_define_method(cUjitBlock, "address", block_address, 0); rb_define_method(cYjitBlock, "address", block_address, 0);
rb_define_method(cUjitBlock, "code", block_code, 0); rb_define_method(cYjitBlock, "code", block_code, 0);
rb_define_method(cUjitBlock, "iseq_start_index", iseq_start_index, 0); rb_define_method(cYjitBlock, "iseq_start_index", iseq_start_index, 0);
rb_define_method(cUjitBlock, "iseq_end_index", iseq_end_index, 0); rb_define_method(cYjitBlock, "iseq_end_index", iseq_end_index, 0);
// UJIT disassembler interface // YJIT disassembler interface
#if HAVE_LIBCAPSTONE #if HAVE_LIBCAPSTONE
cUjitDisasm = rb_define_class_under(mUjit, "Disasm", rb_cObject); cYjitDisasm = rb_define_class_under(mYjit, "Disasm", rb_cObject);
rb_define_alloc_func(cUjitDisasm, ujit_disasm_init); rb_define_alloc_func(cYjitDisasm, yjit_disasm_init);
rb_define_method(cUjitDisasm, "disasm", ujit_disasm, 2); rb_define_method(cYjitDisasm, "disasm", yjit_disasm, 2);
cUjitDisasmInsn = rb_struct_define_under(cUjitDisasm, "Insn", "address", "mnemonic", "op_str", NULL); cYjitDisasmInsn = rb_struct_define_under(cYjitDisasm, "Insn", "address", "mnemonic", "op_str", NULL);
#endif #endif
if (RUBY_DEBUG && rb_ujit_opts.gen_stats) { if (RUBY_DEBUG && rb_yjit_opts.gen_stats) {
// Setup at_exit callback for printing out counters // Setup at_exit callback for printing out counters
rb_block_call(rb_mKernel, rb_intern("at_exit"), 0, NULL, at_exit_print_stats, Qfalse); rb_block_call(rb_mKernel, rb_intern("at_exit"), 0, NULL, at_exit_print_stats, Qfalse);
} }
// 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 yjit_root_struct *root;
VALUE ujit_root = TypedData_Make_Struct(0, struct ujit_root_struct, &ujit_root_type, root); VALUE yjit_root = TypedData_Make_Struct(0, struct yjit_root_struct, &yjit_root_type, root);
rb_gc_register_mark_object(ujit_root); rb_gc_register_mark_object(yjit_root);
} }

30
ujit_iface.h → yjit_iface.h
View file

@ -1,10 +1,10 @@
// //
// These are definitions uJIT uses to interface with the CRuby codebase, // These are definitions YJIT uses to interface with the CRuby codebase,
// but which are only used internally by uJIT. // but which are only used internally by YJIT.
// //
#ifndef UJIT_IFACE_H #ifndef YJIT_IFACE_H
#define UJIT_IFACE_H 1 #define YJIT_IFACE_H 1
#include "stddef.h" #include "stddef.h"
#include "stdint.h" #include "stdint.h"
@ -14,19 +14,19 @@
#include "vm_core.h" #include "vm_core.h"
#include "vm_callinfo.h" #include "vm_callinfo.h"
#include "builtin.h" #include "builtin.h"
#include "ujit_core.h" #include "yjit_core.h"
#ifndef rb_callcache #ifndef rb_callcache
struct rb_callcache; struct rb_callcache;
#define rb_callcache rb_callcache #define rb_callcache rb_callcache
#endif #endif
#define UJIT_DECLARE_COUNTERS(...) struct rb_ujit_runtime_counters { \ #define YJIT_DECLARE_COUNTERS(...) struct rb_yjit_runtime_counters { \
int64_t __VA_ARGS__; \ int64_t __VA_ARGS__; \
}; \ }; \
static char ujit_counter_names[] = #__VA_ARGS__; static char yjit_counter_names[] = #__VA_ARGS__;
UJIT_DECLARE_COUNTERS( YJIT_DECLARE_COUNTERS(
exec_instruction, exec_instruction,
oswb_callsite_not_simple, oswb_callsite_not_simple,
@ -62,11 +62,11 @@ UJIT_DECLARE_COUNTERS(
last_member last_member
) )
#undef UJIT_DECLARE_COUNTERS #undef YJIT_DECLARE_COUNTERS
RUBY_EXTERN struct rb_ujit_options rb_ujit_opts; RUBY_EXTERN struct rb_yjit_options rb_yjit_opts;
RUBY_EXTERN int64_t rb_compiled_iseq_count; RUBY_EXTERN int64_t rb_compiled_iseq_count;
RUBY_EXTERN struct rb_ujit_runtime_counters ujit_runtime_counters; RUBY_EXTERN struct rb_yjit_runtime_counters yjit_runtime_counters;
void cb_write_pre_call_bytes(codeblock_t* cb); void cb_write_pre_call_bytes(codeblock_t* cb);
void cb_write_post_call_bytes(codeblock_t* cb); void cb_write_post_call_bytes(codeblock_t* cb);
@ -83,9 +83,9 @@ RBIMPL_ATTR_NODISCARD() bool assume_single_ractor_mode(block_t *block);
RBIMPL_ATTR_NODISCARD() bool assume_stable_global_constant_state(block_t *block); RBIMPL_ATTR_NODISCARD() bool assume_stable_global_constant_state(block_t *block);
// this function *must* return passed exit_pc // this function *must* return passed exit_pc
const VALUE *rb_ujit_count_side_exit_op(const VALUE *exit_pc); const VALUE *rb_yjit_count_side_exit_op(const VALUE *exit_pc);
void ujit_unlink_method_lookup_dependency(block_t *block); void yjit_unlink_method_lookup_dependency(block_t *block);
void ujit_block_assumptions_free(block_t *block); void yjit_block_assumptions_free(block_t *block);
#endif // #ifndef UJIT_IFACE_H #endif // #ifndef YJIT_IFACE_

4
ujit_utils.c → yjit_utils.c
View file

@ -1,8 +1,8 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
#include "ujit_utils.h" #include "yjit_utils.h"
#include "ujit_asm.h" #include "yjit_asm.h"
// Save caller-save registers on the stack before a C call // Save caller-save registers on the stack before a C call
void push_regs(codeblock_t* cb) void push_regs(codeblock_t* cb)

8
ujit_utils.h → yjit_utils.h
View file

@ -1,10 +1,10 @@
#ifndef UJIT_UTILS_H #ifndef YJIT_UTILS_H
#define UJIT_UTILS_H 1 #define YJIT_UTILS_H 1
#include <stdint.h> #include <stdint.h>
#include <stddef.h> #include <stddef.h>
#include <stdbool.h> #include <stdbool.h>
#include "ujit_asm.h" #include "yjit_asm.h"
void push_regs(codeblock_t* cb); void push_regs(codeblock_t* cb);
void pop_regs(codeblock_t* cb); void pop_regs(codeblock_t* cb);
@ -12,4 +12,4 @@ void print_int(codeblock_t* cb, x86opnd_t opnd);
void print_ptr(codeblock_t* cb, x86opnd_t opnd); void print_ptr(codeblock_t* cb, x86opnd_t opnd);
void print_str(codeblock_t* cb, const char* str); void print_str(codeblock_t* cb, const char* str);
#endif // #ifndef UJIT_UTILS_H #endif // #ifndef YJIT_UTILS_H