66 #if VM_COLLECT_USAGE_DETAILS 67 static void vm_collect_usage_operand(
int insn,
int n,
VALUE op);
68 static void vm_collect_usage_insn(
int insn);
69 static void vm_collect_usage_register(
int reg,
int isset);
141 if (iseq->
type != ISEQ_TYPE_TOP) {
248 while (th->
cfp != cfp) {
250 printf(
"skipped frame: %s\n", vm_frametype_name(th->
cfp));
283 typedef void rb_vm_at_exit_func(
rb_vm_t*);
299 #define ENV_IN_HEAP_P(th, env) \ 300 (!((th)->stack <= (env) && (env) < ((th)->stack + (th)->stack_size))) 301 #define ENV_VAL(env) ((env)[1]) 321 if (
env->block.iseq) {
371 env->prev_envval = 0;
381 fprintf(stderr,
"---\n");
382 fprintf(stderr,
"envptr: %p\n", (
void *)&
env->block.ep[0]);
383 fprintf(stderr,
"envval: %10p ", (
void *)
env->block.ep[1]);
384 dp(
env->block.ep[1]);
385 fprintf(stderr,
"ep: %10p\n", (
void *)
env->block.ep);
386 if (
env->prev_envval) {
387 fprintf(stderr,
">>\n");
389 fprintf(stderr,
"<<\n");
411 VALUE envval, penvval = 0;
420 if (envptr != endptr) {
428 while (pcfp->
ep != penvptr) {
451 env->env_size = local_size + 1 + 1;
452 env->local_size = local_size;
454 env->prev_envval = penvval;
456 for (
i = 0;
i <= local_size;
i++) {
457 env->env[
i] = envptr[-local_size +
i];
459 fprintf(stderr,
"%2d ", &envptr[-local_size +
i] - th->
stack);
dp(
env->env[
i]);
462 envptr[-local_size +
i] = 0;
468 nenvptr = &
env->env[
i - 1];
476 env->block.ep = cfp->
ep;
548 *blockprocptr = blockprocval;
568 (cfp->
iseq->
type == ISEQ_TYPE_RESCUE ||
569 cfp->
iseq->
type == ISEQ_TYPE_ENSURE)) {
574 VALUE epval = *escape_ep;
611 VALUE procval, envval, blockprocval = 0;
616 rb_bug(
"rb_vm_make_proc: Proc value is already created.");
637 rb_bug(
"invalid ptr: block->ep");
651 VALUE bindval, envval;
653 VALUE blockprocval = 0;
655 if (cfp == 0 || ruby_level_cfp == 0) {
661 if (cfp == ruby_level_cfp) {
690 int i, opt_pc, arg_size = iseq->
arg_size;
792 while (cfp->
pc == 0) {
911 debug_cref(
NODE *cref)
915 printf(
"%ld\n", cref->nd_visi);
916 cref = cref->nd_next;
1112 #define OP(mid_, bop_) (mid = id##mid_, bop = BOP_##bop_, ruby_vm_redefined_flag[bop] = 0) 1113 #define C(k) add_opt_method(rb_c##k, mid, bop) 1114 OP(PLUS, PLUS), (
C(Fixnum),
C(Float),
C(String),
C(Array));
1115 OP(MINUS, MINUS), (
C(Fixnum),
C(Float));
1116 OP(MULT, MULT), (
C(Fixnum),
C(Float));
1119 OP(Eq, EQ), (
C(Fixnum),
C(Float),
C(String));
1120 OP(Eqq, EQQ), (
C(Fixnum),
C(Bignum),
C(Float),
C(Symbol),
C(String));
1121 OP(LT, LT), (
C(Fixnum),
C(Float));
1122 OP(LE, LE), (
C(Fixnum),
C(Float));
1123 OP(GT, GT), (
C(Fixnum),
C(Float));
1124 OP(GE, GE), (
C(Fixnum),
C(Float));
1125 OP(LTLT, LTLT), (
C(String),
C(Array));
1127 OP(ASET, ASET), (
C(Array),
C(Hash));
1128 OP(Length, LENGTH), (
C(Array),
C(String),
C(Hash));
1129 OP(Size, SIZE), (
C(Array),
C(String),
C(Hash));
1130 OP(EmptyP, EMPTY_P), (
C(Array),
C(String),
C(Hash));
1131 OP(Succ, SUCC), (
C(Fixnum),
C(String),
C(Time));
1271 if ((state = th->
state) != 0) {
1274 goto exception_handler;
1280 unsigned long epc, cont_pc, cont_sp;
1281 VALUE catch_iseqval;
1288 cont_pc = cont_sp = catch_iseqval = 0;
1305 if (cfp->
ep == escape_ep) {
1314 if (entry->
start < epc && entry->
end >= epc) {
1316 catch_iseqval = entry->
iseq;
1317 cont_pc = entry->
cont;
1318 cont_sp = entry->
sp;
1323 if (!catch_iseqval) {
1334 #if OPT_STACK_CACHING 1348 if (entry->
start < epc && entry->
end >= epc) {
1352 catch_iseqval = entry->
iseq;
1353 cont_pc = entry->
cont;
1354 cont_sp = entry->
sp;
1363 if (entry->
start < epc && entry->
end >= epc) {
1366 catch_iseqval = entry->
iseq;
1367 cont_pc = entry->
cont;
1368 cont_sp = entry->
sp;
1374 if (cfp->
ep == escape_ep) {
1383 else if (state ==
TAG_BREAK && ((
VALUE)escape_ep & ~0x03) == 0) {
1386 search_restart_point:
1390 if (entry->
start < epc && entry->
end >= epc) {
1392 catch_iseqval = entry->
iseq;
1393 cont_pc = entry->
cont;
1394 cont_sp = entry->
sp;
1402 #if OPT_STACK_CACHING 1417 goto search_restart_point;
1421 goto search_restart_point;
1426 if (entry->
start < epc && entry->
end >= epc) {
1429 catch_iseqval = entry->
iseq;
1430 cont_pc = entry->
cont;
1431 cont_sp = entry->
sp;
1438 if (catch_iseqval != 0) {
1486 goto exception_handler;
1529 if (klassp) *klassp = cfp->
me->
klass;
1534 if (idp)
CONST_ID(*idp,
"<ifunc>");
1535 if (klassp) *klassp = 0;
1538 if (
iseq->defined_method_id) {
1539 if (idp) *idp =
iseq->defined_method_id;
1540 if (klassp) *klassp =
iseq->klass;
1569 if (cfp->
iseq != 0) {
1623 RUBY_GC_INFO(
"-------------------------------------------------\n");
1670 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE 1683 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE 1725 #define SET(name) rb_hash_aset(result, ID2SYM(rb_intern(#name)), SIZET2NUM(vm->default_params.name)); 1726 SET(thread_vm_stack_size);
1727 SET(thread_machine_stack_size);
1728 SET(fiber_vm_stack_size);
1729 SET(fiber_machine_stack_size);
1739 size_t result = default_value;
1741 long val = atol(envval);
1742 if (
val < (
long)min_value) {
1743 val = (long)min_value;
1755 #ifdef PTHREAD_STACK_MIN 1756 size_t size = *sizep;
1759 #ifdef __SYMBIAN32__ 1763 #ifdef PTHREAD_STACK_MIN 1764 if (
size < PTHREAD_STACK_MIN) {
1765 *sizep = PTHREAD_STACK_MIN * 2;
1779 get_param(
"RUBY_THREAD_MACHINE_STACK_SIZE",
1789 get_param(
"RUBY_FIBER_MACHINE_STACK_SIZE",
1811 #define USE_THREAD_DATA_RECYCLE 1 1813 #if USE_THREAD_DATA_RECYCLE 1814 #define RECYCLE_MAX 64 1831 #define thread_recycle_stack(size) ALLOC_N(VALUE, (size)) 1837 #if USE_THREAD_DATA_RECYCLE 1846 #ifdef USE_THREAD_RECYCLE 1848 thread_recycle_struct(
void)
1874 while (cfp != limit_cfp) {
1939 rb_bug(
"thread_free: locking_mutex must be NULL (%p:%p)", (
void *)th, (
void *)th->
locking_mutex);
1942 rb_bug(
"thread_free: keeping_mutexes must be NULL (%p:%p)", (
void *)th, (
void *)th->
keeping_mutexes);
1953 #ifdef USE_SIGALTSTACK 1986 #define thread_data_type ruby_threadptr_data_type 2011 #ifdef USE_THREAD_RECYCLE 2027 #ifdef USE_SIGALTSTACK 2048 #if OPT_CALL_THREADED_CODE 2082 VALUE klass = cref->nd_clss;
2083 int noex = (int)cref->nd_visi;
2104 miseq->klass = klass;
2105 miseq->defined_method_id =
id;
2114 #define REWIND_CFP(expr) do { \ 2115 rb_thread_t *th__ = GET_THREAD(); \ 2116 th__->cfp++; expr; th__->cfp--; \ 2176 rb_bug(
"m_core_set_postexe: unreachable");
2182 blockptr->
iseq = blockiseq;
2260 extern VALUE *rb_gc_register_stack_start;
2279 #include <execinfo.h> 2280 #define MAX_NATIVE_TRACE 1024 2281 static void *trace[MAX_NATIVE_TRACE];
2282 int n = backtrace(trace, MAX_NATIVE_TRACE);
2283 char **syms = backtrace_symbols(trace, n);
2290 for (
i=0;
i<n;
i++) {
2298 #if VM_COLLECT_USAGE_DETAILS 2299 static VALUE usage_analysis_insn_stop(
VALUE self);
2300 static VALUE usage_analysis_operand_stop(
VALUE self);
2301 static VALUE usage_analysis_register_stop(
VALUE self);
2345 #if VM_COLLECT_USAGE_DETAILS 2359 #if OPT_DIRECT_THREADED_CODE 2361 #elif OPT_TOKEN_THREADED_CODE 2363 #elif OPT_CALL_THREADED_CODE 2367 #if OPT_STACK_CACHING 2370 #if OPT_OPERANDS_UNIFICATION 2373 #if OPT_INSTRUCTIONS_UNIFICATION 2376 #if OPT_INLINE_METHOD_CACHE 2379 #if OPT_BLOCKINLINING 2409 volatile VALUE th_self;
2456 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE 2467 fprintf(stderr,
"[FATAL] failed to allocate memory\n");
2474 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE 2496 return GET_VM()->top_self;
2539 int len,
size_t pos,
VALUE *pnop,
VALUE child);
2541 #if VM_COLLECT_USAGE_DETAILS 2543 #define HASH_ASET(h, k, v) st_insert(RHASH_TBL(h), (st_data_t)(k), (st_data_t)(v)) 2557 vm_analysis_insn(
int insn)
2561 static int prev_insn = -1;
2567 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
2568 CONST_ID(bigram_hash,
"USAGE_ANALYSIS_INSN_BIGRAM");
2572 HASH_ASET(uh,
INT2FIX(insn), ihash);
2580 if (prev_insn != -1) {
2599 vm_analysis_operand(
int insn,
int n,
VALUE op)
2609 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
2614 HASH_ASET(uh,
INT2FIX(insn), ihash);
2618 HASH_ASET(ihash,
INT2FIX(n), ophash);
2631 vm_analysis_register(
int reg,
int isset)
2636 static const char regstrs[][5] = {
2644 static const char getsetstr[][4] = {
2648 static VALUE syms[
sizeof(regstrs) /
sizeof(regstrs[0])][2];
2652 CONST_ID(usage_hash,
"USAGE_ANALYSIS_REGS");
2657 for (
i = 0;
i < (int)(
sizeof(regstrs) /
sizeof(regstrs[0]));
i++) {
2659 for (j = 0; j < 2; j++) {
2660 snprintf(buff, 0x10,
"%d %s %-4s",
i, getsetstr[j], regstrs[
i]);
2665 valstr = syms[reg][isset];
2682 usage_analysis_insn_stop(
VALUE self)
2690 usage_analysis_operand_stop(
VALUE self)
2698 usage_analysis_register_stop(
VALUE self)
2712 #if VM_COLLECT_USAGE_DETAILS 2715 vm_collect_usage_insn(
int insn)
2717 if (RUBY_DTRACE_INSN_ENABLED()) {
2721 (*ruby_vm_collect_usage_func_insn)(insn);
2729 vm_collect_usage_operand(
int insn,
int n,
VALUE op)
2731 if (RUBY_DTRACE_INSN_OPERAND_ENABLED()) {
2740 (*ruby_vm_collect_usage_func_operand)(insn, n, op);
2746 vm_collect_usage_register(
int reg,
int isset)
2749 (*ruby_vm_collect_usage_func_register)(reg, isset);
RUBY_EXTERN VALUE rb_cString
void rb_define_global_const(const char *, VALUE)
#define RUBY_VM_THREAD_MACHINE_STACK_SIZE
#define VM_FRAME_MAGIC_BLOCK
#define RUBY_EVENT_B_RETURN
static VALUE core_hash_merge(VALUE hash, long argc, const VALUE *argv)
VALUE insn_operand_intern(rb_iseq_t *iseq, VALUE insn, int op_no, VALUE op, int len, size_t pos, VALUE *pnop, VALUE child)
static void vm_clear_all_inline_method_cache(void)
static void thread_free(void *ptr)
VALUE rb_proc_alloc(VALUE klass)
void rb_vm_bugreport(void)
void rb_vm_check_redefinition_by_prepend(VALUE klass)
VALUE rb_ary_pop(VALUE ary)
VALUE rb_ary_new4(long n, const VALUE *elts)
static VALUE make_localjump_error(const char *mesg, VALUE value, int reason)
RUBY_EXTERN VALUE rb_cFloat
#define RUBY_EVENT_C_RETURN
void rb_bug(const char *fmt,...)
static size_t vm_memsize(const void *ptr)
rb_control_frame_t * rb_vm_get_binding_creatable_next_cfp(rb_thread_t *th, const rb_control_frame_t *cfp)
void(* ruby_vm_collect_usage_func_insn)(int insn)
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)
#define RUBY_DTRACE_METHOD_RETURN_HOOK(th, klass, id)
VALUE rb_iseq_new(NODE *node, VALUE name, VALUE path, VALUE absolute_path, VALUE parent, enum iseq_type type)
void rb_objspace_free(rb_objspace_t *objspace)
int rb_vm_get_sourceline(const rb_control_frame_t *cfp)
#define VM_ENVVAL_PREV_EP_PTR(v)
#define RUBY_EVENT_RETURN
#define VM_FRAME_FLAG_FINISH
static VALUE m_core_hash_merge_ary(VALUE self, VALUE hash, VALUE ary)
#define VM_FRAME_TYPE_FINISH_P(cfp)
static VALUE * VM_CF_PREV_EP(rb_control_frame_t *cfp)
static void vm_rewrite_ep_in_errinfo(rb_thread_t *th)
#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)
#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN
void rb_vm_mark(void *ptr)
#define FLOAT_REDEFINED_OP_FLAG
VALUE rb_vm_call_cfunc(VALUE recv, VALUE(*func)(VALUE), VALUE arg, const rb_block_t *blockptr, VALUE filename)
void rb_vm_pop_cfunc_frame(void)
int st_insert(st_table *, st_data_t, st_data_t)
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)
struct st_table * loaded_features_index
static int check_env(rb_env_t *const env)
struct rb_vm_struct::@131 default_params
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)
VALUE pending_interrupt_mask_stack
#define GET_THROWOBJ_CATCH_POINT(obj)
void(* ruby_vm_collect_usage_func_operand)(int insn, int n, VALUE op)
VALUE rb_insns_name_array(void)
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)
SSL_METHOD *(* func)(void)
void st_free_table(st_table *)
#define RUBY_VM_SIZE_ALIGN
st_table * living_threads
size_t fiber_machine_stack_size
VALUE rb_ary_tmp_new(long capa)
VALUE rb_backref_get(void)
#define RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp)
#define VM_ENVVAL_BLOCK_PTR(v)
VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass)
#define VM_FRAME_MAGIC_METHOD
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 lep_svar_set(rb_thread_t *th, VALUE *lep, rb_num_t key, VALUE val)
static void vm_clear_all_cache()
#define RUBY_MARK_LEAVE(msg)
VALUE rb_convert_type(VALUE, int, const char *, const char *)
static void env_mark(void *const ptr)
#define VM_FRAME_MAGIC_IFUNC
static int thread_recycle_stack_count
void Init_vm_backtrace(void)
void rb_vm_localjump_error(const char *mesg, VALUE value, int reason)
void rb_gc_mark(VALUE ptr)
#define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)
static VALUE * thread_recycle_stack_slot[RECYCLE_MAX]
#define VM_FRAME_MAGIC_RESCUE
static VALUE vm_cfp_svar_get(rb_thread_t *th, rb_control_frame_t *cfp, VALUE key)
#define GetEnvPtr(obj, ptr)
int st_update(st_table *table, st_data_t key, st_update_callback_func *func, st_data_t arg)
VALUE rb_sourcefilename(void)
static VALUE lep_svar_get(rb_thread_t *th, VALUE *lep, rb_num_t key)
VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, int argc, const VALUE *argv, const rb_block_t *blockptr)
static VALUE * VM_CF_LEP(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
#define RUBY_VM_FIBER_VM_STACK_SIZE
static VALUE env_alloc(void)
static VALUE vm_default_params(void)
static VALUE main_to_s(VALUE obj)
void rb_undef_method(VALUE klass, const char *name)
VALUE rb_iseq_eval_main(VALUE iseqval)
void rb_mark_method_entry(const rb_method_entry_t *me)
void rb_gc_force_recycle(VALUE p)
static st_table * vm_opt_method_table
#define VM_FRAME_FLAG_PASSED
enum iseq_catch_table_entry::catch_type type
void rb_hash_foreach(VALUE hash, int(*func)(ANYARGS), VALUE farg)
void rb_exc_raise(VALUE mesg)
VALUE rb_singleton_class(VALUE obj)
Returns the singleton class of obj.
int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, VALUE *klassp)
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
VALUE rb_binding_new(void)
int st_lookup(st_table *, st_data_t, st_data_t *)
static VALUE m_core_define_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval)
#define MEMZERO(p, type, n)
RUBY_EXTERN VALUE rb_cBinding
unsigned short first_lineno
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)
#define RUBY_VM_THREAD_VM_STACK_SIZE
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 void add_opt_method(VALUE klass, ID mid, VALUE bop)
const char * rb_insns_name(int i)
#define BIGNUM_REDEFINED_OP_FLAG
rb_control_frame_t * rb_vm_get_ruby_level_next_cfp(rb_thread_t *th, const rb_control_frame_t *cfp)
VALUE * rb_vm_ep_local_ep(VALUE *ep)
RUBY_EXTERN VALUE rb_cObject
VALUE rb_block_lambda(void)
static void vm_iter_break(rb_thread_t *th, 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, VALUE defined_class)
const rb_data_type_t ruby_threadptr_data_type
size_t fiber_vm_stack_size
#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 load_path_check_cache
#define COPY_CREF(c1, c2)
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)
#define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN
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)
static void check_machine_stack_size(size_t *sizep)
#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)
struct st_table * loading_table
#define VM_FRAME_MAGIC_CLASS
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)
#define RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, klass, id)
static int kwmerge_ii(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
void rb_gc_register_mark_object(VALUE obj)
VALUE * rb_gc_stack_start
VALUE rb_obj_alloc(VALUE)
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)
static rb_control_frame_t * vm_push_frame(rb_thread_t *th, const rb_iseq_t *iseq, VALUE type, VALUE self, VALUE klass, VALUE specval, const VALUE *pc, VALUE *sp, int local_size, const rb_method_entry_t *me)
rb_method_entry_t * rb_method_entry(VALUE klass, ID id, VALUE *define_class_ptr)
void rb_thread_mark(void *ptr)
#define ARRAY_REDEFINED_OP_FLAG
#define RUBY_VM_FIBER_MACHINE_STACK_SIZE
void rb_gc_mark_machine_stack(rb_thread_t *th)
void * ruby_mimmalloc(size_t size)
void rb_call_end_proc(VALUE data)
VALUE rb_const_get(VALUE, ID)
rb_hook_list_t event_hooks
VALUE rb_iseq_clone(VALUE iseqval, VALUE newcbase)
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_alias_variable(ID, ID)
static void vm_svar_set(VALUE key, VALUE val)
static rb_block_t * VM_CF_BLOCK_PTR(rb_control_frame_t *cfp)
#define rb_thread_set_current(th)
#define VM_EP_PREV_EP(ep)
VALUE special_exceptions[ruby_special_error_count]
void rb_vm_stack_to_heap(rb_thread_t *th)
struct rb_mutex_struct * keeping_mutexes
VALUE rb_sprintf(const char *format,...)
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)
#define EXEC_EVENT_HOOK_AND_POP_FRAME(th_, flag_, self_, id_, klass_, data_)
VALUE rb_iv_set(VALUE, const char *, VALUE)
static VALUE m_core_define_singleton_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval)
struct rb_vm_struct::@130 trap_list[RUBY_NSIG]
int rb_is_local_id(ID id)
static void vm_set_eval_stack(rb_thread_t *th, VALUE iseqval, const NODE *cref, rb_block_t *base_block)
int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
#define FIXNUM_REDEFINED_OP_FLAG
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 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.
static VALUE * VM_EP_LEP(VALUE *ep)
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 VALUE * vm_base_ptr(rb_control_frame_t *cfp)
static void vm_pop_frame(rb_thread_t *th)
static VALUE m_core_hash_merge_ptr(int argc, VALUE *argv, VALUE recv)
#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 Init_native_thread(void)
#define SYMBOL_REDEFINED_OP_FLAG
void rb_alias(VALUE, ID, ID)
rb_iseq_location_t location
int rb_sigaltstack_size(void)
int ruby_vm_destruct(rb_vm_t *vm)
st_table * st_init_numtable(void)
#define RUBY_DTRACE_HASH_CREATE_ENABLED()
#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
void rb_iter_break_value(VALUE val)
static VALUE vm_svar_get(VALUE key)
void vm_trace_mark_event_hooks(rb_hook_list_t *hooks)
#define RUBY_FREE_UNLESS_NULL(ptr)
#define VM_FRAME_MAGIC_PROC
static int kwmerge_i(VALUE key, VALUE value, VALUE hash)
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 int vm_collect_local_variables_in_heap(rb_thread_t *th, VALUE *ep, VALUE ary)
static size_t get_param(const char *name, size_t default_value, size_t min_value)
#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)
static VALUE vm_get_cbase(const rb_iseq_t *iseq, const VALUE *ep)
static int vm_redefinition_check_flag(VALUE klass)
void rb_thread_recycle_stack_release(VALUE *stack)
VALUE rb_block_proc(void)
static const unsigned char cv[]
rb_method_definition_t * def
size_t st_memsize(const st_table *)
NORETURN(static void vm_iter_break(rb_thread_t *th, VALUE val))
VALUE * rb_ruby_verbose_ptr(void)
const rb_method_entry_t * me
#define RUBY_FREE_LEAVE(msg)
unsigned long rb_event_flag_t
rb_hook_list_t event_hooks
#define RUBY_VM_THREAD_VM_STACK_SIZE_MIN
VALUE rb_hash_aref(VALUE hash, VALUE key)
#define RUBY_FREE_ENTER(msg)
#define STRING_REDEFINED_OP_FLAG
static int check_redefined_method(st_data_t key, st_data_t value, st_data_t data)
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
#define RUBY_VM_FIBER_VM_STACK_SIZE_MIN
static void ruby_vm_run_at_exit_hooks(rb_vm_t *vm)
#define VM_PROFILE_ATEXIT()
#define VM_EP_BLOCK_PTR(ep)
rb_event_flag_t ruby_vm_event_flags
void(* ruby_vm_collect_usage_func_register)(int reg, int isset)
static const rb_data_type_t env_data_type
#define RUBY_MARK_UNLESS_NULL(ptr)
size_t thread_machine_stack_size
rb_block_t * rb_vm_control_frame_block_ptr(rb_control_frame_t *cfp)
#define TypedData_Make_Struct(klass, type, data_type, sval)
#define GetThreadPtr(obj, ptr)
VALUE loaded_features_snapshot
size_t rb_gc_stack_maxsize
static unsigned int hash(const char *str, unsigned int len)
void rb_vm_change_state(void)
static VALUE thread_alloc(VALUE klass)
static void env_free(void *const ptr)
#define TIME_REDEFINED_OP_FLAG
#define EXEC_EVENT_HOOK(th_, flag_, self_, id_, klass_, data_)
#define assert(condition)
NODE * rb_vm_get_cref(const rb_iseq_t *, const VALUE *)
#define GetISeqPtr(obj, ptr)
const char * rb_id2name(ID id)
static VALUE m_core_set_variable_alias(VALUE self, VALUE sym1, VALUE sym2)
struct rb_thread_struct rb_thread_t
static VALUE m_core_set_method_alias(VALUE self, VALUE cbase, VALUE sym1, VALUE sym2)
static VALUE m_core_set_postexe(VALUE self, VALUE iseqval)
void rb_vm_rewind_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
void rb_vm_gvl_destroy(rb_vm_t *vm)
static VALUE m_core_hash_merge_kwd(VALUE recv, VALUE hash, VALUE kw)
void rb_lastline_set(VALUE val)
#define GC_GUARDED_PTR_REF(p)
#define CONST_ID(var, str)
static VALUE vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self, VALUE defined_class, int argc, const VALUE *argv, const rb_block_t *blockptr)
VALUE rb_obj_freeze(VALUE)
#define SPECIAL_CONST_P(x)
#define CHECK_VM_STACK_OVERFLOW(cfp, margin)
VALUE pending_interrupt_queue
RUBY_EXTERN VALUE rb_cSymbol
static VALUE vm_make_proc_from_block(rb_thread_t *th, rb_block_t *block)
const char * rb_sourcefile(void)
static VALUE m_core_hash_from_ary(VALUE self, VALUE ary)
static void rb_vm_check_redefinition_opt_method(const rb_method_entry_t *me, VALUE klass)
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
RUBY_EXTERN VALUE rb_cFixnum
RUBY_EXTERN VALUE rb_cTime
void rb_vm_jump_tag_but_local_jump(int state)
#define INC_VM_STATE_VERSION()
#define HASH_REDEFINED_OP_FLAG
static rb_thread_t * GET_THREAD(void)
VALUE rb_class_new(VALUE super)
Creates a new class.
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
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)
VALUE rb_binding_alloc(VALUE klass)
static void vm_init_redefined_flag(void)
#define rb_thread_set_current_raw(th)
#define RUBY_DTRACE_HASH_CREATE(arg0, arg1, arg2)
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)
static void vm_default_params_setup(rb_vm_t *vm)
VALUE rb_thread_current_status(const rb_thread_t *th)