debase-ruby_core_source 0.10.18 → 3.2.1

data/lib/debase/ruby_core_source/ruby-3.2.0-preview2/internal/bignum.h

@@ -1,246 +0,0 @@
-#ifndef INTERNAL_BIGNUM_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_BIGNUM_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for Bignums.
- */
-#include "ruby/internal/config.h"      /* for HAVE_LIBGMP */
-#include <stddef.h>             /* for size_t */
-
-#ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>         /* for ssize_t (note: on Windows ssize_t is */
-#endif                          /* `#define`d in ruby/config.h) */
-
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/ruby.h"          /* for struct RBasic */
-
-#ifndef BDIGIT
-# if SIZEOF_INT*2 <= SIZEOF_LONG_LONG
-#  define BDIGIT unsigned int
-#  define SIZEOF_BDIGIT SIZEOF_INT
-#  define BDIGIT_DBL unsigned LONG_LONG
-#  define BDIGIT_DBL_SIGNED LONG_LONG
-#  define PRI_BDIGIT_PREFIX ""
-#  define PRI_BDIGIT_DBL_PREFIX PRI_LL_PREFIX
-# elif SIZEOF_INT*2 <= SIZEOF_LONG
-#  define BDIGIT unsigned int
-#  define SIZEOF_BDIGIT SIZEOF_INT
-#  define BDIGIT_DBL unsigned long
-#  define BDIGIT_DBL_SIGNED long
-#  define PRI_BDIGIT_PREFIX ""
-#  define PRI_BDIGIT_DBL_PREFIX "l"
-# elif SIZEOF_SHORT*2 <= SIZEOF_LONG
-#  define BDIGIT unsigned short
-#  define SIZEOF_BDIGIT SIZEOF_SHORT
-#  define BDIGIT_DBL unsigned long
-#  define BDIGIT_DBL_SIGNED long
-#  define PRI_BDIGIT_PREFIX "h"
-#  define PRI_BDIGIT_DBL_PREFIX "l"
-# else
-#  define BDIGIT unsigned short
-#  define SIZEOF_BDIGIT (SIZEOF_LONG/2)
-#  define SIZEOF_ACTUAL_BDIGIT SIZEOF_LONG
-#  define BDIGIT_DBL unsigned long
-#  define BDIGIT_DBL_SIGNED long
-#  define PRI_BDIGIT_PREFIX "h"
-#  define PRI_BDIGIT_DBL_PREFIX "l"
-# endif
-#endif
-
-#ifndef SIZEOF_ACTUAL_BDIGIT
-# define SIZEOF_ACTUAL_BDIGIT SIZEOF_BDIGIT
-#endif
-
-#ifdef PRI_BDIGIT_PREFIX
-# define PRIdBDIGIT PRI_BDIGIT_PREFIX"d"
-# define PRIiBDIGIT PRI_BDIGIT_PREFIX"i"
-# define PRIoBDIGIT PRI_BDIGIT_PREFIX"o"
-# define PRIuBDIGIT PRI_BDIGIT_PREFIX"u"
-# define PRIxBDIGIT PRI_BDIGIT_PREFIX"x"
-# define PRIXBDIGIT PRI_BDIGIT_PREFIX"X"
-#endif
-
-#ifdef PRI_BDIGIT_DBL_PREFIX
-# define PRIdBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"d"
-# define PRIiBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"i"
-# define PRIoBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"o"
-# define PRIuBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"u"
-# define PRIxBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"x"
-# define PRIXBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"X"
-#endif
-
-#define RBIGNUM(obj) ((struct RBignum *)(obj))
-#define BIGNUM_SIGN_BIT FL_USER1
-#define BIGNUM_EMBED_FLAG ((VALUE)FL_USER2)
-#define BIGNUM_EMBED_LEN_NUMBITS 3
-#define BIGNUM_EMBED_LEN_MASK \
-    (~(~(VALUE)0U << BIGNUM_EMBED_LEN_NUMBITS) << BIGNUM_EMBED_LEN_SHIFT)
-#define BIGNUM_EMBED_LEN_SHIFT \
-    (FL_USHIFT+3) /* bit offset of BIGNUM_EMBED_LEN_MASK */
-#ifndef BIGNUM_EMBED_LEN_MAX
-# if (SIZEOF_VALUE*RBIMPL_RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT) < (1 << BIGNUM_EMBED_LEN_NUMBITS)-1
-#  define BIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*RBIMPL_RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT)
-# else
-#  define BIGNUM_EMBED_LEN_MAX ((1 << BIGNUM_EMBED_LEN_NUMBITS)-1)
-# endif
-#endif
-
-enum rb_int_parse_flags {
-    RB_INT_PARSE_SIGN       = 0x01,
-    RB_INT_PARSE_UNDERSCORE = 0x02,
-    RB_INT_PARSE_PREFIX     = 0x04,
-    RB_INT_PARSE_ALL        = 0x07,
-    RB_INT_PARSE_DEFAULT    = 0x07,
-};
-
-struct RBignum {
-    struct RBasic basic;
-    union {
-        struct {
-            size_t len;
-            BDIGIT *digits;
-        } heap;
-        BDIGIT ary[BIGNUM_EMBED_LEN_MAX];
-    } as;
-};
-
-/* bignum.c */
-extern const char ruby_digitmap[];
-double rb_big_fdiv_double(VALUE x, VALUE y);
-VALUE rb_big_uminus(VALUE x);
-VALUE rb_big_hash(VALUE);
-VALUE rb_big_odd_p(VALUE);
-VALUE rb_big_even_p(VALUE);
-size_t rb_big_size(VALUE);
-VALUE rb_integer_float_cmp(VALUE x, VALUE y);
-VALUE rb_integer_float_eq(VALUE x, VALUE y);
-VALUE rb_str_convert_to_inum(VALUE str, int base, int badcheck, int raise_exception);
-VALUE rb_big_comp(VALUE x);
-VALUE rb_big_aref(VALUE x, VALUE y);
-VALUE rb_big_abs(VALUE x);
-VALUE rb_big_size_m(VALUE big);
-VALUE rb_big_bit_length(VALUE big);
-VALUE rb_big_remainder(VALUE x, VALUE y);
-VALUE rb_big_gt(VALUE x, VALUE y);
-VALUE rb_big_ge(VALUE x, VALUE y);
-VALUE rb_big_lt(VALUE x, VALUE y);
-VALUE rb_big_le(VALUE x, VALUE y);
-VALUE rb_int_powm(int const argc, VALUE * const argv, VALUE const num);
-VALUE rb_big_isqrt(VALUE n);
-static inline bool BIGNUM_SIGN(VALUE b);
-static inline bool BIGNUM_POSITIVE_P(VALUE b);
-static inline bool BIGNUM_NEGATIVE_P(VALUE b);
-static inline void BIGNUM_SET_SIGN(VALUE b, bool sign);
-static inline void BIGNUM_NEGATE(VALUE b);
-static inline size_t BIGNUM_LEN(VALUE b);
-static inline BDIGIT *BIGNUM_DIGITS(VALUE b);
-static inline int BIGNUM_LENINT(VALUE b);
-static inline bool BIGNUM_EMBED_P(VALUE b);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* bignum.c (export) */
-VALUE rb_big_mul_normal(VALUE x, VALUE y);
-VALUE rb_big_mul_balance(VALUE x, VALUE y);
-VALUE rb_big_mul_karatsuba(VALUE x, VALUE y);
-VALUE rb_big_mul_toom3(VALUE x, VALUE y);
-VALUE rb_big_sq_fast(VALUE x);
-VALUE rb_big_divrem_normal(VALUE x, VALUE y);
-VALUE rb_big2str_poweroftwo(VALUE x, int base);
-VALUE rb_big2str_generic(VALUE x, int base);
-VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck);
-VALUE rb_str2big_normal(VALUE arg, int base, int badcheck);
-VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck);
-#if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
-VALUE rb_big_mul_gmp(VALUE x, VALUE y);
-VALUE rb_big_divrem_gmp(VALUE x, VALUE y);
-VALUE rb_big2str_gmp(VALUE x, int base);
-VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck);
-#endif
-VALUE rb_int_parse_cstr(const char *str, ssize_t len, char **endp, size_t *ndigits, int base, int flags);
-RUBY_SYMBOL_EXPORT_END
-
-MJIT_SYMBOL_EXPORT_BEGIN
-#if defined(HAVE_INT128_T)
-VALUE rb_int128t2big(int128_t n);
-#endif
-MJIT_SYMBOL_EXPORT_END
-
-/* sign: positive:1, negative:0 */
-static inline bool
-BIGNUM_SIGN(VALUE b)
-{
-    return FL_TEST_RAW(b, BIGNUM_SIGN_BIT);
-}
-
-static inline bool
-BIGNUM_POSITIVE_P(VALUE b)
-{
-    return BIGNUM_SIGN(b);
-}
-
-static inline bool
-BIGNUM_NEGATIVE_P(VALUE b)
-{
-    return ! BIGNUM_POSITIVE_P(b);
-}
-
-static inline void
-BIGNUM_SET_SIGN(VALUE b, bool sign)
-{
-    if (sign) {
-        FL_SET_RAW(b, BIGNUM_SIGN_BIT);
-    }
-    else {
-        FL_UNSET_RAW(b, BIGNUM_SIGN_BIT);
-    }
-}
-
-static inline void
-BIGNUM_NEGATE(VALUE b)
-{
-    FL_REVERSE_RAW(b, BIGNUM_SIGN_BIT);
-}
-
-static inline size_t
-BIGNUM_LEN(VALUE b)
-{
-    if (! BIGNUM_EMBED_P(b)) {
-        return RBIGNUM(b)->as.heap.len;
-    }
-    else {
-        size_t ret = RBASIC(b)->flags;
-        ret &= BIGNUM_EMBED_LEN_MASK;
-        ret >>= BIGNUM_EMBED_LEN_SHIFT;
-        return ret;
-    }
-}
-
-static inline int
-BIGNUM_LENINT(VALUE b)
-{
-    return rb_long2int(BIGNUM_LEN(b));
-}
-
-/* LSB:BIGNUM_DIGITS(b)[0], MSB:BIGNUM_DIGITS(b)[BIGNUM_LEN(b)-1] */
-static inline BDIGIT *
-BIGNUM_DIGITS(VALUE b)
-{
-    if (BIGNUM_EMBED_P(b)) {
-        return RBIGNUM(b)->as.ary;
-    }
-    else {
-        return RBIGNUM(b)->as.heap.digits;
-    }
-}
-
-static inline bool
-BIGNUM_EMBED_P(VALUE b)
-{
-    return FL_TEST_RAW(b, BIGNUM_EMBED_FLAG);
-}
-
-#endif /* INTERNAL_BIGNUM_H */

