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++) {
2131 #if OPT_DIRECT_THREADED_CODE
2133 #elif OPT_TOKEN_THREADED_CODE
2135 #elif OPT_CALL_THREADED_CODE
2139 #if OPT_STACK_CACHING
2142 #if OPT_OPERANDS_UNIFICATION
2145 #if OPT_INSTRUCTIONS_UNIFICATION
2148 #if OPT_INLINE_METHOD_CACHE
2151 #if OPT_BLOCKINLINING
2173 volatile VALUE th_self;
2214 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
2225 fprintf(stderr,
"[FATAL] failed to allocate memory\n");
2233 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
2236 ruby_current_vm = vm;
2255 return GET_VM()->top_self;