datadog-ruby_core_source 3.3.6 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ec714497a760b5d980a750e9714e66764a5d15f16a64e662930dbe0d6fb42de
-  data.tar.gz: 48694ad218f613ab0d7c788f23fca5c650e92763af9ce3fb81e9c9cf1185db9c
+  metadata.gz: 7470c7abdc5d94bc72ee812550d229f64dba4c2dec7b4f60820dc37967c2cf2e
+  data.tar.gz: a504f8f22d8cc0de40f3a4fec72b0e185b323166a1057d7943c2943eed80994e
 SHA512:
-  metadata.gz: d54ba0edb39e0f2ecaab66a3cc97e92938753290b9762b7899113da31d3b9eedd82df434367fb16fc04e627954f566ca1d31ffa0b15bef85626001a948b4b74a
-  data.tar.gz: 8da9aef7c7229156d33830db314a7aaba4cfa91ca7f6288020ea81a8e2fab885942682691427ea28a7f8742df2439906ec56ec5f592d30d50f70610139befda2
+  metadata.gz: 1b091fedb7e84e5d9afdb6e2c62f65a70f006e097b0db3b1bd72f701921b98799928afd34c841f5531448e2f2726d3fb620fc575d08853810698dee90c5ae5da
+  data.tar.gz: 1bfe4205e866f8c692350cb6563e664715f87eab4ebd965e2e59b6e7bbd096acc892683b83969f042896740fb43a8cd6eef5e2eaee78ba5ac11069378477528d

data/CHANGELOG.datadog.md

@@ -1,4 +1,19 @@
-## 2024-10-18
+## [3.4.1] - 2025-04-23
+
+* Add 3.5.0-preview1 headers
+
+## [3.4.0] - 2025-01-27
+
+* Removed 3.4.0-preview2, 3.4.0-rc1 headers
+* Add 3.4.0 headers
+
+## [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/README.md

@@ -1,8 +1,10 @@
+# `datadog-ruby_core_source`
+
 ## Description
