datadog-ruby_core_source 3.3.6 → 3.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ec714497a760b5d980a750e9714e66764a5d15f16a64e662930dbe0d6fb42de
-  data.tar.gz: 48694ad218f613ab0d7c788f23fca5c650e92763af9ce3fb81e9c9cf1185db9c
+  metadata.gz: 640fafef2d6fd5b47ad31e030466f953c1392627b792993842d2faf87672971f
+  data.tar.gz: b98be1cfb06e954f8a7c3e9854c8db7816629ee4cb1082fabc19a841cf1d72d3
 SHA512:
-  metadata.gz: d54ba0edb39e0f2ecaab66a3cc97e92938753290b9762b7899113da31d3b9eedd82df434367fb16fc04e627954f566ca1d31ffa0b15bef85626001a948b4b74a
-  data.tar.gz: 8da9aef7c7229156d33830db314a7aaba4cfa91ca7f6288020ea81a8e2fab885942682691427ea28a7f8742df2439906ec56ec5f592d30d50f70610139befda2
+  metadata.gz: fad66114abf5661df3b8ea86888e865e9eb60275565e993d44dc923b5514339e59f1125df023e5310d2d92cc0b4cab673852095faf8539036436e4e88b2226a9
+  data.tar.gz: cb71c539e7586bf50149b5bc3efaae55c53ed0a6cab14a9b94dd3ca95ac751286e8b9e6fc03ab3e5db46c83053ee5aa3a990d869340b920f8e6b4fef8c3c625d

data/CHANGELOG.datadog.md

@@ -1,4 +1,10 @@
-## 2024-10-18
+## [3.3.7] - 2024-12-13
+
+* Remove headers and files not used by dd-trace-rb
+* Removed 3.4.0-preview1 headers
+* Add 3.4.0-rc1 headers
+
+## [3.3.6] - 2024-10-18
 
 * Initial release - gem renamed to datadog-ruby_source_code, Debase module renamed to Datadog
 * only sources for 2.5, 3.3, and 3.4 included

data/datadog-ruby_core_source.gemspec

@@ -5,7 +5,7 @@ require File.dirname(__FILE__) + "/lib/datadog/ruby_core_source/version"
 Gem::Specification.new do |s|
   s.name = "datadog-ruby_core_source"
   s.version = Datadog::RubyCoreSource::VERSION
-  s.authors = ["Mark Moseley", "Gabriel Horner", "JetBrains RubyMine Team"]
+  s.authors = ["Mark Moseley", "Gabriel Horner", "JetBrains RubyMine Team", "Datadog, Inc."]
   s.email = "dev@datadoghq.com"
   s.homepage = "https://github.com/DataDog/datadog-ruby_core_source"
   s.summary = %q{Provide Ruby core source files}
@@ -15,6 +15,11 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.0.0'
   s.extra_rdoc_files = [ "README.md"]
   s.files = `git ls-files`.split("\n")
+    .reject { |fn| fn.include?('find_includes.rb') }
+    .reject { |fn| fn.include?('Gemfile') }
+    .reject { |fn| fn.include?('Rakefile') }
+    .reject { |fn| fn.include?('.github/') }
+    .reject { |fn| fn.include?('.gitignore') }
   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-3.4.0-preview1 → ruby-3.4.0-rc1}/id.h

