debase-ruby_core_source 0.10.18 → 3.2.1

data/lib/debase/ruby_core_source/{ruby-3.2.0-preview1 → ruby-3.3.0-preview1}/regint.h

@@ -35,12 +35,16 @@
 /* #define ONIG_DEBUG_COMPILE */
 /* #define ONIG_DEBUG_SEARCH */
 /* #define ONIG_DEBUG_MATCH */
+/* #define ONIG_DEBUG_MATCH_CACHE */
 /* #define ONIG_DEBUG_MEMLEAK */
 /* #define ONIG_DONT_OPTIMIZE */
 
 /* for byte-code statistical data. */
 /* #define ONIG_DEBUG_STATISTICS */
 
+/* enable the match optimization by using a cache. */
+#define USE_MATCH_CACHE
+
 #if defined(ONIG_DEBUG_PARSE_TREE) || defined(ONIG_DEBUG_MATCH) || \
     defined(ONIG_DEBUG_SEARCH) || defined(ONIG_DEBUG_COMPILE) || \
     defined(ONIG_DEBUG_STATISTICS) || defined(ONIG_DEBUG_MEMLEAK)
@@ -49,10 +53,11 @@
 # endif
 #endif
 
+/* __POWERPC__ added to accommodate Darwin case. */
 #ifndef UNALIGNED_WORD_ACCESS
 # if defined(__i386) || defined(__i386__) || defined(_M_IX86) || \
      defined(__x86_64) || defined(__x86_64__) || defined(_M_AMD64) || \
-     defined(__powerpc64__) || defined(__aarch64__) || \
+     defined(__powerpc64__) || defined(__POWERPC__) || defined(__aarch64__) || \
      defined(__mc68020__)
 #  define UNALIGNED_WORD_ACCESS 1
 # else
@@ -310,9 +315,13 @@ RUBY_SYMBOL_EXPORT_BEGIN
 
 #define ONIG_LAST_CODE_POINT    (~((OnigCodePoint )0))
 
+#define PLATFORM_GET_INC_ARGUMENTS_ASSERT(val, type) \
+  ((void)sizeof(char[2 * (sizeof(val) == sizeof(type)) - 1]))
+
 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS
 
 # define PLATFORM_GET_INC(val,p,type) do{\
+  PLATFORM_GET_INC_ARGUMENTS_ASSERT(val, type);\
   val  = *(type* )p;\
   (p) += sizeof(type);\
 } while(0)
@@ -320,7 +329,10 @@ RUBY_SYMBOL_EXPORT_BEGIN
 #else
 
 # define PLATFORM_GET_INC(val,p,type) do{\
-  xmemcpy(&val, (p), sizeof(type));\
+  PLATFORM_GET_INC_ARGUMENTS_ASSERT(val, type);\
+  type platform_get_value;\
+  xmemcpy(&platform_get_value, (p), sizeof(type));\
+  val = platform_get_value;\
   (p) += sizeof(type);\
 } while(0)
 
@@ -378,6 +390,7 @@ typedef unsigned int  BitStatusType;
 
 
 #define INT_MAX_LIMIT           ((1UL << (SIZEOF_INT * 8 - 1)) - 1)
+#define LONG_MAX_LIMIT           ((1UL << (SIZEOF_LONG * 8 - 1)) - 1)
 
 #define DIGITVAL(code)    ((code) - '0')
 #define ODIGITVAL(code)   DIGITVAL(code)
