datadog-ruby_core_source 3.4.3 → 3.5.0

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/numeric.h

@@ -1,274 +0,0 @@
-#ifndef INTERNAL_NUMERIC_H                               /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_NUMERIC_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 Numeric.
- */
-#include "internal/bignum.h"    /* for BIGNUM_POSITIVE_P */
-#include "internal/bits.h"      /* for RUBY_BIT_ROTL */
-#include "internal/fixnum.h"    /* for FIXNUM_POSITIVE_P */
-#include "internal/vm.h"        /* for rb_method_basic_definition_p */
-#include "ruby/intern.h"        /* for rb_cmperr */
-#include "ruby/ruby.h"          /* for USE_FLONUM */
-
-#define ROUND_TO(mode, even, up, down) \
-    ((mode) == RUBY_NUM_ROUND_HALF_EVEN ? even : \
-     (mode) == RUBY_NUM_ROUND_HALF_UP ? up : down)
-#define ROUND_FUNC(mode, name) \
-    ROUND_TO(mode, name##_half_even, name##_half_up, name##_half_down)
-#define ROUND_CALL(mode, name, args) \
-    ROUND_TO(mode, name##_half_even args, \
-             name##_half_up args, name##_half_down args)
-
-#ifndef ROUND_DEFAULT
-# define ROUND_DEFAULT RUBY_NUM_ROUND_HALF_UP
-#endif
-
-enum ruby_num_rounding_mode {
-    RUBY_NUM_ROUND_HALF_UP,
-    RUBY_NUM_ROUND_HALF_EVEN,
-    RUBY_NUM_ROUND_HALF_DOWN,
-    RUBY_NUM_ROUND_DEFAULT = ROUND_DEFAULT,
-};
-
-/* same as internal.h */
-#define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
-#define roomof(x, y) (((x) + (y) - 1) / (y))
-#define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
-
-#if SIZEOF_DOUBLE <= SIZEOF_VALUE
-typedef double rb_float_value_type;
-#else
-typedef struct {
-    VALUE values[roomof(SIZEOF_DOUBLE, SIZEOF_VALUE)];
-} rb_float_value_type;
-#endif
-
-struct RFloat {
-    struct RBasic basic;
-    rb_float_value_type float_value;
-};
-
-#define RFLOAT(obj)  ((struct RFloat *)(obj))
-
-/* numeric.c */
-int rb_num_to_uint(VALUE val, unsigned int *ret);
-VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
-double ruby_float_step_size(double beg, double end, double unit, int excl);
-int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl, int allow_endless);
-int rb_num_negative_p(VALUE);
-VALUE rb_int_succ(VALUE num);
-VALUE rb_float_uminus(VALUE num);
-VALUE rb_int_plus(VALUE x, VALUE y);
-VALUE rb_float_plus(VALUE x, VALUE y);
-VALUE rb_int_minus(VALUE x, VALUE y);
-VALUE rb_float_minus(VALUE x, VALUE y);
-VALUE rb_int_mul(VALUE x, VALUE y);
-VALUE rb_float_mul(VALUE x, VALUE y);
-VALUE rb_float_div(VALUE x, VALUE y);
-VALUE rb_int_idiv(VALUE x, VALUE y);
-VALUE rb_int_modulo(VALUE x, VALUE y);
-VALUE rb_int2str(VALUE num, int base);
-VALUE rb_fix_plus(VALUE x, VALUE y);
-VALUE rb_int_gt(VALUE x, VALUE y);
-VALUE rb_float_gt(VALUE x, VALUE y);
-VALUE rb_int_ge(VALUE x, VALUE y);
-enum ruby_num_rounding_mode rb_num_get_rounding_option(VALUE opts);
-double rb_int_fdiv_double(VALUE x, VALUE y);
-VALUE rb_int_pow(VALUE x, VALUE y);
-VALUE rb_float_pow(VALUE x, VALUE y);
-VALUE rb_int_cmp(VALUE x, VALUE y);
-VALUE rb_int_equal(VALUE x, VALUE y);
-VALUE rb_int_divmod(VALUE x, VALUE y);
-VALUE rb_int_and(VALUE x, VALUE y);
-VALUE rb_int_lshift(VALUE x, VALUE y);
-VALUE rb_int_rshift(VALUE x, VALUE y);
-VALUE rb_int_div(VALUE x, VALUE y);
-int rb_int_positive_p(VALUE num);
-int rb_int_negative_p(VALUE num);
-VALUE rb_check_integer_type(VALUE);
-VALUE rb_num_pow(VALUE x, VALUE y);
-VALUE rb_float_ceil(VALUE num, int ndigits);
-VALUE rb_float_floor(VALUE x, int ndigits);
-VALUE rb_float_abs(VALUE flt);
-static inline VALUE rb_num_compare_with_zero(VALUE num, ID mid);
-static inline int rb_num_positive_int_p(VALUE num);
-static inline int rb_num_negative_int_p(VALUE num);
-static inline double rb_float_flonum_value(VALUE v);
-static inline double rb_float_noflonum_value(VALUE v);
-static inline double rb_float_value_inline(VALUE v);
-static inline VALUE rb_float_new_inline(double d);
-static inline bool INT_POSITIVE_P(VALUE num);
-static inline bool INT_NEGATIVE_P(VALUE num);
-static inline bool FLOAT_ZERO_P(VALUE num);
-#define rb_float_value rb_float_value_inline
-#define rb_float_new   rb_float_new_inline
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* numeric.c (export) */
-RUBY_SYMBOL_EXPORT_END
-
-VALUE rb_flo_div_flo(VALUE x, VALUE y);
-double ruby_float_mod(double x, double y);
-VALUE rb_float_equal(VALUE x, VALUE y);
-int rb_float_cmp(VALUE x, VALUE y);
-VALUE rb_float_eql(VALUE x, VALUE y);
-VALUE rb_fix_aref(VALUE fix, VALUE idx);
-VALUE rb_int_zero_p(VALUE num);
-VALUE rb_int_even_p(VALUE num);
-VALUE rb_int_odd_p(VALUE num);
-VALUE rb_int_abs(VALUE num);
-VALUE rb_int_bit_length(VALUE num);
-VALUE rb_int_uminus(VALUE num);
-VALUE rb_int_comp(VALUE num);
-
-static inline bool
-INT_POSITIVE_P(VALUE num)
-{
-    if (FIXNUM_P(num)) {
-        return FIXNUM_POSITIVE_P(num);
-    }
-    else {
-        return BIGNUM_POSITIVE_P(num);
-    }
-}
-
-static inline bool
-INT_NEGATIVE_P(VALUE num)
-{
-    if (FIXNUM_P(num)) {
-        return FIXNUM_NEGATIVE_P(num);
-    }
-    else {
-        return BIGNUM_NEGATIVE_P(num);
-    }
-}
-
-static inline bool
-FLOAT_ZERO_P(VALUE num)
-{
-    return RFLOAT_VALUE(num) == 0.0;
-}
-
-static inline VALUE
-rb_num_compare_with_zero(VALUE num, ID mid)
-{
-    VALUE zero = INT2FIX(0);
-    VALUE r = rb_check_funcall(num, mid, 1, &zero);
-    if (RB_UNDEF_P(r)) {
-        rb_cmperr(num, zero);
-    }
-    return r;
-}
-
-static inline int
-rb_num_positive_int_p(VALUE num)
-{
-    const ID mid = '>';
-
-    if (FIXNUM_P(num)) {
-        if (rb_method_basic_definition_p(rb_cInteger, mid))
-            return FIXNUM_POSITIVE_P(num);
-    }
-    else if (RB_TYPE_P(num, T_BIGNUM)) {
-        if (rb_method_basic_definition_p(rb_cInteger, mid))
-            return BIGNUM_POSITIVE_P(num);
-    }
-    return RTEST(rb_num_compare_with_zero(num, mid));
-}
-
-static inline int
-rb_num_negative_int_p(VALUE num)
-{
-    const ID mid = '<';
-
-    if (FIXNUM_P(num)) {
-        if (rb_method_basic_definition_p(rb_cInteger, mid))
-            return FIXNUM_NEGATIVE_P(num);
-    }
-    else if (RB_TYPE_P(num, T_BIGNUM)) {
-        if (rb_method_basic_definition_p(rb_cInteger, mid))
-            return BIGNUM_NEGATIVE_P(num);
-    }
-    return RTEST(rb_num_compare_with_zero(num, mid));
-}
-
-static inline double
-rb_float_flonum_value(VALUE v)
-{
-#if USE_FLONUM
-    if (v != (VALUE)0x8000000000000002) { /* LIKELY */
-        union {
-            double d;
-            VALUE v;
-        } t;
-
-        VALUE b63 = (v >> 63);
-        /* e: xx1... -> 011... */
-        /*    xx0... -> 100... */
-        /*      ^b63           */
-        t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~(VALUE)0x03), 3);
-        return t.d;
-    }
-#endif
-    return 0.0;
-}
-
-static inline double
-rb_float_noflonum_value(VALUE v)
-{
-#if SIZEOF_DOUBLE <= SIZEOF_VALUE
-    return RFLOAT(v)->float_value;
-#else
-    union {
-        rb_float_value_type v;
-        double d;
-    } u = {RFLOAT(v)->float_value};
-    return u.d;
-#endif
-}
-
-static inline double
-rb_float_value_inline(VALUE v)
-{
-    if (FLONUM_P(v)) {
-        return rb_float_flonum_value(v);
-    }
-    return rb_float_noflonum_value(v);
-}
-
-static inline VALUE
-rb_float_new_inline(double d)
-{
-#if USE_FLONUM
-    union {
-        double d;
-        VALUE v;
-    } t;
-    int bits;
-
-    t.d = d;
-    bits = (int)((VALUE)(t.v >> 60) & 0x7);
-    /* bits contains 3 bits of b62..b60. */
-    /* bits - 3 = */
-    /*   b011 -> b000 */
-    /*   b100 -> b001 */
-
-    if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
-        !((bits-3) & ~0x01)) {
-        return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
-    }
-    else if (t.v == (VALUE)0) {
-        /* +0.0 */
-        return 0x8000000000000002;
-    }
-    /* out of range */
-#endif
-    return rb_float_new_in_heap(d);
-}
-
-#endif /* INTERNAL_NUMERIC_H */

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/object.h

