debase-ruby_core_source 0.10.18 → 3.2.1

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

@@ -23,6 +23,7 @@
 #define RARRAY_PTR_IN_USE_FLAG  FL_USER14
 
 /* array.c */
+VALUE rb_ary_hash_values(long len, const VALUE *elements);
 VALUE rb_ary_last(int, const VALUE *, VALUE);
 void rb_ary_set_len(VALUE, long);
 void rb_ary_delete_same(VALUE, VALUE);
@@ -35,13 +36,13 @@ void rb_ary_cancel_sharing(VALUE ary);
 size_t rb_ary_size_as_embedded(VALUE ary);
 void rb_ary_make_embedded(VALUE ary);
 bool rb_ary_embeddable_p(VALUE ary);
+VALUE rb_ary_diff(VALUE ary1, VALUE ary2);
 
 static inline VALUE rb_ary_entry_internal(VALUE ary, long offset);
 static inline bool ARY_PTR_USING_P(VALUE ary);
 static inline void RARY_TRANSIENT_SET(VALUE ary);
 static inline void RARY_TRANSIENT_UNSET(VALUE ary);
 
-MJIT_SYMBOL_EXPORT_BEGIN
 VALUE rb_ary_tmp_new_from_values(VALUE, long, const VALUE *);
 VALUE rb_check_to_array(VALUE ary);
 VALUE rb_ary_behead(VALUE, long);
@@ -49,7 +50,6 @@ VALUE rb_ary_aref1(VALUE ary, VALUE i);
 
 struct rb_execution_context_struct;
 VALUE rb_ec_ary_new_from_values(struct rb_execution_context_struct *ec, long n, const VALUE *elts);
-MJIT_SYMBOL_EXPORT_END
 
 // YJIT needs this function to never allocate and never raise
 static inline VALUE

data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/internal/basic_operators.h

@@ -0,0 +1,63 @@
+#ifndef INTERNAL_BOP_H                                /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_BOP_H
+
+#include "internal.h"
+#include "ruby/internal/dllexport.h"
+
+enum ruby_basic_operators {
+    BOP_PLUS,
+    BOP_MINUS,
+    BOP_MULT,
+    BOP_DIV,
+    BOP_MOD,
+    BOP_EQ,
+    BOP_EQQ,
+    BOP_LT,
+    BOP_LE,
+    BOP_LTLT,
+    BOP_AREF,
+    BOP_ASET,
+    BOP_LENGTH,
+    BOP_SIZE,
+    BOP_EMPTY_P,
+    BOP_NIL_P,
+    BOP_SUCC,
+    BOP_GT,
+    BOP_GE,
+    BOP_NOT,
+    BOP_NEQ,
+    BOP_MATCH,
+    BOP_FREEZE,
+    BOP_UMINUS,
+    BOP_MAX,
+    BOP_MIN,
+    BOP_HASH,
+    BOP_CALL,
+    BOP_AND,
+    BOP_OR,
+    BOP_CMP,
+    BOP_DEFAULT,
+
+    BOP_LAST_
+};
+
+RUBY_EXTERN short ruby_vm_redefined_flag[BOP_LAST_];
+
+/* optimize insn */
+#define INTEGER_REDEFINED_OP_FLAG (1 << 0)
+#define FLOAT_REDEFINED_OP_FLAG  (1 << 1)
+#define STRING_REDEFINED_OP_FLAG (1 << 2)
+#define ARRAY_REDEFINED_OP_FLAG  (1 << 3)
+#define HASH_REDEFINED_OP_FLAG   (1 << 4)
+/* #define BIGNUM_REDEFINED_OP_FLAG (1 << 5) */
+#define SYMBOL_REDEFINED_OP_FLAG (1 << 6)
+#define TIME_REDEFINED_OP_FLAG   (1 << 7)
+#define REGEXP_REDEFINED_OP_FLAG (1 << 8)
+#define NIL_REDEFINED_OP_FLAG    (1 << 9)
+#define TRUE_REDEFINED_OP_FLAG   (1 << 10)
+#define FALSE_REDEFINED_OP_FLAG  (1 << 11)
+#define PROC_REDEFINED_OP_FLAG   (1 << 12)
+
+#define BASIC_OP_UNREDEFINED_P(op, klass) (LIKELY((ruby_vm_redefined_flag[(op)]&(klass)) == 0))
+
+#endif

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