@@ -819,6 +832,7 @@ typedef intptr_t OnigStackIndex;
 
 typedef struct _OnigStackType {
   unsigned int type;
+  OnigStackIndex null_check;
   union {
     struct {
       UChar *pcode;      /* byte code position */
@@ -862,6 +876,16 @@ typedef struct _OnigStackType {
   } u;
 } OnigStackType;
 
+#ifdef USE_MATCH_CACHE
+typedef struct {
+  UChar *addr;
+  long cache_point;
+  int outer_repeat_mem;
+  long num_cache_points_at_outer_repeat;
+  long num_cache_points_in_outer_repeat;
+} OnigCacheOpcode;
+#endif
+
 typedef struct {
   void* stack_p;
   size_t stack_n;
@@ -884,8 +908,23 @@ typedef struct {
 #else
   uint64_t end_time;
 #endif
+#ifdef USE_MATCH_CACHE
+  int              match_cache_status;
+  long             num_fails;
+  long             num_cache_opcodes;
+  OnigCacheOpcode* cache_opcodes;
+  long             num_cache_points;
+  uint8_t*         match_cache_buf;
+#endif
 } OnigMatchArg;
 
+#define NUM_CACHE_OPCODES_UNINIT      1
+#define NUM_CACHE_OPCODES_IMPOSSIBLE -1
+
+#define MATCH_CACHE_STATUS_UNINIT    1
+#define MATCH_CACHE_STATUS_INIT      2
+#define MATCH_CACHE_STATUS_DISABLED -1
+#define MATCH_CACHE_STATUS_ENABLED   0
 
 #define IS_CODE_SB_WORD(enc,code) \
   (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_WORD(enc,code))

data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/revision.h

@@ -0,0 +1,5 @@
+#define RUBY_REVISION "a1b01e7701"
+#define RUBY_FULL_REVISION "a1b01e7701f9fc370f8dff777aad6d39a2c5a3e3"
+#define RUBY_RELEASE_YEAR 2023
+#define RUBY_RELEASE_MONTH 5
+#define RUBY_RELEASE_DAY 12

data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/rjit.h

@@ -0,0 +1,103 @@
+#ifndef RUBY_RJIT_H
+#define RUBY_RJIT_H 1
+/**********************************************************************
+
+  rjit.h - Interface to RJIT
+
+  Copyright (C) 2023 Takashi Kokubun <k0kubun@ruby-lang.org>.
+
+**********************************************************************/
+
+#include "ruby/internal/config.h" // defines USE_RJIT
+#include "ruby/internal/stdbool.h"
+#include "vm_core.h"
+
+# if USE_RJIT
+
+#ifndef RJIT_STATS
+# define RJIT_STATS RUBY_DEBUG
+#endif
+
+#include "ruby.h"
+#include "vm_core.h"
+
+// RJIT options which can be defined on the MRI command line.
+struct rb_rjit_options {
+    // Converted from "rjit" feature flag to tell the enablement
+    // information to ruby_show_version().
+    bool on;
+    // Number of calls to trigger JIT compilation.
+    unsigned int call_threshold;
+    // Size of executable memory block in MiB
+    unsigned int exec_mem_size;
+    // Collect RJIT statistics
+    bool stats;
+    // Trace side exit locations
+    bool trace_exits;
+    // Enable disasm of all JIT code
+    bool dump_disasm;
+    // Verify context objects
+    bool verify_ctx;
+    // [experimental] Do not start RJIT until RJIT.resume is called.
+    bool pause;
+};
+
+RUBY_SYMBOL_EXPORT_BEGIN
+RUBY_EXTERN struct rb_rjit_options rb_rjit_opts;
+RUBY_EXTERN bool rb_rjit_call_p;
+
+#define rb_rjit_call_threshold() rb_rjit_opts.call_threshold
+
+extern void rb_rjit_compile(const rb_iseq_t *iseq);
+RUBY_SYMBOL_EXPORT_END
+
+extern void rb_rjit_cancel_all(const char *reason);
+extern void rb_rjit_init(const struct rb_rjit_options *opts);
+extern void rb_rjit_free_iseq(const rb_iseq_t *iseq);
+extern void rb_rjit_iseq_update_references(struct rb_iseq_constant_body *const body);
+extern void rb_rjit_mark(void);
+extern void rb_rjit_iseq_mark(VALUE rjit_blocks);
+extern void rjit_notify_waitpid(int exit_code);
+
+extern void rb_rjit_bop_redefined(int redefined_flag, enum ruby_basic_operators bop);
+extern void rb_rjit_cme_invalidate(rb_callable_method_entry_t *cme);
+extern void rb_rjit_before_ractor_spawn(void);
+extern void rb_rjit_constant_state_changed(ID id);
+extern void rb_rjit_constant_ic_update(const rb_iseq_t *const iseq, IC ic, unsigned insn_idx);
+extern void rb_rjit_tracing_invalidate_all(rb_event_flag_t new_iseq_events);
+
+extern void rb_rjit_bop_redefined(int redefined_flag, enum ruby_basic_operators bop);
+extern void rb_rjit_before_ractor_spawn(void);
+extern void rb_rjit_tracing_invalidate_all(rb_event_flag_t new_iseq_events);
+extern void rb_rjit_collect_vm_usage_insn(int insn);
+
+extern bool rb_rjit_enabled;
+extern bool rb_rjit_stats_enabled;
+extern bool rb_rjit_trace_exits_enabled;
+
+# else // USE_RJIT
+
+static inline void rb_rjit_compile(const rb_iseq_t *iseq){}
+
+static inline void rb_rjit_cancel_all(const char *reason){}
+static inline void rb_rjit_free_iseq(const rb_iseq_t *iseq){}
+static inline void rb_rjit_mark(void){}
+
+static inline void rb_rjit_bop_redefined(int redefined_flag, enum ruby_basic_operators bop) {}
+static inline void rb_rjit_cme_invalidate(rb_callable_method_entry_t *cme) {}
+static inline void rb_rjit_before_ractor_spawn(void) {}
+static inline void rb_rjit_constant_state_changed(ID id) {}
+static inline void rb_rjit_constant_ic_update(const rb_iseq_t *const iseq, IC ic, unsigned insn_idx) {}
+static inline void rb_rjit_tracing_invalidate_all(rb_event_flag_t new_iseq_events) {}
+
+#define rb_rjit_enabled false
+#define rb_rjit_call_p false
+#define rb_rjit_stats_enabled false
+#define rb_rjit_trace_exits_enabled false
+
+#define rb_rjit_call_threshold() UINT_MAX
+
+static inline void rb_rjit_collect_vm_usage_insn(int insn) {}
+
+# endif // USE_RJIT
+#endif // RUBY_RJIT_H

data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/rjit_c.h

@@ -0,0 +1,165 @@
+// This file is parsed by tool/rjit/generate.rb to generate rjit_c.rb
+#ifndef RJIT_C_H
+#define RJIT_C_H
+
+#include "ruby/internal/config.h"
+#include "internal/string.h"
+#include "internal/struct.h"
+#include "internal/variable.h"
+#include "vm_core.h"
+#include "vm_callinfo.h"
+#include "builtin.h"
+#include "ccan/list/list.h"
+#include "rjit.h"
+#include "shape.h"
+
+extern uint8_t *rb_rjit_mem_block;
+
+#define RJIT_RUNTIME_COUNTERS(...) struct rb_rjit_runtime_counters { size_t __VA_ARGS__; };
+RJIT_RUNTIME_COUNTERS(
+    vm_insns_count,
+    rjit_insns_count,
+
+    send_args_splat_kw_splat,
+    send_args_splat,
+    send_args_splat_not_array,
+    send_args_splat_length_not_equal,
+    send_args_splat_cfunc_var_args,
+    send_args_splat_arity_error,
+    send_args_splat_ruby2_hash,
+    send_args_splat_cfunc_zuper,
+    send_args_splat_cfunc_ruby2_keywords,
+    send_kw_splat,
+    send_kwarg,
+    send_klass_megamorphic,
+    send_missing_cme,
+    send_private,
+    send_protected_check_failed,
+    send_tailcall,
+    send_notimplemented,
+    send_missing,
+    send_bmethod,
+    send_alias,
+    send_undef,
+    send_zsuper,
+    send_refined,
+    send_stackoverflow,
+    send_arity,
+    send_c_tracing,
+    send_is_a_class_mismatch,
+    send_instance_of_class_mismatch,
+    send_keywords,
+
+    send_blockiseq,
+    send_block_handler,
+    send_block_setup,
+    send_block_not_nil,
+    send_block_not_proxy,
+    send_block_arg,
+
+    send_iseq_kwparam,
+    send_iseq_accepts_no_kwarg,
+    send_iseq_has_opt,
+    send_iseq_has_kwrest,
+    send_iseq_ruby2_keywords,
+    send_iseq_has_rest_and_captured,
+    send_iseq_has_rest_and_kw_supplied,
+    send_iseq_has_no_kw,
+    send_iseq_zsuper,
+    send_iseq_materialized_block,
+    send_iseq_has_rest,
+    send_iseq_block_arg0_splat,
+    send_iseq_kw_call,
+    send_iseq_splat,
+    send_iseq_has_rest_and_optional,
+    send_iseq_arity_error,
+    send_iseq_missing_optional_kw,
+    send_iseq_too_many_kwargs,
+    send_iseq_kwargs_mismatch,
+    send_iseq_splat_with_kw,
+    send_iseq_splat_arity_error,
+    send_iseq_has_rest_and_splat_not_equal,
+
+    send_cfunc_variadic,
+    send_cfunc_too_many_args,
+    send_cfunc_ruby_array_varg,
+    send_cfunc_splat_with_kw,
+    send_cfunc_tracing,
+    send_cfunc_argc_mismatch,
+    send_cfunc_toomany_args,
+
+    send_attrset_splat,
+    send_attrset_kwarg,
+    send_attrset_method,
+
+    send_ivar_splat,
+    send_ivar_opt_send,
+
+    send_optimized_send_no_args,
+    send_optimized_send_not_sym_or_str,
+    send_optimized_send_mid_class_changed,
+    send_optimized_send_mid_id_changed,
+    send_optimized_send_null_mid,
+    send_optimized_send_send,
+    send_optimized_call_block,
+    send_optimized_call_kwarg,
+    send_optimized_call_splat,
+    send_optimized_struct_aref_error,
+
+    send_optimized_block_call,
+    send_optimized_struct_aset,
+
+    send_bmethod_not_iseq,
+    send_bmethod_blockarg,
+
+    invokesuper_me_changed,
+    invokesuper_block,
+
+    invokeblock_none,
+    invokeblock_symbol,
+    invokeblock_proc,
+    invokeblock_tag_changed,
+    invokeblock_iseq_block_changed,
+    invokeblock_iseq_arity,
+    invokeblock_iseq_arg0_splat,
+    invokeblock_ifunc_args_splat,
+    invokeblock_ifunc_kw_splat,
+    invokeblock_iseq_arg0_args_splat,
+    invokeblock_iseq_arg0_has_kw,
+
+    getivar_megamorphic,
+    getivar_not_heap,
+    getivar_special_const,
+    getivar_too_complex,
+
+    optaref_arg_not_fixnum,
+    optaref_argc_not_one,
+    optaref_recv_not_array,
+    optaref_recv_not_hash,
+    optaref_send,
+
+    optgetconst_not_cached,
+    optgetconst_cref,
+    optgetconst_cache_miss,
+
+    setivar_frozen,
+    setivar_not_heap,
+    setivar_megamorphic,
+    setivar_too_complex,
+
+    expandarray_splat,
+    expandarray_postarg,
+    expandarray_not_array,
+    expandarray_rhs_too_small,
+
+    getblockpp_block_param_modified,
+    getblockpp_block_handler_none,
+    getblockpp_not_gc_guarded,
+    getblockpp_not_iseq_block,
+
+    compiled_block_count
+)
+#undef RJIT_RUNTIME_COUNTERS
+extern struct rb_rjit_runtime_counters rb_rjit_counters;
+
+#endif /* RJIT_C_H */

data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/shape.h

@@ -0,0 +1,232 @@
+#ifndef RUBY_SHAPE_H
+#define RUBY_SHAPE_H
+
+#include "internal/gc.h"
+
+#if (SIZEOF_UINT64_T <= SIZEOF_VALUE)
+#define SIZEOF_SHAPE_T 4
+#define SHAPE_IN_BASIC_FLAGS 1
+typedef uint32_t attr_index_t;
+#else
+#define SIZEOF_SHAPE_T 2
+#define SHAPE_IN_BASIC_FLAGS 0
+typedef uint16_t attr_index_t;
+#endif
+
+#define MAX_IVARS (attr_index_t)(-1)
+
+#if SIZEOF_SHAPE_T == 4
+typedef uint32_t shape_id_t;
+# define SHAPE_ID_NUM_BITS 32
+# define SHAPE_BUFFER_SIZE 0x80000
+#else
+typedef uint16_t shape_id_t;
+# define SHAPE_ID_NUM_BITS 16
+# define SHAPE_BUFFER_SIZE 0x8000
+#endif
+
+# define SHAPE_MASK (((uintptr_t)1 << SHAPE_ID_NUM_BITS) - 1)
+# define SHAPE_FLAG_MASK (((VALUE)-1) >> SHAPE_ID_NUM_BITS)
+
+# define SHAPE_FLAG_SHIFT ((SIZEOF_VALUE * 8) - SHAPE_ID_NUM_BITS)
+
+# define SHAPE_MAX_VARIATIONS 8
+# define SHAPE_MAX_NUM_IVS 80
+
+# define MAX_SHAPE_ID SHAPE_BUFFER_SIZE
+# define INVALID_SHAPE_ID SHAPE_MASK
+# define ROOT_SHAPE_ID 0x0
+
+# define SPECIAL_CONST_SHAPE_ID (SIZE_POOL_COUNT * 2)
+# define OBJ_TOO_COMPLEX_SHAPE_ID (SPECIAL_CONST_SHAPE_ID + 1)
+
+struct rb_shape {
+    struct rb_id_table * edges; // id_table from ID (ivar) to next shape
+    ID edge_name; // ID (ivar) for transition from parent to rb_shape
+    attr_index_t next_iv_index;
+    uint32_t capacity; // Total capacity of the object with this shape
+    uint8_t type;
+    uint8_t size_pool_index;
+    shape_id_t parent_id;
+};
+
+typedef struct rb_shape rb_shape_t;
+
+enum shape_type {
+    SHAPE_ROOT,
+    SHAPE_IVAR,
+    SHAPE_FROZEN,
+    SHAPE_CAPACITY_CHANGE,
+    SHAPE_INITIAL_CAPACITY,
+    SHAPE_T_OBJECT,
+    SHAPE_OBJ_TOO_COMPLEX,
+};
+
+typedef struct {
+    /* object shapes */
+    rb_shape_t *shape_list;
+    rb_shape_t *root_shape;
+    shape_id_t next_shape_id;
+} rb_shape_tree_t;
+RUBY_EXTERN rb_shape_tree_t *rb_shape_tree_ptr;
+
+static inline rb_shape_tree_t *
+rb_current_shape_tree(void)
+{
+    return rb_shape_tree_ptr;
+}
+#define GET_SHAPE_TREE() rb_current_shape_tree()
+
+static inline shape_id_t
+get_shape_id_from_flags(VALUE obj)
+{
+    RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));
+    return (shape_id_t)(SHAPE_MASK & ((RBASIC(obj)->flags) >> SHAPE_FLAG_SHIFT));
+}
+
+static inline void
+set_shape_id_in_flags(VALUE obj, shape_id_t shape_id)
+{
+    // Ractors are occupying the upper 32 bits of flags, but only in debug mode
+    // Object shapes are occupying top bits
+    RBASIC(obj)->flags &= SHAPE_FLAG_MASK;
+    RBASIC(obj)->flags |= ((VALUE)(shape_id) << SHAPE_FLAG_SHIFT);
+}
+
+
+#if SHAPE_IN_BASIC_FLAGS
+static inline shape_id_t
+RBASIC_SHAPE_ID(VALUE obj)
+{
+    return get_shape_id_from_flags(obj);
+}
+
+static inline void
+RBASIC_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id)
+{
+    set_shape_id_in_flags(obj, shape_id);
+}
+#endif
+
+static inline shape_id_t
+ROBJECT_SHAPE_ID(VALUE obj)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    return get_shape_id_from_flags(obj);
+}
+
+static inline void
+ROBJECT_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    set_shape_id_in_flags(obj, shape_id);
+}
+
+static inline shape_id_t
+RCLASS_SHAPE_ID(VALUE obj)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, T_CLASS) || RB_TYPE_P(obj, T_MODULE));
+    return get_shape_id_from_flags(obj);
+}
+
+static inline void
+RCLASS_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, T_CLASS) || RB_TYPE_P(obj, T_MODULE));
+    set_shape_id_in_flags(obj, shape_id);
+}
+
+rb_shape_t * rb_shape_get_root_shape(void);
+int32_t rb_shape_id_offset(void);
+
+rb_shape_t * rb_shape_get_parent(rb_shape_t * shape);
+
+rb_shape_t* rb_shape_get_shape_by_id(shape_id_t shape_id);
+shape_id_t rb_shape_get_shape_id(VALUE obj);
+rb_shape_t * rb_shape_get_next_iv_shape(rb_shape_t * shape, ID id);
+bool rb_shape_get_iv_index(rb_shape_t * shape, ID id, attr_index_t * value);
+bool rb_shape_obj_too_complex(VALUE obj);
+
+void rb_shape_set_shape(VALUE obj, rb_shape_t* shape);
+rb_shape_t* rb_shape_get_shape(VALUE obj);
+int rb_shape_frozen_shape_p(rb_shape_t* shape);
+void rb_shape_transition_shape_frozen(VALUE obj);
+void rb_shape_transition_shape_remove_ivar(VALUE obj, ID id, rb_shape_t *shape, VALUE * removed);
+rb_shape_t * rb_shape_transition_shape_capa(rb_shape_t * shape, uint32_t new_capacity);
+rb_shape_t* rb_shape_get_next(rb_shape_t* shape, VALUE obj, ID id);
+
+rb_shape_t * rb_shape_rebuild_shape(rb_shape_t * initial_shape, rb_shape_t * dest_shape);
+
+static inline uint32_t
+ROBJECT_IV_CAPACITY(VALUE obj)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    // Asking for capacity doesn't make sense when the object is using
+    // a hash table for storing instance variables
+    RUBY_ASSERT(ROBJECT_SHAPE_ID(obj) != OBJ_TOO_COMPLEX_SHAPE_ID);
+    return rb_shape_get_shape_by_id(ROBJECT_SHAPE_ID(obj))->capacity;
+}
+
+static inline st_table *
+ROBJECT_IV_HASH(VALUE obj)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    RUBY_ASSERT(ROBJECT_SHAPE_ID(obj) == OBJ_TOO_COMPLEX_SHAPE_ID);
+    return (st_table *)ROBJECT(obj)->as.heap.ivptr;
+}
+
+static inline void
+ROBJECT_SET_IV_HASH(VALUE obj, const struct rb_id_table *tbl)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    RUBY_ASSERT(ROBJECT_SHAPE_ID(obj) == OBJ_TOO_COMPLEX_SHAPE_ID);
+    ROBJECT(obj)->as.heap.ivptr = (VALUE *)tbl;
+}
+
+size_t rb_id_table_size(const struct rb_id_table *tbl);
+
+static inline uint32_t
+ROBJECT_IV_COUNT(VALUE obj)
+{
+    if (ROBJECT_SHAPE_ID(obj) == OBJ_TOO_COMPLEX_SHAPE_ID) {
+        return (uint32_t)rb_st_table_size(ROBJECT_IV_HASH(obj));
+    }
+    else {
+        RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+        RUBY_ASSERT(ROBJECT_SHAPE_ID(obj) != OBJ_TOO_COMPLEX_SHAPE_ID);
+        return rb_shape_get_shape_by_id(ROBJECT_SHAPE_ID(obj))->next_iv_index;
+    }
+}
+
+static inline uint32_t
+RBASIC_IV_COUNT(VALUE obj)
+{
+    return rb_shape_get_shape_by_id(rb_shape_get_shape_id(obj))->next_iv_index;
+}
+
+static inline uint32_t
+RCLASS_IV_COUNT(VALUE obj)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
+    uint32_t ivc = rb_shape_get_shape_by_id(RCLASS_SHAPE_ID(obj))->next_iv_index;
+    return ivc;
+}
+
+rb_shape_t *rb_shape_traverse_from_new_root(rb_shape_t *initial_shape, rb_shape_t *orig_shape);
+
+bool rb_shape_set_shape_id(VALUE obj, shape_id_t shape_id);
+
+VALUE rb_obj_debug_shape(VALUE self, VALUE obj);
+void rb_shape_set_too_complex(VALUE obj);
+
+// For ext/objspace
+RUBY_SYMBOL_EXPORT_BEGIN
+typedef void each_shape_callback(rb_shape_t * shape, void *data);
+void rb_shape_each_shape(each_shape_callback callback, void *data);
+size_t rb_shape_memsize(rb_shape_t *shape);
+size_t rb_shape_edges_count(rb_shape_t *shape);
+size_t rb_shape_depth(rb_shape_t *shape);
+shape_id_t rb_shape_id(rb_shape_t * shape);
+RUBY_SYMBOL_EXPORT_END
+
+#endif

