111 if (iseq->
type != ISEQ_TYPE_TOP) {
216 typedef void rb_vm_at_exit_func(
rb_vm_t*);
233 #define ENV_IN_HEAP_P(th, env) \
234 (!((th)->stack < (env) && (env) < ((th)->stack + (th)->stack_size)))
235 #define ENV_VAL(env) ((env)[1])
316 printf(
"envptr: %p\n", (
void *)&env->
block.
dfp[0]);
317 printf(
"orphan: %p\n", (
void *)env->
block.
dfp[1]);
318 printf(
"inheap: %p\n", (
void *)env->
block.
dfp[2]);
319 printf(
"envval: %10p ", (
void *)env->
block.
dfp[3]);
321 printf(
"penvv : %10p ", (
void *)env->
block.
dfp[4]);
323 printf(
"lfp: %10p\n", (
void *)env->
block.
lfp);
324 printf(
"dfp: %10p\n", (
void *)env->
block.
dfp);
350 VALUE envval, penvval = 0;
359 if (envptr != endptr) {
367 while (pcfp->
dfp != penvptr) {
369 if (pcfp->
dfp == 0) {
396 for (i = 0; i <= local_size; i++) {
397 env->
env[
i] = envptr[-local_size +
i];
399 fprintf(stderr,
"%2d ", &envptr[-local_size + i] - th->
stack);
dp(env->
env[i]);
402 envptr[-local_size +
i] = 0;
408 nenvptr = &env->
env[i - 1];
410 nenvptr[2] = penvval;
414 if (envptr == endptr) {
495 if (blockptr && !(lfp[0] & 0x02)) {
500 *blockprocptr = blockprocval;
520 (cfp->
iseq->
type == ISEQ_TYPE_RESCUE ||
521 cfp->
iseq->
type == ISEQ_TYPE_ENSURE)) {
526 VALUE dfpval = *escape_dfp;
563 VALUE procval, envval, blockprocval = 0;
568 rb_bug(
"rb_vm_make_proc: Proc value is already created.");
589 rb_bug(
"invalid ptr: block->dfp");
592 rb_bug(
"invalid ptr: block->lfp");
612 int i, opt_pc, arg_size = iseq->
arg_size;
621 for (i=0; i<
argc; i++) {
622 cfp->
sp[
i] = argv[
i];
705 while (cfp->
pc == 0) {
801 if (++limit_cfp > cfp) {
808 while (cfp > limit_cfp) {
809 if (cfp->
iseq != 0) {
815 if ((*iter)(arg, file, line_no, iseq->
name))
break;
869 if (!ary)
return Qnil;
915 debug_cref(
NODE *cref)
919 printf(
"%ld\n", cref->nd_visi);
920 cref = cref->nd_next;
1075 #define OP(mid_, bop_) (mid = id##mid_, bop = BOP_##bop_, ruby_vm_redefined_flag[bop] = 0)
1076 #define C(k) add_opt_method(rb_c##k, mid, bop)
1077 OP(PLUS, PLUS), (
C(Fixnum),
C(Float),
C(String),
C(Array));
1078 OP(MINUS, MINUS), (
C(Fixnum));
1079 OP(MULT, MULT), (
C(Fixnum),
C(Float));
1082 OP(Eq, EQ), (
C(Fixnum),
C(Float),
C(String));
1083 OP(Eqq, EQQ), (
C(Fixnum),
C(Bignum),
C(Float),
C(Symbol),
C(String));
1084 OP(LT, LT), (
C(Fixnum));
1086 OP(LTLT, LTLT), (
C(String),
C(Array));
1088 OP(ASET, ASET), (
C(Array),
C(Hash));
1089 OP(Length, LENGTH), (
C(Array),
C(String),
C(Hash));
1090 OP(Size, SIZE), (
C(Array),
C(String),
C(Hash));
1091 OP(Succ, SUCC), (
C(Fixnum),
C(String),
C(Time));
1092 OP(GT, GT), (
C(Fixnum));
1093 OP(GE, GE), (
C(Fixnum));
1237 if ((state = th->
state) != 0) {
1240 goto exception_handler;
1246 unsigned long epc, cont_pc, cont_sp;
1247 VALUE catch_iseqval;
1254 cont_pc = cont_sp = catch_iseqval = 0;
1270 if (cfp->
dfp == escape_dfp) {
1279 if (entry->
start < epc && entry->
end >= epc) {
1281 catch_iseqval = entry->
iseq;
1282 cont_pc = entry->
cont;
1283 cont_sp = entry->
sp;
1288 if (!catch_iseqval) {
1299 #if OPT_STACK_CACHING
1313 if (entry->
start < epc && entry->
end >= epc) {
1317 catch_iseqval = entry->
iseq;
1318 cont_pc = entry->
cont;
1319 cont_sp = entry->
sp;
1328 if (entry->
start < epc && entry->
end >= epc) {
1331 catch_iseqval = entry->
iseq;
1332 cont_pc = entry->
cont;
1333 cont_sp = entry->
sp;
1339 if (cfp->
dfp == escape_dfp) {
1348 else if (state ==
TAG_BREAK && ((
VALUE)escape_dfp & ~0x03) == 0) {
1351 search_restart_point:
1355 if (entry->
start < epc && entry->
end >= epc) {
1357 catch_iseqval = entry->
iseq;
1358 cont_pc = entry->
cont;
1359 cont_sp = entry->
sp;
1362 else if (entry->
type == type) {
1364 cfp->
sp = cfp->
bp + entry->
sp;
1367 #if OPT_STACK_CACHING
1382 goto search_restart_point;
1386 goto search_restart_point;
1391 if (entry->
start < epc && entry->
end >= epc) {
1394 catch_iseqval = entry->
iseq;
1395 cont_pc = entry->
cont;
1396 cont_sp = entry->
sp;
1403 if (catch_iseqval != 0) {
1409 cfp->
sp = cfp->
bp + cont_sp;
1438 goto exception_handler;
1489 if (!iseq && cfp->
me) {
1491 if (klassp) *klassp = cfp->
me->
klass;
1496 if (idp)
CONST_ID(*idp,
"<ifunc>");
1497 if (klassp) *klassp = 0;
1502 if (klassp) *klassp = iseq->
klass;
1525 if (cfp->
iseq != 0) {
1553 recv, (
VALUE)blockptr, 0, reg_cfp->
sp, 0, 1);
1586 RUBY_GC_INFO(
"-------------------------------------------------\n");
1623 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
1636 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
1644 ruby_current_vm = 0;
1678 #define USE_THREAD_DATA_RECYCLE 1
1680 #if USE_THREAD_DATA_RECYCLE
1681 #define RECYCLE_MAX 64
1688 if (thread_recycle_stack_count) {
1697 #define thread_recycle_stack(size) ALLOC_N(VALUE, (size))
1703 #if USE_THREAD_DATA_RECYCLE
1705 thread_recycle_stack_slot[thread_recycle_stack_count++] = stack;
1712 #ifdef USE_THREAD_RECYCLE
1714 thread_recycle_struct(
void)
1740 while (cfp != limit_cfp) {
1799 rb_bug(
"thread_free: locking_mutex must be NULL (%p:%p)", (
void *)th, (
void *)th->
locking_mutex);
1802 rb_bug(
"thread_free: keeping_mutexes must be NULL (%p:%p)", (
void *)th, (
void *)th->
keeping_mutexes);
1813 #ifdef USE_SIGALTSTACK
1820 if (ruby_current_thread == th)
1821 ruby_current_thread =
NULL;
1846 #define thread_data_type ruby_threadptr_data_type
1871 #ifdef USE_THREAD_RECYCLE
1887 #ifdef USE_SIGALTSTACK
1932 VALUE klass = cref->nd_clss;
1933 int noex = (int)cref->nd_visi;
1950 "can't define singleton method \"%s\" for %s",
1962 miseq->klass = klass;
1963 miseq->defined_method_id =
id;
1972 #define REWIND_CFP(expr) do { \
1973 rb_thread_t *th__ = GET_THREAD(); \
1974 th__->cfp++; expr; th__->cfp--; \
2034 rb_bug(
"m_core_set_postexe: unreachable");
2040 blockptr->
iseq = blockiseq;
2052 extern VALUE *rb_gc_register_stack_start;
2071 #include <execinfo.h>
2072 #define MAX_NATIVE_TRACE 1024
2073 static void *trace[MAX_NATIVE_TRACE];
2074 int n = backtrace(trace, MAX_NATIVE_TRACE);
2075 char **syms = backtrace_symbols(trace, n);
2082 for (i=0; i<n; i++) {
2133 #if OPT_DIRECT_THREADED_CODE
2135 #elif OPT_TOKEN_THREADED_CODE
2137 #elif OPT_CALL_THREADED_CODE
2141 #if OPT_STACK_CACHING
2144 #if OPT_OPERANDS_UNIFICATION
2147 #if OPT_INSTRUCTIONS_UNIFICATION
2150 #if OPT_INLINE_METHOD_CACHE
2153 #if OPT_BLOCKINLINING
2175 volatile VALUE th_self;
2216 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
2227 fprintf(stderr,
"[FATAL] failed to allocate memory\n");
2235 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
2238 ruby_current_vm = vm;
2257 return GET_VM()->top_self;
void rb_define_global_const(const char *, VALUE)
const rb_block_t * passed_block
#define VM_FRAME_MAGIC_BLOCK
NORETURN(static void vm_iter_break(rb_thread_t *th))
static void vm_clear_all_inline_method_cache(void)
static void thread_free(void *ptr)
VALUE rb_proc_alloc(VALUE klass)
VALUE rb_ary_pop(VALUE ary)
static VALUE make_localjump_error(const char *mesg, VALUE value, int reason)
static void lfp_svar_set(rb_thread_t *th, VALUE *lfp, rb_num_t key, VALUE val)
#define RUBY_EVENT_C_RETURN
void rb_bug(const char *fmt,...)
static size_t vm_memsize(const void *ptr)
VALUE ruby_vm_const_missing_count
static void vm_init2(rb_vm_t *vm)
#define rb_gc_mark_locations(start, end)
#define RUBY_VM_IFUNC_P(ptr)
struct rb_thread_struct * running_thread
static rb_control_frame_t * vm_get_ruby_level_caller_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
void rb_objspace_free(rb_objspace_t *objspace)
#define RUBY_EVENT_RETURN
#define VM_FRAME_MAGIC_CFUNC
char ruby_vm_redefined_flag[BOP_LAST_]
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 ruby_vm_global_state_version
#define GetProcPtr(obj, ptr)
static VALUE vm_yield(rb_thread_t *th, int argc, const VALUE *argv)
const rb_method_entry_t * passed_me
#define RUBY_VM_NORMAL_ISEQ_P(ptr)
#define SET_THROWOBJ_STATE(obj, val)
static VALUE rb_vm_set_finish_env(rb_thread_t *th)
void rb_vm_mark(void *ptr)
VALUE rb_vm_call_cfunc(VALUE recv, VALUE(*func)(VALUE), VALUE arg, const rb_block_t *blockptr, VALUE filename)
static size_t env_memsize(const void *ptr)
static int vm_mark_each_thread_func(st_data_t key, st_data_t value, st_data_t dummy)
static int check_env(rb_env_t *const env)
static int block_proc_is_lambda(const VALUE procval)
#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)
#define GET_THROWOBJ_CATCH_POINT(obj)
static void vm_backtrace_alloc(void *arg)
VALUE rb_insns_name_array(void)
#define VMDEBUG
VM Debug Level.
VALUE * rb_ruby_debug_ptr(void)
#define TH_JUMP_TAG(th, st)
#define ENV_IN_HEAP_P(th, env)
VALUE rb_ary_push(VALUE ary, VALUE item)
void rb_vm_jump_tag_but_local_jump(int state, VALUE val)
static VALUE invoke_block_from_c(rb_thread_t *th, const rb_block_t *block, VALUE self, int argc, const VALUE *argv, const rb_block_t *blockptr, const NODE *cref)
st_table * living_threads
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
VALUE rb_ary_tmp_new(long capa)
VALUE rb_backref_get(void)
#define RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp)
VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass)
static int vm_collect_local_variables_in_heap(rb_thread_t *th, VALUE *dfp, VALUE ary)
#define RSTRING_PTR(string)
#define VM_FRAME_MAGIC_METHOD
struct rb_iseq_struct * local_iseq
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
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)
#define VM_FRAME_TYPE(cfp)
static void vm_clear_all_cache()
void rb_vm_rewrite_dfp_in_errinfo(rb_thread_t *th)
#define RUBY_MARK_LEAVE(msg)
static int vm_backtrace_push(void *arg, VALUE file, int line_no, VALUE name)
static void env_mark(void *const ptr)
#define VM_FRAME_MAGIC_IFUNC
static int thread_recycle_stack_count
#define RARRAY_LEN(ARRAY)
void rb_vm_localjump_error(const char *mesg, VALUE value, int reason)
void rb_gc_mark(VALUE ptr)
static void vm_iter_break(rb_thread_t *th)
#define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)
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)
#define GetEnvPtr(obj, ptr)
RUBY_FUNC_EXPORTED int rb_vm_get_sourceline(const rb_control_frame_t *cfp)
struct rb_objspace * rb_objspace_alloc(void)
RUBY_EXTERN VALUE rb_cProc
static int vm_yield_setup_args(rb_thread_t *const th, const rb_iseq_t *iseq, int argc, VALUE *argv, const rb_block_t *blockptr, int lambda)
static const rb_data_type_t vm_data_type
static VALUE env_alloc(void)
rb_control_frame_t * rb_vm_get_ruby_level_next_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
static VALUE main_to_s(VALUE obj)
void rb_undef_method(VALUE klass, const char *name)
#define id_core_set_method_alias
#define CHECK_STACK_OVERFLOW(cfp, margin)
VALUE rb_iseq_eval_main(VALUE iseqval)
const rb_method_entry_t * me
static VALUE vm_get_cbase(const rb_iseq_t *iseq, const VALUE *lfp, const VALUE *dfp)
const char * rb_obj_classname(VALUE)
VALUE rb_enc_sprintf(rb_encoding *enc, const char *format,...)
void rb_gc_force_recycle(VALUE p)
static st_table * vm_opt_method_table
#define VM_FRAME_FLAG_PASSED
static rb_control_frame_t * vm_push_frame(rb_thread_t *th, const rb_iseq_t *iseq, VALUE type, VALUE self, VALUE specval, const VALUE *pc, VALUE *sp, VALUE *lfp, int local_size)
struct rb_vm_struct::@75 trap_list[RUBY_NSIG]
enum iseq_catch_table_entry::catch_type type
void rb_exc_raise(VALUE mesg)
#define RUBY_VM_THREAD_STACK_SIZE
VALUE rb_singleton_class(VALUE obj)
Returns the singleton class of obj.
static VALUE vm_yield_with_cref(rb_thread_t *th, int argc, const VALUE *argv, const NODE *cref)
#define RB_TYPE_P(obj, type)
static VALUE check_env_value(VALUE envval)
enum rb_iseq_struct::iseq_type type
static void mark_event_hooks(rb_event_hook_t *hook)
VALUE rb_binding_new(void)
static VALUE m_core_define_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval)
#define MEMZERO(p, type, n)
#define id_core_set_postexe
static VALUE finish_insn_seq[1]
static VALUE vm_make_env_each(rb_thread_t *const th, rb_control_frame_t *const cfp, VALUE *envptr, VALUE *const endptr)
static void vm_set_main_stack(rb_thread_t *th, VALUE iseqval)
void rb_ary_free(VALUE ary)
int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp)
static void th_init(rb_thread_t *th, VALUE self)
static VALUE lfp_svar_get(rb_thread_t *th, VALUE *lfp, rb_num_t key)
static void add_opt_method(VALUE klass, ID mid, VALUE bop)
struct rb_event_hook_struct * next
RUBY_EXTERN VALUE rb_cObject
VALUE rb_block_lambda(void)
const rb_data_type_t ruby_threadptr_data_type
#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
#define COPY_CREF(c1, c2)
rb_event_hook_t * event_hooks
void rb_backref_set(VALUE val)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
void rb_define_const(VALUE, const char *, VALUE)
static int collect_local_variables_in_iseq(rb_iseq_t *iseq, const VALUE ary)
static const rb_block_t * check_block(rb_thread_t *th)
#define RUBY_MARK_ENTER(msg)
static void vm_define_method(rb_thread_t *th, VALUE obj, ID id, VALUE iseqval, rb_num_t is_singleton, NODE *cref)
rb_event_hook_t * event_hooks
struct st_table * loading_table
void rb_vm_bugreport(void)
#define VM_FRAME_MAGIC_CLASS
static NODE * vm_get_cref(const rb_iseq_t *iseq, const VALUE *lfp, const VALUE *dfp)
static VALUE ruby_thread_init(VALUE self)
static size_t thread_memsize(const void *ptr)
void ruby_thread_init_stack(rb_thread_t *th)
static int collect_local_variables_in_env(rb_env_t *env, const VALUE ary)
void rb_gc_register_mark_object(VALUE obj)
VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self, int argc, const VALUE *argv, const rb_block_t *blockptr)
#define RUBY_FUNC_EXPORTED
VALUE * rb_gc_stack_start
VALUE rb_obj_alloc(VALUE)
RUBY_FUNC_EXPORTED VALUE rb_vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp)
VALUE * machine_stack_start
#define SET_THROWOBJ_CATCH_POINT(obj, val)
static VALUE vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp, VALUE *blockprocptr)
static VALUE vm_exec(rb_thread_t *th)
#define RUBY_VM_GET_CFP_FROM_BLOCK_PTR(b)
VALUE * ruby_vm_debug_ptr(rb_vm_t *vm)
void rb_thread_mark(void *ptr)
void rb_gc_mark_machine_stack(rb_thread_t *th)
void rb_call_end_proc(VALUE data)
#define GC_GUARDED_PTR(p)
VALUE rb_const_get(VALUE, ID)
void rb_alias_variable(ID, ID)
static void vm_svar_set(VALUE key, VALUE val)
SSL_METHOD *(* func)(void)
#define rb_thread_set_current(th)
VALUE special_exceptions[ruby_special_error_count]
void rb_vm_stack_to_heap(rb_thread_t *th)
struct rb_mutex_struct * keeping_mutexes
#define id_core_set_variable_alias
VALUE rb_sprintf(const char *format,...)
void vm_analysis_operand(int insn, int n, VALUE op)
#define RB_GC_GUARD(object)
rb_method_entry_t * rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_flag_t noex)
static void vm_set_top_stack(rb_thread_t *th, VALUE iseqval)
VALUE rb_iv_set(VALUE, const char *, VALUE)
static VALUE m_core_define_singleton_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval)
int rb_is_local_id(ID id)
int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
struct rb_iseq_struct * parent_iseq
#define RUBY_VM_NEXT_CONTROL_FRAME(cfp)
VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val)
#define RUBYVM_CFUNC_FRAME_P(cfp)
void ruby_vm_at_exit(void(*func)(rb_vm_t *))
ruby_vm_at_exit registers a function func to be invoked when a VM passed away.
VALUE rb_exc_new2(VALUE etype, const char *s)
#define VM_FRAME_MAGIC_EVAL
VALUE rb_vm_top_self(void)
VALUE rb_iseq_eval(VALUE iseqval)
static int vm_backtrace_each(rb_thread_t *th, int lev, void(*init)(void *), rb_backtrace_iter_func *iter, void *arg)
static void vm_pop_frame(rb_thread_t *th)
#define RARRAY_EMBED_FLAG
struct rb_thread_struct * main_thread
const char * rb_class2name(VALUE)
rb_thread_t * ruby_current_thread
#define RARRAY_EMBED_LEN_MASK
void rb_mark_tbl(st_table *tbl)
void rb_alias(VALUE, ID, ID)
int ruby_vm_destruct(rb_vm_t *vm)
int rb_backtrace_iter_func(void *, VALUE, int, VALUE)
#define NEW_THROW_OBJECT(val, pt, st)
void rb_set_end_proc(void(*func)(VALUE), VALUE data)
static VALUE * thread_recycle_stack(size_t size)
enum rb_thread_status status
#define VM_FRAME_MAGIC_TOP
static VALUE vm_svar_get(VALUE key)
#define RUBY_FREE_UNLESS_NULL(ptr)
#define VM_FRAME_MAGIC_PROC
#define EXEC_EVENT_HOOK(th, flag, self, id, klass)
VALUE rb_mRubyVMFrozenCore
VALUE * machine_stack_end
static VALUE vm_exec_core(rb_thread_t *th, VALUE initial)
void rb_define_method_id(VALUE klass, ID mid, VALUE(*func)(ANYARGS), int argc)
static void vm_set_eval_stack(rb_thread_t *th, VALUE iseqval, const NODE *cref)
#define VM_FRAME_MAGIC_LAMBDA
struct rb_objspace * objspace
static void vm_clear_global_method_cache(void)
rb_vm_t * ruby_current_vm
VALUE rb_lastline_get(void)
void rb_thread_recycle_stack_release(VALUE *stack)
#define id_core_define_method
VALUE rb_block_proc(void)
rb_method_definition_t * def
size_t st_memsize(const st_table *)
VALUE * rb_ruby_verbose_ptr(void)
#define RUBY_FREE_LEAVE(msg)
#define RUBY_FREE_ENTER(msg)
#define id_core_define_singleton_method
static void vm_cfp_svar_set(rb_thread_t *th, rb_control_frame_t *cfp, VALUE key, const VALUE val)
struct iseq_catch_table_entry * catch_table
static void ruby_vm_run_at_exit_hooks(rb_vm_t *vm)
#define EXEC_EVENT_HOOK_AND_POP_FRAME(th, flag, self, id, klass)
static const rb_data_type_t env_data_type
#define RUBY_MARK_UNLESS_NULL(ptr)
#define TypedData_Make_Struct(klass, type, data_type, sval)
static VALUE vm_backtrace(rb_thread_t *th, int lev)
#define GetThreadPtr(obj, ptr)
size_t rb_gc_stack_maxsize
void rb_vm_change_state(void)
static VALUE thread_alloc(VALUE klass)
static void env_free(void *const ptr)
void vm_analysis_insn(int insn)
#define GetISeqPtr(obj, ptr)
const char * rb_id2name(ID id)
static VALUE m_core_set_variable_alias(VALUE self, VALUE sym1, VALUE sym2)
VALUE rb_ary_reverse(VALUE ary)
struct rb_thread_struct rb_thread_t
static VALUE m_core_set_method_alias(VALUE self, VALUE cbase, VALUE sym1, VALUE sym2)
#define VM_FRAME_MAGIC_FINISH
static VALUE m_core_set_postexe(VALUE self, VALUE iseqval)
void rb_vm_gvl_destroy(rb_vm_t *vm)
void rb_lastline_set(VALUE val)
#define rb_check_frozen(obj)
#define GC_GUARDED_PTR_REF(p)
#define CONST_ID(var, str)
VALUE rb_iseq_new(NODE *node, VALUE name, VALUE filename, VALUE filepath, VALUE parent, enum iseq_type type)
VALUE rb_obj_freeze(VALUE)
#define SPECIAL_CONST_P(x)
struct iseq_insn_info_entry * insn_info_table
void Init_native_thread(void)
static VALUE vm_make_proc_from_block(rb_thread_t *th, rb_block_t *block)
const char * rb_sourcefile(void)
#define INC_VM_STATE_VERSION()
VALUE rb_class_new(VALUE super)
Creates a new class.
#define id_core_undef_method
VALUE rb_str_new2(const char *)
#define GET_THROWOBJ_VAL(obj)
VALUE rb_obj_is_thread(VALUE obj)
VALUE * ruby_vm_verbose_ptr(rb_vm_t *vm)
static void rb_vm_check_redefinition_opt_method(const rb_method_entry_t *me)
static void vm_init_redefined_flag(void)
#define rb_thread_set_current_raw(th)
void vm_analysis_register(int reg, int isset)
VALUE rb_iseq_clone(VALUE iseqval, VALUE newcbase)
static VALUE vm_yield_with_cfunc(rb_thread_t *th, const rb_block_t *block, VALUE self, int argc, const VALUE *argv, const rb_block_t *blockargptr)
VALUE rb_thread_current_status(const rb_thread_t *th)