Ruby 4.0.10p0 (2026-11-19 revision a704b7cd95a42cc0cf5f307137bf3aac0285b915)
vm_core.h
1#ifndef RUBY_VM_CORE_H
2#define RUBY_VM_CORE_H
3/**********************************************************************
4
5 vm_core.h -
6
7 $Author$
8 created at: 04/01/01 19:41:38 JST
9
10 Copyright (C) 2004-2007 Koichi Sasada
11
12**********************************************************************/
13
14/*
15 * Enable check mode.
16 * 1: enable local assertions.
17 */
18#ifndef VM_CHECK_MODE
19
20// respect RUBY_DUBUG: if given n is 0, then use RUBY_DEBUG
21#define N_OR_RUBY_DEBUG(n) (((n) > 0) ? (n) : RUBY_DEBUG)
22
23#define VM_CHECK_MODE N_OR_RUBY_DEBUG(0)
24#endif
25
38
39#ifndef VMDEBUG
40#define VMDEBUG 0
41#endif
42
43#if 0
44#undef VMDEBUG
45#define VMDEBUG 3
46#endif
47
48#include "ruby/internal/config.h"
49
50#include <stddef.h>
51#include <signal.h>
52#include <stdarg.h>
53
54#include "ruby_assert.h"
55
56#define RVALUE_SIZE (sizeof(struct RBasic) + sizeof(VALUE[RBIMPL_RVALUE_EMBED_LEN_MAX]))
57
58#if VM_CHECK_MODE > 0
59#define VM_ASSERT(expr, ...) \
60 RUBY_ASSERT_MESG_WHEN(VM_CHECK_MODE > 0, expr, #expr RBIMPL_VA_OPT_ARGS(__VA_ARGS__))
61#define VM_UNREACHABLE(func) rb_bug(#func ": unreachable")
62#define RUBY_ASSERT_CRITICAL_SECTION
63#define RUBY_DEBUG_THREAD_SCHEDULE() rb_thread_schedule()
64#else
65#define VM_ASSERT(/*expr, */...) ((void)0)
66#define VM_UNREACHABLE(func) UNREACHABLE
67#define RUBY_DEBUG_THREAD_SCHEDULE()
68#endif
69
70#define RUBY_ASSERT_MUTEX_OWNED(mutex) VM_ASSERT(rb_mutex_owned_p(mutex))
71
72#if defined(RUBY_ASSERT_CRITICAL_SECTION)
73/*
74# Critical Section Assertions
75
76These assertions are used to ensure that context switching does not occur between two points in the code. In theory,
77such code should already be protected by a mutex, but these assertions are used to ensure that the mutex is held.
78
79The specific case where it can be useful is where a mutex is held further up the call stack, and the code in question
80may not directly hold the mutex. In this case, the critical section assertions can be used to ensure that the mutex is
81held by someone else.
82
83These assertions are only enabled when RUBY_ASSERT_CRITICAL_SECTION is defined, which is only defined if VM_CHECK_MODE
84is set.
85
86## Example Usage
87
88```c
89RUBY_ASSERT_CRITICAL_SECTION_ENTER();
90// ... some code which does not invoke rb_vm_check_ints() ...
91RUBY_ASSERT_CRITICAL_SECTION_LEAVE();
92```
93
94If `rb_vm_check_ints()` is called between the `RUBY_ASSERT_CRITICAL_SECTION_ENTER()` and
95`RUBY_ASSERT_CRITICAL_SECTION_LEAVE()`, a failed assertion will result.
96*/
97extern int ruby_assert_critical_section_entered;
98#define RUBY_ASSERT_CRITICAL_SECTION_ENTER() do{ruby_assert_critical_section_entered += 1;}while(false)
99#define RUBY_ASSERT_CRITICAL_SECTION_LEAVE() do{VM_ASSERT(ruby_assert_critical_section_entered > 0);ruby_assert_critical_section_entered -= 1;}while(false)
100#else
101#define RUBY_ASSERT_CRITICAL_SECTION_ENTER()
102#define RUBY_ASSERT_CRITICAL_SECTION_LEAVE()
103#endif
104
105#if defined(__wasm__) && !defined(__EMSCRIPTEN__)
106# include "wasm/setjmp.h"
107#else
108# include <setjmp.h>
109#endif
110
111#if defined(__linux__) || defined(__FreeBSD__)
112# define RB_THREAD_T_HAS_NATIVE_ID
113#endif
114
116#include "ccan/list/list.h"
117#include "id.h"
118#include "internal.h"
119#include "internal/array.h"
120#include "internal/basic_operators.h"
121#include "internal/box.h"
122#include "internal/sanitizers.h"
123#include "internal/serial.h"
124#include "internal/set_table.h"
125#include "internal/vm.h"
126#include "method.h"
127#include "node.h"
128#include "ruby/ruby.h"
129#include "ruby/st.h"
130#include "ruby_atomic.h"
131#include "vm_opts.h"
132
133#include "ruby/thread_native.h"
134/*
135 * implementation selector of get_insn_info algorithm
136 * 0: linear search
137 * 1: binary search
138 * 2: succinct bitvector
139 */
140#ifndef VM_INSN_INFO_TABLE_IMPL
141# define VM_INSN_INFO_TABLE_IMPL 2
142#endif
143
144#if defined(NSIG_MAX) /* POSIX issue 8 */
145# undef NSIG
146# define NSIG NSIG_MAX
147#elif defined(_SIG_MAXSIG) /* FreeBSD */
148# undef NSIG
149# define NSIG _SIG_MAXSIG
150#elif defined(_SIGMAX) /* QNX */
151# define NSIG (_SIGMAX + 1)
152#elif defined(NSIG) /* 99% of everything else */
153# /* take it */
154#else /* Last resort */
155# define NSIG (sizeof(sigset_t) * CHAR_BIT + 1)
156#endif
157
158#define RUBY_NSIG NSIG
159
160#if defined(SIGCLD)
161# define RUBY_SIGCHLD (SIGCLD)
162#elif defined(SIGCHLD)
163# define RUBY_SIGCHLD (SIGCHLD)
164#endif
165
166#if defined(SIGSEGV) && defined(HAVE_SIGALTSTACK) && defined(SA_SIGINFO) && !defined(__NetBSD__)
167# define USE_SIGALTSTACK
168void *rb_allocate_sigaltstack(void);
169void *rb_register_sigaltstack(void *);
170# define RB_ALTSTACK_INIT(var, altstack) var = rb_register_sigaltstack(altstack)
171# define RB_ALTSTACK_FREE(var) free(var)
172# define RB_ALTSTACK(var) var
173#else /* noop */
174# define RB_ALTSTACK_INIT(var, altstack)
175# define RB_ALTSTACK_FREE(var)
176# define RB_ALTSTACK(var) (0)
177#endif
178
179#include THREAD_IMPL_H
180#define RUBY_VM_THREAD_MODEL 2
181
182/*****************/
183/* configuration */
184/*****************/
185
186/* gcc ver. check */
187#if defined(__GNUC__) && __GNUC__ >= 2
188
189#if OPT_TOKEN_THREADED_CODE
190#if OPT_DIRECT_THREADED_CODE
191#undef OPT_DIRECT_THREADED_CODE
192#endif
193#endif
194
195#else /* defined(__GNUC__) && __GNUC__ >= 2 */
196
197/* disable threaded code options */
198#if OPT_DIRECT_THREADED_CODE
199#undef OPT_DIRECT_THREADED_CODE
200#endif
201#if OPT_TOKEN_THREADED_CODE
202#undef OPT_TOKEN_THREADED_CODE
203#endif
204#endif
205
206/* call threaded code */
207#if OPT_CALL_THREADED_CODE
208#if OPT_DIRECT_THREADED_CODE
209#undef OPT_DIRECT_THREADED_CODE
210#endif /* OPT_DIRECT_THREADED_CODE */
211#endif /* OPT_CALL_THREADED_CODE */
212
213void rb_vm_encoded_insn_data_table_init(void);
214typedef unsigned long rb_num_t;
215typedef signed long rb_snum_t;
216
217enum ruby_tag_type {
218 RUBY_TAG_NONE = 0x0,
219 RUBY_TAG_RETURN = 0x1,
220 RUBY_TAG_BREAK = 0x2,
221 RUBY_TAG_NEXT = 0x3,
222 RUBY_TAG_RETRY = 0x4,
223 RUBY_TAG_REDO = 0x5,
224 RUBY_TAG_RAISE = 0x6,
225 RUBY_TAG_THROW = 0x7,
226 RUBY_TAG_FATAL = 0x8,
227 RUBY_TAG_MASK = 0xf
228};
229
230#define TAG_NONE RUBY_TAG_NONE
231#define TAG_RETURN RUBY_TAG_RETURN
232#define TAG_BREAK RUBY_TAG_BREAK
233#define TAG_NEXT RUBY_TAG_NEXT
234#define TAG_RETRY RUBY_TAG_RETRY
235#define TAG_REDO RUBY_TAG_REDO
236#define TAG_RAISE RUBY_TAG_RAISE
237#define TAG_THROW RUBY_TAG_THROW
238#define TAG_FATAL RUBY_TAG_FATAL
239#define TAG_MASK RUBY_TAG_MASK
240
241enum ruby_vm_throw_flags {
242 VM_THROW_NO_ESCAPE_FLAG = 0x8000,
243 VM_THROW_STATE_MASK = 0xff
244};
245
246/* forward declarations */
247struct rb_thread_struct;
249
250/* iseq data type */
251typedef struct rb_compile_option_struct rb_compile_option_t;
252
254 rb_serial_t raw;
255 VALUE data[2];
256};
257
258#define IMEMO_CONST_CACHE_SHAREABLE IMEMO_FL_USER0
259
260// imemo_constcache
262 VALUE flags;
263
264 VALUE value;
265 const rb_cref_t *ic_cref;
266};
267STATIC_ASSERT(sizeof_iseq_inline_constant_cache_entry,
268 (offsetof(struct iseq_inline_constant_cache_entry, ic_cref) +
269 sizeof(const rb_cref_t *)) <= RVALUE_SIZE);
270
287
289 uint64_t value; // dest_shape_id in former half, attr_index in latter half
290 ID iv_set_name;
291};
292
296
298 struct {
299 struct rb_thread_struct *running_thread;
300 VALUE value;
301 } once;
302 struct iseq_inline_constant_cache ic_cache;
303 struct iseq_inline_iv_cache_entry iv_cache;
304};
305
307 const struct rb_call_data *cd;
308 const struct rb_callcache *cc;
309 VALUE block_handler;
310 VALUE recv;
311 int argc;
312 bool kw_splat;
313 VALUE heap_argv;
314};
315
316#ifndef VM_ARGC_STACK_MAX
317#define VM_ARGC_STACK_MAX 128
318#endif
319
320#define VM_KW_SPECIFIED_BITS_MAX (32-1) /* TODO: 32 -> Fixnum's max bits */
321
322# define CALLING_ARGC(calling) ((calling)->heap_argv ? RARRAY_LENINT((calling)->heap_argv) : (calling)->argc)
323
325
326#if 1
327#define CoreDataFromValue(obj, type) (type*)DATA_PTR(obj)
328#else
329#define CoreDataFromValue(obj, type) (type*)rb_data_object_get(obj)
330#endif
331#define GetCoreDataFromValue(obj, type, ptr) ((ptr) = CoreDataFromValue((obj), type))
332
334 VALUE pathobj; /* String (path) or Array [path, realpath]. Frozen. */
335 VALUE base_label; /* String */
336 VALUE label; /* String */
337 int first_lineno;
338 int node_id;
339 rb_code_location_t code_location;
340} rb_iseq_location_t;
341
342#define PATHOBJ_PATH 0
343#define PATHOBJ_REALPATH 1
344
345static inline VALUE
346pathobj_path(VALUE pathobj)
347{
348 if (RB_TYPE_P(pathobj, T_STRING)) {
349 return pathobj;
350 }
351 else {
352 VM_ASSERT(RB_TYPE_P(pathobj, T_ARRAY));
353 return RARRAY_AREF(pathobj, PATHOBJ_PATH);
354 }
355}
356
357static inline VALUE
358pathobj_realpath(VALUE pathobj)
359{
360 if (RB_TYPE_P(pathobj, T_STRING)) {
361 return pathobj;
362 }
363 else {
364 VM_ASSERT(RB_TYPE_P(pathobj, T_ARRAY));
365 return RARRAY_AREF(pathobj, PATHOBJ_REALPATH);
366 }
367}
368
369/* Forward declarations */
370typedef uintptr_t iseq_bits_t;
371
372#define ISEQ_IS_SIZE(body) (body->ic_size + body->ivc_size + body->ise_size + body->icvarc_size)
373
374/* [ TS_IVC | TS_ICVARC | TS_ISE | TS_IC ] */
375#define ISEQ_IS_IC_ENTRY(body, idx) (body->is_entries[(idx) + body->ise_size + body->icvarc_size + body->ivc_size].ic_cache);
376
377/* instruction sequence type */
378enum rb_iseq_type {
379 ISEQ_TYPE_TOP,
380 ISEQ_TYPE_METHOD,
381 ISEQ_TYPE_BLOCK,
382 ISEQ_TYPE_CLASS,
383 ISEQ_TYPE_RESCUE,
384 ISEQ_TYPE_ENSURE,
385 ISEQ_TYPE_EVAL,
386 ISEQ_TYPE_MAIN,
387 ISEQ_TYPE_PLAIN
388};
389
390// Attributes specified by Primitive.attr!
391enum rb_builtin_attr {
392 // The iseq does not call methods.
393 BUILTIN_ATTR_LEAF = 0x01,
394 // This iseq only contains single `opt_invokebuiltin_delegate_leave` instruction with 0 arguments.
395 BUILTIN_ATTR_SINGLE_NOARG_LEAF = 0x02,
396 // This attribute signals JIT to duplicate the iseq for each block iseq so that its `yield` will be monomorphic.
397 BUILTIN_ATTR_INLINE_BLOCK = 0x04,
398 // The iseq acts like a C method in backtraces.
399 BUILTIN_ATTR_C_TRACE = 0x08,
400};
401
402typedef VALUE (*rb_jit_func_t)(struct rb_execution_context_struct *, struct rb_control_frame_struct *);
403typedef VALUE (*rb_zjit_func_t)(struct rb_execution_context_struct *, struct rb_control_frame_struct *, rb_jit_func_t);
404
406 enum rb_iseq_type type;
407
408 unsigned int iseq_size;
409 VALUE *iseq_encoded; /* encoded iseq (insn addr and operands) */
410
433
435 struct {
436 unsigned int has_lead : 1;
437 unsigned int has_opt : 1;
438 unsigned int has_rest : 1;
439 unsigned int has_post : 1;
440 unsigned int has_kw : 1;
441 unsigned int has_kwrest : 1;
442 unsigned int has_block : 1;
443
444 unsigned int ambiguous_param0 : 1; /* {|a|} */
445 unsigned int accepts_no_kwarg : 1;
446 unsigned int ruby2_keywords: 1;
447 unsigned int anon_rest: 1;
448 unsigned int anon_kwrest: 1;
449 unsigned int use_block: 1;
450 unsigned int forwardable: 1;
451 } flags;
452
453 unsigned int size;
454
455 int lead_num;
456 int opt_num;
457 int rest_start;
458 int post_start;
459 int post_num;
460 int block_start;
461
462 const VALUE *opt_table; /* (opt_num + 1) entries. */
463 /* opt_num and opt_table:
464 *
465 * def foo o1=e1, o2=e2, ..., oN=eN
466 * #=>
467 * # prologue code
468 * A1: e1
469 * A2: e2
470 * ...
471 * AN: eN
472 * AL: body
473 * opt_num = N
474 * opt_table = [A1, A2, ..., AN, AL]
475 */
476
478 int num;
479 int required_num;
480 int bits_start;
481 int rest_start;
482 const ID *table;
483 VALUE *default_values;
484 } *keyword;
485 } param;
486
487 rb_iseq_location_t location;
488
489 /* insn info, must be freed */
491 const struct iseq_insn_info_entry *body;
492 unsigned int *positions;
493 unsigned int size;
494#if VM_INSN_INFO_TABLE_IMPL == 2
495 struct succ_index_table *succ_index_table;
496#endif
497 } insns_info;
498
499 const ID *local_table; /* must free */
500
501 enum lvar_state {
502 lvar_uninitialized,
503 lvar_initialized,
504 lvar_reassigned,
505 } *lvar_states;
506
507 /* catch table */
508 struct iseq_catch_table *catch_table;
509
510 /* for child iseq */
511 const struct rb_iseq_struct *parent_iseq;
512 struct rb_iseq_struct *local_iseq; /* local_iseq->flip_cnt can be modified */
513
514 union iseq_inline_storage_entry *is_entries; /* [ TS_IVC | TS_ICVARC | TS_ISE | TS_IC ] */
515 struct rb_call_data *call_data; //struct rb_call_data calls[ci_size];
516
517 struct {
518 rb_snum_t flip_count;
519 VALUE script_lines;
520 VALUE coverage;
521 VALUE pc2branchindex;
522 VALUE *original_iseq;
523 } variable;
524
525 unsigned int local_table_size;
526 unsigned int ic_size; // Number of IC caches
527 unsigned int ise_size; // Number of ISE caches
528 unsigned int ivc_size; // Number of IVC caches
529 unsigned int icvarc_size; // Number of ICVARC caches
530 unsigned int ci_size;
531 unsigned int stack_max; /* for stack overflow check */
532
533 unsigned int builtin_attrs; // Union of rb_builtin_attr
534
535 bool prism; // ISEQ was generated from prism compiler
536
537 // Set once an EP escape of this iseq has been reported to the enabled JIT.
538 rb_atomic_t jit_ep_escape_recorded;
539
540 union {
541 iseq_bits_t * list; /* Find references for GC */
542 iseq_bits_t single;
543 } mark_bits;
544
545 struct rb_id_table *outer_variables;
546
547 const rb_iseq_t *mandatory_only_iseq;
548
549#if USE_YJIT || USE_ZJIT
550 // Function pointer for JIT code on jit_exec()
551 rb_jit_func_t jit_entry;
552 // Number of calls on jit_exec()
553 long unsigned jit_entry_calls;
554 // Function pointer for JIT code on jit_exec_exception()
555 rb_jit_func_t jit_exception;
556 // Number of calls on jit_exec_exception()
557 long unsigned jit_exception_calls;
558#endif
559
560#if USE_YJIT
561 // YJIT stores some data on each iseq.
562 void *yjit_payload;
563 // Used to estimate how frequently this ISEQ gets called
564 uint64_t yjit_calls_at_interv;
565#endif
566
567#if USE_ZJIT
568 // ZJIT stores some data on each iseq.
569 void *zjit_payload;
570#endif
571};
572
573/* T_IMEMO/iseq */
574/* typedef rb_iseq_t is in method.h */
576 VALUE flags; /* 1 */
577 VALUE wrapper; /* 2 */
578
579 struct rb_iseq_constant_body *body; /* 3 */
580
581 union { /* 4, 5 words */
582 struct iseq_compile_data *compile_data; /* used at compile time */
583
584 struct {
585 VALUE obj;
586 int index;
587 } loader;
588
589 struct {
590 unsigned int local_hooks_cnt;
591 rb_event_flag_t global_trace_events;
592 } exec;
593 } aux;
594};
595
596#define ISEQ_BODY(iseq) ((iseq)->body)
597
598#if !defined(USE_LAZY_LOAD) || !(USE_LAZY_LOAD+0)
599#define USE_LAZY_LOAD 0
600#endif
601
602#if !USE_LAZY_LOAD
603static inline const rb_iseq_t *rb_iseq_complete(const rb_iseq_t *iseq) {return 0;}
604#endif
605const rb_iseq_t *rb_iseq_complete(const rb_iseq_t *iseq);
606
607static inline const rb_iseq_t *
608rb_iseq_check(const rb_iseq_t *iseq)
609{
610 if (USE_LAZY_LOAD && ISEQ_BODY(iseq) == NULL) {
611 rb_iseq_complete((rb_iseq_t *)iseq);
612 }
613 return iseq;
614}
615
616static inline bool
617rb_iseq_attr_p(const rb_iseq_t *iseq, enum rb_builtin_attr attr)
618{
619 return (ISEQ_BODY(iseq)->builtin_attrs & attr) == attr;
620}
621
622static inline const rb_iseq_t *
623def_iseq_ptr(rb_method_definition_t *def)
624{
625//TODO: re-visit. to check the bug, enable this assertion.
626#if VM_CHECK_MODE > 0
627 if (def->type != VM_METHOD_TYPE_ISEQ) rb_bug("def_iseq_ptr: not iseq (%d)", def->type);
628#endif
629 return rb_iseq_check(def->body.iseq.iseqptr);
630}
631
632enum ruby_special_exceptions {
633 ruby_error_reenter,
634 ruby_error_nomemory,
635 ruby_error_sysstack,
636 ruby_error_stackfatal,
637 ruby_error_stream_closed,
638 ruby_special_error_count
639};
640
641#define GetVMPtr(obj, ptr) \
642 GetCoreDataFromValue((obj), rb_vm_t, (ptr))
643
644struct rb_vm_struct;
645typedef void rb_vm_at_exit_func(struct rb_vm_struct*);
646
647typedef struct rb_at_exit_list {
648 rb_vm_at_exit_func *func;
649 struct rb_at_exit_list *next;
651
652void *rb_objspace_alloc(void);
653void rb_objspace_free(void *objspace);
654void rb_objspace_call_finalizer(void);
655
656enum rb_hook_list_type {
657 hook_list_type_ractor_local,
658 hook_list_type_targeted_iseq,
659 hook_list_type_targeted_def, // C function
660 hook_list_type_global
661};
662
663typedef struct rb_hook_list_struct {
664 struct rb_event_hook_struct *hooks;
665 rb_event_flag_t events;
666 unsigned int running;
667 enum rb_hook_list_type type;
668 bool need_clean;
669} rb_hook_list_t;
670
671// see builtin.h for definition
672typedef const struct rb_builtin_function *RB_BUILTIN;
673
675 VALUE *varptr;
676 struct global_object_list *next;
677};
678
679typedef struct rb_vm_struct {
680 VALUE self;
681
682 struct {
683 struct ccan_list_head set;
684 unsigned int cnt;
685 unsigned int blocking_cnt;
686
687 struct rb_ractor_struct *main_ractor;
688 struct rb_thread_struct *main_thread; // == vm->ractor.main_ractor->threads.main
689
690 struct {
691 // monitor
692 rb_nativethread_lock_t lock;
693 struct rb_ractor_struct *lock_owner;
694 unsigned int lock_rec;
695
696 // join at exit
697 rb_nativethread_cond_t terminate_cond;
698 bool terminate_waiting;
699
700#ifndef RUBY_THREAD_PTHREAD_H
701 // win32
702 bool barrier_waiting;
703 unsigned int barrier_cnt;
704 rb_nativethread_cond_t barrier_complete_cond;
705 rb_nativethread_cond_t barrier_release_cond;
706#endif
707 } sync;
708
709#ifdef RUBY_THREAD_PTHREAD_H
710 // ractor scheduling
711 struct {
712 rb_nativethread_lock_t lock;
713 struct rb_ractor_struct *lock_owner;
714 bool locked;
715
716 rb_nativethread_cond_t cond; // GRQ
717 unsigned int snt_cnt; // count of shared NTs
718 unsigned int dnt_cnt; // count of dedicated NTs
719
720 unsigned int running_cnt;
721
722 unsigned int max_cpu;
723 struct ccan_list_head grq; // // Global Ready Queue
724 unsigned int grq_cnt;
725
726 // running threads
727 struct ccan_list_head running_threads;
728
729 // threads which switch context by timeslice
730 struct ccan_list_head timeslice_threads;
731
732 struct ccan_list_head zombie_threads;
733
734 // true if timeslice timer is not enable
735 bool timeslice_wait_inf;
736
737 // barrier
738 rb_nativethread_cond_t barrier_complete_cond;
739 rb_nativethread_cond_t barrier_release_cond;
740 bool barrier_waiting;
741 unsigned int barrier_waiting_cnt;
742 unsigned int barrier_serial;
743 struct rb_ractor_struct *barrier_ractor;
744 unsigned int barrier_lock_rec;
745 } sched;
746#endif
747 } ractor;
748
749#ifdef USE_SIGALTSTACK
750 void *main_altstack;
751#endif
752
753 rb_serial_t fork_gen;
754
755 /* set in single-threaded processes only: */
756 volatile int ubf_async_safe;
757
758 unsigned int running: 1;
759 unsigned int thread_abort_on_exception: 1;
760 unsigned int thread_report_on_exception: 1;
761 unsigned int thread_ignore_deadlock: 1;
762
763 /* object management */
764 VALUE mark_object_ary;
766 const VALUE special_exceptions[ruby_special_error_count];
767
768 /* Ruby Box */
769 rb_box_t *master_box;
770 rb_box_t *root_box;
771 rb_box_t *main_box;
772
773 /* load */
774 // For running the init function of statically linked
775 // extensions when they are loaded
776 struct st_table *static_ext_inits;
777
778 /* signal */
779 struct {
780 VALUE cmd[RUBY_NSIG];
781 } trap_list;
782
783 /* hook (for internal events: NEWOBJ, FREEOBJ, GC events, etc.) */
784 rb_hook_list_t global_hooks;
785
786 /* postponed_job (async-signal-safe, and thread-safe) */
787 struct rb_postponed_job_queue *postponed_job_queue;
788
789 int src_encoding_index;
790
791 /* workqueue (thread-safe, NOT async-signal-safe) */
792 struct ccan_list_head workqueue; /* <=> rb_workqueue_job.jnode */
793 rb_nativethread_lock_t workqueue_lock;
794
795 VALUE orig_progname, progname;
796 VALUE coverages, me2counter;
797 int coverage_mode;
798
799 struct {
800 struct rb_objspace *objspace;
801 struct gc_mark_func_data_struct {
802 void *data;
803 void (*mark_func)(VALUE v, void *data);
804 } *mark_func_data;
805 } gc;
806
807 rb_at_exit_list *at_exit;
808
809 const struct rb_builtin_function *builtin_function_table;
810
811 st_table *ci_table;
812 struct rb_id_table *negative_cme_table;
813 st_table *overloaded_cme_table; // cme -> overloaded_cme
814 set_table *unused_block_warning_table;
815 set_table *cc_refinement_table;
816
817 // This id table contains a mapping from ID to ICs. It does this with ID
818 // keys and nested st_tables as values. The nested tables have ICs as keys
819 // and Qtrue as values. It is used when inline constant caches need to be
820 // invalidated or ISEQs are being freed.
821 struct rb_id_table *constant_cache;
822 ID inserting_constant_cache_id;
823
824#ifndef VM_GLOBAL_CC_CACHE_TABLE_SIZE
825#define VM_GLOBAL_CC_CACHE_TABLE_SIZE 1023
826#endif
827 const struct rb_callcache *global_cc_cache_table[VM_GLOBAL_CC_CACHE_TABLE_SIZE]; // vm_eval.c
828 bool global_cc_cache_table_used; // vm_eval.c
829
830#if defined(USE_VM_CLOCK) && USE_VM_CLOCK
831 uint32_t clock;
832#endif
833
834 /* params */
835 struct { /* size in byte */
836 size_t thread_vm_stack_size;
837 size_t thread_machine_stack_size;
838 size_t fiber_vm_stack_size;
839 size_t fiber_machine_stack_size;
840 } default_params;
841} rb_vm_t;
842
843extern bool ruby_vm_during_cleanup;
844
845/* default values */
846
847#define RUBY_VM_SIZE_ALIGN 4096
848
849#define RUBY_VM_THREAD_VM_STACK_SIZE ( 128 * 1024 * sizeof(VALUE)) /* 512 KB or 1024 KB */
850#define RUBY_VM_THREAD_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE)) /* 8 KB or 16 KB */
851#define RUBY_VM_THREAD_MACHINE_STACK_SIZE ( 128 * 1024 * sizeof(VALUE)) /* 512 KB or 1024 KB */
852#define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE)) /* 64 KB or 128 KB */
853
854#define RUBY_VM_FIBER_VM_STACK_SIZE ( 16 * 1024 * sizeof(VALUE)) /* 64 KB or 128 KB */
855#define RUBY_VM_FIBER_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE)) /* 8 KB or 16 KB */
856#define RUBY_VM_FIBER_MACHINE_STACK_SIZE ( 64 * 1024 * sizeof(VALUE)) /* 256 KB or 512 KB */
857#if defined(__powerpc64__) || defined(__ppc64__) // macOS has __ppc64__
858#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 32 * 1024 * sizeof(VALUE)) /* 128 KB or 256 KB */
859#else
860#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE)) /* 64 KB or 128 KB */
861#endif
862
863#if __has_feature(memory_sanitizer) || __has_feature(address_sanitizer) || __has_feature(leak_sanitizer)
864/* It seems sanitizers consume A LOT of machine stacks */
865#undef RUBY_VM_THREAD_MACHINE_STACK_SIZE
866#define RUBY_VM_THREAD_MACHINE_STACK_SIZE (1024 * 1024 * sizeof(VALUE))
867#undef RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN
868#define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN ( 512 * 1024 * sizeof(VALUE))
869#undef RUBY_VM_FIBER_MACHINE_STACK_SIZE
870#define RUBY_VM_FIBER_MACHINE_STACK_SIZE ( 256 * 1024 * sizeof(VALUE))
871#undef RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN
872#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 128 * 1024 * sizeof(VALUE))
873#endif
874
875#ifndef VM_DEBUG_BP_CHECK
876#define VM_DEBUG_BP_CHECK 0
877#endif
878
879#ifndef VM_DEBUG_VERIFY_METHOD_CACHE
880#define VM_DEBUG_VERIFY_METHOD_CACHE (VMDEBUG != 0)
881#endif
882
884 VALUE self;
885 const VALUE *ep;
886 union {
887 const rb_iseq_t *iseq;
888 const struct vm_ifunc *ifunc;
889 VALUE val;
890 } code;
891};
892
893enum rb_block_handler_type {
894 block_handler_type_iseq,
895 block_handler_type_ifunc,
896 block_handler_type_symbol,
897 block_handler_type_proc
898};
899
900enum rb_block_type {
901 block_type_iseq,
902 block_type_ifunc,
903 block_type_symbol,
904 block_type_proc
905};
906
907struct rb_block {
908 union {
909 struct rb_captured_block captured;
910 VALUE symbol;
911 VALUE proc;
912 } as;
913 enum rb_block_type type;
914};
915
917 const VALUE *pc; // cfp[0]
918 VALUE *sp; // cfp[1]
919 const rb_iseq_t *iseq; // cfp[2]
920 VALUE self; // cfp[3] / block[0]
921 const VALUE *ep; // cfp[4] / block[1]
922 const void *block_code; // cfp[5] / block[2] -- iseq, ifunc, or forwarded block handler
923 void *jit_return; // cfp[6] -- return address for JIT code
924#if VM_DEBUG_BP_CHECK
925 VALUE *bp_check; // cfp[7]
926#endif
927} rb_control_frame_t;
928
929extern const rb_data_type_t ruby_threadptr_data_type;
930
931static inline struct rb_thread_struct *
932rb_thread_ptr(VALUE thval)
933{
934 return (struct rb_thread_struct *)rb_check_typeddata(thval, &ruby_threadptr_data_type);
935}
936
937enum rb_thread_status {
938 THREAD_RUNNABLE,
939 THREAD_STOPPED,
940 THREAD_STOPPED_FOREVER,
941 THREAD_KILLED
942};
943
944#ifdef RUBY_JMP_BUF
945typedef RUBY_JMP_BUF rb_jmpbuf_t;
946#else
947typedef void *rb_jmpbuf_t[5];
948#endif
949
950/*
951 `rb_vm_tag_jmpbuf_t` type represents a buffer used to
952 long jump to a C frame associated with `rb_vm_tag`.
953
954 Use-site of `rb_vm_tag_jmpbuf_t` is responsible for calling the
955 following functions:
956 - `rb_vm_tag_jmpbuf_init` once `rb_vm_tag_jmpbuf_t` is allocated.
957 - `rb_vm_tag_jmpbuf_deinit` once `rb_vm_tag_jmpbuf_t` is no longer necessary.
958
959 `RB_VM_TAG_JMPBUF_GET` transforms a `rb_vm_tag_jmpbuf_t` into a
960 `rb_jmpbuf_t` to be passed to `rb_setjmp/rb_longjmp`.
961*/
962#if defined(__wasm__) && !defined(__EMSCRIPTEN__)
963/*
964 WebAssembly target with Asyncify-based SJLJ needs
965 to capture the execution context by unwind/rewind-ing
966 call frames into a jump buffer. The buffer space tends
967 to be considerably large unlike other architectures'
968 register-based buffers.
969 Therefore, we allocates the buffer on the heap on such
970 environments.
971*/
972typedef rb_jmpbuf_t *rb_vm_tag_jmpbuf_t;
973
974#define RB_VM_TAG_JMPBUF_GET(buf) (*buf)
975
976static inline void
977rb_vm_tag_jmpbuf_init(rb_vm_tag_jmpbuf_t *jmpbuf)
978{
979 *jmpbuf = ruby_xmalloc(sizeof(rb_jmpbuf_t));
980}
981
982static inline void
983rb_vm_tag_jmpbuf_deinit(const rb_vm_tag_jmpbuf_t *jmpbuf)
984{
985 ruby_xfree(*jmpbuf);
986}
987#else
988typedef rb_jmpbuf_t rb_vm_tag_jmpbuf_t;
989
990#define RB_VM_TAG_JMPBUF_GET(buf) (buf)
991
992static inline void
993rb_vm_tag_jmpbuf_init(rb_vm_tag_jmpbuf_t *jmpbuf)
994{
995 // no-op
996}
997
998static inline void
999rb_vm_tag_jmpbuf_deinit(const rb_vm_tag_jmpbuf_t *jmpbuf)
1000{
1001 // no-op
1002}
1003#endif
1004
1005/*
1006 the members which are written in EC_PUSH_TAG() should be placed at
1007 the beginning and the end, so that entire region is accessible.
1008*/
1010 VALUE tag;
1011 VALUE retval;
1012 rb_vm_tag_jmpbuf_t buf;
1013 struct rb_vm_tag *prev;
1014 enum ruby_tag_type state;
1015 unsigned int lock_rec;
1016};
1017
1018STATIC_ASSERT(rb_vm_tag_buf_offset, offsetof(struct rb_vm_tag, buf) > 0);
1019STATIC_ASSERT(rb_vm_tag_buf_end,
1020 offsetof(struct rb_vm_tag, buf) + sizeof(rb_vm_tag_jmpbuf_t) <
1021 sizeof(struct rb_vm_tag));
1022
1025 void *arg;
1026};
1027
1028struct rb_mutex_struct;
1029
1030typedef struct rb_fiber_struct rb_fiber_t;
1031
1033 struct rb_waiting_list *next;
1034 struct rb_thread_struct *thread;
1035 struct rb_fiber_struct *fiber;
1036};
1037
1039 /* execution information */
1040 VALUE *vm_stack; /* must free, must mark */
1041 size_t vm_stack_size; /* size in word (byte size / sizeof(VALUE)) */
1042 rb_control_frame_t *cfp;
1043
1044 struct rb_vm_tag *tag;
1045
1046 /* interrupt flags */
1047 rb_atomic_t interrupt_flag;
1048 rb_atomic_t interrupt_mask; /* size should match flag */
1049#if defined(USE_VM_CLOCK) && USE_VM_CLOCK
1050 uint32_t checked_clock;
1051#endif
1052
1053 rb_fiber_t *fiber_ptr;
1054 struct rb_thread_struct *thread_ptr;
1055 rb_serial_t serial;
1056 rb_serial_t ractor_id;
1057
1058 /* storage (ec (fiber) local) */
1059 struct rb_id_table *local_storage;
1060 VALUE local_storage_recursive_hash;
1061 VALUE local_storage_recursive_hash_for_trace;
1062
1063 /* Inheritable fiber storage. */
1064 VALUE storage;
1065
1066 /* eval env */
1067 const VALUE *root_lep;
1068 VALUE root_svar;
1069
1070 /* trace information */
1071 struct rb_trace_arg_struct *trace_arg;
1072
1073 /* temporary places */
1074 VALUE errinfo;
1075 VALUE passed_block_handler; /* for rb_iterate */
1076
1077 uint8_t raised_flag; /* only 3 bits needed */
1078
1079 /* n.b. only 7 bits needed, really: */
1080 BITFIELD(enum method_missing_reason, method_missing_reason, 8);
1081
1082 VALUE private_const_reference;
1083
1084 struct {
1085 VALUE obj;
1086 VALUE fields_obj;
1087 } gen_fields_cache;
1088
1089 /* for GC */
1090 struct {
1091 VALUE *stack_start;
1092 VALUE *stack_end;
1093 size_t stack_maxsize;
1094 RUBY_ALIGNAS(SIZEOF_VALUE) jmp_buf regs;
1095
1096#ifdef RUBY_ASAN_ENABLED
1097 void *asan_fake_stack_handle;
1098#endif
1099 } machine;
1100};
1101
1102#ifndef rb_execution_context_t
1103typedef struct rb_execution_context_struct rb_execution_context_t;
1104#define rb_execution_context_t rb_execution_context_t
1105#endif
1106
1107// for builtin.h
1108#define VM_CORE_H_EC_DEFINED 1
1109
1110// Set the vm_stack pointer in the execution context.
1111void rb_ec_set_vm_stack(rb_execution_context_t *ec, VALUE *stack, size_t size);
1112
1113// Initialize the vm_stack pointer in the execution context and push the initial stack frame.
1114// @param ec the execution context to update.
1115// @param stack a pointer to the stack to use.
1116// @param size the size of the stack, as in `VALUE stack[size]`.
1117void rb_ec_initialize_vm_stack(rb_execution_context_t *ec, VALUE *stack, size_t size);
1118
1119// Clear (set to `NULL`) the vm_stack pointer.
1120// @param ec the execution context to update.
1121void rb_ec_clear_vm_stack(rb_execution_context_t *ec);
1122
1123// Close an execution context and free related resources that are no longer needed.
1124// @param ec the execution context to close.
1125void rb_ec_close(rb_execution_context_t *ec);
1126
1128 bool ractor_safe;
1129};
1130
1131typedef struct rb_ractor_struct rb_ractor_t;
1132
1133struct rb_native_thread;
1134
1135typedef struct rb_thread_struct {
1136 struct ccan_list_node lt_node; // managed by a ractor (r->threads.set)
1137 VALUE self;
1138 rb_ractor_t *ractor;
1139 rb_vm_t *vm;
1140 struct rb_native_thread *nt;
1141 rb_execution_context_t *ec;
1142
1143 struct rb_thread_sched_item sched;
1144 bool mn_schedulable;
1145 rb_atomic_t serial; // only for RUBY_DEBUG_LOG()
1146
1147 VALUE last_status; /* $? */
1148
1149 /* for cfunc */
1150 struct rb_calling_info *calling;
1151
1152 /* for load(true) */
1153 VALUE top_self;
1154 VALUE top_wrapper;
1155
1156 /* thread control */
1157
1158 BITFIELD(enum rb_thread_status, status, 2);
1159 /* bit flags */
1160 unsigned int has_dedicated_nt : 1;
1161 unsigned int to_kill : 1;
1162 unsigned int abort_on_exception: 1;
1163 unsigned int report_on_exception: 1;
1164 unsigned int pending_interrupt_queue_checked: 1;
1165 int8_t priority; /* -3 .. 3 (RUBY_THREAD_PRIORITY_{MIN,MAX}) */
1166 uint32_t running_time_us; /* 12500..800000 */
1167
1168 void *blocking_region_buffer;
1169
1170 VALUE thgroup;
1171 VALUE value;
1172
1173 /* temporary place of retval on OPT_CALL_THREADED_CODE */
1174#if OPT_CALL_THREADED_CODE
1175 VALUE retval;
1176#endif
1177
1178 /* async errinfo queue */
1179 VALUE pending_interrupt_queue;
1180 VALUE pending_interrupt_mask_stack;
1181
1182 /* interrupt management */
1183 rb_nativethread_lock_t interrupt_lock;
1184 struct rb_unblock_callback unblock;
1185 VALUE locking_mutex;
1186 struct rb_mutex_struct *keeping_mutexes;
1187 struct ccan_list_head interrupt_exec_tasks;
1188
1189 struct rb_waiting_list *join_list;
1190
1191 union {
1192 struct {
1193 VALUE proc;
1194 VALUE args;
1195 int kw_splat;
1196 } proc;
1197 struct {
1198 VALUE (*func)(void *);
1199 void *arg;
1200 } func;
1201 } invoke_arg;
1202
1203 enum thread_invoke_type {
1204 thread_invoke_type_none = 0,
1205 thread_invoke_type_proc,
1206 thread_invoke_type_ractor_proc,
1207 thread_invoke_type_func
1208 } invoke_type;
1209
1210 /* fiber */
1211 rb_fiber_t *root_fiber;
1212
1213 VALUE scheduler;
1214 unsigned int blocking;
1215
1216 /* misc */
1217 VALUE name;
1218 void **specific_storage;
1219
1220 struct rb_ext_config ext_config;
1221} rb_thread_t;
1222
1223static inline unsigned int
1224rb_th_serial(const rb_thread_t *th)
1225{
1226 return th ? (unsigned int)th->serial : 0;
1227}
1228
1229typedef enum {
1230 VM_DEFINECLASS_TYPE_CLASS = 0x00,
1231 VM_DEFINECLASS_TYPE_SINGLETON_CLASS = 0x01,
1232 VM_DEFINECLASS_TYPE_MODULE = 0x02,
1233 /* 0x03..0x06 is reserved */
1234 VM_DEFINECLASS_TYPE_MASK = 0x07
1235} rb_vm_defineclass_type_t;
1236
1237#define VM_DEFINECLASS_TYPE(x) ((rb_vm_defineclass_type_t)(x) & VM_DEFINECLASS_TYPE_MASK)
1238#define VM_DEFINECLASS_FLAG_SCOPED 0x08
1239#define VM_DEFINECLASS_FLAG_HAS_SUPERCLASS 0x10
1240#define VM_DEFINECLASS_SCOPED_P(x) ((x) & VM_DEFINECLASS_FLAG_SCOPED)
1241#define VM_DEFINECLASS_HAS_SUPERCLASS_P(x) \
1242 ((x) & VM_DEFINECLASS_FLAG_HAS_SUPERCLASS)
1243
1244/* iseq.c */
1245RUBY_SYMBOL_EXPORT_BEGIN
1246
1247/* node -> iseq */
1248rb_iseq_t *rb_iseq_new (const VALUE ast_value, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, enum rb_iseq_type);
1249rb_iseq_t *rb_iseq_new_top (const VALUE ast_value, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent);
1250rb_iseq_t *rb_iseq_new_main (const VALUE ast_value, VALUE path, VALUE realpath, const rb_iseq_t *parent, int opt);
1251rb_iseq_t *rb_iseq_new_eval (const VALUE ast_value, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth);
1252rb_iseq_t *rb_iseq_new_with_opt( VALUE ast_value, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth,
1253 enum rb_iseq_type, const rb_compile_option_t*,
1254 VALUE script_lines);
1255
1256struct iseq_link_anchor;
1258 VALUE flags;
1259 VALUE reserved;
1260 void (*func)(rb_iseq_t *, struct iseq_link_anchor *, const void *);
1261 const void *data;
1262};
1263static inline struct rb_iseq_new_with_callback_callback_func *
1264rb_iseq_new_with_callback_new_callback(
1265 void (*func)(rb_iseq_t *, struct iseq_link_anchor *, const void *), const void *ptr)
1266{
1268 IMEMO_NEW(struct rb_iseq_new_with_callback_callback_func, imemo_ifunc, Qfalse);
1269 memo->func = func;
1270 memo->data = ptr;
1271
1272 return memo;
1273}
1274rb_iseq_t *rb_iseq_new_with_callback(const struct rb_iseq_new_with_callback_callback_func * ifunc,
1275 VALUE name, VALUE path, VALUE realpath, int first_lineno,
1276 const rb_iseq_t *parent, enum rb_iseq_type, const rb_compile_option_t*);
1277
1278VALUE rb_iseq_disasm(const rb_iseq_t *iseq);
1279int rb_iseq_disasm_insn(VALUE str, const VALUE *iseqval, size_t pos, const rb_iseq_t *iseq, VALUE child);
1280
1281VALUE rb_iseq_coverage(const rb_iseq_t *iseq);
1282
1283RUBY_EXTERN VALUE rb_cISeq;
1284RUBY_EXTERN VALUE rb_cRubyVM;
1285RUBY_EXTERN VALUE rb_mRubyVMFrozenCore;
1286RUBY_EXTERN VALUE rb_block_param_proxy;
1287RUBY_SYMBOL_EXPORT_END
1288
1289#define GetProcPtr(obj, ptr) \
1290 GetCoreDataFromValue((obj), rb_proc_t, (ptr))
1291
1292typedef struct {
1293 const struct rb_block block;
1294 unsigned int is_from_method: 1; /* bool */
1295 unsigned int is_lambda: 1; /* bool */
1296 unsigned int is_isolated: 1; /* bool */
1297} rb_proc_t;
1298
1299RUBY_SYMBOL_EXPORT_BEGIN
1300VALUE rb_proc_isolate(VALUE self);
1301VALUE rb_proc_isolate_bang(VALUE self, VALUE replace_self);
1302VALUE rb_proc_ractor_make_shareable(VALUE proc, VALUE replace_self);
1303RUBY_SYMBOL_EXPORT_END
1304
1305typedef struct {
1306 VALUE flags; /* imemo header */
1307 rb_iseq_t *iseq;
1308 const VALUE *ep;
1309 const VALUE *env;
1310 unsigned int env_size;
1311} rb_env_t;
1312
1313extern const rb_data_type_t ruby_binding_data_type;
1314
1315#define GetBindingPtr(obj, ptr) \
1316 GetCoreDataFromValue((obj), rb_binding_t, (ptr))
1317
1318typedef struct {
1319 const struct rb_block block;
1320 const VALUE pathobj;
1321 int first_lineno;
1322} rb_binding_t;
1323
1324/* used by compile time and send insn */
1325
1326enum vm_check_match_type {
1327 VM_CHECKMATCH_TYPE_WHEN = 1,
1328 VM_CHECKMATCH_TYPE_CASE = 2,
1329 VM_CHECKMATCH_TYPE_RESCUE = 3
1330};
1331
1332#define VM_CHECKMATCH_TYPE_MASK 0x03
1333#define VM_CHECKMATCH_ARRAY 0x04
1334
1335enum vm_opt_newarray_send_type {
1336 VM_OPT_NEWARRAY_SEND_MAX = 1,
1337 VM_OPT_NEWARRAY_SEND_MIN = 2,
1338 VM_OPT_NEWARRAY_SEND_HASH = 3,
1339 VM_OPT_NEWARRAY_SEND_PACK = 4,
1340 VM_OPT_NEWARRAY_SEND_PACK_BUFFER = 5,
1341 VM_OPT_NEWARRAY_SEND_INCLUDE_P = 6,
1342};
1343
1344enum vm_special_object_type {
1345 VM_SPECIAL_OBJECT_VMCORE = 1,
1346 VM_SPECIAL_OBJECT_CBASE,
1347 VM_SPECIAL_OBJECT_CONST_BASE
1348};
1349
1350enum vm_svar_index {
1351 VM_SVAR_LASTLINE = 0, /* $_ */
1352 VM_SVAR_BACKREF = 1, /* $~ */
1353
1354 VM_SVAR_EXTRA_START = 2,
1355 VM_SVAR_FLIPFLOP_START = 2 /* flipflop */
1356};
1357
1358/* inline cache */
1359typedef struct iseq_inline_constant_cache *IC;
1360typedef struct iseq_inline_iv_cache_entry *IVC;
1361typedef struct iseq_inline_cvar_cache_entry *ICVARC;
1362typedef union iseq_inline_storage_entry *ISE;
1363typedef const struct rb_callinfo *CALL_INFO;
1364typedef const struct rb_callcache *CALL_CACHE;
1365typedef struct rb_call_data *CALL_DATA;
1366
1367typedef VALUE CDHASH;
1368
1369#ifndef FUNC_FASTCALL
1370#define FUNC_FASTCALL(x) x
1371#endif
1372
1373typedef rb_control_frame_t *
1374 (FUNC_FASTCALL(*rb_insn_func_t))(rb_execution_context_t *, rb_control_frame_t *);
1375
1376#define VM_TAGGED_PTR_SET(p, tag) ((VALUE)(p) | (tag))
1377#define VM_TAGGED_PTR_REF(v, mask) ((void *)((v) & ~mask))
1378
1379#define GC_GUARDED_PTR(p) VM_TAGGED_PTR_SET((p), 0x01)
1380#define GC_GUARDED_PTR_REF(p) VM_TAGGED_PTR_REF((p), 0x03)
1381#define GC_GUARDED_PTR_P(p) (((VALUE)(p)) & 0x01)
1382
1383enum vm_frame_env_flags {
1384 /* Frame/Environment flag bits:
1385 * MMMM MMMM MMMM MMMM ___F FFFF FFFE EEEX (LSB)
1386 *
1387 * X : tag for GC marking (It seems as Fixnum)
1388 * EEE : 4 bits Env flags
1389 * FF..: 8 bits Frame flags
1390 * MM..: 15 bits frame magic (to check frame corruption)
1391 */
1392
1393 /* frame types */
1394 VM_FRAME_MAGIC_METHOD = 0x11110001,
1395 VM_FRAME_MAGIC_BLOCK = 0x22220001,
1396 VM_FRAME_MAGIC_CLASS = 0x33330001,
1397 VM_FRAME_MAGIC_TOP = 0x44440001,
1398 VM_FRAME_MAGIC_CFUNC = 0x55550001,
1399 VM_FRAME_MAGIC_IFUNC = 0x66660001,
1400 VM_FRAME_MAGIC_EVAL = 0x77770001,
1401 VM_FRAME_MAGIC_RESCUE = 0x78880001,
1402 VM_FRAME_MAGIC_DUMMY = 0x79990001,
1403
1404 VM_FRAME_MAGIC_MASK = 0x7fff0001,
1405
1406 /* frame flag */
1407 VM_FRAME_FLAG_FINISH = 0x0020,
1408 VM_FRAME_FLAG_BMETHOD = 0x0040,
1409 VM_FRAME_FLAG_CFRAME = 0x0080,
1410 VM_FRAME_FLAG_LAMBDA = 0x0100,
1411 VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM = 0x0200,
1412 VM_FRAME_FLAG_CFRAME_KW = 0x0400,
1413 VM_FRAME_FLAG_PASSED = 0x0800,
1414 VM_FRAME_FLAG_BOX_REQUIRE = 0x1000,
1415
1416 /* env flag */
1417 VM_ENV_FLAG_LOCAL = 0x0002,
1418 VM_ENV_FLAG_ESCAPED = 0x0004,
1419 VM_ENV_FLAG_WB_REQUIRED = 0x0008,
1420 VM_ENV_FLAG_ISOLATED = 0x0010,
1421};
1422
1423#define VM_ENV_DATA_SIZE ( 3)
1424
1425#define VM_ENV_DATA_INDEX_ME_CREF (-2) /* ep[-2] */
1426#define VM_ENV_DATA_INDEX_SPECVAL (-1) /* ep[-1] */
1427#define VM_ENV_DATA_INDEX_FLAGS ( 0) /* ep[ 0] */
1428#define VM_ENV_DATA_INDEX_ENV ( 1) /* ep[ 1] */
1429
1430#define VM_ENV_INDEX_LAST_LVAR (-VM_ENV_DATA_SIZE)
1431
1432static inline void VM_FORCE_WRITE_SPECIAL_CONST(const VALUE *ptr, VALUE special_const_value);
1433
1434static inline void
1435VM_ENV_FLAGS_SET(const VALUE *ep, VALUE flag)
1436{
1437 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
1438 VM_ASSERT(FIXNUM_P(flags));
1439 VM_FORCE_WRITE_SPECIAL_CONST(&ep[VM_ENV_DATA_INDEX_FLAGS], flags | flag);
1440}
1441
1442static inline void
1443VM_ENV_FLAGS_UNSET(const VALUE *ep, VALUE flag)
1444{
1445 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
1446 VM_ASSERT(FIXNUM_P(flags));
1447 VM_FORCE_WRITE_SPECIAL_CONST(&ep[VM_ENV_DATA_INDEX_FLAGS], flags & ~flag);
1448}
1449
1450static inline unsigned long
1451VM_ENV_FLAGS(const VALUE *ep, long flag)
1452{
1453 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
1454 VM_ASSERT(FIXNUM_P(flags));
1455 return flags & flag;
1456}
1457
1458static inline unsigned long
1459VM_ENV_FLAGS_UNCHECKED(const VALUE *ep, long flag)
1460{
1461 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
1462 return flags & flag;
1463}
1464
1465static inline unsigned long
1466VM_ENV_FRAME_TYPE_P(const VALUE *ep, unsigned long frame_type)
1467{
1468 return VM_ENV_FLAGS(ep, VM_FRAME_MAGIC_MASK) == frame_type;
1469}
1470
1471static inline unsigned long
1472VM_FRAME_TYPE(const rb_control_frame_t *cfp)
1473{
1474 return VM_ENV_FLAGS(cfp->ep, VM_FRAME_MAGIC_MASK);
1475}
1476
1477static inline unsigned long
1478VM_FRAME_TYPE_UNCHECKED(const rb_control_frame_t *cfp)
1479{
1480 return VM_ENV_FLAGS_UNCHECKED(cfp->ep, VM_FRAME_MAGIC_MASK);
1481}
1482
1483static inline int
1484VM_FRAME_LAMBDA_P(const rb_control_frame_t *cfp)
1485{
1486 return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_LAMBDA) != 0;
1487}
1488
1489static inline int
1490VM_FRAME_CFRAME_KW_P(const rb_control_frame_t *cfp)
1491{
1492 return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_CFRAME_KW) != 0;
1493}
1494
1495static inline int
1496VM_FRAME_FINISHED_P(const rb_control_frame_t *cfp)
1497{
1498 return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_FINISH) != 0;
1499}
1500
1501static inline int
1502VM_FRAME_FINISHED_P_UNCHECKED(const rb_control_frame_t *cfp)
1503{
1504 return VM_ENV_FLAGS_UNCHECKED(cfp->ep, VM_FRAME_FLAG_FINISH) != 0;
1505}
1506
1507static inline int
1508VM_FRAME_BMETHOD_P(const rb_control_frame_t *cfp)
1509{
1510 return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_BMETHOD) != 0;
1511}
1512
1513static inline int
1514rb_obj_is_iseq(VALUE iseq)
1515{
1516 return imemo_type_p(iseq, imemo_iseq);
1517}
1518
1519#if VM_CHECK_MODE > 0
1520#define RUBY_VM_NORMAL_ISEQ_P(iseq) rb_obj_is_iseq((VALUE)iseq)
1521#endif
1522
1523static inline int
1524VM_FRAME_CFRAME_P(const rb_control_frame_t *cfp)
1525{
1526 int cframe_p = VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_CFRAME) != 0;
1527 VM_ASSERT(RUBY_VM_NORMAL_ISEQ_P(cfp->iseq) != cframe_p ||
1528 (VM_FRAME_TYPE(cfp) & VM_FRAME_MAGIC_MASK) == VM_FRAME_MAGIC_DUMMY);
1529 return cframe_p;
1530}
1531
1532static inline int
1533VM_FRAME_CFRAME_P_UNCHECKED(const rb_control_frame_t *cfp)
1534{
1535 return VM_ENV_FLAGS_UNCHECKED(cfp->ep, VM_FRAME_FLAG_CFRAME) != 0;
1536}
1537
1538static inline int
1539VM_FRAME_RUBYFRAME_P(const rb_control_frame_t *cfp)
1540{
1541 return !VM_FRAME_CFRAME_P(cfp);
1542}
1543
1544static inline int
1545VM_FRAME_RUBYFRAME_P_UNCHECKED(const rb_control_frame_t *cfp)
1546{
1547 return !VM_FRAME_CFRAME_P_UNCHECKED(cfp);
1548}
1549
1550static inline int
1551VM_FRAME_NS_REQUIRE_P(const rb_control_frame_t *cfp)
1552{
1553 return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_BOX_REQUIRE) != 0;
1554}
1555
1556#define RUBYVM_CFUNC_FRAME_P(cfp) \
1557 (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC)
1558
1559#define VM_GUARDED_PREV_EP(ep) GC_GUARDED_PTR(ep)
1560#define VM_BLOCK_HANDLER_NONE 0
1561
1562static inline int
1563VM_ENV_LOCAL_P(const VALUE *ep)
1564{
1565 return VM_ENV_FLAGS(ep, VM_ENV_FLAG_LOCAL) ? 1 : 0;
1566}
1567
1568static inline int
1569VM_ENV_LOCAL_P_UNCHECKED(const VALUE *ep)
1570{
1571 return VM_ENV_FLAGS_UNCHECKED(ep, VM_ENV_FLAG_LOCAL) ? 1 : 0;
1572}
1573
1574static inline const VALUE *
1575VM_ENV_PREV_EP_UNCHECKED(const VALUE *ep)
1576{
1577 return GC_GUARDED_PTR_REF(ep[VM_ENV_DATA_INDEX_SPECVAL]);
1578}
1579
1580static inline const VALUE *
1581VM_ENV_PREV_EP(const VALUE *ep)
1582{
1583 VM_ASSERT(VM_ENV_LOCAL_P(ep) == 0);
1584 return VM_ENV_PREV_EP_UNCHECKED(ep);
1585}
1586
1587static inline bool
1588VM_ENV_BOXED_P(const VALUE *ep)
1589{
1590 return VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_CLASS) || VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_TOP);
1591}
1592
1593static inline VALUE
1594VM_ENV_BLOCK_HANDLER(const VALUE *ep)
1595{
1596 if (VM_ENV_BOXED_P(ep)) {
1597 VM_ASSERT(VM_ENV_LOCAL_P(ep));
1598 return VM_BLOCK_HANDLER_NONE;
1599 }
1600
1601 VM_ASSERT(VM_ENV_LOCAL_P(ep));
1602 return ep[VM_ENV_DATA_INDEX_SPECVAL];
1603}
1604
1605static inline const rb_box_t *
1606VM_ENV_BOX(const VALUE *ep)
1607{
1608 VM_ASSERT(VM_ENV_BOXED_P(ep));
1609 VM_ASSERT(VM_ENV_LOCAL_P(ep));
1610 return (const rb_box_t *)GC_GUARDED_PTR_REF(ep[VM_ENV_DATA_INDEX_SPECVAL]);
1611}
1612
1613static inline const rb_box_t *
1614VM_ENV_BOX_UNCHECKED(const VALUE *ep)
1615{
1616 return (const rb_box_t *)GC_GUARDED_PTR_REF(ep[VM_ENV_DATA_INDEX_SPECVAL]);
1617}
1618
1619#if VM_CHECK_MODE > 0
1620int rb_vm_ep_in_heap_p(const VALUE *ep);
1621#endif
1622
1623static inline int
1624VM_ENV_ESCAPED_P(const VALUE *ep)
1625{
1626 VM_ASSERT(rb_vm_ep_in_heap_p(ep) == !!VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED));
1627 return VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED) ? 1 : 0;
1628}
1629
1631static inline VALUE
1632VM_ENV_ENVVAL(const VALUE *ep)
1633{
1634 VALUE envval = ep[VM_ENV_DATA_INDEX_ENV];
1635 VM_ASSERT(VM_ENV_ESCAPED_P(ep));
1636 VM_ASSERT(envval == Qundef || imemo_type_p(envval, imemo_env));
1637 return envval;
1638}
1639
1641static inline const rb_env_t *
1642VM_ENV_ENVVAL_PTR(const VALUE *ep)
1643{
1644 return (const rb_env_t *)VM_ENV_ENVVAL(ep);
1645}
1646
1647static inline const rb_env_t *
1648vm_env_new(VALUE *env_ep, VALUE *env_body, unsigned int env_size, const rb_iseq_t *iseq)
1649{
1650 rb_env_t *env = IMEMO_NEW(rb_env_t, imemo_env, (VALUE)iseq);
1651 env->ep = env_ep;
1652 env->env = env_body;
1653 env->env_size = env_size;
1654 env_ep[VM_ENV_DATA_INDEX_ENV] = (VALUE)env;
1655 return env;
1656}
1657
1658static inline void
1659VM_FORCE_WRITE(const VALUE *ptr, VALUE v)
1660{
1661 *((VALUE *)ptr) = v;
1662}
1663
1664static inline void
1665VM_FORCE_WRITE_SPECIAL_CONST(const VALUE *ptr, VALUE special_const_value)
1666{
1667 VM_ASSERT(RB_SPECIAL_CONST_P(special_const_value));
1668 VM_FORCE_WRITE(ptr, special_const_value);
1669}
1670
1671static inline void
1672VM_STACK_ENV_WRITE(const VALUE *ep, int index, VALUE v)
1673{
1674 VM_ASSERT(VM_ENV_FLAGS(ep, VM_ENV_FLAG_WB_REQUIRED) == 0);
1675 VM_FORCE_WRITE(&ep[index], v);
1676}
1677
1678const VALUE *rb_vm_ep_local_ep(const VALUE *ep);
1679const VALUE *rb_vm_proc_local_ep(VALUE proc);
1680void rb_vm_block_ep_update(VALUE obj, const struct rb_block *dst, const VALUE *ep);
1681void rb_vm_block_copy(VALUE obj, const struct rb_block *dst, const struct rb_block *src);
1682
1683VALUE rb_vm_frame_block_handler(const rb_control_frame_t *cfp);
1684
1685#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) ((cfp)+1)
1686#define RUBY_VM_NEXT_CONTROL_FRAME(cfp) ((cfp)-1)
1687
1688#define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp) \
1689 ((void *)(ecfp) > (void *)(cfp))
1690
1691static inline const rb_control_frame_t *
1692RUBY_VM_END_CONTROL_FRAME(const rb_execution_context_t *ec)
1693{
1694 return (rb_control_frame_t *)(ec->vm_stack + ec->vm_stack_size);
1695}
1696
1697static inline int
1698RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
1699{
1700 return !RUBY_VM_VALID_CONTROL_FRAME_P(cfp, RUBY_VM_END_CONTROL_FRAME(ec));
1701}
1702
1703static inline int
1704VM_BH_ISEQ_BLOCK_P(VALUE block_handler)
1705{
1706 if ((block_handler & 0x03) == 0x01) {
1707#if VM_CHECK_MODE > 0
1708 struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
1709 VM_ASSERT(imemo_type_p(captured->code.val, imemo_iseq));
1710#endif
1711 return 1;
1712 }
1713 else {
1714 return 0;
1715 }
1716}
1717
1718static inline VALUE
1719VM_BH_FROM_ISEQ_BLOCK(const struct rb_captured_block *captured)
1720{
1721 VALUE block_handler = VM_TAGGED_PTR_SET(captured, 0x01);
1722 VM_ASSERT(VM_BH_ISEQ_BLOCK_P(block_handler));
1723 return block_handler;
1724}
1725
1726static inline const struct rb_captured_block *
1727VM_BH_TO_ISEQ_BLOCK(VALUE block_handler)
1728{
1729 struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
1730 VM_ASSERT(VM_BH_ISEQ_BLOCK_P(block_handler));
1731 return captured;
1732}
1733
1734static inline int
1735VM_BH_IFUNC_P(VALUE block_handler)
1736{
1737 if ((block_handler & 0x03) == 0x03) {
1738#if VM_CHECK_MODE > 0
1739 struct rb_captured_block *captured = (void *)(block_handler & ~0x03);
1740 VM_ASSERT(imemo_type_p(captured->code.val, imemo_ifunc));
1741#endif
1742 return 1;
1743 }
1744 else {
1745 return 0;
1746 }
1747}
1748
1749static inline VALUE
1750VM_BH_FROM_IFUNC_BLOCK(const struct rb_captured_block *captured)
1751{
1752 VALUE block_handler = VM_TAGGED_PTR_SET(captured, 0x03);
1753 VM_ASSERT(VM_BH_IFUNC_P(block_handler));
1754 return block_handler;
1755}
1756
1757static inline const struct rb_captured_block *
1758VM_BH_TO_IFUNC_BLOCK(VALUE block_handler)
1759{
1760 struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
1761 VM_ASSERT(VM_BH_IFUNC_P(block_handler));
1762 return captured;
1763}
1764
1765static inline const struct rb_captured_block *
1766VM_BH_TO_CAPT_BLOCK(VALUE block_handler)
1767{
1768 struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
1769 VM_ASSERT(VM_BH_IFUNC_P(block_handler) || VM_BH_ISEQ_BLOCK_P(block_handler));
1770 return captured;
1771}
1772
1773static inline enum rb_block_handler_type
1774vm_block_handler_type(VALUE block_handler)
1775{
1776 if (VM_BH_ISEQ_BLOCK_P(block_handler)) {
1777 return block_handler_type_iseq;
1778 }
1779 else if (VM_BH_IFUNC_P(block_handler)) {
1780 return block_handler_type_ifunc;
1781 }
1782 else if (SYMBOL_P(block_handler)) {
1783 return block_handler_type_symbol;
1784 }
1785 else {
1786 VM_ASSERT(rb_obj_is_proc(block_handler));
1787 return block_handler_type_proc;
1788 }
1789}
1790
1791static inline void
1792vm_block_handler_verify(MAYBE_UNUSED(VALUE block_handler))
1793{
1794 VM_ASSERT(block_handler == VM_BLOCK_HANDLER_NONE ||
1795 (vm_block_handler_type(block_handler), 1));
1796}
1797
1798static inline enum rb_block_type
1799vm_block_type(const struct rb_block *block)
1800{
1801#if VM_CHECK_MODE > 0
1802 switch (block->type) {
1803 case block_type_iseq:
1804 VM_ASSERT(imemo_type_p(block->as.captured.code.val, imemo_iseq));
1805 break;
1806 case block_type_ifunc:
1807 VM_ASSERT(imemo_type_p(block->as.captured.code.val, imemo_ifunc));
1808 break;
1809 case block_type_symbol:
1810 VM_ASSERT(SYMBOL_P(block->as.symbol));
1811 break;
1812 case block_type_proc:
1813 VM_ASSERT(rb_obj_is_proc(block->as.proc));
1814 break;
1815 }
1816#endif
1817 return block->type;
1818}
1819
1820static inline void
1821vm_block_type_set(const struct rb_block *block, enum rb_block_type type)
1822{
1823 struct rb_block *mb = (struct rb_block *)block;
1824 mb->type = type;
1825}
1826
1827static inline const struct rb_block *
1828vm_proc_block(VALUE procval)
1829{
1830 VM_ASSERT(rb_obj_is_proc(procval));
1831 return &((rb_proc_t *)RTYPEDDATA_DATA(procval))->block;
1832}
1833
1834static inline const rb_iseq_t *vm_block_iseq(const struct rb_block *block);
1835static inline const VALUE *vm_block_ep(const struct rb_block *block);
1836
1837static inline const rb_iseq_t *
1838vm_proc_iseq(VALUE procval)
1839{
1840 return vm_block_iseq(vm_proc_block(procval));
1841}
1842
1843static inline const VALUE *
1844vm_proc_ep(VALUE procval)
1845{
1846 return vm_block_ep(vm_proc_block(procval));
1847}
1848
1849static inline const rb_iseq_t *
1850vm_block_iseq(const struct rb_block *block)
1851{
1852 switch (vm_block_type(block)) {
1853 case block_type_iseq: return rb_iseq_check(block->as.captured.code.iseq);
1854 case block_type_proc: return vm_proc_iseq(block->as.proc);
1855 case block_type_ifunc:
1856 case block_type_symbol: return NULL;
1857 }
1858 VM_UNREACHABLE(vm_block_iseq);
1859 return NULL;
1860}
1861
1862static inline const VALUE *
1863vm_block_ep(const struct rb_block *block)
1864{
1865 switch (vm_block_type(block)) {
1866 case block_type_iseq:
1867 case block_type_ifunc: return block->as.captured.ep;
1868 case block_type_proc: return vm_proc_ep(block->as.proc);
1869 case block_type_symbol: return NULL;
1870 }
1871 VM_UNREACHABLE(vm_block_ep);
1872 return NULL;
1873}
1874
1875static inline VALUE
1876vm_block_self(const struct rb_block *block)
1877{
1878 switch (vm_block_type(block)) {
1879 case block_type_iseq:
1880 case block_type_ifunc:
1881 return block->as.captured.self;
1882 case block_type_proc:
1883 return vm_block_self(vm_proc_block(block->as.proc));
1884 case block_type_symbol:
1885 return Qundef;
1886 }
1887 VM_UNREACHABLE(vm_block_self);
1888 return Qundef;
1889}
1890
1891static inline VALUE
1892VM_BH_TO_SYMBOL(VALUE block_handler)
1893{
1894 VM_ASSERT(SYMBOL_P(block_handler));
1895 return block_handler;
1896}
1897
1898static inline VALUE
1899VM_BH_FROM_SYMBOL(VALUE symbol)
1900{
1901 VM_ASSERT(SYMBOL_P(symbol));
1902 return symbol;
1903}
1904
1905static inline VALUE
1906VM_BH_TO_PROC(VALUE block_handler)
1907{
1908 VM_ASSERT(rb_obj_is_proc(block_handler));
1909 return block_handler;
1910}
1911
1912static inline VALUE
1913VM_BH_FROM_PROC(VALUE procval)
1914{
1915 VM_ASSERT(rb_obj_is_proc(procval));
1916 return procval;
1917}
1918
1919/* VM related object allocate functions */
1920VALUE rb_thread_alloc(VALUE klass);
1921VALUE rb_binding_alloc(VALUE klass);
1922VALUE rb_proc_alloc(VALUE klass);
1923VALUE rb_proc_dup(VALUE self);
1924
1925/* for debug */
1926extern bool rb_vmdebug_stack_dump_raw(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, FILE *);
1927extern bool rb_vmdebug_debug_print_pre(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, const VALUE *_pc, FILE *);
1928extern bool rb_vmdebug_debug_print_post(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, FILE *);
1929
1930#define SDR() rb_vmdebug_stack_dump_raw(GET_EC(), GET_EC()->cfp, stderr)
1931#define SDR2(cfp) rb_vmdebug_stack_dump_raw(GET_EC(), (cfp), stderr)
1932bool rb_vm_bugreport(const void *, FILE *);
1933typedef void (*ruby_sighandler_t)(int);
1934RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 4, 5)
1935NORETURN(void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *, const char *fmt, ...));
1936
1937/* functions about thread/vm execution */
1938RUBY_SYMBOL_EXPORT_BEGIN
1939VALUE rb_iseq_eval(const rb_iseq_t *iseq, const rb_box_t *box);
1940VALUE rb_iseq_eval_main(const rb_iseq_t *iseq);
1941VALUE rb_iseq_path(const rb_iseq_t *iseq);
1942VALUE rb_iseq_realpath(const rb_iseq_t *iseq);
1943RUBY_SYMBOL_EXPORT_END
1944
1945VALUE rb_iseq_pathobj_new(VALUE path, VALUE realpath);
1946void rb_iseq_pathobj_set(const rb_iseq_t *iseq, VALUE path, VALUE realpath);
1947
1948int rb_ec_frame_method_id_and_class(const rb_execution_context_t *ec, ID *idp, ID *called_idp, VALUE *klassp);
1949void rb_ec_setup_exception(const rb_execution_context_t *ec, VALUE mesg, VALUE cause);
1950
1951VALUE rb_vm_invoke_proc(rb_execution_context_t *ec, rb_proc_t *proc, int argc, const VALUE *argv, int kw_splat, VALUE block_handler);
1952
1953VALUE rb_vm_make_proc_lambda(const rb_execution_context_t *ec, const struct rb_captured_block *captured, VALUE klass, int8_t is_lambda);
1954static inline VALUE
1955rb_vm_make_proc(const rb_execution_context_t *ec, const struct rb_captured_block *captured, VALUE klass)
1956{
1957 return rb_vm_make_proc_lambda(ec, captured, klass, 0);
1958}
1959
1960static inline VALUE
1961rb_vm_make_lambda(const rb_execution_context_t *ec, const struct rb_captured_block *captured, VALUE klass)
1962{
1963 return rb_vm_make_proc_lambda(ec, captured, klass, 1);
1964}
1965
1966VALUE rb_vm_make_binding(const rb_execution_context_t *ec, const rb_control_frame_t *src_cfp);
1967VALUE rb_vm_env_local_variables(const rb_env_t *env);
1968VALUE rb_vm_env_numbered_parameters(const rb_env_t *env);
1969const rb_env_t *rb_vm_env_prev_env(const rb_env_t *env);
1970const VALUE *rb_binding_add_dynavars(VALUE bindval, rb_binding_t *bind, int dyncount, const ID *dynvars);
1971void rb_vm_inc_const_missing_count(void);
1972VALUE rb_vm_call_kw(rb_execution_context_t *ec, VALUE recv, VALUE id, int argc,
1973 const VALUE *argv, const rb_callable_method_entry_t *me, int kw_splat);
1974void rb_vm_pop_frame_no_int(rb_execution_context_t *ec);
1975void rb_vm_pop_frame(rb_execution_context_t *ec);
1976
1977void rb_thread_start_timer_thread(void);
1978void rb_thread_stop_timer_thread(void);
1979void rb_thread_reset_timer_thread(void);
1980void rb_thread_wakeup_timer_thread(int);
1981
1982static inline void
1983rb_vm_living_threads_init(rb_vm_t *vm)
1984{
1985 ccan_list_head_init(&vm->workqueue);
1986 ccan_list_head_init(&vm->ractor.set);
1987#ifdef RUBY_THREAD_PTHREAD_H
1988 ccan_list_head_init(&vm->ractor.sched.zombie_threads);
1989#endif
1990}
1991
1992typedef int rb_backtrace_iter_func(void *, VALUE, int, VALUE);
1993rb_control_frame_t *rb_vm_get_ruby_level_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp);
1994rb_control_frame_t *rb_vm_get_binding_creatable_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp);
1995VALUE *rb_vm_svar_lep(const rb_execution_context_t *ec, const rb_control_frame_t *cfp);
1996int rb_vm_get_sourceline(const rb_control_frame_t *);
1997void rb_vm_stack_to_heap(rb_execution_context_t *ec);
1998void ruby_thread_init_stack(rb_thread_t *th, void *local_in_parent_frame);
1999void rb_thread_malloc_stack_set(rb_thread_t *th, void *stack);
2000rb_thread_t * ruby_thread_from_native(void);
2001int ruby_thread_set_native(rb_thread_t *th);
2002int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp);
2003void rb_vm_rewind_cfp(rb_execution_context_t *ec, rb_control_frame_t *cfp);
2004void rb_vm_env_write(const VALUE *ep, int index, VALUE v);
2005VALUE rb_vm_bh_to_procval(const rb_execution_context_t *ec, VALUE block_handler);
2006
2007void rb_vm_register_special_exception_str(enum ruby_special_exceptions sp, VALUE exception_class, VALUE mesg);
2008
2009#define rb_vm_register_special_exception(sp, e, m) \
2010 rb_vm_register_special_exception_str(sp, e, rb_usascii_str_new_static((m), (long)rb_strlen_lit(m)))
2011
2012void rb_gc_mark_machine_context(const rb_execution_context_t *ec);
2013
2014rb_cref_t *rb_vm_rewrite_cref(rb_cref_t *node, VALUE old_klass, VALUE new_klass);
2015
2016const rb_callable_method_entry_t *rb_vm_frame_method_entry(const rb_control_frame_t *cfp);
2017const rb_callable_method_entry_t *rb_vm_frame_method_entry_unchecked(const rb_control_frame_t *cfp);
2018
2019#define sysstack_error GET_VM()->special_exceptions[ruby_error_sysstack]
2020
2021#define CHECK_VM_STACK_OVERFLOW0(cfp, sp, margin) do { \
2022 STATIC_ASSERT(sizeof_sp, sizeof(*(sp)) == sizeof(VALUE)); \
2023 STATIC_ASSERT(sizeof_cfp, sizeof(*(cfp)) == sizeof(rb_control_frame_t)); \
2024 const struct rb_control_frame_struct *bound = (void *)&(sp)[(margin)]; \
2025 if (UNLIKELY((cfp) <= &bound[1])) { \
2026 vm_stackoverflow(); \
2027 } \
2028} while (0)
2029
2030#define CHECK_VM_STACK_OVERFLOW(cfp, margin) \
2031 CHECK_VM_STACK_OVERFLOW0((cfp), (cfp)->sp, (margin))
2032
2033VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, enum ruby_tag_type *stateptr);
2034
2035rb_execution_context_t *rb_vm_main_ractor_ec(rb_vm_t *vm); // ractor.c
2036
2037/* for thread */
2038
2039#if RUBY_VM_THREAD_MODEL == 2
2040
2041RUBY_EXTERN struct rb_ractor_struct *ruby_single_main_ractor; // ractor.c
2042RUBY_EXTERN rb_vm_t *ruby_current_vm_ptr;
2043RUBY_EXTERN rb_event_flag_t ruby_vm_event_flags;
2044RUBY_EXTERN rb_event_flag_t ruby_vm_event_enabled_global_flags; // only ever added to
2045RUBY_EXTERN unsigned int ruby_vm_iseq_events_enabled;
2046RUBY_EXTERN unsigned int ruby_vm_c_events_enabled;
2047
2048#define GET_VM() rb_current_vm()
2049#define GET_RACTOR() rb_current_ractor()
2050#define GET_THREAD() rb_current_thread()
2051#define GET_EC() rb_current_execution_context(true)
2052
2053static inline rb_serial_t
2054rb_ec_serial(struct rb_execution_context_struct *ec)
2055{
2056 VM_ASSERT(ec->serial >= 1);
2057 return ec->serial;
2058}
2059
2060static inline rb_thread_t *
2061rb_ec_thread_ptr(const rb_execution_context_t *ec)
2062{
2063 return ec->thread_ptr;
2064}
2065
2066static inline rb_ractor_t *
2067rb_ec_ractor_ptr(const rb_execution_context_t *ec)
2068{
2069 const rb_thread_t *th = rb_ec_thread_ptr(ec);
2070 if (th) {
2071 VM_ASSERT(th->ractor != NULL);
2072 return th->ractor;
2073 }
2074 else {
2075 return NULL;
2076 }
2077}
2078
2079static inline rb_serial_t
2080rb_ec_ractor_id(const rb_execution_context_t *ec)
2081{
2082 rb_serial_t ractor_id = ec->ractor_id;
2083 RUBY_ASSERT(ractor_id);
2084 return ractor_id;
2085}
2086
2087static inline rb_vm_t *
2088rb_ec_vm_ptr(const rb_execution_context_t *ec)
2089{
2090 const rb_thread_t *th = rb_ec_thread_ptr(ec);
2091 if (th) {
2092 return th->vm;
2093 }
2094 else {
2095 return NULL;
2096 }
2097}
2098
2099NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void));
2100
2101static inline rb_execution_context_t *
2102rb_current_execution_context(bool expect_ec)
2103{
2104#ifdef RB_THREAD_LOCAL_SPECIFIER
2105 #ifdef RB_THREAD_CURRENT_EC_NOINLINE
2106 rb_execution_context_t * volatile ec = rb_current_ec();
2107 #else
2108 rb_execution_context_t * volatile ec = ruby_current_ec;
2109 #endif
2110
2111 /* On the shared objects, `__tls_get_addr()` is used to access the TLS
2112 * and the address of the `ruby_current_ec` can be stored on a function
2113 * frame. However, this address can be mis-used after native thread
2114 * migration of a coroutine.
2115 * 1) Get `ptr = &ruby_current_ec` on NT1 and store it on the frame.
2116 * 2) Context switch and resume it on the NT2.
2117 * 3) `ptr` is used on NT2 but it accesses the TLS of NT1.
2118 * This assertion checks such misusage.
2119 *
2120 * To avoid accidents, `GET_EC()` should be called once on the frame.
2121 * Note that inlining can produce the problem.
2122 */
2123 VM_ASSERT(ec == rb_current_ec_noinline());
2124#else
2125 rb_execution_context_t * volatile ec = native_tls_get(ruby_current_ec_key);
2126#endif
2127 VM_ASSERT(!expect_ec || ec != NULL);
2128 return ec;
2129}
2130
2131static inline rb_thread_t *
2132rb_current_thread(void)
2133{
2134 const rb_execution_context_t *ec = GET_EC();
2135 return rb_ec_thread_ptr(ec);
2136}
2137
2138static inline rb_ractor_t *
2139rb_current_ractor_raw(bool expect)
2140{
2141 if (ruby_single_main_ractor) {
2142 return ruby_single_main_ractor;
2143 }
2144 else {
2145 const rb_execution_context_t *ec = rb_current_execution_context(expect);
2146 return (expect || ec) ? rb_ec_ractor_ptr(ec) : NULL;
2147 }
2148}
2149
2150static inline rb_ractor_t *
2151rb_current_ractor(void)
2152{
2153 return rb_current_ractor_raw(true);
2154}
2155
2156static inline rb_vm_t *
2157rb_current_vm(void)
2158{
2159#if 0 // TODO: reconsider the assertions
2160 VM_ASSERT(ruby_current_vm_ptr == NULL ||
2161 ruby_current_execution_context_ptr == NULL ||
2162 rb_ec_thread_ptr(GET_EC()) == NULL ||
2163 rb_ec_thread_ptr(GET_EC())->status == THREAD_KILLED ||
2164 rb_ec_vm_ptr(GET_EC()) == ruby_current_vm_ptr);
2165#endif
2166
2167 return ruby_current_vm_ptr;
2168}
2169
2170void rb_ec_vm_lock_rec_release(const rb_execution_context_t *ec,
2171 unsigned int recorded_lock_rec,
2172 unsigned int current_lock_rec);
2173
2174/* This technically is a data race, as it's checked without the lock, however we
2175 * check against a value only our own thread will write. */
2176NO_SANITIZE("thread", static inline bool
2177vm_locked_by_ractor_p(rb_vm_t *vm, rb_ractor_t *cr))
2178{
2179 VM_ASSERT(cr == GET_RACTOR());
2180 return vm->ractor.sync.lock_owner == cr;
2181}
2182
2183static inline unsigned int
2184rb_ec_vm_lock_rec(const rb_execution_context_t *ec)
2185{
2186 rb_vm_t *vm = rb_ec_vm_ptr(ec);
2187
2188 if (!vm_locked_by_ractor_p(vm, rb_ec_ractor_ptr(ec))) {
2189 return 0;
2190 }
2191 else {
2192 return vm->ractor.sync.lock_rec;
2193 }
2194}
2195
2196#else
2197#error "unsupported thread model"
2198#endif
2199
2200enum {
2201 TIMER_INTERRUPT_MASK = 0x01,
2202 PENDING_INTERRUPT_MASK = 0x02,
2203 POSTPONED_JOB_INTERRUPT_MASK = 0x04,
2204 TRAP_INTERRUPT_MASK = 0x08,
2205 TERMINATE_INTERRUPT_MASK = 0x10,
2206 VM_BARRIER_INTERRUPT_MASK = 0x20,
2207};
2208
2209#define RUBY_VM_SET_TIMER_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, TIMER_INTERRUPT_MASK)
2210#define RUBY_VM_SET_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, PENDING_INTERRUPT_MASK)
2211#define RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, POSTPONED_JOB_INTERRUPT_MASK)
2212#define RUBY_VM_SET_TRAP_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, TRAP_INTERRUPT_MASK)
2213#define RUBY_VM_SET_TERMINATE_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, TERMINATE_INTERRUPT_MASK)
2214#define RUBY_VM_SET_VM_BARRIER_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, VM_BARRIER_INTERRUPT_MASK)
2215
2216static inline bool
2217RUBY_VM_INTERRUPTED(rb_execution_context_t *ec)
2218{
2219 return (ATOMIC_LOAD_RELAXED(ec->interrupt_flag) & ~(ec->interrupt_mask) & (PENDING_INTERRUPT_MASK|TRAP_INTERRUPT_MASK));
2220}
2221
2222static inline bool
2223RUBY_VM_INTERRUPTED_ANY(rb_execution_context_t *ec)
2224{
2225#if defined(USE_VM_CLOCK) && USE_VM_CLOCK
2226 uint32_t current_clock = rb_ec_vm_ptr(ec)->clock;
2227
2228 if (current_clock != ec->checked_clock) {
2229 ec->checked_clock = current_clock;
2230 RUBY_VM_SET_TIMER_INTERRUPT(ec);
2231 }
2232#endif
2233 return ATOMIC_LOAD_RELAXED(ec->interrupt_flag) & ~(ec)->interrupt_mask;
2234}
2235
2236VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt);
2237int rb_signal_buff_size(void);
2238int rb_signal_exec(rb_thread_t *th, int sig);
2239void rb_threadptr_check_signal(rb_thread_t *mth);
2240void rb_threadptr_signal_raise(rb_thread_t *th, int sig);
2241void rb_threadptr_interrupt_raise(rb_thread_t *th);
2242void rb_threadptr_signal_exit(rb_thread_t *th);
2243int rb_threadptr_execute_interrupts(rb_thread_t *, int);
2244void rb_threadptr_interrupt(rb_thread_t *th);
2245void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th);
2246void rb_threadptr_pending_interrupt_clear(rb_thread_t *th);
2247void rb_threadptr_pending_interrupt_enque(rb_thread_t *th, VALUE v);
2248VALUE rb_ec_get_errinfo(const rb_execution_context_t *ec);
2249void rb_ec_error_print(rb_execution_context_t * volatile ec, volatile VALUE errinfo);
2250void rb_execution_context_update(rb_execution_context_t *ec);
2251void rb_execution_context_mark(const rb_execution_context_t *ec);
2252void rb_fiber_close(rb_fiber_t *fib);
2253void Init_native_thread(rb_thread_t *th);
2254int rb_vm_check_ints_blocking(rb_execution_context_t *ec);
2255
2256// vm_sync.h
2257void rb_vm_cond_wait(rb_vm_t *vm, rb_nativethread_cond_t *cond);
2258void rb_vm_cond_timedwait(rb_vm_t *vm, rb_nativethread_cond_t *cond, unsigned long msec);
2259
2260#define RUBY_VM_CHECK_INTS(ec) rb_vm_check_ints(ec)
2261static inline void
2262rb_vm_check_ints(rb_execution_context_t *ec)
2263{
2264#ifdef RUBY_ASSERT_CRITICAL_SECTION
2265 VM_ASSERT(ruby_assert_critical_section_entered == 0);
2266#endif
2267
2268 VM_ASSERT(ec == rb_current_ec_noinline());
2269
2270 if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(ec))) {
2271 rb_threadptr_execute_interrupts(rb_ec_thread_ptr(ec), 0);
2272 }
2273}
2274
2275/* tracer */
2276
2278 rb_event_flag_t event;
2279 rb_execution_context_t *ec;
2280 const rb_control_frame_t *cfp;
2281 VALUE self;
2282 ID id;
2283 ID called_id;
2284 VALUE klass;
2285 VALUE data;
2286
2287 int klass_solved;
2288
2289 /* calc from cfp */
2290 int lineno;
2291 VALUE path;
2292};
2293
2294void rb_hook_list_mark(rb_hook_list_t *hooks);
2295void rb_hook_list_mark_and_move(rb_hook_list_t *hooks);
2296void rb_hook_list_free(rb_hook_list_t *hooks);
2297void rb_hook_list_connect_local_tracepoint(rb_hook_list_t *list, VALUE tpval, unsigned int target_line);
2298bool rb_hook_list_remove_local_tracepoint(rb_hook_list_t *list, VALUE tpval);
2299unsigned int rb_hook_list_count(rb_hook_list_t *list);
2300
2301void rb_exec_event_hooks(struct rb_trace_arg_struct *trace_arg, rb_hook_list_t *hooks, int pop_p);
2302
2303#define EXEC_EVENT_HOOK_ORIG(ec_, hooks_, flag_, self_, id_, called_id_, klass_, data_, pop_p_) do { \
2304 const rb_event_flag_t flag_arg_ = (flag_); \
2305 rb_hook_list_t *hooks_arg_ = (hooks_); \
2306 if (UNLIKELY((hooks_arg_)->events & (flag_arg_))) { \
2307 /* defer evaluating the other arguments */ \
2308 rb_exec_event_hook_orig(ec_, hooks_arg_, flag_arg_, self_, id_, called_id_, klass_, data_, pop_p_); \
2309 } \
2310} while (0)
2311
2312static inline void
2313rb_exec_event_hook_orig(rb_execution_context_t *ec, rb_hook_list_t *hooks, rb_event_flag_t flag,
2314 VALUE self, ID id, ID called_id, VALUE klass, VALUE data, int pop_p)
2315{
2316 struct rb_trace_arg_struct trace_arg;
2317
2318 VM_ASSERT((hooks->events & flag) != 0);
2319
2320 trace_arg.event = flag;
2321 trace_arg.ec = ec;
2322 trace_arg.cfp = ec->cfp;
2323 trace_arg.self = self;
2324 trace_arg.id = id;
2325 trace_arg.called_id = called_id;
2326 trace_arg.klass = klass;
2327 trace_arg.data = data;
2328 trace_arg.path = Qundef;
2329 trace_arg.klass_solved = 0;
2330
2331 rb_exec_event_hooks(&trace_arg, hooks, pop_p);
2332}
2333
2335 VALUE self;
2336 uint32_t id;
2337 rb_hook_list_t hooks;
2338 st_table *targeted_hooks; // also called "local hooks". {ISEQ => hook_list, def => hook_list...}
2339 unsigned int targeted_hooks_cnt; // ex: tp.enabled(target: method(:puts))
2340};
2341
2342static inline rb_hook_list_t *
2343rb_ec_ractor_hooks(const rb_execution_context_t *ec)
2344{
2345 struct rb_ractor_pub *cr_pub = (struct rb_ractor_pub *)rb_ec_ractor_ptr(ec);
2346 return &cr_pub->hooks;
2347}
2348
2349static inline rb_hook_list_t *
2350rb_vm_global_hooks(const rb_execution_context_t *ec)
2351{
2352 return &rb_ec_vm_ptr(ec)->global_hooks;
2353}
2354
2355static inline rb_hook_list_t *
2356rb_ec_hooks(const rb_execution_context_t *ec, rb_event_flag_t event)
2357{
2358 // Should be a single bit set
2359 VM_ASSERT(event != 0 && ((event - 1) & event) == 0);
2360
2362 return rb_vm_global_hooks(ec);
2363 }
2364 else {
2365 return rb_ec_ractor_hooks(ec);
2366 }
2367}
2368
2369#define EXEC_EVENT_HOOK(ec_, flag_, self_, id_, called_id_, klass_, data_) \
2370 EXEC_EVENT_HOOK_ORIG(ec_, rb_ec_hooks(ec_, flag_), flag_, self_, id_, called_id_, klass_, data_, 0)
2371
2372#define EXEC_EVENT_HOOK_AND_POP_FRAME(ec_, flag_, self_, id_, called_id_, klass_, data_) \
2373 EXEC_EVENT_HOOK_ORIG(ec_, rb_ec_hooks(ec_, flag_), flag_, self_, id_, called_id_, klass_, data_, 1)
2374
2375static inline void
2376rb_exec_event_hook_script_compiled(rb_execution_context_t *ec, const rb_iseq_t *iseq, VALUE eval_script)
2377{
2378 EXEC_EVENT_HOOK(ec, RUBY_EVENT_SCRIPT_COMPILED, ec->cfp->self, 0, 0, 0,
2379 NIL_P(eval_script) ? (VALUE)iseq :
2380 rb_ary_new_from_args(2, eval_script, (VALUE)iseq));
2381}
2382
2383void rb_vm_trap_exit(rb_vm_t *vm);
2384void rb_vm_postponed_job_atfork(void); /* vm_trace.c */
2385void rb_vm_postponed_job_free(void); /* vm_trace.c */
2386size_t rb_vm_memsize_postponed_job_queue(void); /* vm_trace.c */
2387void rb_vm_postponed_job_queue_init(rb_vm_t *vm); /* vm_trace.c */
2388
2389RUBY_SYMBOL_EXPORT_BEGIN
2390
2391int rb_thread_check_trap_pending(void);
2392
2393/* #define RUBY_EVENT_RESERVED_FOR_INTERNAL_USE 0x030000 */ /* from vm_core.h */
2394#define RUBY_EVENT_COVERAGE_LINE 0x010000
2395#define RUBY_EVENT_COVERAGE_BRANCH 0x020000
2396
2397extern VALUE rb_get_coverages(void);
2398extern void rb_set_coverages(VALUE, int, VALUE);
2399extern void rb_clear_coverages(void);
2400extern void rb_reset_coverages(void);
2401extern void rb_resume_coverages(void);
2402extern void rb_suspend_coverages(void);
2403
2404void rb_postponed_job_flush(rb_vm_t *vm);
2405
2406// ractor.c
2407RUBY_EXTERN VALUE rb_eRactorUnsafeError;
2408RUBY_EXTERN VALUE rb_eRactorIsolationError;
2409
2410RUBY_SYMBOL_EXPORT_END
2411
2412#endif /* RUBY_VM_CORE_H */
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
Definition atomic.h:69
#define RUBY_ALIGNAS
Wraps (or simulates) alignas.
Definition stdalign.h:27
#define RUBY_EXTERN
Declaration of externally visible global variables.
Definition dllexport.h:45
#define RUBY_EVENT_SCRIPT_COMPILED
Encountered an eval.
Definition event.h:60
#define RUBY_INTERNAL_EVENT_OBJSPACE_MASK
Bitmask of GC events.
Definition event.h:100
uint32_t rb_event_flag_t
Represents event(s).
Definition event.h:108
#define RBIMPL_ATTR_FORMAT(x, y, z)
Wraps (or simulates) __attribute__((format)).
Definition format.h:29
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define Qundef
Old name of RUBY_Qundef.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
#define NIL_P
Old name of RB_NIL_P.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
Definition value_type.h:88
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
Identical to rb_typeddata_is_kind_of(), except it raises exceptions instead of returning false.
Definition error.c:1398
VALUE rb_obj_is_proc(VALUE recv)
Queries if the given object is a proc.
Definition proc.c:126
void rb_unblock_function_t(void *)
This is the type of UBFs.
Definition thread.h:336
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
Definition io.h:2
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
This is the type of a function that the interpreter expect for C-backended blocks.
Definition iterator.h:83
VALUE type(ANYARGS)
ANYARGS-ed function type.
#define RBIMPL_ATTR_NONNULL(list)
Wraps (or simulates) __attribute__((nonnull)).
Definition nonnull.h:30
#define inline
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.
Definition defines.h:91
#define RARRAY_AREF(a, i)
Definition rarray.h:403
#define RTYPEDDATA_DATA(v)
Convenient getter macro.
Definition rtypeddata.h:103
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
Definition rtypeddata.h:205
Defines old _.
C99 shim for <stdbool.h>.
Definition vm_core.h:261
const ID * segments
A null-terminated list of ids, used to represent a constant's path idNULL is used to represent the ::...
Definition vm_core.h:285
Definition vm_core.h:293
Definition vm_core.h:288
Definition iseq.h:252
Definition class.h:37
Definition st.h:79
IFUNC (Internal FUNCtion).
Definition imemo.h:86
Definition vm_core.h:253
Definition vm_core.h:297
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
Definition value.h:69
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40