-Fork of [debase-ruby\_core\_source](https://github.com/ruby-debug/debase-ruby_core_source/)
-that uses included Ruby headers (\*.h and \*.inc) instead of downloading
-them. Used by [dd-trace-rb](https://github.com/DataDog/dd-trace-rb).
-Only Ruby 2.5, 3.3, and 3.4 versions are supported - [see here for more information](https://github.com/DataDog/dd-trace-rb/blob/master/ext/datadog_profiling_native_extension/NativeExtensionDesign.md#usage-of-private-vm-headers).
+
+This gem is a fork of [debase-ruby\_core\_source](https://github.com/ruby-debug/debase-ruby_core_source/) for [dd-trace-rb](https://github.com/DataDog/dd-trace-rb).
+
+Only Ruby 2.5 and 3.3+ Rubies are included [see here for more information on why](https://github.com/DataDog/dd-trace-rb/blob/master/ext/datadog_profiling_native_extension/NativeExtensionDesign.md#usage-of-private-vm-headers).
 
 ## Usage
 
@@ -24,11 +26,12 @@ To add another ruby version's source to this gem's directory:
 
 _Adding released versions_. `add_source` can use a pre-downloaded .tgz file. Use TGZ_FILE_NAME to pass it. Note that the PATCHLEVEL variable is optional because `add_source` can extract the patch level from version.h of the downloaded sources.
 
-_Adding pre-release versions_. For pre-releases, do not provide the PATCHLEVEL, as it is not present in distribution. To find sources of pre-release versions, this gem will look in the `Datadog::RubyCoreSource::REVISION_MAP` hash. Please add the respective entry into this hash when adding pre-release version sources. 
+Then, run the `find_includes.rb` to minimize the shipped files. See comments on that file for how to use it, and/or reference previous PRs.
 
 ## Credits
 
 The following credits are in the upstream `debase-ruby_core_source` README:
+
 * @valich for 2.5.0-preview1 headers and src-based ruby support
 * @dirknilius for 2.2.3 headers
 * @andremedeiros for 2.1.1 headers

data/datadog-ruby_core_source.gemspec

@@ -5,16 +5,21 @@ 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}
   s.description = %q{Provide Ruby core source files for C extensions that need them.}
   s.license = "MIT"
   s.required_rubygems_version = ">= 1.3.6"
-  s.required_ruby_version = '>= 2.0.0'
+  s.required_ruby_version = '>= 2.5.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-preview2 → ruby-3.4.0-p0}/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,
@@ -221,6 +223,7 @@ enum ruby_method_ids {
 
     /* CONST tokens {{{ */
     tTOKEN_CONST_BEGIN = tTOKEN_GLOBAL_END-1,
+    tRuby,
     tTOKEN_CONST_END,
     /* CONST tokens }}} */
 
@@ -245,6 +248,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),
@@ -327,6 +331,7 @@ enum ruby_method_ids {
 
     /* CONST IDs {{{ */
 #define DEFINE_CONSTID_FROM_TOKEN(n) id##n = TOKEN2CONSTID(t##n)
+    DEFINE_CONSTID_FROM_TOKEN(Ruby),
 #undef DEFINE_CONSTID_FROM_TOKEN
     /* CONST IDs }}} */
 

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

@@ -38,6 +38,7 @@ enum ruby_basic_operators {
     BOP_CMP,
     BOP_DEFAULT,
     BOP_PACK,
+    BOP_INCLUDE_P,
 
     BOP_LAST_
 };

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/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-p0}/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-preview2 → ruby-3.4.0-p0}/internal/error.h

@@ -72,6 +72,7 @@ const char *rb_builtin_type_name(int t);
 const char *rb_builtin_class_name(VALUE x);
 PRINTF_ARGS(void rb_warn_deprecated(const char *fmt, const char *suggest, ...), 1, 3);
 PRINTF_ARGS(void rb_warn_deprecated_to_remove(const char *removal, const char *fmt, const char *suggest, ...), 2, 4);
+PRINTF_ARGS(void rb_warn_reserved_name(const char *removal, const char *fmt, ...), 2, 3);
 #if RUBY_DEBUG
 # include "ruby/version.h"
 # define RUBY_VERSION_SINCE(major, minor) (RUBY_API_VERSION_CODE >= (major * 10000) + (minor) * 100)
@@ -110,6 +111,14 @@ rb_deprecated_method_to_be_removed(const char *removal)
     RBIMPL_ATTR_DIAGNOSE_IF(RUBY_VERSION_STRING_SINCE(removal), "deprecated method to be removed", "error")
 {
 }
+
+RBIMPL_ATTR_FORCEINLINE()
+static void
+rb_diagnose_reserved_name_at(const char *coming)
+    RBIMPL_ATTR_DIAGNOSE_IF(!RUBY_VERSION_isdigit(coming[0]), "malformed version number", "error")
+    RBIMPL_ATTR_DIAGNOSE_IF(RUBY_VERSION_STRING_SINCE(coming), "reserved name already in use", "error")
+{
+}
 # else
 RBIMPL_ATTR_ERROR(("deprecated"))
 void rb_deprecated_method_to_be_removed(const char *);
@@ -117,16 +126,32 @@ void rb_deprecated_method_to_be_removed(const char *);
     (sizeof(char[1-2*(!RUBY_VERSION_isdigit(removal[0]) || RUBY_VERSION_STRING_SINCE(removal))])!=1 ? \
      rb_deprecated_method_to_be_removed(removal) : \
      RBIMPL_ASSERT_NOTHING)
+
+RBIMPL_ATTR_ERROR(("deprecated"))
+void rb_diagnose_reserved_name_at(const char *);
+#   define rb_diagnose_reserved_name_at(coming) \
+    (sizeof(char[1-2*(!RUBY_VERSION_isdigit(coming[0]) || RUBY_VERSION_STRING_SINCE(coming))])!=1 ? \
+     rb_diagnose_reserved_name_at(coming) : \
+     RBIMPL_ASSERT_NOTHING)
+
 # endif
 # define rb_warn_deprecated_to_remove_at(removal, ...) \
     (rb_deprecated_method_to_be_removed(#removal), \
      rb_warn_deprecated_to_remove(#removal, __VA_ARGS__))
+
+# define rb_warn_reserved_name_at(coming, ...) \
+    (rb_diagnose_reserved_name_at(#coming), \
+     rb_warn_reserved_name(#coming, __VA_ARGS__))
 # endif
 #endif
 #ifndef rb_warn_deprecated_to_remove_at
 # define rb_warn_deprecated_to_remove_at(removal, ...) \
         rb_warn_deprecated_to_remove(#removal, __VA_ARGS__)
 #endif
+#ifndef rb_warn_reserved_name_at
+# define rb_warn_reserved_name_at(removal, ...) \
+        rb_warn_reserved_name(#removal, __VA_ARGS__)
+#endif
 #ifndef RUBY_VERSION_SINCE
 # define RUBY_VERSION_SINCE(major, minor) 0
 #endif
@@ -160,6 +185,7 @@ NORETURN(static inline void rb_key_err_raise(VALUE mesg, VALUE recv, VALUE name)
 static inline void Check_Type(VALUE v, enum ruby_value_type t);
 static inline bool rb_typeddata_is_instance_of_inline(VALUE obj, const rb_data_type_t *data_type);
 #define rb_typeddata_is_instance_of rb_typeddata_is_instance_of_inline
+void rb_bug_without_die(const char *fmt, ...);
 
 RUBY_SYMBOL_EXPORT_BEGIN
 /* error.c (export) */

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/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-preview2 → ruby-3.4.0-p0}/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__)
@@ -175,7 +175,6 @@ struct rb_objspace; /* in vm_core.h */
     if (_already_disabled == Qfalse) rb_gc_enable()
 
 /* 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);
@@ -197,7 +196,7 @@ static inline void *ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size
 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_cache_alloc(void);
+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);
@@ -213,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); \
@@ -225,6 +227,7 @@ void rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), v
 void rb_objspace_reachable_objects_from_root(void (func)(const char *category, VALUE, void *), void *data);
 int rb_objspace_internal_object_p(VALUE obj);
 int rb_objspace_garbage_object_p(VALUE obj);
+bool rb_gc_pointer_to_heap_p(VALUE obj);
 
 void rb_objspace_each_objects(
     int (*callback)(void *start, void *end, size_t stride, void *data),
@@ -234,6 +237,7 @@ 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);
@@ -248,14 +252,18 @@ void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR
 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);
 
-#if USE_SHARED_GC
-void ruby_load_external_gc_from_argv(int argc, char **argv);
+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-preview2 → ruby-3.4.0-p0}/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;

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/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. */

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/internal/parse.h

@@ -79,8 +79,9 @@ 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*);
 int rb_parser_reg_fragment_check(struct parser_params*, rb_parser_string_t*, int);
-int rb_reg_named_capture_assign_iter_impl(struct parser_params *p, const char *s, long len, rb_encoding *enc, NODE **succ_block, const rb_code_location_t *loc);
+int rb_reg_named_capture_assign_iter_impl(struct parser_params *p, const char *s, long len, rb_encoding *enc, NODE **succ_block, const rb_code_location_t *loc, rb_parser_assignable_func assignable);
 int rb_parser_local_defined(struct parser_params *p, ID id, const struct rb_iseq_struct *iseq);
+NODE *rb_parser_assignable(struct parser_params *p, ID id, NODE *val, const YYLTYPE *loc);
 
 RUBY_SYMBOL_EXPORT_END
 

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-p0}/internal/proc.h

@@ -23,6 +23,7 @@ VALUE rb_block_to_s(VALUE self, const struct rb_block *block, const char *additi
 VALUE rb_callable_receiver(VALUE);
 
 VALUE rb_func_proc_new(rb_block_call_func_t func, VALUE val);
+VALUE rb_func_proc_dup(VALUE src_obj);
 VALUE rb_func_lambda_new(rb_block_call_func_t func, VALUE val, int min_argc, int max_argc);
 VALUE rb_iseq_location(const struct rb_iseq_struct *iseq);
 VALUE rb_sym_to_proc(VALUE sym);

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-p0}/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-preview2 → ruby-3.4.0-p0}/internal/sanitizers.h

@@ -16,7 +16,7 @@
 #endif
 
 #ifdef HAVE_SANITIZER_ASAN_INTERFACE_H
-# if __has_feature(address_sanitizer)
+# if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
 #  define RUBY_ASAN_ENABLED
 #  include <sanitizer/asan_interface.h>
 # endif
@@ -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
@@ -115,26 +119,22 @@ asan_poison_memory_region(const volatile void *ptr, size_t size)
     __asan_poison_memory_region(ptr, size);
 }
 
-/**
- * This is a variant of asan_poison_memory_region that takes a VALUE.
- *
- * @param[in]  obj   target object.
- */
-static inline void
-asan_poison_object(VALUE obj)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    asan_poison_memory_region(ptr, SIZEOF_VALUE);
-}
-
 #ifdef RUBY_ASAN_ENABLED
 #define asan_poison_object_if(ptr, obj) do { \
-        if (ptr) asan_poison_object(obj); \
+        if (ptr) rb_asan_poison_object(obj); \
     } while (0)
 #else
 #define asan_poison_object_if(ptr, obj) ((void)(ptr), (void)(obj))
 #endif
 
+RUBY_SYMBOL_EXPORT_BEGIN
+/**
+ * This is a variant of asan_poison_memory_region that takes a VALUE.
+ *
+ * @param[in]  obj   target object.
+ */
+void rb_asan_poison_object(VALUE obj);
+
 /**
  * This function predicates if the given object is fully addressable or not.
  *
@@ -142,12 +142,17 @@ asan_poison_object(VALUE obj)
  * @retval     0          the given object is fully addressable.
  * @retval     otherwise  pointer to first such byte who is poisoned.
  */
-static inline void *
-asan_poisoned_object_p(VALUE obj)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    return __asan_region_is_poisoned(ptr, SIZEOF_VALUE);
-}
+void *rb_asan_poisoned_object_p(VALUE obj);
+
+/**
+ * This is a variant of asan_unpoison_memory_region that takes a VALUE.
+ *
+ * @param[in]  obj       target object.
+ * @param[in]  malloc_p  if the memory region is like a malloc's return value or not.
+ */
+void rb_asan_unpoison_object(VALUE obj, bool newobj_p);
+
+RUBY_SYMBOL_EXPORT_END
 
 /**
  * This function asserts that a (formally poisoned) memory region from ptr to
@@ -176,24 +181,11 @@ asan_unpoison_memory_region(const volatile void *ptr, size_t size, bool malloc_p
     }
 }
 
-/**
- * This is a variant of asan_unpoison_memory_region that takes a VALUE.
- *
- * @param[in]  obj       target object.
- * @param[in]  malloc_p  if the memory region is like a malloc's return value or not.
- */
-static inline void
-asan_unpoison_object(VALUE obj, bool newobj_p)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    asan_unpoison_memory_region(ptr, SIZEOF_VALUE, newobj_p);
-}
-
 static inline void *
 asan_unpoison_object_temporary(VALUE obj)
 {
-    void *ptr = asan_poisoned_object_p(obj);
-    asan_unpoison_object(obj, false);
+    void *ptr = rb_asan_poisoned_object_p(obj);
+    rb_asan_unpoison_object(obj, false);
     return ptr;
 }
 
@@ -201,7 +193,7 @@ static inline void *
 asan_poison_object_restore(VALUE obj, void *ptr)
 {
     if (ptr) {
-        asan_poison_object(obj);
+        rb_asan_poison_object(obj);
     }
     return NULL;
 }

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/internal/string.h

@@ -15,9 +15,11 @@
 #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,
@@ -51,12 +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);
@@ -123,14 +131,18 @@ CHILLED_STRING_P(VALUE obj)
 static inline void
 CHILLED_STRING_MUTATED(VALUE str)
 {
+    VALUE chilled_reason = RB_FL_TEST_RAW(str, STR_CHILLED);
     FL_UNSET_RAW(str, STR_CHILLED);
-    rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "literal string will be frozen in the future");
-}
-
-static inline void
-STR_CHILL_RAW(VALUE str)
-{
-    FL_SET_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

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/internal/thread.h

@@ -66,6 +66,8 @@ struct rb_io_close_wait_list {
 int rb_notify_fd_close(int fd, struct rb_io_close_wait_list *busy);
 void rb_notify_fd_close_wait(struct rb_io_close_wait_list *busy);
 
+void rb_ec_check_ints(struct rb_execution_context_struct *ec);
+
 RUBY_SYMBOL_EXPORT_BEGIN
 
 void *rb_thread_prevent_fork(void *(*func)(void *), void *data); /* for ext/socket/raddrinfo.c */
@@ -82,4 +84,25 @@ RUBY_SYMBOL_EXPORT_END
 int rb_threadptr_execute_interrupts(struct rb_thread_struct *th, int blocking_timing);
 bool rb_thread_mn_schedulable(VALUE thread);
 
+// interrupt exec
+
+typedef VALUE (rb_interrupt_exec_func_t)(void *data);
+
+enum rb_interrupt_exec_flag {
+    rb_interrupt_exec_flag_none = 0x00,
+    rb_interrupt_exec_flag_value_data = 0x01,
+};
+
+// interrupt the target_th and run func.
+struct rb_ractor_struct;
+
+void rb_threadptr_interrupt_exec(struct rb_thread_struct *target_th,
+                                 rb_interrupt_exec_func_t *func, void *data, enum rb_interrupt_exec_flag flags);
+
+// create a thread in the target_r and run func on the created thread.
+void rb_ractor_interrupt_exec(struct rb_ractor_struct *target_r,
+                              rb_interrupt_exec_func_t *func, void *data, enum rb_interrupt_exec_flag flags);
+
+void rb_threadptr_interrupt_exec_task_mark(struct rb_thread_struct *th);
+
 #endif /* INTERNAL_THREAD_H */