mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
rename rb_execution_context_t::stack(_size) to vm_stack(_size).
* vm_core.h: Ruby processes run with two stacks, a machine stack and a VM stack. To make it clear, this fix renames rb_execution_context_t::stack(_size) to vm_stack(_size). git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@59563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ko1
parent
25213719c2
commit
6881279149
9 changed files with 68 additions and 68 deletions
54
cont.c
54
cont.c
|
|
@ -87,8 +87,8 @@ typedef struct rb_context_struct {
|
|||
VALUE value;
|
||||
VALUE *vm_stack;
|
||||
#ifdef CAPTURE_JUST_VALID_VM_STACK
|
||||
size_t vm_stack_slen; /* length of stack (head of th->ec.stack) */
|
||||
size_t vm_stack_clen; /* length of control frames (tail of th->ec.stack) */
|
||||
size_t vm_stack_slen; /* length of stack (head of th->ec.svm_tack) */
|
||||
size_t vm_stack_clen; /* length of control frames (tail of th->ec.vm_stack) */
|
||||
#endif
|
||||
struct {
|
||||
VALUE *stack;
|
||||
|
|
@ -265,7 +265,7 @@ cont_free(void *ptr)
|
|||
rb_context_t *cont = ptr;
|
||||
|
||||
RUBY_FREE_ENTER("cont");
|
||||
RUBY_FREE_UNLESS_NULL(cont->saved_thread.ec.stack);
|
||||
RUBY_FREE_UNLESS_NULL(cont->saved_thread.ec.vm_stack);
|
||||
#if FIBER_USE_NATIVE
|
||||
if (cont->type == CONTINUATION_CONTEXT) {
|
||||
/* cont */
|
||||
|
|
@ -324,7 +324,7 @@ cont_memsize(const void *ptr)
|
|||
#ifdef CAPTURE_JUST_VALID_VM_STACK
|
||||
size_t n = (cont->vm_stack_slen + cont->vm_stack_clen);
|
||||
#else
|
||||
size_t n = cont->saved_thread.ec.stack_size;
|
||||
size_t n = cont->saved_thread.ec.vm_stack_size;
|
||||
#endif
|
||||
size += n * sizeof(*cont->vm_stack);
|
||||
}
|
||||
|
|
@ -346,10 +346,10 @@ fiber_verify(const rb_fiber_t *fib)
|
|||
#if VM_CHECK_MODE > 0
|
||||
switch (fib->status) {
|
||||
case FIBER_RESUMED:
|
||||
VM_ASSERT(fib->cont.saved_thread.ec.stack == NULL);
|
||||
VM_ASSERT(fib->cont.saved_thread.ec.vm_stack == NULL);
|
||||
break;
|
||||
case FIBER_SUSPENDED:
|
||||
VM_ASSERT(fib->cont.saved_thread.ec.stack != NULL);
|
||||
VM_ASSERT(fib->cont.saved_thread.ec.vm_stack != NULL);
|
||||
break;
|
||||
case FIBER_CREATED:
|
||||
case FIBER_TERMINATED:
|
||||
|
|
@ -531,17 +531,17 @@ cont_capture(volatile int *volatile stat)
|
|||
contval = cont->self;
|
||||
|
||||
#ifdef CAPTURE_JUST_VALID_VM_STACK
|
||||
cont->vm_stack_slen = ec->cfp->sp - ec->stack;
|
||||
cont->vm_stack_clen = ec->stack + ec->stack_size - (VALUE*)ec->cfp;
|
||||
cont->vm_stack_slen = ec->cfp->sp - ec->vm_stack;
|
||||
cont->vm_stack_clen = ec->vm_stack + ec->vm_stack_size - (VALUE*)ec->cfp;
|
||||
cont->vm_stack = ALLOC_N(VALUE, cont->vm_stack_slen + cont->vm_stack_clen);
|
||||
MEMCPY(cont->vm_stack, ec->stack, VALUE, cont->vm_stack_slen);
|
||||
MEMCPY(cont->vm_stack, ec->vm_stack, VALUE, cont->vm_stack_slen);
|
||||
MEMCPY(cont->vm_stack + cont->vm_stack_slen,
|
||||
(VALUE*)ec->cfp, VALUE, cont->vm_stack_clen);
|
||||
#else
|
||||
cont->vm_stack = ALLOC_N(VALUE, ec->stack_size);
|
||||
MEMCPY(cont->vm_stack, ec->stack, VALUE, ec->stack_size);
|
||||
cont->vm_stack = ALLOC_N(VALUE, ec->vm_stack_size);
|
||||
MEMCPY(cont->vm_stack, ec->vm_stack, VALUE, ec->vm_stack_size);
|
||||
#endif
|
||||
cont->saved_thread.ec.stack = NULL;
|
||||
cont->saved_thread.ec.vm_stack = NULL;
|
||||
|
||||
cont_save_machine_stack(th, cont);
|
||||
|
||||
|
|
@ -590,16 +590,16 @@ cont_restore_thread(rb_context_t *cont)
|
|||
th->fiber = sth->fiber;
|
||||
fib = th->fiber ? th->fiber : th->root_fiber;
|
||||
|
||||
if (fib && fib->cont.saved_thread.ec.stack) {
|
||||
th->ec.stack_size = fib->cont.saved_thread.ec.stack_size;
|
||||
th->ec.stack = fib->cont.saved_thread.ec.stack;
|
||||
if (fib && fib->cont.saved_thread.ec.vm_stack) {
|
||||
th->ec.vm_stack_size = fib->cont.saved_thread.ec.vm_stack_size;
|
||||
th->ec.vm_stack = fib->cont.saved_thread.ec.vm_stack;
|
||||
}
|
||||
#ifdef CAPTURE_JUST_VALID_VM_STACK
|
||||
MEMCPY(th->ec.stack, cont->vm_stack, VALUE, cont->vm_stack_slen);
|
||||
MEMCPY(th->ec.stack + sth->ec.stack_size - cont->vm_stack_clen,
|
||||
MEMCPY(th->ec.vm_stack, cont->vm_stack, VALUE, cont->vm_stack_slen);
|
||||
MEMCPY(th->ec.vm_stack + sth->ec.vm_stack_size - cont->vm_stack_clen,
|
||||
cont->vm_stack + cont->vm_stack_slen, VALUE, cont->vm_stack_clen);
|
||||
#else
|
||||
MEMCPY(th->ec.stack, cont->vm_stack, VALUE, sth->ec.stack_size);
|
||||
MEMCPY(th->ec.vm_stack, cont->vm_stack, VALUE, sth->ec.vm_stack_size);
|
||||
#endif
|
||||
|
||||
/* other members of ec */
|
||||
|
|
@ -617,11 +617,11 @@ cont_restore_thread(rb_context_t *cont)
|
|||
else {
|
||||
/* fiber */
|
||||
th->ec = sth->ec;
|
||||
sth->ec.stack = NULL;
|
||||
sth->ec.vm_stack = NULL;
|
||||
th->fiber = (rb_fiber_t*)cont;
|
||||
}
|
||||
|
||||
VM_ASSERT(th->ec.stack != NULL);
|
||||
VM_ASSERT(th->ec.vm_stack != NULL);
|
||||
VM_ASSERT(sth->status == THREAD_RUNNABLE);
|
||||
}
|
||||
|
||||
|
|
@ -1258,12 +1258,12 @@ fiber_init(VALUE fibval, VALUE proc)
|
|||
/* initialize cont */
|
||||
cont->vm_stack = 0;
|
||||
|
||||
th->ec.stack = NULL;
|
||||
th->ec.stack_size = 0;
|
||||
th->ec.vm_stack = NULL;
|
||||
th->ec.vm_stack_size = 0;
|
||||
|
||||
th->ec.stack_size = cth->vm->default_params.fiber_vm_stack_size / sizeof(VALUE);
|
||||
th->ec.stack = ALLOC_N(VALUE, th->ec.stack_size);
|
||||
th->ec.cfp = (void *)(th->ec.stack + th->ec.stack_size);
|
||||
th->ec.vm_stack_size = cth->vm->default_params.fiber_vm_stack_size / sizeof(VALUE);
|
||||
th->ec.vm_stack = ALLOC_N(VALUE, th->ec.vm_stack_size);
|
||||
th->ec.cfp = (void *)(th->ec.vm_stack + th->ec.vm_stack_size);
|
||||
|
||||
rb_vm_push_frame(th,
|
||||
NULL,
|
||||
|
|
@ -1272,7 +1272,7 @@ fiber_init(VALUE fibval, VALUE proc)
|
|||
VM_BLOCK_HANDLER_NONE,
|
||||
0, /* specval */
|
||||
NULL, /* pc */
|
||||
th->ec.stack, /* sp */
|
||||
th->ec.vm_stack, /* sp */
|
||||
0, /* local_size */
|
||||
0);
|
||||
|
||||
|
|
@ -1374,7 +1374,7 @@ fiber_current(void)
|
|||
if (th->fiber == 0) {
|
||||
rb_fiber_t *fib = root_fiber_alloc(th);
|
||||
/* Running thread object has stack management responsibility */
|
||||
fib->cont.saved_thread.ec.stack = NULL;
|
||||
fib->cont.saved_thread.ec.vm_stack = NULL;
|
||||
}
|
||||
return th->fiber;
|
||||
}
|
||||
|
|
|
|||
2
eval.c
2
eval.c
|
|
@ -1127,7 +1127,7 @@ previous_frame(rb_thread_t *th)
|
|||
{
|
||||
rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->ec.cfp);
|
||||
/* check if prev_cfp can be accessible */
|
||||
if ((void *)(th->ec.stack + th->ec.stack_size) == (void *)(prev_cfp)) {
|
||||
if ((void *)(th->ec.vm_stack + th->ec.vm_stack_size) == (void *)(prev_cfp)) {
|
||||
return 0;
|
||||
}
|
||||
return prev_cfp;
|
||||
|
|
|
|||
4
thread.c
4
thread.c
|
|
@ -694,8 +694,8 @@ thread_start_func_2(rb_thread_t *th, VALUE *stack_start, VALUE *register_stack_s
|
|||
rb_threadptr_unlock_all_locking_mutexes(th);
|
||||
rb_check_deadlock(th->vm);
|
||||
|
||||
rb_thread_recycle_stack_release(th->ec.stack);
|
||||
th->ec.stack = NULL;
|
||||
rb_thread_recycle_stack_release(th->ec.vm_stack);
|
||||
th->ec.vm_stack = NULL;
|
||||
}
|
||||
native_mutex_lock(&th->vm->thread_destruct_lock);
|
||||
/* make sure vm->running_thread never point me after this point.*/
|
||||
|
|
|
|||
32
vm.c
32
vm.c
|
|
@ -88,8 +88,8 @@ rb_vm_frame_block_handler(const rb_control_frame_t *cfp)
|
|||
static int
|
||||
VM_CFP_IN_HEAP_P(const rb_thread_t *th, const rb_control_frame_t *cfp)
|
||||
{
|
||||
const VALUE *start = th->ec.stack;
|
||||
const VALUE *end = (VALUE *)th->ec.stack + th->ec.stack_size;
|
||||
const VALUE *start = th->ec.vm_stack;
|
||||
const VALUE *end = (VALUE *)th->ec.vm_stack + th->ec.vm_stack_size;
|
||||
VM_ASSERT(start != NULL);
|
||||
|
||||
if (start <= (VALUE *)cfp && (VALUE *)cfp < end) {
|
||||
|
|
@ -103,7 +103,7 @@ VM_CFP_IN_HEAP_P(const rb_thread_t *th, const rb_control_frame_t *cfp)
|
|||
static int
|
||||
VM_EP_IN_HEAP_P(const rb_thread_t *th, const VALUE *ep)
|
||||
{
|
||||
const VALUE *start = th->ec.stack;
|
||||
const VALUE *start = th->ec.vm_stack;
|
||||
const VALUE *end = (VALUE *)th->ec.cfp;
|
||||
VM_ASSERT(start != NULL);
|
||||
|
||||
|
|
@ -2370,11 +2370,11 @@ rb_thread_mark(void *ptr)
|
|||
RUBY_MARK_ENTER("thread");
|
||||
|
||||
/* mark VM stack */
|
||||
if (th->ec.stack) {
|
||||
VALUE *p = th->ec.stack;
|
||||
if (th->ec.vm_stack) {
|
||||
VALUE *p = th->ec.vm_stack;
|
||||
VALUE *sp = th->ec.cfp->sp;
|
||||
rb_control_frame_t *cfp = th->ec.cfp;
|
||||
rb_control_frame_t *limit_cfp = (void *)(th->ec.stack + th->ec.stack_size);
|
||||
rb_control_frame_t *limit_cfp = (void *)(th->ec.vm_stack + th->ec.vm_stack_size);
|
||||
|
||||
rb_gc_mark_values((long)(sp - p), p);
|
||||
|
||||
|
|
@ -2435,9 +2435,9 @@ thread_free(void *ptr)
|
|||
rb_thread_t *th = ptr;
|
||||
RUBY_FREE_ENTER("thread");
|
||||
|
||||
if (th->ec.stack != NULL) {
|
||||
rb_thread_recycle_stack_release(th->ec.stack);
|
||||
th->ec.stack = NULL;
|
||||
if (th->ec.vm_stack != NULL) {
|
||||
rb_thread_recycle_stack_release(th->ec.vm_stack);
|
||||
th->ec.vm_stack = NULL;
|
||||
}
|
||||
|
||||
if (th->locking_mutex != Qfalse) {
|
||||
|
|
@ -2475,7 +2475,7 @@ thread_memsize(const void *ptr)
|
|||
size_t size = sizeof(rb_thread_t);
|
||||
|
||||
if (!th->root_fiber) {
|
||||
size += th->ec.stack_size * sizeof(VALUE);
|
||||
size += th->ec.vm_stack_size * sizeof(VALUE);
|
||||
}
|
||||
if (th->ec.local_storage) {
|
||||
size += st_memsize(th->ec.local_storage);
|
||||
|
|
@ -2525,18 +2525,18 @@ th_init(rb_thread_t *th, VALUE self)
|
|||
/* altstack of main thread is reallocated in another place */
|
||||
th->altstack = malloc(rb_sigaltstack_size());
|
||||
#endif
|
||||
/* th->ec.stack_size is word number.
|
||||
/* th->ec.vm_stack_size is word number.
|
||||
* th->vm->default_params.thread_vm_stack_size is byte size.
|
||||
*/
|
||||
th->ec.stack_size = th->vm->default_params.thread_vm_stack_size / sizeof(VALUE);
|
||||
th->ec.stack = thread_recycle_stack(th->ec.stack_size);
|
||||
th->ec.vm_stack_size = th->vm->default_params.thread_vm_stack_size / sizeof(VALUE);
|
||||
th->ec.vm_stack = thread_recycle_stack(th->ec.vm_stack_size);
|
||||
|
||||
th->ec.cfp = (void *)(th->ec.stack + th->ec.stack_size);
|
||||
th->ec.cfp = (void *)(th->ec.vm_stack + th->ec.vm_stack_size);
|
||||
|
||||
vm_push_frame(th, 0 /* dummy iseq */, VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH | VM_FRAME_FLAG_CFRAME /* dummy frame */,
|
||||
Qnil /* dummy self */, VM_BLOCK_HANDLER_NONE /* dummy block ptr */,
|
||||
0 /* dummy cref/me */,
|
||||
0 /* dummy pc */, th->ec.stack, 0, 0);
|
||||
0 /* dummy pc */, th->ec.vm_stack, 0, 0);
|
||||
|
||||
th->status = THREAD_RUNNABLE;
|
||||
th->last_status = Qnil;
|
||||
|
|
@ -3102,7 +3102,7 @@ void
|
|||
rb_vm_set_progname(VALUE filename)
|
||||
{
|
||||
rb_thread_t *th = GET_VM()->main_thread;
|
||||
rb_control_frame_t *cfp = (void *)(th->ec.stack + th->ec.stack_size);
|
||||
rb_control_frame_t *cfp = (void *)(th->ec.vm_stack + th->ec.vm_stack_size);
|
||||
--cfp;
|
||||
|
||||
rb_iseq_pathobj_set(cfp->iseq, rb_str_dup(filename), rb_iseq_realpath(cfp->iseq));
|
||||
|
|
|
|||
|
|
@ -737,8 +737,8 @@ typedef struct rb_fiber_struct rb_fiber_t;
|
|||
|
||||
typedef struct rb_thread_context_struct {
|
||||
/* execution information */
|
||||
VALUE *stack; /* must free, must mark */
|
||||
size_t stack_size; /* size in word (byte size / sizeof(VALUE)) */
|
||||
VALUE *vm_stack; /* must free, must mark */
|
||||
size_t vm_stack_size; /* size in word (byte size / sizeof(VALUE)) */
|
||||
rb_control_frame_t *cfp;
|
||||
|
||||
struct rb_vm_tag *tag;
|
||||
|
|
@ -1235,7 +1235,7 @@ VALUE rb_vm_frame_block_handler(const rb_control_frame_t *cfp);
|
|||
#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) ((cfp)+1)
|
||||
#define RUBY_VM_NEXT_CONTROL_FRAME(cfp) ((cfp)-1)
|
||||
#define RUBY_VM_END_CONTROL_FRAME(th) \
|
||||
((rb_control_frame_t *)((th)->ec.stack + (th)->ec.stack_size))
|
||||
((rb_control_frame_t *)((th)->ec.vm_stack + (th)->ec.vm_stack_size))
|
||||
#define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp) \
|
||||
((void *)(ecfp) > (void *)(cfp))
|
||||
#define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp) \
|
||||
|
|
|
|||
30
vm_dump.c
30
vm_dump.c
|
|
@ -22,14 +22,14 @@
|
|||
#define MAX_POSBUF 128
|
||||
|
||||
#define VM_CFP_CNT(th, cfp) \
|
||||
((rb_control_frame_t *)((th)->ec.stack + (th)->ec.stack_size) - \
|
||||
((rb_control_frame_t *)((th)->ec.vm_stack + (th)->ec.vm_stack_size) - \
|
||||
(rb_control_frame_t *)(cfp))
|
||||
|
||||
static void
|
||||
control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
|
||||
{
|
||||
ptrdiff_t pc = -1;
|
||||
ptrdiff_t ep = cfp->ep - th->ec.stack;
|
||||
ptrdiff_t ep = cfp->ep - th->ec.vm_stack;
|
||||
char ep_in_heap = ' ';
|
||||
char posbuf[MAX_POSBUF+1];
|
||||
int line = 0;
|
||||
|
|
@ -39,7 +39,7 @@ control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
|
|||
|
||||
const rb_callable_method_entry_t *me;
|
||||
|
||||
if (ep < 0 || (size_t)ep > th->ec.stack_size) {
|
||||
if (ep < 0 || (size_t)ep > th->ec.vm_stack_size) {
|
||||
ep = (ptrdiff_t)cfp->ep;
|
||||
ep_in_heap = 'p';
|
||||
}
|
||||
|
|
@ -112,14 +112,14 @@ control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
|
|||
}
|
||||
|
||||
fprintf(stderr, "c:%04"PRIdPTRDIFF" ",
|
||||
((rb_control_frame_t *)(th->ec.stack + th->ec.stack_size) - cfp));
|
||||
((rb_control_frame_t *)(th->ec.vm_stack + th->ec.vm_stack_size) - cfp));
|
||||
if (pc == -1) {
|
||||
fprintf(stderr, "p:---- ");
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "p:%04"PRIdPTRDIFF" ", pc);
|
||||
}
|
||||
fprintf(stderr, "s:%04"PRIdPTRDIFF" ", cfp->sp - th->ec.stack);
|
||||
fprintf(stderr, "s:%04"PRIdPTRDIFF" ", cfp->sp - th->ec.vm_stack);
|
||||
fprintf(stderr, ep_in_heap == ' ' ? "e:%06"PRIdPTRDIFF" " : "E:%06"PRIxPTRDIFF" ", ep % 10000);
|
||||
fprintf(stderr, "%-6s", magic);
|
||||
if (line) {
|
||||
|
|
@ -145,12 +145,12 @@ rb_vmdebug_stack_dump_raw(rb_thread_t *th, rb_control_frame_t *cfp)
|
|||
VALUE *p, *st, *t;
|
||||
|
||||
fprintf(stderr, "-- stack frame ------------\n");
|
||||
for (p = st = th->ec.stack; p < sp; p++) {
|
||||
for (p = st = th->ec.vm_stack; p < sp; p++) {
|
||||
fprintf(stderr, "%04ld (%p): %08"PRIxVALUE, (long)(p - st), p, *p);
|
||||
|
||||
t = (VALUE *)*p;
|
||||
if (th->ec.stack <= t && t < sp) {
|
||||
fprintf(stderr, " (= %ld)", (long)((VALUE *)GC_GUARDED_PTR_REF(t) - th->ec.stack));
|
||||
if (th->ec.vm_stack <= t && t < sp) {
|
||||
fprintf(stderr, " (= %ld)", (long)((VALUE *)GC_GUARDED_PTR_REF(t) - th->ec.vm_stack));
|
||||
}
|
||||
|
||||
if (p == ep)
|
||||
|
|
@ -162,7 +162,7 @@ rb_vmdebug_stack_dump_raw(rb_thread_t *th, rb_control_frame_t *cfp)
|
|||
|
||||
fprintf(stderr, "-- Control frame information "
|
||||
"-----------------------------------------------\n");
|
||||
while ((void *)cfp < (void *)(th->ec.stack + th->ec.stack_size)) {
|
||||
while ((void *)cfp < (void *)(th->ec.vm_stack + th->ec.vm_stack_size)) {
|
||||
control_frame_dump(th, cfp);
|
||||
cfp++;
|
||||
}
|
||||
|
|
@ -285,7 +285,7 @@ vm_stack_dump_each(rb_thread_t *th, rb_control_frame_t *cfp)
|
|||
break;
|
||||
}
|
||||
fprintf(stderr, " stack %2d: %8s (%"PRIdPTRDIFF")\n", i, StringValueCStr(rstr),
|
||||
(ptr - th->ec.stack));
|
||||
(ptr - th->ec.vm_stack));
|
||||
}
|
||||
}
|
||||
else if (VM_FRAME_FINISHED_P(cfp)) {
|
||||
|
|
@ -307,20 +307,20 @@ rb_vmdebug_debug_print_register(rb_thread_t *th)
|
|||
{
|
||||
rb_control_frame_t *cfp = th->ec.cfp;
|
||||
ptrdiff_t pc = -1;
|
||||
ptrdiff_t ep = cfp->ep - th->ec.stack;
|
||||
ptrdiff_t ep = cfp->ep - th->ec.vm_stack;
|
||||
ptrdiff_t cfpi;
|
||||
|
||||
if (VM_FRAME_RUBYFRAME_P(cfp)) {
|
||||
pc = cfp->pc - cfp->iseq->body->iseq_encoded;
|
||||
}
|
||||
|
||||
if (ep < 0 || (size_t)ep > th->ec.stack_size) {
|
||||
if (ep < 0 || (size_t)ep > th->ec.vm_stack_size) {
|
||||
ep = -1;
|
||||
}
|
||||
|
||||
cfpi = ((rb_control_frame_t *)(th->ec.stack + th->ec.stack_size)) - cfp;
|
||||
cfpi = ((rb_control_frame_t *)(th->ec.vm_stack + th->ec.vm_stack_size)) - cfp;
|
||||
fprintf(stderr, " [PC] %04"PRIdPTRDIFF", [SP] %04"PRIdPTRDIFF", [EP] %04"PRIdPTRDIFF", [CFP] %04"PRIdPTRDIFF"\n",
|
||||
pc, (cfp->sp - th->ec.stack), ep, cfpi);
|
||||
pc, (cfp->sp - th->ec.vm_stack), ep, cfpi);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -342,7 +342,7 @@ rb_vmdebug_debug_print_pre(rb_thread_t *th, rb_control_frame_t *cfp, const VALUE
|
|||
printf(" ");
|
||||
}
|
||||
printf("| ");
|
||||
if(0)printf("[%03ld] ", (long)(cfp->sp - th->ec.stack));
|
||||
if(0)printf("[%03ld] ", (long)(cfp->sp - th->ec.vm_stack));
|
||||
|
||||
/* printf("%3"PRIdPTRDIFF" ", VM_CFP_CNT(th, cfp)); */
|
||||
if (pc >= 0) {
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@ default: \
|
|||
|
||||
#endif
|
||||
|
||||
#define VM_SP_CNT(th, sp) ((sp) - (th)->ec.stack)
|
||||
#define VM_SP_CNT(th, sp) ((sp) - (th)->ec.vm_stack)
|
||||
|
||||
#if OPT_CALL_THREADED_CODE
|
||||
#define THROW_EXCEPTION(exc) do { \
|
||||
|
|
|
|||
|
|
@ -1516,8 +1516,8 @@ vm_base_ptr(const rb_control_frame_t *cfp)
|
|||
#if VM_DEBUG_BP_CHECK
|
||||
if (bp != cfp->bp_check) {
|
||||
fprintf(stderr, "bp_check: %ld, bp: %ld\n",
|
||||
(long)(cfp->bp_check - GET_THREAD()->ec.stack),
|
||||
(long)(bp - GET_THREAD()->ec.stack));
|
||||
(long)(cfp->bp_check - GET_THREAD()->ec.vm_stack),
|
||||
(long)(bp - GET_THREAD()->ec.vm_stack));
|
||||
rb_bug("vm_base_ptr: unreachable");
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -95,7 +95,7 @@ enum vm_regan_acttype {
|
|||
#define SET_SV(x) (*GET_SP() = (x))
|
||||
/* set current stack value as x */
|
||||
|
||||
#define GET_SP_COUNT() (VM_REG_SP - th->ec.stack)
|
||||
#define GET_SP_COUNT() (VM_REG_SP - th->ec.vm_stack)
|
||||
|
||||
/* instruction sequence C struct */
|
||||
#define GET_ISEQ() (GET_CFP()->iseq)
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue