64 #if VM_COLLECT_USAGE_DETAILS 65 static void vm_collect_usage_operand(
int insn,
int n,
VALUE op);
66 static void vm_collect_usage_insn(
int insn);
67 static void vm_collect_usage_register(
int reg,
int isset);
141 static VALUE sym_global_method_state, sym_global_constant_state, sym_class_serial;
152 }
else if (arg ==
Qnil) {
156 if (sym_global_method_state == 0) {
157 #define S(s) sym_##s = ID2SYM(rb_intern_const(#s)) 158 S(global_method_state);
159 S(global_constant_state);
164 #define SET(name, attr) \ 165 if (key == sym_##name) \ 166 return SERIALT2NUM(attr); \ 167 else if (hash != Qnil) \ 168 rb_hash_aset(hash, sym_##name, SERIALT2NUM(attr)); 189 if (iseq->
type != ISEQ_TYPE_TOP) {
294 while (th->
cfp != cfp) {
296 printf(
"skipped frame: %s\n", vm_frametype_name(th->
cfp));
329 typedef void rb_vm_at_exit_func(
rb_vm_t*);
345 #define ENV_IN_HEAP_P(th, env) \ 346 (!((th)->stack <= (env) && (env) < ((th)->stack + (th)->stack_size))) 347 #define ENV_VAL(env) ((env)[1]) 367 if (
env->block.iseq) {
418 env->prev_envval = 0;
428 fprintf(stderr,
"---\n");
429 fprintf(stderr,
"envptr: %p\n", (
void *)&
env->block.ep[0]);
430 fprintf(stderr,
"envval: %10p ", (
void *)
env->block.ep[1]);
431 dp(
env->block.ep[1]);
432 fprintf(stderr,
"ep: %10p\n", (
void *)
env->block.ep);
433 if (
env->prev_envval) {
434 fprintf(stderr,
">>\n");
436 fprintf(stderr,
"<<\n");
458 VALUE envval, penvval = 0;
467 if (envptr != endptr) {
475 while (pcfp->
ep != penvptr) {
498 env->env_size = local_size + 1 + 1;
499 env->local_size = local_size;
501 env->prev_envval = penvval;
503 for (i = 0; i <= local_size; i++) {
504 env->env[i] = envptr[-local_size + i];
506 fprintf(stderr,
"%2d ", &envptr[-local_size + i] - th->
stack);
dp(
env->env[i]);
509 envptr[-local_size + i] = 0;
515 nenvptr = &
env->env[i - 1];
523 env->block.ep = cfp->
ep;
595 *blockprocptr = blockprocval;
615 (cfp->
iseq->
type == ISEQ_TYPE_RESCUE ||
616 cfp->
iseq->
type == ISEQ_TYPE_ENSURE)) {
621 VALUE epval = *escape_ep;
658 VALUE procval, envval, blockprocval = 0;
663 rb_bug(
"rb_vm_make_proc: Proc value is already created.");
684 rb_bug(
"invalid ptr: block->ep");
698 VALUE bindval, envval;
700 VALUE blockprocval = 0;
702 if (cfp == 0 || ruby_level_cfp == 0) {
708 if (cfp == ruby_level_cfp) {
733 ID minibuf[4], *dyns = minibuf;
735 VALUE blockprocval = 0;
737 if (dyncount < 0)
return 0;
741 base_block = &
env->block;
742 base_iseq = base_block->
iseq;
747 MEMCPY(dyns + 1, dynvars,
ID, dyncount);
751 base_iseq->
self, ISEQ_TYPE_EVAL);
779 int i, opt_pc, arg_size = iseq->
arg_size;
785 for (i=0; i<
argc; i++) {
909 while (cfp->
pc == 0) {
1031 if (cfp->
self !=
self)
return NULL;
1037 debug_cref(
NODE *cref)
1041 printf(
"%ld\n", cref->nd_visi);
1042 cref = cref->nd_next;
1239 #define OP(mid_, bop_) (mid = id##mid_, bop = BOP_##bop_, ruby_vm_redefined_flag[bop] = 0) 1240 #define C(k) add_opt_method(rb_c##k, mid, bop) 1241 OP(PLUS, PLUS), (
C(Fixnum),
C(Float),
C(String),
C(Array));
1242 OP(MINUS, MINUS), (
C(Fixnum),
C(Float));
1243 OP(MULT, MULT), (
C(Fixnum),
C(Float));
1246 OP(Eq, EQ), (
C(Fixnum),
C(Float),
C(String));
1247 OP(Eqq, EQQ), (
C(Fixnum),
C(Bignum),
C(Float),
C(Symbol),
C(String));
1248 OP(LT, LT), (
C(Fixnum),
C(Float));
1249 OP(LE, LE), (
C(Fixnum),
C(Float));
1250 OP(GT, GT), (
C(Fixnum),
C(Float));
1251 OP(GE, GE), (
C(Fixnum),
C(Float));
1252 OP(LTLT, LTLT), (
C(String),
C(Array));
1254 OP(ASET, ASET), (
C(Array),
C(Hash));
1255 OP(Length, LENGTH), (
C(Array),
C(String),
C(Hash));
1256 OP(Size, SIZE), (
C(Array),
C(String),
C(Hash));
1257 OP(EmptyP, EMPTY_P), (
C(Array),
C(String),
C(Hash));
1258 OP(Succ, SUCC), (
C(Fixnum),
C(String),
C(Time));
1260 OP(Freeze, FREEZE), (
C(String));
1301 if (!will_finish_vm_exec) {
1428 if ((state = th->
state) != 0) {
1431 goto exception_handler;
1437 unsigned long epc, cont_pc, cont_sp;
1438 VALUE catch_iseqval;
1446 cont_pc = cont_sp = catch_iseqval = 0;
1464 if (cfp->
ep == escape_ep) {
1473 if (entry->
start < epc && entry->
end >= epc) {
1475 catch_iseqval = entry->
iseq;
1476 cont_pc = entry->
cont;
1477 cont_sp = entry->
sp;
1482 if (!catch_iseqval) {
1494 #if OPT_STACK_CACHING 1508 if (entry->
start < epc && entry->
end >= epc) {
1512 catch_iseqval = entry->
iseq;
1513 cont_pc = entry->
cont;
1514 cont_sp = entry->
sp;
1523 if (entry->
start < epc && entry->
end >= epc) {
1526 catch_iseqval = entry->
iseq;
1527 cont_pc = entry->
cont;
1528 cont_sp = entry->
sp;
1534 if (cfp->
ep == escape_ep) {
1543 else if (state ==
TAG_BREAK && ((
VALUE)escape_ep & ~0x03) == 0) {
1546 search_restart_point:
1550 if (entry->
start < epc && entry->
end >= epc) {
1552 catch_iseqval = entry->
iseq;
1553 cont_pc = entry->
cont;
1554 cont_sp = entry->
sp;
1562 #if OPT_STACK_CACHING 1577 goto search_restart_point;
1581 goto search_restart_point;
1586 if (entry->
start < epc && entry->
end >= epc) {
1589 catch_iseqval = entry->
iseq;
1590 cont_pc = entry->
cont;
1591 cont_sp = entry->
sp;
1598 if (catch_iseqval != 0) {
1634 goto exception_handler;
1677 if (klassp) *klassp = cfp->
me->
klass;
1683 if (klassp) *klassp = 0;
1686 if (
iseq->defined_method_id) {
1687 if (idp) *idp =
iseq->defined_method_id;
1688 if (klassp) *klassp =
iseq->klass;
1717 if (cfp->
iseq != 0) {
1771 RUBY_GC_INFO(
"-------------------------------------------------\n");
1827 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE 1842 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE 1886 #define SET(name) rb_hash_aset(result, ID2SYM(rb_intern(#name)), SIZET2NUM(vm->default_params.name)); 1887 SET(thread_vm_stack_size);
1888 SET(thread_machine_stack_size);
1889 SET(fiber_vm_stack_size);
1890 SET(fiber_machine_stack_size);
1900 size_t result = default_value;
1902 long val = atol(envval);
1903 if (
val < (
long)min_value) {
1904 val = (long)min_value;
1916 #ifdef PTHREAD_STACK_MIN 1917 size_t size = *sizep;
1920 #ifdef __SYMBIAN32__ 1924 #ifdef PTHREAD_STACK_MIN 1925 if (
size < PTHREAD_STACK_MIN) {
1926 *sizep = PTHREAD_STACK_MIN * 2;
1940 get_param(
"RUBY_THREAD_MACHINE_STACK_SIZE",
1950 get_param(
"RUBY_FIBER_MACHINE_STACK_SIZE",
1972 #define USE_THREAD_DATA_RECYCLE 1 1974 #if USE_THREAD_DATA_RECYCLE 1975 #define RECYCLE_MAX 64 1992 #define thread_recycle_stack(size) ALLOC_N(VALUE, (size)) 1998 #if USE_THREAD_DATA_RECYCLE 2007 #ifdef USE_THREAD_RECYCLE 2009 thread_recycle_struct(
void)
2035 while (cfp != limit_cfp) {
2100 rb_bug(
"thread_free: locking_mutex must be NULL (%p:%p)", (
void *)th, (
void *)th->
locking_mutex);
2103 rb_bug(
"thread_free: keeping_mutexes must be NULL (%p:%p)", (
void *)th, (
void *)th->
keeping_mutexes);
2114 #ifdef USE_SIGALTSTACK 2147 #define thread_data_type ruby_threadptr_data_type 2173 #ifdef USE_THREAD_RECYCLE 2189 #ifdef USE_SIGALTSTACK 2210 #if OPT_CALL_THREADED_CODE 2244 VALUE klass = cref->nd_clss;
2245 int noex = (int)cref->nd_visi;
2267 miseq->defined_method_id =
id;
2276 #define REWIND_CFP(expr) do { \ 2277 rb_thread_t *th__ = GET_THREAD(); \ 2278 VALUE *const curr_sp = (th__->cfp++)->sp; \ 2279 VALUE *const saved_sp = th__->cfp->sp; \ 2280 th__->cfp->sp = curr_sp; \ 2282 (th__->cfp--)->sp = saved_sp; \ 2348 for (i=0; i<
argc; i+=2) {
2447 extern VALUE *rb_gc_register_stack_start;
2466 #include <execinfo.h> 2467 #define MAX_NATIVE_TRACE 1024 2468 static void *trace[MAX_NATIVE_TRACE];
2469 int n = backtrace(trace, MAX_NATIVE_TRACE);
2470 char **syms = backtrace_symbols(trace, n);
2477 for (i=0; i<n; i++) {
2485 #if VM_COLLECT_USAGE_DETAILS 2486 static VALUE usage_analysis_insn_stop(
VALUE self);
2487 static VALUE usage_analysis_operand_stop(
VALUE self);
2488 static VALUE usage_analysis_register_stop(
VALUE self);
2682 #if VM_COLLECT_USAGE_DETAILS 2684 #define define_usage_analysis_hash(name) \ 2685 rb_define_const(rb_cRubyVM, "USAGE_ANALYSIS_"#name, rb_hash_new()) 2686 define_usage_analysis_hash(
"INSN");
2687 define_usage_analysis_hash(
"REGS");
2688 define_usage_analysis_hash(
"INSN_BIGRAM");
2698 #if OPT_DIRECT_THREADED_CODE 2700 #elif OPT_TOKEN_THREADED_CODE 2702 #elif OPT_CALL_THREADED_CODE 2706 #if OPT_STACK_CACHING 2709 #if OPT_OPERANDS_UNIFICATION 2712 #if OPT_INSTRUCTIONS_UNIFICATION 2715 #if OPT_INLINE_METHOD_CACHE 2718 #if OPT_BLOCKINLINING 2748 volatile VALUE th_self;
2795 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE 2806 fprintf(stderr,
"[FATAL] failed to allocate memory\n");
2813 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE 2836 return GET_VM()->top_self;
2879 int len,
size_t pos,
VALUE *pnop,
VALUE child);
2881 #if VM_COLLECT_USAGE_DETAILS 2883 #define HASH_ASET(h, k, v) rb_hash_aset((h), (st_data_t)(k), (st_data_t)(v)) 2897 vm_analysis_insn(
int insn)
2901 static int prev_insn = -1;
2907 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
2908 CONST_ID(bigram_hash,
"USAGE_ANALYSIS_INSN_BIGRAM");
2912 HASH_ASET(uh,
INT2FIX(insn), ihash);
2920 if (prev_insn != -1) {
2939 vm_analysis_operand(
int insn,
int n,
VALUE op)
2949 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
2954 HASH_ASET(uh,
INT2FIX(insn), ihash);
2958 HASH_ASET(ihash,
INT2FIX(n), ophash);
2971 vm_analysis_register(
int reg,
int isset)
2976 static const char regstrs[][5] = {
2984 static const char getsetstr[][4] = {
2988 static VALUE syms[
sizeof(regstrs) /
sizeof(regstrs[0])][2];
2992 CONST_ID(usage_hash,
"USAGE_ANALYSIS_REGS");
2997 for (i = 0; i < (int)(
sizeof(regstrs) /
sizeof(regstrs[0])); i++) {
2999 for (j = 0; j < 2; j++) {
3000 snprintf(buff, 0x10,
"%d %s %-4s", i, getsetstr[j], regstrs[i]);
3005 valstr = syms[reg][isset];
3022 usage_analysis_insn_stop(
VALUE self)
3030 usage_analysis_operand_stop(
VALUE self)
3038 usage_analysis_register_stop(
VALUE self)
3052 #if VM_COLLECT_USAGE_DETAILS 3055 vm_collect_usage_insn(
int insn)
3057 if (RUBY_DTRACE_INSN_ENABLED()) {
3061 (*ruby_vm_collect_usage_func_insn)(insn);
3069 vm_collect_usage_operand(
int insn,
int n,
VALUE op)
3071 if (RUBY_DTRACE_INSN_OPERAND_ENABLED()) {
3080 (*ruby_vm_collect_usage_func_operand)(insn, n, op);
3086 vm_collect_usage_register(
int reg,
int isset)
3089 (*ruby_vm_collect_usage_func_register)(reg, isset);
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)
#define RUBY_VM_THREAD_MACHINE_STACK_SIZE
#define VM_FRAME_MAGIC_BLOCK
#define RUBY_EVENT_B_RETURN
#define NEXT_CLASS_SERIAL()
static VALUE m_core_set_postexe(VALUE self)
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)
void rb_vm_bugreport(void)
void rb_vm_check_redefinition_by_prepend(VALUE klass)
VALUE rb_ary_pop(VALUE ary)
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,...)
int rb_vm_add_root_module(ID id, VALUE module)
static size_t vm_memsize(const void *ptr)
#define RUBY_TYPED_FREE_IMMEDIATELY
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
#define RB_OBJ_WRITTEN(a, oldv, b)
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.
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, size_t stack_max)
#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)
#define GetProcPtr(obj, ptr)
static VALUE vm_yield(rb_thread_t *th, int argc, const VALUE *argv)
#define RUBY_VM_NORMAL_ISEQ_P(ptr)
#define SET_THROWOBJ_STATE(obj, val)
static int kwcheck_i(VALUE key, VALUE value, VALUE hash)
#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)
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)
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)
void ruby_mimfree(void *ptr)
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 VM_ENVVAL_BLOCK_PTR(v)
VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass)
VALUE rb_iv_set(VALUE, const char *, VALUE)
#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)
#define RUBY_MARK_LEAVE(msg)
static VALUE vm_yield_with_block(rb_thread_t *th, int argc, const VALUE *argv, const rb_block_t *blockargptr)
VALUE rb_convert_type(VALUE, int, const char *, const char *)
static void env_mark(void *const ptr)
#define VM_FRAME_MAGIC_IFUNC
static void hook_before_rewind(rb_thread_t *th, rb_control_frame_t *cfp, int will_finish_vm_exec)
static int thread_recycle_stack_count
void Init_vm_backtrace(void)
void rb_vm_localjump_error(const char *mesg, VALUE value, int reason)
rb_serial_t rb_next_class_serial(void)
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)
#define VM_FRAME_FLAG_BMETHOD
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)
NODE * rb_vm_cref_in_context(VALUE self)
struct rb_thread_struct::@169 machine
VALUE rb_iseq_eval_main(VALUE iseqval)
void rb_mark_method_entry(const rb_method_entry_t *me)
#define RUBY_DTRACE_METHOD_ENTRY_HOOK(th, klass, id)
void rb_gc_force_recycle(VALUE p)
#define REGEXP_REDEFINED_OP_FLAG
static st_table * vm_opt_method_table
#define VM_FRAME_FLAG_PASSED
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
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 defined_module_hash
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)
static rb_serial_t ruby_vm_class_serial
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)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
#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_insn_operand_intern(rb_iseq_t *iseq, VALUE insn, int op_no, VALUE op, int len, size_t pos, VALUE *pnop, VALUE child)
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
struct rb_vm_struct::@167 trap_list[RUBY_NSIG]
#define COPY_CREF(c1, c2)
static VALUE RCLASS_SET_SUPER(VALUE klass, VALUE super)
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 VALUE vm_stat(int argc, VALUE *argv, VALUE self)
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)
#define ALLOCV_N(type, v, n)
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)
#define MEMCPY(p1, p2, type, n)
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)
#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)
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
VALUE * rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars)
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.
RUBY_EXTERN VALUE rb_cRegexp
void rb_alias_variable(ID, ID)
static VALUE core_hash_from_ary(VALUE ary)
#define RARRAY_CONST_PTR(a)
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,...)
unsigned long rb_serial_t
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_)
static VALUE m_core_define_singleton_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval)
int rb_is_local_id(ID id)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
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)
VALUE rb_ivar_set(VALUE, ID, VALUE)
#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 *))
static VALUE * VM_EP_LEP(VALUE *ep)
void rb_clear_method_cache_by_class(VALUE)
#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)
VALUE rb_obj_hide(VALUE obj)
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)
#define RUBY_FREE_UNLESS_NULL(ptr)
#define VM_FRAME_MAGIC_PROC
static int kwmerge_i(VALUE key, VALUE value, VALUE hash)
VALUE rb_mRubyVMFrozenCore
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
rb_vm_t * ruby_current_vm
struct rb_vm_struct::@168 default_params
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)
typedefRUBY_SYMBOL_EXPORT_BEGIN struct re_pattern_buffer Regexp
#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)
rb_nativethread_id_t thread_id
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 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)
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)
short ruby_vm_redefined_flag[BOP_LAST_]
#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)
const rb_method_entry_t * passed_bmethod_me
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)
#define VM_FRAME_TYPE_BMETHOD_P(cfp)
static rb_serial_t ruby_vm_global_method_state
struct rb_thread_struct rb_thread_t
static VALUE m_core_set_method_alias(VALUE self, VALUE cbase, VALUE sym1, VALUE sym2)
void rb_vm_rewind_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
void rb_vm_gvl_destroy(rb_vm_t *vm)
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)
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)
RUBY_EXTERN VALUE rb_cFixnum
RUBY_EXTERN VALUE rb_cTime
void rb_vm_jump_tag_but_local_jump(int state)
#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)
#define NEW_NODE(t, a0, a1, a2)
#define GET_THROWOBJ_VAL(obj)
VALUE rb_obj_is_thread(VALUE obj)
static VALUE core_hash_merge_ary(VALUE hash, VALUE ary)
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 RB_OBJ_WRITE(a, slot, b)
#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)