Ruby
2.7.1p83(2020-03-31revisiona0c7c23c9cec0d0ffcba012279cd652d28ad5bf3)
|
Go to the documentation of this file.
12 #ifndef RUBY_VM_CORE_H
13 #define RUBY_VM_CORE_H
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)
94 # define NSIG NSIG_MAX
95 #elif defined(_SIG_MAXSIG)
97 # define NSIG _SIG_MAXSIG
98 #elif defined(_SIGMAX)
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
175 #if OPT_STACK_CACHING
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
285 pathobj_path(
VALUE pathobj)
297 pathobj_realpath(
VALUE pathobj)
389 const struct rb_iseq_param_keyword {
406 #if VM_INSN_INFO_TABLE_IMPL == 2
477 #ifndef USE_LAZY_LOAD
478 #define USE_LAZY_LOAD 0
500 #if VM_CHECK_MODE > 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)
769 #if VM_DEBUG_BP_CHECK
777 rb_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)
1025 rb_iseq_new_with_callback_new_callback(
1046 #define GetProcPtr(obj, ptr) \
1047 GetCoreDataFromValue((obj), rb_proc_t, (ptr))
1065 #define GetBindingPtr(obj, ptr) \
1066 GetCoreDataFromValue((obj), rb_binding_t, (ptr))
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)
1200 static inline void VM_FORCE_WRITE_SPECIAL_CONST(
const VALUE *
ptr,
VALUE special_const_value);
1203 VM_ENV_FLAGS_SET(
const VALUE *ep,
VALUE flag)
1211 VM_ENV_FLAGS_UNSET(
const VALUE *ep,
VALUE flag)
1218 static inline unsigned long
1219 VM_ENV_FLAGS(
const VALUE *ep,
long flag)
1223 return flags & flag;
1226 static 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
1294 VM_ENV_LOCAL_P(
const VALUE *ep)
1299 static inline const VALUE *
1300 VM_ENV_PREV_EP(
const VALUE *ep)
1307 VM_ENV_BLOCK_HANDLER(
const VALUE *ep)
1313 #if VM_CHECK_MODE > 0
1314 int rb_vm_ep_in_heap_p(
const VALUE *ep);
1318 VM_ENV_ESCAPED_P(
const VALUE *ep)
1324 #if VM_CHECK_MODE > 0
1334 VM_ENV_ENVVAL(
const VALUE *ep)
1343 VM_ENV_ENVVAL_PTR(
const VALUE *ep)
1345 return (
const rb_env_t *)VM_ENV_ENVVAL(ep);
1352 env->env_size = env_size;
1364 VM_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
1504 vm_block_type(
const struct rb_block *block)
1506 #if VM_CHECK_MODE > 0
1507 switch (block->
type) {
1532 static inline const struct rb_block *
1533 vm_proc_block(
VALUE procval)
1540 static inline const VALUE *vm_block_ep(
const struct rb_block *block);
1543 vm_proc_iseq(
VALUE procval)
1545 return vm_block_iseq(vm_proc_block(procval));
1548 static inline const VALUE *
1549 vm_proc_ep(
VALUE procval)
1551 return vm_block_ep(vm_proc_block(procval));
1555 vm_block_iseq(
const struct rb_block *block)
1557 switch (vm_block_type(block)) {
1567 static inline const VALUE *
1568 vm_block_ep(
const struct rb_block *block)
1570 switch (vm_block_type(block)) {
1581 vm_block_self(
const struct rb_block *block)
1583 switch (vm_block_type(block)) {
1588 return vm_block_self(vm_proc_block(block->
as.
proc));
1618 VM_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))
1690 rb_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()
1787 rb_current_execution_context(
void)
1793 rb_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
void rb_ec_error_print(rb_execution_context_t *volatile ec, volatile VALUE errinfo)
struct rb_vm_protect_tag * protect_tag
const struct rb_thread_struct * running_thread
struct list_head workqueue
@ VM_DEFINECLASS_TYPE_SINGLETON_CLASS
@ thread_invoke_type_proc
#define RUBY_SYMBOL_EXPORT_END
struct st_table * loaded_features_index
rb_vm_at_exit_func * func
@ block_handler_type_iseq
RUBY_EXTERN unsigned int ruby_vm_event_local_num
struct rb_objspace * objspace
STATIC_ASSERT(rb_vm_tag_buf_offset, offsetof(struct rb_vm_tag, buf) > 0)
VALUE private_const_reference
struct iseq_inline_iv_cache_entry * IVC
#define RUBY_VM_INTERRUPTED_ANY(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)
unsigned int thread_report_on_exception
struct list_head waiting_grps
enum rb_thread_struct::@190 invoke_type
const rb_data_type_t ruby_threadptr_data_type
void rb_thread_start_timer_thread(void)
struct rb_at_exit_list rb_at_exit_list
rb_event_flag_t global_trace_events
struct rb_calling_info * calling
RUBY_SYMBOL_EXPORT_BEGIN int rb_thread_check_trap_pending(void)
RUBY_EXTERN VALUE rb_cISeq
struct rb_iseq_constant_body::iseq_insn_info insns_info
@ ruby_error_stream_closed
RUBY_EXTERN rb_execution_context_t * ruby_current_execution_context_ptr
void rb_threadptr_signal_exit(rb_thread_t *th)
int rb_vm_get_sourceline(const rb_control_frame_t *)
short redefined_flag[BOP_LAST_]
BITFIELD(enum method_missing_reason, method_missing_reason, 8)
void rb_threadptr_pending_interrupt_clear(rb_thread_t *th)
size_t thread_machine_stack_size
struct succ_index_table * succ_index_table
struct rb_mjit_unit * jit_unit
@ VM_FRAME_FLAG_CFRAME_EMPTY_KW
@ VM_DEFINECLASS_TYPE_MASK
RETSIGTYPE(* ruby_sighandler_t)(int)
void rb_vm_block_copy(VALUE obj, const struct rb_block *dst, const struct rb_block *src)
struct rb_captured_block captured
void rb_vm_trap_exit(rb_vm_t *vm)
#define VM_TAGGED_PTR_REF(v, mask)
void rb_vm_register_special_exception_str(enum ruby_special_exceptions sp, VALUE exception_class, VALUE mesg)
union iseq_inline_storage_entry * ISE
#define EXEC_EVENT_HOOK(ec_, flag_, self_, id_, called_id_, klass_, data_)
RUBY_SYMBOL_EXPORT_BEGIN RUBY_EXTERN rb_vm_t * ruby_current_vm_ptr
void rb_exec_event_hooks(struct rb_trace_arg_struct *trace_arg, rb_hook_list_t *hooks, int pop_p)
void rb_execution_context_update(const rb_execution_context_t *ec)
rb_code_location_t code_location
VALUE(* jit_func)(struct rb_execution_context_struct *, struct rb_control_frame_struct *)
#define offsetof(p_type, field)
union rb_thread_struct::@189 invoke_arg
#define RB_TYPE_P(obj, type)
@ POSTPONED_JOB_INTERRUPT_MASK
RUBY_SYMBOL_EXPORT_END VALUE rb_iseq_pathobj_new(VALUE path, VALUE realpath)
@ block_handler_type_proc
struct iseq_compile_data * compile_data
void rb_thread_stop_timer_thread(void)
struct rb_ensure_entry entry
rb_nativethread_id_t thread_id
struct rb_vm_struct::@185 default_params
rb_ensure_list_t * ensure_list
struct rb_iseq_struct::@181::@182 loader
rb_iseq_location_t location
const struct rb_iseq_constant_body::@178::rb_iseq_param_keyword * keyword
struct rb_iseq_struct * local_iseq
#define VM_ENV_DATA_INDEX_SPECVAL
const rb_env_t * rb_vm_env_prev_env(const rb_env_t *env)
@ VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM
void rb_vm_inc_const_missing_count(void)
MJIT_STATIC VALUE rb_vm_bh_to_procval(const rb_execution_context_t *ec, VALUE block_handler)
struct iseq_inline_cache_entry cache
unsigned int accepts_no_kwarg
IFUNC (Internal FUNCtion)
rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
void rb_thread_reset_timer_thread(void)
rb_at_exit_list * at_exit
const struct rb_iseq_struct * parent_iseq
union rb_iseq_struct::@181 aux
struct list_head waiting_fds
void rb_threadptr_interrupt(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)
struct rb_thread_list_struct rb_thread_list_t
@ thread_invoke_type_none
@ VM_CHECKMATCH_TYPE_WHEN
VALUE rb_vm_env_local_variables(const rb_env_t *env)
@ ruby_special_error_count
void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *ctx, const char *fmt,...)
rb_execution_context_t * ec
const rb_control_frame_t * cfp
VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0)
unsigned int abort_on_exception
VALUE rb_vm_make_proc_lambda(const rb_execution_context_t *ec, const struct rb_captured_block *captured, VALUE klass, int8_t is_lambda)
@ thread_invoke_type_func
void rb_ec_clear_vm_stack(rb_execution_context_t *ec)
#define VM_BLOCK_HANDLER_NONE
struct rb_thread_struct * running_thread
void rb_ec_initialize_vm_stack(rb_execution_context_t *ec, VALUE *stack, size_t size)
struct rb_call_info_with_kwarg ci_kw
VALUE rb_iseq_eval_main(const rb_iseq_t *iseq)
void rb_execution_context_mark(const rb_execution_context_t *ec)
NORETURN(void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *, const char *fmt,...))
void Init_native_thread(rb_thread_t *th)
struct st_table * ensure_rollback_table
union rb_method_definition_struct::@118 body
rb_control_frame_t * rb_vm_get_binding_creatable_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
VALUE rb_obj_is_proc(VALUE)
struct rb_iseq_constant_body::@178 param
parameter information
#define VM_ENV_DATA_INDEX_ENV
struct rb_postponed_job_struct * postponed_job_buffer
#define VM_UNREACHABLE(func)
VALUE rb_get_coverages(void)
#define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp)
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_iseq_eval(const rb_iseq_t *iseq)
struct rb_thread_struct * main_thread
VALUE rb_vm_frame_block_handler(const rb_control_frame_t *cfp)
const VALUE * rb_binding_add_dynavars(VALUE bindval, rb_binding_t *bind, int dyncount, const ID *dynvars)
void rb_postponed_job_flush(rb_vm_t *vm)
struct iseq_inline_iv_cache_entry iv_cache
void rb_vm_block_ep_update(VALUE obj, const struct rb_block *dst, const VALUE *ep)
@ VM_SPECIAL_OBJECT_CBASE
struct rb_vm_struct rb_vm_t
void * blocking_region_buffer
rb_control_frame_t *FUNC_FASTCALL rb_insn_func_t(rb_execution_context_t *, rb_control_frame_t *)
unsigned int local_table_size
union iseq_inline_storage_entry * is_entries
enum rb_thread_status status
void rb_vmdebug_stack_dump_raw(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
VALUE rb_iseq_realpath(const rb_iseq_t *iseq)
unsigned long rb_serial_t
const VALUE * rb_vm_proc_local_ep(VALUE proc)
struct rb_thread_struct * thread_ptr
int rb_backtrace_iter_func(void *, VALUE, int, VALUE)
rb_control_frame_t * rb_vm_get_ruby_level_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
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 *)
@ VM_THROW_NO_ESCAPE_FLAG
void rb_hook_list_remove_tracepoint(rb_hook_list_t *list, VALUE tpval)
void rb_hook_list_connect_tracepoint(VALUE target, rb_hook_list_t *list, VALUE tpval, unsigned int target_line)
struct rb_iseq_constant_body::@179 variable
rb_atomic_t interrupt_flag
struct rb_control_frame_struct rb_control_frame_t
VALUE passed_block_handler
void rb_hook_list_free(rb_hook_list_t *hooks)
struct rb_thread_struct rb_thread_t
struct rb_call_info_kw_arg * kw_arg
struct rb_call_cache * CALL_CACHE
int rb_threadptr_execute_interrupts(rb_thread_t *, int)
VALUE rb_iseq_disasm(const rb_iseq_t *iseq)
VALUE load_path_check_cache
rb_iseq_t * rb_iseq_new_top(const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent)
struct iseq_catch_table * catch_table
const VALUE special_exceptions[ruby_special_error_count]
@ VM_CALL_ARGS_SIMPLE_bit
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
VALUE rb_proc_alloc(VALUE klass)
enum rb_iseq_constant_body::iseq_type type
int rb_signal_exec(rb_thread_t *th, int sig)
void ruby_thread_init_stack(rb_thread_t *th)
VALUE rb_ec_get_errinfo(const rb_execution_context_t *ec)
struct rb_trace_arg_struct * trace_arg
void rb_threadptr_signal_raise(rb_thread_t *th, int sig)
size_t thread_vm_stack_size
size_t fiber_vm_stack_size
@ block_handler_type_ifunc
#define RUBY_EVENT_SCRIPT_COMPILED
@ VM_SPECIAL_OBJECT_VMCORE
#define RARRAY_AREF(a, i)
void rb_fiber_close(rb_fiber_t *fib)
#define RTYPEDDATA_DATA(v)
void rb_unblock_function_t(void *)
int rb_ec_frame_method_id_and_class(const rb_execution_context_t *ec, ID *idp, ID *called_idp, VALUE *klassp)
RUBY_EXTERN VALUE rb_mRubyVMFrozenCore
VALUE rb_proc_dup(VALUE self)
const struct iseq_insn_info_entry * body
@ VM_FRAME_FLAG_CFRAME_KW
@ VM_DEFINECLASS_TYPE_CLASS
void rb_threadptr_pending_interrupt_enque(rb_thread_t *th, VALUE v)
const rb_cref_t * ic_cref
const struct rb_builtin_function * builtin_function_table
struct rb_iseq_constant_body::@178::@180 flags
struct rb_encoding_entry * list
void rb_vm_at_exit_func(struct rb_vm_struct *)
unsigned int thread_abort_on_exception
#define OPT_STACK_CACHING
void rb_thread_wakeup_timer_thread(int)
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_vm_encoded_insn_data_table_init(void)
struct rb_execution_context_struct rb_execution_context_t
const struct rb_builtin_function * RB_BUILTIN
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_vmdebug_debug_print_post(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
struct rb_hook_list_struct * local_hooks
#define VM_ENV_DATA_INDEX_FLAGS
@ VM_CALL_ARGS_BLOCKARG_bit
void rb_vm_rewrite_cref(rb_cref_t *node, VALUE old_klass, VALUE new_klass, rb_cref_t **new_cref_ptr)
void rb_ec_set_vm_stack(rb_execution_context_t *ec, VALUE *stack, size_t size)
@ VM_SPECIAL_OBJECT_CONST_BASE
const MJIT_STATIC rb_callable_method_entry_t * rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp)
rb_thread_list_t * join_list
unsigned int is_from_method
void rb_hook_list_mark(rb_hook_list_t *hooks)
struct rb_execution_context_struct::@188 machine
VALUE rb_vm_make_binding(const rb_execution_context_t *ec, const rb_control_frame_t *src_cfp)
void rb_clear_coverages(void)
void rb_threadptr_check_signal(rb_thread_t *mth)
unsigned char buf[MIME_BUF_SIZE]
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)
void(* func)(rb_iseq_t *, struct iseq_link_anchor *, const void *)
void rb_bug(const char *fmt,...)
void rb_objspace_call_finalizer(struct rb_objspace *)
#define RUBY_SYMBOL_EXPORT_BEGIN
struct rb_vm_struct::@184 trap_list
VALUE loaded_features_snapshot
unsigned int ruby2_keywords
struct rb_unblock_callback unblock
char str[HTML_ESCAPE_MAX_LEN+1]
VALUE pending_interrupt_mask_stack
struct rb_event_hook_struct * hooks
long unsigned total_calls
rb_execution_context_t * ec
union rb_captured_block::@186 code
const VALUE * rb_vm_ep_local_ep(const VALUE *ep)
void rb_vm_gvl_destroy(rb_vm_t *vm)
size_t fiber_machine_stack_size
st_table * frozen_strings
#define VM_TAGGED_PTR_SET(p, tag)
RUBY_EXTERN VALUE rb_cRubyVM
struct list_head living_threads
native_thread_data_t native_thread_data
void rb_set_coverages(VALUE, int, VALUE)
@ block_handler_type_symbol
@ VM_CHECKMATCH_TYPE_RESCUE
struct rb_iseq_location_struct rb_iseq_location_t
rb_atomic_t interrupt_mask
@ VM_ENV_FLAG_WB_REQUIRED
@ VM_METHOD_TYPE_ISEQ
Ruby method.
st_table * defined_module_hash
void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th)
void rb_vm_bugreport(const void *)
struct rb_ensure_entry rb_ensure_entry_t
@ VM_DEFINECLASS_TYPE_MODULE
VALUE rb_iseq_coverage(const rb_iseq_t *iseq)
struct rb_thread_struct * th
struct rb_ensure_list rb_ensure_list_t
unsigned int report_on_exception
MJIT_STATIC void rb_vm_pop_frame(rb_execution_context_t *ec)
struct rb_call_data * CALL_DATA
@ VM_CHECKMATCH_TYPE_CASE
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)
rb_hook_list_t global_hooks
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
rb_iseq_t * rb_iseq_new_main(const rb_ast_body_t *ast, VALUE path, VALUE realpath, const rb_iseq_t *parent)
struct iseq_inline_cache_entry * IC
struct rb_at_exit_list * next
void rb_vm_stack_to_heap(rb_execution_context_t *ec)
volatile int ubf_async_safe
struct rb_vm_protect_tag * prev
struct rb_iseq_constant_body * body
VALUE rb_thread_alloc(VALUE klass)
void rb_ec_setup_exception(const rb_execution_context_t *ec, VALUE mesg, VALUE cause)
void rb_gc_mark_machine_stack(const rb_execution_context_t *ec)
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_objspace_free(struct rb_objspace *)
int rb_signal_buff_size(void)
rb_nativethread_lock_t interrupt_lock
VALUE pending_interrupt_queue
VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, enum ruby_tag_type *stateptr)
VALUE rb_binding_alloc(VALUE klass)
struct list_node vmlt_node
void rb_reset_coverages(void)
struct rb_mutex_struct * keeping_mutexes
struct rb_hook_list_struct rb_hook_list_t
const struct vm_ifunc * ifunc
struct rb_call_info * CALL_INFO
unsigned int ambiguous_param0
RUBY_EXTERN rb_event_flag_t ruby_vm_event_flags
rb_nativethread_lock_t workqueue_lock
VALUE local_storage_recursive_hash_for_trace
RUBY_EXTERN VALUE rb_block_param_proxy
struct rb_call_data * call_data
struct rb_iseq_struct::@181::@183 exec
const rb_data_type_t ruby_binding_data_type
void rb_iseq_pathobj_set(const rb_iseq_t *iseq, VALUE path, VALUE realpath)
VALUE rb_iseq_path(const rb_iseq_t *iseq)
VALUE local_storage_recursive_hash
struct rb_thread_list_struct * next
struct rb_ensure_list * next
unsigned short first_lineno
@ imemo_ifunc
iterator function
VALUE type(ANYARGS)
ANYARGS-ed function type.
struct st_table * loading_table
#define RB_SPECIAL_CONST_P(x)
struct list_head waiting_pids
VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt)
rb_unblock_function_t * func
unsigned int pending_interrupt_queue_checked
struct rb_objspace * rb_objspace_alloc(void)
#define GC_GUARDED_PTR_REF(p)
char rb_thread_id_string_t[sizeof(rb_nativethread_id_t) *2+3]
void rb_vm_rewind_cfp(rb_execution_context_t *ec, rb_control_frame_t *cfp)
rb_nativethread_lock_t waitpid_lock
RUBY_EXTERN rb_event_flag_t ruby_vm_event_enabled_global_flags
struct iseq_inline_storage_entry::@177 once
struct RUBY_ALIGNAS(SIZEOF_VALUE) RBasic
BITFIELD(enum rb_thread_status, status, 2)