data/lib/debase/ruby_core_source/ruby-3.2.0-preview2/internal/compar.h

@@ -1,49 +0,0 @@
-#ifndef INTERNAL_COMPAR_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_COMPAR_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for Comparable.
- */
-#include "internal/vm.h"        /* for rb_method_basic_definition_p */
-
-#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
-
-enum {
-    cmp_opt_Integer,
-    cmp_opt_String,
-    cmp_opt_Float,
-    cmp_optimizable_count
-};
-
-struct cmp_opt_data {
-    unsigned int opt_methods;
-    unsigned int opt_inited;
-};
-
-#define NEW_CMP_OPT_MEMO(type, value) \
-    NEW_PARTIAL_MEMO_FOR(type, value, cmp_opt)
-#define CMP_OPTIMIZABLE_BIT(type) (1U << TOKEN_PASTE(cmp_opt_,type))
-#define CMP_OPTIMIZABLE(data, type) \
-    (((data).opt_inited & CMP_OPTIMIZABLE_BIT(type)) ? \
-     ((data).opt_methods & CMP_OPTIMIZABLE_BIT(type)) : \
-     (((data).opt_inited |= CMP_OPTIMIZABLE_BIT(type)), \
-      rb_method_basic_definition_p(TOKEN_PASTE(rb_c,type), id_cmp) && \
-      ((data).opt_methods |= CMP_OPTIMIZABLE_BIT(type))))
-
-#define OPTIMIZED_CMP(a, b, data) \
-    ((FIXNUM_P(a) && FIXNUM_P(b) && CMP_OPTIMIZABLE(data, Integer)) ? \
-     (((long)a > (long)b) ? 1 : ((long)a < (long)b) ? -1 : 0) : \
-     (STRING_P(a) && STRING_P(b) && CMP_OPTIMIZABLE(data, String)) ? \
-     rb_str_cmp(a, b) : \
-     (RB_FLOAT_TYPE_P(a) && RB_FLOAT_TYPE_P(b) && CMP_OPTIMIZABLE(data, Float)) ? \
-     rb_float_cmp(a, b) : \
-     rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b))
-
-/* compar.c */
-VALUE rb_invcmp(VALUE, VALUE);
-
-#endif /* INTERNAL_COMPAR_H */

