debase-ruby_core_source 3.3.6 → 4.0.0.preview2

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview2 → ruby-4.0.0-preview2}/vm_exec.h

@@ -175,11 +175,22 @@ default:                        \
 
 // Run the JIT from the interpreter
 #define JIT_EXEC(ec, val) do { \
-    rb_jit_func_t func; \
     /* don't run tailcalls since that breaks FINISH */ \
-    if (UNDEF_P(val) && GET_CFP() != ec->cfp && (func = jit_compile(ec))) { \
-        val = func(ec, ec->cfp); \
-        if (ec->tag->state) THROW_EXCEPTION(val); \
+    if (UNDEF_P(val) && GET_CFP() != ec->cfp) { \
+        rb_zjit_func_t zjit_entry; \
+        if (rb_yjit_enabled_p) { \
+            rb_jit_func_t func = yjit_compile(ec); \
+            if (func) { \
+                val = func(ec, ec->cfp); \
+                if (ec->tag->state) THROW_EXCEPTION(val); \
+            } \
+        } \
+        else if ((zjit_entry = rb_zjit_entry)) { \
+            rb_jit_func_t func = zjit_compile(ec); \
+            if (func) { \
+                val = zjit_entry(ec, ec->cfp, func); \
+            } \
+        } \
     } \
 } while (0)
 

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/vm_insnhelper.h

@@ -16,11 +16,11 @@ RUBY_EXTERN rb_serial_t ruby_vm_constant_cache_invalidations;
 RUBY_EXTERN rb_serial_t ruby_vm_constant_cache_misses;
 RUBY_EXTERN rb_serial_t ruby_vm_global_cvar_state;
 
-#if USE_YJIT || USE_RJIT // We want vm_insns_count on any JIT-enabled build.
-// Increment vm_insns_count for --yjit-stats. We increment this even when
+#if YJIT_STATS || ZJIT_STATS // We want vm_insn_count only on stats builds.
+// Increment vm_insn_count for --yjit-stats. We increment this even when
 // --yjit or --yjit-stats is not used because branching to skip it is slower.
 // We also don't use ATOMIC_INC for performance, allowing inaccuracy on Ractors.
-#define JIT_COLLECT_USAGE_INSN(insn) rb_vm_insns_count++
+#define JIT_COLLECT_USAGE_INSN(insn) rb_vm_insn_count++
 #else
 #define JIT_COLLECT_USAGE_INSN(insn) // none
 #endif
@@ -66,6 +66,11 @@ typedef enum call_type {
     CALL_FCALL_KW
 } call_type;
 
+struct rb_forwarding_call_data {
+    struct rb_call_data cd;
+    CALL_INFO caller_ci;
+};
+
 #if VM_COLLECT_USAGE_DETAILS
 enum vm_regan_regtype {
     VM_REGAN_PC = 0,
@@ -139,7 +144,7 @@ CC_SET_FASTPATH(const struct rb_callcache *cc, vm_call_handler func, bool enable
     }
 }
 
-#define GET_BLOCK_HANDLER() (GET_LEP()[VM_ENV_DATA_INDEX_SPECVAL])
+#define GET_BLOCK_HANDLER() VM_CF_BLOCK_HANDLER(GET_CFP())
 
 /**********************************************************/
 /* deal with control flow 3: exception                    */
@@ -258,8 +263,8 @@ THROW_DATA_CONSUMED_SET(struct vm_throw_data *obj)
 static inline bool
 vm_call_cacheable(const struct rb_callinfo *ci, const struct rb_callcache *cc)
 {
-    return (vm_ci_flag(ci) & VM_CALL_FCALL) ||
-        METHOD_ENTRY_VISI(vm_cc_cme(cc)) != METHOD_VISI_PROTECTED;
+    return !(vm_ci_flag(ci) & VM_CALL_FORWARDING) && ((vm_ci_flag(ci) & VM_CALL_FCALL) ||
+        METHOD_ENTRY_VISI(vm_cc_cme(cc)) != METHOD_VISI_PROTECTED);
 }
 /* If this returns true, an optimized function returned by `vm_call_iseq_setup_func`
    can be used as a fastpath. */

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/vm_sync.h

