104 files changed, 3833 insertions, 3057 deletions

diff --git a/include/ruby/assert.h b/include/ruby/assert.h
index 0c052363bc..acc5e5bbfc 100644
--- a/include/ruby/assert.h
+++ b/include/ruby/assert.h
@@ -22,6 +22,7 @@
  */
 #include "ruby/internal/assume.h"
 #include "ruby/internal/attr/cold.h"
+#include "ruby/internal/attr/format.h"
 #include "ruby/internal/attr/noreturn.h"
 #include "ruby/internal/cast.h"
 #include "ruby/internal/dllexport.h"
@@ -132,6 +133,11 @@ RBIMPL_SYMBOL_EXPORT_BEGIN()
 RBIMPL_ATTR_NORETURN()
 RBIMPL_ATTR_COLD()
 void rb_assert_failure(const char *file, int line, const char *name, const char *expr);
+
+RBIMPL_ATTR_NORETURN()
+RBIMPL_ATTR_COLD()
+RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 5, 6)
+void rb_assert_failure_detail(const char *file, int line, const char *name, const char *expr, const char *fmt, ...);
 RBIMPL_SYMBOL_EXPORT_END()
 
 #ifdef RUBY_FUNCTION_NAME_STRING
@@ -147,8 +153,28 @@ RBIMPL_SYMBOL_EXPORT_END()
  *
  * @param  mesg  The message to display.
  */
-#define RUBY_ASSERT_FAIL(mesg) \
+#if defined(HAVE___VA_OPT__)
+# if RBIMPL_HAS_WARNING("-Wgnu-zero-variadic-macro-arguments")
+/* __VA_OPT__ is to be used for the zero variadic macro arguments
+ * cases. */
+RBIMPL_WARNING_IGNORED(-Wgnu-zero-variadic-macro-arguments)
+# endif
+# define RBIMPL_VA_OPT_ARGS(...) __VA_OPT__(,) __VA_ARGS__
+
+# define RUBY_ASSERT_FAIL(mesg, ...) \
+    rb_assert_failure##__VA_OPT__(_detail)( \
+        __FILE__, __LINE__, RBIMPL_ASSERT_FUNC, mesg RBIMPL_VA_OPT_ARGS(__VA_ARGS__))
+#elif !defined(__cplusplus)
+# define RBIMPL_VA_OPT_ARGS(...)
+
+# define RUBY_ASSERT_FAIL(mesg, ...) \
     rb_assert_failure(__FILE__, __LINE__, RBIMPL_ASSERT_FUNC, mesg)
+#else
+# undef RBIMPL_VA_OPT_ARGS
+
+# define RUBY_ASSERT_FAIL(mesg) \
+    rb_assert_failure(__FILE__, __LINE__, RBIMPL_ASSERT_FUNC, mesg)
+#endif
 
 /**
  * Asserts that the expression is truthy.  If not aborts with the message.
@@ -156,15 +182,25 @@ RBIMPL_SYMBOL_EXPORT_END()
  * @param  expr  What supposedly evaluates to true.
  * @param  mesg  The message to display on failure.
  */
-#define RUBY_ASSERT_MESG(expr, mesg) \
+#if defined(RBIMPL_VA_OPT_ARGS)
+# define RUBY_ASSERT_MESG(expr, ...) \
+    (RB_LIKELY(expr) ? RBIMPL_ASSERT_NOTHING : RUBY_ASSERT_FAIL(__VA_ARGS__))
+#else
+# define RUBY_ASSERT_MESG(expr, mesg) \
     (RB_LIKELY(expr) ? RBIMPL_ASSERT_NOTHING : RUBY_ASSERT_FAIL(mesg))
+#endif
 
 /**
  * A variant of #RUBY_ASSERT that does not interface with #RUBY_DEBUG.
  *
  * @copydetails #RUBY_ASSERT
  */