@@ -110,6 +110,7 @@ enum ruby_method_ids {
     idANDDOT = RUBY_TOKEN(ANDDOT),
     tPRESERVED_ID_BEGIN = 150,
     idNilP,
+    idIncludeP,
     idNULL,
     idEmptyP,
     idEqlP,
@@ -139,6 +140,7 @@ enum ruby_method_ids {
     tInspect,
     tIntern,
     tObject_id,
+    t__id__,
     tConst_added,
     tConst_missing,
     tMethodMissing,
@@ -190,6 +192,8 @@ enum ruby_method_ids {
     tName,
     tNil,
     tPath,
+    tPack,
+    tBuffer,
     tUScore,
     tNUMPARAM_1,
     tNUMPARAM_2,
@@ -243,6 +247,7 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(Inspect),
     DEFINE_LOCALID_FROM_TOKEN(Intern),
     DEFINE_LOCALID_FROM_TOKEN(Object_id),
+    DEFINE_LOCALID_FROM_TOKEN(__id__),
     DEFINE_LOCALID_FROM_TOKEN(Const_added),
     DEFINE_LOCALID_FROM_TOKEN(Const_missing),
     DEFINE_LOCALID_FROM_TOKEN(MethodMissing),
@@ -294,6 +299,8 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(Name),
     DEFINE_LOCALID_FROM_TOKEN(Nil),
     DEFINE_LOCALID_FROM_TOKEN(Path),
+    DEFINE_LOCALID_FROM_TOKEN(Pack),
+    DEFINE_LOCALID_FROM_TOKEN(Buffer),
     DEFINE_LOCALID_FROM_TOKEN(UScore),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_1),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_2),

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/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);
+RUBY_EXTERN VALUE rb_cArray_empty_frozen;
 
 static inline VALUE rb_ary_entry_internal(VALUE ary, long offset);
 static inline bool ARY_PTR_USING_P(VALUE ary);

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/basic_operators.h

@@ -37,6 +37,8 @@ enum ruby_basic_operators {
     BOP_OR,
     BOP_CMP,
     BOP_DEFAULT,
+    BOP_PACK,
+    BOP_INCLUDE_P,
 
     BOP_LAST_
 };

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/bits.h

@@ -90,6 +90,7 @@
 
 #define UNSIGNED_INTEGER_MAX(T) ((T)~(T)0)
 
+#ifndef MUL_OVERFLOW_SIGNED_INTEGER_P
 #if __has_builtin(__builtin_mul_overflow_p)
 # define MUL_OVERFLOW_P(a, b) \
     __builtin_mul_overflow_p((a), (b), (__typeof__(a * b))0)
@@ -131,6 +132,87 @@
 # define MUL_OVERFLOW_LONG_P(a, b)      MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
 # define MUL_OVERFLOW_INT_P(a, b)       MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
 #endif
+#endif
+
+#ifndef ADD_OVERFLOW_SIGNED_INTEGER_P
+#if __has_builtin(__builtin_add_overflow_p)
+# define ADD_OVERFLOW_P(a, b) \
+    __builtin_add_overflow_p((a), (b), (__typeof__(a * b))0)
+#elif __has_builtin(__builtin_add_overflow)
+# define ADD_OVERFLOW_P(a, b) \
+    __extension__ ({ __typeof__(a) c; __builtin_add_overflow((a), (b), &c); })
+#endif
+
+#define ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
+    (a) > 0 ? (b) > (max) - (a) : (b) < (min) - (a))
+
+#if __has_builtin(__builtin_add_overflow_p)
+/* __builtin_add_overflow_p can take bitfield */
+/* and GCC permits bitfields for integers other than int */
+# define ADD_OVERFLOW_FIXNUM_P(a, b) \
+    __extension__ ({ \
+        struct { long fixnum : sizeof(long) * CHAR_BIT - 1; } c = { 0 }; \
+        __builtin_add_overflow_p((a), (b), c.fixnum); \
+    })
+#else
+# define ADD_OVERFLOW_FIXNUM_P(a, b) \
+    ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
+#endif
+
+#if defined(ADD_OVERFLOW_P) && defined(USE___BUILTIN_ADD_OVERFLOW_LONG_LONG)
+# define ADD_OVERFLOW_LONG_LONG_P(a, b) ADD_OVERFLOW_P(a, b)
+#else
+# define ADD_OVERFLOW_LONG_LONG_P(a, b) ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, LLONG_MIN, LLONG_MAX)
+#endif
+
+#ifdef ADD_OVERFLOW_P
+# define ADD_OVERFLOW_LONG_P(a, b)      ADD_OVERFLOW_P(a, b)
+# define ADD_OVERFLOW_INT_P(a, b)       ADD_OVERFLOW_P(a, b)
+#else
+# define ADD_OVERFLOW_LONG_P(a, b)      ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
+# define ADD_OVERFLOW_INT_P(a, b)       ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
+#endif
+#endif
+
+#ifndef SUB_OVERFLOW_SIGNED_INTEGER_P
+#if __has_builtin(__builtin_sub_overflow_p)
+# define SUB_OVERFLOW_P(a, b) \
+    __builtin_sub_overflow_p((a), (b), (__typeof__(a * b))0)
+#elif __has_builtin(__builtin_sub_overflow)
+# define SUB_OVERFLOW_P(a, b) \
+    __extension__ ({ __typeof__(a) c; __builtin_sub_overflow((a), (b), &c); })
+#endif
+
+#define SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
+        (b) > 0 ? (a) < (min) + (b) : (a) > (max) + (b))
+
+#if __has_builtin(__builtin_sub_overflow_p)
+/* __builtin_sub_overflow_p can take bitfield */
+/* and GCC permits bitfields for integers other than int */
+# define SUB_OVERFLOW_FIXNUM_P(a, b) \
+    __extension__ ({ \
+        struct { long fixnum : sizeof(long) * CHAR_BIT - 1; } c = { 0 }; \
+        __builtin_sub_overflow_p((a), (b), c.fixnum); \
+    })
+#else
+# define SUB_OVERFLOW_FIXNUM_P(a, b) \
+    SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
+#endif
+
+#if defined(SUB_OVERFLOW_P) && defined(USE___BUILTIN_SUB_OVERFLOW_LONG_LONG)
+# define SUB_OVERFLOW_LONG_LONG_P(a, b) SUB_OVERFLOW_P(a, b)
+#else
+# define SUB_OVERFLOW_LONG_LONG_P(a, b) SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, LLONG_MIN, LLONG_MAX)
+#endif
+
+#ifdef SUB_OVERFLOW_P
+# define SUB_OVERFLOW_LONG_P(a, b)      SUB_OVERFLOW_P(a, b)
+# define SUB_OVERFLOW_INT_P(a, b)       SUB_OVERFLOW_P(a, b)
+#else
+# define SUB_OVERFLOW_LONG_P(a, b)      SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
+# define SUB_OVERFLOW_INT_P(a, b)       SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
+#endif
+#endif
 
 #ifdef HAVE_UINT128_T
 # define bit_length(x) \

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/class.h

@@ -83,7 +83,7 @@ struct RClass {
     struct rb_id_table *m_tbl;
 };
 
-// Assert that classes can be embedded in size_pools[2] (which has 160B slot size)
+// Assert that classes can be embedded in heaps[2] (which has 160B slot size)
 STATIC_ASSERT(sizeof_rb_classext_t, sizeof(struct RClass) + sizeof(rb_classext_t) <= 4 * RVALUE_SIZE);
 
 struct RClass_and_rb_classext_t {

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/encoding.h

@@ -28,6 +28,8 @@ 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_enc_raw_set(VALUE obj, rb_encoding *enc);
+
 PUREFUNC(int rb_data_is_encoding(VALUE obj));
 
 /* vm.c */

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/error.h

@@ -142,6 +142,8 @@ VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding*, const char*,
 PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
 PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
 PRINTF_ARGS(void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt, ...), 3, 4);
+PRINTF_ARGS(void rb_enc_compile_warning(rb_encoding *enc, const char *file, int line, const char *fmt, ...), 4, 5);
+PRINTF_ARGS(void rb_enc_compile_warn(rb_encoding *enc, const char *file, int line, const char *fmt, ...), 4, 5);
 rb_warning_category_t rb_warning_category_from_name(VALUE category);
 bool rb_warning_category_enabled_p(rb_warning_category_t category);
 VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/fixnum.h

@@ -10,6 +10,7 @@
  */
 #include "ruby/internal/config.h"      /* for HAVE_LONG_LONG */
 #include <limits.h>             /* for CHAR_BIT */