@@ -21,9 +21,10 @@ void rb_vm_lock_body(LOCATION_ARGS);
 void rb_vm_unlock_body(LOCATION_ARGS);
 
 struct rb_ractor_struct;
-void rb_vm_lock_enter_body_cr(struct rb_ractor_struct *cr, unsigned int *lev APPEND_LOCATION_ARGS);
-void rb_vm_lock_enter_body_nb(unsigned int *lev APPEND_LOCATION_ARGS);
-void rb_vm_lock_enter_body(unsigned int *lev APPEND_LOCATION_ARGS);
+NOINLINE(void rb_vm_lock_enter_body_cr(struct rb_ractor_struct *cr, unsigned int *lev APPEND_LOCATION_ARGS));
+NOINLINE(void rb_vm_lock_enter_body_nb(unsigned int *lev APPEND_LOCATION_ARGS));
+NOINLINE(void rb_vm_lock_enter_body(unsigned int *lev APPEND_LOCATION_ARGS));
+void rb_vm_lock_leave_body_nb(unsigned int *lev APPEND_LOCATION_ARGS);
 void rb_vm_lock_leave_body(unsigned int *lev APPEND_LOCATION_ARGS);
 void rb_vm_barrier(void);
 
@@ -86,6 +87,14 @@ rb_vm_lock_enter_nb(unsigned int *lev, const char *file, int line)
     }
 }
 
+static inline void
+rb_vm_lock_leave_nb(unsigned int *lev, const char *file, int line)
+{
+    if (rb_multi_ractor_p()) {
+        rb_vm_lock_leave_body_nb(lev APPEND_LOCATION_PARAMS);
+    }
+}
+
 static inline void
 rb_vm_lock_leave(unsigned int *lev, const char *file, int line)
 {
@@ -119,18 +128,28 @@ rb_vm_lock_leave_cr(struct rb_ractor_struct *cr, unsigned int *levp, const char
 
 #define RB_VM_LOCK_ENTER()  { unsigned int _lev; RB_VM_LOCK_ENTER_LEV(&_lev);
 #define RB_VM_LOCK_LEAVE()    RB_VM_LOCK_LEAVE_LEV(&_lev); }
+#define RB_VM_LOCKING() \
+    for (unsigned int vm_locking_level, vm_locking_do = (RB_VM_LOCK_ENTER_LEV(&vm_locking_level), 1); \
+         vm_locking_do; RB_VM_LOCK_LEAVE_LEV(&vm_locking_level), vm_locking_do = 0)
 
 #define RB_VM_LOCK_ENTER_LEV_NB(levp) rb_vm_lock_enter_nb(levp, __FILE__, __LINE__)
+#define RB_VM_LOCK_LEAVE_LEV_NB(levp) rb_vm_lock_leave_nb(levp, __FILE__, __LINE__)
 #define RB_VM_LOCK_ENTER_NO_BARRIER()  { unsigned int _lev; RB_VM_LOCK_ENTER_LEV_NB(&_lev);
-#define RB_VM_LOCK_LEAVE_NO_BARRIER()    RB_VM_LOCK_LEAVE_LEV(&_lev); }
+#define RB_VM_LOCK_LEAVE_NO_BARRIER()    RB_VM_LOCK_LEAVE_LEV_NB(&_lev); }
+#define RB_VM_LOCKING_NO_BARRIER() \
+    for (unsigned int vm_locking_level, vm_locking_do = (RB_VM_LOCK_ENTER_LEV_NB(&vm_locking_level), 1); \
+         vm_locking_do; RB_VM_LOCK_LEAVE_LEV_NB(&vm_locking_level), vm_locking_do = 0)
 
 #if RUBY_DEBUG > 0
 void RUBY_ASSERT_vm_locking(void);
+void RUBY_ASSERT_vm_locking_with_barrier(void);
 void RUBY_ASSERT_vm_unlocking(void);
 #define ASSERT_vm_locking() RUBY_ASSERT_vm_locking()
+#define ASSERT_vm_locking_with_barrier() RUBY_ASSERT_vm_locking_with_barrier()
 #define ASSERT_vm_unlocking() RUBY_ASSERT_vm_unlocking()
 #else
 #define ASSERT_vm_locking()
+#define ASSERT_vm_locking_with_barrier()
 #define ASSERT_vm_unlocking()
 #endif
 

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/vmtc.inc

@@ -64,7 +64,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(toregexp),
     LABEL_PTR(intern),
     LABEL_PTR(newarray),
-    LABEL_PTR(newarraykwsplat),
     LABEL_PTR(pushtoarraykwsplat),
     LABEL_PTR(duparray),
     LABEL_PTR(duphash),
@@ -93,13 +92,19 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(definemethod),
     LABEL_PTR(definesmethod),
     LABEL_PTR(send),
+    LABEL_PTR(sendforward),
     LABEL_PTR(opt_send_without_block),
+    LABEL_PTR(opt_new),
     LABEL_PTR(objtostring),
+    LABEL_PTR(opt_ary_freeze),
+    LABEL_PTR(opt_hash_freeze),
     LABEL_PTR(opt_str_freeze),
     LABEL_PTR(opt_nil_p),
     LABEL_PTR(opt_str_uminus),
+    LABEL_PTR(opt_duparray_send),
     LABEL_PTR(opt_newarray_send),
     LABEL_PTR(invokesuper),
+    LABEL_PTR(invokesuperforward),
     LABEL_PTR(invokeblock),
     LABEL_PTR(leave),
     LABEL_PTR(throw),
@@ -125,8 +130,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(opt_or),
     LABEL_PTR(opt_aref),
     LABEL_PTR(opt_aset),
-    LABEL_PTR(opt_aset_with),
-    LABEL_PTR(opt_aref_with),
     LABEL_PTR(opt_length),
     LABEL_PTR(opt_size),
     LABEL_PTR(opt_empty_p),
@@ -170,7 +173,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_toregexp),
     LABEL_PTR(trace_intern),
     LABEL_PTR(trace_newarray),
-    LABEL_PTR(trace_newarraykwsplat),
     LABEL_PTR(trace_pushtoarraykwsplat),
     LABEL_PTR(trace_duparray),
     LABEL_PTR(trace_duphash),
@@ -199,13 +201,19 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_definemethod),
     LABEL_PTR(trace_definesmethod),
     LABEL_PTR(trace_send),