@@ -1,63 +0,0 @@
-#ifndef INTERNAL_OBJECT_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_OBJECT_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 Object.
- */
-#include "ruby/ruby.h"          /* for VALUE */
-
-/* object.c */
-size_t rb_obj_embedded_size(uint32_t numiv);
-VALUE rb_class_allocate_instance(VALUE klass);
-VALUE rb_class_search_ancestor(VALUE klass, VALUE super);
-NORETURN(void rb_undefined_alloc(VALUE klass));
-double rb_num_to_dbl(VALUE val);
-VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound);
-VALUE rb_obj_clone_setup(VALUE obj, VALUE clone, VALUE kwfreeze);
-VALUE rb_obj_dup_setup(VALUE obj, VALUE dup);
-VALUE rb_immutable_obj_clone(int, VALUE *, VALUE);
-VALUE rb_check_convert_type_with_id(VALUE,int,const char*,ID);
-int rb_bool_expected(VALUE, const char *, int raise);
-static inline void RBASIC_CLEAR_CLASS(VALUE obj);
-static inline void RBASIC_SET_CLASS_RAW(VALUE obj, VALUE klass);
-static inline void RBASIC_SET_CLASS(VALUE obj, VALUE klass);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* object.c (export) */
-int rb_opts_exception_p(VALUE opts, int default_value);
-RUBY_SYMBOL_EXPORT_END
-
-CONSTFUNC(VALUE rb_obj_equal(VALUE obj1, VALUE obj2));
-CONSTFUNC(VALUE rb_obj_not(VALUE obj));
-VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2);
-void rb_obj_copy_ivar(VALUE dest, VALUE obj);
-VALUE rb_false(VALUE obj);
-VALUE rb_convert_type_with_id(VALUE v, int t, const char* nam, ID mid);
-VALUE rb_obj_size(VALUE self, VALUE args, VALUE obj);
-VALUE rb_get_freeze_opt(int argc, VALUE *argv);
-
-static inline void
-RBASIC_SET_CLASS_RAW(VALUE obj, VALUE klass)
-{
-    const VALUE *ptr = &RBASIC(obj)->klass;
-    *(VALUE *)ptr = klass;
-}
-
-static inline void
-RBASIC_CLEAR_CLASS(VALUE obj)
-{
-    RBASIC_SET_CLASS_RAW(obj, 0);
-}
-
-static inline void
-RBASIC_SET_CLASS(VALUE obj, VALUE klass)
-{
-    VALUE oldv = RBASIC_CLASS(obj);
-    RBASIC_SET_CLASS_RAW(obj, klass);
-    RB_OBJ_WRITTEN(obj, oldv, klass);
-}
-#endif /* INTERNAL_OBJECT_H */

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/re.h