+#include "internal/bits.h"      /* for MUL_OVERFLOW_FIXNUM_P */
 #include "internal/compilers.h" /* for __has_builtin */
 #include "ruby/internal/stdbool.h"     /* for bool */
 #include "ruby/intern.h"        /* for rb_big_mul */

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/gc.h

@@ -16,8 +16,8 @@
 #include "ruby/ruby.h"          /* for rb_event_flag_t */
 #include "vm_core.h"            /* for GET_EC() */
 
-#ifndef USE_SHARED_GC
-# define USE_SHARED_GC 0
+#ifndef USE_MODULAR_GC
+# define USE_MODULAR_GC 0
 #endif
 
 #if defined(__x86_64__) && !defined(_ILP32) && defined(__GNUC__)
@@ -163,12 +163,6 @@ struct rb_objspace; /* in vm_core.h */
     RB_OBJ_WRITE(old, _slot, young); \
 } while (0)
 
-// We use SIZE_POOL_COUNT number of shape IDs for transitions out of different size pools
-// The next available shape ID will be the SPECIAL_CONST_SHAPE_ID
-#ifndef SIZE_POOL_COUNT
-# define SIZE_POOL_COUNT 5
-#endif
-
 /* Used in places that could malloc during, which can cause the GC to run. We
  * need to temporarily disable the GC to allow the malloc to happen.
  * Allocating memory during GC is a bad idea, so use this only when absolutely
@@ -180,25 +174,14 @@ struct rb_objspace; /* in vm_core.h */
 #define DURING_GC_COULD_MALLOC_REGION_END() \
     if (_already_disabled == Qfalse) rb_gc_enable()
 
-typedef struct ractor_newobj_size_pool_cache {
-    struct RVALUE *freelist;
-    struct heap_page *using_page;
-} rb_ractor_newobj_size_pool_cache_t;
-
-typedef struct ractor_newobj_cache {
-    size_t incremental_mark_step_allocated_slots;
-    rb_ractor_newobj_size_pool_cache_t size_pool_caches[SIZE_POOL_COUNT];
-} rb_ractor_newobj_cache_t;
-
 /* gc.c */
-extern int ruby_disable_gc;
 RUBY_ATTR_MALLOC void *ruby_mimmalloc(size_t size);
 RUBY_ATTR_MALLOC void *ruby_mimcalloc(size_t num, size_t size);
 void ruby_mimfree(void *ptr);
 void rb_gc_prepare_heap(void);
 void rb_objspace_set_event_hook(const rb_event_flag_t event);
-VALUE rb_objspace_gc_enable(struct rb_objspace *);
-VALUE rb_objspace_gc_disable(struct rb_objspace *);
+VALUE rb_objspace_gc_enable(void *objspace);
+VALUE rb_objspace_gc_disable(void *objspace);
 void ruby_gc_set_params(void);
 void rb_gc_copy_attributes(VALUE dest, VALUE obj);
 size_t rb_size_mul_or_raise(size_t, size_t, VALUE); /* used in compile.c */
@@ -212,12 +195,13 @@ RUBY_ATTR_MALLOC void *rb_xcalloc_mul_add_mul(size_t, size_t, size_t, size_t);
 static inline void *ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
 static inline void *ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
 static inline void ruby_sized_xfree_inlined(void *ptr, size_t size);
-void rb_gc_ractor_newobj_cache_clear(rb_ractor_newobj_cache_t *newobj_cache);
+
+void *rb_gc_ractor_cache_alloc(rb_ractor_t *ractor);
+void rb_gc_ractor_cache_free(void *cache);
+
 bool rb_gc_size_allocatable_p(size_t size);
-size_t *rb_gc_size_pool_sizes(void);
-size_t rb_gc_size_pool_id_for_size(size_t size);
-int rb_objspace_garbage_object_p(VALUE obj);
-bool rb_gc_is_ptr_to_obj(const void *ptr);
+size_t *rb_gc_heap_sizes(void);
+size_t rb_gc_heap_id_for_size(size_t size);
 
 void rb_gc_mark_and_move(VALUE *ptr);
 