+    LABEL_PTR(trace_sendforward),
     LABEL_PTR(trace_opt_send_without_block),
+    LABEL_PTR(trace_opt_new),
     LABEL_PTR(trace_objtostring),
+    LABEL_PTR(trace_opt_ary_freeze),
+    LABEL_PTR(trace_opt_hash_freeze),
     LABEL_PTR(trace_opt_str_freeze),
     LABEL_PTR(trace_opt_nil_p),
     LABEL_PTR(trace_opt_str_uminus),
+    LABEL_PTR(trace_opt_duparray_send),
     LABEL_PTR(trace_opt_newarray_send),
     LABEL_PTR(trace_invokesuper),
+    LABEL_PTR(trace_invokesuperforward),
     LABEL_PTR(trace_invokeblock),
     LABEL_PTR(trace_leave),
     LABEL_PTR(trace_throw),
@@ -231,8 +239,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_opt_or),
     LABEL_PTR(trace_opt_aref),
     LABEL_PTR(trace_opt_aset),
-    LABEL_PTR(trace_opt_aset_with),
-    LABEL_PTR(trace_opt_aref_with),
     LABEL_PTR(trace_opt_length),
     LABEL_PTR(trace_opt_size),
     LABEL_PTR(trace_opt_empty_p),
@@ -248,6 +254,36 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_setlocal_WC_1),
     LABEL_PTR(trace_putobject_INT2FIX_0_),
     LABEL_PTR(trace_putobject_INT2FIX_1_),