data/lib/debase/ruby_core_source/{ruby-3.2.0-preview3 → ruby-3.3.0-preview1}/thread_pthread.h

@@ -26,7 +26,7 @@ struct rb_thread_sched_item {
 };
 
 struct rb_native_thread {
-    int id;
+    rb_atomic_t serial;
 
     rb_nativethread_id_t thread_id;
 
@@ -90,13 +90,20 @@ struct rb_thread_sched {
     int wait_yield;
 };
 
-#if __STDC_VERSION__ >= 201112
-  #define RB_THREAD_LOCAL_SPECIFIER _Thread_local
-#elif defined(__GNUC__) && !defined(RB_THREAD_LOCAL_SPECIFIER_IS_UNSUPPORTED)
-  /* note that ICC (linux) and Clang are covered by __GNUC__ */
-  #define RB_THREAD_LOCAL_SPECIFIER __thread
-#else
+RUBY_SYMBOL_EXPORT_BEGIN
+#ifdef RB_THREAD_LOCAL_SPECIFIER
+  # ifdef __APPLE__
+    // on Darwin, TLS can not be accessed across .so
+    struct rb_execution_context_struct *rb_current_ec(void);
+    void rb_current_ec_set(struct rb_execution_context_struct *);
+  # else
+    RUBY_EXTERN RB_THREAD_LOCAL_SPECIFIER struct rb_execution_context_struct *ruby_current_ec;
 
+    // for RUBY_DEBUG_LOG()
+    RUBY_EXTERN RB_THREAD_LOCAL_SPECIFIER rb_atomic_t ruby_nt_serial;
+    #define RUBY_NT_SERIAL 1
+  # endif
+#else
 typedef pthread_key_t native_tls_key_t;
 
 static inline void *
@@ -113,19 +120,8 @@ native_tls_set(native_tls_key_t key, void *ptr)
         rb_bug("pthread_setspecific error");
     }
 }