@@ -163,11 +163,9 @@ VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck);
 VALUE rb_int_parse_cstr(const char *str, ssize_t len, char **endp, size_t *ndigits, int base, int flags);
 RUBY_SYMBOL_EXPORT_END
 
-MJIT_SYMBOL_EXPORT_BEGIN
 #if defined(HAVE_INT128_T)
 VALUE rb_int128t2big(int128_t n);
 #endif
-MJIT_SYMBOL_EXPORT_END
 
 /* sign: positive:1, negative:0 */
 static inline bool

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

@@ -34,8 +34,7 @@
 # include <stdlib.h>            /* for _byteswap_uint64 */
 #endif
 
-#if defined(HAVE_X86INTRIN_H) && ! defined(MJIT_HEADER)
-# /* Rule out MJIT_HEADER, which does not interface well with <immintrin.h> */
+#if defined(HAVE_X86INTRIN_H)
 # include <x86intrin.h>         /* for _lzcnt_u64 */
 #elif MSC_VERSION_SINCE(1310)
 # include <intrin.h>            /* for the following intrinsics */
@@ -235,7 +234,7 @@ nlz_int32(uint32_t x)
      * safety. */
     return (unsigned int)__lzcnt(x);
 
-#elif defined(__x86_64__) && defined(__LZCNT__) && ! defined(MJIT_HEADER)
+#elif defined(__x86_64__) && defined(__LZCNT__)
     return (unsigned int)_lzcnt_u32(x);
 
 #elif MSC_VERSION_SINCE(1400) /* &&! defined(__AVX2__) */
@@ -264,7 +263,7 @@ nlz_int64(uint64_t x)
 #if defined(_MSC_VER) && defined(__AVX2__)
     return (unsigned int)__lzcnt64(x);
 
-#elif defined(__x86_64__) && defined(__LZCNT__) && ! defined(MJIT_HEADER)
+#elif defined(__x86_64__) && defined(__LZCNT__)
     return (unsigned int)_lzcnt_u64(x);
 
 #elif defined(_WIN64) && MSC_VERSION_SINCE(1400) /* &&! defined(__AVX2__) */