+#if USE_ZJIT
+    LABEL_PTR(zjit_getinstancevariable),
+    LABEL_PTR(zjit_send),
+    LABEL_PTR(zjit_opt_send_without_block),
+    LABEL_PTR(zjit_objtostring),
+    LABEL_PTR(zjit_opt_nil_p),
+    LABEL_PTR(zjit_invokeblock),
+    LABEL_PTR(zjit_opt_plus),
+    LABEL_PTR(zjit_opt_minus),
+    LABEL_PTR(zjit_opt_mult),
+    LABEL_PTR(zjit_opt_div),
+    LABEL_PTR(zjit_opt_mod),
+    LABEL_PTR(zjit_opt_eq),
+    LABEL_PTR(zjit_opt_neq),
+    LABEL_PTR(zjit_opt_lt),
+    LABEL_PTR(zjit_opt_le),
+    LABEL_PTR(zjit_opt_gt),
+    LABEL_PTR(zjit_opt_ge),
+    LABEL_PTR(zjit_opt_ltlt),
+    LABEL_PTR(zjit_opt_and),
+    LABEL_PTR(zjit_opt_or),
+    LABEL_PTR(zjit_opt_aref),
+    LABEL_PTR(zjit_opt_aset),
+    LABEL_PTR(zjit_opt_length),
+    LABEL_PTR(zjit_opt_size),
+    LABEL_PTR(zjit_opt_empty_p),
+    LABEL_PTR(zjit_opt_succ),
+    LABEL_PTR(zjit_opt_not),
+    LABEL_PTR(zjit_opt_regexpmatch2),
+#endif
 };
 
 ASSERT_VM_INSTRUCTION_SIZE(insns_address_table);

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview2 → ruby-4.0.0-preview2}/yjit.h

@@ -9,10 +9,9 @@
 #include "vm_core.h"
 #include "method.h"
 
-// YJIT_STATS controls whether to support runtime counters in generated code
-// and in the interpreter.
+// YJIT_STATS controls whether to support runtime counters in the interpreter
 #ifndef YJIT_STATS
-# define YJIT_STATS RUBY_DEBUG
+# define YJIT_STATS (USE_YJIT && RUBY_DEBUG)
 #endif
 
 #if USE_YJIT
@@ -37,6 +36,7 @@ void rb_yjit_collect_binding_alloc(void);
 void rb_yjit_collect_binding_set(void);
 void rb_yjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec, bool jit_exception);
 void rb_yjit_init(bool yjit_enabled);
+void rb_yjit_free_at_exit(void);
 void rb_yjit_bop_redefined(int redefined_flag, enum ruby_basic_operators bop);
 void rb_yjit_constant_state_changed(ID id);
 void rb_yjit_iseq_mark(void *payload);
