Ruby 2.7.7p221 (2022-11-24 revision 168ec2b1e5ad0e4688e963d9de019557c78feed9)
internal.h
Go to the documentation of this file.
1/**********************************************************************
2
3 internal.h -
4
5 $Author$
6 created at: Tue May 17 11:42:20 JST 2011
7
8 Copyright (C) 2011 Yukihiro Matsumoto
9
10**********************************************************************/
11
12#ifndef RUBY_INTERNAL_H
13#define RUBY_INTERNAL_H 1
14
15#include "ruby.h"
16
17#if defined(__cplusplus)
18extern "C" {
19#if 0
20} /* satisfy cc-mode */
21#endif
22#endif
23
24#ifdef HAVE_STDBOOL_H
25# include <stdbool.h>
26#else
27# include "missing/stdbool.h"
28#endif
29
30/* The most significant bit of the lower part of half-long integer.
31 * If sizeof(long) == 4, this is 0x8000.
32 * If sizeof(long) == 8, this is 0x80000000.
33 */
34#define HALF_LONG_MSB ((SIGNED_VALUE)1<<((SIZEOF_LONG*CHAR_BIT-1)/2))
35
36#define LIKELY(x) RB_LIKELY(x)
37#define UNLIKELY(x) RB_UNLIKELY(x)
38
39#ifndef MAYBE_UNUSED
40# define MAYBE_UNUSED(x) x
41#endif
42
43#ifndef WARN_UNUSED_RESULT
44# define WARN_UNUSED_RESULT(x) x
45#endif
46
47#ifndef __has_feature
48# define __has_feature(x) 0
49#endif
50
51#ifndef __has_extension
52# define __has_extension __has_feature
53#endif
54
55#if 0
56#elif defined(NO_SANITIZE) && __has_feature(memory_sanitizer)
57# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
58 NO_SANITIZE("memory", NO_SANITIZE("address", NOINLINE(x)))
59#elif defined(NO_SANITIZE)
60# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
61 NO_SANITIZE("address", NOINLINE(x))
62#elif defined(NO_SANITIZE_ADDRESS)
63# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
64 NO_SANITIZE_ADDRESS(NOINLINE(x))
65#elif defined(NO_ADDRESS_SAFETY_ANALYSIS)
66# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
67 NO_ADDRESS_SAFETY_ANALYSIS(NOINLINE(x))
68#else
69# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) x
70#endif
71
72#if defined(NO_SANITIZE) && defined(__GNUC__) &&! defined(__clang__)
73/* GCC warns about unknown sanitizer, which is annoying. */
74#undef NO_SANITIZE
75#define NO_SANITIZE(x, y) \
76 COMPILER_WARNING_PUSH; \
77 COMPILER_WARNING_IGNORED(-Wattributes); \
78 __attribute__((__no_sanitize__(x))) y; \
79 COMPILER_WARNING_POP
80#endif
81
82#ifndef NO_SANITIZE
83# define NO_SANITIZE(x, y) y
84#endif
85
86#ifdef HAVE_VALGRIND_MEMCHECK_H
87# include <valgrind/memcheck.h>
88# ifndef VALGRIND_MAKE_MEM_DEFINED
89# define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
90# endif
91# ifndef VALGRIND_MAKE_MEM_UNDEFINED
92# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
93# endif
94#else
95# define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
96# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
97#endif
98
99#define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
100
101#ifndef MJIT_HEADER
102
103#ifdef HAVE_SANITIZER_ASAN_INTERFACE_H
104# include <sanitizer/asan_interface.h>
105#endif
106
107#if !__has_feature(address_sanitizer)
108# define __asan_poison_memory_region(x, y)
109# define __asan_unpoison_memory_region(x, y)
110# define __asan_region_is_poisoned(x, y) 0
111#endif
112
113#ifdef HAVE_SANITIZER_MSAN_INTERFACE_H
114# if __has_feature(memory_sanitizer)
115# include <sanitizer/msan_interface.h>
116# endif
117#endif
118
119#if !__has_feature(memory_sanitizer)
120# define __msan_allocated_memory(x, y) ((void)(x), (void)(y))
121# define __msan_poison(x, y) ((void)(x), (void)(y))
122# define __msan_unpoison(x, y) ((void)(x), (void)(y))
123# define __msan_unpoison_string(x) ((void)(x))
124#endif
125
139static inline void
140asan_poison_memory_region(const volatile void *ptr, size_t size)
141{
144}
145
151static inline void
152asan_poison_object(VALUE obj)
153{
154 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
155 asan_poison_memory_region(ptr, SIZEOF_VALUE);
156}
157
158#if !__has_feature(address_sanitizer)
159#define asan_poison_object_if(ptr, obj) ((void)(ptr), (void)(obj))
160#else
161#define asan_poison_object_if(ptr, obj) do { \
162 if (ptr) asan_poison_object(obj); \
163 } while (0)
164#endif
165
173static inline void *
174asan_poisoned_object_p(VALUE obj)
175{
176 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
178}
179
195static inline void
196asan_unpoison_memory_region(const volatile void *ptr, size_t size, bool malloc_p)
197{
199 if (malloc_p) {
201 }
202 else {
204 }
205}
206
213static inline void
214asan_unpoison_object(VALUE obj, bool newobj_p)
215{
216 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
217 asan_unpoison_memory_region(ptr, SIZEOF_VALUE, newobj_p);
218}
219
220#endif
221
222/* Prevent compiler from reordering access */
223#define ACCESS_ONCE(type,x) (*((volatile type *)&(x)))
224
225#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
226# define STATIC_ASSERT(name, expr) _Static_assert(expr, #name ": " #expr)
227#elif GCC_VERSION_SINCE(4, 6, 0) || __has_extension(c_static_assert)
228# define STATIC_ASSERT(name, expr) RB_GNUC_EXTENSION _Static_assert(expr, #name ": " #expr)
229#else
230# define STATIC_ASSERT(name, expr) typedef int static_assert_##name##_check[1 - 2*!(expr)]
231#endif
232
233#define SIGNED_INTEGER_TYPE_P(int_type) (0 > ((int_type)0)-1)
234#define SIGNED_INTEGER_MAX(sint_type) \
235 (sint_type) \
236 ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) | \
237 ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) - 1))
238#define SIGNED_INTEGER_MIN(sint_type) (-SIGNED_INTEGER_MAX(sint_type)-1)
239#define UNSIGNED_INTEGER_MAX(uint_type) (~(uint_type)0)
240
241#if SIGNEDNESS_OF_TIME_T < 0 /* signed */
242# define TIMET_MAX SIGNED_INTEGER_MAX(time_t)
243# define TIMET_MIN SIGNED_INTEGER_MIN(time_t)
244#elif SIGNEDNESS_OF_TIME_T > 0 /* unsigned */
245# define TIMET_MAX UNSIGNED_INTEGER_MAX(time_t)
246# define TIMET_MIN ((time_t)0)
247#endif
248#define TIMET_MAX_PLUS_ONE (2*(double)(TIMET_MAX/2+1))
249
250#ifdef HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW_P
251#define MUL_OVERFLOW_P(a, b) \
252 __builtin_mul_overflow_p((a), (b), (__typeof__(a * b))0)
253#elif defined HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW
254#define MUL_OVERFLOW_P(a, b) \
255 ({__typeof__(a) c; __builtin_mul_overflow((a), (b), &c);})
256#endif
257
258#define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
259 (a) == 0 ? 0 : \
260 (a) == -1 ? (b) < -(max) : \
261 (a) > 0 ? \
262 ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \
263 ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
264
265#ifdef HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW_P
266/* __builtin_mul_overflow_p can take bitfield */
267/* and GCC permits bitfields for integers other than int */
268#define MUL_OVERFLOW_FIXNUM_P(a, b) ({ \
269 struct { long fixnum : SIZEOF_LONG * CHAR_BIT - 1; } c; \
270 __builtin_mul_overflow_p((a), (b), c.fixnum); \
271})
272#else
273#define MUL_OVERFLOW_FIXNUM_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
274#endif
275
276#ifdef MUL_OVERFLOW_P
277#define MUL_OVERFLOW_LONG_LONG_P(a, b) MUL_OVERFLOW_P(a, b)
278#define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_P(a, b)
279#define MUL_OVERFLOW_INT_P(a, b) MUL_OVERFLOW_P(a, b)
280#else
281#define MUL_OVERFLOW_LONG_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LLONG_MIN, LLONG_MAX)
282#define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
283#define MUL_OVERFLOW_INT_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
284#endif
285
286#ifndef swap16
287# ifdef HAVE_BUILTIN___BUILTIN_BSWAP16
288# define swap16(x) __builtin_bswap16(x)
289# endif
290#endif
291
292#ifndef swap16
293# define swap16(x) ((uint16_t)((((x)&0xFF)<<8) | (((x)>>8)&0xFF)))
294#endif
295
296#ifndef swap32
297# ifdef HAVE_BUILTIN___BUILTIN_BSWAP32
298# define swap32(x) __builtin_bswap32(x)
299# endif
300#endif
301
302#ifndef swap32
303# define swap32(x) ((uint32_t)((((x)&0xFF)<<24) \
304 |(((x)>>24)&0xFF) \
305 |(((x)&0x0000FF00)<<8) \
306 |(((x)&0x00FF0000)>>8) ))
307#endif
308
309#ifndef swap64
310# ifdef HAVE_BUILTIN___BUILTIN_BSWAP64
311# define swap64(x) __builtin_bswap64(x)
312# endif
313#endif
314
315#ifndef swap64
316# ifdef HAVE_INT64_T
317# define byte_in_64bit(n) ((uint64_t)0xff << (n))
318# define swap64(x) ((uint64_t)((((x)&byte_in_64bit(0))<<56) \
319 |(((x)>>56)&0xFF) \
320 |(((x)&byte_in_64bit(8))<<40) \
321 |(((x)&byte_in_64bit(48))>>40) \
322 |(((x)&byte_in_64bit(16))<<24) \
323 |(((x)&byte_in_64bit(40))>>24) \
324 |(((x)&byte_in_64bit(24))<<8) \
325 |(((x)&byte_in_64bit(32))>>8)))
326# endif
327#endif
328
329static inline unsigned int
330nlz_int(unsigned int x)
331{
332#if defined(HAVE_BUILTIN___BUILTIN_CLZ)
333 if (x == 0) return SIZEOF_INT * CHAR_BIT;
334 return (unsigned int)__builtin_clz(x);
335#else
336 unsigned int y;
337# if 64 < SIZEOF_INT * CHAR_BIT
338 unsigned int n = 128;
339# elif 32 < SIZEOF_INT * CHAR_BIT
340 unsigned int n = 64;
341# else
342 unsigned int n = 32;
343# endif
344# if 64 < SIZEOF_INT * CHAR_BIT
345 y = x >> 64; if (y) {n -= 64; x = y;}
346# endif
347# if 32 < SIZEOF_INT * CHAR_BIT
348 y = x >> 32; if (y) {n -= 32; x = y;}
349# endif
350 y = x >> 16; if (y) {n -= 16; x = y;}
351 y = x >> 8; if (y) {n -= 8; x = y;}
352 y = x >> 4; if (y) {n -= 4; x = y;}
353 y = x >> 2; if (y) {n -= 2; x = y;}
354 y = x >> 1; if (y) {return n - 2;}
355 return (unsigned int)(n - x);
356#endif
357}
358
359static inline unsigned int
360nlz_long(unsigned long x)
361{
362#if defined(HAVE_BUILTIN___BUILTIN_CLZL)
363 if (x == 0) return SIZEOF_LONG * CHAR_BIT;
364 return (unsigned int)__builtin_clzl(x);
365#else
366 unsigned long y;
367# if 64 < SIZEOF_LONG * CHAR_BIT
368 unsigned int n = 128;
369# elif 32 < SIZEOF_LONG * CHAR_BIT
370 unsigned int n = 64;
371# else
372 unsigned int n = 32;
373# endif
374# if 64 < SIZEOF_LONG * CHAR_BIT
375 y = x >> 64; if (y) {n -= 64; x = y;}
376# endif
377# if 32 < SIZEOF_LONG * CHAR_BIT
378 y = x >> 32; if (y) {n -= 32; x = y;}
379# endif
380 y = x >> 16; if (y) {n -= 16; x = y;}
381 y = x >> 8; if (y) {n -= 8; x = y;}
382 y = x >> 4; if (y) {n -= 4; x = y;}
383 y = x >> 2; if (y) {n -= 2; x = y;}
384 y = x >> 1; if (y) {return n - 2;}
385 return (unsigned int)(n - x);
386#endif
387}
388
389#ifdef HAVE_LONG_LONG
390static inline unsigned int
391nlz_long_long(unsigned LONG_LONG x)
392{
393#if defined(HAVE_BUILTIN___BUILTIN_CLZLL)
394 if (x == 0) return SIZEOF_LONG_LONG * CHAR_BIT;
395 return (unsigned int)__builtin_clzll(x);
396#else
397 unsigned LONG_LONG y;
398# if 64 < SIZEOF_LONG_LONG * CHAR_BIT
399 unsigned int n = 128;
400# elif 32 < SIZEOF_LONG_LONG * CHAR_BIT
401 unsigned int n = 64;
402# else
403 unsigned int n = 32;
404# endif
405# if 64 < SIZEOF_LONG_LONG * CHAR_BIT
406 y = x >> 64; if (y) {n -= 64; x = y;}
407# endif
408# if 32 < SIZEOF_LONG_LONG * CHAR_BIT
409 y = x >> 32; if (y) {n -= 32; x = y;}
410# endif
411 y = x >> 16; if (y) {n -= 16; x = y;}
412 y = x >> 8; if (y) {n -= 8; x = y;}
413 y = x >> 4; if (y) {n -= 4; x = y;}
414 y = x >> 2; if (y) {n -= 2; x = y;}
415 y = x >> 1; if (y) {return n - 2;}
416 return (unsigned int)(n - x);
417#endif
418}
419#endif
420
421#ifdef HAVE_UINT128_T
422static inline unsigned int
423nlz_int128(uint128_t x)
424{
425 uint128_t y;
426 unsigned int n = 128;
427 y = x >> 64; if (y) {n -= 64; x = y;}
428 y = x >> 32; if (y) {n -= 32; x = y;}
429 y = x >> 16; if (y) {n -= 16; x = y;}
430 y = x >> 8; if (y) {n -= 8; x = y;}
431 y = x >> 4; if (y) {n -= 4; x = y;}
432 y = x >> 2; if (y) {n -= 2; x = y;}
433 y = x >> 1; if (y) {return n - 2;}
434 return (unsigned int)(n - x);
435}
436#endif
437
438static inline unsigned int
439nlz_intptr(uintptr_t x)
440{
441#if SIZEOF_UINTPTR_T == SIZEOF_INT
442 return nlz_int(x);
443#elif SIZEOF_UINTPTR_T == SIZEOF_LONG
444 return nlz_long(x);
445#elif SIZEOF_UINTPTR_T == SIZEOF_LONG_LONG
446 return nlz_long_long(x);
447#else
448 #error no known integer type corresponds uintptr_t
449 return /* sane compiler */ ~0;
450#endif
451}
452
453static inline unsigned int
454rb_popcount32(uint32_t x)
455{
456#ifdef HAVE_BUILTIN___BUILTIN_POPCOUNT
457 return (unsigned int)__builtin_popcount(x);
458#else
459 x = (x & 0x55555555) + (x >> 1 & 0x55555555);
460 x = (x & 0x33333333) + (x >> 2 & 0x33333333);
461 x = (x & 0x0f0f0f0f) + (x >> 4 & 0x0f0f0f0f);
462 x = (x & 0x001f001f) + (x >> 8 & 0x001f001f);
463 return (x & 0x0000003f) + (x >>16 & 0x0000003f);
464#endif
465}
466
467static inline int
468rb_popcount64(uint64_t x)
469{
470#ifdef HAVE_BUILTIN___BUILTIN_POPCOUNT
471 return __builtin_popcountll(x);
472#else
473 x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
474 x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
475 x = (x & 0x0707070707070707) + (x >> 4 & 0x0707070707070707);
476 x = (x & 0x001f001f001f001f) + (x >> 8 & 0x001f001f001f001f);
477 x = (x & 0x0000003f0000003f) + (x >>16 & 0x0000003f0000003f);
478 return (x & 0x7f) + (x >>32 & 0x7f);
479#endif
480}
481
482static inline int
483rb_popcount_intptr(uintptr_t x)
484{
485#if SIZEOF_VOIDP == 8
486 return rb_popcount64(x);
487#elif SIZEOF_VOIDP == 4
488 return rb_popcount32(x);
489#endif
490}
491
492static inline int
493ntz_int32(uint32_t x)
494{
495#ifdef HAVE_BUILTIN___BUILTIN_CTZ
496 return __builtin_ctz(x);
497#else
498 return rb_popcount32((~x) & (x-1));
499#endif
500}
501
502static inline int
503ntz_int64(uint64_t x)
504{
505#ifdef HAVE_BUILTIN___BUILTIN_CTZLL
506 return __builtin_ctzll(x);
507#else
508 return rb_popcount64((~x) & (x-1));
509#endif
510}
511
512static inline int
513ntz_intptr(uintptr_t x)
514{
515#if SIZEOF_VOIDP == 8
516 return ntz_int64(x);
517#elif SIZEOF_VOIDP == 4
518 return ntz_int32(x);
519#endif
520}
521
522#if HAVE_LONG_LONG && SIZEOF_LONG * 2 <= SIZEOF_LONG_LONG
523# define DLONG LONG_LONG
524# define DL2NUM(x) LL2NUM(x)
525#elif defined(HAVE_INT128_T)
526# define DLONG int128_t
527# define DL2NUM(x) (RB_FIXABLE(x) ? LONG2FIX(x) : rb_int128t2big(x))
529#endif
530
531static inline long
532rb_overflowed_fix_to_int(long x)
533{
534 return (long)((unsigned long)(x >> 1) ^ (1LU << (SIZEOF_LONG * CHAR_BIT - 1)));
535}
536
537static inline VALUE
538rb_fix_plus_fix(VALUE x, VALUE y)
539{
540#ifdef HAVE_BUILTIN___BUILTIN_ADD_OVERFLOW
541 long lz;
542 /* NOTE
543 * (1) `LONG2FIX(FIX2LONG(x)+FIX2LONG(y))`
544 + = `((lx*2+1)/2 + (ly*2+1)/2)*2+1`
545 + = `lx*2 + ly*2 + 1`
546 + = `(lx*2+1) + (ly*2+1) - 1`
547 + = `x + y - 1`
548 * (2) Fixnum's LSB is always 1.
549 * It means you can always run `x - 1` without overflow.
550 * (3) Of course `z = x + (y-1)` may overflow.
551 * At that time true value is
552 * * positive: 0b0 1xxx...1, and z = 0b1xxx...1
553 * * nevative: 0b1 0xxx...1, and z = 0b0xxx...1
554 * To convert this true value to long,
555 * (a) Use arithmetic shift
556 * * positive: 0b11xxx...
557 * * negative: 0b00xxx...
558 * (b) invert MSB
559 * * positive: 0b01xxx...
560 * * negative: 0b10xxx...
561 */
562 if (__builtin_add_overflow((long)x, (long)y-1, &lz)) {
563 return rb_int2big(rb_overflowed_fix_to_int(lz));
564 }
565 else {
566 return (VALUE)lz;
567 }
568#else
569 long lz = FIX2LONG(x) + FIX2LONG(y);
570 return LONG2NUM(lz);
571#endif
572}
573
574static inline VALUE
575rb_fix_minus_fix(VALUE x, VALUE y)
576{
577#ifdef HAVE_BUILTIN___BUILTIN_SUB_OVERFLOW
578 long lz;
579 if (__builtin_sub_overflow((long)x, (long)y-1, &lz)) {
580 return rb_int2big(rb_overflowed_fix_to_int(lz));
581 }
582 else {
583 return (VALUE)lz;
584 }
585#else
586 long lz = FIX2LONG(x) - FIX2LONG(y);
587 return LONG2NUM(lz);
588#endif
589}
590
591/* arguments must be Fixnum */
592static inline VALUE
593rb_fix_mul_fix(VALUE x, VALUE y)
594{
595 long lx = FIX2LONG(x);
596 long ly = FIX2LONG(y);
597#ifdef DLONG
598 return DL2NUM((DLONG)lx * (DLONG)ly);
599#else
600 if (MUL_OVERFLOW_FIXNUM_P(lx, ly)) {
601 return rb_big_mul(rb_int2big(lx), rb_int2big(ly));
602 }
603 else {
604 return LONG2FIX(lx * ly);
605 }
606#endif
607}
608
609/*
610 * This behaves different from C99 for negative arguments.
611 * Note that div may overflow fixnum.
612 */
613static inline void
614rb_fix_divmod_fix(VALUE a, VALUE b, VALUE *divp, VALUE *modp)
615{
616 /* assume / and % comply C99.
617 * ldiv(3) won't be inlined by GCC and clang.
618 * I expect / and % are compiled as single idiv.
619 */
620 long x = FIX2LONG(a);
621 long y = FIX2LONG(b);
622 long div, mod;
623 if (x == FIXNUM_MIN && y == -1) {
624 if (divp) *divp = LONG2NUM(-FIXNUM_MIN);
625 if (modp) *modp = LONG2FIX(0);
626 return;
627 }
628 div = x / y;
629 mod = x % y;
630 if (y > 0 ? mod < 0 : mod > 0) {
631 mod += y;
632 div -= 1;
633 }
634 if (divp) *divp = LONG2FIX(div);
635 if (modp) *modp = LONG2FIX(mod);
636}
637
638/* div() for Ruby
639 * This behaves different from C99 for negative arguments.
640 */
641static inline VALUE
642rb_fix_div_fix(VALUE x, VALUE y)
643{
644 VALUE div;
645 rb_fix_divmod_fix(x, y, &div, NULL);
646 return div;
647}
648
649/* mod() for Ruby
650 * This behaves different from C99 for negative arguments.
651 */
652static inline VALUE
653rb_fix_mod_fix(VALUE x, VALUE y)
654{
655 VALUE mod;
656 rb_fix_divmod_fix(x, y, NULL, &mod);
657 return mod;
658}
659
660#if defined(HAVE_UINT128_T) && defined(HAVE_LONG_LONG)
661# define bit_length(x) \
662 (unsigned int) \
663 (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
664 sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
665 sizeof(x) <= SIZEOF_LONG_LONG ? SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)) : \
666 SIZEOF_INT128_T * CHAR_BIT - nlz_int128((uint128_t)(x)))
667#elif defined(HAVE_UINT128_T)
668# define bit_length(x) \
669 (unsigned int) \
670 (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
671 sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
672 SIZEOF_INT128_T * CHAR_BIT - nlz_int128((uint128_t)(x)))
673#elif defined(HAVE_LONG_LONG)
674# define bit_length(x) \
675 (unsigned int) \
676 (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
677 sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
678 SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)))
679#else
680# define bit_length(x) \
681 (unsigned int) \
682 (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
683 SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)))
684#endif
685
686#ifndef BDIGIT
687# if SIZEOF_INT*2 <= SIZEOF_LONG_LONG
688# define BDIGIT unsigned int
689# define SIZEOF_BDIGIT SIZEOF_INT
690# define BDIGIT_DBL unsigned LONG_LONG
691# define BDIGIT_DBL_SIGNED LONG_LONG
692# define PRI_BDIGIT_PREFIX ""
693# define PRI_BDIGIT_DBL_PREFIX PRI_LL_PREFIX
694# elif SIZEOF_INT*2 <= SIZEOF_LONG
695# define BDIGIT unsigned int
696# define SIZEOF_BDIGIT SIZEOF_INT
697# define BDIGIT_DBL unsigned long
698# define BDIGIT_DBL_SIGNED long
699# define PRI_BDIGIT_PREFIX ""
700# define PRI_BDIGIT_DBL_PREFIX "l"
701# elif SIZEOF_SHORT*2 <= SIZEOF_LONG
702# define BDIGIT unsigned short
703# define SIZEOF_BDIGIT SIZEOF_SHORT
704# define BDIGIT_DBL unsigned long
705# define BDIGIT_DBL_SIGNED long
706# define PRI_BDIGIT_PREFIX "h"
707# define PRI_BDIGIT_DBL_PREFIX "l"
708# else
709# define BDIGIT unsigned short
710# define SIZEOF_BDIGIT (SIZEOF_LONG/2)
711# define SIZEOF_ACTUAL_BDIGIT SIZEOF_LONG
712# define BDIGIT_DBL unsigned long
713# define BDIGIT_DBL_SIGNED long
714# define PRI_BDIGIT_PREFIX "h"
715# define PRI_BDIGIT_DBL_PREFIX "l"
716# endif
717#endif
718#ifndef SIZEOF_ACTUAL_BDIGIT
719# define SIZEOF_ACTUAL_BDIGIT SIZEOF_BDIGIT
720#endif
721
722#ifdef PRI_BDIGIT_PREFIX
723# define PRIdBDIGIT PRI_BDIGIT_PREFIX"d"
724# define PRIiBDIGIT PRI_BDIGIT_PREFIX"i"
725# define PRIoBDIGIT PRI_BDIGIT_PREFIX"o"
726# define PRIuBDIGIT PRI_BDIGIT_PREFIX"u"
727# define PRIxBDIGIT PRI_BDIGIT_PREFIX"x"
728# define PRIXBDIGIT PRI_BDIGIT_PREFIX"X"
729#endif
730
731#ifdef PRI_BDIGIT_DBL_PREFIX
732# define PRIdBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"d"
733# define PRIiBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"i"
734# define PRIoBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"o"
735# define PRIuBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"u"
736# define PRIxBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"x"
737# define PRIXBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"X"
738#endif
739
740#define BIGNUM_EMBED_LEN_NUMBITS 3
741#ifndef BIGNUM_EMBED_LEN_MAX
742# if (SIZEOF_VALUE*RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT) < (1 << BIGNUM_EMBED_LEN_NUMBITS)-1
743# define BIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT)
744# else
745# define BIGNUM_EMBED_LEN_MAX ((1 << BIGNUM_EMBED_LEN_NUMBITS)-1)
746# endif
747#endif
748
749struct RBignum {
750 struct RBasic basic;
751 union {
752 struct {
753 size_t len;
757 } as;
758};
759#define BIGNUM_SIGN_BIT ((VALUE)FL_USER1)
760/* sign: positive:1, negative:0 */
761#define BIGNUM_SIGN(b) ((RBASIC(b)->flags & BIGNUM_SIGN_BIT) != 0)
762#define BIGNUM_SET_SIGN(b,sign) \
763 ((sign) ? (RBASIC(b)->flags |= BIGNUM_SIGN_BIT) \
764 : (RBASIC(b)->flags &= ~BIGNUM_SIGN_BIT))
765#define BIGNUM_POSITIVE_P(b) BIGNUM_SIGN(b)
766#define BIGNUM_NEGATIVE_P(b) (!BIGNUM_SIGN(b))
767#define BIGNUM_NEGATE(b) (RBASIC(b)->flags ^= BIGNUM_SIGN_BIT)
768
769#define BIGNUM_EMBED_FLAG ((VALUE)FL_USER2)
770#define BIGNUM_EMBED_LEN_MASK \
771 (~(~(VALUE)0U << BIGNUM_EMBED_LEN_NUMBITS) << BIGNUM_EMBED_LEN_SHIFT)
772#define BIGNUM_EMBED_LEN_SHIFT \
773 (FL_USHIFT+3) /* bit offset of BIGNUM_EMBED_LEN_MASK */
774#define BIGNUM_LEN(b) \
775 ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? \
776 (size_t)((RBASIC(b)->flags >> BIGNUM_EMBED_LEN_SHIFT) & \
777 (BIGNUM_EMBED_LEN_MASK >> BIGNUM_EMBED_LEN_SHIFT)) : \
778 RBIGNUM(b)->as.heap.len)
779/* LSB:BIGNUM_DIGITS(b)[0], MSB:BIGNUM_DIGITS(b)[BIGNUM_LEN(b)-1] */
780#define BIGNUM_DIGITS(b) \
781 ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? \
782 RBIGNUM(b)->as.ary : \
783 RBIGNUM(b)->as.heap.digits)
784#define BIGNUM_LENINT(b) rb_long2int(BIGNUM_LEN(b))
785
786#define RBIGNUM(obj) (R_CAST(RBignum)(obj))
787
788struct RRational {
789 struct RBasic basic;
790 VALUE num;
791 VALUE den;
792};
793
794#define RRATIONAL(obj) (R_CAST(RRational)(obj))
795#define RRATIONAL_SET_NUM(rat, n) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->num,(n))
796#define RRATIONAL_SET_DEN(rat, d) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->den,(d))
797
798struct RFloat {
799 struct RBasic basic;
800 double float_value;
801};
802
803#define RFLOAT(obj) (R_CAST(RFloat)(obj))
804
805struct RComplex {
806 struct RBasic basic;
807 VALUE real;
808 VALUE imag;
809};
810
811#define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
812
813/* shortcut macro for internal only */
814#define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r))
815#define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i))
816
821#define RHASH_AR_TABLE_MAX_SIZE SIZEOF_VALUE
826
827 // we can not put it in "enum" because it can exceed "int" range.
828#define RHASH_LEV_MASK (FL_USER13 | FL_USER14 | FL_USER15 | /* FL 13..19 */ \
829 FL_USER16 | FL_USER17 | FL_USER18 | FL_USER19)
830
831#if USE_TRANSIENT_HEAP
833#endif
834
836 RHASH_LEV_MAX = 127, /* 7 bits */
837
840
841#define RHASH_AR_TABLE_SIZE_RAW(h) \
842 ((unsigned int)((RBASIC(h)->flags & RHASH_AR_TABLE_SIZE_MASK) >> RHASH_AR_TABLE_SIZE_SHIFT))
843
845
846#if 0 /* for debug */
847int rb_hash_ar_table_p(VALUE hash);
850#define RHASH_AR_TABLE_P(hash) rb_hash_ar_table_p(hash)
851#define RHASH_AR_TABLE(h) rb_hash_ar_table(h)
852#define RHASH_ST_TABLE(h) rb_hash_st_table(h)
853#else
854#define RHASH_AR_TABLE_P(hash) (!FL_TEST_RAW((hash), RHASH_ST_TABLE_FLAG))
855#define RHASH_AR_TABLE(hash) (RHASH(hash)->as.ar)
856#define RHASH_ST_TABLE(hash) (RHASH(hash)->as.st)
857#endif
858
859#define RHASH(obj) (R_CAST(RHash)(obj))
860#define RHASH_ST_SIZE(h) (RHASH_ST_TABLE(h)->num_entries)
861#define RHASH_ST_TABLE_P(h) (!RHASH_AR_TABLE_P(h))
862#define RHASH_ST_CLEAR(h) (FL_UNSET_RAW(h, RHASH_ST_TABLE_FLAG), RHASH(h)->as.ar = NULL)
863
864#define RHASH_AR_TABLE_SIZE_MASK (VALUE)RHASH_AR_TABLE_SIZE_MASK
865#define RHASH_AR_TABLE_SIZE_SHIFT RHASH_AR_TABLE_SIZE_SHIFT
866#define RHASH_AR_TABLE_BOUND_MASK (VALUE)RHASH_AR_TABLE_BOUND_MASK
867#define RHASH_AR_TABLE_BOUND_SHIFT RHASH_AR_TABLE_BOUND_SHIFT
868
869#if USE_TRANSIENT_HEAP
870#define RHASH_TRANSIENT_P(hash) FL_TEST_RAW((hash), RHASH_TRANSIENT_FLAG)
871#define RHASH_SET_TRANSIENT_FLAG(h) FL_SET_RAW(h, RHASH_TRANSIENT_FLAG)
872#define RHASH_UNSET_TRANSIENT_FLAG(h) FL_UNSET_RAW(h, RHASH_TRANSIENT_FLAG)
873#else
874#define RHASH_TRANSIENT_P(hash) 0
875#define RHASH_SET_TRANSIENT_FLAG(h) ((void)0)
876#define RHASH_UNSET_TRANSIENT_FLAG(h) ((void)0)
877#endif
878
879#if SIZEOF_VALUE / RHASH_AR_TABLE_MAX_SIZE == 2
880typedef uint16_t ar_hint_t;
881#elif SIZEOF_VALUE / RHASH_AR_TABLE_MAX_SIZE == 1
882typedef unsigned char ar_hint_t;
883#else
884#error unsupported
885#endif
886
887struct RHash {
888 struct RBasic basic;
889 union {
890 st_table *st;
891 struct ar_table_struct *ar; /* possibly 0 */
892 } as;
893 const VALUE ifnone;
894 union {
896 VALUE word;
898};
899
900#ifdef RHASH_IFNONE
901# undef RHASH_IFNONE
902# undef RHASH_SIZE
903
904# define RHASH_IFNONE(h) (RHASH(h)->ifnone)
905# define RHASH_SIZE(h) (RHASH_AR_TABLE_P(h) ? RHASH_AR_TABLE_SIZE_RAW(h) : RHASH_ST_SIZE(h))
906#endif /* ifdef RHASH_IFNONE */
907
908struct RMoved {
909 VALUE flags;
911 VALUE next;
912};
913
914/* missing/setproctitle.c */
915#ifndef HAVE_SETPROCTITLE
916extern void ruby_init_setproctitle(int argc, char *argv[]);
917#endif
918
919#define RSTRUCT_EMBED_LEN_MAX RSTRUCT_EMBED_LEN_MAX
920#define RSTRUCT_EMBED_LEN_MASK RSTRUCT_EMBED_LEN_MASK
921#define RSTRUCT_EMBED_LEN_SHIFT RSTRUCT_EMBED_LEN_SHIFT
922
923enum {
925 RSTRUCT_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER1),
928
931
932#if USE_TRANSIENT_HEAP
933#define RSTRUCT_TRANSIENT_P(st) FL_TEST_RAW((obj), RSTRUCT_TRANSIENT_FLAG)
934#define RSTRUCT_TRANSIENT_SET(st) FL_SET_RAW((st), RSTRUCT_TRANSIENT_FLAG)
935#define RSTRUCT_TRANSIENT_UNSET(st) FL_UNSET_RAW((st), RSTRUCT_TRANSIENT_FLAG)
936#else
937#define RSTRUCT_TRANSIENT_P(st) 0
938#define RSTRUCT_TRANSIENT_SET(st) ((void)0)
939#define RSTRUCT_TRANSIENT_UNSET(st) ((void)0)
940#endif
941
942struct RStruct {
943 struct RBasic basic;
944 union {
945 struct {
946 long len;
947 const VALUE *ptr;
950 } as;
951};
952
953#undef RSTRUCT_LEN
954#undef RSTRUCT_PTR
955#undef RSTRUCT_SET
956#undef RSTRUCT_GET
957#define RSTRUCT_EMBED_LEN(st) \
958 (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
959 (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT))
960#define RSTRUCT_LEN(st) rb_struct_len(st)
961#define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
962#define RSTRUCT_CONST_PTR(st) rb_struct_const_ptr(st)
963#define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(STRUCT, st)))
964#define RSTRUCT_SET(st, idx, v) RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[idx], (v))
965#define RSTRUCT_GET(st, idx) (RSTRUCT_CONST_PTR(st)[idx])
966#define RSTRUCT(obj) (R_CAST(RStruct)(obj))
967
968static inline long
969rb_struct_len(VALUE st)
970{
971 return (RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ?
972 RSTRUCT_EMBED_LEN(st) : RSTRUCT(st)->as.heap.len;
973}
974
975static inline const VALUE *
976rb_struct_const_ptr(VALUE st)
977{
979 RSTRUCT(st)->as.ary : RSTRUCT(st)->as.heap.ptr);
980}
981
982static inline const VALUE *
983rb_struct_const_heap_ptr(VALUE st)
984{
985 /* TODO: check embed on debug mode */
986 return RSTRUCT(st)->as.heap.ptr;
987}
988
989/* class.c */
990
992 char conflict[sizeof(VALUE) * 3];
993};
994
995struct rb_subclass_entry;
997
998struct rb_subclass_entry {
999 VALUE klass;
1001};
1002
1003#if defined(HAVE_LONG_LONG)
1004typedef unsigned LONG_LONG rb_serial_t;
1005#define SERIALT2NUM ULL2NUM
1006#define PRI_SERIALT_PREFIX PRI_LL_PREFIX
1007#define SIZEOF_SERIAL_T SIZEOF_LONG_LONG
1008#elif defined(HAVE_UINT64_T)
1009typedef uint64_t rb_serial_t;
1010#define SERIALT2NUM SIZET2NUM
1011#define PRI_SERIALT_PREFIX PRI_64_PREFIX
1012#define SIZEOF_SERIAL_T SIZEOF_UINT64_T
1013#else
1014typedef unsigned long rb_serial_t;
1015#define SERIALT2NUM ULONG2NUM
1016#define PRI_SERIALT_PREFIX PRI_LONG_PREFIX
1017#define SIZEOF_SERIAL_T SIZEOF_LONG
1018#endif
1019
1020struct rb_classext_struct {
1021 struct st_table *iv_index_tbl;
1022 struct st_table *iv_tbl;
1023#if SIZEOF_SERIAL_T == SIZEOF_VALUE /* otherwise m_tbl is in struct RClass */
1024 struct rb_id_table *m_tbl;
1025#endif
1026 struct rb_id_table *const_tbl;
1036#if SIZEOF_SERIAL_T != SIZEOF_VALUE /* otherwise class_serial is in struct RClass */
1037 rb_serial_t class_serial;
1038#endif
1039 const VALUE origin_;
1040 const VALUE refined_class;
1042 const VALUE includer;
1043};
1044
1046
1047#undef RClass
1048struct RClass {
1049 struct RBasic basic;
1050 VALUE super;
1052#if SIZEOF_SERIAL_T == SIZEOF_VALUE
1053 /* Class serial is as wide as VALUE. Place it here. */
1055#else
1056 /* Class serial does not fit into struct RClass. Place m_tbl instead. */
1057 struct rb_id_table *m_tbl;
1058#endif
1059};
1060
1064
1065#define RCLASS_EXT(c) (RCLASS(c)->ptr)
1066#define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
1067#define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
1068#if SIZEOF_SERIAL_T == SIZEOF_VALUE
1069# define RCLASS_M_TBL(c) (RCLASS_EXT(c)->m_tbl)
1070#else
1071# define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
1072#endif
1073#define RCLASS_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)
1074#define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)
1075#define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin_)
1076#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
1077#if SIZEOF_SERIAL_T == SIZEOF_VALUE
1078# define RCLASS_SERIAL(c) (RCLASS(c)->class_serial)
1079#else
1080# define RCLASS_SERIAL(c) (RCLASS_EXT(c)->class_serial)
1081#endif
1082#define RCLASS_INCLUDER(c) (RCLASS_EXT(c)->includer)
1083
1084#define RCLASS_CLONED FL_USER6
1085#define RICLASS_IS_ORIGIN FL_USER5
1086#define RCLASS_REFINED_BY_ANY FL_USER7
1087
1088static inline void
1089RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
1090{
1092 if (klass != origin) FL_SET(origin, RICLASS_IS_ORIGIN);
1093}
1094
1095static inline void
1096RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass)
1097{
1098 RB_OBJ_WRITE(iclass, &RCLASS_INCLUDER(iclass), klass);
1099}
1100
1101#undef RCLASS_SUPER
1102static inline VALUE
1104{
1105 return RCLASS(klass)->super;
1106}
1107
1108static inline VALUE
1109RCLASS_SET_SUPER(VALUE klass, VALUE super)
1110{
1111 if (super) {
1114 }
1115 RB_OBJ_WRITE(klass, &RCLASS(klass)->super, super);
1116 return super;
1117}
1118/* IMEMO: Internal memo object */
1119
1120#ifndef IMEMO_DEBUG
1121#define IMEMO_DEBUG 0
1122#endif
1123
1124struct RIMemo {
1125 VALUE flags;
1126 VALUE v0;
1127 VALUE v1;
1128 VALUE v2;
1129 VALUE v3;
1130};
1131
1145#define IMEMO_MASK 0x0f
1146
1147static inline enum imemo_type
1149{
1150 return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
1151}
1152
1153static inline int
1154imemo_type_p(VALUE imemo, enum imemo_type imemo_type)
1155{
1157 /* fixed at compile time if imemo_type is given. */
1158 const VALUE mask = (IMEMO_MASK << FL_USHIFT) | RUBY_T_MASK;
1159 const VALUE expected_type = (imemo_type << FL_USHIFT) | T_IMEMO;
1160 /* fixed at runtime. */
1161 return expected_type == (RBASIC(imemo)->flags & mask);
1162 }
1163 else {
1164 return 0;
1165 }
1166}
1167
1168VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
1169
1170/* FL_USER0 to FL_USER3 is for type */
1171#define IMEMO_FL_USHIFT (FL_USHIFT + 4)
1172#define IMEMO_FL_USER0 FL_USER4
1173#define IMEMO_FL_USER1 FL_USER5
1174#define IMEMO_FL_USER2 FL_USER6
1175#define IMEMO_FL_USER3 FL_USER7
1176#define IMEMO_FL_USER4 FL_USER8
1177
1178/* CREF (Class REFerence) is defined in method.h */
1179
1181struct vm_svar {
1182 VALUE flags;
1183 const VALUE cref_or_me;
1184 const VALUE lastline;
1185 const VALUE backref;
1186 const VALUE others;
1187};
1188
1189
1190#define THROW_DATA_CONSUMED IMEMO_FL_USER0
1191
1193struct vm_throw_data {
1194 VALUE flags;
1196 const VALUE throw_obj;
1198 int throw_state;
1199};
1200
1201#define THROW_DATA_P(err) RB_TYPE_P((VALUE)(err), T_IMEMO)
1202
1203/* IFUNC (Internal FUNCtion) */
1204
1205struct vm_ifunc_argc {
1206#if SIZEOF_INT * 2 > SIZEOF_VALUE
1207 signed int min: (SIZEOF_VALUE * CHAR_BIT) / 2;
1208 signed int max: (SIZEOF_VALUE * CHAR_BIT) / 2;
1209#else
1210 int min, max;
1211#endif
1212};
1213
1215struct vm_ifunc {
1216 VALUE flags;
1219 const void *data;
1220 struct vm_ifunc_argc argc;
1221};
1222
1223#define IFUNC_NEW(a, b, c) ((struct vm_ifunc *)rb_imemo_new(imemo_ifunc, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
1225static inline struct vm_ifunc *
1226rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data)
1227{
1229}
1230
1231typedef struct rb_imemo_tmpbuf_struct {
1232 VALUE flags;
1234 VALUE *ptr; /* malloc'ed buffer */
1235 struct rb_imemo_tmpbuf_struct *next; /* next imemo */
1236 size_t cnt; /* buffer size in VALUE */
1238
1239#define rb_imemo_tmpbuf_auto_free_pointer() rb_imemo_new(imemo_tmpbuf, 0, 0, 0, 0)
1241
1242#define RB_IMEMO_TMPBUF_PTR(v) \
1243 ((void *)(((const struct rb_imemo_tmpbuf_struct *)(v))->ptr))
1244
1245static inline void *
1246rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr)
1247{
1248 return ((rb_imemo_tmpbuf_t *)v)->ptr = ptr;
1249}
1250
1251static inline VALUE
1252rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str)
1253{
1254 const void *src;
1255 VALUE imemo;
1256 rb_imemo_tmpbuf_t *tmpbuf;
1257 void *dst;
1258 size_t len;
1259
1261 /* create tmpbuf to keep the pointer before xmalloc */
1263 tmpbuf = (rb_imemo_tmpbuf_t *)imemo;
1264 len = RSTRING_LEN(str);
1265 src = RSTRING_PTR(str);
1266 dst = ruby_xmalloc(len);
1267 memcpy(dst, src, len);
1268 tmpbuf->ptr = dst;
1269 return imemo;
1270}
1271
1273
1278struct MEMO {
1279 VALUE flags;
1281 const VALUE v1;
1282 const VALUE v2;
1283 union {
1284 long cnt;
1285 long state;
1286 const VALUE value;
1287 void (*func)(void);
1289};
1290
1291#define MEMO_V1_SET(m, v) RB_OBJ_WRITE((m), &(m)->v1, (v))
1292#define MEMO_V2_SET(m, v) RB_OBJ_WRITE((m), &(m)->v2, (v))
1293
1294#define MEMO_CAST(m) ((struct MEMO *)m)
1295
1296#define MEMO_NEW(a, b, c) ((struct MEMO *)rb_imemo_new(imemo_memo, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
1297
1298#define roomof(x, y) (((x) + (y) - 1) / (y))
1299#define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
1300#define MEMO_FOR(type, value) ((type *)RARRAY_PTR(value))
1301#define NEW_MEMO_FOR(type, value) \
1302 ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
1303#define NEW_PARTIAL_MEMO_FOR(type, value, member) \
1304 ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), \
1305 rb_ary_set_len((value), offsetof(type, member) / sizeof(VALUE)), \
1306 MEMO_FOR(type, value))
1307
1308#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
1309
1310#ifdef RUBY_INTEGER_UNIFICATION
1311# define rb_cFixnum rb_cInteger
1312# define rb_cBignum rb_cInteger
1313#endif
1314
1315enum {
1321
1322struct cmp_opt_data {
1323 unsigned int opt_methods;
1324 unsigned int opt_inited;
1325};
1326
1327#define NEW_CMP_OPT_MEMO(type, value) \
1328 NEW_PARTIAL_MEMO_FOR(type, value, cmp_opt)
1329#define CMP_OPTIMIZABLE_BIT(type) (1U << TOKEN_PASTE(cmp_opt_,type))
1330#define CMP_OPTIMIZABLE(data, type) \
1331 (((data).opt_inited & CMP_OPTIMIZABLE_BIT(type)) ? \
1332 ((data).opt_methods & CMP_OPTIMIZABLE_BIT(type)) : \
1333 (((data).opt_inited |= CMP_OPTIMIZABLE_BIT(type)), \
1334 rb_method_basic_definition_p(TOKEN_PASTE(rb_c,type), id_cmp) && \
1335 ((data).opt_methods |= CMP_OPTIMIZABLE_BIT(type))))
1336
1337#define OPTIMIZED_CMP(a, b, data) \
1338 ((FIXNUM_P(a) && FIXNUM_P(b) && CMP_OPTIMIZABLE(data, Fixnum)) ? \
1339 (((long)a > (long)b) ? 1 : ((long)a < (long)b) ? -1 : 0) : \
1340 (STRING_P(a) && STRING_P(b) && CMP_OPTIMIZABLE(data, String)) ? \
1341 rb_str_cmp(a, b) : \
1342 (RB_FLOAT_TYPE_P(a) && RB_FLOAT_TYPE_P(b) && CMP_OPTIMIZABLE(data, Float)) ? \
1343 rb_float_cmp(a, b) : \
1344 rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b))
1345
1346/* ment is in method.h */
1347
1348/* global variable */
1349
1350struct rb_global_entry {
1351 struct rb_global_variable *var;
1352 ID id;
1353};
1354
1359
1360/* array.c */
1361
1362#ifndef ARRAY_DEBUG
1363#define ARRAY_DEBUG (0+RUBY_DEBUG)
1364#endif
1365
1366#ifdef ARRAY_DEBUG
1367#define RARRAY_PTR_IN_USE_FLAG FL_USER14
1368#define ARY_PTR_USING_P(ary) FL_TEST_RAW((ary), RARRAY_PTR_IN_USE_FLAG)
1369#else
1370
1371/* disable debug function */
1372#undef RARRAY_PTR_USE_START_TRANSIENT
1373#undef RARRAY_PTR_USE_END_TRANSIENT
1374#define RARRAY_PTR_USE_START_TRANSIENT(a) ((VALUE *)RARRAY_CONST_PTR_TRANSIENT(a))
1375#define RARRAY_PTR_USE_END_TRANSIENT(a)
1376#define ARY_PTR_USING_P(ary) 0
1377
1378#endif
1379
1380#if USE_TRANSIENT_HEAP
1381#define RARY_TRANSIENT_SET(ary) FL_SET_RAW((ary), RARRAY_TRANSIENT_FLAG);
1382#define RARY_TRANSIENT_UNSET(ary) FL_UNSET_RAW((ary), RARRAY_TRANSIENT_FLAG);
1383#else
1384#undef RARRAY_TRANSIENT_P
1385#define RARRAY_TRANSIENT_P(a) 0
1386#define RARY_TRANSIENT_SET(ary) ((void)0)
1387#define RARY_TRANSIENT_UNSET(ary) ((void)0)
1388#endif
1389
1390
1391VALUE rb_ary_last(int, const VALUE *, VALUE);
1392void rb_ary_set_len(VALUE, long);
1394VALUE rb_ary_tmp_new_fill(long capa);
1397size_t rb_ary_memsize(VALUE);
1402#if defined(__GNUC__) && defined(HAVE_VA_ARGS_MACRO)
1403#define rb_ary_new_from_args(n, ...) \
1404 __extension__ ({ \
1405 const VALUE args_to_new_ary[] = {__VA_ARGS__}; \
1406 if (__builtin_constant_p(n)) { \
1407 STATIC_ASSERT(rb_ary_new_from_args, numberof(args_to_new_ary) == (n)); \
1408 } \
1409 rb_ary_new_from_values(numberof(args_to_new_ary), args_to_new_ary); \
1410 })
1411#endif
1412
1413static inline VALUE
1414rb_ary_entry_internal(VALUE ary, long offset)
1415{
1416 long len = RARRAY_LEN(ary);
1417 const VALUE *ptr = RARRAY_CONST_PTR_TRANSIENT(ary);
1418 if (len == 0) return Qnil;
1419 if (offset < 0) {
1420 offset += len;
1421 if (offset < 0) return Qnil;
1422 }
1423 else if (len <= offset) {
1424 return Qnil;
1425 }
1426 return ptr[offset];
1427}
1428
1429/* MRI debug support */
1431void rb_obj_info_dump_loc(VALUE obj, const char *file, int line, const char *func);
1432void ruby_debug_breakpoint(void);
1433
1434// show obj data structure without any side-effect
1435#define rp(obj) rb_obj_info_dump_loc((VALUE)(obj), __FILE__, __LINE__, __func__)
1436
1437// same as rp, but add message header
1438#define rp_m(msg, obj) do { \
1439 fprintf(stderr, "%s", (msg)); \
1440 rb_obj_info_dump((VALUE)obj); \
1441} while (0)
1442
1443// `ruby_debug_breakpoint()` does nothing,
1444// but breakpoint is set in run.gdb, so `make gdb` can stop here.
1445#define bp() ruby_debug_breakpoint()
1446
1447/* bignum.c */
1448extern const char ruby_digitmap[];
1449double rb_big_fdiv_double(VALUE x, VALUE y);
1454size_t rb_big_size(VALUE);
1457VALUE rb_str_convert_to_inum(VALUE str, int base, int badcheck, int raise_exception);
1468VALUE rb_int_powm(int const argc, VALUE * const argv, VALUE const num);
1469
1470/* class.c */
1486void Init_class_hierarchy(void);
1487
1490
1491/* compar.c */
1493
1494/* compile.c */
1495struct rb_block;
1496struct rb_iseq_struct;
1497int rb_dvar_defined(ID, const struct rb_iseq_struct *);
1499const char * rb_insns_name(int i);
1501int rb_vm_insn_addr2insn(const void *);
1502
1503/* complex.c */
1504VALUE rb_dbl_complex_new_polar_pi(double abs, double ang);
1505
1506struct rb_thread_struct;
1507/* cont.c */
1508struct rb_fiber_struct;
1511void ruby_register_rollback_func_for_ensure(VALUE (*ensure_func)(VALUE), VALUE (*rollback_func)(VALUE));
1512void rb_fiber_init_mjit_cont(struct rb_fiber_struct *fiber);
1513
1514/* debug.c */
1515PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
1516
1517/* dir.c */
1519
1520/* dmyext.c */
1521void Init_enc(void);
1522void Init_ext(void);
1523
1524/* encoding.c */
1525ID rb_id_encoding(void);
1526#ifdef RUBY_ENCODING_H
1529#endif
1530int rb_encdb_replicate(const char *alias, const char *orig);
1531int rb_encdb_alias(const char *alias, const char *orig);
1532int rb_encdb_dummy(const char *name);
1533void rb_encdb_declare(const char *name);
1534void rb_enc_set_base(const char *name, const char *orig);
1535int rb_enc_set_dummy(int index);
1536void rb_encdb_set_unicode(int index);
1538
1539/* enum.c */
1540extern VALUE rb_cArithSeq;
1541VALUE rb_f_send(int argc, VALUE *argv, VALUE recv);
1542VALUE rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary);
1543
1544/* error.c */
1545extern VALUE rb_eEAGAIN;
1546extern VALUE rb_eEWOULDBLOCK;
1547extern VALUE rb_eEINPROGRESS;
1548void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args);
1549NORETURN(void rb_async_bug_errno(const char *,int));
1550const char *rb_builtin_type_name(int t);
1551const char *rb_builtin_class_name(VALUE x);
1552PRINTF_ARGS(void rb_warn_deprecated(const char *fmt, const char *suggest, ...), 1, 3);
1553#ifdef RUBY_ENCODING_H
1554VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding*, const char*, va_list);
1555PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
1556PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
1557PRINTF_ARGS(void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt, ...), 3, 4);
1558#endif
1559
1560typedef enum {
1564 RB_WARN_CATEGORY_ALL_BITS = 0x6, /* no RB_WARN_CATEGORY_NONE bit */
1568
1569#define rb_raise_cstr(etype, mesg) \
1570 rb_exc_raise(rb_exc_new_str(etype, rb_str_new_cstr(mesg)))
1571#define rb_raise_static(etype, mesg) \
1572 rb_exc_raise(rb_exc_new_str(etype, rb_str_new_static(mesg, rb_strlen_lit(mesg))))
1573
1574VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);
1575#define rb_name_err_raise_str(mesg, recv, name) \
1576 rb_exc_raise(rb_name_err_new(mesg, recv, name))
1577#define rb_name_err_raise(mesg, recv, name) \
1578 rb_name_err_raise_str(rb_fstring_cstr(mesg), (recv), (name))
1579VALUE rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv);
1581#define rb_key_err_raise(mesg, recv, name) \
1582 rb_exc_raise(rb_key_err_new(mesg, recv, name))
1583PRINTF_ARGS(VALUE rb_warning_string(const char *fmt, ...), 1, 2);
1584NORETURN(void rb_vraise(VALUE, const char *, va_list));
1585
1586/* eval.c */
1590#define id_signo ruby_static_id_signo
1591#define id_status ruby_static_id_status
1593
1594/* eval_error.c */
1596
1597/* eval_jump.c */
1598void rb_call_end_proc(VALUE data);
1599void rb_mark_end_proc(void);
1600
1601/* file.c */
1602extern const char ruby_null_device[];
1603VALUE rb_home_dir_of(VALUE user, VALUE result);
1605VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
1606#ifdef RUBY_ENCODING_H
1608#endif
1609void rb_file_const(const char*, VALUE);
1610int rb_file_load_ok(const char *);
1615void Init_File(void);
1616int ruby_is_fd_loadable(int fd);
1617
1618#ifdef RUBY_FUNCTION_NAME_STRING
1619# if defined __GNUC__ && __GNUC__ >= 4
1620# pragma GCC visibility push(default)
1621# endif
1622NORETURN(void rb_sys_fail_path_in(const char *func_name, VALUE path));
1623NORETURN(void rb_syserr_fail_path_in(const char *func_name, int err, VALUE path));
1624# if defined __GNUC__ && __GNUC__ >= 4
1625# pragma GCC visibility pop
1626# endif
1627# define rb_sys_fail_path(path) rb_sys_fail_path_in(RUBY_FUNCTION_NAME_STRING, path)
1628# define rb_syserr_fail_path(err, path) rb_syserr_fail_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
1629#else
1630# define rb_sys_fail_path(path) rb_sys_fail_str(path)
1631# define rb_syserr_fail_path(err, path) rb_syserr_fail_str((err), (path))
1632#endif
1633
1634/* gc.c */
1636extern int ruby_disable_gc;
1637struct rb_objspace; /* in vm_core.h */
1638void Init_heap(void);
1640void ruby_mimfree(void *ptr);
1644#if USE_RGENGC
1646#else
1647#define rb_gc_writebarrier_remember(obj) 0
1648#endif
1649void ruby_gc_set_params(void);
1651
1652#if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
1653#define ruby_sized_xrealloc(ptr, new_size, old_size) ruby_xrealloc(ptr, new_size)
1654#define ruby_sized_xrealloc2(ptr, new_count, element_size, old_count) ruby_xrealloc2(ptr, new_count, element_size)
1655#define ruby_sized_xfree(ptr, size) ruby_xfree(ptr)
1656#define SIZED_REALLOC_N(var,type,n,old_n) REALLOC_N(var, type, n)
1657#else
1659void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
1660void *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));
1661void ruby_sized_xfree(void *x, size_t size);
1663#define SIZED_REALLOC_N(var,type,n,old_n) ((var)=(type*)ruby_sized_xrealloc2((void*)(var), (n), sizeof(type), (old_n)))
1664#endif
1665
1666/* optimized version of NEWOBJ() */
1667#undef NEWOBJF_OF
1668#undef RB_NEWOBJ_OF
1669#define RB_NEWOBJ_OF(obj,type,klass,flags) \
1670 type *(obj) = (type*)(((flags) & FL_WB_PROTECTED) ? \
1671 rb_wb_protected_newobj_of(klass, (flags) & ~FL_WB_PROTECTED) : \
1672 rb_wb_unprotected_newobj_of(klass, flags))
1673#define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags)
1674
1675#ifdef __has_attribute
1676#if __has_attribute(alloc_align)
1677__attribute__((__alloc_align__(1)))
1678#endif
1679#endif
1681
1682size_t rb_size_mul_or_raise(size_t, size_t, VALUE); /* used in compile.c */
1683size_t rb_size_mul_add_or_raise(size_t, size_t, size_t, VALUE); /* used in iseq.h */
1684void *rb_xmalloc_mul_add(size_t, size_t, size_t) RUBY_ATTR_MALLOC;
1685void *rb_xrealloc_mul_add(const void *, size_t, size_t, size_t);
1686void *rb_xmalloc_mul_add_mul(size_t, size_t, size_t, size_t) RUBY_ATTR_MALLOC;
1687void *rb_xcalloc_mul_add_mul(size_t, size_t, size_t, size_t) RUBY_ATTR_MALLOC;
1688
1689/* hash.c */
1690#if RHASH_CONVERT_TABLE_DEBUG
1691struct st_table *rb_hash_tbl_raw(VALUE hash, const char *file, int line);
1692#define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h, __FILE__, __LINE__)
1693#else
1694struct st_table *rb_hash_tbl_raw(VALUE hash);
1695#define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h)
1696#endif
1697
1702long rb_dbl_long_hash(double d);
1712VALUE rb_hash_set_pair(VALUE hash, VALUE pair);
1713
1715int rb_hash_stlike_delete(VALUE hash, st_data_t *pkey, st_data_t *pval);
1721
1722/* inits.c */
1723void rb_call_inits(void);
1724
1725/* io.c */
1726void ruby_set_inplace_mode(const char *);
1729#ifdef RUBY_IO_H
1730size_t rb_io_memsize(const rb_io_t *);
1731#endif
1732int rb_stderr_tty_p(void);
1734#define rb_io_fptr_finalize rb_io_fptr_finalize_internal
1735
1736/* load.c */
1738int rb_require_internal(VALUE fname);
1739NORETURN(void rb_load_fail(VALUE, const char*));
1740
1741/* loadpath.c */
1742extern const char ruby_exec_prefix[];
1743extern const char ruby_initial_load_paths[];
1744
1745/* localeinit.c */
1747
1748/* math.c */
1754VALUE rb_math_log(int argc, const VALUE *argv);
1757
1758/* mjit.c */
1759
1760#if USE_MJIT
1761extern bool mjit_enabled;
1762VALUE mjit_pause(bool wait_p);
1763VALUE mjit_resume(void);
1764void mjit_finish(bool close_handle_p);
1765#else
1766#define mjit_enabled 0
1767static inline VALUE mjit_pause(bool wait_p){ return Qnil; } // unreachable
1768static inline VALUE mjit_resume(void){ return Qnil; } // unreachable
1769static inline void mjit_finish(bool close_handle_p){}
1770#endif
1771
1772/* newline.c */
1773void Init_newline(void);
1774
1775/* numeric.c */
1776
1777#define FIXNUM_POSITIVE_P(num) ((SIGNED_VALUE)(num) > (SIGNED_VALUE)INT2FIX(0))
1778#define FIXNUM_NEGATIVE_P(num) ((SIGNED_VALUE)(num) < 0)
1779#define FIXNUM_ZERO_P(num) ((num) == INT2FIX(0))
1780
1781#define INT_NEGATIVE_P(x) (FIXNUM_P(x) ? FIXNUM_NEGATIVE_P(x) : BIGNUM_NEGATIVE_P(x))
1782
1783#define FLOAT_ZERO_P(x) (RFLOAT_VALUE(x) == 0.0)
1784
1785#ifndef ROUND_DEFAULT
1786# define ROUND_DEFAULT RUBY_NUM_ROUND_HALF_UP
1787#endif
1794#define ROUND_TO(mode, even, up, down) \
1795 ((mode) == RUBY_NUM_ROUND_HALF_EVEN ? even : \
1796 (mode) == RUBY_NUM_ROUND_HALF_UP ? up : down)
1797#define ROUND_FUNC(mode, name) \
1798 ROUND_TO(mode, name##_half_even, name##_half_up, name##_half_down)
1799#define ROUND_CALL(mode, name, args) \
1800 ROUND_TO(mode, name##_half_even args, \
1801 name##_half_up args, name##_half_down args)
1802
1803int rb_num_to_uint(VALUE val, unsigned int *ret);
1804VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
1805double ruby_float_step_size(double beg, double end, double unit, int excl);
1806int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl, int allow_endless);
1807double ruby_float_mod(double x, double y);
1821VALUE rb_int2str(VALUE num, int base);
1823VALUE rb_fix_aref(VALUE fix, VALUE idx);
1825int rb_float_cmp(VALUE x, VALUE y);
1829double rb_int_fdiv_double(VALUE x, VALUE y);
1840int rb_int_positive_p(VALUE num);
1841int rb_int_negative_p(VALUE num);
1843VALUE rb_float_ceil(VALUE num, int ndigits);
1844VALUE rb_float_floor(VALUE x, int ndigits);
1845
1846static inline VALUE
1847rb_num_compare_with_zero(VALUE num, ID mid)
1848{
1849 VALUE zero = INT2FIX(0);
1850 VALUE r = rb_check_funcall(num, mid, 1, &zero);
1851 if (r == Qundef) {
1852 rb_cmperr(num, zero);
1853 }
1854 return r;
1855}
1856
1857static inline int
1858rb_num_positive_int_p(VALUE num)
1859{
1860 const ID mid = '>';
1861
1862 if (FIXNUM_P(num)) {
1864 return FIXNUM_POSITIVE_P(num);
1865 }
1866 else if (RB_TYPE_P(num, T_BIGNUM)) {
1868 return BIGNUM_POSITIVE_P(num);
1869 }
1870 return RTEST(rb_num_compare_with_zero(num, mid));
1871}
1872
1873
1874static inline int
1875rb_num_negative_int_p(VALUE num)
1876{
1877 const ID mid = '<';
1878
1879 if (FIXNUM_P(num)) {
1881 return FIXNUM_NEGATIVE_P(num);
1882 }
1883 else if (RB_TYPE_P(num, T_BIGNUM)) {
1885 return BIGNUM_NEGATIVE_P(num);
1886 }
1887 return RTEST(rb_num_compare_with_zero(num, mid));
1888}
1889
1890
1895
1896#if USE_FLONUM
1897#define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
1898#define RUBY_BIT_ROTR(v, n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n)))
1899#endif
1900
1901static inline double
1902rb_float_flonum_value(VALUE v)
1903{
1904#if USE_FLONUM
1905 if (v != (VALUE)0x8000000000000002) { /* LIKELY */
1906 union {
1907 double d;
1908 VALUE v;
1909 } t;
1910
1911 VALUE b63 = (v >> 63);
1912 /* e: xx1... -> 011... */
1913 /* xx0... -> 100... */
1914 /* ^b63 */
1915 t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~(VALUE)0x03), 3);
1916 return t.d;
1917 }
1918#endif
1919 return 0.0;
1920}
1921
1922static inline double
1923rb_float_noflonum_value(VALUE v)
1924{
1925 return ((struct RFloat *)v)->float_value;
1926}
1927
1928static inline double
1929rb_float_value_inline(VALUE v)
1930{
1931 if (FLONUM_P(v)) {
1932 return rb_float_flonum_value(v);
1933 }
1934 return rb_float_noflonum_value(v);
1935}
1936
1937static inline VALUE
1938rb_float_new_inline(double d)
1939{
1940#if USE_FLONUM
1941 union {
1942 double d;
1943 VALUE v;
1944 } t;
1945 int bits;
1946
1947 t.d = d;
1948 bits = (int)((VALUE)(t.v >> 60) & 0x7);
1949 /* bits contains 3 bits of b62..b60. */
1950 /* bits - 3 = */
1951 /* b011 -> b000 */
1952 /* b100 -> b001 */
1953
1954 if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
1955 !((bits-3) & ~0x01)) {
1956 return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
1957 }
1958 else if (t.v == (VALUE)0) {
1959 /* +0.0 */
1960 return 0x8000000000000002;
1961 }
1962 /* out of range */
1963#endif
1964 return rb_float_new_in_heap(d);
1965}
1966
1967#define rb_float_value(v) rb_float_value_inline(v)
1968#define rb_float_new(d) rb_float_new_inline(d)
1969
1970/* object.c */
1971void rb_obj_copy_ivar(VALUE dest, VALUE obj);
1972CONSTFUNC(VALUE rb_obj_equal(VALUE obj1, VALUE obj2));
1975NORETURN(void rb_undefined_alloc(VALUE klass));
1976double rb_num_to_dbl(VALUE val);
1977VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound);
1980VALUE rb_convert_type_with_id(VALUE,int,const char*,ID);
1982int rb_bool_expected(VALUE, const char *);
1983
1984struct RBasicRaw {
1985 VALUE flags;
1986 VALUE klass;
1987};
1988
1989#define RBASIC_CLEAR_CLASS(obj) memset(&(((struct RBasicRaw *)((VALUE)(obj)))->klass), 0, sizeof(VALUE))
1990#define RBASIC_SET_CLASS_RAW(obj, cls) memcpy(&((struct RBasicRaw *)((VALUE)(obj)))->klass, &(cls), sizeof(VALUE))
1991#define RBASIC_SET_CLASS(obj, cls) do { \
1992 VALUE _obj_ = (obj); \
1993 RB_OBJ_WRITE(_obj_, &((struct RBasicRaw *)(_obj_))->klass, cls); \
1994} while (0)
1995
1996/* parse.y */
1997#ifndef USE_SYMBOL_GC
1998#define USE_SYMBOL_GC 1
1999#endif
2002VALUE rb_parser_set_context(VALUE, const struct rb_iseq_struct *, int);
2004void *rb_parser_load_file(VALUE parser, VALUE name);
2013
2014/* proc.c */
2017int rb_block_arity(void);
2018int rb_block_min_max_arity(int *max);
2021VALUE rb_block_to_s(VALUE self, const struct rb_block *block, const char *additional_info);
2022
2023/* process.c */
2024#define RB_MAX_GROUPS (65536)
2025
2026struct waitpid_state;
2027struct rb_execarg {
2028 union {
2029 struct {
2032 struct {
2034 VALUE command_abspath; /* full path string or nil */
2043 unsigned use_shell : 1;
2044 unsigned pgroup_given : 1;
2045 unsigned umask_given : 1;
2046 unsigned unsetenv_others_given : 1;
2047 unsigned unsetenv_others_do : 1;
2048 unsigned close_others_given : 1;
2049 unsigned close_others_do : 1;
2050 unsigned chdir_given : 1;
2051 unsigned new_pgroup_given : 1;
2052 unsigned new_pgroup_flag : 1;
2053 unsigned uid_given : 1;
2054 unsigned gid_given : 1;
2055 unsigned exception : 1;
2056 unsigned exception_given : 1;
2057 struct waitpid_state *waitpid_state; /* for async process management */
2058 rb_pid_t pgroup_pgid; /* asis(-1), new pgroup(0), specified pgroup (0<V). */
2059 VALUE rlimit_limits; /* Qfalse or [[rtype, softlim, hardlim], ...] */
2064 VALUE fd_dup2;
2066 VALUE fd_open;
2068 VALUE env_modification; /* Qfalse or [[k1,v1], ...] */
2071};
2072
2073/* argv_str contains extra two elements.
2074 * The beginning one is for /bin/sh used by exec_with_sh.
2075 * The last one for terminating NULL used by execve.
2076 * See rb_exec_fillarg() in process.c. */
2077#define ARGVSTR2ARGV(argv_str) ((char **)RB_IMEMO_TMPBUF_PTR(argv_str) + 1)
2078
2079static inline size_t
2080ARGVSTR2ARGC(VALUE argv_str)
2081{
2082 size_t i = 0;
2083 char *const *p = ARGVSTR2ARGV(argv_str);
2084 while (p[i++])
2085 ;
2086 return i - 1;
2087}
2088
2089#ifdef HAVE_PWD_H
2090VALUE rb_getlogin(void);
2091VALUE rb_getpwdirnam_for_login(VALUE login); /* read as: "get pwd db home dir by username for login" */
2092VALUE rb_getpwdiruid(void); /* read as: "get pwd db home dir for getuid()" */
2093#endif
2094
2096void rb_last_status_clear(void);
2097
2098/* range.c */
2099#define RANGE_BEG(r) (RSTRUCT(r)->as.ary[0])
2100#define RANGE_END(r) (RSTRUCT(r)->as.ary[1])
2101#define RANGE_EXCL(r) (RSTRUCT(r)->as.ary[2])
2102
2103/* rational.c */
2106VALUE rb_rational_plus(VALUE self, VALUE other);
2107VALUE rb_rational_minus(VALUE self, VALUE other);
2108VALUE rb_rational_mul(VALUE self, VALUE other);
2109VALUE rb_rational_div(VALUE self, VALUE other);
2110VALUE rb_lcm(VALUE x, VALUE y);
2112VALUE rb_cstr_to_rat(const char *, int);
2114VALUE rb_rational_cmp(VALUE self, VALUE other);
2115VALUE rb_rational_pow(VALUE self, VALUE other);
2116VALUE rb_rational_floor(VALUE self, int ndigits);
2120
2121/* re.c */
2122VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
2124long rb_reg_search0(VALUE, VALUE, long, int, int);
2125VALUE rb_reg_match_p(VALUE re, VALUE str, long pos);
2127void rb_backref_set_string(VALUE string, long pos, long len);
2129int rb_match_count(VALUE match);
2130int rb_match_nth_defined(int nth, VALUE match);
2132
2133/* signal.c */
2134extern int ruby_enable_coredump;
2135int rb_get_next_signal(void);
2136
2137/* string.c */
2139VALUE rb_fstring_new(const char *ptr, long len);
2140#define rb_fstring_lit(str) rb_fstring_new((str), rb_strlen_lit(str))
2141#define rb_fstring_literal(str) rb_fstring_lit(str)
2142VALUE rb_fstring_cstr(const char *str);
2143#ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
2144# define rb_fstring_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
2145 (__builtin_constant_p(str)) ? \
2146 rb_fstring_new((str), (long)strlen(str)) : \
2147 rb_fstring_cstr(str) \
2148)
2149#endif
2150#ifdef RUBY_ENCODING_H
2151VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc);
2152#define rb_fstring_enc_lit(str, enc) rb_fstring_enc_new((str), rb_strlen_lit(str), (enc))
2153#define rb_fstring_enc_literal(str, enc) rb_fstring_enc_lit(str, enc)
2154#endif
2155int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p);
2159#define QUOTE(str) rb_str_quote_unprintable(str)
2160#define QUOTE_ID(id) rb_id_quote_unprintable(id)
2161char *rb_str_fill_terminator(VALUE str, const int termlen);
2162void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen);
2165#ifdef RUBY_ENCODING_H
2167VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
2168 rb_encoding *from, int ecflags, VALUE ecopts);
2170VALUE rb_str_initialize(VALUE str, const char *ptr, long len, rb_encoding *enc);
2171#endif
2172#define STR_NOEMBED FL_USER1
2173#define STR_SHARED FL_USER2 /* = ELTS_SHARED */
2174#define STR_EMBED_P(str) (!FL_TEST_RAW((str), STR_NOEMBED))
2175#define STR_SHARED_P(s) FL_ALL_RAW((s), STR_NOEMBED|ELTS_SHARED)
2176#define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
2177#define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
2178size_t rb_str_memsize(VALUE);
2179VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc);
2181char *rb_str_to_cstr(VALUE str);
2182VALUE rb_str_eql(VALUE str1, VALUE str2);
2184const char *ruby_escaped_char(int c);
2186
2187/* expect tail call optimization */
2188static inline VALUE
2189rb_str_eql_internal(const VALUE str1, const VALUE str2)
2190{
2191 const long len = RSTRING_LEN(str1);
2192 const char *ptr1, *ptr2;
2193
2194 if (len != RSTRING_LEN(str2)) return Qfalse;
2195 if (!rb_str_comparable(str1, str2)) return Qfalse;
2196 if ((ptr1 = RSTRING_PTR(str1)) == (ptr2 = RSTRING_PTR(str2)))
2197 return Qtrue;
2198 if (memcmp(ptr1, ptr2, len) == 0)
2199 return Qtrue;
2200 return Qfalse;
2201}
2202
2203/* symbol.c */
2204#ifdef RUBY_ENCODING_H
2205VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc);
2206#endif
2207VALUE rb_sym_intern_ascii(const char *ptr, long len);
2209#ifdef __GNUC__
2210#define rb_sym_intern_ascii_cstr(ptr) __extension__ ( \
2211{ \
2212 (__builtin_constant_p(ptr)) ? \
2213 rb_sym_intern_ascii((ptr), (long)strlen(ptr)) : \
2214 rb_sym_intern_ascii_cstr(ptr); \
2215})
2216#endif
2218
2219/* struct.c */
2223
2224/* time.c */
2226
2227/* thread.c */
2228#define COVERAGE_INDEX_LINES 0
2229#define COVERAGE_INDEX_BRANCHES 1
2230#define COVERAGE_TARGET_LINES 1
2231#define COVERAGE_TARGET_BRANCHES 2
2232#define COVERAGE_TARGET_METHODS 4
2233#define COVERAGE_TARGET_ONESHOT_LINES 8
2234
2239int rb_get_coverage_mode(void);
2245int rb_thread_to_be_killed(VALUE thread);
2246void rb_mutex_allow_trap(VALUE self, int val);
2247VALUE rb_uninterruptible(VALUE (*b_proc)(VALUE), VALUE data);
2249
2250/* transcode.c */
2252#ifdef RUBY_ENCODING_H
2254#endif
2255
2256/* us_ascii.c */
2257#ifdef RUBY_ENCODING_H
2258extern rb_encoding OnigEncodingUS_ASCII;
2259#endif
2260
2261/* util.c */
2262char *ruby_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve);
2263char *ruby_hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign, char **rve);
2264
2265/* utf_8.c */
2266#ifdef RUBY_ENCODING_H
2268#endif
2269
2270/* variable.c */
2271#if USE_TRANSIENT_HEAP
2272#define ROBJECT_TRANSIENT_FLAG FL_USER13
2273#define ROBJ_TRANSIENT_P(obj) FL_TEST_RAW((obj), ROBJECT_TRANSIENT_FLAG)
2274#define ROBJ_TRANSIENT_SET(obj) FL_SET_RAW((obj), ROBJECT_TRANSIENT_FLAG)
2275#define ROBJ_TRANSIENT_UNSET(obj) FL_UNSET_RAW((obj), ROBJECT_TRANSIENT_FLAG)
2276#else
2277#define ROBJ_TRANSIENT_P(obj) 0
2278#define ROBJ_TRANSIENT_SET(obj) ((void)0)
2279#define ROBJ_TRANSIENT_UNSET(obj) ((void)0)
2280#endif
2281void rb_gc_mark_global_tbl(void);
2285VALUE rb_ivar_lookup(VALUE obj, ID id, VALUE undef);
2286void rb_autoload_str(VALUE mod, ID id, VALUE file);
2288void rb_deprecate_constant(VALUE mod, const char *name);
2292bool rb_gvar_is_traced(const struct rb_global_entry *);
2294
2295/* vm_insnhelper.h */
2297
2298/* vm.c */
2300void rb_vm_mark(void *ptr);
2301void Init_BareVM(void);
2302void Init_vm_objects(void);
2305const void **rb_vm_get_insns_address_table(void);
2306VALUE rb_source_location(int *pline);
2307const char *rb_source_location_cstr(int *pline);
2309int rb_vm_add_root_module(ID id, VALUE module);
2312VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements);
2315
2316
2317/* vm_dump.c */
2318void rb_print_backtrace(void);
2319
2320/* vm_eval.c */
2321void Init_vm_eval(void);
2322VALUE rb_adjust_argv_kw_splat(int *, const VALUE **, int *);
2325typedef void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE);
2326VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv,
2329 rb_check_funcall_hook *hook, VALUE arg, int kw_splat);
2330const char *rb_type_str(enum ruby_value_type type);
2334VALUE rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv,
2335 rb_block_call_func_t bl_proc, int min_argc, int max_argc,
2336 VALUE data2);
2337
2338/* vm_insnhelper.c */
2341void Init_vm_stack_canary(void);
2342
2343/* vm_method.c */
2344void Init_eval_method(void);
2345
2354 MISSING_NONE = 0x40
2360struct rb_calling_info;
2361struct rb_call_data;
2362/* I have several reasons to chose 64 here:
2363 *
2364 * - A cache line must be a power-of-two size.
2365 * - Setting this to anything less than or equal to 32 boosts nothing.
2366 * - I have never seen an architecture that has 128 byte L1 cache line.
2367 * - I know Intel Core and Sparc T4 at least uses 64.
2368 * - I know jemalloc internally has this exact same `#define CACHE_LINE 64`.
2369 * https://github.com/jemalloc/jemalloc/blob/dev/include/jemalloc/internal/jemalloc_internal_types.h
2370 */
2371#define CACHELINE 64
2372struct rb_call_cache {
2373 /* inline cache: keys */
2376 (CACHELINE
2377 - sizeof(rb_serial_t) /* method_state */
2378 - sizeof(struct rb_callable_method_entry_struct *) /* me */
2379 - sizeof(uintptr_t) /* method_serial */
2380 - sizeof(enum method_missing_reason) /* aux */
2381 - sizeof(VALUE (*)( /* call */
2383 struct rb_control_frame_struct *,
2384 struct rb_calling_info *,
2385 const struct rb_call_data *)))
2386 / sizeof(rb_serial_t)
2387 ];
2388
2389 /* inline cache: values */
2390 const struct rb_callable_method_entry_struct *me;
2391 uintptr_t method_serial; /* me->def->method_serial */
2392
2395 struct rb_calling_info *calling,
2396 struct rb_call_data *cd);
2397
2398 union {
2399 unsigned int index; /* used by ivar */
2400 enum method_missing_reason method_missing_reason; /* used by method_missing */
2402};
2403STATIC_ASSERT(cachelined, sizeof(struct rb_call_cache) <= CACHELINE);
2404struct rb_call_info {
2405 /* fixed at compile time */
2406 ID mid;
2407 unsigned int flag;
2408 int orig_argc;
2409};
2410struct rb_call_data {
2411 struct rb_call_cache cc;
2412 struct rb_call_info ci;
2413};
2415RUBY_FUNC_NONNULL(1, VALUE rb_funcallv_with_cc(struct rb_call_data*, VALUE, ID, int, const VALUE*));
2418
2419#ifdef __GNUC__
2420# define rb_funcallv(recv, mid, argc, argv) \
2421 __extension__({ \
2422 static struct rb_call_data rb_funcallv_data; \
2423 rb_funcallv_with_cc(&rb_funcallv_data, recv, mid, argc, argv); \
2424 })
2425# define rb_method_basic_definition_p(klass, mid) \
2426 __extension__({ \
2427 static struct rb_call_data rb_mbdp; \
2428 (klass == Qfalse) ? /* hidden object cannot be overridden */ true : \
2429 rb_method_basic_definition_p_with_cc(&rb_mbdp, klass, mid); \
2430 })
2431#endif
2432
2433/* vm_backtrace.c */
2434void Init_vm_backtrace(void);
2435VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval);
2437
2443void rb_backtrace_each(VALUE (*iter)(VALUE recv, VALUE str), VALUE output);
2444
2445#ifdef HAVE_PWD_H
2446VALUE rb_getlogin(void);
2447VALUE rb_getpwdirnam_for_login(VALUE login); /* read as: "get pwd db home dir by username for login" */
2448VALUE rb_getpwdiruid(void); /* read as: "get pwd db home dir for getuid()" */
2449#endif
2450
2453
2454/* Temporary. This API will be removed (renamed). */
2456
2457/* array.c (export) */
2460void rb_ary_ptr_use_end(VALUE ary);
2461
2462/* bignum.c (export) */
2469VALUE rb_big2str_poweroftwo(VALUE x, int base);
2470VALUE rb_big2str_generic(VALUE x, int base);
2471VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck);
2472VALUE rb_str2big_normal(VALUE arg, int base, int badcheck);
2473VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck);
2474#if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
2477VALUE rb_big2str_gmp(VALUE x, int base);
2478VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck);
2479#endif
2487VALUE rb_int_parse_cstr(const char *str, ssize_t len, char **endp, size_t *ndigits, int base, int flags);
2488
2489/* enumerator.c (export) */
2490VALUE rb_arith_seq_new(VALUE obj, VALUE meth, int argc, VALUE const *argv,
2491 rb_enumerator_size_func *size_fn,
2492 VALUE beg, VALUE end, VALUE step, int excl);
2493
2494/* error.c (export) */
2495int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
2497#undef Check_Type
2498#define Check_Type(v, t) \
2499 (!RB_TYPE_P((VALUE)(v), (t)) || \
2500 ((t) == RUBY_T_DATA && RTYPEDDATA_P(v)) ? \
2501 rb_unexpected_type((VALUE)(v), (t)) : (void)0)
2502
2503static inline int
2504rb_typeddata_is_instance_of_inline(VALUE obj, const rb_data_type_t *data_type)
2505{
2506 return RB_TYPE_P(obj, T_DATA) && RTYPEDDATA_P(obj) && (RTYPEDDATA_TYPE(obj) == data_type);
2507}
2508#define rb_typeddata_is_instance_of rb_typeddata_is_instance_of_inline
2509
2510/* file.c (export) */
2511#if defined HAVE_READLINK && defined RUBY_ENCODING_H
2513#endif
2514#ifdef __APPLE__
2515VALUE rb_str_normalize_ospath(const char *ptr, long len);
2516#endif
2517
2518/* hash.c (export) */
2521
2522/* io.c (export) */
2523void rb_maygvl_fd_fix_cloexec(int fd);
2524int rb_gc_for_fd(int err);
2525void rb_write_error_str(VALUE mesg);
2526
2527/* numeric.c (export) */
2528VALUE rb_int_positive_pow(long x, unsigned long y);
2529
2530/* object.c (export) */
2531int rb_opts_exception_p(VALUE opts, int default_value);
2532
2533/* process.c (export) */
2534int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen);
2535rb_pid_t rb_fork_async_signal_safe(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds, char *errmsg, size_t errmsg_buflen);
2536VALUE rb_execarg_new(int argc, const VALUE *argv, int accept_shell, int allow_exc_opt);
2537struct rb_execarg *rb_execarg_get(VALUE execarg_obj); /* dangerous. needs GC guard. */
2538int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val);
2539void rb_execarg_parent_start(VALUE execarg_obj);
2540void rb_execarg_parent_end(VALUE execarg_obj);
2541int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char* errmsg, size_t errmsg_buflen);
2542VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash);
2543void rb_execarg_setenv(VALUE execarg_obj, VALUE env);
2544
2545/* rational.c (export) */
2546VALUE rb_gcd(VALUE x, VALUE y);
2547VALUE rb_gcd_normal(VALUE self, VALUE other);
2548#if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
2550#endif
2551
2552/* signal.c (export) */
2553int rb_grantpt(int fd);
2554
2555/* string.c (export) */
2558#ifdef RUBY_ENCODING_H
2559/* internal use */
2560VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
2561#endif
2562VALUE rb_str_upto_each(VALUE, VALUE, int, int (*each)(VALUE, VALUE), VALUE);
2564
2565/* thread.c (export) */
2566int ruby_thread_has_gvl_p(void); /* for ext/fiddle/closure.c */
2567
2568/* time.c (export) */
2570
2571/* util.c (export) */
2572extern const signed char ruby_digit36_to_number_table[];
2573extern const char ruby_hexdigits[];
2574extern unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow);
2575
2576/* variable.c (export) */
2580int rb_class_ivar_set(VALUE klass, ID vid, VALUE value);
2581void rb_iv_tbl_copy(VALUE dst, VALUE src);
2582
2583/* gc.c (export) */
2586
2587size_t rb_obj_memsize_of(VALUE);
2589
2590#define RB_OBJ_GC_FLAGS_MAX 6
2591size_t rb_obj_gc_flags(VALUE, ID[], size_t);
2592void rb_gc_mark_values(long n, const VALUE *values);
2593void rb_gc_mark_vm_stack_values(long n, const VALUE *values);
2594
2595#if IMEMO_DEBUG
2596VALUE rb_imemo_new_debug(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0, const char *file, int line);
2597#define rb_imemo_new(type, v1, v2, v3, v0) rb_imemo_new_debug(type, v1, v2, v3, v0, __FILE__, __LINE__)
2598#else
2599VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
2600#endif
2601
2602/* random.c */
2603int ruby_fill_random_bytes(void *, size_t, int);
2604
2606
2607#define RUBY_DTRACE_CREATE_HOOK(name, arg) \
2608 RUBY_DTRACE_HOOK(name##_CREATE, arg)
2609#define RUBY_DTRACE_HOOK(name, arg) \
2610do { \
2611 if (UNLIKELY(RUBY_DTRACE_##name##_ENABLED())) { \
2612 int dtrace_line; \
2613 const char *dtrace_file = rb_source_location_cstr(&dtrace_line); \
2614 if (!dtrace_file) dtrace_file = ""; \
2615 RUBY_DTRACE_##name(arg, dtrace_file, dtrace_line); \
2616 } \
2617} while (0)
2618
2619#define RB_OBJ_BUILTIN_TYPE(obj) rb_obj_builtin_type(obj)
2620#define OBJ_BUILTIN_TYPE(obj) RB_OBJ_BUILTIN_TYPE(obj)
2621#ifdef __GNUC__
2622#define rb_obj_builtin_type(obj) \
2623__extension__({ \
2624 VALUE arg_obj = (obj); \
2625 RB_SPECIAL_CONST_P(arg_obj) ? -1 : \
2626 RB_BUILTIN_TYPE(arg_obj); \
2627 })
2628#else
2629static inline int
2631{
2632 return RB_SPECIAL_CONST_P(obj) ? -1 :
2634}
2635#endif
2636
2637/* A macro for defining a flexible array, like: VALUE ary[FLEX_ARY_LEN]; */
2638#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
2639# define FLEX_ARY_LEN /* VALUE ary[]; */
2640#elif defined(__GNUC__) && !defined(__STRICT_ANSI__)
2641# define FLEX_ARY_LEN 0 /* VALUE ary[0]; */
2642#else
2643# define FLEX_ARY_LEN 1 /* VALUE ary[1]; */
2644#endif
2645
2646/*
2647 * For declaring bitfields out of non-unsigned int types:
2648 * struct date {
2649 * BITFIELD(enum months, month, 4);
2650 * ...
2651 * };
2652 */
2653#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
2654# define BITFIELD(type, name, size) type name : size
2655#else
2656# define BITFIELD(type, name, size) unsigned int name : size
2657#endif
2658
2659#if defined(_MSC_VER)
2660# define COMPILER_WARNING_PUSH __pragma(warning(push))
2661# define COMPILER_WARNING_POP __pragma(warning(pop))
2662# define COMPILER_WARNING_ERROR(flag) __pragma(warning(error: flag)))
2663# define COMPILER_WARNING_IGNORED(flag) __pragma(warning(suppress: flag)))
2664
2665#elif defined(__clang__) /* clang 2.6 already had this feature */
2666# define COMPILER_WARNING_PUSH _Pragma("clang diagnostic push")
2667# define COMPILER_WARNING_POP _Pragma("clang diagnostic pop")
2668# define COMPILER_WARNING_SPECIFIER(kind, msg) \
2669 clang diagnostic kind # msg
2670# define COMPILER_WARNING_ERROR(flag) \
2671 COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(error, flag))
2672# define COMPILER_WARNING_IGNORED(flag) \
2673 COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(ignored, flag))
2674
2675#elif GCC_VERSION_SINCE(4, 6, 0)
2676/* https://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc/Diagnostic-Pragmas.html */
2677# define COMPILER_WARNING_PUSH _Pragma("GCC diagnostic push")
2678# define COMPILER_WARNING_POP _Pragma("GCC diagnostic pop")
2679# define COMPILER_WARNING_SPECIFIER(kind, msg) \
2680 GCC diagnostic kind # msg
2681# define COMPILER_WARNING_ERROR(flag) \
2682 COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(error, flag))
2683# define COMPILER_WARNING_IGNORED(flag) \
2684 COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(ignored, flag))
2685
2686#else /* other compilers to follow? */
2687# define COMPILER_WARNING_PUSH /* nop */
2688# define COMPILER_WARNING_POP /* nop */
2689# define COMPILER_WARNING_ERROR(flag) /* nop */
2690# define COMPILER_WARNING_IGNORED(flag) /* nop */
2691#endif
2692
2693#define COMPILER_WARNING_PRAGMA(str) COMPILER_WARNING_PRAGMA_(str)
2694#define COMPILER_WARNING_PRAGMA_(str) _Pragma(#str)
2695
2696#if defined(USE_UNALIGNED_MEMBER_ACCESS) && USE_UNALIGNED_MEMBER_ACCESS && \
2697 (defined(__clang__) || GCC_VERSION_SINCE(9, 0, 0))
2698# define UNALIGNED_MEMBER_ACCESS(expr) __extension__({ \
2699 COMPILER_WARNING_PUSH; \
2700 COMPILER_WARNING_IGNORED(-Waddress-of-packed-member); \
2701 typeof(expr) unaligned_member_access_result = (expr); \
2702 COMPILER_WARNING_POP; \
2703 unaligned_member_access_result; \
2704})
2705#else
2706# define UNALIGNED_MEMBER_ACCESS(expr) expr
2707#endif
2708#define UNALIGNED_MEMBER_PTR(ptr, mem) UNALIGNED_MEMBER_ACCESS(&(ptr)->mem)
2709
2710#undef RB_OBJ_WRITE
2711#define RB_OBJ_WRITE(a, slot, b) UNALIGNED_MEMBER_ACCESS(rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__))
2712
2713#if defined(__cplusplus)
2714#if 0
2715{ /* satisfy cc-mode */
2716#endif
2717} /* extern "C" { */
2718#endif
2719
2720#endif /* RUBY_INTERNAL_H */
VALUE rb_int2big(intptr_t n)
Definition: bignum.c:3180
void rb_cmperr(VALUE x, VALUE y)
Definition: compar.c:25
#define sym(x)
Definition: date_core.c:3717
#define mod(x, y)
Definition: date_strftime.c:28
enum @73::@75::@76 mask
struct RIMemo * ptr
Definition: debug.c:65
union @73::@75 imemo
rb_encoding * rb_enc_check_str(VALUE str1, VALUE str2)
Definition: encoding.c:880
rb_encoding * rb_enc_get_from_index(int index)
Definition: encoding.c:618
int rb_data_is_encoding(VALUE obj)
Definition: encoding.c:89
char str[HTML_ESCAPE_MAX_LEN+1]
Definition: escape.c:18
VALUE rb_f_raise(int argc, VALUE *argv)
Definition: eval.c:727
VALUE rb_check_realpath(VALUE basedir, VALUE path, rb_encoding *enc)
Definition: file.c:4478
void rb_class_foreach_subclass(VALUE klass, void(*f)(VALUE, VALUE), VALUE)
Definition: class.c:116
VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1413
void rb_class_subclass_add(VALUE super, VALUE klass)
Definition: class.c:39
VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1379
void rb_class_detach_subclasses(VALUE)
Definition: class.c:136
void Init_class_hierarchy(void)
Definition: class.c:562
VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach)
Definition: class.c:380
VALUE rb_include_class_new(VALUE, VALUE)
Definition: class.c:838
VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1398
int rb_singleton_class_internal_p(VALUE sklass)
Definition: class.c:468
VALUE rb_class_inherited(VALUE, VALUE)
Calls Class::inherited.
Definition: class.c:636
VALUE rb_class_boot(VALUE)
A utility function that wraps class_alloc.
Definition: class.c:204
void rb_class_modify_check(VALUE)
Asserts that klass is not a frozen class.
Definition: eval.c:438
void rb_class_detach_module_subclasses(VALUE)
Definition: class.c:148
VALUE rb_special_singleton_class(VALUE)
Definition: class.c:1639
void rb_class_remove_from_module_subclasses(VALUE)
Definition: class.c:97
VALUE rb_singleton_class_get(VALUE obj)
Returns the singleton class of obj, or nil if obj is not a singleton object.
Definition: class.c:1712
VALUE rb_make_metaclass(VALUE, VALUE)
Definition: class.c:593
VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1428
void rb_class_remove_from_super_subclasses(VALUE)
Definition: class.c:79
int rb_class_has_methods(VALUE c)
Definition: class.c:2219
void rb_undef_methods_from(VALUE klass, VALUE super)
Definition: class.c:1607
VALUE rb_cInteger
Definition: ruby.h:2033
@ RVALUE_EMBED_LEN_MAX
Definition: ruby.h:910
@ RUBY_FL_USHIFT
Definition: ruby.h:853
int rb_bug_reporter_add(void(*func)(FILE *, void *), void *data)
Definition: error.c:457
VALUE rb_syntax_error_append(VALUE exc, VALUE file, int line, int column, rb_encoding *enc, const char *fmt, va_list args)
Definition: error.c:104
VALUE rb_get_backtrace(VALUE info)
Definition: error.c:1231
bool rb_warning_category_enabled_p(rb_warning_category_t category)
Definition: error.c:166
void rb_enc_warn(rb_encoding *enc, const char *fmt,...)
Definition: error.c:325
void rb_sys_enc_warning(rb_encoding *enc, const char *fmt,...)
Definition: error.c:2945
void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt,...)
Definition: error.c:2957
VALUE rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv)
Definition: error.c:1675
const char * rb_builtin_type_name(int t)
Definition: error.c:763
void rb_vraise(VALUE exc, const char *fmt, va_list ap)
Definition: error.c:2665
void rb_load_fail(VALUE path, const char *err)
Definition: error.c:2967
void rb_unexpected_type(VALUE x, int t)
Definition: error.c:854
const char * rb_builtin_class_name(VALUE x)
Definition: error.c:799
VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method)
Definition: error.c:1594
rb_warning_category_t rb_warning_category_from_name(VALUE category)
Definition: error.c:142
VALUE rb_eEAGAIN
Definition: error.c:54
void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args)
Definition: error.c:712
VALUE rb_eEINPROGRESS
Definition: error.c:56
void rb_async_bug_errno(const char *mesg, int errno_arg)
Definition: error.c:690
VALUE rb_eEWOULDBLOCK
Definition: error.c:55
VALUE rb_key_err_new(VALUE mesg, VALUE recv, VALUE name)
Definition: error.c:1909
VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound)
Definition: object.c:3791
void rb_obj_copy_ivar(VALUE dest, VALUE obj)
Definition: object.c:247
int rb_opts_exception_p(VALUE opts, int default_value)
Definition: object.c:3125
double rb_num_to_dbl(VALUE val)
Definition: object.c:3576
int rb_bool_expected(VALUE, const char *)
Definition: object.c:3112
VALUE rb_convert_type_with_id(VALUE, int, const char *, ID)
Definition: object.c:2914
VALUE rb_immutable_obj_clone(int, VALUE *, VALUE)
Definition: object.c:346
VALUE rb_class_search_ancestor(VALUE klass, VALUE super)
Definition: object.c:713
VALUE rb_check_convert_type_with_id(VALUE, int, const char *, ID)
Definition: object.c:2957
VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2)
Definition: object.c:187
int rb_hash_ar_table_p(VALUE hash)
Definition: hash.c:532
st_table * rb_hash_st_table(VALUE hash)
Definition: hash.c:551
ar_table * rb_hash_ar_table(VALUE hash)
Definition: hash.c:544
int rb_int_negative_p(VALUE num)
Definition: numeric.c:307
VALUE rb_big_even_p(VALUE)
Definition: bignum.c:6840
VALUE rb_cArithSeq
Definition: enumerator.c:180
void rb_fiber_reset_root_local_storage(struct rb_thread_struct *)
Definition: cont.c:2135
struct rb_execarg * rb_execarg_get(VALUE execarg_obj)
Definition: process.c:2636
VALUE rb_math_log(int argc, const VALUE *argv)
Definition: math.c:459
VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE)
Definition: gc.c:2287
void Init_newline(void)
VALUE * ruby_initial_gc_stress_ptr
Definition: gc.c:905
VALUE rb_get_coverages(void)
Definition: thread.c:5476
VALUE rb_hash_default_value(VALUE hash, VALUE key)
Definition: hash.c:1990
void rb_file_const(const char *, VALUE)
Definition: file.c:6144
void rb_print_backtrace(void)
Definition: vm_dump.c:750
#define RSTRUCT_EMBED_LEN_SHIFT
Definition: internal.h:921
VALUE rb_adjust_argv_kw_splat(int *, const VALUE **, int *)
Definition: vm_eval.c:237
NORETURN(void rb_async_bug_errno(const char *, int))
VALUE rb_f_send(int argc, VALUE *argv, VALUE recv)
Definition: vm_eval.c:1188
void rb_backref_set_string(VALUE string, long pos, long len)
Definition: re.c:1348
rb_warning_category_t
Definition: internal.h:1560
@ RB_WARN_CATEGORY_DEPRECATED
Definition: internal.h:1562
@ RB_WARN_CATEGORY_ALL_BITS
Definition: internal.h:1564
@ RB_WARN_CATEGORY_EXPERIMENTAL
Definition: internal.h:1563
@ RB_WARN_CATEGORY_NONE
Definition: internal.h:1561
struct rb_global_entry * rb_global_entry(ID)
Definition: variable.c:326
VALUE rb_str_locktmp_ensure(VALUE str, VALUE(*func)(VALUE), VALUE arg)
Definition: string.c:2685
VALUE rb_rational_cmp(VALUE self, VALUE other)
Definition: rational.c:1097
VALUE rb_hash_values(VALUE hash)
Definition: hash.c:3456
size_t rb_big_size(VALUE)
Definition: bignum.c:6778
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2707
char * rb_str_fill_terminator(VALUE str, const int termlen)
Definition: string.c:2306
VALUE rb_hash_resurrect(VALUE hash)
Definition: hash.c:1575
VALUE rb_backtrace_to_str_ary(VALUE obj)
Definition: vm_backtrace.c:620
VALUE rb_rational_uminus(VALUE self)
Definition: rational.c:624
void rb_io_fptr_finalize_internal(void *ptr)
Definition: io.c:4734
void rb_encdb_declare(const char *name)
Definition: encoding.c:350
PRINTF_ARGS(void ruby_debug_printf(const char *,...), 1, 2)
VALUE rb_rational_pow(VALUE self, VALUE other)
Definition: rational.c:1002
int ruby_is_fd_loadable(int fd)
Definition: file.c:6256
const char * ruby_escaped_char(int c)
Definition: string.c:5848
void rb_backtrace_each(VALUE(*iter)(VALUE recv, VALUE str), VALUE output)
Definition: vm_backtrace.c:855
VALUE rb_dir_getwd_ospath(void)
Definition: dir.c:1117
VALUE rb_integer_float_eq(VALUE x, VALUE y)
Definition: bignum.c:5386
#define RHASH_AR_TABLE_SIZE_SHIFT
Definition: internal.h:865
VALUE rb_big_hash(VALUE)
Definition: bignum.c:6726
void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen)
Definition: string.c:2230
double rb_big_fdiv_double(VALUE x, VALUE y)
Definition: bignum.c:6209
VALUE rb_yield_1(VALUE val)
Definition: vm_eval.c:1231
VALUE rb_int_modulo(VALUE x, VALUE y)
Definition: numeric.c:3891
void rb_mutex_allow_trap(VALUE self, int val)
Definition: thread_sync.c:545
VALUE rb_str_eql(VALUE str1, VALUE str2)
Definition: string.c:3287
VALUE rb_fix_aref(VALUE fix, VALUE idx)
Definition: numeric.c:4649
int rb_str_symname_p(VALUE)
Definition: string.c:10695
VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE)
Definition: vm_eval.c:1528
void rb_hash_st_table_set(VALUE hash, st_table *st)
Definition: hash.c:558
int ruby_thread_has_gvl_p(void)
Definition: thread.c:1704
const void ** rb_vm_get_insns_address_table(void)
Definition: vm_exec.c:134
VALUE rb_check_to_array(VALUE ary)
Definition: array.c:915
VALUE rb_big2str_generic(VALUE x, int base)
Definition: bignum.c:5004
void rb_mark_end_proc(void)
Definition: eval_jump.c:78
VALUE rb_to_array_type(VALUE obj)
Definition: array.c:902
void ruby_debug_breakpoint(void)
Definition: debug.c:135
VALUE rb_str_quote_unprintable(VALUE)
Definition: string.c:10714
#define FIXNUM_POSITIVE_P(num)
Definition: internal.h:1777
void Init_heap(void)
Definition: gc.c:2924
int rb_hash_add_new_element(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:4547
RUBY_SYMBOL_EXPORT_BEGIN const char * rb_objspace_data_type_name(VALUE obj)
Definition: gc.c:2445
VALUE rb_num_pow(VALUE x, VALUE y)
Definition: numeric.c:4123
void Init_vm_eval(void)
Definition: vm_eval.c:2472
#define RHASH_AR_TABLE_BOUND_SHIFT
Definition: internal.h:867
VALUE rb_ary_tmp_new_fill(long capa)
Definition: array.c:776
RUBY_FUNC_EXPORTED RUBY_FUNC_NONNULL(1, VALUE rb_funcallv_with_cc(struct rb_call_data *, VALUE, ID, int, const VALUE *))
VALUE rb_struct_init_copy(VALUE copy, VALUE s)
Definition: struct.c:974
void Init_enc(void)
Definition: dmyenc.c:5
VALUE rb_big_mul_toom3(VALUE x, VALUE y)
Definition: bignum.c:2267
VALUE rb_big_comp(VALUE x)
Definition: bignum.c:5564
void ruby_reset_leap_second_info(void)
Definition: time.c:1193
size_t rb_obj_memsize_of(VALUE)
Definition: gc.c:3950
int rb_vm_insn_addr2insn(const void *)
Definition: iseq.c:3115
const char ruby_exec_prefix[]
Definition: loadpath.c:59
VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc)
Definition: string.c:10816
void rb_copy_wb_protected_attribute(VALUE dest, VALUE obj)
Definition: gc.c:6954
#define MAYBE_UNUSED(x)
Definition: internal.h:40
void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE)
Definition: internal.h:2325
#define BIGNUM_EMBED_LEN_MAX
Definition: internal.h:743
VALUE rb_int_abs(VALUE num)
Definition: numeric.c:4862
void rb_execarg_parent_end(VALUE execarg_obj)
Definition: process.c:2883
void ruby_mimfree(void *ptr)
Definition: gc.c:10250
rb_imemo_tmpbuf_t * rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt)
Definition: gc.c:2341
size_t rb_str_memsize(VALUE)
Definition: string.c:1371
#define RSTRUCT_EMBED_LEN_MASK
Definition: internal.h:920
void rb_write_error_str(VALUE mesg)
Definition: io.c:7940
VALUE rb_big_sq_fast(VALUE x)
Definition: bignum.c:1630
int rb_hash_stlike_delete(VALUE hash, st_data_t *pkey, st_data_t *pval)
Definition: hash.c:2310
VALUE rb_mutex_owned_p(VALUE self)
Definition: thread_sync.c:345
VALUE rb_float_floor(VALUE x, int ndigits)
Definition: numeric.c:1898
VALUE rb_int_div(VALUE x, VALUE y)
Definition: numeric.c:3821
VALUE rb_file_expand_path_fast(VALUE, VALUE)
Definition: file.c:4086
st_index_t rb_hash_proc(st_index_t hash, VALUE proc)
Definition: proc.c:1302
void Init_eval_method(void)
Definition: vm_method.c:2298
void * rb_xmalloc_mul_add(size_t, size_t, size_t) RUBY_ATTR_MALLOC
Definition: gc.c:10189
void * rb_xrealloc_mul_add(const void *, size_t, size_t, size_t)
Definition: gc.c:10196
VALUE rb_big2str_poweroftwo(VALUE x, int base)
Definition: bignum.c:4921
VALUE rb_fstring_cstr(const char *str)
Definition: string.c:410
size_t rb_size_mul_or_raise(size_t, size_t, VALUE)
Definition: gc.c:192
void rb_obj_info_dump_loc(VALUE obj, const char *file, int line, const char *func)
Definition: gc.c:11726
VALUE rb_rational_plus(VALUE self, VALUE other)
Definition: rational.c:737
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:415
void * ruby_mimmalloc(size_t size) RUBY_ATTR_MALLOC
Definition: gc.c:10220
VALUE rb_gcd_normal(VALUE self, VALUE other)
Definition: rational.c:344
rb_pid_t rb_fork_ruby(int *status)
@ RB_INT_PARSE_ALL
Definition: internal.h:2484
@ RB_INT_PARSE_UNDERSCORE
Definition: internal.h:2482
@ RB_INT_PARSE_PREFIX
Definition: internal.h:2483
@ RB_INT_PARSE_DEFAULT
Definition: internal.h:2485
@ RB_INT_PARSE_SIGN
Definition: internal.h:2481
void ruby_set_inplace_mode(const char *)
Definition: io.c:12872
@ cmp_opt_Float
Definition: internal.h:1318
@ cmp_opt_Fixnum
Definition: internal.h:1316
@ cmp_optimizable_count
Definition: internal.h:1319
@ cmp_opt_String
Definition: internal.h:1317
VALUE rb_arith_seq_new(VALUE obj, VALUE meth, int argc, VALUE const *argv, rb_enumerator_size_func *size_fn, VALUE beg, VALUE end, VALUE step, int excl)
Definition: enumerator.c:3308
#define __asan_unpoison_memory_region(x, y)
Definition: internal.h:109
#define RSTRUCT_EMBED_LEN_MAX
Definition: internal.h:919
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_parser_set_context(VALUE, const struct rb_iseq_struct *, int)
Definition: ripper.c:20036
VALUE rb_float_pow(VALUE x, VALUE y)
Definition: numeric.c:1298
long rb_reg_search0(VALUE, VALUE, long, int, int)
Definition: re.c:1538
VALUE rb_ident_hash_new(void)
Definition: hash.c:4278
size_t rb_obj_gc_flags(VALUE, ID[], size_t)
int rb_block_arity(void)
Definition: proc.c:1144
VALUE rb_hash_set_pair(VALUE hash, VALUE pair)
Definition: hash.c:3332
#define __asan_region_is_poisoned(x, y)
Definition: internal.h:110
VALUE rb_ary_last(int, const VALUE *, VALUE)
Definition: array.c:1677
int rb_enc_set_dummy(int index)
Definition: encoding.c:393
VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE)
Definition: file.c:3707
VALUE rb_int_pow(VALUE x, VALUE y)
Definition: numeric.c:4111
VALUE rb_hash_rehash(VALUE hash)
Definition: hash.c:1958
#define RSTRUCT(obj)
Definition: internal.h:966
int rb_is_instance_name(VALUE name)
Definition: symbol.c:1062
void rb_deprecate_constant(VALUE mod, const char *name)
Definition: variable.c:2958
void rb_gc_mark_global_tbl(void)
Definition: variable.c:434
void rb_mark_generic_ivar(VALUE)
Definition: variable.c:973
VALUE rb_float_numerator(VALUE x)
Definition: rational.c:2093
void ruby_register_rollback_func_for_ensure(VALUE(*ensure_func)(VALUE), VALUE(*rollback_func)(VALUE))
int rb_thread_to_be_killed(VALUE thread)
Definition: thread.c:2471
#define RCLASS_INCLUDER(c)
Definition: internal.h:1082
VALUE rb_math_cos(VALUE)
void rb_backtrace_print_as_bugreport(void)
Definition: vm_backtrace.c:813
VALUE rb_hash_has_key(VALUE hash, VALUE key)
Definition: hash.c:3507
#define __msan_unpoison(x, y)
Definition: internal.h:122
VALUE rb_int2str(VALUE num, int base)
Definition: numeric.c:3567
void rb_maygvl_fd_fix_cloexec(int fd)
Definition: io.c:245
VALUE rb_cEncodingConverter
Definition: transcode.c:25
void rb_ary_set_len(VALUE, long)
Definition: array.c:1932
VALUE rb_big_gt(VALUE x, VALUE y)
Definition: bignum.c:5489
VALUE rb_float_equal(VALUE x, VALUE y)
Definition: numeric.c:1383
const char * rb_type_str(enum ruby_value_type type)
Definition: vm_eval.c:572
void rb_enc_set_base(const char *name, const char *orig)
Definition: encoding.c:382
VALUE rb_io_flush_raw(VALUE, int)
Definition: io.c:1864
VALUE rb_big_ge(VALUE x, VALUE y)
Definition: bignum.c:5495
void Init_vm_backtrace(void)
VALUE rb_hash_key_str(VALUE)
Definition: hash.c:2802
int rb_require_internal(VALUE fname)
Definition: load.c:1110
VALUE rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
Definition: variable.c:1035
VALUE rb_big_aref(VALUE x, VALUE y)
Definition: bignum.c:6681
VALUE rb_math_atan2(VALUE, VALUE)
void rb_ary_detransient(VALUE a)
Definition: array.c:408
VALUE rb_int_uminus(VALUE num)
Definition: numeric.c:3484
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
VALUE rb_math_sinh(VALUE)
RUBY_SYMBOL_EXPORT_END int rb_hash_stlike_foreach_with_replace(VALUE hash, st_foreach_check_callback_func *func, st_update_callback_func *replace, st_data_t arg)
Definition: hash.c:1453
VALUE rb_autoload_at_p(VALUE, ID, int)
Definition: variable.c:2291
VALUE rb_float_mul(VALUE x, VALUE y)
Definition: numeric.c:1072
VALUE rb_reg_match_p(VALUE re, VALUE str, long pos)
Definition: re.c:3340
VALUE rb_thread_shield_new(void)
Definition: thread.c:4789
int rb_local_defined(ID, const struct rb_iseq_struct *)
VALUE rb_int_equal(VALUE x, VALUE y)
Definition: numeric.c:4168
VALUE rb_func_lambda_new(rb_block_call_func_t func, VALUE val, int min_argc, int max_argc)
Definition: proc.c:735
void ruby_init_setproctitle(int argc, char *argv[])
int rb_gc_for_fd(int err)
Definition: io.c:953
const signed char ruby_digit36_to_number_table[]
Definition: escape.c:6
VALUE rb_float_plus(VALUE x, VALUE y)
Definition: numeric.c:1024
VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:4038
bool rb_gvar_is_traced(const struct rb_global_entry *)
Definition: variable.c:714
VALUE rb_big_bit_length(VALUE big)
Definition: bignum.c:6790
VALUE rb_obj_is_fiber(VALUE)
Definition: cont.c:1040
VALUE rb_thread_shield_destroy(VALUE self)
Definition: thread.c:4845
VALUE rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary)
Definition: enum.c:1568
#define ARGVSTR2ARGV(argv_str)
Definition: internal.h:2077
struct rb_imemo_tmpbuf_struct rb_imemo_tmpbuf_t
void rb_last_status_clear(void)
Definition: process.c:582
int rb_vm_check_optimizable_mid(VALUE mid)
Definition: vm.c:1581
VALUE rb_flo_div_flo(VALUE x, VALUE y)
Definition: numeric.c:1110
void rb_execarg_setenv(VALUE execarg_obj, VALUE env)
Definition: process.c:2674
VALUE rb_block_to_s(VALUE self, const struct rb_block *block, const char *additional_info)
Definition: proc.c:1360
VALUE rb_insns_name_array(void)
Definition: compile.c:8766
VALUE rb_eql_opt(VALUE obj1, VALUE obj2)
VALUE rb_fstring(VALUE)
Definition: string.c:312
void rb_gc_free_dsymbol(VALUE)
Definition: symbol.c:678
unsigned long rb_serial_t
Definition: internal.h:1014
VALUE rb_uninterruptible(VALUE(*b_proc)(VALUE), VALUE data)
Definition: thread.c:5553
VALUE rb_int_cmp(VALUE x, VALUE y)
Definition: numeric.c:4217
VALUE rb_rational_floor(VALUE self, int ndigits)
Definition: rational.c:1415
VALUE rb_gvar_defined(struct rb_global_entry *)
Definition: variable.c:695
double ruby_float_mod(double x, double y)
Definition: numeric.c:1207
int ruby_fill_random_bytes(void *, size_t, int)
Definition: random.c:438
VALUE rb_str_tmp_frozen_acquire(VALUE str)
Definition: string.c:1210
VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash)
Definition: process.c:2307
VALUE rb_float_denominator(VALUE x)
Definition: rational.c:2116
VALUE rb_objspace_gc_disable(struct rb_objspace *)
Definition: gc.c:9269
const char ruby_null_device[]
Definition: file.c:6450
void rb_encdb_set_unicode(int index)
Definition: encoding.c:576
void Init_ext(void)
Definition: dmyext.c:2
rb_gvar_setter_t * rb_gvar_setter_function_of(const struct rb_global_entry *)
Definition: variable.c:708
struct st_table * rb_hash_tbl_raw(VALUE hash)
Definition: hash.c:1594
struct timeval rb_time_timeval(VALUE)
Definition: time.c:2689
VALUE rb_float_eql(VALUE x, VALUE y)
Definition: numeric.c:1654
VALUE rb_int_and(VALUE x, VALUE y)
Definition: numeric.c:4472
#define STATIC_ASSERT(name, expr)
Definition: internal.h:230
size_t rb_generic_ivar_memsize(VALUE)
Definition: variable.c:1010
VALUE rb_to_symbol_type(VALUE obj)
Definition: symbol.c:1044
VALUE rb_rational_reciprocal(VALUE x)
Definition: rational.c:1887
VALUE rb_obj_is_thread(VALUE obj)
Definition: vm.c:2657
#define FIXNUM_NEGATIVE_P(num)
Definition: internal.h:1778
void rb_vm_mark(void *ptr)
Definition: vm.c:2243
int rb_backtrace_p(VALUE obj)
Definition: vm_backtrace.c:446
VALUE rb_float_abs(VALUE flt)
Definition: numeric.c:1698
VALUE * rb_ary_ptr_use_start(VALUE ary)
Definition: array.c:226
#define MUL_OVERFLOW_FIXNUM_P(a, b)
Definition: internal.h:273
int rb_file_load_ok(const char *)
Definition: file.c:6283
int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen)
Definition: process.c:3551
#define RB_OBJ_WRITE(a, slot, b)
Definition: internal.h:2711
VALUE rb_rational_abs(VALUE self)
Definition: rational.c:1255
int ruby_enable_coredump
Definition: signal.c:1481
VALUE rb_hash_new_with_size(st_index_t size)
Definition: hash.c:1529
void rb_strterm_mark(VALUE obj)
Definition: ripper.c:768
VALUE rb_rational_div(VALUE self, VALUE other)
Definition: rational.c:916
int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p)
Definition: string.c:5815
int rb_is_class_name(VALUE name)
Definition: symbol.c:1056
VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck)
Definition: bignum.c:4352
VALUE rb_float_uminus(VALUE num)
Definition: numeric.c:1011
VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements)
Definition: vm_eval.c:1885
VALUE rb_big_lt(VALUE x, VALUE y)
Definition: bignum.c:5501
void rb_ary_ptr_use_end(VALUE ary)
Definition: array.c:235
VALUE rb_equal_opt(VALUE obj1, VALUE obj2)
PUREFUNC(int rb_data_is_encoding(VALUE obj))
VALUE rb_gvar_get(struct rb_global_entry *)
Definition: variable.c:619
void ruby_gc_set_params(void)
Definition: gc.c:9434
void rb_stdio_set_default_encoding(void)
Definition: io.c:11769
void rb_iv_tbl_copy(VALUE dst, VALUE src)
Definition: variable.c:3343
void rb_objspace_set_event_hook(const rb_event_flag_t event)
Definition: gc.c:2095
VALUE rb_big_remainder(VALUE x, VALUE y)
Definition: bignum.c:6119
VALUE rb_backtrace_to_location_ary(VALUE obj)
Definition: vm_backtrace.c:686
void rb_vm_check_redefinition_by_prepend(VALUE klass)
Definition: vm.c:1631
void rb_fiber_init_mjit_cont(struct rb_fiber_struct *fiber)
Definition: cont.c:1134
VALUE rb_dbl_complex_new_polar_pi(double abs, double ang)
Definition: complex.c:667
void rb_gvar_readonly_setter(VALUE v, ID id, VALUE *_)
Definition: variable.c:412
VALUE rb_int_lshift(VALUE x, VALUE y)
Definition: numeric.c:4589
VALUE rb_str_upto_each(VALUE, VALUE, int, int(*each)(VALUE, VALUE), VALUE)
Definition: string.c:4263
double ruby_float_step_size(double beg, double end, double unit, int excl)
Definition: numeric.c:2500
int rb_vm_add_root_module(ID id, VALUE module)
Definition: vm.c:2312
void * rb_aligned_malloc(size_t, size_t) RUBY_ATTR_MALLOC RUBY_ATTR_ALLOC_SIZE((2))
Definition: gc.c:9643
VALUE rb_big_size_m(VALUE big)
Definition: bignum.c:6784
VALUE rb_objspace_gc_enable(struct rb_objspace *)
Definition: gc.c:9232
VALUE rb_to_hash_type(VALUE obj)
Definition: hash.c:1845
const char ruby_digitmap[]
Definition: bignum.c:38
rb_serial_t rb_next_class_serial(void)
Definition: vm.c:358
VALUE rb_math_exp(VALUE)
VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval)
Definition: vm_backtrace.c:960
VALUE rb_int_powm(int const argc, VALUE *const argv, VALUE const num)
Definition: bignum.c:7112
#define RCLASS_ORIGIN(c)
Definition: internal.h:1075
void rb_ary_delete_same(VALUE, VALUE)
Definition: array.c:3396
#define RHASH_AR_TABLE_SIZE_MASK
Definition: internal.h:864
#define RUBY_BIT_ROTR(v, n)
Definition: internal.h:1898
VALUE rb_yield_force_blockarg(VALUE values)
Definition: vm_eval.c:1309
VALUE rb_check_funcall_default(VALUE, ID, int, const VALUE *, VALUE)
Definition: vm_eval.c:533
VALUE rb_cstr_to_rat(const char *, int)
Definition: rational.c:2553
VALUE rb_invcmp(VALUE, VALUE)
Definition: compar.c:47
ID rb_id_encoding(void)
Definition: encoding.c:759
#define RHASH_AR_TABLE_BOUND_MASK
Definition: internal.h:866
VALUE rb_math_sin(VALUE)
VALUE rb_str2big_normal(VALUE arg, int base, int badcheck)
Definition: bignum.c:4310
VALUE rb_check_funcall_with_hook_kw(VALUE recv, ID mid, int argc, const VALUE *argv, rb_check_funcall_hook *hook, VALUE arg, int kw_splat)
Definition: vm_eval.c:539
bool rb_reg_start_with_p(VALUE re, VALUE str)
Definition: re.c:1626
VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv, rb_check_funcall_hook *hook, VALUE arg)
Definition: vm_eval.c:565
void rb_gc_verify_internal_consistency(void)
Definition: gc.c:6218
#define IMEMO_MASK
Definition: internal.h:1145
VALUE rb_hash_compare_by_id_p(VALUE hash)
Definition: hash.c:4267
VALUE rb_thread_shield_wait(VALUE self)
Definition: thread.c:4805
const char ruby_initial_load_paths[]
Definition: loadpath.c:62
void rb_str_tmp_frozen_release(VALUE str, VALUE tmp)
Definition: string.c:1217
#define RHASH_AR_TABLE_MAX_SIZE
Definition: internal.h:821
VALUE rb_float_gt(VALUE x, VALUE y)
Definition: numeric.c:1503
VALUE rb_default_coverage(int)
Definition: thread.c:5518
VALUE rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t bl_proc, int min_argc, int max_argc, VALUE data2)
Definition: vm_eval.c:1501
int rb_num_negative_p(VALUE)
Definition: numeric.c:313
VALUE rb_big_mul_karatsuba(VALUE x, VALUE y)
Definition: bignum.c:1870
VALUE rb_get_path_check_convert(VALUE)
Definition: file.c:211
VALUE rb_hash_set_default_proc(VALUE hash, VALUE proc)
Definition: hash.c:2242
VALUE rb_float_ceil(VALUE num, int ndigits)
Definition: numeric.c:2022
double rb_int_fdiv_double(VALUE x, VALUE y)
Definition: numeric.c:3733
VALUE rb_ary_at(VALUE, VALUE)
Definition: array.c:1629
VALUE rb_func_proc_new(rb_block_call_func_t func, VALUE val)
Definition: proc.c:728
VALUE rb_integer_float_cmp(VALUE x, VALUE y)
Definition: bignum.c:5325
void rb_autoload_str(VALUE mod, ID id, VALUE file)
Definition: variable.c:1937
int rb_int_positive_p(VALUE num)
Definition: numeric.c:301
void void ruby_sized_xfree(void *x, size_t size)
Definition: gc.c:10175
void rb_gc_mark_values(long n, const VALUE *values)
Definition: gc.c:4731
VALUE rb_execarg_new(int argc, const VALUE *argv, int accept_shell, int allow_exc_opt)
Definition: process.c:2661
void rb_call_end_proc(VALUE data)
Definition: eval_jump.c:11
void rb_obj_info_dump(VALUE obj)
Definition: gc.c:11719
VALUE rb_parser_set_yydebug(VALUE, VALUE)
Definition: ripper.c:20131
#define CACHELINE
Definition: internal.h:2371
void rb_execarg_parent_start(VALUE execarg_obj)
Definition: process.c:2844
VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl)
Definition: numeric.c:2560
int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl, int allow_endless)
Definition: numeric.c:2529
VALUE rb_str_upto_endless_each(VALUE, int(*each)(VALUE, VALUE), VALUE)
Definition: string.c:4345
VALUE rb_hash_keys(VALUE hash)
Definition: hash.c:3409
#define __asan_poison_memory_region(x, y)
Definition: internal.h:108
enum ruby_num_rounding_mode rb_num_get_rounding_option(VALUE opts)
Definition: numeric.c:200
#define rb_imemo_tmpbuf_auto_free_pointer()
Definition: internal.h:1239
VALUE rb_obj_as_string_result(VALUE str, VALUE obj)
Definition: string.c:1452
int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
Definition: process.c:2041
imemo_type
Definition: internal.h:1132
@ imemo_ment
Definition: internal.h:1139
@ imemo_ifunc
iterator function
Definition: internal.h:1137
@ imemo_parser_strterm
Definition: internal.h:1143
@ imemo_env
Definition: internal.h:1133
@ imemo_iseq
Definition: internal.h:1140
@ imemo_tmpbuf
Definition: internal.h:1141
@ imemo_cref
class reference
Definition: internal.h:1134
@ imemo_svar
special variable
Definition: internal.h:1135
@ imemo_memo
Definition: internal.h:1138
@ imemo_throw_data
Definition: internal.h:1136
@ imemo_ast
Definition: internal.h:1142
void Init_vm_stack_canary(void)
#define BDIGIT
Definition: internal.h:688
ID rb_make_internal_id(void)
Definition: symbol.c:810
VALUE rb_math_hypot(VALUE, VALUE)
const char * rb_insns_name(int i)
Definition: compile.c:8760
VALUE rb_str_chomp_string(VALUE str, VALUE chomp)
Definition: string.c:8921
RUBY_SYMBOL_EXPORT_BEGIN int rb_hash_stlike_foreach(VALUE hash, st_foreach_callback_func *func, st_data_t arg)
Definition: hash.c:1442
VALUE rb_fstring_new(const char *ptr, long len)
Definition: string.c:396
@ MISSING_SUPER
Definition: internal.h:2352
@ MISSING_VCALL
Definition: internal.h:2351
@ MISSING_PRIVATE
Definition: internal.h:2348
@ MISSING_PROTECTED
Definition: internal.h:2349
@ MISSING_NOENTRY
Definition: internal.h:2347
@ MISSING_NONE
Definition: internal.h:2354
@ MISSING_MISSING
Definition: internal.h:2353
@ MISSING_FCALL
Definition: internal.h:2350
VALUE rb_int_ge(VALUE x, VALUE y)
Definition: numeric.c:4297
VALUE rb_hash_delete_entry(VALUE hash, VALUE key)
Definition: hash.c:2326
int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char *errmsg, size_t errmsg_buflen)
Definition: process.c:3420
VALUE rb_thread_shield_release(VALUE self)
Definition: thread.c:4834
VALUE rb_math_cosh(VALUE)
#define RSTRUCT_EMBED_LEN(st)
Definition: internal.h:957
int ruby_disable_gc
Definition: gc.c:1001
VALUE rb_float_div(VALUE x, VALUE y)
Definition: numeric.c:1126
VALUE rb_rational_minus(VALUE self, VALUE other)
Definition: rational.c:778
VALUE rb_lcm(VALUE x, VALUE y)
Definition: rational.c:1925
int rb_match_nth_defined(int nth, VALUE match)
Definition: re.c:1317
MJIT_STATIC VALUE ruby_vm_special_exception_copy(VALUE)
Definition: vm_insnhelper.c:34
int rb_encdb_dummy(const char *name)
Definition: encoding.c:472
const char * rb_source_location_cstr(int *pline)
Definition: vm.c:1376
struct vm_ifunc * rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc)
Definition: proc.c:699
int rb_class_ivar_set(VALUE klass, ID vid, VALUE value)
Definition: variable.c:3327
int rb_get_next_signal(void)
Definition: signal.c:756
int rb_stderr_tty_p(void)
Definition: io.c:7962
int Init_enc_set_filesystem_encoding(void)
Definition: localeinit.c:119
VALUE rb_source_location(int *pline)
Definition: vm.c:1360
VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0)
Definition: gc.c:2321
VALUE rb_gcd(VALUE x, VALUE y)
Definition: rational.c:1906
VALUE rb_proc_location(VALUE self)
Definition: proc.c:1256
#define RICLASS_IS_ORIGIN
Definition: internal.h:1085
VALUE rb_int_minus(VALUE x, VALUE y)
Definition: numeric.c:3654
@ RHASH_PASS_AS_KEYWORDS
Definition: internal.h:818
@ RHASH_ENUM_END
Definition: internal.h:838
@ RHASH_LEV_MAX
Definition: internal.h:836
@ RHASH_LEV_SHIFT
Definition: internal.h:835
@ RHASH_ST_TABLE_FLAG
Definition: internal.h:820
@ RHASH_TRANSIENT_FLAG
Definition: internal.h:832
@ RHASH_PROC_DEFAULT
Definition: internal.h:819
VALUE rb_int_odd_p(VALUE num)
Definition: numeric.c:3227
@ RSTRUCT_ENUM_END
Definition: internal.h:929
@ RSTRUCT_TRANSIENT_FLAG
Definition: internal.h:927
VALUE rb_big_divrem_normal(VALUE x, VALUE y)
Definition: bignum.c:2714
VALUE rb_refinement_module_get_refined_class(VALUE module)
Definition: eval.c:1481
#define __msan_poison(x, y)
Definition: internal.h:121
int rb_num_to_uint(VALUE val, unsigned int *ret)
Definition: numeric.c:244
int rb_grantpt(int fd)
Definition: signal.c:1597
#define BIGNUM_NEGATIVE_P(b)
Definition: internal.h:766
@ RUBY_NUM_ROUND_HALF_EVEN
Definition: internal.h:1790
@ RUBY_NUM_ROUND_HALF_DOWN
Definition: internal.h:1791
@ RUBY_NUM_ROUND_HALF_UP
Definition: internal.h:1789
@ RUBY_NUM_ROUND_DEFAULT
Definition: internal.h:1792
char * rb_str_to_cstr(VALUE str)
Definition: string.c:2284
VALUE rb_fix_plus(VALUE x, VALUE y)
Definition: numeric.c:3609
VALUE rb_str_convert_to_inum(VALUE str, int base, int badcheck, int raise_exception)
Definition: bignum.c:4246
VALUE rb_const_missing(VALUE klass, VALUE name)
Definition: variable.c:1694
const char ruby_hexdigits[]
Definition: escape.c:5
void rb_mv_generic_ivar(VALUE src, VALUE dst)
Definition: variable.c:983
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2953
RUBY_SYMBOL_EXPORT_END void * rb_parser_load_file(VALUE parser, VALUE name)
Definition: ruby.c:2218
VALUE rb_int_divmod(VALUE x, VALUE y)
Definition: numeric.c:3968
int rb_hash_stlike_update(VALUE hash, st_data_t key, st_update_callback_func func, st_data_t arg)
Definition: hash.c:1651
size_t rb_size_mul_add_or_raise(size_t, size_t, size_t, VALUE)
Definition: gc.c:219
VALUE rb_big_uminus(VALUE x)
Definition: bignum.c:5554
void rb_gc_writebarrier_remember(VALUE obj)
Definition: gc.c:6891
void Init_vm_objects(void)
Definition: vm.c:3326
int rb_match_count(VALUE match)
Definition: re.c:1307
CONSTFUNC(VALUE rb_obj_equal(VALUE obj1, VALUE obj2))
VALUE rb_id_quote_unprintable(ID)
Definition: string.c:10735
long rb_dbl_long_hash(double d)
Definition: hash.c:160
ID ruby_static_id_signo
Definition: eval.c:37
unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow)
Definition: util.c:97
int rb_is_const_name(VALUE name)
Definition: symbol.c:1050
int rb_float_cmp(VALUE x, VALUE y)
Definition: numeric.c:1487
VALUE rb_big_odd_p(VALUE)
Definition: bignum.c:6831
VALUE rb_sym_intern_ascii_cstr(const char *ptr)
Definition: symbol.c:1038
void * rb_xmalloc_mul_add_mul(size_t, size_t, size_t, size_t) RUBY_ATTR_MALLOC
Definition: gc.c:10203
VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval)
Definition: vm_backtrace.c:966
VALUE rb_ary_tmp_new_from_values(VALUE, long, const VALUE *)
Definition: array.c:748
void rb_gc_mark_vm_stack_values(long n, const VALUE *values)
Definition: gc.c:4755
#define mjit_enabled
Definition: internal.h:1766
VALUE rb_int_idiv(VALUE x, VALUE y)
Definition: numeric.c:3848
VALUE rb_big_mul_balance(VALUE x, VALUE y)
Definition: bignum.c:1689
rb_gvar_getter_t * rb_gvar_getter_function_of(const struct rb_global_entry *)
Definition: variable.c:702
int rb_get_coverage_mode(void)
Definition: thread.c:5482
VALUE rb_reg_new_ary(VALUE ary, int options)
Definition: re.c:2927
VALUE rb_big_abs(VALUE x)
Definition: bignum.c:6762
size_t rb_ary_memsize(VALUE)
Definition: array.c:816
void rb_call_inits(void)
Definition: inits.c:19
VALUE rb_gvar_set(struct rb_global_entry *, VALUE)
Definition: variable.c:654
VALUE rb_ary_behead(VALUE, long)
Definition: array.c:1369
VALUE rb_attr_delete(VALUE, ID)
Definition: variable.c:1126
VALUE rb_sym_to_proc(VALUE sym)
Definition: proc.c:1312
VALUE rb_home_dir_of(VALUE user, VALUE result)
Definition: file.c:3576
VALUE rb_int_parse_cstr(const char *str, ssize_t len, char **endp, size_t *ndigits, int base, int flags)
Definition: bignum.c:4041
void rb_match_unbusy(VALUE)
Definition: re.c:1301
VALUE rb_struct_lookup(VALUE s, VALUE idx)
Definition: struct.c:1101
#define BIGNUM_POSITIVE_P(b)
Definition: internal.h:765
VALUE rb_get_path_check_to_string(VALUE)
Definition: file.c:196
VALUE rb_obj_is_mutex(VALUE obj)
Definition: thread_sync.c:131
VALUE rb_wb_protected_newobj_of(VALUE, VALUE)
Definition: gc.c:2294
#define __msan_allocated_memory(x, y)
Definition: internal.h:120
VALUE rb_float_minus(VALUE x, VALUE y)
Definition: numeric.c:1048
VALUE rb_big_mul_normal(VALUE x, VALUE y)
Definition: bignum.c:1561
void rb_thread_execute_interrupts(VALUE th)
Definition: thread.c:2283
void Init_BareVM(void)
Definition: vm.c:3303
void Init_File(void)
Definition: file.c:6496
MJIT_STATIC void rb_vm_pop_cfunc_frame(void)
Definition: vm.c:590
VALUE rb_get_expanded_load_path(void)
Definition: load.c:97
int rb_encdb_alias(const char *alias, const char *orig)
Definition: encoding.c:565
char * ruby_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve)
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:872
VALUE rb_str_opt_plus(VALUE, VALUE)
Definition: string.c:1925
int rb_encdb_replicate(const char *alias, const char *orig)
Definition: encoding.c:450
VALUE rb_current_realfilepath(void)
Definition: vm_eval.c:2462
void * rb_xcalloc_mul_add_mul(size_t, size_t, size_t, size_t) RUBY_ATTR_MALLOC
Definition: gc.c:10210
VALUE rb_rational_canonicalize(VALUE x)
Definition: rational.c:2046
int rb_block_min_max_arity(int *max)
Definition: proc.c:1178
VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict)
Definition: file.c:4470
#define ROUND_DEFAULT
Definition: internal.h:1786
VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd)
Definition: thread.c:1594
VALUE rb_sym_intern_ascii(const char *ptr, long len)
Definition: symbol.c:1032
VALUE rb_rational_mul(VALUE self, VALUE other)
Definition: rational.c:874
VALUE rb_search_class_path(VALUE)
Definition: variable.c:175
int rb_is_local_name(VALUE name)
Definition: symbol.c:1068
int rb_hash_stlike_lookup(VALUE hash, st_data_t key, st_data_t *pval)
Definition: hash.c:2017
VALUE rb_int_plus(VALUE x, VALUE y)
Definition: numeric.c:3615
st_table * rb_init_identtable(void)
Definition: hash.c:4286
VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck)
Definition: bignum.c:4274
RUBY_SYMBOL_EXPORT_BEGIN void * ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2))
Definition: gc.c:10140
VALUE rb_int_gt(VALUE x, VALUE y)
Definition: numeric.c:4257
VALUE rb_numeric_quo(VALUE x, VALUE y)
Definition: rational.c:2026
VALUE rb_ary_aref1(VALUE ary, VALUE i)
Definition: array.c:1595
VALUE rb_int_succ(VALUE num)
Definition: numeric.c:3326
VALUE rb_big_le(VALUE x, VALUE y)
Definition: bignum.c:5507
rb_pid_t rb_fork_async_signal_safe(int *status, int(*chfunc)(void *, char *, size_t), void *charg, VALUE fds, char *errmsg, size_t errmsg_buflen)
#define RUBY_BIT_ROTL(v, n)
Definition: internal.h:1897
char * ruby_hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign, char **rve)
VALUE rb_struct_s_keyword_init(VALUE klass)
Definition: struct.c:52
VALUE rb_int_mul(VALUE x, VALUE y)
Definition: numeric.c:3704
void rb_vm_inc_const_missing_count(void)
Definition: vm.c:386
int rb_dvar_defined(ID, const struct rb_iseq_struct *)
ID ruby_static_id_status
Definition: internal.h:1588
VALUE rb_default_home_dir(VALUE result)
Definition: file.c:3616
#define LIKELY(x)
Definition: internal.h:36
RUBY_FUNC_EXPORTED size_t rb_io_memsize(const rb_io_t *fptr)
Definition: io.c:4764
VALUE type(ANYARGS)
ANYARGS-ed function type.
Definition: cxxanyargs.hpp:39
const char * name
Definition: nkf.c:208
const char * alias
Definition: nkf.c:1159
ONIG_EXTERN const OnigEncodingType OnigEncodingUTF_8
Definition: onigmo.h:201
#define RARRAY_LEN(a)
__uint32_t uint32_t
#define SafeStringValue(v)
#define NULL
int memcmp(const void *, const void *, size_t)
Definition: memcmp.c:7
#define uint128_t
void div_t div(int __numer, int __denom)
#define UNLIMITED_ARGUMENTS
#define RSTRING_LEN(str)
#define _(args)
#define RUBY_ATTR_ALLOC_SIZE(params)
#define RTEST(v)
#define FL_USER3
void mjit_finish(_Bool close_handle_p)
#define RCLASS_SUPER(c)
enum ruby_tag_type st
unsigned long st_data_t
#define RBASIC(obj)
#define SIZEOF_LONG
void ruby_debug_printf(const char *,...) __attribute__((format(printf
const rb_iseq_t const int const int min_argc
int abs(int)
#define FL_USER7
int st_foreach_check_callback_func(st_data_t, st_data_t, st_data_t, int)
__uint16_t uint16_t
VALUE rb_getpwdirnam_for_login(VALUE login)
#define FL_USER10
rb_control_frame_t * cfp
VALUE rb_big2str_gmp(VALUE x, int base)
#define DL2NUM(x)
#define LONG2FIX(i)
#define Qundef
#define RB_SPECIAL_CONST_P(x)
#define CHAR_BIT
#define FL_USER6
void rb_warn_deprecated(const char *fmt, const char *suggest,...) __attribute__((format(printf
const VALUE VALUE obj
#define FL_SET(x, f)
#define RSTRING_PTR(str)
#define T_IMEMO
#define FL_USER1
#define T_BIGNUM
#define rb_uid_t
#define SIZEOF_INT
#define rb_gid_t
VALUE rb_check_funcall(VALUE, ID, int, const VALUE *)
Definition: vm_eval.c:505
void rb_gvar_setter_t(VALUE val, ID id, VALUE *data)
const char size_t n
#define FL_USER12
#define T_DATA
#define RUBY_SYMBOL_EXPORT_BEGIN
#define FL_USER11
unsigned long VALUE
__inline__ const void *__restrict__ src
VALUE rb_big_mul(VALUE, VALUE)
Definition: bignum.c:5933
VALUE rb_big_mul_gmp(VALUE x, VALUE y)
uint32_t i
__inline__ const void *__restrict__ size_t len
const VALUE int int int int int int VALUE char * fmt
#define FL_USER8
__uint64_t uint64_t
unsigned char ar_hint_t
VALUE rb_getlogin(void)
#define RUBY_ATTR_MALLOC
#define FLONUM_P(x)
VALUE rb_enumerator_size_func(VALUE, VALUE, VALUE)
#define LONG2NUM(x)
__gnuc_va_list va_list
#define long
VALUE rb_gcd_gmp(VALUE x, VALUE y)
#define RUBY_SYMBOL_EXPORT_END
unsigned long long rb_serial_t
int rb_str_comparable(VALUE, VALUE)
Definition: string.c:3203
int VALUE v
#define rb_method_basic_definition_p(klass, mid)
rb_control_frame_t struct rb_calling_info * calling
#define int128_t
#define RUBY_ATTR_RETURNS_NONNULL
VALUE rb_getpwdiruid(void)
#define rb_pid_t
#define rb_obj_builtin_type(obj)
#define FIXNUM_MIN
#define RTYPEDDATA_TYPE(v)
#define MJIT_STATIC
#define FL_USER2
#define RARRAY_CONST_PTR_TRANSIENT(a)
#define RCLASS(obj)
#define FL_USER9
unsigned int size
#define Qtrue
rb_block_call_func * rb_block_call_func_t
const rb_iseq_t const int const int const int max_argc
struct rb_call_cache buf
#define FIX_CONST_VALUE_PTR(x)
int st_update_callback_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
__uintptr_t uintptr_t
#define Qnil
#define Qfalse
void * memcpy(void *__restrict__, const void *__restrict__, size_t)
#define RTYPEDDATA_P(v)
st_data_t st_index_t
VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck)
#define RB_TYPE_P(obj, type)
#define INT2FIX(i)
const VALUE * argv
_ssize_t ssize_t
#define SIZEOF_LONG_LONG
uint32_t rb_event_flag_t
__inline__ int
#define FIXNUM_P(f)
int st_foreach_callback_func(st_data_t, st_data_t, st_data_t)
VALUE rb_gvar_getter_t(ID id, VALUE *data)
#define DLONG
VALUE rb_int128t2big(__int128 n)
VALUE rb_blocking_function_t(void *)
#define RB_BUILTIN_TYPE(x)
#define FL_USER5
VALUE rb_warning_string(const char *fmt,...) __attribute__((format(printf
unsigned long ID
rb_control_frame_t * __attribute__((__fastcall__)) *rb_insn_func_t)(rb_execution_context_t *
#define FL_USHIFT
#define RUBY_FUNC_EXPORTED
#define FIX2LONG(x)
__mode_t mode_t
#define SIZEOF_VALUE
VALUE(* rb_alloc_func_t)(VALUE)
#define FL_USER4
VALUE rb_big_divrem_gmp(VALUE x, VALUE y)
#define LONG_LONG
VALUE mjit_resume(void)
VALUE mjit_pause(_Bool wait_p)
void * ruby_xmalloc(size_t) __attribute__((__malloc__)) __attribute__((__returns_nonnull__)) __attribute__((alloc_size(1)))
Definition: gc.c:12008
VALUE rb_float_new_in_heap(double)
Definition: numeric.c:895
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:503
#define f
VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc)
Definition: string.c:385
VALUE rb_str_initialize(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:964
VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len, rb_encoding *from, int ecflags, VALUE ecopts)
Definition: string.c:943
VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc)
Definition: string.c:403
VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc)
Definition: string.c:1074
VALUE rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl)
Definition: string.c:10255
const VALUE v2
void(* func)(void)
const VALUE v1
const VALUE value
union MEMO::@33 u3
BDIGIT * digits
Definition: internal.h:754
struct RBasic basic
union RBignum::@27 as
struct RBignum::@27::@28 heap
unsigned int ary[(8 *RVALUE_EMBED_LEN_MAX/4)]
rb_classext_t * ptr
rb_serial_t class_serial
struct RBasic basic
struct RBasic basic
struct RBasic basic
struct RBasic basic
struct ar_table_struct * ar
ar_hint_t ary[8]
union RHash::@29 as
const VALUE ifnone
union RHash::@30 ar_hint
Definition: ruby.h:988
struct RStruct::@31::@32 heap
struct RBasic basic
const VALUE * ptr
const VALUE ary[RSTRUCT_EMBED_LEN_MAX]
union RStruct::@31 as
Definition: gc.c:566
enum method_missing_reason method_missing_reason
const struct rb_callable_method_entry_struct * me
rb_serial_t class_serial[(64 - sizeof(rb_serial_t) - sizeof(struct rb_callable_method_entry_struct *) - sizeof(uintptr_t) - sizeof(enum method_missing_reason) - sizeof(VALUE(*)(struct rb_execution_context_struct *e, struct rb_control_frame_struct *, struct rb_calling_info *, const struct rb_call_data *)))/sizeof(rb_serial_t)]
union rb_call_cache::@37 aux
VALUE(* call)(struct rb_execution_context_struct *ec, struct rb_control_frame_struct *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)
struct rb_call_info ci
struct rb_call_cache cc
rb_subclass_entry_t ** parent_subclasses
rb_subclass_entry_t ** module_subclasses
In the case that this is an ICLASS, module_subclasses points to the link in the module's subclasses l...
struct st_table * iv_index_tbl
struct rb_id_table * m_tbl
struct rb_id_table * const_tbl
rb_subclass_entry_t * subclasses
struct rb_id_table * callable_m_tbl
rb_gid_t gid
Definition: internal.h:2062
struct rb_execarg::@34::@36 cmd
rb_uid_t uid
Definition: internal.h:2061
union rb_execarg::@34 invoke
struct waitpid_state * waitpid_state
struct rb_execarg::@34::@35 sh
rb_pid_t pgroup_pgid
Definition: internal.h:2058
ID id
struct rb_global_variable * var
struct rb_imemo_tmpbuf_struct * next
Definition: io.h:66
rb_subclass_entry_t * next
VALUE klass
IFUNC (Internal FUNCtion)
struct vm_ifunc_argc argc
rb_block_call_func_t func
SVAR (Special VARiable)
const VALUE lastline
const VALUE cref_or_me
class reference or rb_method_entry_t
const struct rb_control_frame_struct * catch_frame
VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc)
Definition: symbol.c:1024
int rb_is_attrset_sym(VALUE sym)
Definition: symbol.c:902
int rb_is_const_sym(VALUE sym)
Definition: symbol.c:896
size_t rb_econv_memsize(rb_econv_t *ec)
Definition: transcode.c:1703
Definition: dtoa.c:290
VALUE rb_mod_const_missing(VALUE klass, VALUE name)
Definition: variable.c:1739
VALUE rb_vm_top_self(void)
Definition: vm.c:3349
st_table * rb_vm_fstring_table(void)
Definition: vm.c:3394
bool rb_method_basic_definition_p_with_cc(struct rb_call_data *cd, VALUE klass, ID mid)
Definition: vm_method.c:2074
VALUE rb_readlink(VALUE path, rb_encoding *resultenc)
Definition: file.c:618
#define env