@@ -450,7 +449,7 @@ rb_popcount_intptr(uintptr_t x)
 static inline int
 ntz_int32(uint32_t x)
 {
-#if defined(__x86_64__) && defined(__BMI__) && ! defined(MJIT_HEADER)
+#if defined(__x86_64__) && defined(__BMI__)
     return (unsigned)_tzcnt_u32(x);
 
 #elif MSC_VERSION_SINCE(1400)
@@ -472,7 +471,7 @@ ntz_int32(uint32_t x)
 static inline int
 ntz_int64(uint64_t x)
 {
-#if defined(__x86_64__) && defined(__BMI__) && ! defined(MJIT_HEADER)
+#if defined(__x86_64__) && defined(__BMI__)
     return (unsigned)_tzcnt_u64(x);
 
 #elif defined(_WIN64) && MSC_VERSION_SINCE(1400)

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

@@ -8,12 +8,15 @@
  *             file COPYING are met.  Consult the file for details.
  * @brief      Internal header for Class.
  */
+#include "id.h"
 #include "id_table.h"           /* for struct rb_id_table */
-#include "internal/gc.h"        /* for RB_OBJ_WRITE */
 #include "internal/serial.h"    /* for rb_serial_t */
+#include "internal/static_assert.h"
+#include "internal/variable.h"  /* for rb_class_ivar_set */
 #include "ruby/internal/stdbool.h"     /* for bool */
 #include "ruby/intern.h"        /* for rb_alloc_func_t */
 #include "ruby/ruby.h"          /* for struct RBasic */
+#include "shape.h"
 
 #ifdef RCLASS_SUPER
 # undef RCLASS_SUPER
@@ -24,12 +27,7 @@ struct rb_subclass_entry {
     struct rb_subclass_entry *next;
     struct rb_subclass_entry *prev;
 };
-
-struct rb_iv_index_tbl_entry {
-    uint32_t index;
-    rb_serial_t class_serial;
-    VALUE class_value;
-};
+typedef struct rb_subclass_entry rb_subclass_entry_t;
 
 struct rb_cvar_class_tbl_entry {
     uint32_t index;
@@ -38,11 +36,7 @@ struct rb_cvar_class_tbl_entry {
 };
 
 struct rb_classext_struct {
-    struct st_table *iv_index_tbl; // ID -> struct rb_iv_index_tbl_entry
-    struct st_table *iv_tbl;
-#if SIZEOF_SERIAL_T == SIZEOF_VALUE /* otherwise m_tbl is in struct RClass */
-    struct rb_id_table *m_tbl;
-#endif
+    VALUE *iv_ptr;
     struct rb_id_table *const_tbl;
     struct rb_id_table *callable_m_tbl;
     struct rb_id_table *cc_tbl; /* ID -> [[ci, cc1], cc2, ...] */
@@ -57,73 +51,54 @@ struct rb_classext_struct {
      * included. Hopefully that makes sense.
      */
     struct rb_subclass_entry *module_subclass_entry;
-#if SIZEOF_SERIAL_T != SIZEOF_VALUE && !USE_RVARGC /* otherwise class_serial is in struct RClass */
-    rb_serial_t class_serial;
-#endif
     const VALUE origin_;
     const VALUE refined_class;
-    rb_alloc_func_t allocator;
+    union {
+        struct {
+            rb_alloc_func_t allocator;
+        } class;
+        struct {
+            VALUE attached_object;
+        } singleton_class;
+    } as;
     const VALUE includer;
+    attr_index_t max_iv_count;
+    unsigned char variation_count;
+    bool permanent_classpath : 1;
+    bool cloned : 1;
+    VALUE classpath;
 };
+typedef struct rb_classext_struct rb_classext_t;
+
+STATIC_ASSERT(shape_max_variations, SHAPE_MAX_VARIATIONS < (1 << (sizeof(((rb_classext_t *)0)->variation_count) * CHAR_BIT)));
 
 struct RClass {
     struct RBasic basic;
     VALUE super;
-#if !USE_RVARGC
-    struct rb_classext_struct *ptr;
-#endif
-#if SIZEOF_SERIAL_T == SIZEOF_VALUE
-    /* Class serial is as wide as VALUE.  Place it here. */
-    rb_serial_t class_serial;
-#else
-    /* Class serial does not fit into struct RClass. Place m_tbl instead. */
     struct rb_id_table *m_tbl;
-# if USE_RVARGC
-    rb_serial_t *class_serial_ptr;
-# endif
-#endif
 };
 
-typedef struct rb_subclass_entry rb_subclass_entry_t;
-typedef struct rb_classext_struct rb_classext_t;
+// Assert that classes can be embedded in size_pools[2] (which has 160B slot size)
+STATIC_ASSERT(sizeof_rb_classext_t, sizeof(struct RClass) + sizeof(rb_classext_t) <= 4 * RVALUE_SIZE);
 
-#if USE_RVARGC
-#  define RCLASS_EXT(c) ((rb_classext_t *)((char *)(c) + sizeof(struct RClass)))
-#else
-#  define RCLASS_EXT(c) (RCLASS(c)->ptr)
-#endif
-#define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
+#define RCLASS_EXT(c) ((rb_classext_t *)((char *)(c) + sizeof(struct RClass)))
 #define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
-#if SIZEOF_SERIAL_T == SIZEOF_VALUE
-# define RCLASS_M_TBL(c) (RCLASS_EXT(c)->m_tbl)
-#else
-# define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
-#endif
+#define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
+#define RCLASS_IVPTR(c) (RCLASS_EXT(c)->iv_ptr)
 #define RCLASS_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)
 #define RCLASS_CC_TBL(c) (RCLASS_EXT(c)->cc_tbl)
 #define RCLASS_CVC_TBL(c) (RCLASS_EXT(c)->cvc_tbl)
-#define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)
 #define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin_)
 #define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
-#if SIZEOF_SERIAL_T == SIZEOF_VALUE
-# define RCLASS_SERIAL(c) (RCLASS(c)->class_serial)
-#else
-# if USE_RVARGC
-#  define RCLASS_SERIAL(c) (*RCLASS(c)->class_serial_ptr)
-# else
-#  define RCLASS_SERIAL(c) (RCLASS_EXT(c)->class_serial)
-# endif
-#endif
 #define RCLASS_INCLUDER(c) (RCLASS_EXT(c)->includer)
 #define RCLASS_SUBCLASS_ENTRY(c) (RCLASS_EXT(c)->subclass_entry)
 #define RCLASS_MODULE_SUBCLASS_ENTRY(c) (RCLASS_EXT(c)->module_subclass_entry)
-#define RCLASS_ALLOCATOR(c) (RCLASS_EXT(c)->allocator)
 #define RCLASS_SUBCLASSES(c) (RCLASS_EXT(c)->subclasses)
 #define RCLASS_SUPERCLASS_DEPTH(c) (RCLASS_EXT(c)->superclass_depth)
 #define RCLASS_SUPERCLASSES(c) (RCLASS_EXT(c)->superclasses)
+#define RCLASS_ATTACHED_OBJECT(c) (RCLASS_EXT(c)->as.singleton_class.attached_object)
 
 #define RICLASS_IS_ORIGIN FL_USER0
-#define RCLASS_CLONED     FL_USER1
 #define RCLASS_SUPERCLASSES_INCLUDE_SELF FL_USER2
 #define RICLASS_ORIGIN_SHARED_MTBL FL_USER3
 
@@ -161,10 +136,24 @@ static inline VALUE RCLASS_SUPER(VALUE klass);
 static inline VALUE RCLASS_SET_SUPER(VALUE klass, VALUE super);
 static inline void RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass);
 
-MJIT_SYMBOL_EXPORT_BEGIN
 VALUE rb_class_inherited(VALUE, VALUE);
 VALUE rb_keyword_error_new(const char *, VALUE);
-MJIT_SYMBOL_EXPORT_END
+
+static inline rb_alloc_func_t
+RCLASS_ALLOCATOR(VALUE klass)
+{
+    if (FL_TEST_RAW(klass, FL_SINGLETON)) {
+        return NULL;
+    }
+    return RCLASS_EXT(klass)->as.class.allocator;
+}
+
+static inline void
+RCLASS_SET_ALLOCATOR(VALUE klass, rb_alloc_func_t allocator)
+{
+    assert(!FL_TEST(klass, FL_SINGLETON));
+    RCLASS_EXT(klass)->as.class.allocator = allocator;
+}
 
 static inline void
 RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
@@ -209,4 +198,24 @@ RCLASS_SET_SUPER(VALUE klass, VALUE super)
     return super;
 }
 
+static inline void
+RCLASS_SET_CLASSPATH(VALUE klass, VALUE classpath, bool permanent)
+{
+    assert(BUILTIN_TYPE(klass) == T_CLASS || BUILTIN_TYPE(klass) == T_MODULE);
+    assert(classpath == 0 || BUILTIN_TYPE(classpath) == T_STRING);
+
+    RB_OBJ_WRITE(klass, &(RCLASS_EXT(klass)->classpath), classpath);
+    RCLASS_EXT(klass)->permanent_classpath = permanent;
+}
+
+static inline VALUE
+RCLASS_SET_ATTACHED_OBJECT(VALUE klass, VALUE attached_object)
+{
+    assert(BUILTIN_TYPE(klass) == T_CLASS);
+    assert(FL_TEST_RAW(klass, FL_SINGLETON));
+
+    RB_OBJ_WRITE(klass, &RCLASS_EXT(klass)->as.singleton_class.attached_object, attached_object);
+    return attached_object;
+}
+
 #endif /* INTERNAL_CLASS_H */

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

@@ -1,7 +1,7 @@
 #ifndef INTERNAL_CMDLINEOPT_H                               /*-*-C-*-vi:se ft=c:*/
 #define INTERNAL_CMDLINEOPT_H
 
-#include "mjit.h"
+#include "rjit.h"
 #include "yjit.h"
 
 typedef struct {
@@ -23,8 +23,8 @@ typedef struct ruby_cmdline_options {
     ruby_features_t features;
     ruby_features_t warn;
     unsigned int dump;
-#if USE_MJIT
-    struct mjit_options mjit;
+#if USE_RJIT
+    struct rb_rjit_options rjit;
 #endif
 
     int sflag, xflag;
@@ -36,6 +36,9 @@ typedef struct ruby_cmdline_options {
     unsigned int do_split: 1;
     unsigned int do_search: 1;
     unsigned int setids: 2;
+#if USE_YJIT
+    unsigned int yjit: 1;
+#endif
 } ruby_cmdline_options_t;
 
 struct ruby_opt_message {

data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/internal/compar.h

@@ -0,0 +1,29 @@
+#ifndef INTERNAL_COMPAR_H                                /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_COMPAR_H
+/**
+ * @author     Ruby developers <ruby-core@ruby-lang.org>
+ * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
+ *             Permission  is hereby  granted,  to  either redistribute  and/or
+ *             modify this file, provided that  the conditions mentioned in the
+ *             file COPYING are met.  Consult the file for details.
+ * @brief      Internal header for Comparable.
+ */
+#include "internal/basic_operators.h"
+
+#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
+
+#define CMP_OPTIMIZABLE(type) BASIC_OP_UNREDEFINED_P(BOP_CMP, type##_REDEFINED_OP_FLAG)
+
+#define OPTIMIZED_CMP(a, b) \
+    ((FIXNUM_P(a) && FIXNUM_P(b) && CMP_OPTIMIZABLE(INTEGER)) ? \
+     (((long)a > (long)b) ? 1 : ((long)a < (long)b) ? -1 : 0) : \
+     (STRING_P(a) && STRING_P(b) && CMP_OPTIMIZABLE(STRING)) ? \
+     rb_str_cmp(a, b) : \
+     (RB_FLOAT_TYPE_P(a) && RB_FLOAT_TYPE_P(b) && CMP_OPTIMIZABLE(FLOAT)) ? \
+     rb_float_cmp(a, b) : \
+     rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b))
+
+/* compar.c */
+VALUE rb_invcmp(VALUE, VALUE);
+
+#endif /* INTERNAL_COMPAR_H */

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

@@ -17,6 +17,8 @@ struct rb_iseq_struct;          /* in vm_core.h */
 /* compile.c */
 int rb_dvar_defined(ID, const struct rb_iseq_struct *);
 int rb_local_defined(ID, const struct rb_iseq_struct *);
+bool rb_insns_leaf_p(int i);
+int rb_insn_len(VALUE insn);
 const char *rb_insns_name(int i);
 VALUE rb_insns_name_array(void);
 int rb_iseq_cdhash_cmp(VALUE val, VALUE lit);
@@ -27,9 +29,7 @@ int rb_vm_insn_addr2insn(const void *);
 int rb_vm_insn_decode(const VALUE encoded);
 extern bool ruby_vm_keep_script_lines;
 
-MJIT_SYMBOL_EXPORT_BEGIN
 /* iseq.c (export) */
 rb_event_flag_t rb_iseq_event_flags(const struct rb_iseq_struct *iseq, size_t pos);
-MJIT_SYMBOL_EXPORT_END
 
 #endif /* INTERNAL_COMPILE_H */

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

@@ -9,6 +9,7 @@
  * @brief      Internal header for Fiber.
  */
 #include "ruby/ruby.h"          /* for VALUE */
+#include "iseq.h"
 
 struct rb_thread_struct;        /* in vm_core.h */
 struct rb_fiber_struct;         /* in cont.c */
@@ -17,7 +18,12 @@ struct rb_execution_context_struct; /* in vm_core.c */
 /* cont.c */
 void rb_fiber_reset_root_local_storage(struct rb_thread_struct *);
 void ruby_register_rollback_func_for_ensure(VALUE (*ensure_func)(VALUE), VALUE (*rollback_func)(VALUE));
-void rb_fiber_init_mjit_cont(struct rb_fiber_struct *fiber);
+void rb_jit_cont_init(void);
+void rb_jit_cont_each_iseq(rb_iseq_callback callback, void *data);
+void rb_jit_cont_finish(void);
+
+// Copy locals from the current execution to the specified fiber.
+VALUE rb_fiber_inherit_storage(struct rb_execution_context_struct *ec, struct rb_fiber_struct *fiber);
 
 VALUE rb_fiberptr_self(struct rb_fiber_struct *fiber);
 unsigned int rb_fiberptr_blocking(struct rb_fiber_struct *fiber);

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

@@ -12,6 +12,9 @@
 #include "ruby/encoding.h"      /* for rb_encoding */
 
 #define rb_enc_autoload_p(enc) (!rb_enc_mbmaxlen(enc))
+#define rb_is_usascii_enc(enc) ((enc) == rb_usascii_encoding())
+#define rb_is_ascii8bit_enc(enc) ((enc) == rb_ascii8bit_encoding())
+#define rb_is_locale_enc(enc) ((enc) == rb_locale_encoding())
 
 /* encoding.c */
 ID rb_id_encoding(void);
@@ -24,7 +27,6 @@ int rb_encdb_dummy(const char *name);
 void rb_encdb_declare(const char *name);
 void rb_enc_set_base(const char *name, const char *orig);
 int rb_enc_set_dummy(int index);
-void rb_encdb_set_unicode(int index);
 PUREFUNC(int rb_data_is_encoding(VALUE obj));
 
 #endif /* INTERNAL_ENCODING_H */