-#endif
 
-RUBY_SYMBOL_EXPORT_BEGIN
-#ifdef RB_THREAD_LOCAL_SPECIFIER
-  #ifdef __APPLE__
-    // on Darwin, TLS can not be accessed across .so
-    struct rb_execution_context_struct *rb_current_ec(void);
-    void rb_current_ec_set(struct rb_execution_context_struct *);
-  #else
-    RUBY_EXTERN RB_THREAD_LOCAL_SPECIFIER struct rb_execution_context_struct *ruby_current_ec;
-  #endif
-#else
-  RUBY_EXTERN native_tls_key_t ruby_current_ec_key;
+RUBY_EXTERN native_tls_key_t ruby_current_ec_key;
 #endif
 RUBY_SYMBOL_EXPORT_END
 

data/lib/debase/ruby_core_source/{ruby-3.2.0-preview2 → ruby-3.3.0-preview1}/timev.h

@@ -2,10 +2,7 @@
 #define RUBY_TIMEV_H
 #include "ruby/ruby.h"
 
-#if 0
-struct vtm {/* dummy for TAGS */};
-#endif
-PACKED_STRUCT_UNALIGNED(struct vtm {
+struct vtm {
     VALUE year; /* 2000 for example.  Integer. */
     VALUE subsecx; /* 0 <= subsecx < TIME_SCALE.  possibly Rational. */
     VALUE utc_offset; /* -3600 as -01:00 for example.  possibly Rational. */
@@ -18,7 +15,11 @@ PACKED_STRUCT_UNALIGNED(struct vtm {
     unsigned int sec:6; /* 0..60 */
     unsigned int wday:3; /* 0:Sunday, 1:Monday, ..., 6:Saturday 7:init */
     unsigned int isdst:2; /* 0:StandardTime 1:DayLightSavingTime 3:init */
-});
+
+    /* Flags for struct time_object */
+    unsigned int tzmode:3; /* 0:localtime 1:utc 2:fixoff 3:uninitialized */
+    unsigned int tm_got:1;
+};
 
 #define TIME_SCALE 1000000000