-#define RUBY_ASSERT_ALWAYS(expr) RUBY_ASSERT_MESG((expr), #expr)
+#if defined(RBIMPL_VA_OPT_ARGS)
+# define RUBY_ASSERT_ALWAYS(expr, ...) \
+    RUBY_ASSERT_MESG(expr, #expr RBIMPL_VA_OPT_ARGS(__VA_ARGS__))
+#else
+# define RUBY_ASSERT_ALWAYS(expr) RUBY_ASSERT_MESG((expr), #expr)
+#endif
 
 /**
  * Asserts that the given expression is truthy if and only if #RUBY_DEBUG is truthy.
@@ -172,9 +208,18 @@ RBIMPL_SYMBOL_EXPORT_END()
  * @param  expr  What supposedly evaluates to true.
  */
 #if RUBY_DEBUG
-# define RUBY_ASSERT(expr) RUBY_ASSERT_MESG((expr), #expr)
+# if defined(RBIMPL_VA_OPT_ARGS)
+#   define RUBY_ASSERT(expr, ...) \
+    RUBY_ASSERT_MESG((expr), #expr RBIMPL_VA_OPT_ARGS(__VA_ARGS__))
+# else
+#   define RUBY_ASSERT(expr) RUBY_ASSERT_MESG((expr), #expr)
+# endif
 #else
-# define RUBY_ASSERT(expr) RBIMPL_ASSERT_NOTHING
+# if defined(RBIMPL_VA_OPT_ARGS)
+#   define RUBY_ASSERT(/* expr, */...) RBIMPL_ASSERT_NOTHING
+# else
+#   define RUBY_ASSERT(expr) RBIMPL_ASSERT_NOTHING
+# endif
 #endif
 
 /**
@@ -187,9 +232,18 @@ RBIMPL_SYMBOL_EXPORT_END()
 /* Currently  `RUBY_DEBUG == ! defined(NDEBUG)` is  always true.   There is  no
  * difference any longer between this one and `RUBY_ASSERT`. */
 #if defined(NDEBUG)
-# define RUBY_ASSERT_NDEBUG(expr) RBIMPL_ASSERT_NOTHING
+# if defined(RBIMPL_VA_OPT_ARGS)
+#   define RUBY_ASSERT_NDEBUG(/* expr, */...) RBIMPL_ASSERT_NOTHING
+# else
+#   define RUBY_ASSERT_NDEBUG(expr) RBIMPL_ASSERT_NOTHING
+# endif
 #else
-# define RUBY_ASSERT_NDEBUG(expr) RUBY_ASSERT_MESG((expr), #expr)
+# if defined(RBIMPL_VA_OPT_ARGS)
+#   define RUBY_ASSERT_NDEBUG(expr, ...) \
+    RUBY_ASSERT_MESG((expr), #expr RBIMPL_VA_OPT_ARGS(__VA_ARGS__))
+# else
+#   define RUBY_ASSERT_NDEBUG(expr) RUBY_ASSERT_MESG((expr), #expr)
+# endif
 #endif
 
 /**
@@ -197,10 +251,20 @@ RBIMPL_SYMBOL_EXPORT_END()
  * @param  mesg  The message to display on failure.
  */
 #if RUBY_DEBUG
-# define RUBY_ASSERT_MESG_WHEN(cond, expr, mesg) RUBY_ASSERT_MESG((expr), (mesg))
+# if defined(RBIMPL_VA_OPT_ARGS)
+#   define RUBY_ASSERT_MESG_WHEN(cond, /* expr, */...)  \
+    RUBY_ASSERT_MESG(__VA_ARGS__)
+# else
+#   define RUBY_ASSERT_MESG_WHEN(cond, expr, mesg) RUBY_ASSERT_MESG((expr), (mesg))
+# endif
 #else
-# define RUBY_ASSERT_MESG_WHEN(cond, expr, mesg) \
+# if defined(RBIMPL_VA_OPT_ARGS)
+#   define RUBY_ASSERT_MESG_WHEN(cond, expr, ...) \
+    ((cond) ? RUBY_ASSERT_MESG((expr), __VA_ARGS__) : RBIMPL_ASSERT_NOTHING)
+# else
+#   define RUBY_ASSERT_MESG_WHEN(cond, expr, mesg) \
     ((cond) ? RUBY_ASSERT_MESG((expr), (mesg)) : RBIMPL_ASSERT_NOTHING)
+# endif
 #endif
 
 /**
@@ -210,7 +274,23 @@ RBIMPL_SYMBOL_EXPORT_END()
  * @param  cond  Extra condition that shall hold for assertion to take effect.
  * @param  expr  What supposedly evaluates to true.
  */
-#define RUBY_ASSERT_WHEN(cond, expr) RUBY_ASSERT_MESG_WHEN((cond), (expr), #expr)
+#if defined(RBIMPL_VA_OPT_ARGS)
+# define RUBY_ASSERT_WHEN(cond, expr, ...) \
+    RUBY_ASSERT_MESG_WHEN(cond, expr, #expr RBIMPL_VA_OPT_ARGS(__VA_ARGS__))
+#else
+# define RUBY_ASSERT_WHEN(cond, expr) RUBY_ASSERT_MESG_WHEN((cond), (expr), #expr)
+#endif
+
+/**
+ * A variant of #RUBY_ASSERT that  asserts when either #RUBY_DEBUG or built-in
+ * type of `obj` is `type`.
+ *
+ * @param  obj  Object to check its built-in typue.
+ * @param  type  Built-in type constant, T_ARRAY, T_STRING, etc.
+ */
+#define RUBY_ASSERT_BUILTIN_TYPE(obj, type) \
+    RUBY_ASSERT(RB_TYPE_P(obj, type), \
+                "Actual type is %s", rb_builtin_type_name(BUILTIN_TYPE(obj)))
 
 /**
  * This is either #RUBY_ASSERT or #RBIMPL_ASSUME, depending on #RUBY_DEBUG.
@@ -218,17 +298,19 @@ RBIMPL_SYMBOL_EXPORT_END()
  * @copydetails #RUBY_ASSERT
  */
 #if RUBY_DEBUG
-# define RBIMPL_ASSERT_OR_ASSUME(expr) RUBY_ASSERT_ALWAYS(expr)
+# define RBIMPL_ASSERT_OR_ASSUME RUBY_ASSERT_ALWAYS
+#elif ! defined(RBIMPL_VA_OPT_ARGS)
+# define RBIMPL_ASSERT_OR_ASSUME(expr) RBIMPL_ASSUME(expr)
 #elif RBIMPL_COMPILER_BEFORE(Clang, 7, 0, 0)
 # /* See commit 67d259c5dccd31fe49d417fec169977712ffdf10 */
-# define RBIMPL_ASSERT_OR_ASSUME(expr) RBIMPL_ASSERT_NOTHING
+# define RBIMPL_ASSERT_OR_ASSUME(...) RBIMPL_ASSERT_NOTHING
 #elif defined(RUBY_ASSERT_NOASSUME)
 # /* See commit d300a734414ef6de7e8eb563b7cc4389c455ed08 */
-# define RBIMPL_ASSERT_OR_ASSUME(expr) RBIMPL_ASSERT_NOTHING
+# define RBIMPL_ASSERT_OR_ASSUME(...) RBIMPL_ASSERT_NOTHING
 #elif ! defined(RBIMPL_HAVE___ASSUME)
-# define RBIMPL_ASSERT_OR_ASSUME(expr) RBIMPL_ASSERT_NOTHING
+# define RBIMPL_ASSERT_OR_ASSUME(...) RBIMPL_ASSERT_NOTHING
 #else
-# define RBIMPL_ASSERT_OR_ASSUME(expr) RBIMPL_ASSUME(expr)
+# define RBIMPL_ASSERT_OR_ASSUME(expr, ...) RBIMPL_ASSUME(expr)
 #endif
 
 #endif /* RUBY_ASSERT_H */
diff --git a/include/ruby/atomic.h b/include/ruby/atomic.h
index 3eb80fbf7d..fcc48f532c 100644
--- a/include/ruby/atomic.h
+++ b/include/ruby/atomic.h
@@ -34,7 +34,7 @@
 # include <sys/types.h>         /* ssize_t */
 #endif
 
-#if RBIMPL_COMPILER_SINCE(MSVC, 13, 0, 0)
+#if RBIMPL_COMPILER_IS(MSVC)
 # pragma intrinsic(_InterlockedOr)
 #elif defined(__sun) && defined(HAVE_ATOMIC_H)
 # include <atomic.h>
@@ -72,13 +72,40 @@ typedef unsigned int rb_atomic_t;
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
 typedef unsigned int rb_atomic_t;
 #elif defined(_WIN32)
+# include <winsock2.h>       // to prevent macro redefinitions
+# include <windows.h>        // for `LONG` and `Interlocked` functions
 typedef LONG rb_atomic_t;
 #elif defined(__sun) && defined(HAVE_ATOMIC_H)
 typedef unsigned int rb_atomic_t;
+#elif defined(HAVE_STDATOMIC_H)
+# include <stdatomic.h>
+typedef unsigned int rb_atomic_t;
 #else
 # error No atomic operation found
 #endif
 
+/* Memory ordering constants */
+#if defined(HAVE_GCC_ATOMIC_BUILTINS)
+# define RBIMPL_ATOMIC_RELAXED __ATOMIC_RELAXED
+# define RBIMPL_ATOMIC_ACQUIRE __ATOMIC_ACQUIRE
+# define RBIMPL_ATOMIC_RELEASE __ATOMIC_RELEASE
+# define RBIMPL_ATOMIC_ACQ_REL __ATOMIC_ACQ_REL
+# define RBIMPL_ATOMIC_SEQ_CST __ATOMIC_SEQ_CST
+#elif defined(HAVE_STDATOMIC_H)
+# define RBIMPL_ATOMIC_RELAXED memory_order_relaxed
+# define RBIMPL_ATOMIC_ACQUIRE memory_order_acquire
+# define RBIMPL_ATOMIC_RELEASE memory_order_release
+# define RBIMPL_ATOMIC_ACQ_REL memory_order_acq_rel
+# define RBIMPL_ATOMIC_SEQ_CST memory_order_seq_cst
+#else
+/* Dummy values for unsupported platforms */
+# define RBIMPL_ATOMIC_RELAXED 0
+# define RBIMPL_ATOMIC_ACQUIRE 1
+# define RBIMPL_ATOMIC_RELEASE 2
+# define RBIMPL_ATOMIC_ACQ_REL 3
+# define RBIMPL_ATOMIC_SEQ_CST 4
+#endif
+
 /**
  * Atomically replaces the  value pointed by `var` with the  result of addition
  * of `val` to the old value of `var`.
@@ -88,7 +115,7 @@ typedef unsigned int rb_atomic_t;
  * @return  What was stored in `var` before the addition.
  * @post    `var` holds `var + val`.
  */
-#define RUBY_ATOMIC_FETCH_ADD(var, val) rbimpl_atomic_fetch_add(&(var), (val))
+#define RUBY_ATOMIC_FETCH_ADD(var, val) rbimpl_atomic_fetch_add(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Atomically  replaces  the  value  pointed   by  `var`  with  the  result  of
@@ -99,7 +126,7 @@ typedef unsigned int rb_atomic_t;
  * @return  What was stored in `var` before the subtraction.
  * @post    `var` holds `var - val`.
  */
-#define RUBY_ATOMIC_FETCH_SUB(var, val) rbimpl_atomic_fetch_sub(&(var), (val))
+#define RUBY_ATOMIC_FETCH_SUB(var, val) rbimpl_atomic_fetch_sub(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Atomically  replaces  the  value  pointed   by  `var`  with  the  result  of
@@ -111,7 +138,7 @@ typedef unsigned int rb_atomic_t;
  * @post    `var` holds `var | val`.
  * @note    For portability, this macro can return void.
  */
-#define RUBY_ATOMIC_OR(var, val) rbimpl_atomic_or(&(var), (val))
+#define RUBY_ATOMIC_OR(var, val) rbimpl_atomic_or(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Atomically replaces the value pointed by  `var` with `val`.  This is just an
@@ -122,7 +149,7 @@ typedef unsigned int rb_atomic_t;
  * @return  What was stored in `var` before the assignment.
  * @post    `var` holds `val`.
  */
-#define RUBY_ATOMIC_EXCHANGE(var, val) rbimpl_atomic_exchange(&(var), (val))
+#define RUBY_ATOMIC_EXCHANGE(var, val) rbimpl_atomic_exchange(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Atomic compare-and-swap.   This stores  `val` to  `var` if  and only  if the
@@ -136,7 +163,16 @@ typedef unsigned int rb_atomic_t;
  * @retval  otherwise  Something else is at `var`; not updated.
  */
 #define RUBY_ATOMIC_CAS(var, oldval, newval) \
-    rbimpl_atomic_cas(&(var), (oldval), (newval))
+    rbimpl_atomic_cas(&(var), (oldval), (newval), RBIMPL_ATOMIC_SEQ_CST, RBIMPL_ATOMIC_SEQ_CST)
+
+/**
+ * Atomic load. This loads `var` with an atomic intrinsic and returns
+ * its value.
+ *
+ * @param var  A variable of ::rb_atomic_t
+ * @return     What was stored in `var`j
+ */
+#define RUBY_ATOMIC_LOAD(var) rbimpl_atomic_load(&(var), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_EXCHANGE, except for the return type.
@@ -146,7 +182,7 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `val`.
  */
-#define RUBY_ATOMIC_SET(var, val) rbimpl_atomic_set(&(var), (val))
+#define RUBY_ATOMIC_SET(var, val) rbimpl_atomic_store(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_FETCH_ADD, except for the return type.
@@ -156,7 +192,7 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `var + val`.
  */
-#define RUBY_ATOMIC_ADD(var, val) rbimpl_atomic_add(&(var), (val))
+#define RUBY_ATOMIC_ADD(var, val) rbimpl_atomic_add(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_FETCH_SUB, except for the return type.
@@ -166,7 +202,7 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `var - val`.
  */
-#define RUBY_ATOMIC_SUB(var, val) rbimpl_atomic_sub(&(var), (val))
+#define RUBY_ATOMIC_SUB(var, val) rbimpl_atomic_sub(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Atomically increments the value pointed by `var`.
@@ -175,7 +211,7 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `var + 1`.
  */
-#define RUBY_ATOMIC_INC(var) rbimpl_atomic_inc(&(var))
+#define RUBY_ATOMIC_INC(var) rbimpl_atomic_inc(&(var), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Atomically decrements the value pointed by `var`.
@@ -184,7 +220,19 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `var - 1`.
  */
-#define RUBY_ATOMIC_DEC(var) rbimpl_atomic_dec(&(var))
+#define RUBY_ATOMIC_DEC(var) rbimpl_atomic_dec(&(var), RBIMPL_ATOMIC_SEQ_CST)
+
+/**
+ * Identical to #RUBY_ATOMIC_FETCH_ADD,  except it expects its arguments to be `size_t`.
+ * There are cases where ::rb_atomic_t is  32bit while `size_t` is 64bit.  This
+ * should be used for size related operations to support such platforms.
+ *
+ * @param   var  A variable of `size_t`.
+ * @param   val  Value to add.
+ * @return  What was stored in `var` before the addition.
+ * @post    `var` holds `var + val`.
+ */
+#define RUBY_ATOMIC_SIZE_FETCH_ADD(var, val) rbimpl_atomic_size_fetch_add(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_INC,  except it expects its  argument is `size_t`.
@@ -195,7 +243,7 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `var + 1`.
  */
-#define RUBY_ATOMIC_SIZE_INC(var) rbimpl_atomic_size_inc(&(var))
+#define RUBY_ATOMIC_SIZE_INC(var) rbimpl_atomic_size_inc(&(var), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_DEC,  except it expects its  argument is `size_t`.
@@ -206,7 +254,7 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `var - 1`.
  */
-#define RUBY_ATOMIC_SIZE_DEC(var) rbimpl_atomic_size_dec(&(var))
+#define RUBY_ATOMIC_SIZE_DEC(var) rbimpl_atomic_size_dec(&(var), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical  to #RUBY_ATOMIC_EXCHANGE,  except  it expects  its arguments  are
@@ -220,7 +268,7 @@ typedef unsigned int rb_atomic_t;
  * @post    `var` holds `val`.
  */
 #define RUBY_ATOMIC_SIZE_EXCHANGE(var, val) \
-    rbimpl_atomic_size_exchange(&(var), (val))
+    rbimpl_atomic_size_exchange(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_CAS, except it expects its arguments are `size_t`.
@@ -234,7 +282,7 @@ typedef unsigned int rb_atomic_t;
  * @retval  otherwise  Something else is at `var`; not updated.
  */
 #define RUBY_ATOMIC_SIZE_CAS(var, oldval, newval) \
-    rbimpl_atomic_size_cas(&(var), (oldval), (newval))
+    rbimpl_atomic_size_cas(&(var), (oldval), (newval), RBIMPL_ATOMIC_SEQ_CST, RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_ADD, except it expects its arguments are `size_t`.
@@ -246,7 +294,7 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `var + val`.
  */
-#define RUBY_ATOMIC_SIZE_ADD(var, val) rbimpl_atomic_size_add(&(var), (val))
+#define RUBY_ATOMIC_SIZE_ADD(var, val) rbimpl_atomic_size_add(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_SUB, except it expects its arguments are `size_t`.
@@ -258,7 +306,7 @@ typedef unsigned int rb_atomic_t;
  * @return  void
  * @post    `var` holds `var - val`.
  */
-#define RUBY_ATOMIC_SIZE_SUB(var, val) rbimpl_atomic_size_sub(&(var), (val))
+#define RUBY_ATOMIC_SIZE_SUB(var, val) rbimpl_atomic_size_sub(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical  to #RUBY_ATOMIC_EXCHANGE,  except  it expects  its arguments  are
@@ -277,7 +325,31 @@ typedef unsigned int rb_atomic_t;
  * some pointers, most notably function pointers.
  */
 #define RUBY_ATOMIC_PTR_EXCHANGE(var, val) \
-    RBIMPL_CAST(rbimpl_atomic_ptr_exchange((void **)&(var), (void *)val))
+    RBIMPL_CAST(rbimpl_atomic_ptr_exchange((void **)&(var), (void *)val, RBIMPL_ATOMIC_SEQ_CST))
+
+/**
+ * Identical to #RUBY_ATOMIC_LOAD, except it expects its arguments are `void*`.
+ * There are cases where ::rb_atomic_t is 32bit while `void*` is 64bit.  This
+ * should be used for size related operations to support such platforms.
+ *
+ * @param   var        A variable of `void*`
+ * @return             The value of `var` (without tearing)
+ */
+#define RUBY_ATOMIC_PTR_LOAD(var) \
+    RBIMPL_CAST(rbimpl_atomic_ptr_load((void **)&var, RBIMPL_ATOMIC_SEQ_CST))
+
+/**
+* Identical  to #RUBY_ATOMIC_SET,  except  it expects  its arguments  are
+* `void*`.   There are  cases where  ::rb_atomic_t is  32bit while  ::VALUE is
+* 64bit.  This should  be used for pointer related operations  to support such
+* platforms.
+*
+* @param   var  A variable of `void*`.
+* @param   val   Value to set.
+* @post    `var` holds `val`.
+*/
+#define RUBY_ATOMIC_PTR_SET(var, val) \
+   rbimpl_atomic_ptr_store((volatile void **)&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_CAS, except it expects its arguments are `void*`.
@@ -291,7 +363,20 @@ typedef unsigned int rb_atomic_t;
  * @retval  otherwise  Something else is at `var`; not updated.
  */
 #define RUBY_ATOMIC_PTR_CAS(var, oldval, newval) \
-    RBIMPL_CAST(rbimpl_atomic_ptr_cas((void **)&(var), (oldval), (newval)))
+    RBIMPL_CAST(rbimpl_atomic_ptr_cas((void **)&(var), (void *)(oldval), (void *)(newval), RBIMPL_ATOMIC_SEQ_CST, RBIMPL_ATOMIC_SEQ_CST))
+
+/**
+ * Identical  to #RUBY_ATOMIC_SET,  except  it expects  its arguments  are
+ * ::VALUE.   There are  cases where  ::rb_atomic_t is  32bit while  ::VALUE is
+ * 64bit.  This should  be used for pointer related operations  to support such
+ * platforms.
+ *
+ * @param   var  A variable of ::VALUE.
+ * @param   val   Value to set.
+ * @post    `var` holds `val`.
+ */
+#define RUBY_ATOMIC_VALUE_SET(var, val) \
+    rbimpl_atomic_value_store(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical  to #RUBY_ATOMIC_EXCHANGE,  except  it expects  its arguments  are
@@ -305,7 +390,7 @@ typedef unsigned int rb_atomic_t;
  * @post    `var` holds `val`.
  */
 #define RUBY_ATOMIC_VALUE_EXCHANGE(var, val) \
-    rbimpl_atomic_value_exchange(&(var), (val))
+    rbimpl_atomic_value_exchange(&(var), (val), RBIMPL_ATOMIC_SEQ_CST)
 
 /**
  * Identical to #RUBY_ATOMIC_CAS, except it  expects its arguments are ::VALUE.
@@ -319,19 +404,20 @@ typedef unsigned int rb_atomic_t;
  * @retval  otherwise  Something else is at `var`; not updated.
  */
 #define RUBY_ATOMIC_VALUE_CAS(var, oldval, newval) \
-    rbimpl_atomic_value_cas(&(var), (oldval), (newval))
+    rbimpl_atomic_value_cas(&(var), (oldval), (newval), RBIMPL_ATOMIC_SEQ_CST, RBIMPL_ATOMIC_SEQ_CST)
 
 /** @cond INTERNAL_MACRO */
 RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline rb_atomic_t
-rbimpl_atomic_fetch_add(volatile rb_atomic_t *ptr, rb_atomic_t val)
+rbimpl_atomic_fetch_add(volatile rb_atomic_t *ptr, rb_atomic_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    return __atomic_fetch_add(ptr, val, __ATOMIC_SEQ_CST);
+    return __atomic_fetch_add(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     return __sync_fetch_and_add(ptr, val);
@@ -348,6 +434,47 @@ rbimpl_atomic_fetch_add(volatile rb_atomic_t *ptr, rb_atomic_t val)
     RBIMPL_ASSERT_OR_ASSUME(val <= INT_MAX);
     return atomic_add_int_nv(ptr, val) - val;
 
+#elif defined(HAVE_STDATOMIC_H)
+    return atomic_fetch_add_explicit((_Atomic volatile rb_atomic_t *)ptr, val, memory_order);
+
+#else
+# error Unsupported platform.
+#endif
+}
+
+/** @cond INTERNAL_MACRO */
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NOALIAS()
+RBIMPL_ATTR_NONNULL((1))
+static inline size_t
+rbimpl_atomic_size_fetch_add(volatile size_t *ptr, size_t val, int memory_order)
+{
+    (void)memory_order;
+#if 0
+
+#elif defined(HAVE_GCC_ATOMIC_BUILTINS)
+    return __atomic_fetch_add(ptr, val, memory_order);
+
+#elif defined(HAVE_GCC_SYNC_BUILTINS)
+    return __sync_fetch_and_add(ptr, val);
+
+#elif defined(_WIN32)
+    return InterlockedExchangeAdd64(ptr, val);
+
+#elif defined(__sun) && defined(HAVE_ATOMIC_H) && (defined(_LP64) || defined(_I32LPx))
+    /* Ditto for `atomic_add_int_nv`. */
+    RBIMPL_ASSERT_OR_ASSUME(val <= LONG_MAX);
+    atomic_add_long(ptr, val);
+
+#elif defined(__sun) && defined(HAVE_ATOMIC_H)
+    RBIMPL_STATIC_ASSERT(size_of_rb_atomic_t, sizeof *ptr == sizeof(rb_atomic_t));
+
+    volatile rb_atomic_t *const tmp = RBIMPL_CAST((volatile rb_atomic_t *)ptr);
+    rbimpl_atomic_fetch_add(tmp, val, memory_order);
+
+#elif defined(HAVE_STDATOMIC_H)
+    return atomic_fetch_add_explicit((_Atomic volatile size_t *)ptr, val, memory_order);
+
 #else
 # error Unsupported platform.
 #endif
@@ -357,8 +484,9 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_add(volatile rb_atomic_t *ptr, rb_atomic_t val)
+rbimpl_atomic_add(volatile rb_atomic_t *ptr, rb_atomic_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
@@ -367,7 +495,7 @@ rbimpl_atomic_add(volatile rb_atomic_t *ptr, rb_atomic_t val)
      * return value is not used, then compiles it into single `LOCK ADD`
      * instruction.
      */
-    __atomic_add_fetch(ptr, val, __ATOMIC_SEQ_CST);
+    __atomic_add_fetch(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     __sync_add_and_fetch(ptr, val);
@@ -385,6 +513,9 @@ rbimpl_atomic_add(volatile rb_atomic_t *ptr, rb_atomic_t val)
     RBIMPL_ASSERT_OR_ASSUME(val <= INT_MAX);
     atomic_add_int(ptr, val);
 
+#elif defined(HAVE_STDATOMIC_H)
+    atomic_fetch_add_explicit((_Atomic volatile rb_atomic_t *)ptr, val, memory_order);
+
 #else
 # error Unsupported platform.
 #endif
@@ -394,17 +525,18 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_size_add(volatile size_t *ptr, size_t val)
+rbimpl_atomic_size_add(volatile size_t *ptr, size_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    __atomic_add_fetch(ptr, val, __ATOMIC_SEQ_CST);
+    __atomic_add_fetch(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     __sync_add_and_fetch(ptr, val);
 
-#elif defined(_WIN32) && defined(_M_AMD64)
+#elif defined(_WIN64)
     /* Ditto for `InterlockeExchangedAdd`. */
     InterlockedExchangeAdd64(ptr, val);
 
@@ -413,12 +545,17 @@ rbimpl_atomic_size_add(volatile size_t *ptr, size_t val)
     RBIMPL_ASSERT_OR_ASSUME(val <= LONG_MAX);
     atomic_add_long(ptr, val);
 
-#else
+#elif defined(_WIN32) || (defined(__sun) && defined(HAVE_ATOMIC_H))
     RBIMPL_STATIC_ASSERT(size_of_rb_atomic_t, sizeof *ptr == sizeof(rb_atomic_t));
 
     volatile rb_atomic_t *const tmp = RBIMPL_CAST((volatile rb_atomic_t *)ptr);
-    rbimpl_atomic_add(tmp, val);
+    rbimpl_atomic_add(tmp, val, memory_order);
 
+#elif defined(HAVE_STDATOMIC_H)
+    atomic_fetch_add_explicit((_Atomic volatile size_t *)ptr, val, memory_order);
+
+#else
+# error Unsupported platform.
 #endif
 }
 
@@ -426,12 +563,13 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_inc(volatile rb_atomic_t *ptr)
+rbimpl_atomic_inc(volatile rb_atomic_t *ptr, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS) || defined(HAVE_GCC_SYNC_BUILTINS)
-    rbimpl_atomic_add(ptr, 1);
+    rbimpl_atomic_add(ptr, 1, memory_order);
 
 #elif defined(_WIN32)
     InterlockedIncrement(ptr);
@@ -439,9 +577,11 @@ rbimpl_atomic_inc(volatile rb_atomic_t *ptr)
 #elif defined(__sun) && defined(HAVE_ATOMIC_H)
     atomic_inc_uint(ptr);
 
-#else
-    rbimpl_atomic_add(ptr, 1);
+#elif defined(HAVE_STDATOMIC_H)
+    rbimpl_atomic_add(ptr, 1, memory_order);
 
+#else
+# error Unsupported platform.
 #endif
 }
 
@@ -449,22 +589,30 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_size_inc(volatile size_t *ptr)
+rbimpl_atomic_size_inc(volatile size_t *ptr, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS) || defined(HAVE_GCC_SYNC_BUILTINS)
-    rbimpl_atomic_size_add(ptr, 1);
+    rbimpl_atomic_size_add(ptr, 1, memory_order);
 
-#elif defined(_WIN32) && defined(_M_AMD64)
+#elif defined(_WIN64)
     InterlockedIncrement64(ptr);
 
 #elif defined(__sun) && defined(HAVE_ATOMIC_H) && (defined(_LP64) || defined(_I32LPx))
     atomic_inc_ulong(ptr);
 
-#else
-    rbimpl_atomic_size_add(ptr, 1);
+#elif defined(_WIN32) || (defined(__sun) && defined(HAVE_ATOMIC_H))
+    RBIMPL_STATIC_ASSERT(size_of_size_t, sizeof *ptr == sizeof(rb_atomic_t));
+
+    rbimpl_atomic_size_add(ptr, 1, memory_order);
 
+#elif defined(HAVE_STDATOMIC_H)
+    rbimpl_atomic_size_add(ptr, 1, memory_order);
+
+#else
+# error Unsupported platform.
 #endif
 }
 
@@ -472,12 +620,13 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline rb_atomic_t
-rbimpl_atomic_fetch_sub(volatile rb_atomic_t *ptr, rb_atomic_t val)
+rbimpl_atomic_fetch_sub(volatile rb_atomic_t *ptr, rb_atomic_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    return __atomic_fetch_sub(ptr, val, __ATOMIC_SEQ_CST);
+    return __atomic_fetch_sub(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     return __sync_fetch_and_sub(ptr, val);
@@ -492,6 +641,9 @@ rbimpl_atomic_fetch_sub(volatile rb_atomic_t *ptr, rb_atomic_t val)
     RBIMPL_ASSERT_OR_ASSUME(val <= INT_MAX);
     return atomic_add_int_nv(ptr, neg * val) + val;
 
+#elif defined(HAVE_STDATOMIC_H)
+    return atomic_fetch_sub_explicit((_Atomic volatile rb_atomic_t *)ptr, val, memory_order);
+
 #else
 # error Unsupported platform.
 #endif
@@ -501,12 +653,13 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_sub(volatile rb_atomic_t *ptr, rb_atomic_t val)
+rbimpl_atomic_sub(volatile rb_atomic_t *ptr, rb_atomic_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    __atomic_sub_fetch(ptr, val, __ATOMIC_SEQ_CST);
+    __atomic_sub_fetch(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     __sync_sub_and_fetch(ptr, val);
@@ -519,6 +672,9 @@ rbimpl_atomic_sub(volatile rb_atomic_t *ptr, rb_atomic_t val)
     RBIMPL_ASSERT_OR_ASSUME(val <= INT_MAX);
     atomic_add_int(ptr, neg * val);
 
+#elif defined(HAVE_STDATOMIC_H)
+    atomic_fetch_sub_explicit((_Atomic volatile rb_atomic_t *)ptr, val, memory_order);
+
 #else
 # error Unsupported platform.
 #endif
@@ -528,17 +684,18 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_size_sub(volatile size_t *ptr, size_t val)
+rbimpl_atomic_size_sub(volatile size_t *ptr, size_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    __atomic_sub_fetch(ptr, val, __ATOMIC_SEQ_CST);
+    __atomic_sub_fetch(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     __sync_sub_and_fetch(ptr, val);
 
-#elif defined(_WIN32) && defined(_M_AMD64)
+#elif defined(_WIN64)
     const ssize_t neg = -1;
     InterlockedExchangeAdd64(ptr, neg * val);
 
@@ -547,12 +704,17 @@ rbimpl_atomic_size_sub(volatile size_t *ptr, size_t val)
     RBIMPL_ASSERT_OR_ASSUME(val <= LONG_MAX);
     atomic_add_long(ptr, neg * val);
 
-#else
+#elif defined(_WIN32) || (defined(__sun) && defined(HAVE_ATOMIC_H))
     RBIMPL_STATIC_ASSERT(size_of_rb_atomic_t, sizeof *ptr == sizeof(rb_atomic_t));
 
     volatile rb_atomic_t *const tmp = RBIMPL_CAST((volatile rb_atomic_t *)ptr);
-    rbimpl_atomic_sub(tmp, val);
+    rbimpl_atomic_sub(tmp, val, memory_order);
 
+#elif defined(HAVE_STDATOMIC_H)
+    atomic_fetch_sub_explicit((_Atomic volatile size_t *)ptr, val, memory_order);
+
+#else
+# error Unsupported platform.
 #endif
 }
 
@@ -560,12 +722,13 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_dec(volatile rb_atomic_t *ptr)
+rbimpl_atomic_dec(volatile rb_atomic_t *ptr, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS) || defined(HAVE_GCC_SYNC_BUILTINS)
-    rbimpl_atomic_sub(ptr, 1);
+    rbimpl_atomic_sub(ptr, 1, memory_order);
 
 #elif defined(_WIN32)
     InterlockedDecrement(ptr);
@@ -573,9 +736,11 @@ rbimpl_atomic_dec(volatile rb_atomic_t *ptr)
 #elif defined(__sun) && defined(HAVE_ATOMIC_H)
     atomic_dec_uint(ptr);
 
-#else
-    rbimpl_atomic_sub(ptr, 1);
+#elif defined(HAVE_STDATOMIC_H)
+    rbimpl_atomic_sub(ptr, 1, memory_order);
 
+#else
+# error Unsupported platform.
 #endif
 }
 
@@ -583,22 +748,30 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_size_dec(volatile size_t *ptr)
+rbimpl_atomic_size_dec(volatile size_t *ptr, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS) || defined(HAVE_GCC_SYNC_BUILTINS)
-    rbimpl_atomic_size_sub(ptr, 1);
+    rbimpl_atomic_size_sub(ptr, 1, memory_order);
 
-#elif defined(_WIN32) && defined(_M_AMD64)
+#elif defined(_WIN64)
     InterlockedDecrement64(ptr);
 
 #elif defined(__sun) && defined(HAVE_ATOMIC_H) && (defined(_LP64) || defined(_I32LPx))
     atomic_dec_ulong(ptr);
 
-#else
-    rbimpl_atomic_size_sub(ptr, 1);
+#elif defined(_WIN32) || (defined(__sun) && defined(HAVE_ATOMIC_H))
+    RBIMPL_STATIC_ASSERT(size_of_size_t, sizeof *ptr == sizeof(rb_atomic_t));
+
+    rbimpl_atomic_size_sub(ptr, 1, memory_order);
 
+#elif defined(HAVE_STDATOMIC_H)
+    rbimpl_atomic_size_sub(ptr, 1, memory_order);
+
+#else
+# error Unsupported platform.
 #endif
 }
 
@@ -606,59 +779,42 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_or(volatile rb_atomic_t *ptr, rb_atomic_t val)
+rbimpl_atomic_or(volatile rb_atomic_t *ptr, rb_atomic_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    __atomic_or_fetch(ptr, val, __ATOMIC_SEQ_CST);
+    __atomic_or_fetch(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     __sync_or_and_fetch(ptr, val);
 
-#elif RBIMPL_COMPILER_SINCE(MSVC, 13, 0, 0)
+#elif RBIMPL_COMPILER_IS(MSVC)
     _InterlockedOr(ptr, val);
 
-#elif defined(_WIN32) && defined(__GNUC__)
-    /* This was for old MinGW.  Maybe not needed any longer? */
-    __asm__(
-        "lock\n\t"
-        "orl\t%1, %0"
-        : "=m"(ptr)
-        : "Ir"(val));
-
-#elif defined(_WIN32) && defined(_M_IX86)
-    __asm mov eax, ptr;
-    __asm mov ecx, val;
-    __asm lock or [eax], ecx;
-
 #elif defined(__sun) && defined(HAVE_ATOMIC_H)
     atomic_or_uint(ptr, val);
 
+#elif !defined(_WIN32) && defined(HAVE_STDATOMIC_H)
+    atomic_fetch_or_explicit((_Atomic volatile rb_atomic_t *)ptr, val, memory_order);
+
 #else
 # error Unsupported platform.
 #endif
 }
 
-/* Nobody uses this but for theoretical backwards compatibility... */
-#if RBIMPL_COMPILER_BEFORE(MSVC, 13, 0, 0)
-static inline rb_atomic_t
-rb_w32_atomic_or(volatile rb_atomic_t *var, rb_atomic_t val)
-{
-    return rbimpl_atomic_or(var, val);
-}
-#endif
-
 RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline rb_atomic_t
-rbimpl_atomic_exchange(volatile rb_atomic_t *ptr, rb_atomic_t val)
+rbimpl_atomic_exchange(volatile rb_atomic_t *ptr, rb_atomic_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    return __atomic_exchange_n(ptr, val, __ATOMIC_SEQ_CST);
+    return __atomic_exchange_n(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     return __sync_lock_test_and_set(ptr, val);
@@ -669,6 +825,9 @@ rbimpl_atomic_exchange(volatile rb_atomic_t *ptr, rb_atomic_t val)
 #elif defined(__sun) && defined(HAVE_ATOMIC_H)
     return atomic_swap_uint(ptr, val);
 
+#elif defined(HAVE_STDATOMIC_H)
+    return atomic_exchange_explicit((_Atomic volatile rb_atomic_t *)ptr, val, memory_order);
+
 #else
 # error Unsupported platform.
 #endif
@@ -678,29 +837,53 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline size_t
-rbimpl_atomic_size_exchange(volatile size_t *ptr, size_t val)
+rbimpl_atomic_size_exchange(volatile size_t *ptr, size_t val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    return __atomic_exchange_n(ptr, val, __ATOMIC_SEQ_CST);
+    return __atomic_exchange_n(ptr, val, memory_order);
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     return __sync_lock_test_and_set(ptr, val);
 
-#elif defined(_WIN32) && defined(_M_AMD64)
+#elif defined(_WIN64)
     return InterlockedExchange64(ptr, val);
 
 #elif defined(__sun) && defined(HAVE_ATOMIC_H) && (defined(_LP64) || defined(_I32LPx))
     return atomic_swap_ulong(ptr, val);
 
-#else
+#elif defined(_WIN32) || (defined(__sun) && defined(HAVE_ATOMIC_H))
     RBIMPL_STATIC_ASSERT(size_of_size_t, sizeof *ptr == sizeof(rb_atomic_t));
 
     volatile rb_atomic_t *const tmp = RBIMPL_CAST((volatile rb_atomic_t *)ptr);
-    const rb_atomic_t ret = rbimpl_atomic_exchange(tmp, val);
+    const rb_atomic_t ret = rbimpl_atomic_exchange(tmp, val, memory_order);
     return RBIMPL_CAST((size_t)ret);
 
+#elif defined(HAVE_STDATOMIC_H)
+    return atomic_exchange_explicit((_Atomic volatile size_t *)ptr, val, memory_order);
+
+#else
+# error Unsupported platform.
+#endif
+}
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NOALIAS()
+RBIMPL_ATTR_NONNULL((1))
+static inline void
+rbimpl_atomic_size_store(volatile size_t *ptr, size_t val, int memory_order)
+{
+    (void)memory_order;
+#if 0
+
+#elif defined(HAVE_GCC_ATOMIC_BUILTINS)
+    __atomic_store_n(ptr, val, memory_order);
+
+#else
+    rbimpl_atomic_size_exchange(ptr, val, memory_order);
+
 #endif
 }
 
@@ -708,8 +891,9 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void *
-rbimpl_atomic_ptr_exchange(void *volatile *ptr, const void *val)
+rbimpl_atomic_ptr_exchange(void *volatile *ptr, const void *val, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(InterlockedExchangePointer)
@@ -726,7 +910,7 @@ rbimpl_atomic_ptr_exchange(void *volatile *ptr, const void *val)
 
     const size_t sval = RBIMPL_CAST((size_t)val);
     volatile size_t *const sptr = RBIMPL_CAST((volatile size_t *)ptr);
-    const size_t sret = rbimpl_atomic_size_exchange(sptr, sval);
+    const size_t sret = rbimpl_atomic_size_exchange(sptr, sval, memory_order);
     return RBIMPL_CAST((void *)sret);
 
 #endif
@@ -735,14 +919,27 @@ rbimpl_atomic_ptr_exchange(void *volatile *ptr, const void *val)
 RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
+static inline void
+rbimpl_atomic_ptr_store(volatile void **ptr, void *val, int memory_order)
+{
+    RBIMPL_STATIC_ASSERT(sizeof_value, sizeof *ptr == sizeof(size_t));
+
+    const size_t sval = RBIMPL_CAST((size_t)val);
+    volatile size_t *const sptr = RBIMPL_CAST((volatile size_t *)ptr);
+    rbimpl_atomic_size_store(sptr, sval, memory_order);
+}
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NOALIAS()
+RBIMPL_ATTR_NONNULL((1))
 static inline VALUE
-rbimpl_atomic_value_exchange(volatile VALUE *ptr, VALUE val)
+rbimpl_atomic_value_exchange(volatile VALUE *ptr, VALUE val, int memory_order)
 {
     RBIMPL_STATIC_ASSERT(sizeof_value, sizeof *ptr == sizeof(size_t));
 
     const size_t sval = RBIMPL_CAST((size_t)val);
     volatile size_t *const sptr = RBIMPL_CAST((volatile size_t *)ptr);
-    const size_t sret = rbimpl_atomic_size_exchange(sptr, sval);
+    const size_t sret = rbimpl_atomic_size_exchange(sptr, sval, memory_order);
     return RBIMPL_CAST((VALUE)sret);
 }
 
@@ -750,16 +947,46 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void
-rbimpl_atomic_set(volatile rb_atomic_t *ptr, rb_atomic_t val)
+rbimpl_atomic_value_store(volatile VALUE *ptr, VALUE val, int memory_order)
+{
+    RBIMPL_STATIC_ASSERT(sizeof_value, sizeof *ptr == sizeof(size_t));
+
+    const size_t sval = RBIMPL_CAST((size_t)val);
+    volatile size_t *const sptr = RBIMPL_CAST((volatile size_t *)ptr);
+    rbimpl_atomic_size_store(sptr, sval, memory_order);
+}
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NOALIAS()
+RBIMPL_ATTR_NONNULL((1))
+static inline rb_atomic_t
+rbimpl_atomic_load(volatile rb_atomic_t *ptr, int memory_order)
 {
+    (void)memory_order;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
-    __atomic_store_n(ptr, val, __ATOMIC_SEQ_CST);
+    return __atomic_load_n(ptr, memory_order);
+#else
+    return rbimpl_atomic_fetch_add(ptr, 0, memory_order);
+#endif
+}
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NOALIAS()
+RBIMPL_ATTR_NONNULL((1))
+static inline void
+rbimpl_atomic_store(volatile rb_atomic_t *ptr, rb_atomic_t val, int memory_order)
+{
+    (void)memory_order;
+#if 0
+
+#elif defined(HAVE_GCC_ATOMIC_BUILTINS)
+    __atomic_store_n(ptr, val, memory_order);
 
 #else
     /* Maybe std::atomic<rb_atomic_t>::store can be faster? */
-    rbimpl_atomic_exchange(ptr, val);
+    rbimpl_atomic_exchange(ptr, val, memory_order);
 
 #endif
 }
@@ -768,73 +995,73 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline rb_atomic_t
-rbimpl_atomic_cas(volatile rb_atomic_t *ptr, rb_atomic_t oldval, rb_atomic_t newval)
+rbimpl_atomic_cas(volatile rb_atomic_t *ptr, rb_atomic_t oldval, rb_atomic_t newval, int success_memorder, int failure_memorder)
 {
+    (void)success_memorder;
+    (void)failure_memorder;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
     __atomic_compare_exchange_n(
-        ptr, &oldval, newval, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        ptr, &oldval, newval, 0, success_memorder, failure_memorder);
     return oldval;
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     return __sync_val_compare_and_swap(ptr, oldval, newval);
 
-#elif RBIMPL_COMPILER_SINCE(MSVC, 13, 0, 0)
+#elif RBIMPL_COMPILER_IS(MSVC)
     return InterlockedCompareExchange(ptr, newval, oldval);
 
-#elif defined(_WIN32)
-    PVOID *pptr = RBIMPL_CAST((PVOID *)ptr);
-    PVOID pold = RBIMPL_CAST((PVOID)oldval);
-    PVOID pnew = RBIMPL_CAST((PVOID)newval);
-    PVOID pret = InterlockedCompareExchange(pptr, pnew, pold);
-    return RBIMPL_CAST((rb_atomic_t)pret);
-
 #elif defined(__sun) && defined(HAVE_ATOMIC_H)
     return atomic_cas_uint(ptr, oldval, newval);
 
+#elif defined(HAVE_STDATOMIC_H)
+    atomic_compare_exchange_strong_explicit(
+        (_Atomic volatile rb_atomic_t *)ptr, &oldval, newval, success_memorder, failure_memorder);
+    return oldval;
+
 #else
 # error Unsupported platform.
 #endif
 }
 
-/* Nobody uses this but for theoretical backwards compatibility... */
-#if RBIMPL_COMPILER_BEFORE(MSVC, 13, 0, 0)
-static inline rb_atomic_t
-rb_w32_atomic_cas(volatile rb_atomic_t *var, rb_atomic_t oldval, rb_atomic_t newval)
-{
-    return rbimpl_atomic_cas(var, oldval, newval);
-}
-#endif
-
 RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline size_t
-rbimpl_atomic_size_cas(volatile size_t *ptr, size_t oldval, size_t newval)
+rbimpl_atomic_size_cas(volatile size_t *ptr, size_t oldval, size_t newval, int success_memorder, int failure_memorder)
 {
+    (void)success_memorder;
+    (void)failure_memorder;
 #if 0
 
 #elif defined(HAVE_GCC_ATOMIC_BUILTINS)
     __atomic_compare_exchange_n(
-        ptr, &oldval, newval, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        ptr, &oldval, newval, 0, success_memorder, failure_memorder);
     return oldval;
 
 #elif defined(HAVE_GCC_SYNC_BUILTINS)
     return __sync_val_compare_and_swap(ptr, oldval, newval);
 
-#elif defined(_WIN32) && defined(_M_AMD64)
+#elif defined(_WIN64)
     return InterlockedCompareExchange64(ptr, newval, oldval);
 
 #elif defined(__sun) && defined(HAVE_ATOMIC_H) && (defined(_LP64) || defined(_I32LPx))
     return atomic_cas_ulong(ptr, oldval, newval);
 
-#else
+#elif defined(_WIN32) || (defined(__sun) && defined(HAVE_ATOMIC_H))
     RBIMPL_STATIC_ASSERT(size_of_size_t, sizeof *ptr == sizeof(rb_atomic_t));
 
     volatile rb_atomic_t *tmp = RBIMPL_CAST((volatile rb_atomic_t *)ptr);
-    return rbimpl_atomic_cas(tmp, oldval, newval);
+    return rbimpl_atomic_cas(tmp, oldval, newval, success_memorder, failure_memorder);
+
+#elif defined(HAVE_STDATOMIC_H)
+    atomic_compare_exchange_strong_explicit(
+        (_Atomic volatile size_t *)ptr, &oldval, newval, success_memorder, failure_memorder);
+    return oldval;
 
+#else
+# error Unsupported platform.
 #endif
 }
 
@@ -842,8 +1069,10 @@ RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
 static inline void *
-rbimpl_atomic_ptr_cas(void **ptr, const void *oldval, const void *newval)
+rbimpl_atomic_ptr_cas(void **ptr, const void *oldval, const void *newval, int success_memorder, int failure_memorder)
 {
+    (void)success_memorder;
+    (void)failure_memorder;
 #if 0
 
 #elif defined(InterlockedExchangePointer)
@@ -866,7 +1095,7 @@ rbimpl_atomic_ptr_cas(void **ptr, const void *oldval, const void *newval)
     const size_t snew = RBIMPL_CAST((size_t)newval);
     const size_t sold = RBIMPL_CAST((size_t)oldval);
     volatile size_t *const sptr = RBIMPL_CAST((volatile size_t *)ptr);
-    const size_t sret = rbimpl_atomic_size_cas(sptr, sold, snew);
+    const size_t sret = rbimpl_atomic_size_cas(sptr, sold, snew, success_memorder, failure_memorder);
     return RBIMPL_CAST((void *)sret);
 
 #endif
@@ -875,15 +1104,41 @@ rbimpl_atomic_ptr_cas(void **ptr, const void *oldval, const void *newval)
 RBIMPL_ATTR_ARTIFICIAL()
 RBIMPL_ATTR_NOALIAS()
 RBIMPL_ATTR_NONNULL((1))
+static inline void *
+rbimpl_atomic_ptr_load(void **ptr, int memory_order)
+{
+    (void)memory_order;
+#if 0
+
+#elif defined(HAVE_GCC_ATOMIC_BUILTINS)
+    return __atomic_load_n(ptr, memory_order);
+#else
+    void *val = *ptr;
+    return rbimpl_atomic_ptr_cas(ptr, val, val, memory_order, memory_order);
+#endif
+}
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NOALIAS()
+RBIMPL_ATTR_NONNULL((1))
+static inline VALUE
+rbimpl_atomic_value_load(volatile VALUE *ptr, int memory_order)
+{
+    return RBIMPL_CAST((VALUE)rbimpl_atomic_ptr_load((void **)ptr, memory_order));
+}
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NOALIAS()
+RBIMPL_ATTR_NONNULL((1))
 static inline VALUE
-rbimpl_atomic_value_cas(volatile VALUE *ptr, VALUE oldval, VALUE newval)
+rbimpl_atomic_value_cas(volatile VALUE *ptr, VALUE oldval, VALUE newval, int success_memorder, int failure_memorder)
 {
     RBIMPL_STATIC_ASSERT(sizeof_value, sizeof *ptr == sizeof(size_t));
 
     const size_t snew = RBIMPL_CAST((size_t)newval);
     const size_t sold = RBIMPL_CAST((size_t)oldval);
     volatile size_t *const sptr = RBIMPL_CAST((volatile size_t *)ptr);
-    const size_t sret = rbimpl_atomic_size_cas(sptr, sold, snew);
+    const size_t sret = rbimpl_atomic_size_cas(sptr, sold, snew, success_memorder, failure_memorder);
     return RBIMPL_CAST((VALUE)sret);
 }
 /** @endcond */
diff --git a/include/ruby/backward.h b/include/ruby/backward.h
index f804c2c36e..6726102158 100644
--- a/include/ruby/backward.h
+++ b/include/ruby/backward.h
@@ -11,12 +11,6 @@
 #include "ruby/internal/interpreter.h"
 #include "ruby/backward/2/attributes.h"
 
-#define RBIMPL_ATTR_DEPRECATED_SINCE(ver) RBIMPL_ATTR_DEPRECATED(("since " #ver))
-#define RBIMPL_ATTR_DEPRECATED_INTERNAL(ver) RBIMPL_ATTR_DEPRECATED(("since "#ver", also internal"))
-#define RBIMPL_ATTR_DEPRECATED_INTERNAL_ONLY() RBIMPL_ATTR_DEPRECATED(("only for internal use"))
-
-RBIMPL_ATTR_DEPRECATED_INTERNAL_ONLY() void rb_clear_constant_cache(void);
-
 /* from version.c */
 #if defined(RUBY_SHOW_COPYRIGHT_TO_DIE) && !!(RUBY_SHOW_COPYRIGHT_TO_DIE+0)
 # error RUBY_SHOW_COPYRIGHT_TO_DIE is deprecated
diff --git a/include/ruby/backward/2/attributes.h b/include/ruby/backward/2/attributes.h
index 73acfc9dc0..916d9e9d5b 100644
--- a/include/ruby/backward/2/attributes.h
+++ b/include/ruby/backward/2/attributes.h
@@ -39,6 +39,7 @@
 #include "ruby/internal/attr/noinline.h"
 #include "ruby/internal/attr/nonnull.h"
 #include "ruby/internal/attr/noreturn.h"
+#include "ruby/internal/attr/packed_struct.h"
 #include "ruby/internal/attr/pure.h"
 #include "ruby/internal/attr/restrict.h"
 #include "ruby/internal/attr/returns_nonnull.h"
@@ -80,10 +81,8 @@
 #undef NOINLINE
 #define NOINLINE(x) RBIMPL_ATTR_NOINLINE() x
 
-#ifndef MJIT_HEADER
-# undef ALWAYS_INLINE
-# define ALWAYS_INLINE(x) RBIMPL_ATTR_FORCEINLINE() x
-#endif
+#undef ALWAYS_INLINE
+#define ALWAYS_INLINE(x) RBIMPL_ATTR_FORCEINLINE() x
 
 #undef ERRORFUNC
 #define ERRORFUNC(mesg, x) RBIMPL_ATTR_ERROR(mesg) x
@@ -147,17 +146,14 @@
 #define NORETURN(x) RBIMPL_ATTR_NORETURN() x
 #define NORETURN_STYLE_NEW
 
-#ifndef PACKED_STRUCT
-# define PACKED_STRUCT(x) x
-#endif
+#undef PACKED_STRUCT
+#define PACKED_STRUCT(x) \
+    RBIMPL_ATTR_PACKED_STRUCT_BEGIN() x RBIMPL_ATTR_PACKED_STRUCT_END()
 
-#ifndef PACKED_STRUCT_UNALIGNED
-# if UNALIGNED_WORD_ACCESS
-#   define PACKED_STRUCT_UNALIGNED(x) PACKED_STRUCT(x)
-# else
-#   define PACKED_STRUCT_UNALIGNED(x) x
-# endif
-#endif
+#undef PACKED_STRUCT_UNALIGNED
+#define PACKED_STRUCT_UNALIGNED(x) \
+    RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_BEGIN() x \
+    RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_END()
 
 #undef RB_UNUSED_VAR
 #define RB_UNUSED_VAR(x) x RBIMPL_ATTR_MAYBE_UNUSED()
diff --git a/include/ruby/backward/2/rmodule.h b/include/ruby/backward/2/rmodule.h
index 53b37831c0..76c0936462 100644
--- a/include/ruby/backward/2/rmodule.h
+++ b/include/ruby/backward/2/rmodule.h
@@ -23,7 +23,7 @@
  * who is implementing the internals) could have used those macros for a while.
  * Kept public as-is here to keep some theoretical backwards compatibility.
  */
-#define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m)
+#define RMODULE_IV_TBL(m) RCLASS_FIELDS(m)
 #define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
 #define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
 #define RMODULE_SUPER(m) RCLASS_SUPER(m)
diff --git a/include/ruby/backward/cxxanyargs.hpp b/include/ruby/backward/cxxanyargs.hpp
index 2414b7ae6d..0ca2745c20 100644
--- a/include/ruby/backward/cxxanyargs.hpp
+++ b/include/ruby/backward/cxxanyargs.hpp
@@ -190,33 +190,6 @@ rb_define_hooked_variable(const char *q, VALUE *w, std::nullptr_t e, void_type *
 /// @name Exceptions and tag jumps
 /// @{
 
-// RUBY_CXX_DEPRECATED("by rb_block_call since 1.9")
-RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
-/// @brief       Old way to implement iterators.
-/// @param[in]   q  A function that can yield.
-/// @param[in]   w  Passed to `q`.
-/// @param[in]   e  What is to be yielded.
-/// @param[in]   r  Passed to `e`.
-/// @return      The return value of `q`.
-/// @note        `e` can be nullptr.
-/// @deprecated  This function is obsoleted since  long before 2.x era.  Do not
-///              use it any longer.  rb_block_call() is provided instead.
-inline VALUE
-rb_iterate(onearg_type *q, VALUE w, type *e, VALUE r)
-{
-    rb_block_call_func_t t = reinterpret_cast<rb_block_call_func_t>(e);
-    return backward::rb_iterate_deprecated(q, w, t, r);
-}
-
-#ifdef HAVE_NULLPTR
-RUBY_CXX_DEPRECATED("by rb_block_call since 1.9")
-inline VALUE
-rb_iterate(onearg_type *q, VALUE w, std::nullptr_t e, VALUE r)
-{
-    return backward::rb_iterate_deprecated(q, w, e, r);
-}
-#endif
-
 RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
 /// @brief       Call a method with a block.
 /// @param[in]   q  The self.
@@ -537,9 +510,7 @@ struct driver {
          * this writing the  version is 2.8.  Let's warn this  later, some time
          * during 3.x.   Hopefully codes in  old (ANYARGS-ed) format  should be
          * less than now. */
-#if (RUBY_API_VERSION_MAJOR * 100 + RUBY_API_VERSION_MINOR) >= 301
         RUBY_CXX_DEPRECATED("use of ANYARGS is deprecated")
-#endif
         /// @copydoc define(VALUE klass, T mid, U func)
         /// @deprecated  Pass correctly typed function instead.
         static inline void
diff --git a/include/ruby/debug.h b/include/ruby/debug.h
index c88da9c43d..27a7a5f2c1 100644
--- a/include/ruby/debug.h
+++ b/include/ruby/debug.h
@@ -10,6 +10,7 @@
  *             modify this file, provided that  the conditions mentioned in the
  *             file COPYING are met.  Consult the file for details.
  */
+#include "ruby/internal/attr/deprecated.h"
 #include "ruby/internal/attr/nonnull.h"
 #include "ruby/internal/attr/returns_nonnull.h"
 #include "ruby/internal/dllexport.h"
@@ -51,6 +52,25 @@ RBIMPL_ATTR_NONNULL((3))
 int rb_profile_frames(int start, int limit, VALUE *buff, int *lines);
 
 /**
+ * Queries mysterious "frame"s of the given range.
+ *
+ * A per-thread version of rb_profile_frames().
+ * Arguments and return values are the same with rb_profile_frames() with the
+ * exception of the first argument _thread_, which accepts the Thread to be
+ * profiled/queried.
+ *
+ * @param[in]   thread The Ruby Thread to be profiled.
+ * @param[in]   start  Start position (0 means the topmost).
+ * @param[in]   limit  Number objects of `buff`.
+ * @param[out]  buff   Return buffer.
+ * @param[out]  lines  Return buffer.
+ * @return      Number of objects filled into `buff`.
+ * @post        `buff` is filled with backtrace pointers.
+ * @post        `lines` is filled with `__LINE__` of each backtraces.
+ */
+int rb_profile_thread_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines);
+
+/**
  * Queries the path of the passed backtrace.
  *
  * @param[in]  frame      What rb_profile_frames() returned.
@@ -207,6 +227,17 @@ typedef VALUE (*rb_debug_inspector_func_t)(const rb_debug_inspector_t *dc, void
 VALUE rb_debug_inspector_open(rb_debug_inspector_func_t func, void *data);
 
 /**
+ * Queries  the backtrace  object  of the  context.   This is  as  if you  call
+ * `caller_locations` at the point of debugger.
+ *
+ * @param[in]  dc  A debug context.
+ * @return     An array  of `Thread::Backtrace::Location` which  represents the
+ *             current point of execution at `dc`.
+
+ */
+VALUE rb_debug_inspector_backtrace_locations(const rb_debug_inspector_t *dc);
+
+/**
  * Queries the current receiver of the passed context's upper frame.
  *
  * @param[in]  dc           A debug context.
@@ -250,15 +281,27 @@ VALUE rb_debug_inspector_frame_binding_get(const rb_debug_inspector_t *dc, long
 VALUE rb_debug_inspector_frame_iseq_get(const rb_debug_inspector_t *dc, long index);
 
 /**
- * Queries  the backtrace  object  of the  context.   This is  as  if you  call
- * `caller_locations` at the point of debugger.
+ * Queries the depth of the passed context's upper frame.
  *
- * @param[in]  dc  A debug context.
- * @return     An array  of `Thread::Backtrace::Location` which  represents the
- *             current point of execution at `dc`.
+ * Note that the depth is not same as the frame index because debug_inspector
+ * skips some special frames but the depth counts all frames.
+ *
+ * @param[in]  dc           A debug context.
+ * @param[in]  index        Index of the frame from top to bottom.
+ * @exception  rb_eArgError `index` out of range.
+ * @retval     The depth at `index`-th frame in Integer.
+ */
+VALUE rb_debug_inspector_frame_depth(const rb_debug_inspector_t *dc, long index);
+
+// A macro to recognize `rb_debug_inspector_frame_depth()` is available or not
+#define RB_DEBUG_INSPECTOR_FRAME_DEPTH(dc, index) rb_debug_inspector_frame_depth(dc, index)
 
+/**
+ * Return current frame depth.
+ *
+ * @retval     The depth of the current frame in Integer.
  */
-VALUE rb_debug_inspector_backtrace_locations(const rb_debug_inspector_t *dc);
+VALUE rb_debug_inspector_current_depth(void);
 
 /** @} */
 
@@ -436,7 +479,7 @@ RBIMPL_ATTR_RETURNS_NONNULL()
  */
 rb_trace_arg_t *rb_tracearg_from_tracepoint(VALUE tpval);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the event of the passed trace.
  *
@@ -445,7 +488,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 rb_event_flag_t rb_tracearg_event_flag(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Identical to  rb_tracearg_event_flag(), except  it returns  the name  of the
  * event in Ruby's symbol.
@@ -455,7 +498,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_event(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the line of the point where the trace is at.
  *
@@ -465,7 +508,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_lineno(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the file name of the point where the trace is at.
  *
@@ -475,7 +518,19 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_path(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
+/**
+ *
+ * Queries the parameters passed on a call or return event.
+ *
+ * @param[in]  trace_arg         A trace instance
+ * @exception  rb_eRuntimeError  The tracing event does not support querying parameters.
+ * @return     Array of parameters in the format of `Method#parameters`.
+ *
+ */
+VALUE rb_tracearg_parameters(rb_trace_arg_t *trace_arg);
+
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the method name of the point where the trace is at.
  *
@@ -485,7 +540,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_method_id(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Identical  to  rb_tracearg_method_id(), except  it  returns  callee id  like
  * rb_frame_callee().
@@ -496,7 +551,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_callee_id(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the class that defines the method that the passed trace is at.  This
  * can be different from the class of rb_tracearg_self()'s return value because
@@ -508,7 +563,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_defined_class(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Creates a binding object of the point where the trace is at.
  *
@@ -523,7 +578,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_binding(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the receiver of the point trace is at.
  *
@@ -532,7 +587,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_self(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the return value that the trace represents.
  *
@@ -542,7 +597,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_return_value(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the raised exception that the trace represents.
  *
@@ -552,7 +607,33 @@ RBIMPL_ATTR_NONNULL(())
  */
 VALUE rb_tracearg_raised_exception(rb_trace_arg_t *trace_arg);
 
-RBIMPL_ATTR_NONNULL(())
+RBIMPL_ATTR_NONNULL((1))
+/**
+ * Queries the compiled source code of the 'script_compiled' event.
+ * If loaded from a file, it will return nil.
+ *
+ * @param[in]  trace_arg         A trace instance
+ * @exception  rb_eRuntimeError  The tracing event is not 'script_compiled'.
+ * @retval     RUBY_Qnil         The script was loaded from a file.
+ * @retval     otherwise         The compiled source code.
+ *
+ */
+VALUE rb_tracearg_eval_script(rb_trace_arg_t *trace_arg);
+
+RBIMPL_ATTR_NONNULL((1))
+/**
+ *
+ * Queries the compiled instruction sequence on a 'script_compiled' event.
+ * Note that this method is MRI specific.
+ *
+ * @param[in]  trace_arg         A trace instance
+ * @exception  rb_eRuntimeError  The tracing event is not 'script_compiled'.
+ * @return     The `RubyVM::InstructionSequence` object representing the instruction sequence.
+ *
+ */
+VALUE rb_tracearg_instruction_sequence(rb_trace_arg_t *trace_arg);
+
+RBIMPL_ATTR_NONNULL((1))
 /**
  * Queries the allocated/deallocated object that the trace represents.
  *
@@ -573,49 +654,105 @@ VALUE rb_tracearg_object(rb_trace_arg_t *trace_arg);
 
 /*
  * Postponed Job API
- * rb_postponed_job_register and rb_postponed_job_register_one are
- * async-signal-safe and used via SIGPROF by the "stackprof" RubyGem
+ *
+ * This API is designed to be called from contexts where it is not safe to run Ruby
+ * code (e.g. because they do not hold the GVL or because GC is in progress), and
+ * defer a callback to run in a context where it _is_ safe. The primary intended
+ * users of this API is for sampling profilers like the "stackprof" gem; these work
+ * by scheduling the periodic delivery of a SIGPROF signal, and inside the C-level
+ * signal handler, deferring a job to collect a Ruby backtrace when it is next safe
+ * to do so.
+ *
+ * Ruby maintains a small, fixed-size postponed job table. An extension using this
+ * API should first call `rb_postponed_job_preregister` to register a callback
+ * function in this table and obtain a handle of type `rb_postponed_job_handle_t`
+ * to it. Subsequently, the callback can be triggered  by calling
+ * `rb_postponed_job_trigger` with that handle, or the `data` associated with the
+ * callback function can be changed by calling `rb_postponed_job_preregister` again.
+ *
+ * Because the postponed job table is quite small (it only has 32 entries on most
+ * common systems), extensions should generally only preregister one or two `func`
+ * values.
+ *
+ * Historically, this API provided two functions `rb_postponed_job_register` and
+ * `rb_postponed_job_register_one`, which claimed to be fully async-signal-safe and
+ * would call back the provided `func` and `data` at an appropriate time. However,
+ * these functions were subject to race conditions which could cause crashes when
+ * racing with Ruby's internal use of them. These two functions are still present,
+ * but are marked as deprecated and have slightly changed semantics:
+ *
+ * * rb_postponed_job_register now works like rb_postponed_job_register_one i.e.
+ *   `func` will only be executed at most one time each time Ruby checks for
+ *   interrupts, no matter how many times it is registered
+ * * They are also called with the last `data` to be registered, not the first
+ *   (which is how rb_postponed_job_register_one previously worked)
  */
 
+
 /**
  * Type of postponed jobs.
  *
- * @param[in,out]  arg What was passed to rb_postponed_job_register().
+ * @param[in,out]  arg What was passed to `rb_postponed_job_preregister`
  */
 typedef void (*rb_postponed_job_func_t)(void *arg);
 
 /**
- * Registers a postponed job.
+ * The type of a handle returned from `rb_postponed_job_preregister` and
+ * passed to `rb_postponed_job_trigger`
+ */
+typedef unsigned int rb_postponed_job_handle_t;
+#define POSTPONED_JOB_HANDLE_INVALID ((rb_postponed_job_handle_t)UINT_MAX)
+
+/**
+ * Pre-registers a func in Ruby's postponed job preregistration table,
+ * returning an opaque handle which can be used to trigger the job later. Generally,
+ * this function will be called during the initialization routine of an extension.
+ *
+ * The returned handle can be used later to call `rb_postponed_job_trigger`. This will
+ * cause Ruby to call back into the registered `func` with `data` at a later time, in
+ * a context where the GVL is held and it is safe to perform Ruby allocations.
+ *
+ * If the given `func` was already pre-registered, this function will overwrite the
+ * stored data with the newly passed data, and return the same handle instance as
+ * was previously returned.
  *
- * There  are situations  when running  a ruby  program is  not possible.   For
- * instance when  a program is in  a signal handler; for  another instance when
- * the GC  is busy.   On such situations  however, there might  be needs  to do
- * something.  We cannot but defer such operations until we are 100% sure it is
- * safe  to execute  them.   This  mechanism is  called  postponed jobs.   This
- * function  registers a  new one.   The registered  job would  eventually gets
- * executed.
+ * If this function is called concurrently with the same `func`, then the stored data
+ * could be the value from either call (but will definitely be one of them).
  *
- * @param[in]      flags      (Unused) reserved for future extensions.
- * @param[in]      func       Job body.
- * @param[in,out]  data       Passed as-is to `func`.
- * @retval         0          Postponed job buffer is full.  Failed.
- * @retval         otherwise  Opaque return value.
- * @post           The passed job is postponed.
+ * If this function is called to update the data concurrently with a call to
+ * `rb_postponed_job_trigger` on the same handle, it's undefined whether `func` will
+ * be called with the old data or the new data.
+ *
+ * Although the current implementation of this function is in fact async-signal-safe and
+ * has defined semantics when called concurrently on the same `func`, a future Ruby
+ * version might require that this method be called under the GVL; thus, programs which
+ * aim to be forward-compatible should call this method whilst holding the GVL.
+ *
+ * @param[in]   flags       Unused and ignored
+ * @param[in]   func        The function to be pre-registered
+ * @param[in]   data        The data to be pre-registered
+ * @retval      POSTPONED_JOB_HANDLE_INVALID    The job table is full; this registration
+ *                          did not succeed and no further registration will do so for
+ *                          the lifetime of the program.
+ * @retval      otherwise   A handle which can be passed to `rb_postponed_job_trigger`
  */
-int rb_postponed_job_register(unsigned int flags, rb_postponed_job_func_t func, void *data);
+rb_postponed_job_handle_t rb_postponed_job_preregister(unsigned int flags, rb_postponed_job_func_t func, void *data);
 
 /**
- * Identical to rb_postponed_job_register_one(),  except it additionally checks
- * for  duplicated registration.   In case  the passed  job is  already in  the
- * postponed job buffer this function does nothing.
+ * Triggers a pre-registered job registered with rb_postponed_job_preregister,
+ * scheduling it for execution the next time the Ruby VM checks for interrupts.
+ * The context in which the job is called in holds the GVL and is safe to perform
+ * Ruby allocations within (i.e. it is not during GC).
+ *
+ * This method is async-signal-safe and can be called from any thread, at any
+ * time, including in signal handlers.
+ *
+ * If this method is called multiple times, Ruby will coalesce this into only
+ * one call to the job the next time it checks for interrupts.
  *
- * @param[in]      flags      (Unused) reserved for future extensions.
- * @param[in]      func       Job body.
- * @param[in,out]  data       Passed as-is to `func`.
- * @retval         0          Postponed job buffer is full.  Failed.
- * @retval         otherwise  Opaque return value.
+ * @params[in]  h   A handle returned from rb_postponed_job_preregister
  */
-int rb_postponed_job_register_one(unsigned int flags, rb_postponed_job_func_t func, void *data);
+void rb_postponed_job_trigger(rb_postponed_job_handle_t h);
 
 /** @} */
 
diff --git a/include/ruby/fiber/scheduler.h b/include/ruby/fiber/scheduler.h
index d38651da5c..4d764f68ae 100644
--- a/include/ruby/fiber/scheduler.h
+++ b/include/ruby/fiber/scheduler.h
@@ -23,7 +23,11 @@
 
 RBIMPL_SYMBOL_EXPORT_BEGIN()
 
+// Version 3: Adds support for `fiber_interrupt`.
+#define RUBY_FIBER_SCHEDULER_VERSION 3
+
 struct timeval;
+struct rb_thread_struct;
 
 /**
  * Wrap a `ssize_t` and `int errno` into a single `VALUE`. This interface should
@@ -95,7 +99,7 @@ VALUE rb_fiber_scheduler_get(void);
  * current  thread  will  call  scheduler's  `#close`  method  on  finalisation
  * (allowing  the  scheduler  to  properly  manage  all  non-finished  fibers).
  * `scheduler`   can   be   an   object   of   any   class   corresponding   to
- * `Fiber::SchedulerInterface`. Its implementation is up to the user.
+ * `Fiber::Scheduler` interface. Its implementation is up to the user.
  *
  * @param[in]  scheduler     The scheduler to set.
  * @exception  rb_eArgError  `scheduler` does not conform the interface.
@@ -115,7 +119,7 @@ VALUE rb_fiber_scheduler_current(void);
 
 /**
  * Identical to rb_fiber_scheduler_current(), except it queries for that of the
- * passed thread instead of the implicit current one.
+ * passed thread value instead of the implicit current one.
  *
  * @param[in]  thread         Target thread.
  * @exception  rb_eTypeError  `thread` is not a thread.
@@ -125,6 +129,17 @@ VALUE rb_fiber_scheduler_current(void);
 VALUE rb_fiber_scheduler_current_for_thread(VALUE thread);
 
 /**
+ * Identical to rb_fiber_scheduler_current_for_thread(), except it expects
+ * a threadptr instead of a thread value.
+ *
+ * @param[in]  thread         Target thread.
+ * @exception  rb_eTypeError  `thread` is not a thread.
+ * @retval     RUBY_Qnil      No scheduler is in effect in `thread`.
+ * @retval     otherwise      The scheduler that is in effect in `thread`.
+ */
+VALUE rb_fiber_scheduler_current_for_threadptr(struct rb_thread_struct *thread);
+
+/**
  * Converts the passed timeout to an expression that rb_fiber_scheduler_block()
  * etc. expects.
  *
@@ -144,7 +159,7 @@ VALUE rb_fiber_scheduler_make_timeout(struct timeval *timeout);
 VALUE rb_fiber_scheduler_close(VALUE scheduler);
 
 /**
- * Nonblocking  `sleep`.   Depending  on  scheduler  implementation,  this  for
+ * Non-blocking  `sleep`.  Depending  on  scheduler  implementation,  this  for
  * instance switches to another fiber etc.
  *
  * @param[in]  scheduler  Target scheduler.
@@ -164,6 +179,14 @@ VALUE rb_fiber_scheduler_kernel_sleep(VALUE scheduler, VALUE duration);
  */
 VALUE rb_fiber_scheduler_kernel_sleepv(VALUE scheduler, int argc, VALUE * argv);
 
+/**
+ * Yield to the scheduler, to be resumed on the next scheduling cycle.
+ *
+ * @param[in]  scheduler  Target scheduler.
+ * @return     What `scheduler.yield` returns.
+ */
+VALUE rb_fiber_scheduler_yield(VALUE scheduler);
+
 /* Description TBW */
 #if 0
 VALUE rb_fiber_scheduler_timeout_after(VALUE scheduler, VALUE timeout, VALUE exception, VALUE message);
@@ -172,7 +195,7 @@ int rb_fiber_scheduler_supports_process_wait(VALUE scheduler);
 #endif
 
 /**
- * Nonblocking  `waitpid`.  Depending  on  scheduler  implementation, this  for
+ * Non-blocking `waitpid`.  Depending  on  scheduler  implementation, this  for
  * instance switches to another fiber etc.
  *
  * @param[in]  scheduler  Target scheduler.
@@ -183,7 +206,7 @@ int rb_fiber_scheduler_supports_process_wait(VALUE scheduler);
 VALUE rb_fiber_scheduler_process_wait(VALUE scheduler, rb_pid_t pid, int flags);
 
 /**
- * Nonblocking  wait   for  the  passed   "blocker",  which  is   for  instance
+ * Non-blocking  wait  for  the  passed   "blocker",  which  is   for  instance
  * `Thread.join` or `Mutex.lock`.  Depending  on scheduler implementation, this
  * for instance switches to another fiber etc.
  *
@@ -197,6 +220,8 @@ VALUE rb_fiber_scheduler_block(VALUE scheduler, VALUE blocker, VALUE timeout);
 /**
  * Wakes up a fiber previously blocked using rb_fiber_scheduler_block().
  *
+ * This function may be called from a different thread.
+ *
  * @param[in]  scheduler  Target scheduler.
  * @param[in]  blocker    What was awaited for.
  * @param[in]  fiber      What to unblock.
@@ -205,8 +230,8 @@ VALUE rb_fiber_scheduler_block(VALUE scheduler, VALUE blocker, VALUE timeout);
 VALUE rb_fiber_scheduler_unblock(VALUE scheduler, VALUE blocker, VALUE fiber);
 
 /**
- * Nonblocking version of rb_io_wait().  Depending on scheduler implementation,
- * this for instance switches to another fiber etc.
+ * Non-blocking version of rb_io_wait().  Depending on scheduler
+ * implementation, this for instance switches to another fiber etc.
  *
  * The  "events" here  is a  Ruby level  integer, which  is an  OR-ed value  of
  * `IO::READABLE`, `IO::WRITABLE`, and `IO::PRIORITY`.
@@ -220,7 +245,7 @@ VALUE rb_fiber_scheduler_unblock(VALUE scheduler, VALUE blocker, VALUE fiber);
 VALUE rb_fiber_scheduler_io_wait(VALUE scheduler, VALUE io, VALUE events, VALUE timeout);
 
 /**
- * Nonblocking  wait until  the passed  IO  is ready  for reading.   This is  a
+ * Non-blocking  wait until the passed  IO  is ready  for reading.   This is  a
  * special  case   of  rb_fiber_scheduler_io_wait(),  where  the   interest  is
  * `IO::READABLE` and timeout is never.
  *
@@ -231,7 +256,7 @@ VALUE rb_fiber_scheduler_io_wait(VALUE scheduler, VALUE io, VALUE events, VALUE
 VALUE rb_fiber_scheduler_io_wait_readable(VALUE scheduler, VALUE io);
 
 /**
- * Nonblocking  wait until  the passed  IO  is ready  for writing.   This is  a
+ * Non-blocking  wait until  the passed  IO  is ready  for writing.   This is a
  * special  case   of  rb_fiber_scheduler_io_wait(),  where  the   interest  is
  * `IO::WRITABLE` and timeout is never.
  *
@@ -242,83 +267,135 @@ VALUE rb_fiber_scheduler_io_wait_readable(VALUE scheduler, VALUE io);
 VALUE rb_fiber_scheduler_io_wait_writable(VALUE scheduler, VALUE io);
 
 /**
- * Nonblocking read from the passed IO.
+ * Non-blocking version of `IO.select`.
+ *
+ * It's possible that this will be emulated using a thread, so you should not
+ * rely on it for high performance.
+ *
+ * @param[in]  scheduler    Target scheduler.
+ * @param[in]  readables    An array of readable objects.
+ * @param[in]  writables    An array of writable objects.
+ * @param[in]  exceptables  An array of objects that might encounter exceptional conditions.
+ * @param[in]  timeout      Numeric timeout or nil.
+ * @return     What `scheduler.io_select` returns, normally a 3-tuple of arrays of ready objects.
+ */
+VALUE rb_fiber_scheduler_io_select(VALUE scheduler, VALUE readables, VALUE writables, VALUE exceptables, VALUE timeout);
+
+/**
+ * Non-blocking version of `IO.select`, `argv` variant.
+ */
+VALUE rb_fiber_scheduler_io_selectv(VALUE scheduler, int argc, VALUE *argv);
+
+/**
+ * Non-blocking read from the passed IO.
  *
  * @param[in]   scheduler    Target scheduler.
- * @param[out]  io           An io object to read from.
- * @param[out]  buffer       Return buffer.
- * @param[in]   length       Requested number of bytes to read.
+ * @param[in]   io           An io object to read from.
+ * @param[in]   buffer       The buffer to read to.
+ * @param[in]   length       The minimum number of bytes to read.
+ * @param[in]   offset       The offset in the buffer to read from.
  * @retval      RUBY_Qundef  `scheduler` doesn't have `#io_read`.
  * @return      otherwise    What `scheduler.io_read` returns `[-errno, size]`.
  */
-VALUE rb_fiber_scheduler_io_read(VALUE scheduler, VALUE io, VALUE buffer, size_t length);
+VALUE rb_fiber_scheduler_io_read(VALUE scheduler, VALUE io, VALUE buffer, size_t length, size_t offset);
 
 /**
- * Nonblocking write to the passed IO.
+ * Non-blocking write to the passed IO.
  *
  * @param[in]   scheduler    Target scheduler.
- * @param[out]  io           An io object to write to.
- * @param[in]   buffer       What to write.
- * @param[in]   length       Number of bytes to write.
+ * @param[in]   io           An io object to write to.
+ * @param[in]   buffer       The buffer to write from.
+ * @param[in]   length       The minimum number of bytes to write.
+ * @param[in]   offset       The offset in the buffer to write from.
  * @retval      RUBY_Qundef  `scheduler` doesn't have `#io_write`.
  * @return      otherwise    What `scheduler.io_write` returns `[-errno, size]`.
  */
-VALUE rb_fiber_scheduler_io_write(VALUE scheduler, VALUE io, VALUE buffer, size_t length);
+VALUE rb_fiber_scheduler_io_write(VALUE scheduler, VALUE io, VALUE buffer, size_t length, size_t offset);
+
+/**
+ * Non-blocking read from the passed IO at the specified offset.
+ *
+ * @param[in]   scheduler    Target scheduler.
+ * @param[in]   io           An io object to read from.
+ * @param[in]   from         The offset to read from.
+ * @param[in]   buffer       The buffer to read to.
+ * @param[in]   length       The minimum number of bytes to read.
+ * @param[in]   offset       The offset in the buffer to read to.
+ * @retval      RUBY_Qundef  `scheduler` doesn't have `#io_read`.
+ * @return      otherwise    What `scheduler.io_read` returns.
+ */
+VALUE rb_fiber_scheduler_io_pread(VALUE scheduler, VALUE io, rb_off_t from, VALUE buffer, size_t length, size_t offset);
+
+/**
+ * Non-blocking write to the passed IO at the specified offset.
+ *
+ * @param[in]   scheduler    Target scheduler.
+ * @param[in]   io           An io object to write to.
+ * @param[in]   from         The offset to write to.
+ * @param[in]   buffer       The buffer to write from.
+ * @param[in]   length       The minimum number of bytes to write.
+ * @param[in]   offset       The offset in the buffer to write from.
+ * @retval      RUBY_Qundef  `scheduler` doesn't have `#io_write`.
+ * @return      otherwise    What `scheduler.io_write` returns.
+ */
+VALUE rb_fiber_scheduler_io_pwrite(VALUE scheduler, VALUE io, rb_off_t from, VALUE buffer, size_t length, size_t offset);
 
 /**
- * Nonblocking read from the passed IO at the specified offset.
+ * Non-blocking read from the passed IO using a native buffer.
  *
  * @param[in]   scheduler    Target scheduler.
- * @param[out]  io           An io object to read from.
- * @param[out]  buffer       Return buffer.
- * @param[in]   length       Requested number of bytes to read.
- * @param[in]   offset       The offset in the given IO to read the data from.
+ * @param[in]   io           An io object to read from.
+ * @param[in]   base         The memory to read to.
+ * @param[in]   size         Size of the memory.
+ * @param[in]   length       The minimum number of bytes to read.
  * @retval      RUBY_Qundef  `scheduler` doesn't have `#io_read`.
  * @return      otherwise    What `scheduler.io_read` returns.
  */
-VALUE rb_fiber_scheduler_io_pread(VALUE scheduler, VALUE io, VALUE buffer, size_t length, rb_off_t offset);
+VALUE rb_fiber_scheduler_io_read_memory(VALUE scheduler, VALUE io, void *base, size_t size, size_t length);
 
 /**
- * Nonblocking write to the passed IO at the specified offset.
+ * Non-blocking write to the passed IO using a native buffer.
  *
  * @param[in]   scheduler    Target scheduler.
- * @param[out]  io           An io object to write to.
- * @param[in]   buffer       What to write.
- * @param[in]   length       Number of bytes to write.
- * @param[in]   offset       The offset in the given IO to write the data to.
+ * @param[in]   io           An io object to write to.
+ * @param[in]   base         The memory to write from.
+ * @param[in]   size         Size of the memory.
+ * @param[in]   length       The minimum number of bytes to write.
  * @retval      RUBY_Qundef  `scheduler` doesn't have `#io_write`.
  * @return      otherwise    What `scheduler.io_write` returns.
  */
-VALUE rb_fiber_scheduler_io_pwrite(VALUE scheduler, VALUE io, VALUE buffer, size_t length, rb_off_t offset);
+VALUE rb_fiber_scheduler_io_write_memory(VALUE scheduler, VALUE io, const void *base, size_t size, size_t length);
 
 /**
- * Nonblocking read from the passed IO using a native buffer.
+ * Non-blocking pread from the passed IO using a native buffer.
  *
  * @param[in]   scheduler    Target scheduler.
- * @param[out]  io           An io object to read from.
- * @param[out]  buffer       Return buffer.
- * @param[in]   size         Size of the return buffer.
- * @param[in]   length       Requested number of bytes to read.
+ * @param[in]   io           An io object to read from.
+ * @param[in]   from         The offset to read from.
+ * @param[in]   base         The memory to read to.
+ * @param[in]   size         Size of the memory.
+ * @param[in]   length       The minimum number of bytes to read.
  * @retval      RUBY_Qundef  `scheduler` doesn't have `#io_read`.
  * @return      otherwise    What `scheduler.io_read` returns.
  */
-VALUE rb_fiber_scheduler_io_read_memory(VALUE scheduler, VALUE io, void *buffer, size_t size, size_t length);
+VALUE rb_fiber_scheduler_io_pread_memory(VALUE scheduler, VALUE io, rb_off_t from, void *base, size_t size, size_t length);
 
 /**
- * Nonblocking write to the passed IO using a native buffer.
+ * Non-blocking pwrite to the passed IO using a native buffer.
  *
  * @param[in]   scheduler    Target scheduler.
- * @param[out]  io           An io object to write to.
- * @param[in]   buffer       What to write.
- * @param[in]   size         Size of the buffer.
- * @param[in]   length       Number of bytes to write.
+ * @param[in]   io           An io object to write to.
+ * @param[in]   from         The offset to write from.
+ * @param[in]   base         The memory to write from.
+ * @param[in]   size         Size of the memory.
+ * @param[in]   length       The minimum number of bytes to write.
  * @retval      RUBY_Qundef  `scheduler` doesn't have `#io_write`.
  * @return      otherwise    What `scheduler.io_write` returns.
  */
-VALUE rb_fiber_scheduler_io_write_memory(VALUE scheduler, VALUE io, const void *buffer, size_t size, size_t length);
+VALUE rb_fiber_scheduler_io_pwrite_memory(VALUE scheduler, VALUE io, rb_off_t from, const void *base, size_t size, size_t length);
 
 /**
- * Nonblocking close the given IO.
+ * Non-blocking close the given IO.
  *
  * @param[in]  scheduler    Target scheduler.
  * @param[in]  io           An io object to close.
@@ -328,7 +405,7 @@ VALUE rb_fiber_scheduler_io_write_memory(VALUE scheduler, VALUE io, const void *
 VALUE rb_fiber_scheduler_io_close(VALUE scheduler, VALUE io);
 
 /**
- * Nonblocking DNS lookup.
+ * Non-blocking DNS lookup.
  *
  * @param[in]  scheduler    Target scheduler.
  * @param[in]  hostname     A host name to query.
@@ -337,6 +414,92 @@ VALUE rb_fiber_scheduler_io_close(VALUE scheduler, VALUE io);
  */
 VALUE rb_fiber_scheduler_address_resolve(VALUE scheduler, VALUE hostname);
 
+// The state of the blocking operation execution.
+struct rb_fiber_scheduler_blocking_operation_state {
+    void *result;
+    int saved_errno;
+};
+
+// The opaque handle for the blocking operation.
+typedef struct rb_fiber_scheduler_blocking_operation rb_fiber_scheduler_blocking_operation_t;
+
+/**
+ * Extract the blocking operation handle from a BlockingOperationRuby object.
+ *
+ * This function safely extracts the opaque handle from a BlockingOperation VALUE
+ * while holding the GVL. The returned pointer can be passed to worker threads
+ * and used with rb_fiber_scheduler_blocking_operation_execute.
+ *
+ * @param[in] self The BlockingOperation VALUE to extract from
+ * @return The opaque struct pointer on success, NULL on error
+ * @note Experimental.
+ */
+rb_fiber_scheduler_blocking_operation_t *rb_fiber_scheduler_blocking_operation_extract(VALUE self);
+
+/**
+ * Execute blocking operation from handle (GVL not required).
+ *
+ * This function executes a blocking operation using the opaque handle
+ * obtained from rb_fiber_scheduler_blocking_operation_extract.
+ * It can be called from native threads without holding the GVL.
+ *
+ * @param[in] blocking_operation The opaque handle.
+ * @return 0 on success, -1 on error.
+ * @note Experimental. Can be called from any thread without holding the GVL
+ */
+int rb_fiber_scheduler_blocking_operation_execute(rb_fiber_scheduler_blocking_operation_t *blocking_operation);
+
+/**
+ * Cancel a blocking operation.
+ *
+ * This function cancels a blocking operation. If the operation is queued,
+ * it just marks it as cancelled. If it's executing, it marks it as cancelled
+ * and calls the unblock function to interrupt the operation.
+ *
+ * @param blocking_operation The opaque struct pointer
+ * @return 1 if unblock function was called, 0 if just marked cancelled, -1 on error
+ * @note Experimental.
+ */
+int rb_fiber_scheduler_blocking_operation_cancel(rb_fiber_scheduler_blocking_operation_t *blocking_operation);
+
+/**
+ * Defer the execution of the passed function to the scheduler.
+ *
+ * @param[in]  scheduler         Target scheduler.
+ * @param[in]  function          The function to run.
+ * @param[in]  data              The data to pass to the function.
+ * @param[in]  unblock_function  The unblock function to use to interrupt the operation.
+ * @param[in]  data2             The data to pass to the unblock function.
+ * @param[in]  flags             Flags passed to `rb_nogvl`.
+ * @param[out] state             The result and errno of the operation.
+ * @retval     RUBY_Qundef       `scheduler` doesn't have `#blocking_operation_wait`.
+ * @return     otherwise         What `scheduler.blocking_operation_wait` returns.
+ */
+VALUE rb_fiber_scheduler_blocking_operation_wait(VALUE scheduler, void* (*function)(void *), void *data, rb_unblock_function_t *unblock_function, void *data2, int flags, struct rb_fiber_scheduler_blocking_operation_state *state);
+
+/**
+ * Interrupt a fiber by raising an exception. You can construct an exception using `rb_make_exception`.
+ *
+ * This hook may be invoked by a different thread.
+ *
+ * @param[in]  scheduler  Target scheduler.
+ * @param[in]  fiber      The fiber to interrupt.
+ * @param[in]  exception  The exception to raise in the fiber.
+ * @return     What `scheduler.fiber_interrupt` returns.
+ */
+VALUE rb_fiber_scheduler_fiber_interrupt(VALUE scheduler, VALUE fiber, VALUE exception);
+
+/**
+ * Create and schedule a non-blocking fiber.
+ *
+ * @param[in]  scheduler  Target scheduler.
+ * @param[in]  argc      Number of arguments in argv.
+ * @param[in]  argv      Array of arguments to pass to the fiber.
+ * @param[in]  kw_splat  Whether to expand last argument as keywords.
+ * @return     The created and scheduled fiber.
+ */
+VALUE rb_fiber_scheduler_fiber(VALUE scheduler, int argc, VALUE *argv, int kw_splat);
+
 RBIMPL_SYMBOL_EXPORT_END()
 
 #endif /* RUBY_FIBER_SCHEDULER_H */
diff --git a/include/ruby/intern.h b/include/ruby/intern.h
index 2480e2e703..8718169ce2 100644
--- a/include/ruby/intern.h
+++ b/include/ruby/intern.h
@@ -36,7 +36,6 @@
 #include "ruby/internal/intern/error.h"
 #include "ruby/internal/intern/eval.h"
 #include "ruby/internal/intern/file.h"
-#include "ruby/internal/intern/gc.h"
 #include "ruby/internal/intern/hash.h"
 #include "ruby/internal/intern/io.h"
 #include "ruby/internal/intern/load.h"
@@ -52,6 +51,7 @@
 #include "ruby/internal/intern/re.h"
 #include "ruby/internal/intern/ruby.h"
 #include "ruby/internal/intern/select.h"
+#include "ruby/internal/intern/set.h"
 #include "ruby/internal/intern/signal.h"
 #include "ruby/internal/intern/sprintf.h"
 #include "ruby/internal/intern/string.h"
diff --git a/include/ruby/internal/abi.h b/include/ruby/internal/abi.h
index fe1977a9a1..7ceb8c40b7 100644
--- a/include/ruby/internal/abi.h
+++ b/include/ruby/internal/abi.h
@@ -24,15 +24,16 @@
  * In released versions of Ruby, this number is not defined since teeny
  * versions of Ruby should guarantee ABI compatibility.
  */
-#define RUBY_ABI_VERSION 2
+#define RUBY_ABI_VERSION 3
 
 /* Windows does not support weak symbols so ruby_abi_version will not exist
  * in the shared library. */
 #if defined(HAVE_FUNC_WEAK) && !defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # define RUBY_DLN_CHECK_ABI
 #endif
+#endif  /* RUBY_ABI_VERSION */
 
-#ifdef RUBY_DLN_CHECK_ABI
+#if defined(RUBY_DLN_CHECK_ABI) && !defined(RUBY_EXPORT)
 
 # ifdef __cplusplus
 extern "C" {
@@ -41,7 +42,11 @@ extern "C" {
 RUBY_FUNC_EXPORTED unsigned long long __attribute__((weak))
 ruby_abi_version(void)
 {
+# ifdef RUBY_ABI_VERSION
     return RUBY_ABI_VERSION;
+# else
+    return 0;
+# endif
 }
 
 # ifdef __cplusplus
@@ -51,5 +56,3 @@ ruby_abi_version(void)
 #endif
 
 #endif
-
-#endif
diff --git a/include/ruby/internal/anyargs.h b/include/ruby/internal/anyargs.h
index 9d8d16fdab..e4c6d155cc 100644
--- a/include/ruby/internal/anyargs.h
+++ b/include/ruby/internal/anyargs.h
@@ -84,12 +84,15 @@
 
 #elif defined(_WIN32) || defined(__CYGWIN__)
 # /* Skip due to [Bug #16134] */
+# define RBIMPL_CAST_FN_PTR 1
 
 #elif ! RBIMPL_HAS_ATTRIBUTE(transparent_union)
 # /* :TODO: improve here, please find a way to support. */
+# define RBIMPL_CAST_FN_PTR 1
 
 #elif ! defined(HAVE_VA_ARGS_MACRO)
 # /* :TODO: improve here, please find a way to support. */
+# define RBIMPL_CAST_FN_PTR 1
 
 #else
 # /** @cond INTERNAL_MACRO */
@@ -239,15 +242,16 @@
 # define RBIMPL_ANYARGS_DISPATCH_rb_define_method_13(n)           RBIMPL_ANYARGS_DISPATCH((n) == 13, rb_define_method_13,           RBIMPL_ANYARGS_DISPATCH_rb_define_method_12(n))
 # define RBIMPL_ANYARGS_DISPATCH_rb_define_method_14(n)           RBIMPL_ANYARGS_DISPATCH((n) == 14, rb_define_method_14,           RBIMPL_ANYARGS_DISPATCH_rb_define_method_13(n))
 # define RBIMPL_ANYARGS_DISPATCH_rb_define_method_15(n)           RBIMPL_ANYARGS_DISPATCH((n) == 15, rb_define_method_15,           RBIMPL_ANYARGS_DISPATCH_rb_define_method_14(n))
-# define RBIMPL_ANYARGS_DISPATCH_rb_define_singleton_method(n, f) RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_singleton_method_m3, RBIMPL_ANYARGS_DISPATCH_rb_define_singleton_method_15(n))
-# define RBIMPL_ANYARGS_DISPATCH_rb_define_protected_method(n, f) RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_protected_method_m3, RBIMPL_ANYARGS_DISPATCH_rb_define_protected_method_15(n))
-# define RBIMPL_ANYARGS_DISPATCH_rb_define_private_method(n, f)   RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_private_method_m3,   RBIMPL_ANYARGS_DISPATCH_rb_define_private_method_15(n))
-# define RBIMPL_ANYARGS_DISPATCH_rb_define_module_function(n, f)  RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_module_function_m3,  RBIMPL_ANYARGS_DISPATCH_rb_define_module_function_15(n))
-# define RBIMPL_ANYARGS_DISPATCH_rb_define_global_function(n, f)  RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_global_function_m3,  RBIMPL_ANYARGS_DISPATCH_rb_define_global_function_15(n))
-# define RBIMPL_ANYARGS_DISPATCH_rb_define_method_id(n, f)        RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_method_id_m3,        RBIMPL_ANYARGS_DISPATCH_rb_define_method_id_15(n))
-# define RBIMPL_ANYARGS_DISPATCH_rb_define_method(n, f)           RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_method_m3,           RBIMPL_ANYARGS_DISPATCH_rb_define_method_15(n))
+# define RBIMPL_ANYARGS_DISPATCH_rb_define_singleton_method(n, f) RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_singleton_method_notimpl, RBIMPL_ANYARGS_DISPATCH_rb_define_singleton_method_15(n))
+# define RBIMPL_ANYARGS_DISPATCH_rb_define_protected_method(n, f) RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_protected_method_notimpl, RBIMPL_ANYARGS_DISPATCH_rb_define_protected_method_15(n))
+# define RBIMPL_ANYARGS_DISPATCH_rb_define_private_method(n, f)   RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_private_method_notimpl,   RBIMPL_ANYARGS_DISPATCH_rb_define_private_method_15(n))
+# define RBIMPL_ANYARGS_DISPATCH_rb_define_module_function(n, f)  RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_module_function_notimpl,  RBIMPL_ANYARGS_DISPATCH_rb_define_module_function_15(n))
+# define RBIMPL_ANYARGS_DISPATCH_rb_define_global_function(n, f)  RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_global_function_notimpl,  RBIMPL_ANYARGS_DISPATCH_rb_define_global_function_15(n))
+# define RBIMPL_ANYARGS_DISPATCH_rb_define_method_id(n, f)        RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_method_id_notimpl,        RBIMPL_ANYARGS_DISPATCH_rb_define_method_id_15(n))
+# define RBIMPL_ANYARGS_DISPATCH_rb_define_method(n, f)           RBIMPL_ANYARGS_DISPATCH(RBIMPL_CFUNC_IS_rb_f_notimplement(f), rb_define_method_notimpl,           RBIMPL_ANYARGS_DISPATCH_rb_define_method_15(n))
 # define RBIMPL_ANYARGS_ATTRSET(sym) RBIMPL_ATTR_MAYBE_UNUSED() RBIMPL_ATTR_NONNULL(()) RBIMPL_ATTR_WEAKREF(sym)
 # define RBIMPL_ANYARGS_DECL(sym, ...) \
+RBIMPL_ANYARGS_ATTRSET(sym) static void sym ## _notimpl(__VA_ARGS__, VALUE(*)(int, const VALUE *, VALUE, VALUE), int); \
 RBIMPL_ANYARGS_ATTRSET(sym) static void sym ## _m3(__VA_ARGS__, VALUE(*)(ANYARGS), int); \
 RBIMPL_ANYARGS_ATTRSET(sym) static void sym ## _m2(__VA_ARGS__, VALUE(*)(VALUE, VALUE), int); \
 RBIMPL_ANYARGS_ATTRSET(sym) static void sym ## _m1(__VA_ARGS__, VALUE(*)(int, union { VALUE *x; const VALUE *y; } __attribute__((__transparent_union__)), VALUE), int); \
@@ -347,6 +351,25 @@ RBIMPL_ANYARGS_DECL(rb_define_method, VALUE, const char *)
 
 #endif /* __cplusplus */
 
+#if defined(RBIMPL_CAST_FN_PTR) && !defined(__cplusplus)
+/* In C23, K&R style prototypes are gone and so `void foo(ANYARGS)` became
+ * equivalent to `void foo(void)` unlike in earlier versions. This is a problem
+ * for rb_define_* functions since that makes all valid functions one can pass
+ * trip -Wincompatible-pointer-types, which we treat as errors. This is mostly
+ * not a problem for the __builtin_choose_expr path, but outside of that we
+ * need to add a cast for compatibility.
+ */
+#define rb_define_method(klass, mid, func, arity)           rb_define_method((klass), (mid), (VALUE (*)(ANYARGS))(func), (arity))
+#define rb_define_method_id(klass, mid, func, arity)        rb_define_method_id((klass), (mid), (VALUE (*)(ANYARGS))(func), (arity))
+#define rb_define_singleton_method(obj, mid, func, arity)   rb_define_singleton_method((obj), (mid), (VALUE (*)(ANYARGS))(func), (arity))
+#define rb_define_protected_method(klass, mid, func, arity) rb_define_protected_method((klass), (mid), (VALUE (*)(ANYARGS))(func), (arity))
+#define rb_define_private_method(klass, mid, func, arity)   rb_define_private_method((klass), (mid), (VALUE (*)(ANYARGS))(func), (arity))
+#define rb_define_module_function(mod, mid, func, arity)    rb_define_module_function((mod), (mid), (VALUE (*)(ANYARGS))(func), (arity))
+#define rb_define_global_function(mid, func, arity)         rb_define_global_function((mid), (VALUE (*)(ANYARGS))(func), (arity))
+
+#undef RBIMPL_CAST_FN_PTR
+#endif /* defined(RBIMPL_CAST_FN_PTR) && !defined(__cplusplus) */
+
 /**
  * This  macro is  to properly  cast  a function  parameter of  *_define_method
  * family.  It  has been  around since  1.x era so  you can  maximise backwards
diff --git a/include/ruby/internal/arithmetic/int.h b/include/ruby/internal/arithmetic/int.h
index 6bd8ec2184..7b24d16887 100644
--- a/include/ruby/internal/arithmetic/int.h
+++ b/include/ruby/internal/arithmetic/int.h
@@ -254,7 +254,7 @@ static inline VALUE
 rb_uint2num_inline(unsigned int v)
 {
     if (RB_POSFIXABLE(v))
-        return RB_LONG2FIX(v);
+        return RB_LONG2FIX(RBIMPL_CAST((long)v));
     else
         return rb_uint2big(v);
 }
diff --git a/include/ruby/internal/arithmetic/intptr_t.h b/include/ruby/internal/arithmetic/intptr_t.h
index a354f4469c..70090f88e6 100644
--- a/include/ruby/internal/arithmetic/intptr_t.h
+++ b/include/ruby/internal/arithmetic/intptr_t.h
@@ -32,6 +32,18 @@
 #define rb_int_new  rb_int2inum  /**< @alias{rb_int2inum} */
 #define rb_uint_new rb_uint2inum /**< @alias{rb_uint2inum} */
 
+// These definitions are same as fiddle/conversions.h
+#if SIZEOF_VOIDP <= SIZEOF_LONG
+# define PTR2NUM(x) (LONG2NUM((long)(x)))
+# define NUM2PTR(x) ((void*)(NUM2ULONG(x)))
+#elif SIZEOF_VOIDP <= SIZEOF_LONG_LONG
+# define PTR2NUM(x) (LL2NUM((LONG_LONG)(x)))
+# define NUM2PTR(x) ((void*)(NUM2ULL(x)))
+#else
+// should have been an error in ruby/internal/value.h
+# error Need integer for VALUE
+#endif
+
 RBIMPL_SYMBOL_EXPORT_BEGIN()
 
 /**
diff --git a/include/ruby/internal/arithmetic/long.h b/include/ruby/internal/arithmetic/long.h
index 6b8fd8ffc3..6c00dbceb7 100644
--- a/include/ruby/internal/arithmetic/long.h
+++ b/include/ruby/internal/arithmetic/long.h
@@ -114,11 +114,11 @@ RB_INT2FIX(long i)
 
     /* :NOTE: VALUE can be wider than long.  As j being unsigned, 2j+1 is fully
      * defined. Also it can be compiled into a single LEA instruction. */
-    const unsigned long j = i;
+    const unsigned long j = RBIMPL_CAST((unsigned long)i);
     const unsigned long k = (j << 1) + RUBY_FIXNUM_FLAG;
-    const long          l = k;
+    const long          l = RBIMPL_CAST((long)k);
     const SIGNED_VALUE  m = l; /* Sign extend */
-    const VALUE         n = m;
+    const VALUE         n = RBIMPL_CAST((VALUE)m);
 
     RBIMPL_ASSERT_OR_ASSUME(RB_FIXNUM_P(n));
     return n;
@@ -166,7 +166,7 @@ rbimpl_fix2long_by_idiv(VALUE x)
     /* :NOTE: VALUE  can be wider  than long.  (x-1)/2 never  overflows because
      * RB_FIXNUM_P(x)  holds.   Also it  has  no  portability issue  like  y>>1
      * below. */
-    const SIGNED_VALUE y = x - RUBY_FIXNUM_FLAG;
+    const SIGNED_VALUE y = RBIMPL_CAST((SIGNED_VALUE)(x - RUBY_FIXNUM_FLAG));
     const SIGNED_VALUE z = y / 2;
     const long         w = RBIMPL_CAST((long)z);
 
@@ -193,7 +193,7 @@ rbimpl_fix2long_by_shift(VALUE x)
 
     /* :NOTE: VALUE can be wider than long.  If right shift is arithmetic, this
      * is noticeably faster than above. */
-    const SIGNED_VALUE y = x;
+    const SIGNED_VALUE y = RBIMPL_CAST((SIGNED_VALUE)x);
     const SIGNED_VALUE z = y >> 1;
     const long         w = RBIMPL_CAST((long)z);
 
@@ -252,7 +252,7 @@ static inline unsigned long
 rb_fix2ulong(VALUE x)
 {
     RBIMPL_ASSERT_OR_ASSUME(RB_FIXNUM_P(x));
-    return rb_fix2long(x);
+    return RBIMPL_CAST((unsigned long)rb_fix2long(x));
 }
 
 /**
@@ -323,7 +323,7 @@ static inline VALUE
 rb_ulong2num_inline(unsigned long v)
 {
     if (RB_POSFIXABLE(v))
-        return RB_LONG2FIX(v);
+        return RB_LONG2FIX(RBIMPL_CAST((long)v));
     else
         return rb_uint2big(v);
 }
diff --git a/include/ruby/internal/arithmetic/long_long.h b/include/ruby/internal/arithmetic/long_long.h
index 65dec8729d..aab455c830 100644
--- a/include/ruby/internal/arithmetic/long_long.h
+++ b/include/ruby/internal/arithmetic/long_long.h
@@ -127,7 +127,7 @@ static inline unsigned LONG_LONG
 rb_num2ull_inline(VALUE x)
 {
     if (RB_FIXNUM_P(x))
-        return RB_FIX2LONG(x);
+        return RBIMPL_CAST((unsigned LONG_LONG)RB_FIX2LONG(x));
     else
         return rb_num2ull(x);
 }
diff --git a/include/ruby/internal/arithmetic/st_data_t.h b/include/ruby/internal/arithmetic/st_data_t.h
index 3bff4ffc0b..91776b3fce 100644
--- a/include/ruby/internal/arithmetic/st_data_t.h
+++ b/include/ruby/internal/arithmetic/st_data_t.h
@@ -58,7 +58,7 @@ RBIMPL_ATTR_ARTIFICIAL()
 static inline VALUE
 RB_ST2FIX(st_data_t i)
 {
-    SIGNED_VALUE x = i;
+    SIGNED_VALUE x = RBIMPL_CAST((SIGNED_VALUE)i);
 
     if (x >= 0) {
         x &= RUBY_FIXNUM_MAX;
@@ -69,7 +69,7 @@ RB_ST2FIX(st_data_t i)
 
     RBIMPL_ASSERT_OR_ASSUME(RB_FIXABLE(x));
     unsigned long y = RBIMPL_CAST((unsigned long)x);
-    return RB_LONG2FIX(y);
+    return RB_LONG2FIX(RBIMPL_CAST((long)y));
 }
 
 #endif /* RBIMPL_ARITHMETIC_ST_DATA_T_H */
diff --git a/include/ruby/internal/attr/deprecated.h b/include/ruby/internal/attr/deprecated.h
index e1bbdbd15a..a374ace868 100644
--- a/include/ruby/internal/attr/deprecated.h
+++ b/include/ruby/internal/attr/deprecated.h
@@ -48,7 +48,7 @@
 #elif RBIMPL_HAS_ATTRIBUTE(deprecated) /* but not with message. */
 # define RBIMPL_ATTR_DEPRECATED(msg) __attribute__((__deprecated__))
 
-#elif RBIMPL_COMPILER_SINCE(MSVC, 14, 0, 0)
+#elif RBIMPL_COMPILER_IS(MSVC)
 # define RBIMPL_ATTR_DEPRECATED(msg) __declspec(deprecated msg)
 
 #elif RBIMPL_HAS_DECLSPEC_ATTRIBUTE(deprecated)
@@ -72,4 +72,11 @@
 # define RBIMPL_ATTR_DEPRECATED_EXT(msg) RBIMPL_ATTR_DEPRECATED(msg)
 #endif
 
+#define RBIMPL_ATTR_DEPRECATED_SINCE(ver) \
+    RBIMPL_ATTR_DEPRECATED(("since " #ver))
+#define RBIMPL_ATTR_DEPRECATED_INTERNAL(ver) \
+    RBIMPL_ATTR_DEPRECATED(("since "#ver", also internal"))
+#define RBIMPL_ATTR_DEPRECATED_INTERNAL_ONLY() \
+    RBIMPL_ATTR_DEPRECATED(("only for internal use"))
+
 #endif /* RBIMPL_ATTR_DEPRECATED_H */
diff --git a/include/ruby/internal/attr/forceinline.h b/include/ruby/internal/attr/forceinline.h
index b7daafede7..5b9ae794af 100644
--- a/include/ruby/internal/attr/forceinline.h
+++ b/include/ruby/internal/attr/forceinline.h
@@ -29,7 +29,7 @@
  * `__forceinline` are mutually exclusive.  We have to mimic that behaviour for
  * non-MSVC compilers.
  */
-#if RBIMPL_COMPILER_SINCE(MSVC, 12, 0, 0)
+#if RBIMPL_COMPILER_IS(MSVC)
 # define RBIMPL_ATTR_FORCEINLINE() __forceinline
 #elif RBIMPL_HAS_ATTRIBUTE(always_inline)
 # define RBIMPL_ATTR_FORCEINLINE() __attribute__((__always_inline__)) inline
diff --git a/include/ruby/internal/attr/format.h b/include/ruby/internal/attr/format.h
index b3488ee00a..7feff1c846 100644
--- a/include/ruby/internal/attr/format.h
+++ b/include/ruby/internal/attr/format.h
@@ -22,6 +22,10 @@
  */
 #include "ruby/internal/has/attribute.h"
 
+#if defined(__MINGW32__)
+#include <stdio.h>              /* for __MINGW_PRINTF_FORMAT */
+#endif
+
 /** Wraps (or simulates) `__attribute__((format))` */
 #if RBIMPL_HAS_ATTRIBUTE(format)
 # define RBIMPL_ATTR_FORMAT(x, y, z) __attribute__((__format__(x, y, z)))
diff --git a/include/ruby/internal/attr/noexcept.h b/include/ruby/internal/attr/noexcept.h
index ea3001df2a..dd4c667407 100644
--- a/include/ruby/internal/attr/noexcept.h
+++ b/include/ruby/internal/attr/noexcept.h
@@ -54,7 +54,7 @@
  *       get smarter and  smarter.  Today they can infer if  it actually throws
  *       or not without any annotations by humans (correct me if I'm wrong).
  *
- *     - When an inline function attributed `noexcepr` actually _does_ throw an
+ *     - When an inline function attributed `noexcept` actually _does_ throw an
  *       exception:  they  have to  call  `std::terminate`  then (C++  standard
  *       mandates  so).  This  means exception  handling routines  are actually
  *       enforced, not  omitted.  This doesn't impact  runtime performance (The
@@ -78,7 +78,7 @@
 #elif defined(__INTEL_CXX11_MODE__)
 # define RBIMPL_ATTR_NOEXCEPT(_) noexcept(noexcept(_))
 
-#elif RBIMPL_COMPILER_SINCE(MSVC, 19, 0, 0)
+#elif RBIMPL_COMPILER_IS(MSVC)
 # define RBIMPL_ATTR_NOEXCEPT(_) noexcept(noexcept(_))
 
 #elif __cplusplus >= 201103L
diff --git a/include/ruby/internal/attr/nonstring.h b/include/ruby/internal/attr/nonstring.h
new file mode 100644
index 0000000000..da2501f7bf
--- /dev/null
+++ b/include/ruby/internal/attr/nonstring.h
@@ -0,0 +1,40 @@
+#ifndef RBIMPL_ATTR_NONSTRING_H                        /*-*-C++-*-vi:se ft=cpp:*/
+#define RBIMPL_ATTR_NONSTRING_H
+/**
+ * @file
+ * @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.
+ * @warning    Symbols   prefixed  with   either  `RBIMPL`   or  `rbimpl`   are
+ *             implementation details.   Don't take  them as canon.  They could
+ *             rapidly appear then vanish.  The name (path) of this header file
+ *             is also an  implementation detail.  Do not expect  it to persist
+ *             at the place it is now.  Developers are free to move it anywhere
+ *             anytime at will.
+ * @note       To  ruby-core:  remember  that   this  header  can  be  possibly
+ *             recursively included  from extension  libraries written  in C++.
+ *             Do not  expect for  instance `__VA_ARGS__` is  always available.
+ *             We assume C99  for ruby itself but we don't  assume languages of
+ *             extension libraries.  They could be written in C++98.
+ * @brief      Defines #RBIMPL_ATTR_NONSTRING.
+ */
+#include "ruby/internal/has/attribute.h"
+
+/** Wraps (or simulates) `__attribute__((nonstring))` */
+#if RBIMPL_HAS_ATTRIBUTE(nonstring)
+# define RBIMPL_ATTR_NONSTRING() __attribute__((nonstring))
+# if RBIMPL_COMPILER_SINCE(GCC, 15, 0, 0)
+#   define RBIMPL_ATTR_NONSTRING_ARRAY() RBIMPL_ATTR_NONSTRING()
+# elif defined(__clang_major__) && __clang_major__ >= 21
+#   define RBIMPL_ATTR_NONSTRING_ARRAY() RBIMPL_ATTR_NONSTRING()
+# else
+#   define RBIMPL_ATTR_NONSTRING_ARRAY() /* void */
+# endif
+#else
+# define RBIMPL_ATTR_NONSTRING() /* void */
+# define RBIMPL_ATTR_NONSTRING_ARRAY() /* void */
+#endif
+
+#endif /* RBIMPL_ATTR_NONSTRING_H */
diff --git a/include/ruby/internal/attr/packed_struct.h b/include/ruby/internal/attr/packed_struct.h
new file mode 100644
index 0000000000..0678b9acc8
--- /dev/null
+++ b/include/ruby/internal/attr/packed_struct.h
@@ -0,0 +1,43 @@
+#ifndef RBIMPL_ATTR_PACKED_STRUCT_H                 /*-*-C++-*-vi:se ft=cpp:*/
+#define RBIMPL_ATTR_PACKED_STRUCT_H
+/**
+ * @file
+ * @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.
+ * @warning    Symbols   prefixed  with   either  `RBIMPL`   or  `rbimpl`   are
+ *             implementation details.   Don't take  them as canon.  They could
+ *             rapidly appear then vanish.  The name (path) of this header file
+ *             is also an  implementation detail.  Do not expect  it to persist
+ *             at the place it is now.  Developers are free to move it anywhere
+ *             anytime at will.
+ * @note       To  ruby-core:  remember  that   this  header  can  be  possibly
+ *             recursively included  from extension  libraries written  in C++.
+ *             Do not  expect for  instance `__VA_ARGS__` is  always available.
+ *             We assume C99  for ruby itself but we don't  assume languages of
+ *             extension libraries.  They could be written in C++98.
+ * @brief      Defines #RBIMPL_ATTR_PACKED_STRUCT_BEGIN,
+ *             #RBIMPL_ATTR_PACKED_STRUCT_END,
+ *             #RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_BEGIN, and
+ *             #RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_END.
+ */
+#include "ruby/internal/config.h"
+
+#ifndef RBIMPL_ATTR_PACKED_STRUCT_BEGIN
+# define RBIMPL_ATTR_PACKED_STRUCT_BEGIN() /* void */
+#endif
+#ifndef RBIMPL_ATTR_PACKED_STRUCT_END
+# define RBIMPL_ATTR_PACKED_STRUCT_END() /* void */
+#endif
+
+#if UNALIGNED_WORD_ACCESS
+# define RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_BEGIN() RBIMPL_ATTR_PACKED_STRUCT_BEGIN()
+# define RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_END() RBIMPL_ATTR_PACKED_STRUCT_END()
+#else
+# define RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_BEGIN() /* void */
+# define RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_END() /* void */
+#endif
+
+#endif
diff --git a/include/ruby/internal/attr/restrict.h b/include/ruby/internal/attr/restrict.h
index e39104138c..b12fdc9dbc 100644
--- a/include/ruby/internal/attr/restrict.h
+++ b/include/ruby/internal/attr/restrict.h
@@ -28,7 +28,7 @@
  * `__has_declspec_attribute()` which involves macro substitution. */
 
 /** Wraps (or simulates) `__declspec(restrict)` */
-#if RBIMPL_COMPILER_SINCE(MSVC, 14, 0, 0)
+#if RBIMPL_COMPILER_IS(MSVC)
 # define RBIMPL_ATTR_RESTRICT() __declspec(re ## strict)
 
 #elif RBIMPL_HAS_ATTRIBUTE(malloc)
diff --git a/include/ruby/internal/compiler_is/msvc.h b/include/ruby/internal/compiler_is/msvc.h
index 8a864ea558..824f0ecc21 100644
--- a/include/ruby/internal/compiler_is/msvc.h
+++ b/include/ruby/internal/compiler_is/msvc.h
@@ -38,19 +38,8 @@
 # define RBIMPL_COMPILER_VERSION_MINOR (_MSC_FULL_VER % 10000000 / 100000)
 # define RBIMPL_COMPILER_VERSION_PATCH (_MSC_FULL_VER            % 100000)
 
-#elif defined(_MSC_FULL_VER)
-# define RBIMPL_COMPILER_IS_MSVC 1
-# /* _MSC_FULL_VER = XXYYZZZZ */
-# define RBIMPL_COMPILER_VERSION_MAJOR (_MSC_FULL_VER / 1000000)
-# define RBIMPL_COMPILER_VERSION_MINOR (_MSC_FULL_VER % 1000000 / 10000)
-# define RBIMPL_COMPILER_VERSION_PATCH (_MSC_FULL_VER           % 10000)
-
 #else
-# define RBIMPL_COMPILER_IS_MSVC 1
-# /* _MSC_VER = XXYY */
-# define RBIMPL_COMPILER_VERSION_MAJOR (_MSC_VER / 100)
-# define RBIMPL_COMPILER_VERSION_MINOR (_MSC_VER % 100)
-# define RBIMPL_COMPILER_VERSION_PATCH 0
+# error Unsupported MSVC version
 #endif
 
 #endif /* RBIMPL_COMPILER_IS_MSVC_H */
diff --git a/include/ruby/internal/config.h b/include/ruby/internal/config.h
index 0c434e5b05..34862ded6e 100644
--- a/include/ruby/internal/config.h
+++ b/include/ruby/internal/config.h
@@ -50,7 +50,7 @@
 #  define HAVE_VA_ARGS_MACRO
 # elif defined(__INTEL_CXX11_MODE__)
 #  define HAVE_VA_ARGS_MACRO
-# elif RBIMPL_COMPILER_SINCE(MSVC, 16, 0, 0)
+# elif RBIMPL_COMPILER_IS(MSVC)
 #  define HAVE_VA_ARGS_MACRO
 # else
 #  /* NG, not known. */
@@ -113,6 +113,8 @@
 # define UNALIGNED_WORD_ACCESS 1
 #elif defined(__powerpc64__)
 # define UNALIGNED_WORD_ACCESS 1
+#elif defined(__POWERPC__) // __POWERPC__ is defined for ppc and ppc64 on Darwin
+# define UNALIGNED_WORD_ACCESS 1
 #elif defined(__aarch64__)
 # define UNALIGNED_WORD_ACCESS 1
 #elif defined(__mc68020__)
@@ -146,8 +148,4 @@
 # undef RBIMPL_TEST3
 #endif /* HAVE_VA_ARGS_MACRO */
 
-#ifndef USE_RVARGC
-# define USE_RVARGC 1
-#endif
-
 #endif /* RBIMPL_CONFIG_H */
diff --git a/include/ruby/internal/core/rarray.h b/include/ruby/internal/core/rarray.h
index c3bb40be25..b47b63d51b 100644
--- a/include/ruby/internal/core/rarray.h
+++ b/include/ruby/internal/core/rarray.h
@@ -29,25 +29,13 @@
 #include "ruby/internal/core/rbasic.h"
 #include "ruby/internal/dllexport.h"
 #include "ruby/internal/fl_type.h"
-#include "ruby/internal/rgengc.h"
+#include "ruby/internal/gc.h"
 #include "ruby/internal/stdbool.h"
 #include "ruby/internal/value.h"
 #include "ruby/internal/value_type.h"
 #include "ruby/assert.h"
 
 /**
- * @private
- * @warning  Do not touch this macro.
- * @warning  It is an implementation detail.
- * @warning  The  value of  this  macro  must match  for  ruby  itself and  all
- *           extension  libraries, otherwise  serious  memory corruption  shall
- *           occur.
- */
-#ifndef USE_TRANSIENT_HEAP
-# define USE_TRANSIENT_HEAP 1
-#endif
-
-/**
  * Convenient casting macro.
  *
  * @param   obj  An object, which is in fact an ::RArray.
@@ -59,15 +47,9 @@
 #define RARRAY_EMBED_LEN_MASK  RARRAY_EMBED_LEN_MASK
 #define RARRAY_EMBED_LEN_MAX   RARRAY_EMBED_LEN_MAX
 #define RARRAY_EMBED_LEN_SHIFT RARRAY_EMBED_LEN_SHIFT
-#if USE_TRANSIENT_HEAP
-# define RARRAY_TRANSIENT_FLAG RARRAY_TRANSIENT_FLAG
-#else
-# define RARRAY_TRANSIENT_FLAG 0
-#endif
 /** @endcond */
 #define RARRAY_LEN                 rb_array_len                 /**< @alias{rb_array_len} */
 #define RARRAY_CONST_PTR           rb_array_const_ptr           /**< @alias{rb_array_const_ptr} */
-#define RARRAY_CONST_PTR_TRANSIENT rb_array_const_ptr_transient /**< @alias{rb_array_const_ptr_transient} */
 
 /** @cond INTERNAL_MACRO */
 #if defined(__fcc__) || defined(__fcc_version) || \
@@ -80,7 +62,6 @@
 
 #define RARRAY_EMBED_LEN   RARRAY_EMBED_LEN
 #define RARRAY_LENINT      RARRAY_LENINT
-#define RARRAY_TRANSIENT_P RARRAY_TRANSIENT_P
 #define RARRAY_ASET        RARRAY_ASET
 #define RARRAY_PTR         RARRAY_PTR
 /** @endcond */
@@ -99,6 +80,8 @@
  * here is at least incomplete.
  */
 enum ruby_rarray_flags {
+    /* RUBY_FL_USER0 is for ELTS_SHARED */
+
     /**
      * This flag  has something to do  with memory footprint.  If  the array is
      * "small"  enough, ruby  tries to  be creative  to abuse  padding bits  of
@@ -118,8 +101,6 @@ enum ruby_rarray_flags {
      */
     RARRAY_EMBED_FLAG      = RUBY_FL_USER1,
 
-    /* RUBY_FL_USER2 is for ELTS_SHARED */
-
     /**
      * When an array employs embedded strategy (see ::RARRAY_EMBED_FLAG), these
      * bits  are used  to store  the number  of elements  actually filled  into
@@ -130,30 +111,8 @@ enum ruby_rarray_flags {
      * 3rd parties must  not be aware that  there even is more than  one way to
      * store array elements.  It was a bad idea to expose this to them.
      */
-#if USE_RVARGC
     RARRAY_EMBED_LEN_MASK  = RUBY_FL_USER9 | RUBY_FL_USER8 | RUBY_FL_USER7 | RUBY_FL_USER6 |
                                  RUBY_FL_USER5 | RUBY_FL_USER4 | RUBY_FL_USER3
-#else
-    RARRAY_EMBED_LEN_MASK  = RUBY_FL_USER4 | RUBY_FL_USER3
-#endif
-
-#if USE_TRANSIENT_HEAP
-    ,
-
-    /**
-     * This flag has something to do with an array's "transiency".  A transient
-     * array is an  array of young generation (of generational  GC), who stores
-     * its elements inside  of dedicated memory pages called  a transient heap.
-     * Not  every  young  generation  share  that  storage  scheme,  but  elder
-     * generations must no join.
-     *
-     * @internal
-     *
-     * 3rd parties must  not be aware that  there even is more than  one way to
-     * store array elements.  It was a bad idea to expose this to them.
-     */
-    RARRAY_TRANSIENT_FLAG  = RUBY_FL_USER13
-#endif
 };
 
 /**
@@ -163,13 +122,6 @@ enum ruby_rarray_flags {
 enum ruby_rarray_consts {
     /** Where ::RARRAY_EMBED_LEN_MASK resides. */
     RARRAY_EMBED_LEN_SHIFT = RUBY_FL_USHIFT + 3
-
-#if !USE_RVARGC
-    ,
-
-    /** Max possible number elements that can be embedded. */
-    RARRAY_EMBED_LEN_MAX   = RBIMPL_EMBED_LEN_MAX_OF(VALUE)
-#endif
 };
 
 /** Ruby's array. */
@@ -228,16 +180,12 @@ struct RArray {
          * to store its elements.  In this  case the length is encoded into the
          * flags.
          */
-#if USE_RVARGC
         /* 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
          */
         const VALUE ary[1];
-#else
-        const VALUE ary[RARRAY_EMBED_LEN_MAX];
-#endif
     } as;
 };
 
@@ -264,16 +212,6 @@ VALUE *rb_ary_ptr_use_start(VALUE ary);
  */
 void rb_ary_ptr_use_end(VALUE a);
 
-#if USE_TRANSIENT_HEAP
-/**
- * Destructively converts an array of transient backend into ordinal one.
- *
- * @param[out]  a  An object of ::RArray.
- * @pre         `a` must be a transient array.
- * @post        `a` gets out of transient heap, destructively.
- */
-void rb_ary_detransient(VALUE a);
-#endif
 RBIMPL_SYMBOL_EXPORT_END()
 
 RBIMPL_ATTR_PURE_UNLESS_DEBUG()
@@ -346,33 +284,6 @@ RARRAY_LENINT(VALUE ary)
 }
 
 RBIMPL_ATTR_PURE_UNLESS_DEBUG()
-RBIMPL_ATTR_ARTIFICIAL()
-/**
- * Queries if the array is a transient array.
- *
- * @param[in]  ary    Array in question.
- * @retval     true   Yes it is.
- * @retval     false  No it isn't.
- * @pre        `ary` must be an instance of ::RArray.
- *
- * @internal
- *
- * @shyouhei  doesn't  understand the  benefit  of  this function  called  from
- * extension libraries.
- */
-static inline bool
-RARRAY_TRANSIENT_P(VALUE ary)
-{
-    RBIMPL_ASSERT_TYPE(ary, RUBY_T_ARRAY);
-
-#if USE_TRANSIENT_HEAP
-    return RB_FL_ANY_RAW(ary, RARRAY_TRANSIENT_FLAG);
-#else
-    return false;
-#endif
-}
-
-RBIMPL_ATTR_PURE_UNLESS_DEBUG()
 /**
  * @private
  *
@@ -383,7 +294,7 @@ RBIMPL_ATTR_PURE_UNLESS_DEBUG()
  * @return     Its backend storage.
  */
 static inline const VALUE *
-rb_array_const_ptr_transient(VALUE a)
+rb_array_const_ptr(VALUE a)
 {
     RBIMPL_ASSERT_TYPE(a, RUBY_T_ARRAY);
 
@@ -395,102 +306,21 @@ rb_array_const_ptr_transient(VALUE a)
     }
 }
 
-#if ! USE_TRANSIENT_HEAP
-RBIMPL_ATTR_PURE_UNLESS_DEBUG()
-#endif
-/**
- * @private
- *
- * This is  an implementation  detail of  RARRAY_PTR().  People  do not  use it
- * directly.
- *
- * @param[in]  a  An object of ::RArray.
- * @return     Its backend storage.
- * @post       `a` is not a transient array.
- */
-static inline const VALUE *
-rb_array_const_ptr(VALUE a)
-{
-    RBIMPL_ASSERT_TYPE(a, RUBY_T_ARRAY);
-
-#if USE_TRANSIENT_HEAP
-    if (RARRAY_TRANSIENT_P(a)) {
-        rb_ary_detransient(a);
-    }
-#endif
-    return rb_array_const_ptr_transient(a);
-}
-
 /**
  * @private
  *
  * This is an  implementation detail of #RARRAY_PTR_USE.  People do  not use it
  * directly.
- *
- * @param[in]  a                An object of ::RArray.
- * @param[in]  allow_transient  Whether `a` can be transient or not.
- * @return     Its backend storage.
- * @post       `a` is not a transient array unless `allow_transient`.
  */
-static inline VALUE *
-rb_array_ptr_use_start(VALUE a,
-                       RBIMPL_ATTR_MAYBE_UNUSED()
-                       int allow_transient)
-{
-    RBIMPL_ASSERT_TYPE(a, RUBY_T_ARRAY);
-
-#if USE_TRANSIENT_HEAP
-    if (!allow_transient) {
-        if (RARRAY_TRANSIENT_P(a)) {
-            rb_ary_detransient(a);
-        }
-    }
-#endif
-
-    return rb_ary_ptr_use_start(a);
-}
-
-/**
- * @private
- *
- * This is an  implementation detail of #RARRAY_PTR_USE.  People do  not use it
- * directly.
- *
- * @param[in]  a                An object of ::RArray.
- * @param[in]  allow_transient  Whether `a` can be transient or not.
- */
-static inline void
-rb_array_ptr_use_end(VALUE a,
-                     RBIMPL_ATTR_MAYBE_UNUSED()
-                     int allow_transient)
-{
-    RBIMPL_ASSERT_TYPE(a, RUBY_T_ARRAY);
-    rb_ary_ptr_use_end(a);
-}
-
-/**
- * @private
- *
- * This is an  implementation detail of #RARRAY_PTR_USE.  People do  not use it
- * directly.
- */
-#define RBIMPL_RARRAY_STMT(flag, ary, var, expr) do {        \
+#define RBIMPL_RARRAY_STMT(ary, var, expr) do {        \
     RBIMPL_ASSERT_TYPE((ary), RUBY_T_ARRAY);                 \
     const VALUE rbimpl_ary = (ary);                          \
-    VALUE *var = rb_array_ptr_use_start(rbimpl_ary, (flag)); \
+    VALUE *var = rb_ary_ptr_use_start(rbimpl_ary); \
     expr;                                                   \
-    rb_array_ptr_use_end(rbimpl_ary, (flag));                \
+    rb_ary_ptr_use_end(rbimpl_ary);                \
 } while (0)
 
 /**
- * @private
- *
- * This is an  implementation detail of #RARRAY_PTR_USE.  People do  not use it
- * directly.
- */
-#define RARRAY_PTR_USE_END(a) rb_array_ptr_use_end(a, 0)
-
-/**
  * Declares a section of code where raw pointers are used.  In case you need to
  * touch the raw C array instead of  polite CAPIs, then that operation shall be
  * wrapped using this macro.
@@ -516,21 +346,11 @@ rb_array_ptr_use_end(VALUE a,
  * them use it...  Maybe some transition path can be implemented later.
  */
 #define RARRAY_PTR_USE(ary, ptr_name, expr)     \
-    RBIMPL_RARRAY_STMT(0, ary, ptr_name, expr)
-
-/**
- * Identical to #RARRAY_PTR_USE, except the pointer can be a transient one.
- *
- * @param  ary       An object of ::RArray.
- * @param  ptr_name  A variable name which points the C array in `expr`.
- * @param  expr      The expression that touches `ptr_name`.
- */
-#define RARRAY_PTR_USE_TRANSIENT(ary, ptr_name, expr)   \
-    RBIMPL_RARRAY_STMT(1, ary, ptr_name, expr)
+    RBIMPL_RARRAY_STMT(ary, ptr_name, expr)
 
 /**
  * Wild  use of  a  C  pointer.  This  function  accesses  the backend  storage
- * directly.   This is  slower  than  #RARRAY_PTR_USE_TRANSIENT.  It  exercises
+ * directly.   This is  slower  than  #RARRAY_PTR_USE.  It  exercises
  * extra manoeuvres  to protect our generational  GC.  Use of this  function is
  * considered archaic.  Use a modern way instead.
  *
@@ -547,7 +367,7 @@ RARRAY_PTR(VALUE ary)
 {
     RBIMPL_ASSERT_TYPE(ary, RUBY_T_ARRAY);
 
-    VALUE tmp = RB_OBJ_WB_UNPROTECT_FOR(ARRAY, ary);
+    VALUE tmp = RB_OBJ_WB_UNPROTECT(ary);
     return RBIMPL_CAST((VALUE *)RARRAY_CONST_PTR(tmp));
 }
 
@@ -565,7 +385,7 @@ RARRAY_PTR(VALUE ary)
 static inline void
 RARRAY_ASET(VALUE ary, long i, VALUE v)
 {
-    RARRAY_PTR_USE_TRANSIENT(ary, ptr,
+    RARRAY_PTR_USE(ary, ptr,
         RB_OBJ_WRITE(ary, &ptr[i], v));
 }
 
@@ -580,6 +400,6 @@ RARRAY_ASET(VALUE ary, long i, VALUE v)
  * remains as  it is due to  that.  If we could  warn such usages we  can set a
  * transition path, but currently no way is found to do so.
  */
-#define RARRAY_AREF(a, i) RARRAY_CONST_PTR_TRANSIENT(a)[i]
+#define RARRAY_AREF(a, i) RARRAY_CONST_PTR(a)[i]
 
 #endif /* RBIMPL_RARRAY_H */
diff --git a/include/ruby/internal/core/rbasic.h b/include/ruby/internal/core/rbasic.h
index 4617f743a7..63cdff8e09 100644
--- a/include/ruby/internal/core/rbasic.h
+++ b/include/ruby/internal/core/rbasic.h
@@ -55,23 +55,27 @@ enum ruby_rvalue_flags {
     RVALUE_EMBED_LEN_MAX = RBIMPL_RVALUE_EMBED_LEN_MAX
 };
 
+#if (SIZEOF_VALUE < SIZEOF_UINT64_T)
+#define RBASIC_SHAPE_ID_FIELD 1
+#else
+#define RBASIC_SHAPE_ID_FIELD 0
+#endif
+
 /**
- * Ruby's object's,  base components.  Every  single ruby objects have  them in
- * common.
+ * Ruby object's base components. All Ruby objects have them in common.
  */
 struct
 RUBY_ALIGNAS(SIZEOF_VALUE)
 RBasic {
 
     /**
-     * Per-object  flags.  Each  ruby  objects have  their own  characteristics
-     * apart from their  classes.  For instance whether an object  is frozen or
-     * not is not  controlled by its class.  This is  where such properties are
-     * stored.
+     * Per-object flags.   Each Ruby object  has its own  characteristics apart
+     * from its class.  For instance, whether an object is frozen or not is not
+     * controlled by its class.  This is where such properties are stored.
      *
      * @see enum ::ruby_fl_type
      *
-     * @note  This is ::VALUE rather than  an enum for alignment purpose.  Back
+     * @note  This is ::VALUE rather than  an enum for alignment purposes.  Back
      *        in the 1990s there were no such thing like `_Alignas` in C.
      */
     VALUE flags;
@@ -79,14 +83,18 @@ RBasic {
     /**
      * Class of an object.  Every object has its class.  Also, everything is an
      * object  in Ruby.   This means  classes are  also objects.   Classes have
-     * their own classes,  classes of classes have their classes,  too ...  and
-     * it recursively continues forever.
+     * their own classes,  classes  of classes have their classes too,  and  it
+     * recursively continues forever.
      *
-     * Also note the `const` qualifier.  In  ruby an object cannot "change" its
+     * Also note the `const` qualifier.  In Ruby, an object cannot "change" its
      * class.
      */
     const VALUE klass;
 
+#if RBASIC_SHAPE_ID_FIELD
+    VALUE shape_id;
+#endif
+
 #ifdef __cplusplus
   public:
     RBIMPL_ATTR_CONSTEXPR(CXX11)
@@ -102,8 +110,14 @@ RBasic {
     RBasic() :
         flags(RBIMPL_VALUE_NULL),
         klass(RBIMPL_VALUE_NULL)
+#if RBASIC_SHAPE_ID_FIELD
+        , shape_id(RBIMPL_VALUE_NULL)
+#endif
     {
     }
+# define RBASIC_INIT RBasic()
+#else
+# define RBASIC_INIT {RBIMPL_VALUE_NULL}
 #endif
 };
 
diff --git a/include/ruby/internal/core/rclass.h b/include/ruby/internal/core/rclass.h
index b0b6bfc80c..6f78cc569b 100644
--- a/include/ruby/internal/core/rclass.h
+++ b/include/ruby/internal/core/rclass.h
@@ -58,7 +58,7 @@ enum ruby_rmodule_flags {
      * rb_mod_refine()  has this  flag set.   This  is the  bit which  controls
      * difference between normal inclusion versus refinements.
      */
-    RMODULE_IS_REFINEMENT            = RUBY_FL_USER3
+    RMODULE_IS_REFINEMENT            = RUBY_FL_USER1
 };
 
 struct RClass; /* Opaque, declared here for RCLASS() macro. */
diff --git a/include/ruby/internal/core/rdata.h b/include/ruby/internal/core/rdata.h
index 43ab3c01e7..d0a4dc7c83 100644
--- a/include/ruby/internal/core/rdata.h
+++ b/include/ruby/internal/core/rdata.h
@@ -37,40 +37,14 @@
 #include "ruby/defines.h"
 
 /** @cond INTERNAL_MACRO */
-#ifdef RUBY_UNTYPED_DATA_WARNING
-# /* Take that. */
-#elif defined(RUBY_EXPORT)
-# define RUBY_UNTYPED_DATA_WARNING 1
-#else
-# define RUBY_UNTYPED_DATA_WARNING 0
+#ifndef RUBY_UNTYPED_DATA_WARNING
+#define RUBY_UNTYPED_DATA_WARNING 1
 #endif
 
 #define RBIMPL_DATA_FUNC(f) RBIMPL_CAST((void (*)(void *))(f))
-#define RBIMPL_ATTRSET_UNTYPED_DATA_FUNC() \
-    RBIMPL_ATTR_WARNING(("untyped Data is unsafe; use TypedData instead")) \
-    RBIMPL_ATTR_DEPRECATED(("by TypedData"))
-
-#define RBIMPL_MACRO_SELECT(x, y) x ## y
-#define RUBY_MACRO_SELECT(x, y)   RBIMPL_MACRO_SELECT(x, y)
 /** @endcond */
 
 /**
- * Convenient casting macro.
- *
- * @param   obj  An object, which is in fact an ::RData.
- * @return  The passed object casted to ::RData.
- */
-#define RDATA(obj)                RBIMPL_CAST((struct RData *)(obj))
-
-/**
- * Convenient getter macro.
- *
- * @param   obj  An object, which is in fact an ::RData.
- * @return  The passed object's ::RData::data field.
- */
-#define DATA_PTR(obj)             RDATA(obj)->data
-
-/**
  * This is a value you can set  to ::RData::dfree.  Setting this means the data
  * was allocated using ::ruby_xmalloc() (or variants), and shall be freed using
  * ::ruby_xfree().
@@ -89,19 +63,6 @@
 #define RUBY_NEVER_FREE           RBIMPL_DATA_FUNC(0)
 
 /**
- * @private
- *
- * @deprecated  This macro once was a thing in the old days, but makes no sense
- *              any  longer today.   Exists  here  for backwards  compatibility
- *              only.  You can safely forget about it.
- */
-#define RUBY_UNTYPED_DATA_FUNC(f) f RBIMPL_ATTRSET_UNTYPED_DATA_FUNC()
-
-/*
-#define RUBY_DATA_FUNC(func) ((void (*)(void*))(func))
-*/
-
-/**
  * This is  the type of callbacks  registered to ::RData.  The  argument is the
  * `data` field.
  */
@@ -110,277 +71,16 @@ typedef void (*RUBY_DATA_FUNC)(void*);
 /**
  * @deprecated
  *
- * Old  "untyped"  user  data.   It  has  roughly  the  same  usage  as  struct
- * ::RTypedData, but lacked several features such as support for compaction GC.
- * Use of this struct is not recommended  any longer.  If it is dead necessary,
- * please inform the core devs about your usage.
- *
- * @internal
- *
- * @shyouhei tried to add RBIMPL_ATTR_DEPRECATED for this type but that yielded
- * too many warnings  in the core.  Maybe  we want to retry  later...  Just add
- * deprecated document for now.
+ * DO NOT USE: Obsolete "untyped" user data, that is remained only for
+ * the backward compatibility for some wrapper generator gems.
  */
 struct RData {
-
-    /** Basic part, including flags and class. */
     struct RBasic basic;
-
-    /**
-     * This function is called when the object is experiencing GC marks.  If it
-     * contains references to  other Ruby objects, you need to  mark them also.
-     * Otherwise GC will smash your data.
-     *
-     * @see      rb_gc_mark()
-     * @warning  This  is  called  during  GC  runs.   Object  allocations  are
-     *           impossible at that moment (that is why GC runs).
-     */
+    VALUE fields_obj;
+    VALUE _reserved;
+    void *data;
     RUBY_DATA_FUNC dmark;
-
-    /**
-     * This function is called when the object  is no longer used.  You need to
-     * do whatever necessary to avoid memory leaks.
-     *
-     * @warning  This  is  called  during  GC  runs.   Object  allocations  are
-     *           impossible at that moment (that is why GC runs).
-     */
     RUBY_DATA_FUNC dfree;
-
-    /** Pointer to the actual C level struct that you want to wrap. */
-    void *data;
 };
 
-RBIMPL_SYMBOL_EXPORT_BEGIN()
-
-/**
- * This is the primitive way to wrap an existing C struct into ::RData.
- *
- * @param[in]  klass          Ruby level class of the returning object.
- * @param[in]  datap          Pointer to the target C struct.
- * @param[in]  dmark          Mark function.
- * @param[in]  dfree          Free function.
- * @exception  rb_eTypeError  `klass` is not a class.
- * @exception  rb_eNoMemError  Out of memory.
- * @return     An allocated object that wraps `datap`.
- */
-VALUE rb_data_object_wrap(VALUE klass, void *datap, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree);
-
-/**
- * Identical to  rb_data_object_wrap(), except it  allocates a new  data region
- * internally instead of taking an existing  one.  The allocation is done using
- * ruby_calloc().   Hence  it  makes  no  sense to  pass  anything  other  than
- * ::RUBY_DEFAULT_FREE to the last argument.
- *
- * @param[in]  klass          Ruby level class of the returning object.
- * @param[in]  size           Requested size of memory to allocate.
- * @param[in]  dmark          Mark function.
- * @param[in]  dfree          Free function.
- * @exception  rb_eTypeError  `klass` is not a class.
- * @exception  rb_eNoMemError  Out of memory.
- * @return     An allocated object that wraps a new `size` byte region.
- */
-VALUE rb_data_object_zalloc(VALUE klass, size_t size, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree);
-
-/**
- * @private
- * Documented in include/ruby/internal/globals.h
- */
-RUBY_EXTERN VALUE rb_cObject;
-RBIMPL_SYMBOL_EXPORT_END()
-
-/**
- * Converts sval, a pointer to your struct, into a Ruby object.
- *
- * @param      klass          A ruby level class.
- * @param      mark           Mark function.
- * @param      free           Free function.
- * @param      sval           A pointer to your struct.
- * @exception  rb_eTypeError  `klass` is not a class.
- * @exception  rb_eNoMemError  Out of memory.
- * @return     A created Ruby object.
- */
-#define Data_Wrap_Struct(klass, mark, free, sval) \
-    rb_data_object_wrap(                          \
-        (klass),                                  \
-        (sval),                                   \
-        RBIMPL_DATA_FUNC(mark),                    \
-        RBIMPL_DATA_FUNC(free))
-
-/**
- * @private
- *
- * This is an implementation detail  of #Data_Make_Struct.  People don't use it
- * directly.
- *
- * @param  result     Variable name of created Ruby object.
- * @param  klass      Ruby level class of the object.
- * @param  type       Type name of the C struct.
- * @param  size       Size of the C struct.
- * @param  mark       Mark function.
- * @param  free       Free function.
- * @param  sval       Variable name of created C struct.
- */
-#define Data_Make_Struct0(result, klass, type, size, mark, free, sval)  \
-    VALUE result = rb_data_object_zalloc(          \
-        (klass),                                   \
-        (size),                                    \
-        RBIMPL_DATA_FUNC(mark),                     \
-        RBIMPL_DATA_FUNC(free));                    \
-    (sval) = RBIMPL_CAST((type *)DATA_PTR(result)); \
-    RBIMPL_CAST(/*suppress unused variable warnings*/(void)(sval))
-
-/**
- * Identical  to  #Data_Wrap_Struct, except  it  allocates  a new  data  region
- * internally instead of taking an existing  one.  The allocation is done using
- * ruby_calloc().   Hence  it  makes  no  sense to  pass  anything  other  than
- * ::RUBY_DEFAULT_FREE to the `free` argument.
- *
- * @param      klass          Ruby level class of the returning object.
- * @param      type           Type name of the C struct.
- * @param      mark           Mark function.
- * @param      free           Free function.
- * @param      sval           Variable name of created C struct.
- * @exception  rb_eTypeError  `klass` is not a class.
- * @exception  rb_eNoMemError  Out of memory.
- * @return     A created Ruby object.
- */
-#ifdef HAVE_STMT_AND_DECL_IN_EXPR
-#define Data_Make_Struct(klass, type, mark, free, sval) \
-    RB_GNUC_EXTENSION({      \
-        Data_Make_Struct0(   \
-            data_struct_obj, \
-            klass,           \
-            type,            \
-            sizeof(type),    \
-            mark,            \
-            free,            \
-            sval);           \
-        data_struct_obj;     \
-    })
-#else
-#define Data_Make_Struct(klass, type, mark, free, sval) \
-    rb_data_object_make(              \
-        (klass),                      \
-        RBIMPL_DATA_FUNC(mark),        \
-        RBIMPL_DATA_FUNC(free),        \
-        RBIMPL_CAST((void **)&(sval)), \
-        sizeof(type))
-#endif
-
-/**
- * Obtains a C struct from inside of a wrapper Ruby object.
- *
- * @param      obj            An instance of ::RData.
- * @param      type           Type name of the C struct.
- * @param      sval           Variable name of obtained C struct.
- * @return     Unwrapped C struct that `obj` holds.
- */
-#define Data_Get_Struct(obj, type, sval) \
-    ((sval) = RBIMPL_CAST((type*)rb_data_object_get(obj)))
-
-RBIMPL_ATTRSET_UNTYPED_DATA_FUNC()
-/**
- * @private
- *
- * This is an implementation detail of rb_data_object_wrap().  People don't use
- * it directly.
- *
- * @param[in]  klass          Ruby level class of the returning object.
- * @param[in]  ptr            Pointer to the target C struct.
- * @param[in]  mark           Mark function.
- * @param[in]  free           Free function.
- * @exception  rb_eTypeError  `klass` is not a class.
- * @exception  rb_eNoMemError  Out of memory.
- * @return     An allocated object that wraps `datap`.
- */
-static inline VALUE
-rb_data_object_wrap_warning(VALUE klass, void *ptr, RUBY_DATA_FUNC mark, RUBY_DATA_FUNC free)
-{
-    return rb_data_object_wrap(klass, ptr, mark, free);
-}
-
-/**
- * @private
- *
- * This is an  implementation detail of #Data_Get_Struct.  People  don't use it
- * directly.
- *
- * @param[in]  obj  An instance of ::RData.
- * @return     Unwrapped C struct that `obj` holds.
- */
-static inline void *
-rb_data_object_get(VALUE obj)
-{
-    Check_Type(obj, RUBY_T_DATA);
-    return DATA_PTR(obj);
-}
-
-RBIMPL_ATTRSET_UNTYPED_DATA_FUNC()
-/**
- * @private
- *
- * This is an  implementation detail of #Data_Get_Struct.  People  don't use it
- * directly.
- *
- * @param[in]  obj  An instance of ::RData.
- * @return     Unwrapped C struct that `obj` holds.
- */
-static inline void *
-rb_data_object_get_warning(VALUE obj)
-{
-    return rb_data_object_get(obj);
-}
-
-#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P)
-# define rb_data_object_wrap_warning(klass, ptr, mark, free) \
-    RB_GNUC_EXTENSION(                                       \
-        __builtin_choose_expr(                               \
-            __builtin_constant_p(klass) && !(klass),         \
-            rb_data_object_wrap(klass, ptr, mark, free),     \
-            (rb_data_object_wrap_warning)(klass, ptr, mark, free)))
-#endif
-
-/**
- * This is an implementation detail  of #Data_Make_Struct.  People don't use it
- * directly.
- *
- * @param[in]  klass           Ruby level class of the returning object.
- * @param[in]  mark_func       Mark function.
- * @param[in]  free_func       Free function.
- * @param[in]  datap           Variable of created C struct.
- * @param[in]  size            Requested size of allocation.
- * @exception  rb_eTypeError  `klass` is not a class.
- * @exception  rb_eNoMemError  Out of memory.
- * @return     A created Ruby object.
- * @post       `*datap` holds the created C struct.
- */
-static inline VALUE
-rb_data_object_make(VALUE klass, RUBY_DATA_FUNC mark_func, RUBY_DATA_FUNC free_func, void **datap, size_t size)
-{
-    Data_Make_Struct0(result, klass, void, size, mark_func, free_func, *datap);
-    return result;
-}
-
-RBIMPL_ATTR_DEPRECATED(("by: rb_data_object_wrap"))
-/** @deprecated  This function was renamed to rb_data_object_wrap(). */
-static inline VALUE
-rb_data_object_alloc(VALUE klass, void *data, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree)
-{
-    return rb_data_object_wrap(klass, data, dmark, dfree);
-}
-
-/** @cond INTERNAL_MACRO */
-#define rb_data_object_wrap_0 rb_data_object_wrap
-#define rb_data_object_wrap_1 rb_data_object_wrap_warning
-#define rb_data_object_wrap_2 rb_data_object_wrap_ /* Used here vvvv */
-#define rb_data_object_wrap   RUBY_MACRO_SELECT(rb_data_object_wrap_2, RUBY_UNTYPED_DATA_WARNING)
-#define rb_data_object_get_0  rb_data_object_get
-#define rb_data_object_get_1  rb_data_object_get_warning
-#define rb_data_object_get_2  rb_data_object_get_ /* Used here vvvv */
-#define rb_data_object_get    RUBY_MACRO_SELECT(rb_data_object_get_2, RUBY_UNTYPED_DATA_WARNING)
-#define rb_data_object_make_0 rb_data_object_make
-#define rb_data_object_make_1 rb_data_object_make_warning
-#define rb_data_object_make_2 rb_data_object_make_ /* Used here vvvv */
-#define rb_data_object_make   RUBY_MACRO_SELECT(rb_data_object_make_2, RUBY_UNTYPED_DATA_WARNING)
-/** @endcond */
 #endif /* RBIMPL_RDATA_H */
diff --git a/include/ruby/internal/core/rfile.h b/include/ruby/internal/core/rfile.h
index f8dddde9e5..a0eb8cb833 100644
--- a/include/ruby/internal/core/rfile.h
+++ b/include/ruby/internal/core/rfile.h
@@ -25,7 +25,7 @@
 
 /* rb_io_t is in ruby/io.h.  The header file has historically not been included
  * into ruby/ruby.h.  We follow that tradition. */
-struct rb_io_t;
+struct rb_io;
 
 /**
  * Ruby's File  and IO.  Ruby's  IO are not  just file descriptors.   They have
@@ -38,7 +38,7 @@ struct RFile {
     struct RBasic basic;
 
     /** IO's specific fields. */
-    struct rb_io_t *fptr;
+    struct rb_io *fptr;
 };
 
 /**
diff --git a/include/ruby/internal/core/rhash.h b/include/ruby/internal/core/rhash.h
index 61d2c15d87..897c570794 100644
--- a/include/ruby/internal/core/rhash.h
+++ b/include/ruby/internal/core/rhash.h
@@ -54,19 +54,6 @@
  *
  * @internal
  *
- * Declaration of rb_hash_iter_lev() is at include/ruby/backward.h.
- */
-#define RHASH_ITER_LEV(h)           rb_hash_iter_lev(h)
-
-/**
- * @private
- *
- * @deprecated  This macro once was a thing in the old days, but makes no sense
- *              any  longer today.   Exists  here  for backwards  compatibility
- *              only.  You can safely forget about it.
- *
- * @internal
- *
  * Declaration of rb_hash_ifnone() is at include/ruby/backward.h.
  */
 #define RHASH_IFNONE(h)             rb_hash_ifnone(h)
diff --git a/include/ruby/internal/core/rmatch.h b/include/ruby/internal/core/rmatch.h
index 2d2fd897f5..ae93755531 100644
--- a/include/ruby/internal/core/rmatch.h
+++ b/include/ruby/internal/core/rmatch.h
@@ -67,21 +67,6 @@ struct rmatch_offset {
     long end; /**< End of a group. */
 };
 
-/** Represents a match. */
-struct rmatch {
-    /**
-     * "Registers"  of a  match.   This  is a  quasi-opaque  struct that  holds
-     * execution result of a match.  Roughly resembles `&~`.
-     */
-    struct re_registers regs;
-
-    /** Capture group offsets, in C array. */
-    struct rmatch_offset *char_offset;
-
-    /** Number of ::rmatch_offset that ::rmatch::char_offset holds. */
-    int char_offset_num_allocated;
-};
-
 /**
  * Regular expression  execution context.  When a  regular expression "matches"
  * to a string, it generates capture  groups etc.  This struct holds that info.
@@ -102,18 +87,44 @@ struct RMatch {
     VALUE str;
 
     /**
-     * The result of this match.
+     * The expression of this match.
      */
-    struct rmatch *rmatch;
+    VALUE regexp;  /* RRegexp */
+
+    /** Number of ::rmatch_offset that ::rmatch::char_offset holds. */
+    int char_offset_num_allocated;
+
+    /** Capture group offsets, in C array. */
+    struct rmatch_offset *char_offset;
+
+    /** Number of capture-group registers. */
+    int num_regs;
+
+    /** Capacity of `as.embed`, in OnigPosition slots. */
+    int capa;
 
     /**
-     * The expression of this match.
+     * "Registers" of a match.  This is a quasi-opaque struct that holds
+     * execution result of a match.  Roughly resembles `$~`.
      */
-    VALUE regexp;  /* RRegexp */
+    union {
+        OnigPosition embed[1];
+        struct re_registers onig;
+    } as;
 };
 
-RBIMPL_ATTR_PURE_UNLESS_DEBUG()
-RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_SYMBOL_EXPORT_BEGIN()
+/**
+ * @private
+ *
+ * Converts an  embedded match  to onig  form.  This  is an  implementation
+ * detail of #RMATCH_REGS.  People don't use it directly.
+ *
+ * @param[out]  match  A match object, possibly in embedded form.
+ */
+void rb_match_ensure_onig(VALUE match);
+RBIMPL_SYMBOL_EXPORT_END()
+
 /**
  * Queries the raw ::re_registers.
  *
@@ -139,8 +150,8 @@ static inline struct re_registers *
 RMATCH_REGS(VALUE match)
 {
     RBIMPL_ASSERT_TYPE(match, RUBY_T_MATCH);
-    RBIMPL_ASSERT_OR_ASSUME(RMATCH(match)->rmatch != NULL);
-    return &RMATCH(match)->rmatch->regs;
+    rb_match_ensure_onig(match);
+    return &RMATCH(match)->as.onig;
 }
 
 #endif /* RBIMPL_RMATCH_H */
diff --git a/include/ruby/internal/core/robject.h b/include/ruby/internal/core/robject.h
index 7823061d8f..df1901eb1e 100644
--- a/include/ruby/internal/core/robject.h
+++ b/include/ruby/internal/core/robject.h
@@ -37,16 +37,15 @@
 /**
  * Convenient casting macro.
  *
- * @param   obj  An object, which is in fact an ::RRegexp.
- * @return  The passed object casted to ::RRegexp.
+ * @param   obj  An object, which is in fact an ::RObject.
+ * @return  The passed object casted to ::RObject.
  */
 #define ROBJECT(obj)          RBIMPL_CAST((struct RObject *)(obj))
 /** @cond INTERNAL_MACRO */
-#define ROBJECT_EMBED_LEN_MAX ROBJECT_EMBED_LEN_MAX
-#define ROBJECT_EMBED         ROBJECT_EMBED
-#define ROBJECT_NUMIV         ROBJECT_NUMIV
-#define ROBJECT_IVPTR         ROBJECT_IVPTR
-#define ROBJECT_IV_INDEX_TBL  ROBJECT_IV_INDEX_TBL
+#define ROBJECT_EMBED_LEN_MAX       ROBJECT_EMBED_LEN_MAX
+#define ROBJECT_HEAP                ROBJECT_HEAP
+#define ROBJECT_FIELDS_CAPACITY     ROBJECT_FIELDS_CAPACITY
+#define ROBJECT_FIELDS              ROBJECT_FIELDS
 /** @endcond */
 
 /**
@@ -56,10 +55,12 @@
  */
 enum ruby_robject_flags {
     /**
-     * This flag has  something to do with memory footprint.   If the object is
-     * "small"  enough, ruby  tries to  be creative  to abuse  padding bits  of
-     * struct ::RObject for storing instance variables.  This flag denotes that
-     * situation.
+     * This flag marks that the object's instance variables are stored in an
+     * external heap buffer.
+     * Normally, instance variable references are stored inside the object slot,
+     * but if it overflow, Ruby may have to allocate a separate buffer and spills
+     * the instance variables there.
+     * This flag denotes that situation.
      *
      * @warning  This  bit has  to be  considered read-only.   Setting/clearing
      *           this  bit without  corresponding fix  up must  cause immediate
@@ -72,20 +73,9 @@ enum ruby_robject_flags {
      * 3rd parties must  not be aware that  there even is more than  one way to
      * store instance variables.  Might better be hidden.
      */
-    ROBJECT_EMBED = RUBY_FL_USER1
+    ROBJECT_HEAP = RUBY_FL_USER4
 };
 
-#if !USE_RVARGC
-/**
- * This is an enum because GDB wants it (rather than a macro).  People need not
- * bother.
- */
-enum ruby_robject_consts {
-    /** Max possible number of instance variables that can be embedded. */
-    ROBJECT_EMBED_LEN_MAX = RBIMPL_EMBED_LEN_MAX_OF(VALUE)
-};
-#endif
-
 struct st_table;
 
 /**
@@ -97,14 +87,6 @@ struct RObject {
     /** Basic part, including flags and class. */
     struct RBasic basic;
 
-#if USE_RVARGC
-    /**
-    * Number of instance variables.  This is per object; objects might
-    * differ in this field even if they have the identical classes.
-    */
-    uint32_t numiv;
-#endif
-
     /** Object's specific fields. */
     union {
 
@@ -113,29 +95,15 @@ struct RObject {
          * this pattern.
          */
         struct {
-#if !USE_RVARGC
-            /**
-             * Number of instance variables.  This is per object; objects might
-             * differ in this field even if they have the identical classes.
-             */
-            uint32_t numiv;
-#endif
-
             /** Pointer to a C array that holds instance variables. */
-            VALUE *ivptr;
-
-            /**
-             * This  is a  table that  holds  instance variable  name to  index
-             * mapping.  Used when accessing instance variables using names.
-             *
-             * @internal
-             *
-             * This is a shortcut for `RCLASS_IV_INDEX_TBL(rb_obj_class(obj))`.
-             */
-            struct st_table *iv_index_tbl;
+            VALUE *fields;
         } heap;
 
-#if USE_RVARGC
+        /* When an object is too complex, it uses a st_table to store instance
+         * variable name to value mappings.
+         */
+        st_table *hash;
+
         /* Embedded instance variables. When an object is small enough, it
          * uses this area to store the instance variables.
          *
@@ -145,54 +113,9 @@ struct RObject {
          *   2. Zero length arrays are not supported by all compilers
          */
         VALUE ary[1];
-#else
-        /**
-        * Embedded instance  variables.  When  an object  is small  enough, it
-        * uses this area to store the instance variables.
-        */
-        VALUE ary[ROBJECT_EMBED_LEN_MAX];
-#endif
     } as;
 };
 
-/* Offsets for YJIT */
-#ifndef __cplusplus
-# if USE_RVARGC
-static const int32_t ROBJECT_OFFSET_NUMIV = offsetof(struct RObject, numiv);
-# else
-static const int32_t ROBJECT_OFFSET_NUMIV = offsetof(struct RObject, as.heap.numiv);
-# endif
-static const int32_t ROBJECT_OFFSET_AS_HEAP_IVPTR = offsetof(struct RObject, as.heap.ivptr);
-static const int32_t ROBJECT_OFFSET_AS_HEAP_IV_INDEX_TBL = offsetof(struct RObject, as.heap.iv_index_tbl);
-static const int32_t ROBJECT_OFFSET_AS_ARY = offsetof(struct RObject, as.ary);
-#endif
-
-RBIMPL_ATTR_PURE_UNLESS_DEBUG()
-RBIMPL_ATTR_ARTIFICIAL()
-/**
- * Queries the number of instance variables.
- *
- * @param[in]  obj  Object in question.
- * @return     Its number of instance variables.
- * @pre        `obj` must be an instance of ::RObject.
- */
-static inline uint32_t
-ROBJECT_NUMIV(VALUE obj)
-{
-    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
-
-#if USE_RVARGC
-    return ROBJECT(obj)->numiv;
-#else
-    if (RB_FL_ANY_RAW(obj, ROBJECT_EMBED)) {
-        return ROBJECT_EMBED_LEN_MAX;
-    }
-    else {
-        return ROBJECT(obj)->as.heap.numiv;
-    }
-#endif
-}
-
 RBIMPL_ATTR_PURE_UNLESS_DEBUG()
 RBIMPL_ATTR_ARTIFICIAL()
 /**
@@ -207,17 +130,17 @@ RBIMPL_ATTR_ARTIFICIAL()
  * @shyouhei finds no reason for this to be visible from extension libraries.
  */
 static inline VALUE *
-ROBJECT_IVPTR(VALUE obj)
+ROBJECT_FIELDS(VALUE obj)
 {
     RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
 
     struct RObject *const ptr = ROBJECT(obj);
 
-    if (RB_FL_ANY_RAW(obj, ROBJECT_EMBED)) {
-        return ptr->as.ary;
+    if (RB_UNLIKELY(RB_FL_ANY_RAW(obj, ROBJECT_HEAP))) {
+        return ptr->as.heap.fields;
     }
     else {
-        return ptr->as.heap.ivptr;
+        return ptr->as.ary;
     }
 }
 
diff --git a/include/ruby/internal/core/rstring.h b/include/ruby/internal/core/rstring.h
index e394ab7dca..35175ea94a 100644
--- a/include/ruby/internal/core/rstring.h
+++ b/include/ruby/internal/core/rstring.h
@@ -42,13 +42,7 @@
 
 /** @cond INTERNAL_MACRO */
 #define RSTRING_NOEMBED         RSTRING_NOEMBED
-#if !USE_RVARGC
-#define RSTRING_EMBED_LEN_MASK  RSTRING_EMBED_LEN_MASK
-#define RSTRING_EMBED_LEN_SHIFT RSTRING_EMBED_LEN_SHIFT
-#define RSTRING_EMBED_LEN_MAX   RSTRING_EMBED_LEN_MAX
-#endif
 #define RSTRING_FSTR            RSTRING_FSTR
-#define RSTRING_EMBED_LEN RSTRING_EMBED_LEN
 #define RSTRING_LEN       RSTRING_LEN
 #define RSTRING_LENINT    RSTRING_LENINT
 #define RSTRING_PTR       RSTRING_PTR
@@ -162,21 +156,6 @@ enum ruby_rstring_flags {
      */
     RSTRING_NOEMBED         = RUBY_FL_USER1,
 
-#if !USE_RVARGC
-    /**
-     * When a  string employs embedded strategy  (see ::RSTRING_NOEMBED), these
-     * bits  are  used to  store  the  number  of  bytes actually  filled  into
-     * ::RString::ary.
-     *
-     * @internal
-     *
-     * 3rd parties must  not be aware that  there even is more than  one way to
-     * store a string.  Might better be hidden.
-     */
-    RSTRING_EMBED_LEN_MASK  = RUBY_FL_USER2 | RUBY_FL_USER3 | RUBY_FL_USER4 |
-                              RUBY_FL_USER5 | RUBY_FL_USER6,
-#endif
-
     /* Actually,  string  encodings are  also  encoded  into the  flags,  using
      * remaining bits.*/
 
@@ -202,20 +181,6 @@ enum ruby_rstring_flags {
     RSTRING_FSTR            = RUBY_FL_USER17
 };
 
-#if !USE_RVARGC
-/**
- * This is an enum because GDB wants it (rather than a macro).  People need not
- * bother.
- */
-enum ruby_rstring_consts {
-    /** Where ::RSTRING_EMBED_LEN_MASK resides. */
-    RSTRING_EMBED_LEN_SHIFT = RUBY_FL_USHIFT + 2,
-
-    /** Max possible number of characters that can be embedded. */
-    RSTRING_EMBED_LEN_MAX   = RBIMPL_EMBED_LEN_MAX_OF(char) - 1
-};
-#endif
-
 /**
  * Ruby's String.  A string in ruby conceptually has these information:
  *
@@ -233,6 +198,13 @@ struct RString {
     /** Basic part, including flags and class. */
     struct RBasic basic;
 
+    /**
+     * Length of the string, not including terminating NUL character.
+     *
+     * @note  This is in bytes.
+     */
+    long len;
+
     /** String's specific fields. */
     union {
 
@@ -241,14 +213,6 @@ struct RString {
          * pattern.
          */
         struct {
-
-            /**
-             * Length of the string, not including terminating NUL character.
-             *
-             * @note  This is in bytes.
-             */
-            long len;
-
             /**
              * Pointer to  the contents of  the string.   In the old  days each
              * string had  dedicated memory  regions.  That  is no  longer true
@@ -279,24 +243,12 @@ struct RString {
 
         /** Embedded contents. */
         struct {
-#if USE_RVARGC
-            long len;
             /* 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
              */
             char ary[1];
-#else
-            /**
-             * When a  string is short enough,  it uses this area  to store the
-             * contents themselves.  This was  impractical in the 20th century,
-             * but these days 64 bit machines can typically hold 24 bytes here.
-             * Could be sufficiently large.  In this case the length is encoded
-             * into the flags.
-             */
-            char ary[RSTRING_EMBED_LEN_MAX + 1];
-#endif
         } embed;
     } as;
 };
@@ -409,81 +361,12 @@ RBIMPL_ATTR_ARTIFICIAL()
  *
  * @param[in]  str  String in question.
  * @return     Its length, in bytes.
- * @pre        `str`  must  be an  instance  of  ::RString,  and must  has  its
- *             ::RSTRING_NOEMBED flag off.
- *
- * @internal
- *
- * This was a macro  before.  It was inevitable to be  public, since macros are
- * global constructs.   But should it be  forever?  Now that it  is a function,
- * @shyouhei thinks  it could  just be  eliminated, hidden  into implementation
- * details.
- */
-static inline long
-RSTRING_EMBED_LEN(VALUE str)
-{
-    RBIMPL_ASSERT_TYPE(str, RUBY_T_STRING);
-    RBIMPL_ASSERT_OR_ASSUME(! RB_FL_ANY_RAW(str, RSTRING_NOEMBED));
-
-#if USE_RVARGC
-    long f = RSTRING(str)->as.embed.len;
-    return f;
-#else
-    VALUE f = RBASIC(str)->flags;
-    f &= RSTRING_EMBED_LEN_MASK;
-    f >>= RSTRING_EMBED_LEN_SHIFT;
-    return RBIMPL_CAST((long)f);
-#endif
-}
-
-RBIMPL_WARNING_PUSH()
-#if RBIMPL_COMPILER_IS(Intel)
-RBIMPL_WARNING_IGNORED(413)
-#endif
-
-RBIMPL_ATTR_PURE_UNLESS_DEBUG()
-RBIMPL_ATTR_ARTIFICIAL()
-/**
- * @private
- *
- * "Expands" an embedded  string into an ordinal one.  This  is a function that
- * returns aggregated type.   The returned struct always  has its `as.heap.len`
- * an `as.heap.ptr` fields set appropriately.
- *
- * This is an implementation detail that 3rd parties should never bother.
- */
-static inline struct RString
-rbimpl_rstring_getmem(VALUE str)
-{
-    RBIMPL_ASSERT_TYPE(str, RUBY_T_STRING);
-
-    if (RB_FL_ANY_RAW(str, RSTRING_NOEMBED)) {
-        return *RSTRING(str);
-    }
-    else {
-        /* Expecting compilers to optimize this on-stack struct away. */
-        struct RString retval;
-        retval.as.heap.len = RSTRING_EMBED_LEN(str);
-        retval.as.heap.ptr = RSTRING(str)->as.embed.ary;
-        return retval;
-    }
-}
-
-RBIMPL_WARNING_POP()
-
-RBIMPL_ATTR_PURE_UNLESS_DEBUG()
-RBIMPL_ATTR_ARTIFICIAL()
-/**
- * Queries the length of the string.
- *
- * @param[in]  str  String in question.
- * @return     Its length, in bytes.
  * @pre        `str` must be an instance of ::RString.
  */
 static inline long
 RSTRING_LEN(VALUE str)
 {
-    return rbimpl_rstring_getmem(str).as.heap.len;
+    return RSTRING(str)->len;
 }
 
 RBIMPL_ATTR_ARTIFICIAL()
@@ -497,15 +380,13 @@ RBIMPL_ATTR_ARTIFICIAL()
 static inline char *
 RSTRING_PTR(VALUE str)
 {
-    char *ptr = rbimpl_rstring_getmem(str).as.heap.ptr;
+    char *ptr = RB_FL_TEST_RAW(str, RSTRING_NOEMBED) ?
+        RSTRING(str)->as.heap.ptr :
+        RSTRING(str)->as.embed.ary;
 
-    if (RB_UNLIKELY(! ptr)) {
+    if (RUBY_DEBUG && RB_UNLIKELY(! ptr)) {
         /* :BEWARE: @shyouhei thinks  that currently, there are  rooms for this
-         * function to return  NULL.  In the 20th century that  was a pointless
-         * concern.  However struct RString can hold fake strings nowadays.  It
-         * seems no  check against NULL  are exercised around handling  of them
-         * (one  of  such   usages  is  located  in   marshal.c,  which  scares
-         * @shyouhei).  Better check here for maximum safety.
+         * function to return  NULL.  Better check here for maximum safety.
          *
          * Also,  this is  not rb_warn()  because RSTRING_PTR()  can be  called
          * during GC (see  what obj_info() does).  rb_warn()  needs to allocate
@@ -527,14 +408,17 @@ RBIMPL_ATTR_ARTIFICIAL()
 static inline char *
 RSTRING_END(VALUE str)
 {
-    struct RString buf = rbimpl_rstring_getmem(str);
+    char *ptr = RB_FL_TEST_RAW(str, RSTRING_NOEMBED) ?
+        RSTRING(str)->as.heap.ptr :
+        RSTRING(str)->as.embed.ary;
+    long len = RSTRING_LEN(str);
 
-    if (RB_UNLIKELY(! buf.as.heap.ptr)) {
+    if (RUBY_DEBUG && RB_UNLIKELY(!ptr)) {
         /* Ditto. */
         rb_debug_rstring_null_ptr("RSTRING_END");
     }
 
-    return &buf.as.heap.ptr[buf.as.heap.len];
+    return &ptr[len];
 }
 
 RBIMPL_ATTR_ARTIFICIAL()
@@ -563,16 +447,7 @@ RSTRING_LENINT(VALUE str)
  * @param  ptrvar  Variable where its contents is stored.
  * @param  lenvar  Variable where its length is stored.
  */
-#ifdef HAVE_STMT_AND_DECL_IN_EXPR
-# define RSTRING_GETMEM(str, ptrvar, lenvar) \
-    __extension__ ({ \
-        struct RString rbimpl_str = rbimpl_rstring_getmem(str); \
-        (ptrvar) = rbimpl_str.as.heap.ptr; \
-        (lenvar) = rbimpl_str.as.heap.len; \
-    })
-#else
 # define RSTRING_GETMEM(str, ptrvar, lenvar) \
     ((ptrvar) = RSTRING_PTR(str),           \
      (lenvar) = RSTRING_LEN(str))
-#endif /* HAVE_STMT_AND_DECL_IN_EXPR */
 #endif /* RBIMPL_RSTRING_H */
diff --git a/include/ruby/internal/core/rstruct.h b/include/ruby/internal/core/rstruct.h
index 69be487b59..0028a1bdcd 100644
--- a/include/ruby/internal/core/rstruct.h
+++ b/include/ruby/internal/core/rstruct.h
@@ -31,18 +31,6 @@
 # include "ruby/backward.h"
 #endif
 
-/**
- * @private
- *
- * @deprecated  This macro once was a thing in the old days, but makes no sense
- *              any  longer today.   Exists  here  for backwards  compatibility
- *              only.  You can safely forget about it.
- *
- * @internal
- *
- * Declaration of rb_struct_ptr() is at include/ruby/backward.h.
- */
-#define RSTRUCT_PTR(st) rb_struct_ptr(st)
 /** @cond INTERNAL_MACRO */
 #define RSTRUCT_LEN RSTRUCT_LEN
 #define RSTRUCT_SET RSTRUCT_SET
diff --git a/include/ruby/internal/core/rtypeddata.h b/include/ruby/internal/core/rtypeddata.h
index bbf208867d..eb8313f180 100644
--- a/include/ruby/internal/core/rtypeddata.h
+++ b/include/ruby/internal/core/rtypeddata.h
@@ -26,6 +26,7 @@
 # include <stddef.h>
 #endif
 
+#include "ruby/assert.h"
 #include "ruby/internal/assume.h"
 #include "ruby/internal/attr/artificial.h"
 #include "ruby/internal/attr/flag_enum.h"
@@ -37,6 +38,7 @@
 #include "ruby/internal/dllexport.h"
 #include "ruby/internal/error.h"
 #include "ruby/internal/fl_type.h"
+#include "ruby/internal/static_assert.h"
 #include "ruby/internal/stdbool.h"
 #include "ruby/internal/value_type.h"
 
@@ -93,13 +95,15 @@
  */
 #define RTYPEDDATA(obj)              RBIMPL_CAST((struct RTypedData *)(obj))
 
+static inline VALUE rbimpl_check_external_typeddata(VALUE obj);
+
 /**
  * Convenient getter macro.
  *
  * @param   v  An object, which is in fact an ::RTypedData.
  * @return  The passed object's ::RTypedData::data field.
  */
-#define RTYPEDDATA_DATA(v)           (RTYPEDDATA(v)->data)
+#define RTYPEDDATA_DATA(v)           (RTYPEDDATA(rbimpl_check_external_typeddata(v))->data)
 
 /** @old{rb_check_typeddata} */
 #define Check_TypedStruct(v, t)      \
@@ -108,11 +112,18 @@
 /** @cond INTERNAL_MACRO */
 #define RTYPEDDATA_P                 RTYPEDDATA_P
 #define RTYPEDDATA_TYPE              RTYPEDDATA_TYPE
+#define TYPED_DATA_EMBEDDED          ((VALUE)1)
+#define TYPED_DATA_PTR_MASK          (~(TYPED_DATA_EMBEDDED))
+/** @endcond */
+
+/**
+ * Macros to see if each corresponding flag is defined.
+ */
 #define RUBY_TYPED_FREE_IMMEDIATELY  RUBY_TYPED_FREE_IMMEDIATELY
 #define RUBY_TYPED_FROZEN_SHAREABLE  RUBY_TYPED_FROZEN_SHAREABLE
 #define RUBY_TYPED_WB_PROTECTED      RUBY_TYPED_WB_PROTECTED
+#define RUBY_TYPED_EMBEDDABLE        RUBY_TYPED_EMBEDDABLE
 #define RUBY_TYPED_PROMOTED1         RUBY_TYPED_PROMOTED1
-/** @endcond */
 
 /**
  * @private
@@ -138,6 +149,22 @@ rbimpl_typeddata_flags {
     RUBY_TYPED_FREE_IMMEDIATELY = 1,
 
     /**
+     * This flag indicate to Ruby that the associated C struct may be embedded
+     * inside the object slot, instead of being externally allocated
+     * with +malloc+.
+     *
+     * Embeddable types MUST NOT be accessed using the +DATA_PTR+ macro, only
+     * with +TypedData_Get_Struct+ or +RTYPEDDATA_GET_DATA+.
+     *
+     * Embeddable types MUST NOT free the associated C struct.
+     *
+     * Pointers into the associated C struct MUST NOT be used after the ruby
+     * object is not longer on the stack, as they become invalid when GC
+     * compaction occurs
+     */
+    RUBY_TYPED_EMBEDDABLE = 2,
+
+    /**
      * This flag has something to do with Ractor.  Multiple Ractors run without
      * protecting each  other.  Sharing  an object  among Ractors  is basically
      * dangerous,  disabled by  default.   This  flag is  used  to bypass  that
@@ -151,6 +178,12 @@ rbimpl_typeddata_flags {
      */
     RUBY_TYPED_FROZEN_SHAREABLE = RUBY_FL_SHAREABLE,
 
+    // experimental flag
+    // Similar to RUBY_TYPED_FROZEN_SHAREABLE, but doesn't make shareable
+    // reachable objects from this T_DATA object on the Ractor.make_shareable.
+    // If it refers to unshareable objects, simply raise an error.
+    // RUBY_TYPED_FROZEN_SHAREABLE_NO_REC = RUBY_FL_FINALIZE,
+
     /**
      * This flag  has something to do  with our garbage collector.   These days
      * ruby  objects are  "generational".  There  are those  who are  young and
@@ -173,10 +206,11 @@ rbimpl_typeddata_flags {
     RUBY_TYPED_WB_PROTECTED     = RUBY_FL_WB_PROTECTED, /* THIS FLAG DEPENDS ON Ruby version */
 
     /**
-     * This flag  is mysterious.  It seems  nobody is currently using  it.  The
-     * intention of this flag is also unclear.  We need further investigations.
+     * This flag determines whether marking and compaction should be carried out
+     * using the dmark/dcompact callback functions or whether we should mark
+     * declaratively using a list of references defined inside the data struct we're wrapping
      */
-    RUBY_TYPED_PROMOTED1        = RUBY_FL_PROMOTED1     /* THIS FLAG DEPENDS ON Ruby version */
+    RUBY_TYPED_DECL_MARKING     = RUBY_FL_USER2
 };
 
 /**
@@ -241,10 +275,15 @@ struct rb_data_type_struct {
         RUBY_DATA_FUNC dcompact;
 
         /**
-         * This field  is reserved for future  extension.  For now, it  must be
-         * filled with zeros.
+         * @internal
          */
-        void *reserved[1]; /* For future extension.
+        void (*handle_weak_references)(void *);
+
+         /**
+          * This field  is reserved for future  extension.  For now, it  must be
+          * filled with zeros.
+          */
+        void *reserved[7]; /* For future extension.
                               This array *must* be filled with ZERO. */
     } function;
 
@@ -342,26 +381,45 @@ struct RTypedData {
     /** The part that all ruby objects have in common. */
     struct RBasic basic;
 
-    /**
-     * This field  stores various  information about how  Ruby should  handle a
-     * data.   This roughly  resembles a  Ruby level  class (apart  from method
-     * definition etc.)
-     */
-    const rb_data_type_t *type;
+    /** Direct reference to the slots that holds instance variables, if any **/
+    VALUE fields_obj;
 
     /**
-     * This has to be always 1.
+     * This is a `const rb_data_type_t *const` value, with the low bits set:
      *
-     * @internal
+     * 1: Set if object is embedded.
      *
-     * Why, then, this is not a const ::VALUE?
+     * This field  stores various  information about how  Ruby should  handle a
+     * data.   This roughly  resembles a  Ruby level  class (apart  from method
+     * definition etc.)
      */
-    VALUE typed_flag;
+    const VALUE type;
 
     /** Pointer to the actual C level struct that you want to wrap. */
     void *data;
 };
 
+#if !defined(__cplusplus) || __cplusplus >= 201103L
+RBIMPL_STATIC_ASSERT(fields_obj_in_rdata, offsetof(struct RData, fields_obj) == offsetof(struct RTypedData, fields_obj));
+RBIMPL_STATIC_ASSERT(data_in_rtypeddata, offsetof(struct RData, data) == offsetof(struct RTypedData, data));
+#endif
+
+/**
+ * Convenient casting macro for backward compatibility.
+ *
+ * @param   obj  An object, which is in fact an ::RData.
+ * @return  The passed object casted to ::RData.
+ */
+#define RDATA(obj)                RTYPEDDATA(obj)
+
+/**
+ * Convenient casting macro for backward compatibility.
+ *
+ * @param   obj  An object, which is in fact an ::RData.
+ * @return  The passed object's ::RTypedData::data field.
+ */
+#define DATA_PTR(obj)             RTYPEDDATA_DATA(obj)
+
 RBIMPL_SYMBOL_EXPORT_BEGIN()
 RBIMPL_ATTR_NONNULL((3))
 /**
@@ -376,11 +434,11 @@ RBIMPL_ATTR_NONNULL((3))
  */
 VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *type);
 
+RBIMPL_ATTR_NONNULL((3))
 /**
  * Identical  to rb_data_typed_object_wrap(),  except it  allocates a  new data
  * region internally instead of taking an existing one.  The allocation is done
- * using ruby_calloc().  Hence it makes  no sense for `type->function.dfree` to
- * be anything other than ::RUBY_TYPED_DEFAULT_FREE.
+ * using ruby_calloc().
  *
  * @param[in]  klass          Ruby level class of the returning object.
  * @param[in]  size           Requested size of memory to allocate.
@@ -391,6 +449,7 @@ VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *
  */
 VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type);
 
+RBIMPL_ATTR_NONNULL(())
 /**
  * Checks for the domestic relationship between the two.
  *
@@ -405,6 +464,7 @@ VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t
  */
 int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
 
+RBIMPL_ATTR_NONNULL((2))
 /**
  * Checks if the given object is of given kind.
  *
@@ -415,6 +475,7 @@ int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *
  */
 int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type);
 
+RBIMPL_ATTR_NONNULL((2))
 /**
  * Identical to rb_typeddata_is_kind_of(), except  it raises exceptions instead
  * of returning false.
@@ -426,8 +487,49 @@ int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type);
  * @post       Upon successful return `obj`'s type is guaranteed `data_type`.
  */
 void *rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type);
+
+RBIMPL_ATTR_NORETURN()
+RBIMPL_ATTR_NONNULL((2))
+/**
+ * @private
+ *
+ * Fails with the given object's type incompatibility to the type.
+ *
+ * This  is  an implementation  detail  of  Check_Type.   People don't  use  it
+ * directly.
+ *
+ * @param[in]  obj            The object in question.
+ * @param[in]  expected       Name of expected data type of `obj`.
+ */
+void rb_unexpected_object_type(VALUE obj, const char *expected);
+
+RBIMPL_ATTR_NORETURN()
+RBIMPL_ATTR_NONNULL(())
+/**
+ * @private
+ *
+ * Fails with the given object's type incompatibility to the type.
+ *
+ * This is  an implementation  detail of #TypedData_Make_Struct.   People don't
+ * use it directly.
+ *
+ * @param[in]  actual         Actual data type.
+ * @param[in]  expected       Expected data type.
+ */
+void rb_unexpected_typeddata(const rb_data_type_t *actual, const rb_data_type_t *expected);
 RBIMPL_SYMBOL_EXPORT_END()
 
+#if RUBY_DEBUG
+# define RBIMPL_TYPEDDATA_PRECONDITION(obj, unreachable) \
+    while (RB_UNLIKELY(!RB_TYPE_P(obj, RUBY_T_DATA))) { \
+        rb_unexpected_object_type(obj, "Data"); \
+        unreachable; \
+    }
+#else
+# define RBIMPL_TYPEDDATA_PRECONDITION(obj, unreachable) \
+    RBIMPL_ASSERT_NOTHING
+#endif
+
 /**
  * Converts sval, a pointer to your struct, into a Ruby object.
  *
@@ -456,14 +558,13 @@ RBIMPL_SYMBOL_EXPORT_END()
  */
 #define TypedData_Make_Struct0(result, klass, type, size, data_type, sval) \
     VALUE result = rb_data_typed_object_zalloc(klass, size, data_type);    \
-    (sval) = RBIMPL_CAST((type *)RTYPEDDATA_DATA(result));                  \
+    (sval) = RBIMPL_CAST((type *)rbimpl_typeddata_get_data(result)); \
     RBIMPL_CAST(/*suppress unused variable warnings*/(void)(sval))
 
 /**
  * Identical to #TypedData_Wrap_Struct,  except it allocates a  new data region
  * internally instead of taking an existing  one.  The allocation is done using
- * ruby_calloc().  Hence  it makes no sense  for `data_type->function.dfree` to
- * be anything other than ::RUBY_TYPED_DEFAULT_FREE.
+ * ruby_calloc().
  *
  * @param      klass          Ruby level class of the object.
  * @param      type           Type name of the C struct.
@@ -494,64 +595,78 @@ RBIMPL_SYMBOL_EXPORT_END()
         sizeof(type))
 #endif
 
-/**
- * Obtains a C struct from inside of a wrapper Ruby object.
- *
- * @param      obj            An instance of ::RTypedData.
- * @param      type           Type name of the C struct.
- * @param      data_type      The data type describing `type`.
- * @param      sval           Variable name of obtained C struct.
- * @exception  rb_eTypeError  `obj` is not a kind of `data_type`.
- * @return     Unwrapped C struct that `obj` holds.
- */
-#define TypedData_Get_Struct(obj,type,data_type,sval) \
-    ((sval) = RBIMPL_CAST((type *)rb_check_typeddata((obj), (data_type))))
+static inline bool
+rbimpl_typeddata_embedded_p(VALUE obj)
+{
+    return (RTYPEDDATA(obj)->type) & TYPED_DATA_EMBEDDED;
+}
+
+RBIMPL_ATTR_DEPRECATED_INTERNAL_ONLY()
+static inline bool
+RTYPEDDATA_EMBEDDED_P(VALUE obj)
+{
+    RBIMPL_TYPEDDATA_PRECONDITION(obj, RBIMPL_UNREACHABLE_RETURN(false));
+
+    return rbimpl_typeddata_embedded_p(obj);
+}
+
+static inline void *
+rbimpl_typeddata_get_data(VALUE obj)
+{
+    /* We reuse the data pointer in embedded TypedData. */
+    return rbimpl_typeddata_embedded_p(obj) ?
+        RBIMPL_CAST((void *)&RTYPEDDATA(obj)->data) :
+        RTYPEDDATA_DATA(obj);
+}
+
+static inline void *
+RTYPEDDATA_GET_DATA(VALUE obj)
+{
+    RBIMPL_TYPEDDATA_PRECONDITION(obj, RBIMPL_UNREACHABLE_RETURN(NULL));
+
+    return rbimpl_typeddata_get_data(obj);
+}
 
 RBIMPL_ATTR_PURE()
 RBIMPL_ATTR_ARTIFICIAL()
 /**
  * @private
  *
- * This  is an  implementation detail  of  Check_Type().  People  don't use  it
- * directly.
+ * Checks whether the passed object is ::RTypedData.
+ *
+ * This is an  implementation detail of inline functions defined  in this file.
+ * People don't use it directly.
  *
  * @param[in]  obj    Object in question
  * @retval     true   `obj` is an instance of ::RTypedData.
- * @retval     false  `obj` is an instance of ::RData.
- * @pre        `obj` must be a Ruby object of ::RUBY_T_DATA.
+ * @retval     false  `obj` is not an instance of ::RTypedData
  */
 static inline bool
-rbimpl_rtypeddata_p(VALUE obj)
+rbimpl_obj_typeddata_p(VALUE obj)
 {
-    return RTYPEDDATA(obj)->typed_flag == 1;
+    return RB_TYPE_P(obj, RUBY_T_DATA);
 }
 
 RBIMPL_ATTR_PURE_UNLESS_DEBUG()
 RBIMPL_ATTR_ARTIFICIAL()
 /**
- * Checks whether the passed object is ::RTypedData or ::RData.
+ * Checks whether the passed object is ::RTypedData.
  *
  * @param[in]  obj    Object in question
- * @retval     true   `obj` is an instance of ::RTypedData.
- * @retval     false  `obj` is an instance of ::RData.
+ * @retval     true
  * @pre        `obj` must be a Ruby object of ::RUBY_T_DATA.
  */
 static inline bool
 RTYPEDDATA_P(VALUE obj)
 {
-#if RUBY_DEBUG
-    if (RB_UNLIKELY(! RB_TYPE_P(obj, RUBY_T_DATA))) {
-        Check_Type(obj, RUBY_T_DATA);
-        RBIMPL_UNREACHABLE_RETURN(false);
-    }
-#endif
+    RBIMPL_TYPEDDATA_PRECONDITION(obj, RBIMPL_UNREACHABLE_RETURN(false));
 
-    return rbimpl_rtypeddata_p(obj);
+    return true;
 }
 
 RBIMPL_ATTR_PURE_UNLESS_DEBUG()
 RBIMPL_ATTR_ARTIFICIAL()
-/* :TODO: can this function be __attribute__((returns_nonnull)) or not? */
+RBIMPL_ATTR_RETURNS_NONNULL()
 /**
  * Queries for the type of given object.
  *
@@ -559,19 +674,92 @@ RBIMPL_ATTR_ARTIFICIAL()
  * @return     Data type struct that corresponds to `obj`.
  * @pre        `obj` must be an instance of ::RTypedData.
  */
-static inline const struct rb_data_type_struct *
+static inline const rb_data_type_t *
 RTYPEDDATA_TYPE(VALUE obj)
 {
-#if RUBY_DEBUG
-    if (RB_UNLIKELY(! RTYPEDDATA_P(obj))) {
-        rb_unexpected_type(obj, RUBY_T_DATA);
-        RBIMPL_UNREACHABLE_RETURN(NULL);
+    RBIMPL_TYPEDDATA_PRECONDITION(obj, RBIMPL_UNREACHABLE_RETURN(NULL));
+
+    VALUE type = RTYPEDDATA(obj)->type & TYPED_DATA_PTR_MASK;
+    const rb_data_type_t *ptr = RBIMPL_CAST((const rb_data_type_t *)type);
+    RBIMPL_ASSERT_OR_ASSUME(ptr);
+    return ptr;
+}
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NONNULL(())
+static inline bool
+rbimpl_typeddata_inherited_p_inline(const rb_data_type_t *child, const rb_data_type_t *parent)
+{
+    do {
+        if (RB_LIKELY(child == parent)) return true;
+    } while ((child = child->parent) != NULL);
+    return false;
+}
+#define rb_typeddata_inherited_p rbimpl_typeddata_inherited_p_inline
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NONNULL((2))
+static inline bool
+rbimpl_typeddata_is_kind_of_inline(VALUE obj, const rb_data_type_t *data_type)
+{
+    if (RB_UNLIKELY(!rbimpl_obj_typeddata_p(obj))) return false;
+    return rb_typeddata_inherited_p(RTYPEDDATA_TYPE(obj), data_type);
+}
+#define rb_typeddata_is_kind_of rbimpl_typeddata_is_kind_of_inline
+
+RBIMPL_ATTR_ARTIFICIAL()
+RBIMPL_ATTR_NONNULL((2))
+/**
+ * @private
+ *
+ * This  is an  implementation detail  of  TypedData_Get_Struct().  Don't use  it
+ * directly.
+ */
+static inline void *
+rbimpl_check_typeddata(VALUE obj, const rb_data_type_t *expected_type)
+{
+    if (RB_UNLIKELY(!rbimpl_obj_typeddata_p(obj))) {
+        rb_unexpected_object_type(obj, expected_type->wrap_struct_name);
+    }
+
+    const rb_data_type_t *actual_type = RTYPEDDATA_TYPE(obj);
+    if (RB_UNLIKELY(!rb_typeddata_inherited_p(actual_type, expected_type))){
+        rb_unexpected_typeddata(actual_type, expected_type);
     }
-#endif
 
-    return RTYPEDDATA(obj)->type;
+    return RTYPEDDATA_GET_DATA(obj);
 }
 
+RBIMPL_ATTR_PURE_UNLESS_DEBUG()
+RBIMPL_ATTR_ARTIFICIAL()
+/**
+ * @private
+ *
+ * This  is an  implementation detail  of  RTYPEDDATA_DATA().  Don't use  it
+ * directly.
+ */
+static inline VALUE
+rbimpl_check_external_typeddata(VALUE obj)
+{
+    RBIMPL_TYPEDDATA_PRECONDITION(obj, RBIMPL_UNREACHABLE_RETURN(false));
+    RUBY_ASSERT(!rbimpl_typeddata_embedded_p(obj));
+    return obj;
+}
+
+/**
+ * Obtains a C struct from inside of a wrapper Ruby object.
+ *
+ * @param      obj            An instance of ::RTypedData.
+ * @param      type           Type name of the C struct.
+ * @param      data_type      The data type describing `type`.
+ * @param      sval           Variable name of obtained C struct.
+ * @exception  rb_eTypeError  `obj` is not a kind of `data_type`.
+ * @return     Unwrapped C struct that `obj` holds.
+ */
+#define TypedData_Get_Struct(obj,type,data_type,sval) \
+    ((sval) = RBIMPL_CAST((type *)rbimpl_check_typeddata((obj), (data_type))))
+
+RBIMPL_ATTR_NONNULL((2))
 /**
  * While  we don't  stop  you from  using  this  function, it  seems  to be  an
  * implementation  detail of  #TypedData_Make_Struct, which  is preferred  over
@@ -593,12 +781,4 @@ rb_data_typed_object_make(VALUE klass, const rb_data_type_t *type, void **datap,
     return result;
 }
 
-RBIMPL_ATTR_DEPRECATED(("by: rb_data_typed_object_wrap"))
-/** @deprecated  This function was renamed to rb_data_typed_object_wrap(). */
-static inline VALUE
-rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *type)
-{
-    return rb_data_typed_object_wrap(klass, datap, type);
-}
-
 #endif /* RBIMPL_RTYPEDDATA_H */
diff --git a/include/ruby/internal/ctype.h b/include/ruby/internal/ctype.h
index 0f7ca6c516..8b24026311 100644
--- a/include/ruby/internal/ctype.h
+++ b/include/ruby/internal/ctype.h
@@ -498,8 +498,8 @@ RBIMPL_ATTR_ARTIFICIAL()
  * Our own locale-insensitive version of `tolower(3)`.
  *
  * @param[in]  c          Byte in question to convert.
- * @retval     c          The  byte is  not listed  in in  IEEE 1003.1  section
- *                        7.3.1.1 "upper".
+ * @retval     c          The byte is not listed  in IEEE 1003.1 section 7.3.1.1
+ *                        "upper".
  * @retval     otherwise  Byte converted  using the map defined  in IEEE 1003.1
  *                        section 7.3.1 "tolower".
  * @note       Not only  does this function  works under the POSIX  Locale, but
diff --git a/include/ruby/internal/dllexport.h b/include/ruby/internal/dllexport.h
index 08a262209d..71026e7100 100644
--- a/include/ruby/internal/dllexport.h
+++ b/include/ruby/internal/dllexport.h
@@ -37,9 +37,7 @@
  * ```
  */
 #undef RUBY_EXTERN
-#if defined(MJIT_HEADER) && defined(_WIN32)
-# define RUBY_EXTERN extern __declspec(dllimport)
-#elif defined(RUBY_EXPORT)
+#if defined(RUBY_EXPORT)
 # define RUBY_EXTERN extern
 #elif defined(_WIN32)
 # define RUBY_EXTERN extern __declspec(dllimport)
@@ -59,36 +57,6 @@
 # define RUBY_FUNC_EXPORTED /* void */
 #endif
 
-/**
- * @cond INTERNAL_MACRO
- *
- * These MJIT related macros are placed here because translate_mjit_header can
- * need them.  Extension libraries should not touch.
- */
-
-/* These macros are used for functions which are exported only for MJIT
-   and NOT ensured to be exported in future versions. */
-
-#if ! defined(MJIT_HEADER)
-# define MJIT_FUNC_EXPORTED RUBY_FUNC_EXPORTED
-#elif ! RBIMPL_COMPILER_IS(MSVC)
-# define MJIT_FUNC_EXPORTED RUBY_FUNC_EXPORTED
-#else
-# define MJIT_FUNC_EXPORTED static
-#endif
-
-#define MJIT_SYMBOL_EXPORT_BEGIN RUBY_SYMBOL_EXPORT_BEGIN
-#define MJIT_SYMBOL_EXPORT_END   RUBY_SYMBOL_EXPORT_END
-
-/* On mswin, MJIT header transformation can't be used since cl.exe can't output
-   preprocessed output preserving macros. So this `MJIT_STATIC` is needed
-   to force non-static function to static on MJIT header to avoid symbol conflict. */
-#ifdef MJIT_HEADER
-# define MJIT_STATIC static
-#else
-# define MJIT_STATIC
-#endif
-
 /** @endcond */
 
 /** Shortcut macro equivalent to `RUBY_SYMBOL_EXPORT_BEGIN extern "C" {`.
diff --git a/include/ruby/internal/encoding/coderange.h b/include/ruby/internal/encoding/coderange.h
index 7a81208c9e..c89f871518 100644
--- a/include/ruby/internal/encoding/coderange.h
+++ b/include/ruby/internal/encoding/coderange.h
@@ -79,7 +79,7 @@ RBIMPL_ATTR_CONST()
 static inline bool
 RB_ENC_CODERANGE_CLEAN_P(enum ruby_coderange_type cr)
 {
-    return rb_enc_coderange_clean_p(cr);
+    return rb_enc_coderange_clean_p(RBIMPL_CAST((int)cr));
 }
 
 RBIMPL_ATTR_PURE_UNLESS_DEBUG()
diff --git a/include/ruby/internal/encoding/encoding.h b/include/ruby/internal/encoding/encoding.h
index 4748ca806b..a58f9f2b15 100644
--- a/include/ruby/internal/encoding/encoding.h
+++ b/include/ruby/internal/encoding/encoding.h
@@ -28,6 +28,7 @@
 #include "ruby/internal/attr/pure.h"
 #include "ruby/internal/attr/returns_nonnull.h"
 #include "ruby/internal/dllexport.h"
+#include "ruby/internal/encoding/coderange.h"
 #include "ruby/internal/value.h"
 #include "ruby/internal/core/rbasic.h"
 #include "ruby/internal/fl_type.h"
@@ -79,7 +80,7 @@ enum ruby_encoding_consts {
 static inline void
 RB_ENCODING_SET_INLINED(VALUE obj, int encindex)
 {
-    VALUE f = /* upcast */ encindex;
+    VALUE f = /* upcast */ RBIMPL_CAST((VALUE)encindex);
 
     f <<= RUBY_ENCODING_SHIFT;
     RB_FL_UNSET_RAW(obj, RUBY_ENCODING_MASK);
@@ -139,23 +140,6 @@ RBIMPL_ATTR_NOALIAS()
 int rb_char_to_option_kcode(int c, int *option, int *kcode);
 
 /**
- * Creates a new encoding, using the passed one as a template.
- *
- * @param[in]  name          Name of the creating encoding.
- * @param[in]  src           Template.
- * @exception  rb_eArgError  Duplicated or malformed `name`.
- * @return     Replicated new encoding's index.
- * @post       Encoding named `name` is created as a copy of `src`, whose index
- *             is the return value.
- *
- * @internal
- *
- * `name` can be `NULL`,  but that just raises an exception.   OTOH it seems no
- * sanity check is done against `src`...?
- */
-int rb_enc_replicate(const char *name, rb_encoding *src);
-
-/**
  * Creates a new "dummy" encoding.  Roughly speaking, an encoding is dummy when
  * it is  stateful.  Notable  example of  dummy encoding  are those  defined in
  * ISO/IEC 2022
diff --git a/include/ruby/internal/encoding/string.h b/include/ruby/internal/encoding/string.h
index 6ed7ca1c90..ea78cf23f3 100644
--- a/include/ruby/internal/encoding/string.h
+++ b/include/ruby/internal/encoding/string.h
@@ -30,7 +30,7 @@
 RBIMPL_SYMBOL_EXPORT_BEGIN()
 
 /**
- * Identical to rb_enc_str_new(), except it additionally takes an encoding.
+ * Identical to rb_str_new(), except it additionally takes an encoding.
  *
  * @param[in]  ptr             A memory region of `len` bytes length.
  * @param[in]  len             Length  of `ptr`,  in bytes,  not including  the
@@ -264,6 +264,14 @@ VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to);
 VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts);
 
 /**
+ * @private
+ *
+ * This is an implementation detail of rb_enc_str_coderange().  Don't use this
+ * directly.
+ **/
+int rbimpl_enc_str_coderange_scan(VALUE str);
+
+/**
  * Scans the passed string to collect  its code range.  Because a Ruby's string
  * is mutable, its contents  change from time to time; so  does its code range.
  * A  long-lived string  tends  to fall  back to  ::RUBY_ENC_CODERANGE_UNKNOWN.
@@ -275,6 +283,27 @@ VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ec
 int rb_enc_str_coderange(VALUE str);
 
 /**
+ * Scans the passed string to collect  its code range.  Because a Ruby's string
+ * is mutable, its contents  change from time to time; so  does its code range.
+ * A  long-lived string  tends  to fall  back to  ::RUBY_ENC_CODERANGE_UNKNOWN.
+ * This API scans it and re-assigns a fine-grained code range constant.
+ *
+ * @param[out]  str  A string.
+ * @return      An enum ::ruby_coderange_type.
+ */
+static inline int
+rb_enc_str_coderange_inline(VALUE str)
+{
+    int cr = ENC_CODERANGE(str);
+    if (cr == ENC_CODERANGE_UNKNOWN) {
+        cr = rbimpl_enc_str_coderange_scan(str);
+    }
+    return cr;
+}
+
+#define rb_enc_str_coderange rb_enc_str_coderange_inline
+
+/**
  * Scans the passed string until it finds something odd.  Returns the number of
  * bytes scanned.  As the name implies this is suitable for repeated call.  One
  * of its application is `IO#readlines`.   The method reads from its receiver's
@@ -307,13 +336,13 @@ RBIMPL_ATTR_NONNULL(())
 /**
  * Looks for the passed string in the passed buffer.
  *
- * @param[in]  x          Buffer that potentially includes `y`.
+ * @param[in]  x          Query string.
  * @param[in]  m          Number of bytes of `x`.
- * @param[in]  y          Query string.
+ * @param[in]  y          Buffer that potentially includes `x`.
  * @param[in]  n          Number of bytes of `y`.
  * @param[in]  enc        Encoding of both `x` and `y`.
  * @retval     -1         Not found.
- * @retval     otherwise  Found index in `x`.
+ * @retval     otherwise  Found index in `y`.
  * @note       This API can match at a non-character-boundary.
  */
 long rb_memsearch(const void *x, long m, const void *y, long n, rb_encoding *enc);
diff --git a/include/ruby/internal/error.h b/include/ruby/internal/error.h
index 49e2276cb9..5bf82bfe7d 100644
--- a/include/ruby/internal/error.h
+++ b/include/ruby/internal/error.h
@@ -50,7 +50,23 @@ typedef enum {
     /** Warning is for experimental features. */
     RB_WARN_CATEGORY_EXPERIMENTAL,
 
-    RB_WARN_CATEGORY_ALL_BITS = 0x6 /* no RB_WARN_CATEGORY_NONE bit */
+    /** Warning is for performance issues (not enabled by -w). */
+    RB_WARN_CATEGORY_PERFORMANCE,
+
+    /** Warning is for checking unused block strictly */
+    RB_WARN_CATEGORY_STRICT_UNUSED_BLOCK,
+
+    RB_WARN_CATEGORY_DEFAULT_BITS = (
+        (1U << RB_WARN_CATEGORY_DEPRECATED) |
+        (1U << RB_WARN_CATEGORY_EXPERIMENTAL) |
+        0),
+
+    RB_WARN_CATEGORY_ALL_BITS = (
+        (1U << RB_WARN_CATEGORY_DEPRECATED) |
+        (1U << RB_WARN_CATEGORY_EXPERIMENTAL) |
+        (1U << RB_WARN_CATEGORY_PERFORMANCE) |
+        (1U << RB_WARN_CATEGORY_STRICT_UNUSED_BLOCK) |
+        0)
 } rb_warning_category_t;
 
 /** for rb_readwrite_sys_fail first argument */
@@ -405,11 +421,12 @@ void rb_readwrite_syserr_fail(enum rb_io_wait_readwrite waiting, int err, const
 RBIMPL_ATTR_COLD()
 RBIMPL_ATTR_NORETURN()
 /**
+ * @private
+ *
  * Fails with the given object's type incompatibility to the type.
  *
- * It  seems this  function is  visible from  extension libraries  only because
- * RTYPEDDATA_TYPE() uses  it on RUBY_DEBUG.   So you can basically  ignore it;
- * use some other fine-grained method instead.
+ * This  is  an implementation  detail  of  Check_Type.   People don't  use  it
+ * directly.
  *
  * @param[in]  self           The object in question.
  * @param[in]  t              Expected type of the object.
@@ -469,7 +486,7 @@ VALUE *rb_ruby_debug_ptr(void);
  */
 #define ruby_debug   (*rb_ruby_debug_ptr())
 
-/* reports if `-W' specified */
+/* reports if $VERBOSE is true */
 RBIMPL_ATTR_NONNULL((1))
 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 1, 2)
 /**
@@ -484,7 +501,8 @@ RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 1, 2)
  * default,  the method  just emits  its passed  contents to  ::rb_stderr using
  * rb_io_write().
  *
- * @note       This function is affected by the `-W` flag.
+ * @note       This function is affected by the value of $VERBOSE, it does
+ *             nothing unless $VERBOSE is true.
  * @param[in]  fmt  Format specifier string compatible with rb_sprintf().
  *
  * @internal
@@ -509,7 +527,7 @@ RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 3, 4)
  * Issues a compile-time warning  that happens at `__file__:__line__`.  Purpose
  * of this function being exposed to CAPI is unclear.
  *
- * @note       This function is affected by the `-W` flag.
+ * @note       This function is affected by the value of $VERBOSE.
  * @param[in]  file  The path corresponding to Ruby level `__FILE__`.
  * @param[in]  line  The number corresponding to Ruby level `__LINE__`.
  * @param[in]  fmt   Format specifier string compatible with rb_sprintf().
@@ -522,19 +540,20 @@ RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 1, 2)
  * Identical to rb_sys_fail(), except it does  not raise an exception to render
  * a warning instead.
  *
- * @note       This function is affected by the `-W` flag.
+ * @note       This function is affected by the value of $VERBOSE.
  * @param[in]  fmt  Format specifier string compatible with rb_sprintf().
  */
 void rb_sys_warning(const char *fmt, ...);
 
-/* reports always */
+/* reports if $VERBOSE is not nil (so if it is true or false) */
 RBIMPL_ATTR_COLD()
 RBIMPL_ATTR_NONNULL((1))
 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 1, 2)
 /**
- * Identical to  rb_warning(), except it  reports always regardless  of runtime
- * `-W` flag.
+ * Identical to rb_warning(), except it reports unless $VERBOSE is nil.
  *
+ * @note       This function is affected by the value of $VERBOSE, it does
+ *             nothing if $VERBOSE is nil.
  * @param[in]  fmt  Format specifier string compatible with rb_sprintf().
  */
 void rb_warn(const char *fmt, ...);
@@ -543,8 +562,7 @@ RBIMPL_ATTR_COLD()
 RBIMPL_ATTR_NONNULL((2))
 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 2, 3)
 /**
- * Identical to  rb_category_warning(), except it reports  always regardless of
- * runtime `-W` flag.
+ * Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
  *
  * @param[in]  cat  Category e.g. deprecated.
  * @param[in]  fmt  Format specifier string compatible with rb_sprintf().
@@ -554,8 +572,7 @@ void rb_category_warn(rb_warning_category_t cat, const char *fmt, ...);
 RBIMPL_ATTR_NONNULL((1, 3))
 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 3, 4)
 /**
- * Identical to  rb_compile_warning(), except  it reports always  regardless of
- * runtime `-W` flag.
+ * Identical to rb_compile_warning(), except  it reports unless $VERBOSE is nil.
  *
  * @param[in]  file  The path corresponding to Ruby level `__FILE__`.
  * @param[in]  line  The number corresponding to Ruby level `__LINE__`.
diff --git a/include/ruby/internal/eval.h b/include/ruby/internal/eval.h
index 34a53849da..23aa1d9580 100644
--- a/include/ruby/internal/eval.h
+++ b/include/ruby/internal/eval.h
@@ -28,10 +28,12 @@ RBIMPL_SYMBOL_EXPORT_BEGIN()
 
 RBIMPL_ATTR_NONNULL(())
 /**
- * Evaluates the given string in an isolated binding.
+ * Evaluates the given string.
  *
- * Here  "isolated"  means  that  the   binding  does  not  inherit  any  other
- * bindings.  This behaves same as the binding for required libraries.
+ * In case  it is called  from within a  C-backended method, the  evaluation is
+ * done under  the current binding.  However  there can be no  method.  On such
+ * situation this  function evaluates  in an  isolated binding,  like `require`
+ * runs in a separate one.
  *
  * `__FILE__`  will  be  `"(eval)"`,  and  `__LINE__`  starts  from  1  in  the
  * evaluation.
@@ -39,6 +41,31 @@ RBIMPL_ATTR_NONNULL(())
  * @param[in]  str            Ruby code to evaluate.
  * @exception  rb_eException  Raises an exception on error.
  * @return     The evaluated result.
+ *
+ * @internal
+ *
+ * @shyouhei's old tale about the birth and growth of this function:
+ *
+ * At  the beginning,  there  was no  rb_eval_string().   @shyouhei heard  that
+ * @shugo, author of  Apache httpd's mod_ruby module, requested  @matz for this
+ * API.  He wanted a way so that mod_ruby can evaluate ruby scripts one by one,
+ * separately, in each different contexts.  So  this function was made.  It was
+ * designed to be a global interpreter entry point like ruby_run_node().
+ *
+ * The  way it  is implemented  however  allows extension  libraries (not  just
+ * programs like  Apache httpd) to call  this function.  Because its  name says
+ * nothing  about the  initial design,  people  started to  think of  it as  an
+ * orthodox  way  to  call  ruby  level  `eval`  method  from  their  extension
+ * libraries.  Even our `extension.rdoc` has had a description of this function
+ * basically according to this understanding.
+ *
+ * The old  (mod_ruby like) usage still  works.  But over time,  usages of this
+ * function from extension libraries got  popular, while mod_ruby faded out; is
+ * no  longer maintained  now.  Devs  decided to  actively support  both.  This
+ * function  now auto-detects  how  it is  called, and  switches  how it  works
+ * depending on it.
+ *
+ * @see https://bugs.ruby-lang.org/issues/18780
  */
 VALUE rb_eval_string(const char *str);
 
@@ -128,7 +155,8 @@ VALUE rb_funcallv(VALUE recv, ID mid, int argc, const VALUE *argv);
  * @param[in]      kw_splat           Handling of keyword parameters:
  *   - RB_NO_KEYWORDS           `argv`'s last is not a keyword argument.
  *   - RB_PASS_KEYWORDS         `argv`'s last is a keyword argument.
- *   - RB_PASS_CALLED_KEYWORDS  it depends if there is a passed block.
+ *   - RB_PASS_CALLED_KEYWORDS  Pass keyword arguments if the current method
+ *                              was called with keyword arguments.
  * @exception      rb_eNoMethodError  No such method.
  * @exception      rb_eException      Any exceptions happen inside.
  * @return         What the method evaluates to.
@@ -162,7 +190,8 @@ VALUE rb_funcallv_public(VALUE recv, ID mid, int argc, const VALUE *argv);
  * @param[in]      kw_splat           Handling of keyword parameters:
  *   - RB_NO_KEYWORDS           `argv`'s last is not a keyword argument.
  *   - RB_PASS_KEYWORDS         `argv`'s last is a keyword argument.
- *   - RB_PASS_CALLED_KEYWORDS  it depends if there is a passed block.
+ *   - RB_PASS_CALLED_KEYWORDS  Pass keyword arguments if the current method
+ *                              was called with keyword arguments.
  * @exception      rb_eNoMethodError  No such method.
  * @exception      rb_eNoMethodError  The method is private or protected.
  * @exception      rb_eException      Any exceptions happen inside.
@@ -234,7 +263,8 @@ VALUE rb_funcall_passing_block(VALUE recv, ID mid, int argc, const VALUE *argv);
  * @param[in]      kw_splat           Handling of keyword parameters:
  *   - RB_NO_KEYWORDS           `argv`'s last is not a keyword argument.
  *   - RB_PASS_KEYWORDS         `argv`'s last is a keyword argument.
- *   - RB_PASS_CALLED_KEYWORDS  it depends if there is a passed block.
+ *   - RB_PASS_CALLED_KEYWORDS  Pass keyword arguments if the current method
+ *                              was called with keyword arguments.
  * @exception      rb_eNoMethodError  No such method.
  * @exception      rb_eNoMethodError  The method is private or protected.
  * @exception      rb_eException      Any exceptions happen inside.
@@ -280,7 +310,8 @@ VALUE rb_funcall_with_block(VALUE recv, ID mid, int argc, const VALUE *argv, VAL
  * @param[in]      kw_splat           Handling of keyword parameters:
  *   - RB_NO_KEYWORDS           `argv`'s last is not a keyword argument.
  *   - RB_PASS_KEYWORDS         `argv`'s last is a keyword argument.
- *   - RB_PASS_CALLED_KEYWORDS  it depends if there is a passed block.
+ *   - RB_PASS_CALLED_KEYWORDS  Pass keyword arguments if the current method
+ *                              was called with keyword arguments.
  * @exception      rb_eNoMethodError  No such method.
  * @exception      rb_eNoMethodError  The method is private or protected.
  * @exception      rb_eException      Any exceptions happen inside.
@@ -308,7 +339,8 @@ VALUE rb_call_super(int argc, const VALUE *argv);
  * @param[in]  kw_splat           Handling of keyword parameters:
  *   - RB_NO_KEYWORDS           `argv`'s last is not a keyword argument.
  *   - RB_PASS_KEYWORDS         `argv`'s last is a keyword argument.
- *   - RB_PASS_CALLED_KEYWORDS  it depends if there is a passed block.
+ *   - RB_PASS_CALLED_KEYWORDS  Pass keyword arguments if the current method
+ *                              was called with keyword arguments.
  * @exception  rb_eNoMethodError  No super method are there.
  * @exception  rb_eException      Any exceptions happen inside.
  * @return     What the super method evaluates to.
diff --git a/include/ruby/internal/event.h b/include/ruby/internal/event.h

path: root/spec/ruby/core/hash/index_spec.rb

require_relative '../../spec_helper'
require_relative 'fixtures/classes'
require_relative 'shared/index'

describe "Hash#index" do
  it_behaves_like :hash_index, :index
end