datadog-ruby_core_source 3.5.1 → 3.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 516e509afa1920fd3ed7cf382e06006d2ce680e00ba16ecd1a39f7f2dc417dbe
-  data.tar.gz: 87af7c48459a9d8d45d99ab063329352a529f5089cab54afff9c4dd34c03a182
+  metadata.gz: 4ddda3216e9e2df336d43e4ead1944a58324fd0044abdbac2c281cbdf0fc9b5c
+  data.tar.gz: 1b6ed3757b230901e7b8dbdc1bfe0d3bea04c0fb50ebd2280bdb141ca940b6d4
 SHA512:
-  metadata.gz: 3bf0c620ee078694ac52f390f7cd40e0408c19ce4b751c7383c74750152bd887baa461bf8df3ac837555150b67bf33b4466f06cb3718116a3c60063a389584a8
-  data.tar.gz: 810028e9bcdec7d9696acd62d16b1156e54ce68fd15e41f6461d46e30b47996067fd13d458ded3ad884b4880fb0bce480fb7f4805599bf6b6d3f3ed8e145efdc
+  metadata.gz: 456241058e3ef1b2ccb823fa196c05526f4b665f10a0f76254a7b17a99c572b58a77d10f765cd0082d44508d5877f749de782b7559655c073bbd2319a4cb61a0
+  data.tar.gz: 8e3787e8408c3bae05bc1618919fb76fd0f9729cf4383be0b1ef10ce7756745da9affb3f6beddfe18b40757c6fec667a1ebda8f30af7d199a99d541bce5db268

data/datadog-ruby_core_source.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
     .reject { |fn| fn.include?('Rakefile') }
     .reject { |fn| fn.include?('.github/') }
     .reject { |fn| fn.include?('.gitignore') }
+    .reject { |fn| fn.include?('spec/') }
   s.add_development_dependency "archive-tar-minitar", ">= 0.5.2"
   s.add_development_dependency 'rake', '>= 0.9.2'
   s.add_development_dependency 'minitar-cli'

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/id.h

@@ -109,6 +109,7 @@ enum ruby_method_ids {
     tPRESERVED_ID_BEGIN = 150,
     idNilP,
     idIncludeP,
+    idItImplicit,
     idNULL,
     idEmptyP,
     idEqlP,
@@ -204,6 +205,7 @@ enum ruby_method_ids {
     tNUMPARAM_7,
     tNUMPARAM_8,
     tNUMPARAM_9,
+    tIt,
     tDefault,
     tTOKEN_LOCAL_END,
     /* LOCAL tokens }}} */
@@ -314,6 +316,7 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_7),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_8),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_9),
+    DEFINE_LOCALID_FROM_TOKEN(It),
     DEFINE_LOCALID_FROM_TOKEN(Default),
 #undef DEFINE_LOCALID_FROM_TOKEN
     /* LOCAL IDs }}} */

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/id_table.h

@@ -47,6 +47,16 @@ int rb_managed_id_table_delete(VALUE table, ID id);
 
 extern const rb_data_type_t rb_managed_id_table_type;
 
+VALUE rb_marked_id_table_new(size_t capa);
+int rb_marked_id_table_insert(VALUE table, ID id, VALUE val);
+VALUE rb_marked_id_table_dup(VALUE table);
+
+// alisases
+#define rb_marked_id_table_size             rb_managed_id_table_size
+#define rb_marked_id_table_lookup           rb_managed_id_table_lookup
+#define rb_marked_id_table_foreach          rb_managed_id_table_foreach
+#define rb_marked_id_table_foreach_values   rb_managed_id_table_foreach_values
+
 RUBY_SYMBOL_EXPORT_BEGIN
 size_t rb_id_table_size(const struct rb_id_table *tbl);
 RUBY_SYMBOL_EXPORT_END

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/array.h

@@ -37,6 +37,7 @@ 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);
+VALUE rb_ary_compact_bang(VALUE ary);
 RUBY_EXTERN VALUE rb_cArray_empty_frozen;
 
 static inline VALUE rb_ary_entry_internal(VALUE ary, long offset);

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/basic_operators.h

@@ -24,6 +24,7 @@ enum ruby_basic_operators {
     BOP_SUCC,
     BOP_GT,
     BOP_GE,
+    BOP_GTGT,
     BOP_NOT,
     BOP_NEQ,
     BOP_MATCH,

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/bignum.h

@@ -9,6 +9,7 @@
  * @brief      Internal header for Bignums.
  */
 #include "ruby/internal/config.h"      /* for HAVE_LIBGMP */
+#include "internal/compilers.h"        /* for FLEX_ARY_LEN */
 #include <stddef.h>             /* for size_t */
 
 #ifdef HAVE_SYS_TYPES_H
@@ -76,18 +77,17 @@
 #define RBIGNUM(obj) ((struct RBignum *)(obj))
 #define BIGNUM_SIGN_BIT FL_USER1
 #define BIGNUM_EMBED_FLAG ((VALUE)FL_USER2)
-#define BIGNUM_EMBED_LEN_NUMBITS 3
+
+/* This is likely more bits than we need today and will also need adjustment if
+ * we change GC slot sizes.
+ */
+#define BIGNUM_EMBED_LEN_NUMBITS 9
 #define BIGNUM_EMBED_LEN_MASK \
-    (~(~(VALUE)0U << BIGNUM_EMBED_LEN_NUMBITS) << BIGNUM_EMBED_LEN_SHIFT)
+    (RUBY_FL_USER11 | RUBY_FL_USER10 | RUBY_FL_USER9 | RUBY_FL_USER8 | RUBY_FL_USER7 | \
+     RUBY_FL_USER6 | RUBY_FL_USER5 | RUBY_FL_USER4 | RUBY_FL_USER3)
 #define BIGNUM_EMBED_LEN_SHIFT \
     (FL_USHIFT+3) /* bit offset of BIGNUM_EMBED_LEN_MASK */
-#ifndef BIGNUM_EMBED_LEN_MAX
-# if (SIZEOF_VALUE*RBIMPL_RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT) < (1 << BIGNUM_EMBED_LEN_NUMBITS)-1
-#  define BIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*RBIMPL_RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT)
-# else
-#  define BIGNUM_EMBED_LEN_MAX ((1 << BIGNUM_EMBED_LEN_NUMBITS)-1)
-# endif
-#endif
+#define BIGNUM_EMBED_LEN_MAX (BIGNUM_EMBED_LEN_MASK >> BIGNUM_EMBED_LEN_SHIFT)
 
 enum rb_int_parse_flags {
     RB_INT_PARSE_SIGN       = 0x01,
@@ -104,7 +104,12 @@ struct RBignum {
             size_t len;
             BDIGIT *digits;
         } heap;
-        BDIGIT ary[BIGNUM_EMBED_LEN_MAX];
+        /* This is a length 1 array because:
+         *   1. GCC has a bug that does not optimize C flexible array members
+         *      (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102452)
+         *   2. Zero length arrays are not supported by all compilers
+         */
+        BDIGIT ary[1];
     } as;
 };
 
@@ -164,7 +169,13 @@ 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
 
+#if HAVE_LONG_LONG
+VALUE rb_ull2big(unsigned LONG_LONG n);
+VALUE rb_ll2big(LONG_LONG n);
+#endif
+
 #if defined(HAVE_INT128_T)
+VALUE rb_uint128t2big(uint128_t n);
 VALUE rb_int128t2big(int128_t n);
 #endif
 

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/bits.h

@@ -30,13 +30,13 @@
 #include <stdint.h>             /* for uintptr_t */
 #include "internal/compilers.h" /* for MSC_VERSION_SINCE */
 
-#if MSC_VERSION_SINCE(1310)
+#ifdef _MSC_VER
 # include <stdlib.h>            /* for _byteswap_uint64 */
 #endif
 
 #if defined(HAVE_X86INTRIN_H)
 # include <x86intrin.h>         /* for _lzcnt_u64 */
-#elif MSC_VERSION_SINCE(1310)
+#elif defined(_MSC_VER)
 # include <intrin.h>            /* for the following intrinsics */
 #endif
 
@@ -50,16 +50,13 @@
 # pragma intrinsic(__lzcnt64)
 #endif
 
-#if MSC_VERSION_SINCE(1310)
+#if defined(_MSC_VER)
 # pragma intrinsic(_rotl)
 # pragma intrinsic(_rotr)
 # ifdef _WIN64
 #  pragma intrinsic(_rotl64)
 #  pragma intrinsic(_rotr64)
 # endif
-#endif
-
-#if MSC_VERSION_SINCE(1400)
 # pragma intrinsic(_BitScanForward)
 # pragma intrinsic(_BitScanReverse)
 # ifdef _WIN64
@@ -266,7 +263,7 @@ ruby_swap16(uint16_t x)
 #if __has_builtin(__builtin_bswap16)
     return __builtin_bswap16(x);
 
-#elif MSC_VERSION_SINCE(1310)
+#elif defined(_MSC_VER)
     return _byteswap_ushort(x);
 
 #else
@@ -281,7 +278,7 @@ ruby_swap32(uint32_t x)
 #if __has_builtin(__builtin_bswap32)
     return __builtin_bswap32(x);
 
-#elif MSC_VERSION_SINCE(1310)
+#elif defined(_MSC_VER)
     return _byteswap_ulong(x);
 
 #else
@@ -298,7 +295,7 @@ ruby_swap64(uint64_t x)
 #if __has_builtin(__builtin_bswap64)
     return __builtin_bswap64(x);
 
-#elif MSC_VERSION_SINCE(1310)
+#elif defined(_MSC_VER)
     return _byteswap_uint64(x);
 
 #else
@@ -323,7 +320,7 @@ nlz_int32(uint32_t x)
 #elif defined(__x86_64__) && defined(__LZCNT__)
     return (unsigned int)_lzcnt_u32(x);
 
-#elif MSC_VERSION_SINCE(1400) /* &&! defined(__AVX2__) */
+#elif defined(_MSC_VER) /* &&! defined(__AVX2__) */
     unsigned long r;
     return _BitScanReverse(&r, x) ? (31 - (int)r) : 32;
 
@@ -352,7 +349,7 @@ nlz_int64(uint64_t x)
 #elif defined(__x86_64__) && defined(__LZCNT__)
     return (unsigned int)_lzcnt_u64(x);
 
-#elif defined(_WIN64) && MSC_VERSION_SINCE(1400) /* &&! defined(__AVX2__) */
+#elif defined(_WIN64) && defined(_MSC_VER) /* &&! defined(__AVX2__) */
     unsigned long r;
     return _BitScanReverse64(&r, x) ? (63u - (unsigned int)r) : 64;
 
@@ -538,7 +535,7 @@ ntz_int32(uint32_t x)
 #if defined(__x86_64__) && defined(__BMI__)
     return (unsigned)_tzcnt_u32(x);
 
-#elif MSC_VERSION_SINCE(1400)
+#elif defined(_MSC_VER)
     /* :FIXME: Is there any way to issue TZCNT instead of BSF, apart from using
      *         assembly?  Because issuing LZCNT seems possible (see nlz.h). */
     unsigned long r;
@@ -560,7 +557,7 @@ ntz_int64(uint64_t x)
 #if defined(__x86_64__) && defined(__BMI__)
     return (unsigned)_tzcnt_u64(x);
 
-#elif defined(_WIN64) && MSC_VERSION_SINCE(1400)
+#elif defined(_WIN64) && defined(_MSC_VER)
     unsigned long r;
     return _BitScanForward64(&r, x) ? (int)r : 64;
 
@@ -608,10 +605,10 @@ RUBY_BIT_ROTL(VALUE v, int n)
 #elif __has_builtin(__builtin_rotateleft64) && (SIZEOF_VALUE * CHAR_BIT == 64)
     return __builtin_rotateleft64(v, n);
 
-#elif MSC_VERSION_SINCE(1310) && (SIZEOF_VALUE * CHAR_BIT == 32)
+#elif defined(_MSC_VER) && (SIZEOF_VALUE * CHAR_BIT == 32)
     return _rotl(v, n);
 
-#elif MSC_VERSION_SINCE(1310) && (SIZEOF_VALUE * CHAR_BIT == 64)
+#elif defined(_MSC_VER) && (SIZEOF_VALUE * CHAR_BIT == 64)
     return _rotl64(v, n);
 
 #elif defined(_lrotl) && (SIZEOF_VALUE == SIZEOF_LONG)
@@ -632,10 +629,10 @@ RUBY_BIT_ROTR(VALUE v, int n)
 #elif __has_builtin(__builtin_rotateright64) && (SIZEOF_VALUE * CHAR_BIT == 64)
     return __builtin_rotateright64(v, n);
 
-#elif MSC_VERSION_SINCE(1310) && (SIZEOF_VALUE * CHAR_BIT == 32)
+#elif defined(_MSC_VER) && (SIZEOF_VALUE * CHAR_BIT == 32)
     return _rotr(v, n);
 
-#elif MSC_VERSION_SINCE(1310) && (SIZEOF_VALUE * CHAR_BIT == 64)
+#elif defined(_MSC_VER) && (SIZEOF_VALUE * CHAR_BIT == 64)
     return _rotr64(v, n);
 
 #elif defined(_lrotr) && (SIZEOF_VALUE == SIZEOF_LONG)

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/box.h

@@ -34,15 +34,27 @@ struct rb_box_struct {
     VALUE ruby_dln_libmap;
 
     VALUE gvar_tbl;
+    struct st_table *classext_cow_classes;
 
+    bool is_root;
     bool is_user;
     bool is_optional;
 };
 typedef struct rb_box_struct rb_box_t;
 
+struct rb_box_gem_flags {
+    bool gem;
+    bool error_highlight;
+    bool did_you_mean;
+    bool syntax_suggest;
+};
+typedef struct rb_box_gem_flags rb_box_gem_flags_t;
+
 #define BOX_OBJ_P(obj) (rb_obj_class(obj) == rb_cBox)
 
-#define BOX_ROOT_P(box) (box && !box->is_user)
+#define BOX_MASTER_P(box) (box && !box->is_root && !box->is_user)
+#define BOX_MUTABLE_P(box) (box && (box->is_root || box->is_user))
+#define BOX_ROOT_P(box) (box && box->is_root)
 #define BOX_USER_P(box) (box && box->is_user)
 #define BOX_OPTIONAL_P(box) (box && box->is_optional)
 #define BOX_MAIN_P(box) (box && box->is_user && !box->is_optional)
@@ -62,6 +74,7 @@ rb_box_available(void)
     return ruby_box_enabled;
 }
 
+const rb_box_t * rb_master_box(void);
 const rb_box_t * rb_root_box(void);
 const rb_box_t * rb_main_box(void);
 const rb_box_t * rb_current_box(void);
@@ -74,8 +87,10 @@ void rb_box_gc_update_references(void *ptr);
 rb_box_t * rb_get_box_t(VALUE ns);
 VALUE rb_get_box_object(rb_box_t *ns);
 
-VALUE rb_box_local_extension(VALUE box, VALUE fname, VALUE path);
+VALUE rb_box_local_extension(VALUE box, VALUE fname, VALUE path, VALUE *cleanup);
+void rb_box_cleanup_local_extension(VALUE cleanup);
 
-void rb_initialize_main_box(void);
+void rb_initialize_mandatory_boxes(void);
 void rb_box_init_done(void);
+void rb_box_set_gem_flags(rb_box_gem_flags_t *);
 #endif /* INTERNAL_BOX_H */

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/class.h

@@ -27,41 +27,6 @@
 # undef RCLASS_SUPER
 #endif
 
