25 static inline const VALUE *
61 static inline const VALUE *
67 static inline const VALUE *
95 if (start <= (
VALUE *)cfp && (
VALUE *)cfp < end) {
110 if (start <= ep && ep < end) {
121 if (VM_EP_IN_HEAP_P(th, ep)) {
139 rb_vm_ep_in_heap_p(
const VALUE *ep)
173 return block_handler;
180 int omod_shared =
FALSE;
190 scope_visi.visi.module_func = module_func;
193 if (prev_cref !=
NULL && prev_cref != (
void *)1 ) {
196 if (!
NIL_P(refinements)) {
219 return vm_cref_new0(klass, visi, module_func, prev_cref, pushed_by_eval,
TRUE);
261 fprintf(stderr,
"vm_cref_dump: %s (%p)\n", mesg, cref);
277 #if VM_COLLECT_USAGE_DETAILS 278 static void vm_collect_usage_operand(
int insn,
int n,
VALUE op);
279 static void vm_collect_usage_insn(
int insn);
280 static void vm_collect_usage_register(
int reg,
int isset);
288 int argc,
const VALUE *argv,
VALUE block_handler);
314 #define ruby_vm_redefined_flag GET_VM()->redefined_flag 325 ruby_vm_const_missing_count +=1;
341 klass =
RBASIC(klass)->klass;
354 classname =
"<unknown>";
391 static VALUE sym_global_method_state, sym_global_constant_state, sym_class_serial;
407 if (sym_global_method_state == 0) {
408 #define S(s) sym_##s = ID2SYM(rb_intern_const(#s)) 409 S(global_method_state);
410 S(global_constant_state);
415 #define SET(name, attr) \ 416 if (key == sym_##name) \ 417 return SERIALT2NUM(attr); \ 418 else if (hash != Qnil) \ 419 rb_hash_aset(hash, sym_##name, SERIALT2NUM(attr)); 421 SET(global_method_state, ruby_vm_global_method_state);
422 SET(global_constant_state, ruby_vm_global_constant_state);
423 SET(class_serial, ruby_vm_class_serial);
438 if (iseq->
body->
type != ISEQ_TYPE_TOP) {
538 while (th->
cfp != cfp) {
540 printf(
"skipped frame: %s\n", vm_frametype_name(th->
cfp));
591 fprintf(stderr,
"---\n");
592 fprintf(stderr,
"envptr: %p\n", (
void *)&env->
ep[0]);
593 fprintf(stderr,
"envval: %10p ", (
void *)env->
ep[1]);
595 fprintf(stderr,
"ep: %10p\n", (
void *)env->
ep);
597 fprintf(stderr,
">>\n");
599 fprintf(stderr,
"<<\n");
625 *procvalptr = block_handler;
636 const VALUE *
const ep = cfp->
ep;
639 VALUE *env_body, *env_ep;
652 while (prev_cfp->
ep != prev_ep) {
689 env_size = local_size +
691 (blockprocval ? 1 : 0) ;
693 MEMCPY(env_body, ep - (local_size - 1 ),
VALUE, local_size);
696 for (i = 0; i < local_size; i++) {
699 ep[-local_size + i] = 0;
705 env_ep = &env_body[local_size - 1 ];
707 env =
vm_env_new(env_ep, env_body, env_size, env_iseq);
709 if (blockprocval)
RB_OBJ_WRITE(env, &env_ep[2], blockprocval);
808 int8_t safe_level, int8_t is_from_method, int8_t is_lambda)
831 int8_t safe_level, int8_t is_from_method, int8_t is_lambda)
893 VALUE bindval, envval;
896 if (cfp == 0 || ruby_level_cfp == 0) {
902 if (cfp == ruby_level_cfp) {
928 ID minibuf[4], *dyns = minibuf;
931 if (dyncount < 0)
return 0;
933 base_block = &bind->
block;
939 MEMCPY(dyns + 1, dynvars,
ID, dyncount);
1001 const rb_cref_t *cref,
const int splattable,
int is_lambda)
1010 for (i=0; i<
argc; i++) {
1018 return invoke_block(th, iseq,
self, captured, cref, type, opt_pc);
1021 return invoke_bmethod(th, iseq,
self, captured, me, type, opt_pc);
1027 int argc,
const VALUE *argv,
1029 int splattable,
int is_lambda)
1037 argc, argv, passed_block_handler,
1038 cref, splattable, is_lambda);
1042 argc, argv, passed_block_handler);
1064 return block_handler;
1072 cref,
FALSE, is_lambda);
1087 argc, argv, block_handler,
1100 VALUE passed_block_handler,
int is_lambda)
1121 int argc,
const VALUE *argv,
VALUE passed_block_handler)
1144 int argc,
const VALUE *argv,
VALUE block_handler)
1151 int argc,
const VALUE *argv,
VALUE passed_block_handler)
1160 return vm_invoke_proc(th, proc,
self, argc, argv, passed_block_handler);
1169 while (cfp->
pc == 0) {
1285 if (pline) *pline = 0;
1294 if (!path)
return 0;
1326 if (cfp->
self !=
self)
return NULL;
1339 printf(
"%ld\n", CREF_VISI(cref));
1556 #define OP(mid_, bop_) (mid = id##mid_, bop = BOP_##bop_, ruby_vm_redefined_flag[bop] = 0) 1557 #define C(k) add_opt_method(rb_c##k, mid, bop) 1558 OP(PLUS, PLUS), (
C(Integer),
C(Float),
C(String),
C(Array));
1559 OP(MINUS, MINUS), (
C(Integer),
C(Float));
1560 OP(MULT, MULT), (
C(Integer),
C(Float));
1563 OP(Eq, EQ), (
C(Integer),
C(Float),
C(String));
1564 OP(Eqq, EQQ), (
C(Integer),
C(Float),
C(Symbol),
C(String),
1565 C(NilClass),
C(TrueClass),
C(FalseClass));
1566 OP(LT, LT), (
C(Integer),
C(Float));
1567 OP(LE, LE), (
C(Integer),
C(Float));
1568 OP(GT, GT), (
C(Integer),
C(Float));
1569 OP(GE, GE), (
C(Integer),
C(Float));
1570 OP(LTLT, LTLT), (
C(String),
C(Array));
1572 OP(ASET, ASET), (
C(Array),
C(Hash));
1573 OP(Length, LENGTH), (
C(Array),
C(String),
C(Hash));
1574 OP(
Size, SIZE), (
C(Array),
C(String),
C(Hash));
1575 OP(EmptyP, EMPTY_P), (
C(Array),
C(String),
C(Hash));
1576 OP(Succ, SUCC), (
C(Integer),
C(String),
C(Time));
1578 OP(Freeze, FREEZE), (
C(String));
1627 #define C(t) if (type == VM_FRAME_MAGIC_##t) return #t 1661 if (!will_finish_vm_exec) {
1775 if ((state = th->
state) != 0) {
1778 goto exception_handler;
1784 const struct iseq_catch_table *ct;
1785 unsigned long epc, cont_pc, cont_sp;
1794 cont_pc = cont_sp = 0;
1817 if (cfp == escape_cfp) {
1825 if (ct)
for (i = 0; i < ct->size; i++) {
1826 entry = &ct->entries[i];
1827 if (entry->
start < epc && entry->
end >= epc) {
1828 if (entry->
type == CATCH_TYPE_ENSURE) {
1829 catch_iseq = entry->
iseq;
1830 cont_pc = entry->
cont;
1831 cont_sp = entry->
sp;
1836 if (catch_iseq ==
NULL) {
1849 #if OPT_STACK_CACHING 1862 if (ct)
for (i = 0; i < ct->size; i++) {
1863 entry = &ct->entries[i];
1864 if (entry->
start < epc && entry->
end >= epc) {
1866 if (entry->
type == CATCH_TYPE_RESCUE ||
1867 entry->
type == CATCH_TYPE_ENSURE) {
1868 catch_iseq = entry->
iseq;
1869 cont_pc = entry->
cont;
1870 cont_sp = entry->
sp;
1878 if (ct)
for (i = 0; i < ct->size; i++) {
1879 entry = &ct->entries[i];
1880 if (entry->
start < epc && entry->
end >= epc) {
1882 if (entry->
type == CATCH_TYPE_ENSURE) {
1883 catch_iseq = entry->
iseq;
1884 cont_pc = entry->
cont;
1885 cont_sp = entry->
sp;
1888 else if (entry->
type == CATCH_TYPE_RETRY) {
1891 if (cfp == escape_cfp) {
1900 else if (state ==
TAG_BREAK && !escape_cfp) {
1901 type = CATCH_TYPE_BREAK;
1903 search_restart_point:
1905 if (ct)
for (i = 0; i < ct->size; i++) {
1906 entry = &ct->entries[i];
1908 if (entry->
start < epc && entry->
end >= epc) {
1909 if (entry->
type == CATCH_TYPE_ENSURE) {
1910 catch_iseq = entry->
iseq;
1911 cont_pc = entry->
cont;
1912 cont_sp = entry->
sp;
1915 else if (entry->
type == type) {
1920 #if OPT_STACK_CACHING 1934 type = CATCH_TYPE_REDO;
1935 goto search_restart_point;
1938 type = CATCH_TYPE_NEXT;
1939 goto search_restart_point;
1943 if (ct)
for (i = 0; i < ct->size; i++) {
1944 entry = &ct->entries[i];
1945 if (entry->
start < epc && entry->
end >= epc) {
1947 if (entry->
type == CATCH_TYPE_ENSURE) {
1948 catch_iseq = entry->
iseq;
1949 cont_pc = entry->
cont;
1950 cont_sp = entry->
sp;
1957 if (catch_iseq !=
NULL) {
1959 const int arg_size = 1;
1972 cfp->
sp + arg_size ,
1992 goto exception_handler;
2031 if (called_idp) *called_idp = me->
called_id;
2032 if (klassp) *klassp = me->
owner;
2059 if (cfp->
iseq != 0) {
2086 recv, block_handler,
2088 0, reg_cfp->
sp, 0, 0);
2106 RUBY_GC_INFO(
"-------------------------------------------------\n");
2199 ruby_current_vm = 0;
2231 #define SET(name) rb_hash_aset(result, ID2SYM(rb_intern(#name)), SIZET2NUM(vm->default_params.name)); 2232 SET(thread_vm_stack_size);
2233 SET(thread_machine_stack_size);
2234 SET(fiber_vm_stack_size);
2235 SET(fiber_machine_stack_size);
2245 size_t result = default_value;
2246 if ((envval =
getenv(name)) != 0) {
2247 long val = atol(envval);
2248 if (val < (
long)min_value) {
2249 val = (long)min_value;
2253 if (0) fprintf(stderr,
"%s: %"PRIuSIZE"\n", name, result);
2261 #ifdef PTHREAD_STACK_MIN 2262 size_t size = *sizep;
2265 #ifdef PTHREAD_STACK_MIN 2266 if (size < PTHREAD_STACK_MIN) {
2267 *sizep = PTHREAD_STACK_MIN * 2;
2281 get_param(
"RUBY_THREAD_MACHINE_STACK_SIZE",
2291 get_param(
"RUBY_FIBER_MACHINE_STACK_SIZE",
2312 #define USE_THREAD_DATA_RECYCLE 1 2314 #if USE_THREAD_DATA_RECYCLE 2315 #define RECYCLE_MAX 64 2322 if (thread_recycle_stack_count > 0) {
2332 #define thread_recycle_stack(size) ALLOC_N(VALUE, (size)) 2340 #if USE_THREAD_DATA_RECYCLE 2342 thread_recycle_stack_slot[thread_recycle_stack_count++] = stack;
2365 while (cfp != limit_cfp) {
2366 #if VM_CHECK_MODE > 0 2433 rb_bug(
"thread_free: locking_mutex must be NULL (%p:%p)", (
void *)th, (
void *)th->
locking_mutex);
2436 rb_bug(
"thread_free: keeping_mutexes must be NULL (%p:%p)", (
void *)th, (
void *)th->
keeping_mutexes);
2447 #ifdef USE_SIGALTSTACK 2454 if (ruby_current_thread == th)
2455 ruby_current_thread =
NULL;
2475 #define thread_data_type ruby_threadptr_data_type 2483 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
2513 #ifdef USE_SIGALTSTACK 2528 0 , th->
stack, 0, 0);
2536 #ifdef NON_SCALAR_THREAD_ID 2537 th->thread_id_string[0] =
'\0';
2540 #if OPT_CALL_THREADED_CODE 2578 if (!is_singleton) {
2599 #define REWIND_CFP(expr) do { \ 2600 rb_thread_t *th__ = GET_THREAD(); \ 2601 VALUE *const curr_sp = (th__->cfp++)->sp; \ 2602 VALUE *const saved_sp = th__->cfp->sp; \ 2603 th__->cfp->sp = curr_sp; \ 2605 (th__->cfp--)->sp = saved_sp; \ 2672 for (i=0; i<
argc; i+=2) {
2715 VALUE hash = argv[0];
2753 if (argc < 2) hash = kw;
2761 extern VALUE *rb_gc_register_stack_start;
2780 #include <execinfo.h> 2781 #define MAX_NATIVE_TRACE 1024 2782 static void *trace[MAX_NATIVE_TRACE];
2783 int n = (int)backtrace(trace, MAX_NATIVE_TRACE);
2784 char **syms = backtrace_symbols(trace, n);
2791 for (i=0; i<n; i++) {
2799 #if VM_COLLECT_USAGE_DETAILS 2800 static VALUE usage_analysis_insn_stop(
VALUE self);
2801 static VALUE usage_analysis_operand_stop(
VALUE self);
2802 static VALUE usage_analysis_register_stop(
VALUE self);
2840 rb_mRubyVMFrozenCore = fcore;
2992 #if VM_COLLECT_USAGE_DETAILS 2994 #define define_usage_analysis_hash(name) \ 2995 rb_define_const(rb_cRubyVM, "USAGE_ANALYSIS_" #name, rb_hash_new()) 2996 define_usage_analysis_hash(
INSN);
2997 define_usage_analysis_hash(REGS);
2998 define_usage_analysis_hash(INSN_BIGRAM);
3008 #if OPT_DIRECT_THREADED_CODE 3010 #elif OPT_TOKEN_THREADED_CODE 3012 #elif OPT_CALL_THREADED_CODE 3016 #if OPT_STACK_CACHING 3019 #if OPT_OPERANDS_UNIFICATION 3022 #if OPT_INSTRUCTIONS_UNIFICATION 3025 #if OPT_INLINE_METHOD_CACHE 3028 #if OPT_BLOCKINLINING 3058 volatile VALUE th_self;
3077 th->
cfp->
pc = iseq->body->iseq_encoded;
3113 fprintf(stderr,
"[FATAL] failed to allocate memory\n");
3121 ruby_current_vm = vm;
3153 return GET_VM()->top_self;
3198 return GET_VM()->frozen_strings;
3201 #if VM_COLLECT_USAGE_DETAILS 3203 #define HASH_ASET(h, k, v) rb_hash_aset((h), (st_data_t)(k), (st_data_t)(v)) 3217 vm_analysis_insn(
int insn)
3221 static int prev_insn = -1;
3227 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
3228 CONST_ID(bigram_hash,
"USAGE_ANALYSIS_INSN_BIGRAM");
3232 HASH_ASET(uh,
INT2FIX(insn), ihash);
3240 if (prev_insn != -1) {
3259 vm_analysis_operand(
int insn,
int n,
VALUE op)
3269 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
3274 HASH_ASET(uh,
INT2FIX(insn), ihash);
3278 HASH_ASET(ihash,
INT2FIX(n), ophash);
3291 vm_analysis_register(
int reg,
int isset)
3296 static const char regstrs[][5] = {
3304 static const char getsetstr[][4] = {
3308 static VALUE syms[
sizeof(regstrs) /
sizeof(regstrs[0])][2];
3312 CONST_ID(usage_hash,
"USAGE_ANALYSIS_REGS");
3317 for (i = 0; i < (int)(
sizeof(regstrs) /
sizeof(regstrs[0])); i++) {
3319 for (j = 0; j < 2; j++) {
3320 snprintf(buff, 0x10,
"%d %s %-4s", i, getsetstr[j], regstrs[i]);
3325 valstr = syms[reg][isset];
3342 usage_analysis_insn_stop(
VALUE self)
3350 usage_analysis_operand_stop(
VALUE self)
3358 usage_analysis_register_stop(
VALUE self)
3372 #if VM_COLLECT_USAGE_DETAILS 3375 vm_collect_usage_insn(
int insn)
3377 if (RUBY_DTRACE_INSN_ENABLED()) {
3381 (*ruby_vm_collect_usage_func_insn)(insn);
3389 vm_collect_usage_operand(
int insn,
int n,
VALUE op)
3391 if (RUBY_DTRACE_INSN_OPERAND_ENABLED()) {
3400 (*ruby_vm_collect_usage_func_operand)(insn, n, op);
3406 vm_collect_usage_register(
int reg,
int isset)
3409 (*ruby_vm_collect_usage_func_register)(reg, isset);
3413 #include "vm_call_iseq_optimized.inc" static VALUE core_hash_merge_kwd(int argc, VALUE *argv)
RUBY_EXTERN VALUE rb_cString
void rb_define_global_const(const char *, VALUE)
#define RBASIC_CLEAR_CLASS(obj)
static VALUE classname(VALUE klass, int *permanent)
Returns +classpath+ of klass, if it is named, or +nil+ for anonymous +class+/+module+.
#define RUBY_VM_THREAD_MACHINE_STACK_SIZE
#define RUBY_ASSERT_MESG(expr, mesg)
#define RUBY_EVENT_B_RETURN
static int VM_ENV_ESCAPED_P(const VALUE *ep)
rb_control_frame_t * rb_vm_get_ruby_level_next_cfp(const rb_thread_t *th, const rb_control_frame_t *cfp)
#define VM_DEBUG_BP_CHECK
static const VALUE * VM_CF_LEP(const rb_control_frame_t *const cfp)
#define NEXT_CLASS_SERIAL()
static VALUE m_core_set_postexe(VALUE self)
rb_iseq_t * rb_iseq_new(NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent, enum iseq_type type)
static VALUE core_hash_merge(VALUE hash, long argc, const VALUE *argv)
static rb_serial_t ruby_vm_global_constant_state
static void thread_free(void *ptr)
VALUE rb_proc_alloc(VALUE klass)
static VALUE invoke_block_from_c_splattable(rb_thread_t *th, VALUE block_handler, int argc, const VALUE *argv, VALUE passed_block_handler, const rb_cref_t *cref, int splattable, int is_lambda)
void rb_vm_check_redefinition_by_prepend(VALUE klass)
static VALUE make_localjump_error(const char *mesg, VALUE value, int reason)
RUBY_EXTERN VALUE rb_cFalseClass
RUBY_EXTERN VALUE rb_cFloat
#define RUBY_EVENT_C_RETURN
void rb_bug(const char *fmt,...)
VALUE passed_block_handler
static size_t vm_memsize(const void *ptr)
#define RUBY_TYPED_FREE_IMMEDIATELY
void(* ruby_vm_collect_usage_func_insn)(int insn)
VALUE ruby_vm_const_missing_count
static void vm_init2(rb_vm_t *vm)
struct rb_thread_struct * running_thread
#define RUBY_DTRACE_METHOD_RETURN_HOOK(th, klass, id)
void rb_objspace_free(rb_objspace_t *objspace)
int rb_vm_get_sourceline(const rb_control_frame_t *cfp)
#define RUBY_EVENT_RETURN
static VALUE vm_yield_lambda_splattable(rb_thread_t *th, VALUE args)
static VALUE lep_svar_get(rb_thread_t *th, const VALUE *lep, rb_num_t key)
static void hook_before_rewind(rb_thread_t *th, const rb_control_frame_t *cfp, int will_finish_vm_exec, int state, struct vm_throw_data *err)
void rb_add_method_iseq(VALUE klass, ID mid, const rb_iseq_t *iseq, rb_cref_t *cref, rb_method_visibility_t visi)
VALUE rb_hash_dup(VALUE hash)
static int vm_env_cref_by_cref(const VALUE *ep)
static rb_cref_t * rb_vm_get_cref(const VALUE *ep)
struct rb_thread_struct::@204 machine
#define RB_OBJ_WRITTEN(a, oldv, b)
static unsigned int hash(str, len) register const char *str
void rb_undef_alloc_func(VALUE)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)
static VALUE vm_yield(rb_thread_t *th, int argc, const VALUE *argv)
static int VM_FRAME_FINISHED_P(const rb_control_frame_t *cfp)
static int kwcheck_i(VALUE key, VALUE value, VALUE hash)
VALUE rb_iseq_eval_main(const rb_iseq_t *iseq)
#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN
void rb_vm_mark(void *ptr)
VALUE rb_fstring_cstr(const char *str)
static void lep_svar_set(rb_thread_t *th, const VALUE *lep, rb_num_t key, VALUE val)
void rb_vm_pop_cfunc_frame(void)
static VALUE check_block_handler(rb_thread_t *th)
static const rb_iseq_t * rb_iseq_check(const rb_iseq_t *iseq)
struct rb_method_definition_struct *const def
static int block_proc_is_lambda(const VALUE procval)
VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0)
#define TypedData_Wrap_Struct(klass, data_type, sval)
static VALUE m_core_undef_method(VALUE self, VALUE cbase, VALUE sym)
void rb_fiber_reset_root_local_storage(VALUE thval)
static int CREF_PUSHED_BY_EVAL(const rb_cref_t *cref)
VALUE pending_interrupt_mask_stack
void(* ruby_vm_collect_usage_func_operand)(int insn, int n, VALUE op)
static void rb_vm_living_threads_insert(rb_vm_t *vm, rb_thread_t *th)
VALUE rb_insns_name_array(void)
const rb_callable_method_entry_t * rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
void ruby_mimfree(void *ptr)
VALUE * rb_ruby_debug_ptr(void)
static VALUE * ruby_vm_debug_ptr(rb_vm_t *vm)
#define TH_JUMP_TAG(th, st)
#define HASH_REDEFINED_OP_FLAG
VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, int argc, const VALUE *argv, VALUE passed_block_handler)
VALUE rb_ary_push(VALUE ary, VALUE item)
#define VM_BLOCK_HANDLER_NONE
static void vm_define_method(rb_thread_t *th, VALUE obj, ID id, VALUE iseqval, int is_singleton)
SSL_METHOD *(* func)(void)
PUREFUNC(static inline const VALUE *VM_EP_LEP(const VALUE *))
#define RUBY_VM_SIZE_ALIGN
static VALUE VM_BH_TO_SYMBOL(VALUE block_handler)
size_t fiber_machine_stack_size
VALUE rb_ary_tmp_new(long capa)
struct rb_iseq_constant_body * body
VALUE rb_backref_get(void)
st_table * frozen_strings
VALUE rb_iv_set(VALUE, const char *, VALUE)
rb_at_exit_list * at_exit
#define VM_TAGGED_PTR_REF(v, mask)
static VALUE vm_yield_with_cref(rb_thread_t *th, int argc, const VALUE *argv, const rb_cref_t *cref, int is_lambda)
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_thread_alloc(VALUE klass)
static rb_control_frame_t * vm_normal_frame(rb_thread_t *th, rb_control_frame_t *cfp)
VALUE rb_insn_operand_intern(const rb_iseq_t *iseq, VALUE insn, int op_no, VALUE op, int len, size_t pos, VALUE *pnop, VALUE child)
#define RUBY_MARK_LEAVE(msg)
VALUE rb_convert_type(VALUE, int, const char *, const char *)
struct rb_iseq_constant_body::@196 param
parameter information
static int thread_recycle_stack_count
static int free_loading_table_entry(st_data_t key, st_data_t value, st_data_t arg)
void Init_vm_backtrace(void)
void rb_vm_localjump_error(const char *mesg, VALUE value, int reason)
rb_vm_at_exit_func * func
rb_serial_t rb_next_class_serial(void)
static VALUE CREF_REFINEMENTS(const rb_cref_t *cref)
static int THROW_DATA_CONSUMED_P(const struct vm_throw_data *obj)
void rb_gc_mark(VALUE ptr)
#define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)
static VALUE invoke_iseq_block_from_c(rb_thread_t *th, const struct rb_captured_block *captured, VALUE self, int argc, const VALUE *argv, VALUE passed_block_handler, const rb_cref_t *cref, const int splattable, int is_lambda)
static VALUE * thread_recycle_stack_slot[RECYCLE_MAX]
static VALUE vm_cfp_svar_get(rb_thread_t *th, rb_control_frame_t *cfp, VALUE key)
VALUE rb_proc_create(VALUE klass, const struct rb_block *block, int8_t safe_level, int8_t is_from_method, int8_t is_lambda)
VALUE rb_sourcefilename(void)
VALUE local_storage_recursive_hash_for_trace
static int VM_ENV_LOCAL_P(const VALUE *ep)
RUBY_EXTERN VALUE rb_cProc
static int VM_FRAME_RUBYFRAME_P(const rb_control_frame_t *cfp)
static const rb_data_type_t vm_data_type
#define RUBY_VM_FIBER_VM_STACK_SIZE
static VALUE vm_default_params(void)
static int check_env(const rb_env_t *env)
static const VALUE * VM_EP_LEP(const VALUE *ep)
static VALUE main_to_s(VALUE obj)
void rb_undef_method(VALUE klass, const char *name)
void rb_gc_mark_locations(const VALUE *start, const VALUE *end)
#define FALSE_REDEFINED_OP_FLAG
#define VM_ENV_DATA_INDEX_ME_CREF
#define RUBY_DTRACE_METHOD_ENTRY_HOOK(th, klass, id)
static void CREF_OMOD_SHARED_UNSET(rb_cref_t *cref)
#define THROW_DATA_P(err)
static rb_control_frame_t * vm_push_frame(rb_thread_t *th, const rb_iseq_t *iseq, VALUE type, VALUE self, VALUE specval, VALUE cref_or_me, const VALUE *pc, VALUE *sp, int local_size, int stack_max)
static st_table * vm_opt_method_table
static void vm_set_eval_stack(rb_thread_t *th, const rb_iseq_t *iseq, const rb_cref_t *cref, const struct rb_block *base_block)
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
VALUE rb_vm_make_proc(rb_thread_t *th, const struct rb_captured_block *captured, VALUE klass)
enum iseq_catch_table_entry::catch_type type
const VALUE * iseq_encoded
static VALUE invoke_bmethod(rb_thread_t *th, const rb_iseq_t *iseq, VALUE self, const struct rb_captured_block *captured, const rb_callable_method_entry_t *me, VALUE type, int opt_pc)
void rb_hash_foreach(VALUE hash, int(*func)(ANYARGS), VALUE farg)
void rb_gc_mark_values(long n, const VALUE *values)
void rb_exc_raise(VALUE mesg)
static const struct rb_captured_block * VM_BH_TO_CAPT_BLOCK(VALUE block_handler)
rb_cref_t * rb_vm_cref(void)
VALUE rb_singleton_class(VALUE obj)
Returns the singleton class of obj.
#define RB_TYPE_P(obj, type)
VALUE defined_module_hash
VALUE rb_binding_new(void)
static VALUE vm_get_cbase(const VALUE *ep)
#define MEMZERO(p, type, n)
static rb_serial_t ruby_vm_class_serial
static VALUE vm_make_env_each(rb_thread_t *const th, rb_control_frame_t *const cfp)
int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp)
RUBY_EXTERN VALUE rb_cBinding
unsigned short first_lineno
#define RUBY_VM_THREAD_VM_STACK_SIZE
static VALUE vm_proc_to_block_handler(VALUE procval)
static void th_init(rb_thread_t *th, VALUE self)
static void add_opt_method(VALUE klass, ID mid, VALUE bop)
const char * rb_insns_name(int i)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
const rb_env_t * rb_vm_env_prev_env(const rb_env_t *env)
unsigned int local_table_size
static rb_control_frame_t * vm_get_ruby_level_caller_cfp(const rb_thread_t *th, const rb_control_frame_t *cfp)
RUBY_EXTERN VALUE rb_cObject
static VALUE * vm_base_ptr(const rb_control_frame_t *cfp)
static VALUE invoke_block_from_c_unsplattable(rb_thread_t *th, const struct rb_block *block, VALUE self, int argc, const VALUE *argv, VALUE passed_block_handler, int is_lambda)
VALUE rb_block_lambda(void)
static void vm_iter_break(rb_thread_t *th, VALUE val)
size_t st_memsize(const st_table *tab)
#define st_init_table_with_size
const rb_data_type_t ruby_threadptr_data_type
size_t fiber_vm_stack_size
struct rb_vm_struct::@200 trap_list[RUBY_NSIG]
VALUE rb_vm_make_proc_lambda(rb_thread_t *th, const struct rb_captured_block *captured, VALUE klass, int8_t is_lambda)
#define GetBindingPtr(obj, ptr)
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
struct rb_vm_struct rb_vm_t
void rb_vm_inc_const_missing_count(void)
void rb_vm_set_progname(VALUE filename)
RUBY_EXTERN VALUE rb_cBasicObject
VALUE rb_proc_create_from_captured(VALUE klass, const struct rb_captured_block *captured, enum rb_block_type block_type, int8_t safe_level, int8_t is_from_method, int8_t is_lambda)
static VALUE vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self, int argc, const VALUE *argv, VALUE block_handler)
static void CREF_PUSHED_BY_EVAL_SET(rb_cref_t *cref)
VALUE load_path_check_cache
static const rb_control_frame_t * THROW_DATA_CATCH_FRAME(const struct vm_throw_data *obj)
void rb_backref_set(VALUE val)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
RUBY_EXTERN VALUE rb_cTrueClass
#define TRUE_REDEFINED_OP_FLAG
struct rb_method_definition_struct *const def
static void local_var_list_init(struct local_var_list *vars)
void rb_define_const(VALUE, const char *, VALUE)
static rb_method_visibility_t rb_scope_visibility_get(void)
#define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN
static VALUE vm_stat(int argc, VALUE *argv, VALUE self)
static VALUE vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp)
static void check_machine_stack_size(size_t *sizep)
static const struct rb_captured_block * VM_BH_TO_ISEQ_BLOCK(VALUE block_handler)
st_table * rb_vm_fstring_table(void)
#define RUBY_MARK_ENTER(msg)
static const rb_control_frame_t * rb_vm_search_cf_from_ep(const rb_thread_t *const th, const rb_control_frame_t *cfp, const VALUE *const ep)
void rb_vm_register_special_exception(enum ruby_special_exceptions sp, VALUE cls, const char *mesg)
struct st_table * loading_table
static VALUE ruby_thread_init(VALUE self)
#define ALLOCV_N(type, v, n)
static size_t thread_memsize(const void *ptr)
const VALUE special_exceptions[ruby_special_error_count]
void ruby_thread_init_stack(rb_thread_t *th)
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)
#define RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, klass, id)
#define VM_GUARDED_PREV_EP(ep)
void rb_gc_register_mark_object(VALUE obj)
#define MEMCPY(p1, p2, type, n)
static const rb_env_t * vm_env_new(VALUE *env_ep, VALUE *env_body, unsigned int env_size, const rb_iseq_t *iseq)
VALUE * rb_gc_stack_start
VALUE rb_obj_alloc(VALUE)
VALUE rb_vm_call_cfunc(VALUE recv, VALUE(*func)(VALUE), VALUE arg, VALUE block_handler, VALUE filename)
int rb_vm_add_root_module(ID id, VALUE module)
static VALUE vm_exec(rb_thread_t *th)
static const rb_env_t * VM_ENV_ENVVAL_PTR(const VALUE *ep)
void rb_thread_mark(void *ptr)
#define VM_ENV_DATA_INDEX_SPECVAL
#define RUBY_VM_FIBER_MACHINE_STACK_SIZE
void rb_gc_mark_machine_stack(rb_thread_t *th)
#define RUBY_DTRACE_CREATE_HOOK(name, arg)
void * ruby_mimmalloc(size_t size)
void rb_call_end_proc(VALUE data)
static VALUE vm_invoke_bmethod(rb_thread_t *th, rb_proc_t *proc, VALUE self, int argc, const VALUE *argv, VALUE block_handler)
static void rb_vm_living_threads_init(rb_vm_t *vm)
VALUE rb_const_get(VALUE, ID)
static VALUE vm_block_self(const struct rb_block *block)
rb_hook_list_t event_hooks
static const VALUE * VM_CF_PREV_EP(const rb_control_frame_t *const cfp)
#define STRING_REDEFINED_OP_FLAG
void rb_vm_pop_frame(rb_thread_t *th)
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
RUBY_EXTERN VALUE rb_cRegexp
void rb_alias_variable(ID, ID)
static VALUE core_hash_from_ary(VALUE ary)
static int rb_scope_module_func_check(void)
#define RARRAY_CONST_PTR(a)
static const struct rb_block * vm_proc_block(VALUE procval)
static void vm_svar_set(VALUE key, VALUE val)
static int vm_pop_frame(rb_thread_t *th, rb_control_frame_t *cfp, const VALUE *ep)
#define rb_thread_set_current(th)
void rb_vm_stack_to_heap(rb_thread_t *th)
struct rb_mutex_struct * keeping_mutexes
VALUE rb_sprintf(const char *format,...)
unsigned long rb_serial_t
static rb_cref_t * CREF_NEXT(const rb_cref_t *cref)
#define RICLASS_IS_ORIGIN
const rb_method_entry_t * rb_method_entry(VALUE klass, ID id)
static enum rb_block_handler_type vm_block_handler_type(VALUE block_handler)
VALUE rb_class_path(VALUE)
static VALUE CREF_CLASS(const rb_cref_t *cref)
static VALUE m_core_define_singleton_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval)
static const rb_iseq_t * vm_block_iseq(const struct rb_block *block)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
static void VM_STACK_ENV_WRITE(const VALUE *ep, int index, VALUE v)
int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
VALUE rb_ivar_set(VALUE, ID, VALUE)
static void vm_set_main_stack(rb_thread_t *th, const rb_iseq_t *iseq)
size_t thread_vm_stack_size
VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val)
VALUE rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp)
void rb_vm_bugreport(const void *)
const VALUE * rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars)
static const VALUE * vm_block_ep(const struct rb_block *block)
void ruby_vm_at_exit(void(*func)(rb_vm_t *))
static rb_control_frame_t * next_not_local_frame(rb_control_frame_t *cfp)
void rb_clear_method_cache_by_class(VALUE)
static void vm_set_top_stack(rb_thread_t *th, const rb_iseq_t *iseq)
rb_cref_t * rb_vm_cref_new_toplevel(void)
VALUE rb_vm_top_self(void)
#define EXEC_EVENT_HOOK(th_, flag_, self_, id_, called_id_, klass_, data_)
static VALUE m_core_hash_merge_ptr(int argc, VALUE *argv, VALUE recv)
struct rb_thread_struct * main_thread
rb_thread_t * ruby_current_thread
#define REGEXP_REDEFINED_OP_FLAG
RUBY_EXTERN VALUE rb_cInteger
static void vm_block_handler_escape(rb_thread_t *th, VALUE block_handler, VALUE *procvalptr)
rb_method_visibility_t method_visi
struct rb_at_exit_list * next
void rb_mark_tbl(st_table *tbl)
void Init_native_thread(void)
static enum rb_block_type vm_block_type(const struct rb_block *block)
void rb_alias(VALUE, ID, ID)
VALUE rb_str_concat_literals(size_t, const VALUE *)
const char * rb_id2name(ID)
int rb_sigaltstack_size(void)
static int collect_local_variables_in_iseq(const rb_iseq_t *iseq, const struct local_var_list *vars)
int ruby_vm_destruct(rb_vm_t *vm)
const rb_method_entry_t * rb_method_entry_at(VALUE obj, ID id)
enum rb_iseq_constant_body::iseq_type type
#define RUBY_VM_END_CONTROL_FRAME(th)
const rb_callable_method_entry_t * passed_bmethod_me
struct rb_captured_block captured
static VALUE invoke_block(rb_thread_t *th, const rb_iseq_t *iseq, VALUE self, const struct rb_captured_block *captured, const rb_cref_t *cref, VALUE type, int opt_pc)
void rb_set_end_proc(void(*func)(VALUE), VALUE data)
#define VM_ENV_DATA_INDEX_ENV
register unsigned int len
static unsigned long VM_FRAME_TYPE(const rb_control_frame_t *cfp)
static VALUE env_size(void)
static VALUE * thread_recycle_stack(size_t size)
enum rb_thread_status status
void rb_iter_break_value(VALUE val)
static VALUE vm_svar_get(VALUE key)
#define RUBY_FREE_UNLESS_NULL(ptr)
static int kwmerge_i(VALUE key, VALUE value, VALUE hash)
static VALUE m_core_define_method(VALUE self, VALUE sym, VALUE iseqval)
static int VM_BH_FROM_CFP_P(VALUE block_handler, const rb_control_frame_t *cfp)
VALUE rb_mRubyVMFrozenCore
static enum rb_id_table_iterator_result check_redefined_method(ID mid, VALUE value, void *data)
#define SYMBOL_REDEFINED_OP_FLAG
static VALUE frame_return_value(const struct vm_throw_data *err)
static VALUE VM_BH_TO_PROC(VALUE block_handler)
static VALUE vm_exec_core(rb_thread_t *th, VALUE initial)
static VALUE THROW_DATA_VAL(const struct vm_throw_data *obj)
void rb_define_method_id(VALUE klass, ID mid, VALUE(*func)(ANYARGS), int argc)
VALUE rb_vm_frame_block_handler(const rb_control_frame_t *cfp)
static size_t get_param(const char *name, size_t default_value, size_t min_value)
const rb_cref_t * rb_vm_cref_in_context(VALUE self, VALUE cbase)
struct rb_objspace * objspace
rb_vm_t * ruby_current_vm
const VALUE * rb_vm_ep_local_ep(const VALUE *ep)
VALUE rb_lastline_get(void)
const struct iseq_catch_table * catch_table
static int vm_redefinition_check_flag(VALUE klass)
void rb_thread_recycle_stack_release(VALUE *stack)
static rb_cref_t * vm_cref_new(VALUE klass, rb_method_visibility_t visi, int module_func, rb_cref_t *prev_cref, int pushed_by_eval)
static rb_control_frame_t * VM_CAPTURED_BLOCK_TO_CFP(const struct rb_captured_block *captured)
#define TIME_REDEFINED_OP_FLAG
VALUE rb_block_proc(void)
static void collect_local_variables_in_env(const rb_env_t *env, const struct local_var_list *vars)
static const unsigned char cv[]
NORETURN(static void vm_iter_break(rb_thread_t *th, VALUE val))
VALUE * rb_ruby_verbose_ptr(void)
static void THROW_DATA_CATCH_FRAME_SET(struct vm_throw_data *obj, const rb_control_frame_t *cfp)
#define RBASIC_CLASS(obj)
static VALUE VM_ENV_BLOCK_HANDLER(const VALUE *ep)
#define RUBY_FREE_LEAVE(msg)
#define FLOAT_REDEFINED_OP_FLAG
rb_hook_list_t event_hooks
static VALUE check_env_value(const rb_env_t *env)
#define RUBY_VM_THREAD_VM_STACK_SIZE_MIN
VALUE rb_hash_aref(VALUE hash, VALUE key)
typedefRUBY_SYMBOL_EXPORT_BEGIN struct re_pattern_buffer Regexp
#define RUBY_FREE_ENTER(msg)
static rb_cref_t * vm_cref_dup(const rb_cref_t *cref)
static VALUE vm_yield_with_block(rb_thread_t *th, int argc, const VALUE *argv, VALUE block_handler)
static void vm_cfp_svar_set(rb_thread_t *th, rb_control_frame_t *cfp, VALUE key, const VALUE val)
#define EXEC_EVENT_HOOK_AND_POP_FRAME(th_, flag_, self_, id_, called_id_, klass_, data_)
static int THROW_DATA_STATE(const struct vm_throw_data *obj)
#define RUBY_VM_FIBER_VM_STACK_SIZE_MIN
static void local_var_list_add(const struct local_var_list *vars, ID lid)
VALUE rb_class_path_no_cache(VALUE _klass)
const struct rb_block block
static void ruby_vm_run_at_exit_hooks(rb_vm_t *vm)
#define VM_PROFILE_ATEXIT()
VALUE rb_iseq_eval(const rb_iseq_t *iseq)
static int vm_block_handler_verify(VALUE block_handler)
rb_event_flag_t ruby_vm_event_flags
void rb_vm_trace_mark_event_hooks(rb_hook_list_t *hooks)
static VALUE m_core_hash_merge_kwd(int argc, VALUE *argv, VALUE recv)
void(* ruby_vm_collect_usage_func_register)(int reg, int isset)
#define RUBY_MARK_UNLESS_NULL(ptr)
size_t thread_machine_stack_size
rb_objspace_t * rb_objspace_alloc(void)
void rb_fiber_mark_self(rb_fiber_t *fib)
#define ONLY_FOR_INTERNAL_USE(func)
VALUE rb_iseq_local_variables(const rb_iseq_t *iseq)
#define INTEGER_REDEFINED_OP_FLAG
#define VM_UNREACHABLE(func)
#define TypedData_Make_Struct(klass, type, data_type, sval)
void rb_vm_at_exit_func(struct rb_vm_struct *)
static void VM_FORCE_WRITE_SPECIAL_CONST(const VALUE *ptr, VALUE special_const_value)
struct rb_vm_struct::@201 default_params
static void VM_ENV_FLAGS_UNSET(const VALUE *ep, VALUE flag)
static VALUE vm_yield_with_cfunc(rb_thread_t *th, const struct rb_captured_block *captured, VALUE self, int argc, const VALUE *argv, VALUE block_handler)
static void vm_bind_update_env(rb_binding_t *bind, VALUE envval)
#define GetThreadPtr(obj, ptr)
VALUE loaded_features_snapshot
size_t rb_gc_stack_maxsize
static void vm_cref_dump(const char *mesg, const rb_cref_t *cref)
#define ARRAY_REDEFINED_OP_FLAG
const struct rb_iseq_struct * parent_iseq
static VALUE thread_alloc(VALUE klass)
rb_cref_t * rb_vm_cref_replace_with_duplicated_cref(void)
static VALUE vm_passed_block_handler(rb_thread_t *th)
static VALUE vm_yield_with_symbol(rb_thread_t *th, VALUE symbol, int argc, const VALUE *argv, VALUE block_handler)
static VALUE m_core_set_variable_alias(VALUE self, VALUE sym1, VALUE sym2)
int ruby_th_dtrace_setup(rb_thread_t *th, VALUE klass, ID id, struct ruby_dtrace_method_hook_args *args)
#define StringValuePtr(v)
static rb_serial_t ruby_vm_global_method_state
VALUE local_storage_recursive_hash
struct rb_thread_struct rb_thread_t
static VALUE m_core_set_method_alias(VALUE self, VALUE cbase, VALUE sym1, VALUE sym2)
const char * rb_source_loc(int *pline)
struct list_head living_threads
static struct rb_captured_block * VM_CFP_TO_CAPTURED_BLOCK(const rb_control_frame_t *cfp)
static rb_cref_t * vm_cref_new_use_prev(VALUE klass, rb_method_visibility_t visi, int module_func, rb_cref_t *prev_cref, int pushed_by_eval)
void rb_vm_rewind_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
#define RTYPEDDATA_DATA(v)
void rb_vm_gvl_destroy(rb_vm_t *vm)
void rb_lastline_set(VALUE val)
static void THROW_DATA_CONSUMED_SET(struct vm_throw_data *obj)
rb_iseq_t * rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent)
#define NIL_REDEFINED_OP_FLAG
static const rb_scope_visibility_t * CREF_SCOPE_VISI(const rb_cref_t *cref)
#define CONST_ID(var, str)
rb_id_table_iterator_result
VALUE rb_vm_env_local_variables(const rb_env_t *env)
VALUE rb_obj_freeze(VALUE)
int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, ID *called_idp, VALUE *klassp)
void Init_vm_objects(void)
VALUE pending_interrupt_queue
static VALUE VM_CF_BLOCK_HANDLER(const rb_control_frame_t *const cfp)
RUBY_EXTERN VALUE rb_cSymbol
const char * rb_sourcefile(void)
static VALUE m_core_hash_from_ary(VALUE self, VALUE ary)
static void CREF_REFINEMENTS_SET(rb_cref_t *cref, VALUE refs)
static void rb_vm_check_redefinition_opt_method(const rb_method_entry_t *me, VALUE klass)
static rb_cref_t * vm_cref_new_toplevel(rb_thread_t *th)
static int VM_FRAME_BMETHOD_P(const rb_control_frame_t *cfp)
static VALUE VM_ENV_ENVVAL(const VALUE *ep)
VALUE rb_source_location(int *pline)
static rb_cref_t * vm_cref_new0(VALUE klass, rb_method_visibility_t visi, int module_func, rb_cref_t *prev_cref, int pushed_by_eval, int use_prev_prev)
static VALUE local_var_list_finish(struct local_var_list *vars)
RUBY_EXTERN VALUE rb_cTime
void rb_vm_jump_tag_but_local_jump(int state)
VALUE rb_class_new(VALUE super)
Creates a new class.
static const VALUE * VM_ENV_PREV_EP(const VALUE *ep)
#define NEW_NODE(t, a0, a1, a2)
VALUE rb_obj_is_thread(VALUE obj)
static void VM_ENV_FLAGS_SET(const VALUE *ep, VALUE flag)
static VALUE core_hash_merge_ary(VALUE hash, VALUE ary)
RUBY_EXTERN VALUE rb_cNilClass
void rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, void *data)
static int vm_collect_local_variables_in_heap(rb_thread_t *th, const VALUE *ep, const struct local_var_list *vars)
rb_control_frame_t * rb_vm_get_binding_creatable_next_cfp(const rb_thread_t *th, const rb_control_frame_t *cfp)
static void THROW_DATA_STATE_SET(struct vm_throw_data *obj, int st)
VALUE rb_binding_alloc(VALUE klass)
union rb_captured_block::@202 code
static int vm_yield_setup_args(rb_thread_t *th, const rb_iseq_t *iseq, const int argc, VALUE *argv, VALUE block_handler, enum arg_setup_type arg_setup_type)
static void vm_init_redefined_flag(void)
#define rb_thread_set_current_raw(th)
#define ruby_vm_redefined_flag
#define RB_OBJ_WRITE(a, slot, b)
static rb_cref_t * vm_cref_replace_with_duplicated_cref(const VALUE *ep)
VALUE rb_attr_get(VALUE, ID)
static void CREF_OMOD_SHARED_SET(rb_cref_t *cref)
rb_iseq_location_t location
static const struct rb_captured_block * VM_BH_TO_IFUNC_BLOCK(VALUE block_handler)
static void vm_default_params_setup(rb_vm_t *vm)
static VALUE * ruby_vm_verbose_ptr(rb_vm_t *vm)
static struct vm_throw_data * THROW_DATA_NEW(VALUE val, const rb_control_frame_t *cf, VALUE st)
VALUE rb_thread_current_status(const rb_thread_t *th)