data/lib/debase/ruby_core_source/ruby-3.2.0-preview2/internal/encoding.h

@@ -1,30 +0,0 @@
-#ifndef INTERNAL_ENCODING_H                              /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_ENCODING_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for Encoding.
- */
-#include "ruby/ruby.h"          /* for ID */
-#include "ruby/encoding.h"      /* for rb_encoding */
-
-#define rb_enc_autoload_p(enc) (!rb_enc_mbmaxlen(enc))
-
-/* encoding.c */
-ID rb_id_encoding(void);
-rb_encoding *rb_enc_get_from_index(int index);
-rb_encoding *rb_enc_check_str(VALUE str1, VALUE str2);
-int rb_encdb_replicate(const char *alias, const char *orig);
-int rb_encdb_alias(const char *alias, const char *orig);
-int rb_enc_autoload(rb_encoding *enc);
-int rb_encdb_dummy(const char *name);
-void rb_encdb_declare(const char *name);
-void rb_enc_set_base(const char *name, const char *orig);
-int rb_enc_set_dummy(int index);
-void rb_encdb_set_unicode(int index);
-PUREFUNC(int rb_data_is_encoding(VALUE obj));
-
-#endif /* INTERNAL_ENCODING_H */

data/lib/debase/ruby_core_source/ruby-3.2.0-preview2/internal/gc.h