@@ -1,28 +0,0 @@
-#ifndef INTERNAL_RE_H                                    /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_RE_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 Regexp.
- */
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/ruby.h"          /* for VALUE */
-
-/* re.c */
-VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
-VALUE rb_reg_check_preprocess(VALUE);
-long rb_reg_search0(VALUE, VALUE, long, int, int, VALUE *);
-VALUE rb_reg_match_p(VALUE re, VALUE str, long pos);
-bool rb_reg_start_with_p(VALUE re, VALUE str);
-VALUE rb_reg_hash(VALUE re);
-VALUE rb_reg_equal(VALUE re1, VALUE re2);
-VALUE rb_backref_set_string(VALUE string, long pos, long len);
-void rb_match_unbusy(VALUE);
-int rb_match_count(VALUE match);
-VALUE rb_reg_new_ary(VALUE ary, int options);
-VALUE rb_reg_last_defined(VALUE match);
-
-#endif /* INTERNAL_RE_H */

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/sanitizers.h

@@ -1,330 +0,0 @@
-#ifndef INTERNAL_SANITIZERS_H                            /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_SANITIZERS_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 ASAN / MSAN / etc.
- */
-#include "ruby/internal/config.h"
-#include "internal/compilers.h" /* for __has_feature */
-
-#ifdef HAVE_VALGRIND_MEMCHECK_H
-# include <valgrind/memcheck.h>
-#endif
-
-#ifdef HAVE_SANITIZER_ASAN_INTERFACE_H
-# if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
-#  define RUBY_ASAN_ENABLED
-#  include <sanitizer/asan_interface.h>
-# endif
-#endif
-
-#ifdef HAVE_SANITIZER_MSAN_INTERFACE_H
-# if __has_feature(memory_sanitizer)
-#  define RUBY_MSAN_ENABLED
-#  include <sanitizer/msan_interface.h>
-# endif
-#endif
-
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/ruby.h"          /* for VALUE */
-
-#if 0
-#elif defined(RUBY_ASAN_ENABLED) && defined(RUBY_MSAN_ENABLED)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("memory, address"), __noinline__)) x
-#elif defined(RUBY_ASAN_ENABLED)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("address"), __noinline__)) x
-#elif defined(RUBY_MSAN_ENABLED)
-    # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("memory"), __noinline__)) x
-#elif defined(NO_SANITIZE_ADDRESS)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    NO_SANITIZE_ADDRESS(NOINLINE(x))
-#elif defined(NO_ADDRESS_SAFETY_ANALYSIS)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    NO_ADDRESS_SAFETY_ANALYSIS(NOINLINE(x))
-#else
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) x
-#endif
-
-#if defined(NO_SANITIZE) && RBIMPL_COMPILER_IS(GCC)
-/* GCC warns about unknown sanitizer, which is annoying. */
-# include "internal/warnings.h"
-# undef NO_SANITIZE
-# define NO_SANITIZE(x, y) \
-    COMPILER_WARNING_PUSH \
-    COMPILER_WARNING_IGNORED(-Wattributes) \
-    __attribute__((__no_sanitize__(x))) y; \
-    COMPILER_WARNING_POP \
-    y
-#endif
-
-#ifndef NO_SANITIZE
-# define NO_SANITIZE(x, y) y
-#endif
-
-#ifndef RUBY_ASAN_ENABLED
-# define __asan_poison_memory_region(x, y)
-# define __asan_unpoison_memory_region(x, y)
-# define __asan_region_is_poisoned(x, y) 0
-# define __asan_get_current_fake_stack() NULL
-# define __asan_addr_is_in_fake_stack(fake_stack, slot, start, end) NULL
-#endif
-
-#ifndef RUBY_MSAN_ENABLED
-# define __msan_allocated_memory(x, y) ((void)(x), (void)(y))
-# define __msan_poison(x, y) ((void)(x), (void)(y))
-# define __msan_unpoison(x, y) ((void)(x), (void)(y))
-# define __msan_unpoison_string(x) ((void)(x))
-#endif
-
-#ifdef VALGRIND_MAKE_READABLE
-# define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
-#endif
-
-#ifdef VALGRIND_MAKE_WRITABLE
-# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
-#endif
-
-#ifndef VALGRIND_MAKE_MEM_DEFINED
-# define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
-#endif
-
-#ifndef VALGRIND_MAKE_MEM_UNDEFINED
-# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
-#endif
-
-/**
- * This function asserts that a (continuous) memory region from ptr to size
- * being "poisoned".  Both read / write access to such memory region are
- * prohibited until properly unpoisoned.  The region must be previously
- * allocated (do not pass a freed pointer here), but not necessarily be an
- * entire object that the malloc returns.  You can punch hole a part of a
- * gigantic heap arena.  This is handy when you do not free an allocated memory
- * region to reuse later: poison when you keep it unused, and unpoison when you
- * reuse.
- *
- * @param[in]  ptr   pointer to the beginning of the memory region to poison.
- * @param[in]  size  the length of the memory region to poison.
- */
-static inline void
-asan_poison_memory_region(const volatile void *ptr, size_t size)
-{
-    __msan_poison(ptr, size);
-    __asan_poison_memory_region(ptr, size);
-}
-
-#ifdef RUBY_ASAN_ENABLED
-#define asan_poison_object_if(ptr, obj) do { \
-        if (ptr) rb_asan_poison_object(obj); \
-    } while (0)
-#else
-#define asan_poison_object_if(ptr, obj) ((void)(ptr), (void)(obj))
-#endif
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/**
- * This is a variant of asan_poison_memory_region that takes a VALUE.
- *
- * @param[in]  obj   target object.
- */
-void rb_asan_poison_object(VALUE obj);
-
-/**
- * This function predicates if the given object is fully addressable or not.
- *
- * @param[in]  obj        target object.
- * @retval     0          the given object is fully addressable.
- * @retval     otherwise  pointer to first such byte who is poisoned.
- */
-void *rb_asan_poisoned_object_p(VALUE obj);
-
-/**
- * This is a variant of asan_unpoison_memory_region that takes a VALUE.
- *
- * @param[in]  obj       target object.
- * @param[in]  malloc_p  if the memory region is like a malloc's return value or not.
- */
-void rb_asan_unpoison_object(VALUE obj, bool newobj_p);
-
-RUBY_SYMBOL_EXPORT_END
-
-/**
- * This function asserts that a (formally poisoned) memory region from ptr to
- * size is now addressable.  Write access to such memory region gets allowed.
- * However read access might or might not be possible depending on situations,
- * because the region can have contents of previous usages.  That information
- * should be passed by the malloc_p flag.  If that is true, the contents of the
- * region is _not_ fully defined (like the return value of malloc behaves).
- * Reading from there is NG; write something first.  If malloc_p is false on
- * the other hand, that memory region is fully defined and can be read
- * immediately.
- *
- * @param[in]  ptr       pointer to the beginning of the memory region to unpoison.
- * @param[in]  size      the length of the memory region.
- * @param[in]  malloc_p  if the memory region is like a malloc's return value or not.
- */
-static inline void
-asan_unpoison_memory_region(const volatile void *ptr, size_t size, bool malloc_p)
-{
-    __asan_unpoison_memory_region(ptr, size);
-    if (malloc_p) {
-        __msan_allocated_memory(ptr, size);
-    }
-    else {
-        __msan_unpoison(ptr, size);
-    }
-}
-
-static inline void *
-asan_unpoison_object_temporary(VALUE obj)
-{
-    void *ptr = rb_asan_poisoned_object_p(obj);
-    rb_asan_unpoison_object(obj, false);
-    return ptr;
-}
-
-static inline void *
-asan_poison_object_restore(VALUE obj, void *ptr)
-{
-    if (ptr) {
-        rb_asan_poison_object(obj);
-    }
-    return NULL;
-}
-
-#define asan_unpoisoning_object(obj) \
-    for (void *poisoned = asan_unpoison_object_temporary(obj), \
-              *unpoisoning = &poisoned; /* flag to loop just once */ \
-         unpoisoning; \
-         unpoisoning = asan_poison_object_restore(obj, poisoned))
-
-
-static inline void *
-asan_unpoison_memory_region_temporary(void *ptr, size_t len)
-{
-    void *poisoned_ptr = __asan_region_is_poisoned(ptr, len);
-    asan_unpoison_memory_region(ptr, len, false);
-    return poisoned_ptr;
-}
-
-static inline void *
-asan_poison_memory_region_restore(void *ptr, size_t len, void *poisoned_ptr)
-{
-    if (poisoned_ptr) {
-        asan_poison_memory_region(ptr, len);
-    }
-    return NULL;
-}
-
-#define asan_unpoisoning_memory_region(ptr, len) \
-    for (void *poisoned = asan_unpoison_memory_region_temporary(ptr, len), \
-              *unpoisoning = &poisoned; /* flag to loop just once */ \
-         unpoisoning; \
-         unpoisoning = asan_poison_memory_region_restore(ptr, len, poisoned))
-
-/**
- * Checks if the given pointer is on an ASAN fake stack. If so, it returns the
- * address this variable has on the real frame; if not, it returns the origin
- * address unmodified.
- *
- * n.b. - _dereferencing_ the returned address is meaningless and should not
- * be done; even though ASAN reserves space for the variable in both the real and
- * fake stacks, the _value_ of that variable is only in the fake stack.
- *
- * n.b. - this only works for addresses passed in from local variables on the same
- * thread, because the ASAN fake stacks are threadlocal.
- *
- * @param[in] slot  the address of some local variable
- * @retval          a pointer to something from that frame on the _real_ machine stack
- */
-static inline void *
-asan_get_real_stack_addr(void* slot)
-{
-    VALUE *addr;
-    addr = __asan_addr_is_in_fake_stack(__asan_get_current_fake_stack(), slot, NULL, NULL);
-    return addr ? addr : slot;
-}
-
-/**
- * Gets the current thread's fake stack handle, which can be passed into get_fake_stack_extents
- *
- * @retval An opaque value which can be passed to asan_get_fake_stack_extents
- */
-static inline void *
-asan_get_thread_fake_stack_handle(void)
-{
-    return __asan_get_current_fake_stack();
-}
-
-/**
- * Checks if the given VALUE _actually_ represents a pointer to an ASAN fake stack.
- *
- * If the given slot _is_ actually a reference to an ASAN fake stack, and that fake stack
- * contains the real values for the passed-in range of machine stack addresses, returns true
- * and the range of the fake stack through the outparams.
- *
- * Otherwise, returns false, and sets the outparams to NULL.
- *
- * Note that this function expects "start" to be > "end" on downward-growing stack architectures;
- *
- * @param[in]  thread_fake_stack_handle  The asan fake stack reference for the thread we're scanning
- * @param[in]  slot                      The value on the machine stack we want to inspect
- * @param[in]  machine_stack_start       The extents of the real machine stack on which slot lives
- * @param[in]  machine_stack_end         The extents of the real machine stack on which slot lives
- * @param[out] fake_stack_start_out      The extents of the fake stack which contains real VALUEs
- * @param[out] fake_stack_end_out        The extents of the fake stack which contains real VALUEs
- * @return                               Whether slot is a pointer to a fake stack for the given machine stack range
-*/
-
-static inline bool
-asan_get_fake_stack_extents(void *thread_fake_stack_handle, VALUE slot,
-                            void *machine_stack_start, void *machine_stack_end,
-                            void **fake_stack_start_out, void **fake_stack_end_out)
-{
-    /* the ifdef is needed here to suppress a warning about fake_frame_{start/end} being
-       uninitialized if __asan_addr_is_in_fake_stack is an empty macro */
-#ifdef RUBY_ASAN_ENABLED
-    void *fake_frame_start;
-    void *fake_frame_end;
-    void *real_stack_frame = __asan_addr_is_in_fake_stack(
-        thread_fake_stack_handle, (void *)slot, &fake_frame_start, &fake_frame_end
-    );
-    if (real_stack_frame) {
-        bool in_range;
-#if STACK_GROW_DIRECTION < 0
-        in_range = machine_stack_start >= real_stack_frame && real_stack_frame >= machine_stack_end;
-#else
-        in_range = machine_stack_start <= real_stack_frame && real_stack_frame <= machine_stack_end;
-#endif
-        if (in_range) {
-            *fake_stack_start_out = fake_frame_start;
-            *fake_stack_end_out = fake_frame_end;
-            return true;
-        }
-    }
-#endif
-    *fake_stack_start_out = 0;
-    *fake_stack_end_out = 0;
-    return false;
-}
-
-extern const char ruby_asan_default_options[];
-
-#ifdef RUBY_ASAN_ENABLED
-/* Compile in the ASAN options Ruby needs, rather than relying on environment variables, so
- * that even tests which fork ruby with a clean environment will run ASAN with the right
- * settings */
-# undef RUBY__ASAN_DEFAULT_OPTIONS
-# define RUBY__ASAN_DEFAULT_OPTIONS \
-    RBIMPL_SYMBOL_EXPORT_BEGIN() \
-    const char * __asan_default_options(void) {return ruby_asan_default_options;} \
-    RBIMPL_SYMBOL_EXPORT_END()
-#endif
-
-#endif /* INTERNAL_SANITIZERS_H */