22#define N_OR_RUBY_DEBUG(n) (((n) > 0) ? (n) : RUBY_DEBUG)
24#define VM_CHECK_MODE N_OR_RUBY_DEBUG(0)
52#define VM_ASSERT(expr) RUBY_ASSERT_MESG_WHEN(VM_CHECK_MODE > 0, expr, #expr)
53#define VM_UNREACHABLE(func) rb_bug(#func ": unreachable")
56#define VM_ASSERT(expr) ((void)0)
57#define VM_UNREACHABLE(func) UNREACHABLE
60#define RUBY_VM_THREAD_MODEL 2
68#ifndef VM_INSN_INFO_TABLE_IMPL
69# define VM_INSN_INFO_TABLE_IMPL 2
80#include "ccan/list/list.h"
85#elif defined(HAVE_PTHREAD_H)
95#elif defined(_SIG_MAXSIG)
97# define NSIG _SIG_MAXSIG
99# define NSIG (_SIGMAX + 1)
103# define NSIG (sizeof(sigset_t) * CHAR_BIT + 1)
106#define RUBY_NSIG NSIG
109# define RUBY_SIGCHLD (SIGCLD)
110#elif defined(SIGCHLD)
111# define RUBY_SIGCHLD (SIGCHLD)
113# define RUBY_SIGCHLD (0)
117#if defined(__APPLE__)
118# define SIGCHLD_LOSSY (1)
120# define SIGCHLD_LOSSY (0)
124#define WAITPID_USE_SIGCHLD (RUBY_SIGCHLD || SIGCHLD_LOSSY)
126#ifdef HAVE_STDARG_PROTOTYPES
128#define va_init_list(a,b) va_start((a),(b))
131#define va_init_list(a,b) va_start((a))
134#if defined(SIGSEGV) && defined(HAVE_SIGALTSTACK) && defined(SA_SIGINFO) && !defined(__NetBSD__)
135# define USE_SIGALTSTACK
137# define RB_ALTSTACK_INIT(var) var = rb_register_sigaltstack()
138# define RB_ALTSTACK_FREE(var) xfree(var)
139# define RB_ALTSTACK(var) var
141# define RB_ALTSTACK_INIT(var)
142# define RB_ALTSTACK_FREE(var)
143# define RB_ALTSTACK(var) (0)
151#if defined(__GNUC__) && __GNUC__ >= 2
153#if OPT_TOKEN_THREADED_CODE
154#if OPT_DIRECT_THREADED_CODE
155#undef OPT_DIRECT_THREADED_CODE
162#if OPT_DIRECT_THREADED_CODE
163#undef OPT_DIRECT_THREADED_CODE
165#if OPT_TOKEN_THREADED_CODE
166#undef OPT_TOKEN_THREADED_CODE
171#if OPT_CALL_THREADED_CODE
172#if OPT_DIRECT_THREADED_CODE
173#undef OPT_DIRECT_THREADED_CODE
176#undef OPT_STACK_CACHING
197#define TAG_NONE RUBY_TAG_NONE
198#define TAG_RETURN RUBY_TAG_RETURN
199#define TAG_BREAK RUBY_TAG_BREAK
200#define TAG_NEXT RUBY_TAG_NEXT
201#define TAG_RETRY RUBY_TAG_RETRY
202#define TAG_REDO RUBY_TAG_REDO
203#define TAG_RAISE RUBY_TAG_RAISE
204#define TAG_THROW RUBY_TAG_THROW
205#define TAG_FATAL RUBY_TAG_FATAL
206#define TAG_MASK RUBY_TAG_MASK
266#define CoreDataFromValue(obj, type) (type*)DATA_PTR(obj)
268#define CoreDataFromValue(obj, type) (type*)rb_data_object_get(obj)
270#define GetCoreDataFromValue(obj, type, ptr) ((ptr) = CoreDataFromValue((obj), type))
281#define PATHOBJ_PATH 0
282#define PATHOBJ_REALPATH 1
285pathobj_path(
VALUE pathobj)
297pathobj_realpath(
VALUE pathobj)
389 const struct rb_iseq_param_keyword {
402 struct iseq_insn_info {
406#if VM_INSN_INFO_TABLE_IMPL == 2
478#define USE_LAZY_LOAD 0
549#define GetVMPtr(obj, ptr) \
550 GetCoreDataFromValue((obj), rb_vm_t, (ptr))
586#ifdef USE_SIGALTSTACK
674#define RUBY_VM_SIZE_ALIGN 4096
676#define RUBY_VM_THREAD_VM_STACK_SIZE ( 128 * 1024 * sizeof(VALUE))
677#define RUBY_VM_THREAD_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE))
678#define RUBY_VM_THREAD_MACHINE_STACK_SIZE ( 128 * 1024 * sizeof(VALUE))
679#define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE))
681#define RUBY_VM_FIBER_VM_STACK_SIZE ( 16 * 1024 * sizeof(VALUE))
682#define RUBY_VM_FIBER_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE))
683#define RUBY_VM_FIBER_MACHINE_STACK_SIZE ( 64 * 1024 * sizeof(VALUE))
684#if defined(__powerpc64__)
685#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 32 * 1024 * sizeof(VALUE))
687#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE))
690#if __has_feature(memory_sanitizer) || __has_feature(address_sanitizer)
692#undef RUBY_VM_THREAD_MACHINE_STACK_SIZE
693#define RUBY_VM_THREAD_MACHINE_STACK_SIZE (1024 * 1024 * sizeof(VALUE))
694#undef RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN
695#define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN ( 512 * 1024 * sizeof(VALUE))
696#undef RUBY_VM_FIBER_MACHINE_STACK_SIZE
697#define RUBY_VM_FIBER_MACHINE_STACK_SIZE ( 256 * 1024 * sizeof(VALUE))
698#undef RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN
699#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 128 * 1024 * sizeof(VALUE))
703#define INTEGER_REDEFINED_OP_FLAG (1 << 0)
704#define FLOAT_REDEFINED_OP_FLAG (1 << 1)
705#define STRING_REDEFINED_OP_FLAG (1 << 2)
706#define ARRAY_REDEFINED_OP_FLAG (1 << 3)
707#define HASH_REDEFINED_OP_FLAG (1 << 4)
709#define SYMBOL_REDEFINED_OP_FLAG (1 << 6)
710#define TIME_REDEFINED_OP_FLAG (1 << 7)
711#define REGEXP_REDEFINED_OP_FLAG (1 << 8)
712#define NIL_REDEFINED_OP_FLAG (1 << 9)
713#define TRUE_REDEFINED_OP_FLAG (1 << 10)
714#define FALSE_REDEFINED_OP_FLAG (1 << 11)
715#define PROC_REDEFINED_OP_FLAG (1 << 12)
717#define BASIC_OP_UNREDEFINED_P(op, klass) (LIKELY((GET_VM()->redefined_flag[(op)]&(klass)) == 0))
719#ifndef VM_DEBUG_BP_CHECK
720#define VM_DEBUG_BP_CHECK 0
723#ifndef VM_DEBUG_VERIFY_METHOD_CACHE
724#define VM_DEBUG_VERIFY_METHOD_CACHE (VMDEBUG != 0)
777rb_thread_ptr(
VALUE thval)
895#define VM_CORE_H_EC_DEFINED 1
928#ifdef NON_SCALAR_THREAD_ID
947#if OPT_CALL_THREADED_CODE
1001#define VM_DEFINECLASS_TYPE(x) ((rb_vm_defineclass_type_t)(x) & VM_DEFINECLASS_TYPE_MASK)
1002#define VM_DEFINECLASS_FLAG_SCOPED 0x08
1003#define VM_DEFINECLASS_FLAG_HAS_SUPERCLASS 0x10
1004#define VM_DEFINECLASS_SCOPED_P(x) ((x) & VM_DEFINECLASS_FLAG_SCOPED)
1005#define VM_DEFINECLASS_HAS_SUPERCLASS_P(x) \
1006 ((x) & VM_DEFINECLASS_FLAG_HAS_SUPERCLASS)
1025rb_iseq_new_with_callback_new_callback(
1046#define GetProcPtr(obj, ptr) \
1047 GetCoreDataFromValue((obj), rb_proc_t, (ptr))
1051 unsigned int is_from_method: 1;
1052 unsigned int is_lambda: 1;
1060 unsigned int env_size;
1065#define GetBindingPtr(obj, ptr) \
1066 GetCoreDataFromValue((obj), rb_binding_t, (ptr))
1070 const VALUE pathobj;
1071 unsigned short first_lineno;
1082#define VM_CHECKMATCH_TYPE_MASK 0x03
1083#define VM_CHECKMATCH_ARRAY 0x04
1101#define VM_CALL_ARGS_SPLAT (0x01 << VM_CALL_ARGS_SPLAT_bit)
1102#define VM_CALL_ARGS_BLOCKARG (0x01 << VM_CALL_ARGS_BLOCKARG_bit)
1103#define VM_CALL_FCALL (0x01 << VM_CALL_FCALL_bit)
1104#define VM_CALL_VCALL (0x01 << VM_CALL_VCALL_bit)
1105#define VM_CALL_ARGS_SIMPLE (0x01 << VM_CALL_ARGS_SIMPLE_bit)
1106#define VM_CALL_BLOCKISEQ (0x01 << VM_CALL_BLOCKISEQ_bit)
1107#define VM_CALL_KWARG (0x01 << VM_CALL_KWARG_bit)
1108#define VM_CALL_KW_SPLAT (0x01 << VM_CALL_KW_SPLAT_bit)
1109#define VM_CALL_TAILCALL (0x01 << VM_CALL_TAILCALL_bit)
1110#define VM_CALL_SUPER (0x01 << VM_CALL_SUPER_bit)
1111#define VM_CALL_ZSUPER (0x01 << VM_CALL_ZSUPER_bit)
1112#define VM_CALL_OPT_SEND (0x01 << VM_CALL_OPT_SEND_bit)
1138#ifndef FUNC_FASTCALL
1139#define FUNC_FASTCALL(x) x
1145#define VM_TAGGED_PTR_SET(p, tag) ((VALUE)(p) | (tag))
1146#define VM_TAGGED_PTR_REF(v, mask) ((void *)((v) & ~mask))
1148#define GC_GUARDED_PTR(p) VM_TAGGED_PTR_SET((p), 0x01)
1149#define GC_GUARDED_PTR_REF(p) VM_TAGGED_PTR_REF((p), 0x03)
1150#define GC_GUARDED_PTR_P(p) (((VALUE)(p)) & 0x01)
1191#define VM_ENV_DATA_SIZE ( 3)
1193#define VM_ENV_DATA_INDEX_ME_CREF (-2)
1194#define VM_ENV_DATA_INDEX_SPECVAL (-1)
1195#define VM_ENV_DATA_INDEX_FLAGS ( 0)
1196#define VM_ENV_DATA_INDEX_ENV ( 1)
1198#define VM_ENV_INDEX_LAST_LVAR (-VM_ENV_DATA_SIZE)
1200static inline void VM_FORCE_WRITE_SPECIAL_CONST(
const VALUE *
ptr,
VALUE special_const_value);
1211VM_ENV_FLAGS_UNSET(
const VALUE *ep,
VALUE flag)
1218static inline unsigned long
1219VM_ENV_FLAGS(
const VALUE *ep,
long flag)
1223 return flags & flag;
1226static inline unsigned long
1269#if VM_CHECK_MODE > 0
1270#define RUBY_VM_NORMAL_ISEQ_P(iseq) rb_obj_is_iseq((VALUE)iseq)
1284 return !VM_FRAME_CFRAME_P(
cfp);
1287#define RUBYVM_CFUNC_FRAME_P(cfp) \
1288 (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC)
1290#define VM_GUARDED_PREV_EP(ep) GC_GUARDED_PTR(ep)
1291#define VM_BLOCK_HANDLER_NONE 0
1294VM_ENV_LOCAL_P(
const VALUE *ep)
1299static inline const VALUE *
1300VM_ENV_PREV_EP(
const VALUE *ep)
1307VM_ENV_BLOCK_HANDLER(
const VALUE *ep)
1313#if VM_CHECK_MODE > 0
1314int rb_vm_ep_in_heap_p(
const VALUE *ep);
1318VM_ENV_ESCAPED_P(
const VALUE *ep)
1324#if VM_CHECK_MODE > 0
1334VM_ENV_ENVVAL(
const VALUE *ep)
1343VM_ENV_ENVVAL_PTR(
const VALUE *ep)
1345 return (
const rb_env_t *)VM_ENV_ENVVAL(ep);
1352 env->env_size = env_size;
1364VM_FORCE_WRITE_SPECIAL_CONST(
const VALUE *
ptr,
VALUE special_const_value)
1367 VM_FORCE_WRITE(
ptr, special_const_value);
1374 VM_FORCE_WRITE(&ep[
index],
v);
1384#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) ((cfp)+1)
1385#define RUBY_VM_NEXT_CONTROL_FRAME(cfp) ((cfp)-1)
1387#define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp) \
1388 ((void *)(ecfp) > (void *)(cfp))
1406#if VM_CHECK_MODE > 0
1437#if VM_CHECK_MODE > 0
1504vm_block_type(
const struct rb_block *block)
1506#if VM_CHECK_MODE > 0
1507 switch (block->
type) {
1532static inline const struct rb_block *
1533vm_proc_block(
VALUE procval)
1540static inline const VALUE *vm_block_ep(
const struct rb_block *block);
1543vm_proc_iseq(
VALUE procval)
1545 return vm_block_iseq(vm_proc_block(procval));
1548static inline const VALUE *
1549vm_proc_ep(
VALUE procval)
1551 return vm_block_ep(vm_proc_block(procval));
1555vm_block_iseq(
const struct rb_block *block)
1557 switch (vm_block_type(block)) {
1567static inline const VALUE *
1568vm_block_ep(
const struct rb_block *block)
1570 switch (vm_block_type(block)) {
1581vm_block_self(
const struct rb_block *block)
1583 switch (vm_block_type(block)) {
1588 return vm_block_self(vm_proc_block(block->
as.
proc));
1618VM_BH_FROM_PROC(
VALUE procval)
1639#define SDR() rb_vmdebug_stack_dump_raw(GET_EC(), GET_EC()->cfp)
1640#define SDR2(cfp) rb_vmdebug_stack_dump_raw(GET_EC(), (cfp))
1690rb_vm_living_threads_init(
rb_vm_t *vm)
1726#define rb_vm_register_special_exception(sp, e, m) \
1727 rb_vm_register_special_exception_str(sp, e, rb_usascii_str_new_static((m), (long)rb_strlen_lit(m)))
1735#define sysstack_error GET_VM()->special_exceptions[ruby_error_sysstack]
1737#define RUBY_CONST_ASSERT(expr) (1/!!(expr))
1738#define VM_STACK_OVERFLOWED_P(cfp, sp, margin) \
1739 (!RUBY_CONST_ASSERT(sizeof(*(sp)) == sizeof(VALUE)) || \
1740 !RUBY_CONST_ASSERT(sizeof(*(cfp)) == sizeof(rb_control_frame_t)) || \
1741 ((rb_control_frame_t *)((sp) + (margin)) + 1) >= (cfp))
1742#define WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) \
1743 if (LIKELY(!VM_STACK_OVERFLOWED_P(cfp, sp, margin))) {(void)0;} else
1744#define CHECK_VM_STACK_OVERFLOW0(cfp, sp, margin) \
1745 WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) vm_stackoverflow()
1746#define CHECK_VM_STACK_OVERFLOW(cfp, margin) \
1747 WHEN_VM_STACK_OVERFLOWED(cfp, (cfp)->sp, margin) vm_stackoverflow()
1753#if RUBY_VM_THREAD_MODEL == 2
1764#define GET_VM() rb_current_vm()
1765#define GET_THREAD() rb_current_thread()
1766#define GET_EC() rb_current_execution_context()
1787rb_current_execution_context(
void)
1793rb_current_thread(
void)
1796 return rb_ec_thread_ptr(ec);
1821 rb_thread_set_current_raw(th);
1826#error "unsupported thread model"
1836#define RUBY_VM_SET_TIMER_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, TIMER_INTERRUPT_MASK)
1837#define RUBY_VM_SET_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, PENDING_INTERRUPT_MASK)
1838#define RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, POSTPONED_JOB_INTERRUPT_MASK)
1839#define RUBY_VM_SET_TRAP_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, TRAP_INTERRUPT_MASK)
1840#define RUBY_VM_INTERRUPTED(ec) ((ec)->interrupt_flag & ~(ec)->interrupt_mask & \
1841 (PENDING_INTERRUPT_MASK|TRAP_INTERRUPT_MASK))
1842#define RUBY_VM_INTERRUPTED_ANY(ec) ((ec)->interrupt_flag & ~(ec)->interrupt_mask)
1862#define RUBY_VM_CHECK_INTS(ec) rb_vm_check_ints(ec)
1898#define EXEC_EVENT_HOOK_ORIG(ec_, hooks_, flag_, self_, id_, called_id_, klass_, data_, pop_p_) do { \
1899 const rb_event_flag_t flag_arg_ = (flag_); \
1900 rb_hook_list_t *hooks_arg_ = (hooks_); \
1901 if (UNLIKELY((hooks_arg_)->events & (flag_arg_))) { \
1903 rb_exec_event_hook_orig(ec_, hooks_arg_, flag_arg_, self_, id_, called_id_, klass_, data_, pop_p_); \
1915 trace_arg.
event = flag;
1918 trace_arg.
self =
self;
1935#define EXEC_EVENT_HOOK(ec_, flag_, self_, id_, called_id_, klass_, data_) \
1936 EXEC_EVENT_HOOK_ORIG(ec_, rb_vm_global_hooks(ec_), flag_, self_, id_, called_id_, klass_, data_, 0)
1938#define EXEC_EVENT_HOOK_AND_POP_FRAME(ec_, flag_, self_, id_, called_id_, klass_, data_) \
1939 EXEC_EVENT_HOOK_ORIG(ec_, rb_vm_global_hooks(ec_), flag_, self_, id_, called_id_, klass_, data_, 1)
1956#define RUBY_EVENT_COVERAGE_LINE 0x010000
1957#define RUBY_EVENT_COVERAGE_BRANCH 0x020000
struct rb_encoding_entry * list
char str[HTML_ESCAPE_MAX_LEN+1]
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
void rb_bug(const char *fmt,...)
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *ctx, const char *fmt,...)
VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt)
VALUE type(ANYARGS)
ANYARGS-ed function type.
unsigned char buf[MIME_BUF_SIZE]
struct RUBY_ALIGNAS(SIZEOF_VALUE) RBasic
const rb_cref_t * ic_cref
struct rb_at_exit_list * next
rb_vm_at_exit_func * func
struct rb_captured_block captured
struct rb_call_info_kw_arg * kw_arg
const struct vm_ifunc * ifunc
union rb_captured_block::@53 code
struct rb_ensure_entry entry
struct rb_ensure_list * next
VALUE local_storage_recursive_hash_for_trace
BITFIELD(enum method_missing_reason, method_missing_reason, 8)
struct rb_thread_struct * thread_ptr
struct rb_execution_context_struct::@55 machine
VALUE private_const_reference
VALUE passed_block_handler
rb_ensure_list_t * ensure_list
rb_atomic_t interrupt_flag
rb_atomic_t interrupt_mask
struct rb_vm_protect_tag * protect_tag
struct rb_trace_arg_struct * trace_arg
VALUE local_storage_recursive_hash
struct rb_event_hook_struct * hooks
struct succ_index_table * succ_index_table
const struct iseq_insn_info_entry * body
unsigned int ruby2_keywords
unsigned int ambiguous_param0
struct rb_iseq_constant_body::iseq_insn_info insns_info
enum rb_iseq_constant_body::iseq_type type
struct rb_iseq_constant_body::@45 param
union iseq_inline_storage_entry * is_entries
unsigned int local_table_size
const struct rb_iseq_constant_body::@45::rb_iseq_param_keyword * keyword
VALUE(* jit_func)(struct rb_execution_context_struct *, struct rb_control_frame_struct *)
rb_iseq_location_t location
struct rb_iseq_constant_body::@45::@47 flags
struct rb_call_data * call_data
unsigned int accepts_no_kwarg
struct iseq_catch_table * catch_table
const struct rb_iseq_struct * parent_iseq
long unsigned total_calls
struct rb_iseq_constant_body::@46 variable
struct rb_iseq_struct * local_iseq
struct rb_mjit_unit * jit_unit
rb_code_location_t code_location
void(* func)(rb_iseq_t *, struct iseq_link_anchor *, const void *)
struct rb_hook_list_struct * local_hooks
struct rb_iseq_constant_body * body
struct iseq_compile_data * compile_data
union rb_iseq_struct::@48 aux
struct rb_iseq_struct::@48::@49 loader
rb_event_flag_t global_trace_events
struct rb_iseq_struct::@48::@50 exec
struct rb_call_info_with_kwarg ci_kw
union rb_method_definition_struct::@41 body
rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
struct rb_thread_list_struct * next
struct rb_thread_struct * th
rb_execution_context_t * ec
struct rb_unblock_callback unblock
native_thread_data_t native_thread_data
union rb_thread_struct::@56 invoke_arg
struct rb_calling_info * calling
unsigned int pending_interrupt_queue_checked
struct list_node vmlt_node
enum rb_thread_status status
unsigned int abort_on_exception
rb_nativethread_id_t thread_id
enum rb_thread_struct::@57 invoke_type
VALUE pending_interrupt_mask_stack
rb_nativethread_lock_t interrupt_lock
@ thread_invoke_type_proc
@ thread_invoke_type_func
@ thread_invoke_type_none
unsigned int report_on_exception
struct rb_mutex_struct * keeping_mutexes
VALUE pending_interrupt_queue
BITFIELD(enum rb_thread_status, status, 2)
void * blocking_region_buffer
rb_thread_list_t * join_list
const rb_control_frame_t * cfp
rb_execution_context_t * ec
rb_unblock_function_t * func
struct rb_vm_protect_tag * prev
VALUE load_path_check_cache
struct st_table * loaded_features_index
struct rb_objspace * objspace
rb_at_exit_list * at_exit
const struct rb_thread_struct * running_thread
struct st_table * ensure_rollback_table
struct st_table * loading_table
short redefined_flag[BOP_LAST_]
rb_nativethread_lock_t waitpid_lock
struct rb_thread_struct * main_thread
struct list_head waiting_fds
st_table * frozen_strings
st_table * defined_module_hash
const struct rb_builtin_function * builtin_function_table
rb_hook_list_t global_hooks
struct list_head waiting_pids
struct list_head workqueue
size_t fiber_vm_stack_size
volatile int ubf_async_safe
struct rb_postponed_job_struct * postponed_job_buffer
size_t fiber_machine_stack_size
size_t thread_vm_stack_size
const VALUE special_exceptions[ruby_special_error_count]
struct rb_vm_struct::@51 trap_list
VALUE loaded_features_snapshot
struct rb_vm_struct::@52 default_params
struct list_head waiting_grps
unsigned int thread_report_on_exception
rb_nativethread_lock_t workqueue_lock
unsigned int thread_abort_on_exception
size_t thread_machine_stack_size
struct list_head living_threads
IFUNC (Internal FUNCtion)
struct iseq_inline_storage_entry::@44 once
struct iseq_inline_iv_cache_entry iv_cache
struct rb_thread_struct * running_thread
struct iseq_inline_cache_entry cache
void rb_vm_block_copy(VALUE obj, const struct rb_block *dst, const struct rb_block *src)
void rb_ec_setup_exception(const rb_execution_context_t *ec, VALUE mesg, VALUE cause)
const rb_data_type_t ruby_threadptr_data_type
void rb_ec_clear_vm_stack(rb_execution_context_t *ec)
RUBY_SYMBOL_EXPORT_BEGIN rb_iseq_t * rb_iseq_new(const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, enum iseq_type)
VALUE rb_iseq_path(const rb_iseq_t *iseq)
VALUE rb_get_coverages(void)
void rb_ec_initialize_vm_stack(rb_execution_context_t *ec, VALUE *stack, size_t size)
const VALUE * rb_vm_ep_local_ep(const VALUE *ep)
rb_iseq_t * rb_iseq_new_with_callback(const struct rb_iseq_new_with_callback_callback_func *ifunc, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno, const rb_iseq_t *parent, enum iseq_type, const rb_compile_option_t *)
RUBY_SYMBOL_EXPORT_BEGIN RUBY_EXTERN rb_vm_t * ruby_current_vm_ptr
#define RUBY_VM_INTERRUPTED_ANY(ec)
void rb_vm_gvl_destroy(rb_vm_t *vm)
VALUE rb_iseq_eval_main(const rb_iseq_t *iseq)
@ POSTPONED_JOB_INTERRUPT_MASK
@ VM_THROW_NO_ESCAPE_FLAG
void rb_ec_error_print(rb_execution_context_t *volatile ec, volatile VALUE errinfo)
RUBY_SYMBOL_EXPORT_END VALUE rb_iseq_pathobj_new(VALUE path, VALUE realpath)
@ VM_CALL_ARGS_SIMPLE_bit
@ VM_CALL_ARGS_BLOCKARG_bit
RUBY_EXTERN VALUE rb_cISeq
void rb_threadptr_check_signal(rb_thread_t *mth)
void ruby_thread_init_stack(rb_thread_t *th)
struct iseq_inline_cache_entry * IC
VALUE(* vm_call_handler)(struct rb_execution_context_struct *ec, struct rb_control_frame_struct *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)
RUBY_EXTERN rb_event_flag_t ruby_vm_event_enabled_global_flags
void Init_native_thread(rb_thread_t *th)
void rb_vmdebug_debug_print_pre(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, const VALUE *_pc)
RUBY_EXTERN VALUE rb_mRubyVMFrozenCore
NORETURN(void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *, const char *fmt,...))
void rb_iseq_pathobj_set(const rb_iseq_t *iseq, VALUE path, VALUE realpath)
int rb_threadptr_execute_interrupts(rb_thread_t *, int)
struct rb_thread_struct rb_thread_t
const rb_data_type_t ruby_binding_data_type
struct rb_call_cache * CALL_CACHE
void rb_vm_encoded_insn_data_table_init(void)
rb_iseq_t * rb_iseq_new_with_opt(const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno, const rb_iseq_t *parent, enum iseq_type, const rb_compile_option_t *)
void rb_vm_stack_to_heap(rb_execution_context_t *ec)
#define GC_GUARDED_PTR_REF(p)
MJIT_STATIC void rb_vm_pop_frame(rb_execution_context_t *ec)
void rb_clear_coverages(void)
@ VM_SPECIAL_OBJECT_CBASE
@ VM_SPECIAL_OBJECT_VMCORE
@ VM_SPECIAL_OBJECT_CONST_BASE
VALUE rb_vm_frame_block_handler(const rb_control_frame_t *cfp)
RUBY_EXTERN unsigned int ruby_vm_event_local_num
void rb_objspace_call_finalizer(struct rb_objspace *)
RUBY_EXTERN rb_event_flag_t ruby_vm_event_flags
void rb_gc_mark_machine_stack(const rb_execution_context_t *ec)
VALUE rb_ec_get_errinfo(const rb_execution_context_t *ec)
#define VM_ENV_DATA_INDEX_FLAGS
void rb_vm_bugreport(const void *)
struct rb_at_exit_list rb_at_exit_list
VALUE rb_proc_dup(VALUE self)
@ block_handler_type_ifunc
@ block_handler_type_proc
@ block_handler_type_symbol
@ block_handler_type_iseq
VALUE rb_binding_alloc(VALUE klass)
void rb_vm_at_exit_func(struct rb_vm_struct *)
#define VM_ENV_DATA_INDEX_ENV
RUBY_EXTERN VALUE rb_block_param_proxy
@ ruby_special_error_count
@ ruby_error_stream_closed
MJIT_STATIC VALUE rb_vm_bh_to_procval(const rb_execution_context_t *ec, VALUE block_handler)
VALUE rb_vm_make_binding(const rb_execution_context_t *ec, const rb_control_frame_t *src_cfp)
void rb_ec_set_vm_stack(rb_execution_context_t *ec, VALUE *stack, size_t size)
struct rb_execution_context_struct rb_execution_context_t
@ VM_FRAME_FLAG_CFRAME_KW
@ VM_ENV_FLAG_WB_REQUIRED
@ VM_FRAME_FLAG_CFRAME_EMPTY_KW
@ VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM
struct rb_thread_list_struct rb_thread_list_t
void rb_hook_list_free(rb_hook_list_t *hooks)
void rb_threadptr_pending_interrupt_enque(rb_thread_t *th, VALUE v)
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_iseq_eval(const rb_iseq_t *iseq)
int rb_vm_get_sourceline(const rb_control_frame_t *)
MJIT_STATIC const rb_callable_method_entry_t * rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
union iseq_inline_storage_entry * ISE
void rb_threadptr_pending_interrupt_clear(rb_thread_t *th)
#define EXEC_EVENT_HOOK(ec_, flag_, self_, id_, called_id_, klass_, data_)
const struct rb_builtin_function * RB_BUILTIN
void rb_vmdebug_stack_dump_raw(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
char rb_thread_id_string_t[sizeof(rb_nativethread_id_t) *2+3]
rb_iseq_t * rb_iseq_new_main(const rb_ast_body_t *ast, VALUE path, VALUE realpath, const rb_iseq_t *parent)
struct rb_vm_struct rb_vm_t
RETSIGTYPE(* ruby_sighandler_t)(int)
VALUE rb_iseq_coverage(const rb_iseq_t *iseq)
void rb_threadptr_signal_raise(rb_thread_t *th, int sig)
int rb_signal_exec(rb_thread_t *th, int sig)
RUBY_SYMBOL_EXPORT_BEGIN int rb_thread_check_trap_pending(void)
VALUE rb_vm_make_proc_lambda(const rb_execution_context_t *ec, const struct rb_captured_block *captured, VALUE klass, int8_t is_lambda)
VALUE rb_vm_env_local_variables(const rb_env_t *env)
int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp)
STATIC_ASSERT(rb_vm_tag_buf_offset, offsetof(struct rb_vm_tag, buf) > 0)
VALUE rb_thread_alloc(VALUE klass)
RUBY_EXTERN VALUE rb_cRubyVM
VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, enum ruby_tag_type *stateptr)
RUBY_EXTERN rb_execution_context_t * ruby_current_execution_context_ptr
rb_control_frame_t * rb_vm_get_ruby_level_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
void rb_hook_list_mark(rb_hook_list_t *hooks)
struct rb_ensure_entry rb_ensure_entry_t
const VALUE * rb_binding_add_dynavars(VALUE bindval, rb_binding_t *bind, int dyncount, const ID *dynvars)
void rb_thread_reset_timer_thread(void)
void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th)
rb_control_frame_t * rb_vm_get_binding_creatable_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
struct rb_ensure_list rb_ensure_list_t
#define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp)
#define VM_TAGGED_PTR_REF(v, mask)
void rb_vm_rewind_cfp(rb_execution_context_t *ec, rb_control_frame_t *cfp)
struct rb_control_frame_struct rb_control_frame_t
const rb_env_t * rb_vm_env_prev_env(const rb_env_t *env)
VALUE rb_vm_invoke_proc(rb_execution_context_t *ec, rb_proc_t *proc, int argc, const VALUE *argv, int kw_splat, VALUE block_handler)
void rb_thread_stop_timer_thread(void)
void rb_threadptr_signal_exit(rb_thread_t *th)
struct rb_hook_list_struct rb_hook_list_t
void rb_vmdebug_debug_print_post(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
void rb_exec_event_hooks(struct rb_trace_arg_struct *trace_arg, rb_hook_list_t *hooks, int pop_p)
rb_control_frame_t *FUNC_FASTCALL rb_insn_func_t(rb_execution_context_t *, rb_control_frame_t *)
struct rb_call_data * CALL_DATA
void rb_vm_block_ep_update(VALUE obj, const struct rb_block *dst, const VALUE *ep)
void rb_threadptr_interrupt(rb_thread_t *th)
int rb_iseq_disasm_insn(VALUE str, const VALUE *iseqval, size_t pos, const rb_iseq_t *iseq, VALUE child)
Disassemble a instruction Iseq -> Iseq inspect object.
void rb_thread_wakeup_timer_thread(int)
void rb_set_coverages(VALUE, int, VALUE)
#define VM_BLOCK_HANDLER_NONE
const VALUE * rb_vm_proc_local_ep(VALUE proc)
#define VM_ENV_DATA_INDEX_SPECVAL
VALUE rb_iseq_disasm(const rb_iseq_t *iseq)
void rb_fiber_close(rb_fiber_t *fib)
#define VM_TAGGED_PTR_SET(p, tag)
void rb_vm_rewrite_cref(rb_cref_t *node, VALUE old_klass, VALUE new_klass, rb_cref_t **new_cref_ptr)
int rb_ec_frame_method_id_and_class(const rb_execution_context_t *ec, ID *idp, ID *called_idp, VALUE *klassp)
@ VM_DEFINECLASS_TYPE_CLASS
@ VM_DEFINECLASS_TYPE_MASK
@ VM_DEFINECLASS_TYPE_MODULE
@ VM_DEFINECLASS_TYPE_SINGLETON_CLASS
void rb_hook_list_remove_tracepoint(rb_hook_list_t *list, VALUE tpval)
rb_iseq_t * rb_iseq_new_top(const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent)
void rb_vm_trap_exit(rb_vm_t *vm)
int rb_signal_buff_size(void)
struct rb_iseq_location_struct rb_iseq_location_t
void rb_objspace_free(struct rb_objspace *)
void rb_vm_register_special_exception_str(enum ruby_special_exceptions sp, VALUE exception_class, VALUE mesg)
struct iseq_inline_iv_cache_entry * IVC
VALUE rb_iseq_realpath(const rb_iseq_t *iseq)
void rb_hook_list_connect_tracepoint(VALUE target, rb_hook_list_t *list, VALUE tpval, unsigned int target_line)
int rb_backtrace_iter_func(void *, VALUE, int, VALUE)
void rb_execution_context_update(const rb_execution_context_t *ec)
#define VM_UNREACHABLE(func)
@ VM_CHECKMATCH_TYPE_RESCUE
@ VM_CHECKMATCH_TYPE_CASE
@ VM_CHECKMATCH_TYPE_WHEN
void rb_execution_context_mark(const rb_execution_context_t *ec)
struct rb_call_info * CALL_INFO
void rb_postponed_job_flush(rb_vm_t *vm)
void rb_reset_coverages(void)
VALUE rb_vm_call_kw(rb_execution_context_t *ec, VALUE recv, VALUE id, int argc, const VALUE *argv, const rb_callable_method_entry_t *me, int kw_splat)
void rb_thread_start_timer_thread(void)
VALUE rb_proc_alloc(VALUE klass)
void rb_vm_inc_const_missing_count(void)
struct rb_objspace * rb_objspace_alloc(void)