@@ -1,188 +0,0 @@
-#ifndef INTERNAL_GC_H                                    /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_GC_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for GC.
- */
-#include "ruby/internal/config.h"
-
-#include <stddef.h>             /* for size_t */
-
-#include "internal/compilers.h" /* for __has_attribute */
-#include "ruby/ruby.h"          /* for rb_event_flag_t */
-
-struct rb_execution_context_struct; /* in vm_core.h */
-struct rb_objspace; /* in vm_core.h */
-
-#ifdef NEWOBJ_OF
-# undef NEWOBJ_OF
-# undef RB_NEWOBJ_OF
-# undef RB_OBJ_WRITE
-#endif
-
-#define RVALUE_SIZE (sizeof(struct RBasic) + sizeof(VALUE[RBIMPL_RVALUE_EMBED_LEN_MAX]))
-
-#define RB_RVARGC_NEWOBJ_OF(var, T, c, f, s) \
-  T *(var) = (T *)(((f) & FL_WB_PROTECTED) ? \
-                   rb_wb_protected_newobj_of((c), (f) & ~FL_WB_PROTECTED, s) : \
-                   rb_wb_unprotected_newobj_of((c), (f), s))
-
-#define RB_RVARGC_EC_NEWOBJ_OF(ec, var, T, c, f, s) \
-  T *(var) = (T *)(((f) & FL_WB_PROTECTED) ? \
-                   rb_ec_wb_protected_newobj_of((ec), (c), (f) & ~FL_WB_PROTECTED, s) : \
-                   rb_wb_unprotected_newobj_of((c), (f), s))
-
-/* optimized version of NEWOBJ() */
-#define RB_NEWOBJ_OF(var, T, c, f) RB_RVARGC_NEWOBJ_OF(var, T, c, f, RVALUE_SIZE)
-
-#define RB_EC_NEWOBJ_OF(ec, var, T, c, f) RB_RVARGC_EC_NEWOBJ_OF(ec, var, T, c, f, RVALUE_SIZE)
-
-#define NEWOBJ_OF(var, T, c, f) RB_NEWOBJ_OF((var), T, (c), (f))
-#define RVARGC_NEWOBJ_OF(var, T, c, f, s) RB_RVARGC_NEWOBJ_OF((var), T, (c), (f), (s))
-#define RB_OBJ_GC_FLAGS_MAX 6   /* used in ext/objspace */
-
-#ifndef USE_UNALIGNED_MEMBER_ACCESS
-# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
-#elif ! USE_UNALIGNED_MEMBER_ACCESS
-# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
-#elif ! (__has_warning("-Waddress-of-packed-member") || GCC_VERSION_SINCE(9, 0, 0))
-# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
-#else
-# include "internal/warnings.h"
-# define UNALIGNED_MEMBER_ACCESS(expr) __extension__({ \
-    COMPILER_WARNING_PUSH; \
-    COMPILER_WARNING_IGNORED(-Waddress-of-packed-member); \
-    __typeof__(expr) unaligned_member_access_result = (expr); \
-    COMPILER_WARNING_POP; \
-    unaligned_member_access_result; \
-})
-#endif
-
-#define UNALIGNED_MEMBER_PTR(ptr, mem) UNALIGNED_MEMBER_ACCESS(&(ptr)->mem)
-#define RB_OBJ_WRITE(a, slot, b) \
-    rb_obj_write((VALUE)(a), UNALIGNED_MEMBER_ACCESS((VALUE *)(slot)), \
-                 (VALUE)(b), __FILE__, __LINE__)
-
-#if USE_RVARGC
-# define SIZE_POOL_COUNT 5
-#else
-# define SIZE_POOL_COUNT 1
-#endif
-
-typedef struct ractor_newobj_size_pool_cache {
-    struct RVALUE *freelist;
-    struct heap_page *using_page;
-} rb_ractor_newobj_size_pool_cache_t;
-
-typedef struct ractor_newobj_cache {
-    size_t incremental_mark_step_allocated_slots;
-    rb_ractor_newobj_size_pool_cache_t size_pool_caches[SIZE_POOL_COUNT];
-} rb_ractor_newobj_cache_t;
-
-/* gc.c */
-extern VALUE *ruby_initial_gc_stress_ptr;
-extern int ruby_disable_gc;
-RUBY_ATTR_MALLOC void *ruby_mimmalloc(size_t size);
-void ruby_mimfree(void *ptr);
-void rb_objspace_set_event_hook(const rb_event_flag_t event);
-VALUE rb_objspace_gc_enable(struct rb_objspace *);
-VALUE rb_objspace_gc_disable(struct rb_objspace *);
-void ruby_gc_set_params(void);
-void rb_copy_wb_protected_attribute(VALUE dest, VALUE obj);
-#if __has_attribute(alloc_align)
-__attribute__((__alloc_align__(1)))
-#endif
-RUBY_ATTR_MALLOC void *rb_aligned_malloc(size_t, size_t) RUBY_ATTR_ALLOC_SIZE((2));
-size_t rb_size_mul_or_raise(size_t, size_t, VALUE); /* used in compile.c */
-size_t rb_size_mul_add_or_raise(size_t, size_t, size_t, VALUE); /* used in iseq.h */
-RUBY_ATTR_MALLOC void *rb_xmalloc_mul_add(size_t, size_t, size_t);
-RUBY_ATTR_MALLOC void *rb_xcalloc_mul_add(size_t, size_t, size_t);
-void *rb_xrealloc_mul_add(const void *, size_t, size_t, size_t);
-RUBY_ATTR_MALLOC void *rb_xmalloc_mul_add_mul(size_t, size_t, size_t, size_t);
-RUBY_ATTR_MALLOC void *rb_xcalloc_mul_add_mul(size_t, size_t, size_t, size_t);
-static inline void *ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
-static inline void *ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
-static inline void ruby_sized_xfree_inlined(void *ptr, size_t size);
-VALUE rb_class_allocate_instance(VALUE klass);
-void rb_gc_ractor_newobj_cache_clear(rb_ractor_newobj_cache_t *newobj_cache);
-size_t rb_gc_obj_slot_size(VALUE obj);
-bool rb_gc_size_allocatable_p(size_t size);
-int rb_objspace_garbage_object_p(VALUE obj);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* gc.c (export) */
-const char *rb_objspace_data_type_name(VALUE obj);
-VALUE rb_wb_protected_newobj_of(VALUE, VALUE, size_t);
-VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE, size_t);
-VALUE rb_ec_wb_protected_newobj_of(struct rb_execution_context_struct *ec, VALUE klass, VALUE flags, size_t);
-size_t rb_obj_memsize_of(VALUE);
-void rb_gc_verify_internal_consistency(void);
-size_t rb_obj_gc_flags(VALUE, ID[], size_t);
-void rb_gc_mark_values(long n, const VALUE *values);
-void rb_gc_mark_vm_stack_values(long n, const VALUE *values);
-void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
-void *ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
-void ruby_sized_xfree(void *x, size_t size);
-RUBY_SYMBOL_EXPORT_END
-
-MJIT_SYMBOL_EXPORT_BEGIN
-int rb_ec_stack_check(struct rb_execution_context_struct *ec);
-void rb_gc_writebarrier_remember(VALUE obj);
-const char *rb_obj_info(VALUE obj);
-MJIT_SYMBOL_EXPORT_END
-
-#if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
-
-static inline void *
-ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size)
-{
-    return ruby_xrealloc(ptr, new_size);
-}
-
-static inline void *
-ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count)
-{
-    return ruby_xrealloc2(ptr, new_count, elemsiz);
-}
-
-static inline void
-ruby_sized_xfree_inlined(void *ptr, size_t size)
-{
-    ruby_xfree(ptr);
-}
-
-# define SIZED_REALLOC_N(x, y, z, w) REALLOC_N(x, y, z)
-
-#else
-
-static inline void *
-ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size)
-{
-    return ruby_sized_xrealloc(ptr, new_size, old_size);
-}
-
-static inline void *
-ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count)
-{
-    return ruby_sized_xrealloc2(ptr, new_count, elemsiz, old_count);
-}
-
-static inline void
-ruby_sized_xfree_inlined(void *ptr, size_t size)
-{
-    ruby_sized_xfree(ptr, size);
-}
-
-# define SIZED_REALLOC_N(v, T, m, n) \
-    ((v) = (T *)ruby_sized_xrealloc2((void *)(v), (m), sizeof(T), (n)))
-
-#endif /* HAVE_MALLOC_USABLE_SIZE */
-
-#define ruby_sized_xrealloc ruby_sized_xrealloc_inlined
-#define ruby_sized_xrealloc2 ruby_sized_xrealloc2_inlined
-#define ruby_sized_xfree ruby_sized_xfree_inlined
-#endif /* INTERNAL_GC_H */