debase-ruby_core_source 3.3.6 → 3.4.1

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p-1}/vm_core.h

@@ -70,7 +70,30 @@
 #define RUBY_ASSERT_MUTEX_OWNED(mutex) VM_ASSERT(rb_mutex_owned_p(mutex))
 
 #if defined(RUBY_ASSERT_CRITICAL_SECTION)
-// TODO add documentation
+/*
+# Critical Section Assertions
+
+These assertions are used to ensure that context switching does not occur between two points in the code. In theory,
+such code should already be protected by a mutex, but these assertions are used to ensure that the mutex is held.
+
+The specific case where it can be useful is where a mutex is held further up the call stack, and the code in question
+may not directly hold the mutex. In this case, the critical section assertions can be used to ensure that the mutex is
+held by someone else.
+
+These assertions are only enabled when RUBY_ASSERT_CRITICAL_SECTION is defined, which is only defined if VM_CHECK_MODE
+is set.
+
+## Example Usage
+
+```c
+RUBY_ASSERT_CRITICAL_SECTION_ENTER();
+// ... some code which does not invoke rb_vm_check_ints() ...
+RUBY_ASSERT_CRITICAL_SECTION_LEAVE();
+```
+
+If `rb_vm_check_ints()` is called between the `RUBY_ASSERT_CRITICAL_SECTION_ENTER()` and
+`RUBY_ASSERT_CRITICAL_SECTION_LEAVE()`, a failed assertion will result.
+*/
 extern int ruby_assert_critical_section_entered;
 #define RUBY_ASSERT_CRITICAL_SECTION_ENTER() do{ruby_assert_critical_section_entered += 1;}while(false)
 #define RUBY_ASSERT_CRITICAL_SECTION_LEAVE() do{VM_ASSERT(ruby_assert_critical_section_entered > 0);ruby_assert_critical_section_entered -= 1;}while(false)
@@ -230,6 +253,8 @@ union ic_serial_entry {
     VALUE data[2];
 };
 
+#define IMEMO_CONST_CACHE_SHAREABLE IMEMO_FL_USER0
+
 // imemo_constcache
 struct iseq_inline_constant_cache_entry {
     VALUE flags;
@@ -370,6 +395,8 @@ enum rb_builtin_attr {
     BUILTIN_ATTR_SINGLE_NOARG_LEAF = 0x02,
     // This attribute signals JIT to duplicate the iseq for each block iseq so that its `yield` will be monomorphic.
     BUILTIN_ATTR_INLINE_BLOCK = 0x04,
+    // The iseq acts like a C method in backtraces.
+    BUILTIN_ATTR_C_TRACE = 0x08,
 };
 
 typedef VALUE (*rb_jit_func_t)(struct rb_execution_context_struct *, struct rb_control_frame_struct *);
@@ -579,6 +606,12 @@ rb_iseq_check(const rb_iseq_t *iseq)
     return iseq;
 }
 
+static inline bool
+rb_iseq_attr_p(const rb_iseq_t *iseq, enum rb_builtin_attr attr)
+{
+    return (ISEQ_BODY(iseq)->builtin_attrs & attr) == attr;
+}
+
 static inline const rb_iseq_t *
 def_iseq_ptr(rb_method_definition_t *def)
 {
@@ -766,13 +799,13 @@ typedef struct rb_vm_struct {
     struct rb_id_table *negative_cme_table;
     st_table *overloaded_cme_table; // cme -> overloaded_cme
     st_table *unused_block_warning_table;
-    bool unused_block_warning_strict;
 
     // This id table contains a mapping from ID to ICs. It does this with ID
     // keys and nested st_tables as values. The nested tables have ICs as keys
     // and Qtrue as values. It is used when inline constant caches need to be
     // invalidated or ISEQs are being freed.
     struct rb_id_table *constant_cache;
+    ID inserting_constant_cache_id;
 
 #ifndef VM_GLOBAL_CC_CACHE_TABLE_SIZE
 #define VM_GLOBAL_CC_CACHE_TABLE_SIZE 1023
@@ -1124,6 +1157,7 @@ typedef struct rb_thread_struct {
     struct rb_unblock_callback unblock;
     VALUE locking_mutex;
     struct rb_mutex_struct *keeping_mutexes;
+    struct ccan_list_head interrupt_exec_tasks;
 
     struct rb_waiting_list *join_list;
 
@@ -1280,6 +1314,7 @@ enum vm_opt_newarray_send_type {
     VM_OPT_NEWARRAY_SEND_HASH = 3,
     VM_OPT_NEWARRAY_SEND_PACK = 4,
     VM_OPT_NEWARRAY_SEND_PACK_BUFFER = 5,
+    VM_OPT_NEWARRAY_SEND_INCLUDE_P = 6,
 };
 
 enum vm_special_object_type {
@@ -1487,22 +1522,13 @@ VM_ENV_ESCAPED_P(const VALUE *ep)
     return VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED) ? 1 : 0;
 }
 
-#if VM_CHECK_MODE > 0
-static inline int
-vm_assert_env(VALUE obj)
-{
-    VM_ASSERT(imemo_type_p(obj, imemo_env));
-    return 1;
-}
-#endif
-
 RBIMPL_ATTR_NONNULL((1))
 static inline VALUE
 VM_ENV_ENVVAL(const VALUE *ep)
 {
     VALUE envval = ep[VM_ENV_DATA_INDEX_ENV];
     VM_ASSERT(VM_ENV_ESCAPED_P(ep));
-    VM_ASSERT(vm_assert_env(envval));
+    VM_ASSERT(envval == Qundef || imemo_type_p(envval, imemo_env));
     return envval;
 }
 
@@ -1945,6 +1971,8 @@ rb_ec_vm_ptr(const rb_execution_context_t *ec)
     }
 }
 
+NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void));
+
 static inline rb_execution_context_t *
 rb_current_execution_context(bool expect_ec)
 {

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p-1}/vm_sync.h

@@ -21,9 +21,9 @@ 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(unsigned int *lev APPEND_LOCATION_ARGS);
 void rb_vm_barrier(void);
 

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p-1}/vmtc.inc

@@ -100,6 +100,7 @@ static const void *const insns_address_table[] = {
     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),
@@ -209,6 +210,7 @@ static const void *const insns_address_table[] = {
     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),

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-p-1}/yjit.h

@@ -37,6 +37,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 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);

data/lib/debase/ruby_core_source/version.rb

@@ -1,5 +1,5 @@
 module Debase
   module RubyCoreSource
-    VERSION = '3.3.6'
+    VERSION = '3.4.1'
   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