-struct rb_box_subclasses {
-    long refcount;
-    struct st_table *tbl;
-};
-typedef struct rb_box_subclasses rb_box_subclasses_t;
-
-static inline long
-rb_box_subclasses_ref_count(rb_box_subclasses_t *box_sub)
-{
-    return box_sub->refcount;
-}
-
-static inline rb_box_subclasses_t *
-rb_box_subclasses_ref_inc(rb_box_subclasses_t *box_sub)
-{
-    box_sub->refcount++;
-    return box_sub;
-}
-
-static inline void
-rb_box_subclasses_ref_dec(rb_box_subclasses_t *box_sub)
-{
-    box_sub->refcount--;
-    if (box_sub->refcount == 0) {
-        st_free_table(box_sub->tbl);
-        xfree(box_sub);
-    }
-}
-
-struct rb_subclass_anchor {
-    rb_box_subclasses_t *box_subclasses;
-    struct rb_subclass_entry *head;
-};
-typedef struct rb_subclass_anchor rb_subclass_anchor_t;
-
 struct rb_subclass_entry {
     VALUE klass;
     struct rb_subclass_entry *next;
@@ -70,9 +35,10 @@ struct rb_subclass_entry {
 typedef struct rb_subclass_entry rb_subclass_entry_t;
 
 struct rb_cvar_class_tbl_entry {
+    VALUE imemo_flags;
     uint32_t index;
     rb_serial_t global_cvar_state;
-    const rb_cref_t * cref;
+    const rb_cref_t *cref;
     VALUE class_value;
 };
 
@@ -84,27 +50,24 @@ struct rb_classext_struct {
     struct rb_id_table *const_tbl;
     struct rb_id_table *callable_m_tbl;
     VALUE cc_tbl; /* { ID => { cme, [cc1, cc2, ...] }, ... } */
-    struct rb_id_table *cvc_tbl;
+    VALUE cvc_tbl;
     VALUE *superclasses;
     /**
-     * The head of subclasses is a blank (w/o klass) entry to be referred from anchor (and be never deleted).
-     * (anchor -> head -> 1st-entry)
+     * The head of the subclasses linked list. This is a dummy entry (klass == 0)
+     * whose `next` points to the first real entry. Only used in prime classext.
      */
-    struct rb_subclass_anchor *subclasses;
+    struct rb_subclass_entry *subclasses;
     /**
-     * The `box_super_subclasses` points the `box_subclasses` struct to retreive the subclasses
-     * of the super class in a specific box.
-     * In compaction GCs, collecting a classext should trigger the deletion of a rb_subclass_entry
-     * from the super's subclasses. But it may be prevented by the read barrier.
-     * Fetching the super's subclasses for a ns is to avoid the read barrier in that process.
+     * Back-pointer to this class's entry in its superclass's subclasses list.
+     * Used for O(1) removal when the class is freed.
      */
-    rb_box_subclasses_t *box_super_subclasses;
+    struct rb_subclass_entry *subclass_entry;
     /**
-     * In the case that this is an `ICLASS`, `box_module_subclasses` points to the link
-     * in the module's `subclasses` list that indicates that the klass has been
-     * included. Hopefully that makes sense.
+     * In the case that this is an `ICLASS`, `module_subclass_entry` points to the
+     * entry in the module's `subclasses` list that indicates that the klass has been
+     * included. Used for O(1) removal.
      */
-    rb_box_subclasses_t *box_module_subclasses;
+    struct rb_subclass_entry *module_subclass_entry;
 
     const VALUE origin_;
     const VALUE refined_class;
@@ -188,8 +151,8 @@ static inline rb_classext_t * RCLASS_EXT_WRITABLE(VALUE obj);
 #define RCLASSEXT_SUPERCLASS_DEPTH(ext) (ext->superclass_depth)
 #define RCLASSEXT_SUPERCLASSES(ext) (ext->superclasses)
 #define RCLASSEXT_SUBCLASSES(ext) (ext->subclasses)
-#define RCLASSEXT_BOX_SUPER_SUBCLASSES(ext) (ext->box_super_subclasses)
-#define RCLASSEXT_BOX_MODULE_SUBCLASSES(ext) (ext->box_module_subclasses)
+#define RCLASSEXT_SUBCLASS_ENTRY(ext) (ext->subclass_entry)
+#define RCLASSEXT_MODULE_SUBCLASS_ENTRY(ext) (ext->module_subclass_entry)
 #define RCLASSEXT_ORIGIN(ext) (ext->origin_)
 #define RCLASSEXT_REFINED_CLASS(ext) (ext->refined_class)
 // class.allocator/singleton_class.attached_object are not accessed directly via RCLASSEXT_*
@@ -227,8 +190,8 @@ static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE
  * so always those should be writable.
  */
 #define RCLASS_CVC_TBL(c) (RCLASS_EXT_READABLE(c)->cvc_tbl)
-#define RCLASS_SUBCLASSES_X(c) (RCLASS_EXT_READABLE(c)->subclasses)
-#define RCLASS_SUBCLASSES_FIRST(c) (RCLASS_EXT_READABLE(c)->subclasses->head->next)
+#define RCLASS_SUBCLASSES(c) (RCLASS_EXT_PRIME(c)->subclasses)
+#define RCLASS_SUBCLASSES_FIRST(c) (RCLASS_EXT_PRIME(c)->subclasses ? RCLASS_EXT_PRIME(c)->subclasses->next : NULL)
 #define RCLASS_ORIGIN(c) (RCLASS_EXT_READABLE(c)->origin_)
 #define RICLASS_IS_ORIGIN_P(c) (RCLASS_EXT_READABLE(c)->iclass_is_origin)
 #define RCLASS_PERMANENT_CLASSPATH_P(c) (RCLASS_EXT_READABLE(c)->permanent_classpath)
@@ -255,7 +218,8 @@ static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE
 #define RCLASS_WRITABLE_CALLABLE_M_TBL(c) (RCLASS_EXT_WRITABLE(c)->callable_m_tbl)
 #define RCLASS_WRITABLE_CC_TBL(c) (RCLASS_EXT_WRITABLE(c)->cc_tbl)
 #define RCLASS_WRITABLE_CVC_TBL(c) (RCLASS_EXT_WRITABLE(c)->cvc_tbl)
-#define RCLASS_WRITABLE_SUBCLASSES(c) (RCLASS_EXT_WRITABLE(c)->subclasses)
+// Subclasses are only in the prime classext (box-invariant)
+#define RCLASS_WRITABLE_SUBCLASSES(c) (RCLASS_EXT_PRIME(c)->subclasses)
 
 static inline void RCLASS_SET_SUPER(VALUE klass, VALUE super);
 static inline void RCLASS_WRITE_SUPER(VALUE klass, VALUE super);
@@ -263,13 +227,11 @@ static inline void RCLASS_SET_CONST_TBL(VALUE klass, struct rb_id_table *table,
 static inline void RCLASS_WRITE_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared);
 static inline void RCLASS_WRITE_CALLABLE_M_TBL(VALUE klass, struct rb_id_table *table);
 static inline void RCLASS_WRITE_CC_TBL(VALUE klass, VALUE table);
-static inline void RCLASS_SET_CVC_TBL(VALUE klass, struct rb_id_table *table);
-static inline void RCLASS_WRITE_CVC_TBL(VALUE klass, struct rb_id_table *table);
+static inline void RCLASS_SET_CVC_TBL(VALUE klass, VALUE table);
+static inline void RCLASS_WRITE_CVC_TBL(VALUE klass, VALUE table);
 
 static inline void RCLASS_WRITE_SUPERCLASSES(VALUE klass, size_t depth, VALUE *superclasses, bool with_self);
-static inline void RCLASS_SET_SUBCLASSES(VALUE klass, rb_subclass_anchor_t *anchor);
-static inline void RCLASS_WRITE_BOX_SUPER_SUBCLASSES(VALUE klass, rb_box_subclasses_t *box_subclasses);
-static inline void RCLASS_WRITE_BOX_MODULE_SUBCLASSES(VALUE klass, rb_box_subclasses_t *box_subclasses);
+static inline void RCLASS_SET_SUBCLASSES(VALUE klass, rb_subclass_entry_t *head);
 
 static inline void RCLASS_SET_ORIGIN(VALUE klass, VALUE origin);
 static inline void RCLASS_WRITE_ORIGIN(VALUE klass, VALUE origin);
@@ -324,7 +286,7 @@ RCLASS_SET_BOX_CLASSEXT(VALUE obj, const rb_box_t *box, rb_classext_t *ext)
 {
     int first_set = 0;
     st_table *tbl = RCLASS_CLASSEXT_TBL(obj);
-    VM_ASSERT(BOX_USER_P(box)); // non-prime classext is only for user box, with box_object
+    VM_ASSERT(BOX_MUTABLE_P(box)); // Setting non-prime classext never happens on the master box
     VM_ASSERT(box->box_object);
     VM_ASSERT(RCLASSEXT_BOX(ext) == box);
     if (!tbl) {
@@ -357,7 +319,7 @@ RCLASS_PRIME_CLASSEXT_WRITABLE_P(VALUE klass)
 {
     VM_ASSERT(klass != 0, "klass should be a valid object");
     VM_ASSERT_BOXABLE_TYPE(klass);
-    return FL_TEST(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
+    return FL_TEST_RAW(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
 }
 
 static inline void
@@ -366,10 +328,10 @@ RCLASS_SET_PRIME_CLASSEXT_WRITABLE(VALUE klass, bool writable)
     VM_ASSERT(klass != 0, "klass should be a valid object");
     VM_ASSERT_BOXABLE_TYPE(klass);
     if (writable) {
-        FL_SET(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
+        FL_SET_RAW(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
     }
     else {
-        FL_UNSET(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
+        FL_UNSET_RAW(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
     }
 }
 
@@ -399,7 +361,7 @@ RCLASS_EXT_READABLE_LOOKUP(VALUE obj, const rb_box_t *box)
 static inline rb_classext_t *
 RCLASS_EXT_READABLE_IN_BOX(VALUE obj, const rb_box_t *box)
 {
-    if (BOX_ROOT_P(box)
+    if (BOX_MASTER_P(box)
         || RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
         return RCLASS_EXT_PRIME(obj);
     }
@@ -415,7 +377,7 @@ RCLASS_EXT_READABLE(VALUE obj)
     }
     // delay determining the current box to optimize for unmodified classes
     box = rb_current_box();
-    if (BOX_ROOT_P(box)) {
+    if (BOX_MASTER_P(box)) {
         return RCLASS_EXT_PRIME(obj);
     }
     return RCLASS_EXT_READABLE_LOOKUP(obj, box);
@@ -449,7 +411,7 @@ RCLASS_EXT_WRITABLE_LOOKUP(VALUE obj, const rb_box_t *box)
 static inline rb_classext_t *
 RCLASS_EXT_WRITABLE_IN_BOX(VALUE obj, const rb_box_t *box)
 {
-    if (BOX_ROOT_P(box)
+    if (BOX_MASTER_P(box)
         || RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj)) {
         return RCLASS_EXT_PRIME(obj);
     }
@@ -465,7 +427,7 @@ RCLASS_EXT_WRITABLE(VALUE obj)
     }
     // delay determining the current box to optimize for unmodified classes
     box = rb_current_box();
-    if (BOX_ROOT_P(box)) {
+    if (BOX_MASTER_P(box)) {
         return RCLASS_EXT_PRIME(obj);
     }
     return RCLASS_EXT_WRITABLE_LOOKUP(obj, box);
@@ -488,7 +450,6 @@ RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE includer)
 typedef void rb_class_classext_foreach_callback_func(rb_classext_t *classext, bool is_prime, VALUE box_value, void *arg);
 void rb_class_classext_foreach(VALUE klass, rb_class_classext_foreach_callback_func *func, void *arg);
 void rb_class_subclass_add(VALUE super, VALUE klass);
-void rb_class_classext_free_subclasses(rb_classext_t *, VALUE, bool);
 void rb_class_foreach_subclass(VALUE klass, void (*f)(VALUE, VALUE), VALUE);
 void rb_class_update_superclasses(VALUE);
 int rb_singleton_class_internal_p(VALUE sklass);
@@ -513,6 +474,7 @@ void rb_undef_methods_from(VALUE klass, VALUE super);
 VALUE rb_class_inherited(VALUE, VALUE);
 VALUE rb_keyword_error_new(const char *, VALUE);
 
+rb_classext_t *rb_class_unlink_classext(VALUE klass, const rb_box_t *box);
 void rb_class_classext_free(VALUE klass, rb_classext_t *ext, bool is_prime);
 void rb_iclass_classext_free(VALUE klass, rb_classext_t *ext, bool is_prime);
 
@@ -637,15 +599,15 @@ RCLASS_WRITE_CC_TBL(VALUE klass, VALUE table)
 }
 
 static inline void
-RCLASS_SET_CVC_TBL(VALUE klass, struct rb_id_table *table)
+RCLASS_SET_CVC_TBL(VALUE klass, VALUE table)
 {
-    RCLASSEXT_CVC_TBL(RCLASS_EXT_PRIME(klass)) = table;
+    RB_OBJ_ATOMIC_WRITE(klass, &RCLASSEXT_CVC_TBL(RCLASS_EXT_PRIME(klass)), table);
 }
 
 static inline void
-RCLASS_WRITE_CVC_TBL(VALUE klass, struct rb_id_table *table)
+RCLASS_WRITE_CVC_TBL(VALUE klass, VALUE table)
 {
-    RCLASSEXT_CVC_TBL(RCLASS_EXT_WRITABLE(klass)) = table;
+    RB_OBJ_ATOMIC_WRITE(klass, &RCLASSEXT_CVC_TBL(RCLASS_EXT_WRITABLE(klass)), table);
 }
 
 static inline void
@@ -657,8 +619,8 @@ RCLASS_SET_REFINED_CLASS(VALUE klass, VALUE refined)
 static inline rb_alloc_func_t
 RCLASS_ALLOCATOR(VALUE klass)
 {
-    RUBY_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_ICLASS));
-    if (RCLASS_SINGLETON_P(klass) || RB_TYPE_P(klass, T_ICLASS)) {
+    RBIMPL_ASSERT_TYPE(klass, T_CLASS);
+    if (RCLASS_SINGLETON_P(klass)) {
         return 0;
     }
     return RCLASS_EXT_PRIME(klass)->as.class.allocator;
@@ -726,28 +688,10 @@ RCLASS_WRITE_SUPERCLASSES(VALUE klass, size_t depth, VALUE *superclasses, bool w
 }
 
 static inline void
-RCLASS_SET_SUBCLASSES(VALUE klass, struct rb_subclass_anchor *anchor)
+RCLASS_SET_SUBCLASSES(VALUE klass, rb_subclass_entry_t *head)
 {
     rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
-    RCLASSEXT_SUBCLASSES(ext) = anchor;
-}
-
-static inline void
-RCLASS_WRITE_BOX_SUPER_SUBCLASSES(VALUE klass, rb_box_subclasses_t *box_subclasses)
-{
-    rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
-    if (RCLASSEXT_BOX_SUPER_SUBCLASSES(ext))
-        rb_box_subclasses_ref_dec(RCLASSEXT_BOX_SUPER_SUBCLASSES(ext));
-    RCLASSEXT_BOX_SUPER_SUBCLASSES(ext) = rb_box_subclasses_ref_inc(box_subclasses);
-}
-
-static inline void
-RCLASS_WRITE_BOX_MODULE_SUBCLASSES(VALUE klass, rb_box_subclasses_t *box_subclasses)
-{
-    rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
-    if (RCLASSEXT_BOX_MODULE_SUBCLASSES(ext))
-        rb_box_subclasses_ref_dec(RCLASSEXT_BOX_MODULE_SUBCLASSES(ext));
-    RCLASSEXT_BOX_MODULE_SUBCLASSES(ext) = rb_box_subclasses_ref_inc(box_subclasses);
+    RCLASSEXT_SUBCLASSES(ext) = head;
 }
 
 static inline void

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/cont.h

@@ -31,5 +31,4 @@ VALUE rb_fiber_inherit_storage(struct rb_execution_context_struct *ec, struct rb
 VALUE rb_fiberptr_self(struct rb_fiber_struct *fiber);
 unsigned int rb_fiberptr_blocking(struct rb_fiber_struct *fiber);
 struct rb_execution_context_struct * rb_fiberptr_get_ec(struct rb_fiber_struct *fiber);
-
 #endif /* INTERNAL_CONT_H */

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/eval.h

@@ -11,6 +11,7 @@
  *             header (related to this file, but not the same role).
  */
 #include "ruby/ruby.h"          /* for ID */
+#include "vm_core.h"          /* for ID */
 
 #define id_signo ruby_static_id_signo
 #define id_status ruby_static_id_status
@@ -30,6 +31,7 @@ VALUE rb_exception_setup(int argc, VALUE *argv);
 void rb_refinement_setup(struct rb_refinements_data *data, VALUE module, VALUE klass);
 void rb_vm_using_module(VALUE module);
 VALUE rb_top_main_class(const char *method);
+VALUE rb_ec_ensure(rb_execution_context_t *ec, VALUE (*b_proc)(VALUE), VALUE data1, VALUE (*e_proc)(VALUE), VALUE data2);
 
 /* eval_error.c */
 VALUE rb_get_backtrace(VALUE info);

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/gc.h

@@ -122,10 +122,12 @@ const char *rb_raw_obj_info(char *const buff, const size_t buff_size, VALUE obj)
 struct rb_execution_context_struct; /* in vm_core.h */
 struct rb_objspace; /* in vm_core.h */
 
-#define NEWOBJ_OF(var, T, c, f, s, ec) \
+#define NEWOBJ_OF_WITH_SHAPE(var, T, c, f, shape_id, s, ec) \
     T *(var) = (T *)(((f) & FL_WB_PROTECTED) ? \
-            rb_wb_protected_newobj_of((ec ? ec : GET_EC()), (c), (f) & ~FL_WB_PROTECTED, s) : \
-            rb_wb_unprotected_newobj_of((c), (f), s))
+            rb_wb_protected_newobj_of((ec ? ec : GET_EC()), (c), (f) & ~FL_WB_PROTECTED, shape_id, s) : \
+            rb_wb_unprotected_newobj_of((c), (f), shape_id, s))
+
+#define NEWOBJ_OF(var, T, c, f, s, ec) NEWOBJ_OF_WITH_SHAPE(var, T, c, f, 0 /* ROOT_SHAPE_ID */, s, ec)
 
 #ifndef RB_GC_OBJECT_METADATA_ENTRY_DEFINED
 # define RB_GC_OBJECT_METADATA_ENTRY_DEFINED
@@ -248,8 +250,8 @@ VALUE rb_gc_disable_no_rest(void);
 
 /* gc.c (export) */
 const char *rb_objspace_data_type_name(VALUE obj);
-VALUE rb_wb_protected_newobj_of(struct rb_execution_context_struct *, VALUE, VALUE, size_t);
-VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE, size_t);
+VALUE rb_wb_protected_newobj_of(struct rb_execution_context_struct *, VALUE, VALUE, uint32_t /* shape_id_t */, size_t);
+VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE, uint32_t /* shape_id_t */, size_t);
 size_t rb_obj_memsize_of(VALUE);
 struct rb_gc_object_metadata_entry *rb_gc_object_metadata(VALUE obj);
 void rb_gc_mark_values(long n, const VALUE *values);

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/imemo.h

@@ -37,6 +37,7 @@ enum imemo_type {
     imemo_ment           =  6,
     imemo_iseq           =  7,
     imemo_tmpbuf         =  8,
+    imemo_cvar_entry     =  9,
     imemo_callinfo       = 10,
     imemo_callcache      = 11,
     imemo_constcache     = 12,

data/lib/datadog/ruby_core_source/{ruby-4.0.0-preview2 → ruby-4.0.6-p0}/internal/inits.h

@@ -11,7 +11,7 @@
 
 /* box.c */
 void Init_enable_box(void);
-void Init_root_box(void);
+void Init_master_box(void);
 
 /* class.c */
 void Init_class_hierarchy(void);