@@ -49,6 +49,8 @@ void rb_yjit_show_usage(int help, int highlight, unsigned int width, int columns
 void rb_yjit_lazy_push_frame(const VALUE *pc);
 void rb_yjit_invalidate_no_singleton_class(VALUE klass);
 void rb_yjit_invalidate_ep_is_bp(const rb_iseq_t *iseq);
+void rb_yjit_mark_all_writeable(void);
+void rb_yjit_mark_all_executable(void);
 
 #else
 // !USE_YJIT

data/lib/debase/ruby_core_source/ruby-4.0.0-preview2/zjit.h

@@ -0,0 +1,47 @@
+#ifndef ZJIT_H
+#define ZJIT_H 1
+//
+// This file contains definitions ZJIT exposes to the CRuby codebase
+//
+
+// ZJIT_STATS controls whether to support runtime counters in the interpreter
+#ifndef ZJIT_STATS
+# define ZJIT_STATS (USE_ZJIT && RUBY_DEBUG)
+#endif
+
+#if USE_ZJIT
+extern void *rb_zjit_entry;
+extern uint64_t rb_zjit_call_threshold;
+extern uint64_t rb_zjit_profile_threshold;
+void rb_zjit_compile_iseq(const rb_iseq_t *iseq, bool jit_exception);
+void rb_zjit_profile_insn(uint32_t insn, rb_execution_context_t *ec);
+void rb_zjit_profile_enable(const rb_iseq_t *iseq);
+void rb_zjit_bop_redefined(int redefined_flag, enum ruby_basic_operators bop);
+void rb_zjit_cme_invalidate(const rb_callable_method_entry_t *cme);
+void rb_zjit_cme_free(const rb_callable_method_entry_t *cme);
+void rb_zjit_klass_free(VALUE klass);
+void rb_zjit_invalidate_no_ep_escape(const rb_iseq_t *iseq);
+void rb_zjit_constant_state_changed(ID id);
+void rb_zjit_iseq_mark(void *payload);
+void rb_zjit_iseq_update_references(void *payload);
+void rb_zjit_iseq_free(const rb_iseq_t *iseq);
+void rb_zjit_before_ractor_spawn(void);
+void rb_zjit_tracing_invalidate_all(void);
+void rb_zjit_invalidate_no_singleton_class(VALUE klass);
+#else
+#define rb_zjit_entry 0
+static inline void rb_zjit_compile_iseq(const rb_iseq_t *iseq, bool jit_exception) {}
+static inline void rb_zjit_profile_insn(uint32_t insn, rb_execution_context_t *ec) {}
+static inline void rb_zjit_profile_enable(const rb_iseq_t *iseq) {}
+static inline void rb_zjit_bop_redefined(int redefined_flag, enum ruby_basic_operators bop) {}
+static inline void rb_zjit_cme_invalidate(const rb_callable_method_entry_t *cme) {}
+static inline void rb_zjit_invalidate_no_ep_escape(const rb_iseq_t *iseq) {}
+static inline void rb_zjit_constant_state_changed(ID id) {}
+static inline void rb_zjit_before_ractor_spawn(void) {}
+static inline void rb_zjit_tracing_invalidate_all(void) {}
+static inline void rb_zjit_invalidate_no_singleton_class(VALUE klass) {}
+#endif // #if USE_ZJIT
+
+#define rb_zjit_enabled_p (rb_zjit_entry != 0)
+
+#endif // #ifndef ZJIT_H

data/lib/debase/ruby_core_source/version.rb

@@ -1,5 +1,5 @@
 module Debase
   module RubyCoreSource
-    VERSION = '3.3.6'
+    VERSION = '4.0.0.preview2'
   end
 end

data/lib/debase/ruby_core_source.rb

@@ -3,6 +3,8 @@ require 'rbconfig'
 
 module Debase
   module RubyCoreSource
+    MOCK_RUBY_VERSION_KEY = "MOCK_RUBY_VERSION"
+
     REVISION_MAP = {
         # Add pre-release version here since they do not have patchlevel to refer to.
         # Revision can be found at `revision.h` of ruby sources.
@@ -54,7 +56,7 @@ module Debase
         expected_directory
       else
         # Fallback to an older version.
-        ruby_version = Gem::Version.new(RUBY_VERSION)
+        ruby_version = Gem::Version.new(ENV[MOCK_RUBY_VERSION_KEY] || RUBY_VERSION)
         path, = Dir.glob(prefix + 'ruby-*').
           select { |d| File.directory?(d) }.
           map { |d| [d, ruby_source_dir_version(d)] }.
@@ -68,7 +70,7 @@ module Debase
     end
 
     def self.ruby_source_dir_version(dir)
-      match = /ruby-([0-9\.]+)-((p|rc|preview)[0-9]+)\z/.match(dir)
+      match = /ruby-([0-9\.]+)-((p|rc|preview)-?[0-9]+)\z/.match(dir)
       Gem::Version.new("#{match[1]}.#{match[2]}")
     end
 

data/test/deduce_source_dir_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+DIR_NAME = File.dirname(__FILE__)
+$:.unshift File.join(DIR_NAME, "..", "lib")
+
+require 'test/unit'
+require 'debase/ruby_core_source'
+
+class DeduceSourceDirTest < Test::Unit::TestCase
+
+  def test_deduce_source_dir
+    version_to_answer = {
+      "3.4.1" => "ruby-3.4.0-p-1",
+      "3.4.0" => "ruby-3.4.0-p-1",
+      "3.3.6" => "ruby-3.3.5-p100",
+      "3.3.5" => "ruby-3.3.5-p100",
+      "3.3.4" => "ruby-3.3.0-p0",
+      "3.3.3" => "ruby-3.3.0-p0",
+      "3.2.6" => "ruby-3.2.0-p0",
+      "3.1.6" => "ruby-3.1.0-p0",
+      "3.0.7" => "ruby-3.0.0-p0",
+    }
+
+    version_to_answer.each do |version, answer|
+      ENV[Debase::RubyCoreSource::MOCK_RUBY_VERSION_KEY] = version
+      result = Debase::RubyCoreSource.deduce_packaged_source_dir(version)
+      deduced_source_dir_name = result.split(File::SEPARATOR).last
+      assert_equal(answer, deduced_source_dir_name)
+    end
+  end
+end