23#include "ruby/internal/config.h"
41#if defined(_MSC_VER) && defined(_WIN64)
43# pragma intrinsic(_umul128)
54#include "ruby/internal/cast.h"
60#include "ruby/backward/2/limits.h"
70#elif RBIMPL_HAS_BUILTIN(__builtin_alloca)
71# define alloca __builtin_alloca
74#elif defined(__cplusplus)
75extern "C" void *alloca(
size_t);
82#if defined(__DOXYGEN__)
90typedef uint128_t DSIZE_T;
91#elif defined(HAVE_INT128_T) && SIZEOF_SIZE_T <= 8
92# define DSIZE_T uint128_t
93#elif SIZEOF_SIZE_T * 2 <= SIZEOF_LONG_LONG
94# define DSIZE_T unsigned LONG_LONG
105# define RUBY_ALLOCV_LIMIT 0
107# define RUBY_ALLOCV_LIMIT 1024
161#define RB_GC_GUARD(v) \
163 volatile VALUE *rb_gc_guarded_ptr = &(v); \
164 __asm__("" : : "m"(rb_gc_guarded_ptr)); \
167#elif defined _MSC_VER
168#define RB_GC_GUARD(v) (*rb_gc_guarded_ptr(&(v)))
170#define HAVE_RB_GC_GUARDED_PTR_VAL 1
171#define RB_GC_GUARD(v) (*rb_gc_guarded_ptr_val(&(v),(v)))
193#define RB_ALLOC_N(type,n) RBIMPL_CAST((type *)ruby_xmalloc2((n), sizeof(type)))
207#define RB_ALLOC(type) RBIMPL_CAST((type *)ruby_xmalloc(sizeof(type)))
228#define RB_ZALLOC_N(type,n) RBIMPL_CAST((type *)ruby_xcalloc((n), sizeof(type)))
243#define RB_ZALLOC(type) (RB_ZALLOC_N(type, 1))
276#define RB_REALLOC_N(var,type,n) \
277 ((var) = RBIMPL_CAST((type *)ruby_xrealloc2((void *)(var), (n), sizeof(type))))
286#define ALLOCA_N(type,n) \
287 RBIMPL_CAST((type *)alloca(rbimpl_size_mul_or_raise(sizeof(type), (n))))
298#define RB_ALLOCV(v, n) \
299 ((n) < RUBY_ALLOCV_LIMIT ? \
300 ((v) = 0, alloca(n)) : \
301 rb_alloc_tmp_buffer(&(v), (n)))
330#define RB_ALLOCV_N(type, v, n) \
331 RBIMPL_CAST((type *) \
332 (((size_t)(n) < RUBY_ALLOCV_LIMIT / sizeof(type)) ? \
333 ((v) = 0, alloca((n) * sizeof(type))) : \
334 rb_alloc_tmp_buffer2(&(v), (n), sizeof(type))))
343#define RB_ALLOCV_END(v) rb_free_tmp_buffer(&(v))
354#define MEMZERO(p,type,n) memset((p), 0, rbimpl_size_mul_or_raise(sizeof(type), (n)))
366#define MEMCPY(p1,p2,type,n) ruby_nonempty_memcpy((p1), (p2), rbimpl_size_mul_or_raise(sizeof(type), (n)))
378#define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), rbimpl_size_mul_or_raise(sizeof(type), (n)))
391#define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), rbimpl_size_mul_or_raise(sizeof(type), (n)))
393#define ALLOC_N RB_ALLOC_N
394#define ALLOC RB_ALLOC
395#define ZALLOC_N RB_ZALLOC_N
396#define ZALLOC RB_ZALLOC
397#define REALLOC_N RB_REALLOC_N
398#define ALLOCV RB_ALLOCV
399#define ALLOCV_N RB_ALLOCV_N
400#define ALLOCV_END RB_ALLOCV_END
413struct rbimpl_size_mul_overflow_tag {
434void *rb_alloc_tmp_buffer(volatile
VALUE *store,
long len);
457void *rb_alloc_tmp_buffer_with_count(volatile
VALUE *store,
size_t len,
size_t count);
470void rb_free_tmp_buffer(volatile
VALUE *store);
483void ruby_malloc_size_overflow(
size_t x,
size_t y);
485#ifdef HAVE_RB_GC_GUARDED_PTR_VAL
491# pragma optimize("", off)
502static inline volatile VALUE *
503rb_gc_guarded_ptr(
volatile VALUE *ptr)
508# pragma optimize("", on)
532 if (c2 > max)
return 1;
533 *c = RBIMPL_CAST((
size_t)c2);
535 if (b != 0 && a > max / b)
return 1;
541#if defined(__DOXYGEN__)
543#elif RBIMPL_COMPILER_SINCE(GCC, 7, 0, 0)
545#elif RBIMPL_COMPILER_SINCE(Clang, 7, 0, 0)
565static inline struct rbimpl_size_mul_overflow_tag
566rbimpl_size_mul_overflow(
size_t x,
size_t y)
568 struct rbimpl_size_mul_overflow_tag ret = {
false, 0, };
570#if RBIMPL_HAS_BUILTIN(__builtin_mul_overflow)
571 ret.left = __builtin_mul_overflow(x, y, &ret.right);
573#elif defined(DSIZE_T)
577 ret.left = dz > SIZE_MAX;
578 ret.right = RBIMPL_CAST((
size_t)dz);
580#elif defined(_MSC_VER) && defined(_WIN64)
581 unsigned __int64 dp = 0;
582 unsigned __int64 dz = _umul128(x, y, &dp);
583 ret.left = RBIMPL_CAST((
bool)dp);
584 ret.right = RBIMPL_CAST((
size_t)dz);
588 ret.left = (y != 0) && (x > SIZE_MAX / y);
611rbimpl_size_mul_or_raise(
size_t x,
size_t y)
613 struct rbimpl_size_mul_overflow_tag size =
614 rbimpl_size_mul_overflow(x, y);
616 if (RB_LIKELY(! size.left)) {
620 ruby_malloc_size_overflow(x, y);
642 const size_t total_size = rbimpl_size_mul_or_raise(count, elsize);
643 const size_t cnt = (total_size +
sizeof(
VALUE) - 1) /
sizeof(
VALUE);
644 return rb_alloc_tmp_buffer_with_count(store, total_size, cnt);
655ruby_nonempty_memcpy(
void *dest, const
void *src,
size_t n)
658 return memcpy(dest, src, n);
Defines RBIMPL_ATTR_ALLOC_SIZE.
#define RBIMPL_ATTR_ALLOC_SIZE(tuple)
Wraps (or simulates) __attribute__((alloc_size))
Defines ASSUME / RB_LIKELY / UNREACHABLE.
Defines RBIMPL_ATTR_CONST.
#define RBIMPL_ATTR_CONST()
Wraps (or simulates) __attribute__((const))
#define RBIMPL_ATTR_CONSTEXPR(_)
Wraps (or simulates) C++11 constexpr.
#define RB_GNUC_EXTENSION
This is expanded to nothing for non-GCC compilers.
Tweaking visibility of C variables/functions.
#define RBIMPL_SYMBOL_EXPORT_END()
Counterpart of RBIMPL_SYMBOL_EXPORT_BEGIN.
#define RBIMPL_SYMBOL_EXPORT_BEGIN()
Shortcut macro equivalent to RUBY_SYMBOL_EXPORT_BEGIN extern "C" {.
Defines RBIMPL_HAS_BUILTIN.
#define RBIMPL_UNREACHABLE_RETURN(_)
Wraps (or simulates) __builtin_unreachable.
Defines RBIMPL_ALIGNAS / RBIMPL_ALIGNOF.
static void * rb_alloc_tmp_buffer2(volatile VALUE *store, long count, size_t elsize)
This is an implementation detail of RB_ALLOCV_N().
static int rb_mul_size_overflow(size_t a, size_t b, size_t max, size_t *c)
Defines RBIMPL_ATTR_NOALIAS.
#define RBIMPL_ATTR_NOALIAS()
Wraps (or simulates) __declspec((noalias))
Defines RBIMPL_ATTR_NONNULL.
#define RBIMPL_ATTR_NONNULL(list)
Wraps (or simulates) __attribute__((nonnull))
Defines RBIMPL_ATTR_NORETURN.
#define RBIMPL_ATTR_NORETURN()
Wraps (or simulates) [[noreturn]]
Defines RBIMPL_ATTR_RESTRICT.
#define RBIMPL_ATTR_RESTRICT()
Wraps (or simulates) __declspec(restrict)
Defines RBIMPL_ATTR_RETURNS_NONNULL.
#define RBIMPL_ATTR_RETURNS_NONNULL()
Wraps (or simulates) __attribute__((returns_nonnull))
uintptr_t VALUE
Type that represents a Ruby object.