12 #ifndef RUBY_VM_CORE_H 13 #define RUBY_VM_CORE_H 20 #define VM_CHECK_MODE 0 48 #define VM_ASSERT(expr) ( \ 49 RUBY_ASSERT_MESG_WHEN(VM_CHECK_MODE > 0, expr, #expr)) 51 #define VM_UNREACHABLE(func) rb_bug(#func ": unreachable") 54 #define VM_ASSERT(expr) ((void)0) 55 #define VM_UNREACHABLE(func) ((void)0) 58 #define RUBY_VM_THREAD_MODEL 2 69 #include "ccan/list/list.h" 74 #elif defined(HAVE_PTHREAD_H) 78 #ifndef ENABLE_VM_OBJSPACE 85 #define ENABLE_VM_OBJSPACE 0 87 #define ENABLE_VM_OBJSPACE 1 95 # define NSIG (_SIGMAX + 1) 98 #define RUBY_NSIG NSIG 100 #ifdef HAVE_STDARG_PROTOTYPES 102 #define va_init_list(a,b) va_start((a),(b)) 105 #define va_init_list(a,b) va_start((a)) 108 #if defined(SIGSEGV) && defined(HAVE_SIGALTSTACK) && defined(SA_SIGINFO) && !defined(__NetBSD__) 109 #define USE_SIGALTSTACK 117 #if defined(__GNUC__) && __GNUC__ >= 2 119 #if OPT_TOKEN_THREADED_CODE 120 #if OPT_DIRECT_THREADED_CODE 121 #undef OPT_DIRECT_THREADED_CODE 128 #if OPT_DIRECT_THREADED_CODE 129 #undef OPT_DIRECT_THREADED_CODE 131 #if OPT_TOKEN_THREADED_CODE 132 #undef OPT_TOKEN_THREADED_CODE 136 #ifdef __native_client__ 137 #undef OPT_DIRECT_THREADED_CODE 141 #if OPT_CALL_THREADED_CODE 142 #if OPT_DIRECT_THREADED_CODE 143 #undef OPT_DIRECT_THREADED_CODE 145 #if OPT_STACK_CACHING 146 #undef OPT_STACK_CACHING 163 #define TAG_RETURN RUBY_TAG_RETURN 164 #define TAG_BREAK RUBY_TAG_BREAK 165 #define TAG_NEXT RUBY_TAG_NEXT 166 #define TAG_RETRY RUBY_TAG_RETRY 167 #define TAG_REDO RUBY_TAG_REDO 168 #define TAG_RAISE RUBY_TAG_RAISE 169 #define TAG_THROW RUBY_TAG_THROW 170 #define TAG_FATAL RUBY_TAG_FATAL 171 #define TAG_MASK RUBY_TAG_MASK 258 #define CoreDataFromValue(obj, type) (type*)DATA_PTR(obj) 260 #define CoreDataFromValue(obj, type) (type*)rb_data_object_get(obj) 262 #define GetCoreDataFromValue(obj, type, ptr) ((ptr) = CoreDataFromValue((obj), type)) 282 ISEQ_TYPE_DEFINED_GUARD
348 const struct rb_iseq_param_keyword {
407 #ifndef USE_LAZY_LOAD 408 #define USE_LAZY_LOAD 0 463 #define GetVMPtr(obj, ptr) \ 464 GetCoreDataFromValue((obj), rb_vm_t, (ptr)) 493 struct list_head waiting_fds;
494 struct list_head living_threads;
562 #define RUBY_VM_SIZE_ALIGN 4096 564 #define RUBY_VM_THREAD_VM_STACK_SIZE ( 128 * 1024 * sizeof(VALUE)) 565 #define RUBY_VM_THREAD_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE)) 566 #define RUBY_VM_THREAD_MACHINE_STACK_SIZE ( 128 * 1024 * sizeof(VALUE)) 567 #define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE)) 569 #define RUBY_VM_FIBER_VM_STACK_SIZE ( 16 * 1024 * sizeof(VALUE)) 570 #define RUBY_VM_FIBER_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE)) 571 #define RUBY_VM_FIBER_MACHINE_STACK_SIZE ( 64 * 1024 * sizeof(VALUE)) 572 #define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE)) 575 #define INTEGER_REDEFINED_OP_FLAG (1 << 0) 576 #define FLOAT_REDEFINED_OP_FLAG (1 << 1) 577 #define STRING_REDEFINED_OP_FLAG (1 << 2) 578 #define ARRAY_REDEFINED_OP_FLAG (1 << 3) 579 #define HASH_REDEFINED_OP_FLAG (1 << 4) 581 #define SYMBOL_REDEFINED_OP_FLAG (1 << 6) 582 #define TIME_REDEFINED_OP_FLAG (1 << 7) 583 #define REGEXP_REDEFINED_OP_FLAG (1 << 8) 584 #define NIL_REDEFINED_OP_FLAG (1 << 9) 585 #define TRUE_REDEFINED_OP_FLAG (1 << 10) 586 #define FALSE_REDEFINED_OP_FLAG (1 << 11) 588 #define BASIC_OP_UNREDEFINED_P(op, klass) (LIKELY((GET_VM()->redefined_flag[(op)]&(klass)) == 0)) 590 #ifndef VM_DEBUG_BP_CHECK 591 #define VM_DEBUG_BP_CHECK 0 594 #ifndef VM_DEBUG_VERIFY_METHOD_CACHE 595 #define VM_DEBUG_VERIFY_METHOD_CACHE (VM_DEBUG_MODE != 0) 639 #if VM_DEBUG_BP_CHECK 646 #define GetThreadPtr(obj, ptr) \ 647 TypedData_Get_Struct((obj), rb_thread_t, &ruby_threadptr_data_type, (ptr)) 701 struct list_node vmlt_node;
735 #ifdef NON_SCALAR_THREAD_ID 752 #if OPT_CALL_THREADED_CODE 789 VALUE *register_stack_start;
790 VALUE *register_stack_end;
791 size_t register_stack_maxsize;
815 #ifdef USE_SIGALTSTACK 830 #define VM_DEFINECLASS_TYPE(x) ((rb_vm_defineclass_type_t)(x) & VM_DEFINECLASS_TYPE_MASK) 831 #define VM_DEFINECLASS_FLAG_SCOPED 0x08 832 #define VM_DEFINECLASS_FLAG_HAS_SUPERCLASS 0x10 833 #define VM_DEFINECLASS_SCOPED_P(x) ((x) & VM_DEFINECLASS_FLAG_SCOPED) 834 #define VM_DEFINECLASS_HAS_SUPERCLASS_P(x) \ 835 ((x) & VM_DEFINECLASS_FLAG_HAS_SUPERCLASS) 863 #define GetProcPtr(obj, ptr) \ 864 GetCoreDataFromValue((obj), rb_proc_t, (ptr)) 883 #define GetBindingPtr(obj, ptr) \ 884 GetCoreDataFromValue((obj), rb_binding_t, (ptr)) 900 #define VM_CHECKMATCH_TYPE_MASK 0x03 901 #define VM_CHECKMATCH_ARRAY 0x04 903 #define VM_CALL_ARGS_SPLAT (0x01 << 0) 904 #define VM_CALL_ARGS_BLOCKARG (0x01 << 1) 905 #define VM_CALL_FCALL (0x01 << 2) 906 #define VM_CALL_VCALL (0x01 << 3) 907 #define VM_CALL_ARGS_SIMPLE (0x01 << 4) 908 #define VM_CALL_BLOCKISEQ (0x01 << 5) 909 #define VM_CALL_KWARG (0x01 << 6) 910 #define VM_CALL_TAILCALL (0x01 << 7) 911 #define VM_CALL_SUPER (0x01 << 8) 912 #define VM_CALL_OPT_SEND (0x01 << 9) 937 #ifndef FUNC_FASTCALL 938 #define FUNC_FASTCALL(x) x 944 #define VM_TAGGED_PTR_SET(p, tag) ((VALUE)(p) | (tag)) 945 #define VM_TAGGED_PTR_REF(v, mask) ((void *)((v) & ~mask)) 947 #define GC_GUARDED_PTR(p) VM_TAGGED_PTR_SET((p), 0x01) 948 #define GC_GUARDED_PTR_REF(p) VM_TAGGED_PTR_REF((p), 0x03) 949 #define GC_GUARDED_PTR_P(p) (((VALUE)(p)) & 0x01) 988 #define VM_ENV_DATA_SIZE ( 3) 990 #define VM_ENV_DATA_INDEX_ME_CREF (-2) 991 #define VM_ENV_DATA_INDEX_SPECVAL (-1) 992 #define VM_ENV_DATA_INDEX_FLAGS ( 0) 993 #define VM_ENV_DATA_INDEX_ENV ( 1) 994 #define VM_ENV_DATA_INDEX_ENV_PROC ( 2) 996 #define VM_ENV_INDEX_LAST_LVAR (-VM_ENV_DATA_SIZE) 1016 static inline unsigned long 1021 return flags & flag;
1024 static inline unsigned long 1048 #if VM_CHECK_MODE > 0 1049 #define RUBY_VM_NORMAL_ISEQ_P(iseq) rb_obj_is_iseq((VALUE)iseq) 1066 #define RUBYVM_CFUNC_FRAME_P(cfp) \ 1067 (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC) 1069 #define VM_GUARDED_PREV_EP(ep) GC_GUARDED_PTR(ep) 1070 #define VM_BLOCK_HANDLER_NONE 0 1078 static inline const VALUE *
1092 #if VM_CHECK_MODE > 0 1093 int rb_vm_ep_in_heap_p(
const VALUE *ep);
1103 #if VM_CHECK_MODE > 0 1105 vm_assert_env(
VALUE obj)
1150 *((
VALUE *)ptr) = v;
1172 #define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) ((cfp)+1) 1173 #define RUBY_VM_NEXT_CONTROL_FRAME(cfp) ((cfp)-1) 1174 #define RUBY_VM_END_CONTROL_FRAME(th) \ 1175 ((rb_control_frame_t *)((th)->stack + (th)->stack_size)) 1176 #define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp) \ 1177 ((void *)(ecfp) > (void *)(cfp)) 1178 #define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp) \ 1179 (!RUBY_VM_VALID_CONTROL_FRAME_P((cfp), RUBY_VM_END_CONTROL_FRAME(th))) 1184 if ((block_handler & 0x03) == 0x01) {
1185 #if VM_CHECK_MODE > 0 1202 return block_handler;
1216 if ((block_handler & 0x03) == 0x03) {
1217 #if VM_CHECK_MODE > 0 1234 return block_handler;
1262 else if (
SYMBOL_P(block_handler)) {
1282 #if VM_CHECK_MODE > 0 1283 switch (block->
type) {
1310 static inline const struct rb_block *
1315 return &proc->
block;
1328 static inline const VALUE *
1347 static inline const VALUE *
1380 return block_handler;
1394 return block_handler;
1414 #define SDR() rb_vmdebug_stack_dump_raw(GET_THREAD(), GET_THREAD()->cfp) 1415 #define SDR2(cfp) rb_vmdebug_stack_dump_raw(GET_THREAD(), (cfp)) 1486 #define sysstack_error GET_VM()->special_exceptions[ruby_error_sysstack] 1488 #define RUBY_CONST_ASSERT(expr) (1/!!(expr)) 1489 #define VM_STACK_OVERFLOWED_P(cfp, sp, margin) \ 1490 (!RUBY_CONST_ASSERT(sizeof(*(sp)) == sizeof(VALUE)) || \ 1491 !RUBY_CONST_ASSERT(sizeof(*(cfp)) == sizeof(rb_control_frame_t)) || \ 1492 ((rb_control_frame_t *)((sp) + (margin)) + 1) >= (cfp)) 1493 #define WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) \ 1494 if (LIKELY(!VM_STACK_OVERFLOWED_P(cfp, sp, margin))) {(void)0;} else 1495 #define CHECK_VM_STACK_OVERFLOW0(cfp, sp, margin) \ 1496 WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) vm_stackoverflow() 1497 #define CHECK_VM_STACK_OVERFLOW(cfp, margin) \ 1498 WHEN_VM_STACK_OVERFLOWED(cfp, (cfp)->sp, margin) vm_stackoverflow() 1502 #if RUBY_VM_THREAD_MODEL == 2 1507 #define GET_VM() ruby_current_vm 1509 #ifndef OPT_CALL_CFUNC_WITHOUT_FRAME 1510 #define OPT_CALL_CFUNC_WITHOUT_FRAME 0 1513 #define GET_THREAD() vm_thread_with_frame(ruby_current_thread) 1514 #if OPT_CALL_CFUNC_WITHOUT_FRAME 1518 if (
UNLIKELY(th->passed_ci != 0)) {
1519 void rb_vm_call_cfunc_push_frame(
rb_thread_t *th);
1520 rb_vm_call_cfunc_push_frame(th);
1525 #define vm_thread_with_frame(th) (th) 1528 #define rb_thread_set_current_raw(th) (void)(ruby_current_thread = (th)) 1529 #define rb_thread_set_current(th) do { \ 1530 if ((th)->vm->running_thread != (th)) { \ 1531 (th)->running_time_us = 0; \ 1533 rb_thread_set_current_raw(th); \ 1534 (th)->vm->running_thread = (th); \ 1538 #error "unsupported thread model" 1548 #define RUBY_VM_SET_TIMER_INTERRUPT(th) ATOMIC_OR((th)->interrupt_flag, TIMER_INTERRUPT_MASK) 1549 #define RUBY_VM_SET_INTERRUPT(th) ATOMIC_OR((th)->interrupt_flag, PENDING_INTERRUPT_MASK) 1550 #define RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(th) ATOMIC_OR((th)->interrupt_flag, POSTPONED_JOB_INTERRUPT_MASK) 1551 #define RUBY_VM_SET_TRAP_INTERRUPT(th) ATOMIC_OR((th)->interrupt_flag, TRAP_INTERRUPT_MASK) 1552 #define RUBY_VM_INTERRUPTED(th) ((th)->interrupt_flag & ~(th)->interrupt_mask & (PENDING_INTERRUPT_MASK|TRAP_INTERRUPT_MASK)) 1553 #define RUBY_VM_INTERRUPTED_ANY(th) ((th)->interrupt_flag & ~(th)->interrupt_mask) 1569 #define RUBY_VM_CHECK_INTS(th) ruby_vm_check_ints(th) 1599 #define EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, called_id_, klass_, data_, pop_p_) do { \ 1600 const rb_event_flag_t flag_arg_ = (flag_); \ 1601 if (UNLIKELY(ruby_vm_event_flags & (flag_arg_))) { \ 1603 ruby_exec_event_hook_orig(th_, flag_arg_, self_, id_, called_id_, klass_, data_, pop_p_); \ 1613 trace_arg.
event = flag;
1616 trace_arg.
self =
self;
1628 #define EXEC_EVENT_HOOK(th_, flag_, self_, id_, called_id_, klass_, data_) \ 1629 EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, called_id_, klass_, data_, 0) 1631 #define EXEC_EVENT_HOOK_AND_POP_FRAME(th_, flag_, self_, id_, called_id_, klass_, data_) \ 1632 EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, called_id_, klass_, data_, 1) void rb_thread_stop_timer_thread(void)
static int VM_ENV_ESCAPED_P(const VALUE *ep)
void rb_objspace_free(struct rb_objspace *)
rb_thread_list_t * join_list
union iseq_inline_storage_entry * is_entries
struct rb_ensure_entry rb_ensure_entry_t
unsigned long running_time_us
VALUE rb_get_coverages(void)
VALUE rb_vm_call(rb_thread_t *th, VALUE recv, VALUE id, int argc, const VALUE *argv, const rb_callable_method_entry_t *me)
void rb_threadptr_pending_interrupt_clear(rb_thread_t *th)
void rb_threadptr_signal_raise(rb_thread_t *th, int sig)
const VALUE * default_values
VALUE passed_block_handler
void rb_postponed_job_flush(rb_vm_t *vm)
struct rb_vm_protect_tag * protect_tag
struct rb_thread_struct * running_thread
void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th)
int pending_interrupt_queue_checked
const rb_callable_method_entry_t * me
VALUE rb_proc_alloc(VALUE klass)
const VALUE * rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars)
VALUE rb_iseq_disasm(const rb_iseq_t *iseq)
VALUE rb_iseq_eval_main(const rb_iseq_t *iseq)
static int VM_FRAME_FINISHED_P(const rb_control_frame_t *cfp)
struct rb_thread_struct * th
void rb_unblock_function_t(void *)
void rb_thread_start_timer_thread(void)
VALUE rb_vm_frame_block_handler(const rb_control_frame_t *cfp)
rb_unblock_function_t * func
RUBY_SYMBOL_EXPORT_END int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, ID *called_idp, VALUE *klassp)
union iseq_inline_cache_entry::@193 ic_value
struct iseq_compile_data * compile_data
struct st_table * loaded_features_index
static const rb_iseq_t * rb_iseq_check(const rb_iseq_t *iseq)
struct list_node vmlt_node
static const VALUE * vm_proc_ep(VALUE procval)
VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0)
rb_iseq_t * rb_iseq_compile(VALUE src, VALUE file, VALUE line)
VALUE pending_interrupt_mask_stack
static void rb_vm_living_threads_insert(rb_vm_t *vm, rb_thread_t *th)
const rb_callable_method_entry_t * rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
RUBY_EXTERN VALUE rb_cRubyVM
static const rb_iseq_t * vm_proc_iseq(VALUE procval)
#define VM_ENV_DATA_INDEX_ENV_PROC
VALUE rb_thread_alloc(VALUE klass)
VALUE rb_name_err_mesg_new(VALUE mesg, VALUE recv, VALUE method)
rb_iseq_t * rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE line, const struct rb_block *base_block, VALUE opt)
const rb_data_type_t ruby_binding_data_type
int rb_autoloading_value(VALUE mod, ID id, VALUE *value)
#define VM_BLOCK_HANDLER_NONE
#define RB_SPECIAL_CONST_P(x)
static VALUE VM_BH_TO_SYMBOL(VALUE block_handler)
size_t fiber_machine_stack_size
unsigned int report_on_exception
struct rb_iseq_constant_body * body
rb_vm_t * ruby_current_vm
void ruby_thread_init_stack(rb_thread_t *th)
st_table * frozen_strings
struct rb_call_info_kw_arg * kw_arg
rb_at_exit_list * at_exit
#define VM_TAGGED_PTR_REF(v, mask)
struct rb_hook_list_struct rb_hook_list_t
struct rb_vm_protect_tag * prev
static int VM_FRAME_CFRAME_P(const rb_control_frame_t *cfp)
struct rb_control_frame_struct rb_control_frame_t
rb_vm_at_exit_func * func
static void rb_vm_living_threads_remove(rb_vm_t *vm, rb_thread_t *th)
static void ruby_vm_check_ints(rb_thread_t *th)
VALUE local_storage_recursive_hash_for_trace
VALUE rb_vm_make_proc(rb_thread_t *th, const struct rb_captured_block *captured, VALUE klass)
static int VM_ENV_LOCAL_P(const VALUE *ep)
struct rb_thread_list_struct rb_thread_list_t
static int VM_FRAME_RUBYFRAME_P(const rb_control_frame_t *cfp)
void rb_vm_rewrite_cref(rb_cref_t *node, VALUE old_klass, VALUE new_klass, rb_cref_t **new_cref_ptr)
void rb_vmdebug_stack_dump_raw(rb_thread_t *, rb_control_frame_t *)
int rb_threadptr_pending_interrupt_active_p(rb_thread_t *th)
void rb_vm_stack_to_heap(rb_thread_t *th)
#define vm_thread_with_frame(th)
const VALUE * iseq_encoded
VALUE rb_vm_env_local_variables(const rb_env_t *env)
static const struct rb_captured_block * VM_BH_TO_CAPT_BLOCK(VALUE block_handler)
rb_control_frame_t * rb_vm_get_binding_creatable_next_cfp(const rb_thread_t *th, const rb_control_frame_t *cfp)
unsigned int thread_abort_on_exception
#define RB_TYPE_P(obj, type)
VALUE defined_module_hash
#define RUBY_VM_INTERRUPTED_ANY(th)
void rb_thread_reset_timer_thread(void)
rb_iseq_t * rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent)
void rb_vmdebug_debug_print_pre(rb_thread_t *th, rb_control_frame_t *cfp, const VALUE *_pc)
unsigned short first_lineno
rb_iseq_t * rb_iseq_new_with_opt(NODE *, VALUE, VALUE, VALUE, VALUE, const rb_iseq_t *parent, enum iseq_type, const rb_compile_option_t *)
void rb_thread_wakeup_timer_thread(void)
static int rb_obj_is_iseq(VALUE iseq)
static int VM_BH_ISEQ_BLOCK_P(VALUE block_handler)
VALUE(* vm_call_handler)(struct rb_thread_struct *th, struct rb_control_frame_struct *cfp, struct rb_calling_info *calling, const struct rb_call_info *ci, struct rb_call_cache *cc)
unsigned int local_table_size
struct st_table * ensure_rollback_table
void rb_gc_mark_machine_stack(rb_thread_t *th)
rb_iseq_t * rb_iseq_new_with_bopt(NODE *, VALUE, VALUE, VALUE, VALUE, VALUE, enum iseq_type, VALUE)
struct rb_call_info * ci_entries
void rb_signal_exec(rb_thread_t *th, int sig)
size_t fiber_vm_stack_size
struct rb_vm_struct rb_vm_t
void * blocking_region_buffer
void rb_vm_rewind_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
rb_iseq_t * rb_iseq_new_main(NODE *node, VALUE path, VALUE absolute_path, const rb_iseq_t *parent)
VALUE load_path_check_cache
struct rb_ensure_list rb_ensure_list_t
static VALUE VM_BH_FROM_PROC(VALUE procval)
void rb_threadptr_exec_event_hooks_and_pop_frame(struct rb_trace_arg_struct *trace_arg)
static const struct rb_captured_block * VM_BH_TO_ISEQ_BLOCK(VALUE block_handler)
struct st_table * loading_table
void rb_vm_register_special_exception(enum ruby_special_exceptions sp, VALUE exception_class, const char *mesg)
struct rb_iseq_location_struct rb_iseq_location_t
static void vm_block_type_set(const struct rb_block *block, enum rb_block_type type)
static unsigned long VM_ENV_FLAGS(const VALUE *ep, long flag)
VALUE rb_iseq_coverage(const rb_iseq_t *iseq)
void rb_threadptr_signal_exit(rb_thread_t *th)
static const rb_env_t * vm_env_new(VALUE *env_ep, VALUE *env_body, unsigned int env_size, const rb_iseq_t *iseq)
static int VM_BH_IFUNC_P(VALUE block_handler)
struct rb_event_hook_struct * hooks
static const rb_env_t * VM_ENV_ENVVAL_PTR(const VALUE *ep)
#define VM_ENV_DATA_INDEX_SPECVAL
int rb_signal_buff_size(void)
const char * ruby_node_name(int node)
static void rb_vm_living_threads_init(rb_vm_t *vm)
static VALUE vm_block_self(const struct rb_block *block)
rb_hook_list_t event_hooks
void rb_vm_pop_frame(rb_thread_t *th)
struct rb_call_cache * cc_entries
static const struct rb_block * vm_proc_block(VALUE procval)
static void VM_FORCE_WRITE(const VALUE *ptr, VALUE v)
VALUE rb_obj_is_proc(VALUE)
struct rb_mutex_struct * keeping_mutexes
unsigned long rb_serial_t
VALUE rb_vm_make_proc_lambda(rb_thread_t *th, const struct rb_captured_block *captured, VALUE klass, int8_t is_lambda)
NORETURN(void rb_bug_context(const void *, const char *fmt,...))
unsigned int ambiguous_param0
static enum rb_block_handler_type vm_block_handler_type(VALUE block_handler)
#define RUBY_SYMBOL_EXPORT_END
rb_event_flag_t ruby_vm_event_flags
static const rb_iseq_t * vm_block_iseq(const struct rb_block *block)
static void VM_STACK_ENV_WRITE(const VALUE *ep, int index, VALUE v)
void rb_threadptr_pending_interrupt_enque(rb_thread_t *th, VALUE v)
struct list_head waiting_fds
size_t thread_vm_stack_size
rb_thread_t * ruby_current_thread
void rb_vm_bugreport(const void *)
VALUE rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp)
static const VALUE * vm_block_ep(const struct rb_block *block)
rb_control_frame_t * rb_vm_get_ruby_level_next_cfp(const rb_thread_t *th, const rb_control_frame_t *cfp)
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.
const rb_data_type_t ruby_threadptr_data_type
struct rb_thread_struct * main_thread
int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp)
#define RUBY_SYMBOL_EXPORT_BEGIN
RUBY_SYMBOL_EXPORT_BEGIN int rb_thread_check_trap_pending(void)
struct rb_at_exit_list * next
static enum rb_block_type vm_block_type(const struct rb_block *block)
static VALUE VM_BH_FROM_IFUNC_BLOCK(const struct rb_captured_block *captured)
#define VM_ENV_DATA_INDEX_FLAGS
VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt)
const struct vm_ifunc * ifunc
rb_atomic_t interrupt_flag
rb_nativethread_cond_t interrupt_cond
struct rb_calling_info * calling
int rb_backtrace_iter_func(void *, VALUE, int, VALUE)
VALUE rb_binding_alloc(VALUE klass)
struct rb_ensure_list * next
static void ruby_exec_event_hook_orig(rb_thread_t *const th, const rb_event_flag_t flag, VALUE self, ID id, ID called_id, VALUE klass, VALUE data, int pop_p)
const rb_callable_method_entry_t * passed_bmethod_me
struct rb_captured_block captured
struct rb_at_exit_list rb_at_exit_list
#define VM_ENV_DATA_INDEX_ENV
static unsigned long VM_FRAME_TYPE(const rb_control_frame_t *cfp)
static VALUE env_size(void)
void rb_vm_change_state(void)
static VALUE VM_BH_TO_PROC(VALUE block_handler)
const rb_cref_t * ic_cref
rb_iseq_t * rb_iseq_compile_on_base(VALUE src, VALUE file, VALUE line, const struct rb_block *base_block)
void rb_vm_gvl_destroy(rb_vm_t *vm)
struct rb_objspace * objspace
const struct iseq_catch_table * catch_table
unsigned long interrupt_mask
void rb_threadptr_interrupt(rb_thread_t *th)
unsigned int abort_on_exception
static VALUE VM_ENV_BLOCK_HANDLER(const VALUE *ep)
rb_hook_list_t event_hooks
struct rb_iseq_struct * local_iseq
static VALUE VM_ENV_PROCVAL(const VALUE *ep)
rb_nativethread_id_t thread_id
void rb_threadptr_error_print(rb_thread_t *volatile th, volatile VALUE errinfo)
rb_nativethread_lock_t thread_destruct_lock
rb_control_frame_t *FUNC_FASTCALL rb_insn_func_t(rb_thread_t *, rb_control_frame_t *)
const struct rb_block block
void rb_set_coverages(VALUE)
static int vm_block_handler_verify(VALUE block_handler)
static VALUE VM_BH_FROM_SYMBOL(VALUE symbol)
struct rb_call_cache * CALL_CACHE
struct iseq_inline_cache_entry * IC
const VALUE * rb_vm_ep_local_ep(const VALUE *ep)
native_thread_data_t native_thread_data
size_t thread_machine_stack_size
struct rb_thread_struct * running_thread
unsigned int thread_report_on_exception
#define VM_UNREACHABLE(func)
RUBY_SYMBOL_EXPORT_BEGIN rb_iseq_t * rb_iseq_new(NODE *, VALUE, VALUE, VALUE, const rb_iseq_t *parent, enum iseq_type)
void rb_reset_coverages(void)
void rb_vm_at_exit_func(struct rb_vm_struct *)
static void VM_FORCE_WRITE_SPECIAL_CONST(const VALUE *ptr, VALUE special_const_value)
const rb_env_t * rb_vm_env_prev_env(const rb_env_t *env)
static void VM_ENV_FLAGS_UNSET(const VALUE *ep, VALUE flag)
int rb_vm_get_sourceline(const rb_control_frame_t *)
void rb_vm_inc_const_missing_count(void)
rb_ensure_list_t * ensure_list
VALUE loaded_features_snapshot
const struct rb_iseq_struct * parent_iseq
const struct iseq_line_info_entry * line_info_table
char rb_thread_id_string_t[sizeof(rb_nativethread_id_t) *2+3]
static VALUE VM_BH_FROM_ISEQ_BLOCK(const struct rb_captured_block *captured)
void rb_vmdebug_debug_print_post(rb_thread_t *th, rb_control_frame_t *cfp)
struct rb_objspace * rb_objspace_alloc(void)
const VALUE * rb_vm_proc_local_ep(VALUE proc)
VALUE local_storage_recursive_hash
unsigned int line_info_size
struct rb_thread_list_struct * next
struct rb_thread_struct rb_thread_t
struct list_head living_threads
#define RTYPEDDATA_DATA(v)
struct rb_call_info * CALL_INFO
#define GC_GUARDED_PTR_REF(p)
struct rb_postponed_job_struct * postponed_job_buffer
void rb_bug_context(const void *ctx, const char *fmt,...)
rb_nativethread_lock_t interrupt_lock
void rb_threadptr_check_signal(rb_thread_t *mth)
void rb_threadptr_exec_event_hooks(struct rb_trace_arg_struct *trace_arg)
VALUE pending_interrupt_queue
RUBY_EXTERN VALUE rb_mRubyVMFrozenCore
void rb_threadptr_execute_interrupts(rb_thread_t *, int)
static int VM_FRAME_BMETHOD_P(const rb_control_frame_t *cfp)
static VALUE VM_ENV_ENVVAL(const VALUE *ep)
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_iseq_eval(const rb_iseq_t *iseq)
static const VALUE * VM_ENV_PREV_EP(const VALUE *ep)
RUBY_EXTERN VALUE rb_cISeq
static void VM_ENV_FLAGS_SET(const VALUE *ep, VALUE flag)
VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, int argc, const VALUE *argv, VALUE block_handler)
union rb_captured_block::@202 code
struct rb_trace_arg_struct * trace_arg
rb_iseq_location_t location
static const struct rb_captured_block * VM_BH_TO_IFUNC_BLOCK(VALUE block_handler)
#define VM_TAGGED_PTR_SET(p, tag)