@@ -228,6 +212,9 @@ void rb_gc_ref_update_table_values_only(st_table *tbl);
 
 void rb_gc_initial_stress_set(VALUE flag);
 
+void rb_gc_before_fork(void);
+void rb_gc_after_fork(rb_pid_t pid);
+
 #define rb_gc_mark_and_move_ptr(ptr) do { \
     VALUE _obj = (VALUE)*(ptr); \
     rb_gc_mark_and_move(&_obj); \
@@ -238,8 +225,8 @@ RUBY_SYMBOL_EXPORT_BEGIN
 /* exports for objspace module */
 void rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data);
 void rb_objspace_reachable_objects_from_root(void (func)(const char *category, VALUE, void *), void *data);
-int rb_objspace_markable_object_p(VALUE obj);
 int rb_objspace_internal_object_p(VALUE obj);
+int rb_objspace_garbage_object_p(VALUE obj);
 
 void rb_objspace_each_objects(
     int (*callback)(void *start, void *end, size_t stride, void *data),
@@ -249,13 +236,13 @@ size_t rb_gc_obj_slot_size(VALUE obj);
 
 VALUE rb_gc_disable_no_rest(void);
 
+#define RB_GC_MAX_NAME_LEN 20
 
 /* 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);
 size_t rb_obj_memsize_of(VALUE);
-void rb_gc_verify_internal_consistency(void);
 size_t rb_obj_gc_flags(VALUE, ID[], size_t);
 void rb_gc_mark_values(long n, const VALUE *values);
 void rb_gc_mark_vm_stack_values(long n, const VALUE *values);
@@ -263,11 +250,19 @@ void rb_gc_update_values(long n, VALUE *values);
 void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
 void *ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
 void ruby_sized_xfree(void *x, size_t size);
+
+const char *rb_gc_active_gc_name(void);
+int rb_gc_modular_gc_loaded_p(void);
+
+#if USE_MODULAR_GC
+void ruby_load_modular_gc_from_argv(int argc, char **argv);
+#endif
 RUBY_SYMBOL_EXPORT_END
 
 int rb_ec_stack_check(struct rb_execution_context_struct *ec);
 void rb_gc_writebarrier_remember(VALUE obj);
 const char *rb_obj_info(VALUE obj);
+void ruby_annotate_mmap(const void *addr, unsigned long size, const char *name);
 
 #if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
 

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/hash.h

@@ -88,6 +88,7 @@ int rb_hash_stlike_foreach_with_replace(VALUE hash, st_foreach_check_callback_fu
 int rb_hash_stlike_update(VALUE hash, st_data_t key, st_update_callback_func *func, st_data_t arg);
 VALUE rb_ident_hash_new_with_size(st_index_t size);
 void rb_hash_free(VALUE hash);
+RUBY_EXTERN VALUE rb_cHash_empty_frozen;
 
 static inline unsigned RHASH_AR_TABLE_SIZE_RAW(VALUE h);
 static inline VALUE RHASH_IFNONE(VALUE h);

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/imemo.h

@@ -79,7 +79,12 @@ struct vm_ifunc_argc {
 #endif
 };
 
-/*! IFUNC (Internal FUNCtion) */
+/*! IFUNC (Internal FUNCtion)
+ *
+ * Bookkeeping for converting a C function and some closed-over data into a
+ * block passable to methods. Like Ruby Proc, but not directly accessible at
+ * Ruby level since this is an imemo. See rb_block_call() and friends.
+ */
 struct vm_ifunc {
     VALUE flags;
     VALUE *svar_lep;
@@ -87,6 +92,7 @@ struct vm_ifunc {
     const void *data;
     struct vm_ifunc_argc argc;
 };
+#define IFUNC_YIELD_OPTIMIZABLE IMEMO_FL_USER0
 
 struct rb_imemo_tmpbuf_struct {
     VALUE flags;

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/io.h

@@ -15,7 +15,7 @@ struct rb_io;
 
 #include "ruby/io.h"            /* for rb_io_t */
 
-#define IO_WITHOUT_GVL(func, arg) rb_thread_call_without_gvl(func, arg, RUBY_UBF_IO, 0)
+#define IO_WITHOUT_GVL(func, arg) rb_nogvl(func, arg, RUBY_UBF_IO, 0, RB_NOGVL_OFFLOAD_SAFE)
 #define IO_WITHOUT_GVL_INT(func, arg) (int)(VALUE)IO_WITHOUT_GVL(func, arg)
 
 /** Ruby's IO, metadata and buffers. */
@@ -135,6 +135,9 @@ RUBY_SYMBOL_EXPORT_BEGIN
 void rb_maygvl_fd_fix_cloexec(int fd);
 int rb_gc_for_fd(int err);
 void rb_write_error_str(VALUE mesg);
+
+VALUE rb_io_blocking_region_wait(struct rb_io *io, rb_blocking_function_t *function, void *argument, enum rb_io_event events);
+VALUE rb_io_blocking_region(struct rb_io *io, rb_blocking_function_t *function, void *argument);
 RUBY_SYMBOL_EXPORT_END
 
 #endif /* INTERNAL_IO_H */

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/parse.h

@@ -12,6 +12,17 @@
 #include "rubyparser.h"
 #include "internal/static_assert.h"
 
+// The default parser to use for Ruby code.
+typedef enum {
+    RB_DEFAULT_PARSER_PARSE_Y,
+    RB_DEFAULT_PARSER_PRISM,
+} ruby_default_parser_enum;
+
+ruby_default_parser_enum rb_ruby_default_parser(void);
+void rb_ruby_default_parser_set(ruby_default_parser_enum parser);
+
+#define rb_ruby_prism_p() (rb_ruby_default_parser() == RB_DEFAULT_PARSER_PRISM)
+
 #ifdef UNIVERSAL_PARSER
 #define rb_encoding const void
 #endif
@@ -55,7 +66,7 @@ void rb_ruby_parser_set_script_lines(rb_parser_t *p);
 void rb_ruby_parser_error_tolerant(rb_parser_t *p);
 void rb_ruby_parser_keep_tokens(rb_parser_t *p);
 typedef rb_parser_string_t*(rb_parser_lex_gets_func)(struct parser_params*, rb_parser_input_data, int);
-rb_ast_t *rb_parser_compile(rb_parser_t *p, rb_parser_lex_gets_func *gets, const char *fname_ptr, long fname_len, rb_encoding *fname_enc, rb_parser_input_data input, int line);
+rb_ast_t *rb_parser_compile(rb_parser_t *p, rb_parser_lex_gets_func *gets, VALUE fname, rb_parser_input_data input, int line);
 
 RUBY_SYMBOL_EXPORT_BEGIN
 
@@ -63,6 +74,7 @@ rb_encoding *rb_ruby_parser_encoding(rb_parser_t *p);
 int rb_ruby_parser_end_seen_p(rb_parser_t *p);
 int rb_ruby_parser_set_yydebug(rb_parser_t *p, int flag);
 rb_parser_string_t *rb_str_to_parser_string(rb_parser_t *p, VALUE str);
+void rb_parser_string_free(rb_parser_t *p, rb_parser_string_t *str);
 
 int rb_parser_dvar_defined_ref(struct parser_params*, ID, ID**);
 ID rb_parser_internal_id(struct parser_params*);
@@ -97,7 +109,7 @@ VALUE rb_ruby_parser_ruby_sourcefile_string(rb_parser_t *p);
 int rb_ruby_parser_ruby_sourceline(rb_parser_t *p);
 int rb_ruby_parser_lex_state(rb_parser_t *p);
 void rb_ruby_ripper_parse0(rb_parser_t *p);
-int rb_ruby_ripper_dedent_string(rb_parser_t *p, VALUE string, int width);
+int rb_ruby_ripper_dedent_string(rb_parser_t *p, rb_parser_string_t *string, int width);
 int rb_ruby_ripper_initialized_p(rb_parser_t *p);
 void rb_ruby_ripper_parser_initialize(rb_parser_t *p);
 long rb_ruby_ripper_column(rb_parser_t *p);

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/ractor.h

@@ -3,4 +3,8 @@
 
 void rb_ractor_ensure_main_ractor(const char *msg);
 
+RUBY_SYMBOL_EXPORT_BEGIN
+void rb_ractor_setup_belonging(VALUE obj);
+RUBY_SYMBOL_EXPORT_END
+
 #endif /* INTERNAL_RACTOR_H */

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/sanitizers.h

@@ -39,6 +39,9 @@
 #elif defined(RUBY_ASAN_ENABLED)
 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
     __attribute__((__no_sanitize__("address"), __noinline__)) x
+#elif defined(RUBY_MSAN_ENABLED)
+    # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
+    __attribute__((__no_sanitize__("memory"), __noinline__)) x
 #elif defined(NO_SANITIZE_ADDRESS)
 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
     NO_SANITIZE_ADDRESS(NOINLINE(x))
@@ -54,10 +57,11 @@
 # include "internal/warnings.h"
 # undef NO_SANITIZE
 # define NO_SANITIZE(x, y) \
-    COMPILER_WARNING_PUSH; \
-    COMPILER_WARNING_IGNORED(-Wattributes); \
+    COMPILER_WARNING_PUSH \
+    COMPILER_WARNING_IGNORED(-Wattributes) \
     __attribute__((__no_sanitize__(x))) y; \
-    COMPILER_WARNING_POP
+    COMPILER_WARNING_POP \
+    y
 #endif
 
 #ifndef NO_SANITIZE
@@ -206,6 +210,35 @@ asan_poison_object_restore(VALUE obj, void *ptr)
     return NULL;
 }
 
+#define asan_unpoisoning_object(obj) \
+    for (void *poisoned = asan_unpoison_object_temporary(obj), \
+              *unpoisoning = &poisoned; /* flag to loop just once */ \
+         unpoisoning; \
+         unpoisoning = asan_poison_object_restore(obj, poisoned))
+
+
+static inline void *
+asan_unpoison_memory_region_temporary(void *ptr, size_t len)
+{
+    void *poisoned_ptr = __asan_region_is_poisoned(ptr, len);
+    asan_unpoison_memory_region(ptr, len, false);
+    return poisoned_ptr;
+}
+
+static inline void *
+asan_poison_memory_region_restore(void *ptr, size_t len, void *poisoned_ptr)
+{
+    if (poisoned_ptr) {
+        asan_poison_memory_region(ptr, len);
+    }
+    return NULL;
+}
+
+#define asan_unpoisoning_memory_region(ptr, len) \
+    for (void *poisoned = asan_unpoison_memory_region_temporary(ptr, len), \
+              *unpoisoning = &poisoned; /* flag to loop just once */ \
+         unpoisoning; \
+         unpoisoning = asan_poison_memory_region_restore(ptr, len, poisoned))
 
 /**
  * Checks if the given pointer is on an ASAN fake stack. If so, it returns the

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-rc1}/internal/string.h

@@ -15,9 +15,15 @@
 #include "ruby/encoding.h"      /* for rb_encoding */
 #include "ruby/ruby.h"          /* for VALUE */
 
-#define STR_NOEMBED      FL_USER1
-#define STR_SHARED       FL_USER2 /* = ELTS_SHARED */
-#define STR_CHILLED      FL_USER3
+#define STR_SHARED                  FL_USER0 /* = ELTS_SHARED */
+#define STR_NOEMBED                 FL_USER1
+#define STR_CHILLED                 (FL_USER2 | FL_USER3)
+#define STR_CHILLED_LITERAL         FL_USER2
+#define STR_CHILLED_SYMBOL_TO_S     FL_USER3
+
+enum ruby_rstring_private_flags {
+    RSTRING_CHILLED = STR_CHILLED,
+};
 
 #ifdef rb_fstring_cstr
 # undef rb_fstring_cstr
@@ -47,6 +53,18 @@ int rb_enc_str_coderange_scan(VALUE str, rb_encoding *enc);
 int rb_ascii8bit_appendable_encoding_index(rb_encoding *enc, unsigned int code);
 VALUE rb_str_include(VALUE str, VALUE arg);
 VALUE rb_str_byte_substr(VALUE str, VALUE beg, VALUE len);
+VALUE rb_str_substr_two_fixnums(VALUE str, VALUE beg, VALUE len, int empty);
+VALUE rb_str_tmp_frozen_no_embed_acquire(VALUE str);
+void rb_str_make_embedded(VALUE);
+VALUE rb_str_upto_each(VALUE, VALUE, int, int (*each)(VALUE, VALUE), VALUE);
+size_t rb_str_size_as_embedded(VALUE);
+bool rb_str_reembeddable_p(VALUE);
+VALUE rb_str_upto_endless_each(VALUE, int (*each)(VALUE, VALUE), VALUE);
+VALUE rb_str_with_debug_created_info(VALUE, VALUE, int);
+
+/* error.c */
+void rb_warn_unchilled_literal(VALUE str);
+void rb_warn_unchilled_symbol_to_s(VALUE str);
 
 static inline bool STR_EMBED_P(VALUE str);
 static inline bool STR_SHARED_P(VALUE str);
@@ -59,14 +77,8 @@ static inline VALUE rb_str_eql_internal(const VALUE str1, const VALUE str2);
 RUBY_SYMBOL_EXPORT_BEGIN
 /* string.c (export) */
 VALUE rb_str_tmp_frozen_acquire(VALUE str);
-VALUE rb_str_tmp_frozen_no_embed_acquire(VALUE str);
 void rb_str_tmp_frozen_release(VALUE str, VALUE tmp);
 VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
-VALUE rb_str_upto_each(VALUE, VALUE, int, int (*each)(VALUE, VALUE), VALUE);
-VALUE rb_str_upto_endless_each(VALUE, int (*each)(VALUE, VALUE), VALUE);
-void rb_str_make_embedded(VALUE);
-size_t rb_str_size_as_embedded(VALUE);
-bool rb_str_reembeddable_p(VALUE);
 RUBY_SYMBOL_EXPORT_END
 
 VALUE rb_fstring_new(const char *ptr, long len);
@@ -76,6 +88,7 @@ VALUE rb_str_concat_literals(size_t num, const VALUE *strary);
 VALUE rb_str_eql(VALUE str1, VALUE str2);
 VALUE rb_id_quote_unprintable(ID);
 VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc);
+VALUE rb_enc_literal_str(const char *ptr, long len, rb_encoding *enc);
 
 struct rb_execution_context_struct;
 VALUE rb_ec_str_resurrect(struct rb_execution_context_struct *ec, VALUE str, bool chilled);
@@ -118,15 +131,18 @@ CHILLED_STRING_P(VALUE obj)
 static inline void
 CHILLED_STRING_MUTATED(VALUE str)
 {
-    rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "literal string will be frozen in the future");
-    FL_UNSET_RAW(str, STR_CHILLED | FL_FREEZE);
-}
-
-static inline void
-STR_CHILL_RAW(VALUE str)
-{
-    // Chilled strings are always also frozen
-    FL_SET_RAW(str, STR_CHILLED | RUBY_FL_FREEZE);
+    VALUE chilled_reason = RB_FL_TEST_RAW(str, STR_CHILLED);
+    FL_UNSET_RAW(str, STR_CHILLED);
+    switch (chilled_reason) {
+      case STR_CHILLED_SYMBOL_TO_S:
+        rb_warn_unchilled_symbol_to_s(str);
+        break;
+      case STR_CHILLED_LITERAL:
+        rb_warn_unchilled_literal(str);
+        break;
+      default:
+        rb_bug("RString was chilled for multiple reasons");
+    }
 }
 
 static inline bool