* vm.c: some refactoring.

* rename th_* to vm_*.
  * remove unused variables functions.
  * add prototypes.
* blockinlining.c, compile.c, cont.c, eval.c, eval_intern.h,
  eval_jump.h, eval_load.c, inits.c, insns.def, iseq.c, parse.y,
  proc.c, process.c, signal.c, thread.c, vm.c, vm_dump.c,
  vm_evalbody.ci, yarvcore.c, yarvcore.h: ditto.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12603 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ko1 2007-06-24 15:42:41 +00:00
parent a5c2d58428
commit 97ba019c94
22 changed files with 262 additions and 311 deletions

View File

@ -1,3 +1,15 @@
Mon Jun 25 00:14:13 2007 Koichi Sasada <ko1@atdot.net>
* vm.c: some refactoring.
* rename th_* to vm_*.
* remove unused variables functions.
* add prototypes.
* blockinlining.c, compile.c, cont.c, eval.c, eval_intern.h,
eval_jump.h, eval_load.c, inits.c, insns.def, iseq.c, parse.y,
proc.c, process.c, signal.c, thread.c, vm.c, vm_dump.c,
vm_evalbody.ci, yarvcore.c, yarvcore.h: ditto.
Sun Jun 24 22:32:00 2007 Koichi Sasada <ko1@atdot.net> Sun Jun 24 22:32:00 2007 Koichi Sasada <ko1@atdot.net>
* eval_method.h (rb_add_method): fix to check 0. * eval_method.h (rb_add_method): fix to check 0.

View File

@ -199,7 +199,7 @@ yarv_invoke_Integer_times_special_block(VALUE num)
th->cfp->lfp[0] = GC_GUARDED_PTR(&block); th->cfp->lfp[0] = GC_GUARDED_PTR(&block);
argv[0] = INT2FIX(0); argv[0] = INT2FIX(0);
argv[1] = num; argv[1] = num;
val = th_yield(th, 2, argv); val = vm_yield(th, 2, argv);
if (val == Qundef) { if (val == Qundef) {
return num; return num;
} }
@ -318,7 +318,7 @@ yarv_invoke_Range_each_special_block(VALUE range,
th->cfp->lfp[0] = GC_GUARDED_PTR(&block); th->cfp->lfp[0] = GC_GUARDED_PTR(&block);
argv[0] = beg; argv[0] = beg;
argv[1] = end; argv[1] = end;
val = th_yield(th, 2, argv); val = vm_yield(th, 2, argv);
if (val == Qundef) { if (val == Qundef) {
return range; return range;
} }
@ -448,7 +448,7 @@ yarv_invoke_Array_each_special_block(VALUE ary)
th->cfp->lfp[0] = GC_GUARDED_PTR(&block); th->cfp->lfp[0] = GC_GUARDED_PTR(&block);
argv[0] = 0; argv[0] = 0;
argv[1] = ary; argv[1] = ary;
val = th_yield(th, 2, argv); val = vm_yield(th, 2, argv);
if (val == Qundef) { if (val == Qundef) {
return ary; return ary;
} }

View File

@ -90,7 +90,6 @@ static void dump_disasm_list(LINK_ELEMENT *elem);
static int insn_data_length(INSN *iobj); static int insn_data_length(INSN *iobj);
static int insn_data_line_no(INSN *iobj); static int insn_data_line_no(INSN *iobj);
static int calc_sp_depth(int depth, INSN *iobj); static int calc_sp_depth(int depth, INSN *iobj);
static int insn_ret_num(int insn);
static void ADD_ELEM(LINK_ANCHOR *anchor, LINK_ELEMENT *elem); static void ADD_ELEM(LINK_ANCHOR *anchor, LINK_ELEMENT *elem);
@ -109,10 +108,7 @@ static int set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor);
static int set_exception_table(rb_iseq_t *iseq); static int set_exception_table(rb_iseq_t *iseq);
static int set_local_table(rb_iseq_t *iseq, ID *tbl); static int set_local_table(rb_iseq_t *iseq, ID *tbl);
static int set_local_table_eval(rb_iseq_t *iseq, ID *tbl);
static int set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *anchor, NODE * node); static int set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *anchor, NODE * node);
static NODE *set_block_local_tbl(rb_iseq_t *iseq, NODE * node,
LINK_ANCHOR *anchor);
static int set_exception_tbl(rb_iseq_t *iseq); static int set_exception_tbl(rb_iseq_t *iseq);
static int set_optargs_table(rb_iseq_t *iseq); static int set_optargs_table(rb_iseq_t *iseq);
@ -218,7 +214,7 @@ rb_iseq_compile(VALUE self, NODE *node)
return iseq_setup(iseq, ret); return iseq_setup(iseq, ret);
} }
VALUE th_eval(void *); VALUE vm_eval(void *);
static int static int
iseq_translate_direct_threaded_code(rb_iseq_t *iseq) iseq_translate_direct_threaded_code(rb_iseq_t *iseq)
@ -226,7 +222,7 @@ iseq_translate_direct_threaded_code(rb_iseq_t *iseq)
#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE #if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE
#if OPT_DIRECT_THREADED_CODE #if OPT_DIRECT_THREADED_CODE
void **table = (void **)th_eval(0); void **table = (void **)vm_eval(0);
#else #else
extern void **insns_address_table(); extern void **insns_address_table();
void **table = get_insns_address_table(); void **table = get_insns_address_table();
@ -353,6 +349,7 @@ INSERT_ELEM_NEXT(LINK_ELEMENT *elem1, LINK_ELEMENT *elem2)
} }
#endif #endif
#if 0 /* unused */
/* /*
* elemX, elem1 => elemX, elem2, elem1 * elemX, elem1 => elemX, elem2, elem1
*/ */
@ -366,6 +363,8 @@ INSERT_ELEM_PREV(LINK_ELEMENT *elem1, LINK_ELEMENT *elem2)
elem2->prev->next = elem2; elem2->prev->next = elem2;
} }
} }
#endif
/*******************************************/ /*******************************************/
/* /*
@ -417,6 +416,7 @@ POP_ELEMENT(LINK_ANCHOR *anchor)
return elem; return elem;
} }
#if 0 /* unused */
static LINK_ELEMENT * static LINK_ELEMENT *
SHIFT_ELEMENT(LINK_ANCHOR *anchor) SHIFT_ELEMENT(LINK_ANCHOR *anchor)
{ {
@ -426,7 +426,9 @@ SHIFT_ELEMENT(LINK_ANCHOR *anchor)
} }
return elem; return elem;
} }
#endif
#if 0 /* unused */
static int static int
LIST_SIZE(LINK_ANCHOR *anchor) LIST_SIZE(LINK_ANCHOR *anchor)
{ {
@ -438,6 +440,7 @@ LIST_SIZE(LINK_ANCHOR *anchor)
} }
return size; return size;
} }
#endif
static int static int
LIST_SIZE_ZERO(LINK_ANCHOR *anchor) LIST_SIZE_ZERO(LINK_ANCHOR *anchor)
@ -779,12 +782,10 @@ set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)
if (node_args) { if (node_args) {
NODE *node_aux = node_args->nd_next; NODE *node_aux = node_args->nd_next;
int mandatory_len = 0;
NODE *node_opt = node_args->nd_opt; NODE *node_opt = node_args->nd_opt;
ID rest_id = 0; ID rest_id = 0;
ID block_id = 0; ID block_id = 0;
NODE *node_init = 0; NODE *node_init = 0;
int d = iseq->local_size - iseq->local_table_size;
if (nd_type(node_args) != NODE_ARGS) { if (nd_type(node_args) != NODE_ARGS) {
rb_bug("set_arguments: NODE_ARGS is expected, but %s", rb_bug("set_arguments: NODE_ARGS is expected, but %s",
@ -934,24 +935,6 @@ set_local_table(rb_iseq_t *iseq, ID *tbl)
return COMPILE_OK; return COMPILE_OK;
} }
static int
set_local_table_eval(rb_iseq_t *iseq, ID *tbl)
{
int size;
if (tbl) {
size = *tbl;
}
else {
size = 0;
}
if (tbl) {
iseq->local_table = (ID *)ALLOC_N(ID *, size);
MEMCPY(iseq->local_table, tbl + 1, ID *, size);
}
iseq->local_table_size = iseq->local_size = size;
return COMPILE_OK;
}
/** /**
ruby insn object array -> raw instruction sequence ruby insn object array -> raw instruction sequence
*/ */
@ -2130,8 +2113,8 @@ defined_expr(rb_iseq_t *iseq, LINK_ANCHOR *ret,
NODE *vals = node; NODE *vals = node;
do { do {
NODE *val = vals->nd_head;
defined_expr(iseq, ret, vals->nd_head, lfinish, Qfalse); defined_expr(iseq, ret, vals->nd_head, lfinish, Qfalse);
if (lfalse) { if (lfalse) {
ADD_INSNL(ret, nd_line(node), branchunless, lfalse); ADD_INSNL(ret, nd_line(node), branchunless, lfalse);
} }
@ -3723,8 +3706,6 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
if (node->nd_head) { if (node->nd_head) {
if (nd_type(node->nd_head) == NODE_ARRAY) { if (nd_type(node->nd_head) == NODE_ARRAY) {
NODE *p;
argc = node->nd_head->nd_alen; argc = node->nd_head->nd_alen;
compile_array(iseq, args, node->nd_head, Qfalse); compile_array(iseq, args, node->nd_head, Qfalse);
POP_ELEMENT(args); POP_ELEMENT(args);

8
cont.c
View File

@ -157,7 +157,7 @@ cont_new(VALUE klass)
return cont; return cont;
} }
void th_stack_to_heap(rb_thread_t *th); void vm_stack_to_heap(rb_thread_t *th);
static VALUE static VALUE
cont_capture(volatile int *stat) cont_capture(volatile int *stat)
@ -166,7 +166,7 @@ cont_capture(volatile int *stat)
rb_thread_t *th; rb_thread_t *th;
volatile VALUE contval; volatile VALUE contval;
th_stack_to_heap(GET_THREAD()); vm_stack_to_heap(GET_THREAD());
cont = cont_new(rb_cCont); cont = cont_new(rb_cCont);
contval = cont->self; contval = cont->self;
th = &cont->saved_thread; th = &cont->saved_thread;
@ -535,12 +535,12 @@ rb_fiber_start(void)
th->local_lfp = proc->block.lfp; th->local_lfp = proc->block.lfp;
th->local_svar = Qnil; th->local_svar = Qnil;
cont->value = th_invoke_proc(th, proc, proc->block.self, 1, &args); cont->value = vm_invoke_proc(th, proc, proc->block.self, 1, &args);
} }
TH_POP_TAG(); TH_POP_TAG();
if (state) { if (state) {
th->thrown_errinfo = th_make_jump_tag_but_local_jump(state, th->errinfo); th->thrown_errinfo = vm_make_jump_tag_but_local_jump(state, th->errinfo);
th->interrupt_flag = 1; th->interrupt_flag = 1;
} }

53
eval.c
View File

@ -57,6 +57,9 @@ char **rb_origenviron;
jmp_buf function_call_may_return_twice_jmp_buf; jmp_buf function_call_may_return_twice_jmp_buf;
int function_call_may_return_twice_false = 0; int function_call_may_return_twice_false = 0;
void rb_clear_trace_func(void);
void rb_thread_stop_timer_thread(void);
void rb_call_inits _((void)); void rb_call_inits _((void));
void Init_stack _((VALUE *)); void Init_stack _((VALUE *));
void Init_heap _((void)); void Init_heap _((void));
@ -155,7 +158,6 @@ ruby_cleanup(int ex)
int state; int state;
volatile VALUE errs[2]; volatile VALUE errs[2];
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_vm_t *vm = th->vm;
int nerr; int nerr;
errs[1] = th->errinfo; errs[1] = th->errinfo;
@ -347,7 +349,7 @@ rb_eval_cmd(VALUE cmd, VALUE arg, int level)
POP_TAG(); POP_TAG();
rb_set_safe_level_force(safe); rb_set_safe_level_force(safe);
if (state) th_jump_tag_but_local_jump(state, val); if (state) vm_jump_tag_but_local_jump(state, val);
return val; return val;
} }
@ -661,12 +663,12 @@ rb_mod_protected_method_defined(VALUE mod, VALUE mid)
return Qfalse; return Qfalse;
} }
NORETURN(void th_iter_break _((rb_thread_t *))); NORETURN(void vm_iter_break _((rb_thread_t *)));
void void
rb_iter_break() rb_iter_break()
{ {
th_iter_break(GET_THREAD()); vm_iter_break(GET_THREAD());
} }
NORETURN(static void rb_longjmp _((int, VALUE))); NORETURN(static void rb_longjmp _((int, VALUE)));
@ -901,7 +903,7 @@ rb_f_block_given_p()
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
cfp = th_get_ruby_level_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)); cfp = vm_get_ruby_level_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
if (GC_GUARDED_PTR_REF(cfp->lfp[0])) { if (GC_GUARDED_PTR_REF(cfp->lfp[0])) {
return Qtrue; return Qtrue;
} }
@ -916,17 +918,16 @@ void
rb_need_block() rb_need_block()
{ {
if (!rb_block_given_p()) { if (!rb_block_given_p()) {
th_localjump_error("no block given", Qnil, 0); vm_localjump_error("no block given", Qnil, 0);
} }
} }
static inline VALUE static inline VALUE
rb_yield_0(int argc, VALUE *argv) rb_yield_0(int argc, VALUE *argv)
{ {
return th_yield(GET_THREAD(), argc, argv); return vm_yield(GET_THREAD(), argc, argv);
} }
VALUE VALUE
rb_yield(VALUE val) rb_yield(VALUE val)
{ {
@ -1429,7 +1430,7 @@ rb_call(VALUE klass, VALUE recv, ID mid, int argc, const VALUE *argv, int scope)
//printf("%s with %d args\n", rb_id2name(mid), argc); //printf("%s with %d args\n", rb_id2name(mid), argc);
*/ */
val = val =
th_call0(GET_THREAD(), klass, recv, mid, id, argc, argv, body, vm_call0(GET_THREAD(), klass, recv, mid, id, argc, argv, body,
noex & NOEX_NOSUPER); noex & NOEX_NOSUPER);
/* /*
//level--; //level--;
@ -1557,7 +1558,7 @@ rb_funcall3(VALUE recv, ID mid, int argc, const VALUE *argv)
static VALUE static VALUE
backtrace(int lev) backtrace(int lev)
{ {
return th_backtrace(GET_THREAD(), lev); return vm_backtrace(GET_THREAD(), lev);
} }
/* /*
@ -1671,7 +1672,7 @@ const char *
rb_sourcefile(void) rb_sourcefile(void)
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp); rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
if (cfp) { if (cfp) {
return RSTRING_PTR(cfp->iseq->filename); return RSTRING_PTR(cfp->iseq->filename);
@ -1685,10 +1686,10 @@ int
rb_sourceline(void) rb_sourceline(void)
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp); rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
if (cfp) { if (cfp) {
return th_get_sourceline(cfp); return vm_get_sourceline(cfp);
} }
else { else {
return 0; return 0;
@ -1733,16 +1734,16 @@ eval(VALUE self, VALUE src, VALUE scope, char *file, int line)
th->base_block = &env->block; th->base_block = &env->block;
} }
else { else {
rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp); rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
th->base_block = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp); th->base_block = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
th->base_block->iseq = cfp->iseq; /* TODO */ th->base_block->iseq = cfp->iseq; /* TODO */
} }
/* make eval iseq */ /* make eval iseq */
th->parse_in_eval++; th->parse_in_eval++;
iseqval = th_compile(th, src, rb_str_new2(file), INT2FIX(line)); iseqval = vm_compile(th, src, rb_str_new2(file), INT2FIX(line));
th->parse_in_eval--; th->parse_in_eval--;
th_set_eval_stack(th, iseqval); vm_set_eval_stack(th, iseqval);
th->base_block = 0; th->base_block = 0;
if (0) { /* for debug */ if (0) { /* for debug */
@ -1753,22 +1754,22 @@ eval(VALUE self, VALUE src, VALUE scope, char *file, int line)
/* save new env */ /* save new env */
GetISeqPtr(iseqval, iseq); GetISeqPtr(iseqval, iseq);
if (bind && iseq->local_size > 0) { if (bind && iseq->local_size > 0) {
bind->env = th_make_env_object(th, th->cfp); bind->env = vm_make_env_object(th, th->cfp);
} }
/* push tag */ /* push tag */
if (stored_cref_stack) { if (stored_cref_stack) {
stored_cref_stack = stored_cref_stack =
th_set_special_cref(th, env->block.lfp, stored_cref_stack); vm_set_special_cref(th, env->block.lfp, stored_cref_stack);
} }
/* kick */ /* kick */
result = th_eval_body(th); result = vm_eval_body(th);
} }
POP_TAG(); POP_TAG();
if (stored_cref_stack) { if (stored_cref_stack) {
th_set_special_cref(th, env->block.lfp, stored_cref_stack); vm_set_special_cref(th, env->block.lfp, stored_cref_stack);
} }
if (state) { if (state) {
@ -1842,7 +1843,7 @@ rb_f_eval(int argc, VALUE *argv, VALUE self)
return eval(self, src, scope, file, line); return eval(self, src, scope, file, line);
} }
VALUE *th_cfp_svar(rb_control_frame_t *cfp, int idx); VALUE *vm_cfp_svar(rb_control_frame_t *cfp, int idx);
/* function to call func under the specified class/module context */ /* function to call func under the specified class/module context */
static VALUE static VALUE
@ -1874,9 +1875,9 @@ exec_under(VALUE (*func) (VALUE), VALUE under, VALUE self, VALUE args)
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
} }
pcref = (NODE **) th_cfp_svar(cfp, -1); pcref = (NODE **) vm_cfp_svar(cfp, -1);
stored_cref = *pcref; stored_cref = *pcref;
*pcref = th_cref_push(th, under, NOEX_PUBLIC); *pcref = vm_cref_push(th, under, NOEX_PUBLIC);
PUSH_TAG(); PUSH_TAG();
if ((state = EXEC_TAG()) == 0) { if ((state = EXEC_TAG()) == 0) {
@ -2590,7 +2591,7 @@ errat_setter(VALUE val, ID id, VALUE *var)
* local_variables #=> ["fred", "i"] * local_variables #=> ["fred", "i"]
*/ */
int th_collect_local_variables_in_heap(rb_thread_t *th, VALUE *dfp, VALUE ary); int vm_collect_local_variables_in_heap(rb_thread_t *th, VALUE *dfp, VALUE ary);
static VALUE static VALUE
rb_f_local_variables(void) rb_f_local_variables(void)
@ -2598,7 +2599,7 @@ rb_f_local_variables(void)
VALUE ary = rb_ary_new(); VALUE ary = rb_ary_new();
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = rb_control_frame_t *cfp =
th_get_ruby_level_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp)); vm_get_ruby_level_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp));
int i; int i;
while (1) { while (1) {
@ -2618,7 +2619,7 @@ rb_f_local_variables(void)
/* block */ /* block */
VALUE *dfp = GC_GUARDED_PTR_REF(cfp->dfp[0]); VALUE *dfp = GC_GUARDED_PTR_REF(cfp->dfp[0]);
if (th_collect_local_variables_in_heap(th, dfp, ary)) { if (vm_collect_local_variables_in_heap(th, dfp, ary)) {
break; break;
} }
else { else {

View File

@ -196,18 +196,18 @@ NORETURN(void rb_fiber_start(void));
NORETURN(void rb_raise_jump _((VALUE))); NORETURN(void rb_raise_jump _((VALUE)));
NORETURN(void print_undef _((VALUE, ID))); NORETURN(void print_undef _((VALUE, ID)));
NORETURN(void th_localjump_error(const char *, VALUE, int)); NORETURN(void vm_localjump_error(const char *, VALUE, int));
NORETURN(void th_jump_tag_but_local_jump(int, VALUE)); NORETURN(void vm_jump_tag_but_local_jump(int, VALUE));
VALUE th_compile(rb_thread_t *th, VALUE str, VALUE file, VALUE line); VALUE vm_compile(rb_thread_t *th, VALUE str, VALUE file, VALUE line);
NODE *th_get_cref(rb_thread_t *th, rb_iseq_t *iseq, rb_control_frame_t *cfp); NODE *vm_get_cref(rb_thread_t *th, rb_iseq_t *iseq, rb_control_frame_t *cfp);
NODE *th_cref_push(rb_thread_t *th, VALUE, int); NODE *vm_cref_push(rb_thread_t *th, VALUE, int);
NODE *th_set_special_cref(rb_thread_t *th, VALUE *lfp, NODE * cref_stack); NODE *vm_set_special_cref(rb_thread_t *th, VALUE *lfp, NODE * cref_stack);
VALUE th_make_jump_tag_but_local_jump(int state, VALUE val); VALUE vm_make_jump_tag_but_local_jump(int state, VALUE val);
static rb_control_frame_t * static rb_control_frame_t *
th_get_ruby_level_cfp(rb_thread_t *th, rb_control_frame_t *cfp) vm_get_ruby_level_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
{ {
while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) { while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) {
if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) { if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
@ -222,17 +222,17 @@ static inline NODE *
ruby_cref() ruby_cref()
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp); rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
return th_get_cref(th, cfp->iseq, cfp); return vm_get_cref(th, cfp->iseq, cfp);
} }
VALUE th_get_cbase(rb_thread_t *th); VALUE vm_get_cbase(rb_thread_t *th);
VALUE rb_obj_is_proc(VALUE); VALUE rb_obj_is_proc(VALUE);
void rb_vm_check_redefinition_opt_method(NODE *node); void rb_vm_check_redefinition_opt_method(NODE *node);
VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, rb_block_t *blockptr, VALUE filename); VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, rb_block_t *blockptr, VALUE filename);
void rb_thread_terminate_all(void); void rb_thread_terminate_all(void);
#define ruby_cbase() th_get_cbase(GET_THREAD()) #define ruby_cbase() vm_get_cbase(GET_THREAD())
/* tracer */ /* tracer */

View File

@ -138,7 +138,6 @@ static VALUE
terminate_process(int status, const char *mesg, long mlen) terminate_process(int status, const char *mesg, long mlen)
{ {
VALUE args[2]; VALUE args[2];
rb_vm_t *vm = GET_THREAD()->vm;
args[0] = INT2NUM(status); args[0] = INT2NUM(status);
args[1] = rb_str_new(mesg, mlen); args[1] = rb_str_new(mesg, mlen);

View File

@ -202,7 +202,7 @@ rb_load(VALUE fname, int wrap)
rb_exc_raise(GET_THREAD()->errinfo); rb_exc_raise(GET_THREAD()->errinfo);
} }
if (state) { if (state) {
th_jump_tag_but_local_jump(state, Qundef); vm_jump_tag_but_local_jump(state, Qundef);
} }
if (!NIL_P(GET_THREAD()->errinfo)) { if (!NIL_P(GET_THREAD()->errinfo)) {

View File

@ -48,6 +48,7 @@ void Init_version(void);
void Init_ISeq(void); void Init_ISeq(void);
void Init_VM(void); void Init_VM(void);
void Init_Thread(void); void Init_Thread(void);
void Init_Cont(void);
void void
rb_call_inits() rb_call_inits()

View File

@ -215,7 +215,7 @@ getclassvariable
() ()
(VALUE val) (VALUE val)
{ {
VALUE klass = eval_get_cvar_base(th, GET_ISEQ()); VALUE klass = vm_get_cvar_base(th, GET_ISEQ());
val = rb_cvar_get(klass, id); val = rb_cvar_get(klass, id);
} }
@ -230,7 +230,7 @@ setclassvariable
(VALUE val) (VALUE val)
() ()
{ {
rb_cvar_set(eval_get_cvar_base(th, GET_ISEQ()), id, val); rb_cvar_set(vm_get_cvar_base(th, GET_ISEQ()), id, val);
} }
/** /**
@ -251,7 +251,7 @@ getconstant
(VALUE klass) (VALUE klass)
(VALUE val) (VALUE val)
{ {
val = eval_get_ev_const(th, GET_ISEQ(), klass, id, 0); val = vm_get_ev_const(th, GET_ISEQ(), klass, id, 0);
} }
/** /**
@ -275,7 +275,7 @@ setconstant
() ()
{ {
if (klass == Qnil) { if (klass == Qnil) {
klass = th_get_cbase(th); klass = vm_get_cbase(th);
} }
if (NIL_P(klass)) { if (NIL_P(klass)) {
rb_raise(rb_eTypeError, "no class/module to define constant"); rb_raise(rb_eTypeError, "no class/module to define constant");
@ -448,7 +448,7 @@ toregexp
(VALUE str) (VALUE str)
(VALUE val) (VALUE val)
{ {
volatile VALUE tmp = str; volatile VALUE tmp = str; /* for GC */
val = rb_reg_new(RSTRING_PTR(str), RSTRING_LEN(str), flag); val = rb_reg_new(RSTRING_PTR(str), RSTRING_LEN(str), flag);
} }
@ -842,8 +842,8 @@ definemethod
(VALUE obj) (VALUE obj)
() ()
{ {
eval_define_method(th, obj, id, body, is_singleton, vm_define_method(th, obj, id, body, is_singleton,
get_cref(GET_ISEQ(), GET_LFP())); get_cref(GET_ISEQ(), GET_LFP()));
} }
/** /**
@ -923,7 +923,7 @@ defined
break; break;
case DEFINED_CONST: case DEFINED_CONST:
klass = v; klass = v;
if (eval_get_ev_const(th, GET_ISEQ(), klass, SYM2ID(obj), 1)) { if (vm_get_ev_const(th, GET_ISEQ(), klass, SYM2ID(obj), 1)) {
expr_type = "constant"; expr_type = "constant";
} }
break; break;
@ -1011,7 +1011,7 @@ postexe
blockptr->iseq = blockiseq; blockptr->iseq = blockiseq;
blockptr->proc = 0; blockptr->proc = 0;
proc = th_make_proc(th, GET_CFP(), blockptr); proc = vm_make_proc(th, GET_CFP(), blockptr);
rb_set_end_proc(call_yarv_end_proc, proc); rb_set_end_proc(call_yarv_end_proc, proc);
} }
@ -1059,7 +1059,7 @@ defineclass
} }
if (cbase == Qnil) { if (cbase == Qnil) {
cbase = th_get_cbase(th); cbase = vm_get_cbase(th);
} }
/* find klass */ /* find klass */
@ -1097,7 +1097,7 @@ defineclass
/* val is dummy. classdef returns class scope value */ /* val is dummy. classdef returns class scope value */
/* super is dummy */ /* super is dummy */
if (cbase == Qnil) { if (cbase == Qnil) {
cbase = th_get_cbase(th); cbase = vm_get_cbase(th);
} }
/* find klass */ /* find klass */
@ -1119,13 +1119,13 @@ defineclass
rb_bug("unknown defineclass type: %d", define_type); rb_bug("unknown defineclass type: %d", define_type);
} }
COPY_CREF(klass_iseq->cref_stack, th_cref_push(th, klass, NOEX_PUBLIC)); COPY_CREF(klass_iseq->cref_stack, vm_cref_push(th, klass, NOEX_PUBLIC));
/* enter scope */ /* enter scope */
push_frame(th, klass_iseq, vm_push_frame(th, klass_iseq,
FRAME_MAGIC_CLASS, klass, (VALUE) GET_DFP() | 0x02, FRAME_MAGIC_CLASS, klass, (VALUE) GET_DFP() | 0x02,
klass_iseq->iseq_encoded, GET_SP(), 0, klass_iseq->iseq_encoded, GET_SP(), 0,
klass_iseq->local_size); klass_iseq->local_size);
RESTORE_REGS(); RESTORE_REGS();
INC_VM_STATE_VERSION(); INC_VM_STATE_VERSION();
@ -1153,7 +1153,7 @@ send
(VALUE val) // inc += - (op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0)); (VALUE val) // inc += - (op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));
{ {
NODE *mn; NODE *mn;
VALUE recv, klass, v; VALUE recv, klass;
rb_block_t *blockptr = 0; rb_block_t *blockptr = 0;
rb_num_t num = caller_setup_args(th, GET_CFP(), op_flag, op_argc, blockiseq, &blockptr); rb_num_t num = caller_setup_args(th, GET_CFP(), op_flag, op_argc, blockiseq, &blockptr);
rb_num_t flag = op_flag; rb_num_t flag = op_flag;
@ -1171,7 +1171,7 @@ send
klass = CLASS_OF(recv); klass = CLASS_OF(recv);
mn = eval_method_search(id, klass, ic); mn = vm_method_search(id, klass, ic);
/* send/funcall optimization */ /* send/funcall optimization */
if ((flag & VM_CALL_SEND_BIT) && mn && nd_type(mn->nd_body) == NODE_CFUNC) { if ((flag & VM_CALL_SEND_BIT) && mn && nd_type(mn->nd_body) == NODE_CFUNC) {
@ -1287,7 +1287,7 @@ invokeblock
int argc = num; int argc = num;
if (GET_ISEQ()->local_iseq->type != ISEQ_TYPE_METHOD || block == 0) { if (GET_ISEQ()->local_iseq->type != ISEQ_TYPE_METHOD || block == 0) {
th_localjump_error("no block given (yield)", Qnil, 0); vm_localjump_error("no block given (yield)", Qnil, 0);
} }
iseq = block->iseq; iseq = block->iseq;
@ -1297,14 +1297,14 @@ invokeblock
DEC_SP(argc); DEC_SP(argc);
argc = th_yield_setup_args(th, iseq, argc, GET_SP(), argc = vm_yield_setup_args(th, iseq, argc, GET_SP(),
block_proc_is_lambda(block->proc)); block_proc_is_lambda(block->proc));
INC_SP(argc); INC_SP(argc);
push_frame(th, iseq, vm_push_frame(th, iseq,
FRAME_MAGIC_BLOCK, block->self, (VALUE) block->dfp, FRAME_MAGIC_BLOCK, block->self, (VALUE) block->dfp,
iseq->iseq_encoded, GET_SP(), block->lfp, iseq->iseq_encoded, GET_SP(), block->lfp,
iseq->local_size - argc); iseq->local_size - argc);
reg_cfp->sp -= argc; reg_cfp->sp -= argc;
RESTORE_REGS(); RESTORE_REGS();
@ -1312,7 +1312,7 @@ invokeblock
/* unreachable */ /* unreachable */
} }
else { else {
val = th_yield_with_cfunc(th, block, block->self, val = vm_yield_with_cfunc(th, block, block->self,
num, STACK_ADDR_FROM_TOP(num)); num, STACK_ADDR_FROM_TOP(num));
POPN(num); POPN(num);
} }
@ -1337,7 +1337,7 @@ leave
} }
RUBY_VM_CHECK_INTS(); RUBY_VM_CHECK_INTS();
pop_frame(th); vm_pop_frame(th);
RESTORE_REGS(); RESTORE_REGS();
} }
@ -1416,7 +1416,7 @@ throw
cfp++; cfp++;
} }
if (is_orphan) { if (is_orphan) {
th_localjump_error("unexpected return", throwobj, vm_localjump_error("unexpected return", throwobj,
TAG_RETURN); TAG_RETURN);
} }

2
iseq.c
View File

@ -719,7 +719,7 @@ ruby_iseq_disasm(VALUE self)
VALUE str = rb_str_new(0, 0); VALUE str = rb_str_new(0, 0);
VALUE child = rb_ary_new(); VALUE child = rb_ary_new();
unsigned long size; unsigned long size;
int i, d = iseqdat->local_size - iseqdat->local_table_size; int i;
ID *tbl; ID *tbl;
char buff[0x200]; char buff[0x200];

28
parse.y
View File

@ -7946,22 +7946,6 @@ arg_blk_pass(NODE *node1, NODE *node2)
return node1; return node1;
} }
static int
arg_dup_check(ID vid, VALUE m, VALUE list, NODE *node)
{
VALUE sym;
if (!vid) return 0;
if (is_junk_id(vid)) return 0;
sym = ID2SYM(vid);
if ((m && rb_ary_includes(m, sym)) || rb_ary_includes(list, sym)) {
ruby_sourceline = nd_line(node);
return 1;
}
rb_ary_push(list, sym);
return 0;
}
static NODE* static NODE*
new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b) new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b)
{ {
@ -8024,18 +8008,6 @@ vtable_tblcpy(ID *buf, const struct vtable *src)
return 0; return 0;
} }
static ID*
vtable_to_tbl(const struct vtable *src)
{
int cnt = vtable_size(src);
ID *buf;
if (cnt <= 0) return 0;
buf = ALLOC_N(ID, cnt + 1);
vtable_tblcpy(buf+1, src);
return buf;
}
static ID* static ID*
local_tbl_gen(struct parser_params *parser) local_tbl_gen(struct parser_params *parser)
{ {

14
proc.c
View File

@ -182,12 +182,12 @@ VALUE
rb_binding_new(void) rb_binding_new(void)
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp); rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
VALUE bindval = binding_alloc(rb_cBinding); VALUE bindval = binding_alloc(rb_cBinding);
rb_binding_t *bind; rb_binding_t *bind;
GetBindingPtr(bindval, bind); GetBindingPtr(bindval, bind);
bind->env = th_make_env_object(th, cfp); bind->env = vm_make_env_object(th, cfp);
bind->cref_stack = ruby_cref(); bind->cref_stack = ruby_cref();
return bindval; return bindval;
} }
@ -284,7 +284,7 @@ proc_new(VALUE klass, int is_lambda)
} }
} }
procval = th_make_proc(th, cfp, block); procval = vm_make_proc(th, cfp, block);
if (is_lambda) { if (is_lambda) {
rb_proc_t *proc; rb_proc_t *proc;
@ -364,7 +364,7 @@ proc_invoke(VALUE self, VALUE args, VALUE alt_self, VALUE alt_klass)
GetProcPtr(self, proc); GetProcPtr(self, proc);
/* ignore self and klass */ /* ignore self and klass */
return th_invoke_proc(GET_THREAD(), proc, proc->block.self, return vm_invoke_proc(GET_THREAD(), proc, proc->block.self,
RARRAY_LEN(args), RARRAY_PTR(args)); RARRAY_LEN(args), RARRAY_PTR(args));
} }
@ -408,7 +408,7 @@ proc_call(int argc, VALUE *argv, VALUE procval)
rb_proc_t *proc; rb_proc_t *proc;
GetProcPtr(procval, proc); GetProcPtr(procval, proc);
return th_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv); return vm_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv);
} }
static VALUE static VALUE
@ -416,7 +416,7 @@ proc_yield(int argc, VALUE *argv, VALUE procval)
{ {
rb_proc_t *proc; rb_proc_t *proc;
GetProcPtr(procval, proc); GetProcPtr(procval, proc);
return th_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv); return vm_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv);
} }
VALUE VALUE
@ -1034,7 +1034,7 @@ rb_method_call(int argc, VALUE *argv, VALUE method)
} }
if ((state = EXEC_TAG()) == 0) { if ((state = EXEC_TAG()) == 0) {
PASS_PASSED_BLOCK(); PASS_PASSED_BLOCK();
result = th_call0(GET_THREAD(), result = vm_call0(GET_THREAD(),
data->klass, data->recv, data->id, data->oid, data->klass, data->recv, data->id, data->oid,
argc, argv, data->body, 0); argc, argv, data->body, 0);
} }

View File

@ -937,6 +937,8 @@ char *strtok();
#endif #endif
void rb_thread_stop_timer_thread(void); void rb_thread_stop_timer_thread(void);
void rb_thread_start_timer_thread(void);
void rb_thread_reset_timer_thread(void);
#define before_exec() \ #define before_exec() \
(rb_enable_interrupt(), rb_thread_stop_timer_thread()) (rb_enable_interrupt(), rb_thread_stop_timer_thread())

View File

@ -551,7 +551,7 @@ signal_exec(VALUE cmd, int sig)
rb_proc_t *proc; rb_proc_t *proc;
VALUE signum = INT2FIX(sig); VALUE signum = INT2FIX(sig);
GetProcPtr(cmd, proc); GetProcPtr(cmd, proc);
th_invoke_proc(GET_THREAD(), proc, proc->block.self, 1, &signum); vm_invoke_proc(GET_THREAD(), proc, proc->block.self, 1, &signum);
} }
void void

View File

@ -81,7 +81,6 @@ st_delete_wrap(st_table * table, VALUE key)
#define THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION #define THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION
static rb_unblock_function_t* set_unblock_function(rb_thread_t *th, rb_unblock_function_t *func); static rb_unblock_function_t* set_unblock_function(rb_thread_t *th, rb_unblock_function_t *func);
static void clear_unblock_function(rb_thread_t *th);
NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p)); NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
NOINLINE(void rb_gc_save_machine_context(rb_thread_t *)); NOINLINE(void rb_gc_save_machine_context(rb_thread_t *));
@ -210,14 +209,6 @@ set_unblock_function(rb_thread_t *th, rb_unblock_function_t *func)
return oldfunc; return oldfunc;
} }
static void
clear_unblock_function(rb_thread_t *th)
{
native_mutex_lock(&th->interrupt_lock);
th->unblock_function = 0;
native_mutex_unlock(&th->interrupt_lock);
}
static void static void
rb_thread_interrupt(rb_thread_t *th) rb_thread_interrupt(rb_thread_t *th)
{ {
@ -314,7 +305,7 @@ thread_start_func_2(rb_thread_t *th, VALUE *stack_start
th->errinfo = Qnil; th->errinfo = Qnil;
th->local_lfp = proc->block.lfp; th->local_lfp = proc->block.lfp;
th->local_svar = Qnil; th->local_svar = Qnil;
th->value = th_invoke_proc(th, proc, proc->block.self, th->value = vm_invoke_proc(th, proc, proc->block.self,
RARRAY_LEN(args), RARRAY_PTR(args)); RARRAY_LEN(args), RARRAY_PTR(args));
} }
else { else {
@ -393,8 +384,6 @@ rb_thread_create(VALUE (*fn)(ANYARGS), void *arg)
/* +infty, for this purpose */ /* +infty, for this purpose */
#define DELAY_INFTY 1E30 #define DELAY_INFTY 1E30
VALUE th_make_jump_tag_but_local_jump(int state, VALUE val);
static VALUE static VALUE
thread_join(rb_thread_t *target_th, double delay) thread_join(rb_thread_t *target_th, double delay)
{ {
@ -435,7 +424,7 @@ thread_join(rb_thread_t *target_th, double delay)
/* */ /* */
} }
else if (TYPE(target_th->errinfo) == T_NODE) { else if (TYPE(target_th->errinfo) == T_NODE) {
rb_exc_raise(th_make_jump_tag_but_local_jump( rb_exc_raise(vm_make_jump_tag_but_local_jump(
GET_THROWOBJ_STATE(err), GET_THROWOBJ_VAL(err))); GET_THROWOBJ_STATE(err), GET_THROWOBJ_VAL(err)));
} }
else { else {
@ -2716,7 +2705,6 @@ static void call_trace_func(rb_event_flag_t, VALUE data, VALUE self, ID id, VALU
static VALUE static VALUE
set_trace_func(VALUE obj, VALUE trace) set_trace_func(VALUE obj, VALUE trace)
{ {
rb_vm_t *vm = GET_VM();
rb_remove_event_hook(call_trace_func); rb_remove_event_hook(call_trace_func);
if (NIL_P(trace)) { if (NIL_P(trace)) {

View File

@ -1,7 +1,7 @@
#define RUBY_VERSION "1.9.0" #define RUBY_VERSION "1.9.0"
#define RUBY_RELEASE_DATE "2007-06-24" #define RUBY_RELEASE_DATE "2007-06-25"
#define RUBY_VERSION_CODE 190 #define RUBY_VERSION_CODE 190
#define RUBY_RELEASE_CODE 20070624 #define RUBY_RELEASE_CODE 20070625
#define RUBY_PATCHLEVEL 0 #define RUBY_PATCHLEVEL 0
#define RUBY_VERSION_MAJOR 1 #define RUBY_VERSION_MAJOR 1
@ -9,7 +9,7 @@
#define RUBY_VERSION_TEENY 0 #define RUBY_VERSION_TEENY 0
#define RUBY_RELEASE_YEAR 2007 #define RUBY_RELEASE_YEAR 2007
#define RUBY_RELEASE_MONTH 6 #define RUBY_RELEASE_MONTH 6
#define RUBY_RELEASE_DAY 24 #define RUBY_RELEASE_DAY 25
#ifdef RUBY_EXTERN #ifdef RUBY_EXTERN
RUBY_EXTERN const char ruby_version[]; RUBY_EXTERN const char ruby_version[];

257
vm.c
View File

@ -12,7 +12,6 @@
#include "ruby/ruby.h" #include "ruby/ruby.h"
#include "ruby/node.h" #include "ruby/node.h"
#include "ruby/st.h" #include "ruby/st.h"
// #define MARK_FREE_DEBUG 1
#include "gc.h" #include "gc.h"
#include "yarvcore.h" #include "yarvcore.h"
@ -40,14 +39,11 @@ void vm_analysis_operand(int insn, int n, VALUE op);
void vm_analysis_register(int reg, int isset); void vm_analysis_register(int reg, int isset);
void vm_analysis_insn(int insn); void vm_analysis_insn(int insn);
static inline VALUE VALUE vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc,
th_yield_cfunc(rb_thread_t *th, rb_block_t *block,
VALUE self, int argc, VALUE *argv);
VALUE th_invoke_proc(rb_thread_t *th, rb_proc_t *proc,
VALUE self, int argc, VALUE *argv); VALUE self, int argc, VALUE *argv);
VALUE th_eval_body(rb_thread_t *th); VALUE vm_eval_body(rb_thread_t *th);
static NODE *lfp_get_special_cref(VALUE *lfp); static NODE *lfp_get_special_cref(VALUE *lfp);
static NODE *lfp_set_special_cref(VALUE *lfp, NODE * cref); static NODE *lfp_set_special_cref(VALUE *lfp, NODE * cref);
@ -75,9 +71,9 @@ rb_vm_change_state(void)
* prepare stack frame * prepare stack frame
*/ */
static inline rb_control_frame_t * static inline rb_control_frame_t *
push_frame(rb_thread_t *th, rb_iseq_t *iseq, VALUE magic, vm_push_frame(rb_thread_t *th, rb_iseq_t *iseq, VALUE magic,
VALUE self, VALUE specval, VALUE *pc, VALUE self, VALUE specval, VALUE *pc,
VALUE *sp, VALUE *lfp, int local_size) VALUE *sp, VALUE *lfp, int local_size)
{ {
VALUE *dfp; VALUE *dfp;
rb_control_frame_t *cfp; rb_control_frame_t *cfp;
@ -118,7 +114,7 @@ push_frame(rb_thread_t *th, rb_iseq_t *iseq, VALUE magic,
} }
static inline void static inline void
pop_frame(rb_thread_t *th) vm_pop_frame(rb_thread_t *th)
{ {
#if COLLECT_PROFILE #if COLLECT_PROFILE
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
@ -141,17 +137,17 @@ pop_frame(rb_thread_t *th)
} }
VALUE VALUE
th_set_finish_env(rb_thread_t *th) vm_set_finish_env(rb_thread_t *th)
{ {
push_frame(th, 0, FRAME_MAGIC_FINISH, vm_push_frame(th, 0, FRAME_MAGIC_FINISH,
Qnil, th->cfp->lfp[0], 0, Qnil, th->cfp->lfp[0], 0,
th->cfp->sp, 0, 1); th->cfp->sp, 0, 1);
th->cfp->pc = &yarv_finish_insn_seq[0]; th->cfp->pc = &yarv_finish_insn_seq[0];
return Qtrue; return Qtrue;
} }
void void
th_set_top_stack(rb_thread_t *th, VALUE iseqval) vm_set_top_stack(rb_thread_t *th, VALUE iseqval)
{ {
rb_iseq_t *iseq; rb_iseq_t *iseq;
GetISeqPtr(iseqval, iseq); GetISeqPtr(iseqval, iseq);
@ -161,32 +157,32 @@ th_set_top_stack(rb_thread_t *th, VALUE iseqval)
} }
/* for return */ /* for return */
th_set_finish_env(th); vm_set_finish_env(th);
push_frame(th, iseq, FRAME_MAGIC_TOP, vm_push_frame(th, iseq, FRAME_MAGIC_TOP,
th->top_self, 0, iseq->iseq_encoded, th->top_self, 0, iseq->iseq_encoded,
th->cfp->sp, 0, iseq->local_size); th->cfp->sp, 0, iseq->local_size);
} }
VALUE VALUE
th_set_eval_stack(rb_thread_t *th, VALUE iseqval) vm_set_eval_stack(rb_thread_t *th, VALUE iseqval)
{ {
rb_iseq_t *iseq; rb_iseq_t *iseq;
rb_block_t *block = th->base_block; rb_block_t *block = th->base_block;
GetISeqPtr(iseqval, iseq); GetISeqPtr(iseqval, iseq);
/* for return */ /* for return */
th_set_finish_env(th); vm_set_finish_env(th);
push_frame(th, iseq, FRAME_MAGIC_EVAL, block->self, vm_push_frame(th, iseq, FRAME_MAGIC_EVAL, block->self,
GC_GUARDED_PTR(block->dfp), iseq->iseq_encoded, GC_GUARDED_PTR(block->dfp), iseq->iseq_encoded,
th->cfp->sp, block->lfp, iseq->local_size); th->cfp->sp, block->lfp, iseq->local_size);
return 0; return 0;
} }
/* return opt_pc */ /* return opt_pc */
static inline int static inline int
callee_setup_arg(rb_thread_t *th, rb_iseq_t *iseq, vm_callee_setup_arg(rb_thread_t *th, rb_iseq_t *iseq,
int argc, VALUE *argv, rb_block_t **block) int argc, VALUE *argv, rb_block_t **block)
{ {
const int m = iseq->argc; const int m = iseq->argc;
const int orig_argc = argc; const int orig_argc = argc;
@ -263,7 +259,7 @@ callee_setup_arg(rb_thread_t *th, rb_iseq_t *iseq,
rb_proc_t *proc; rb_proc_t *proc;
th->mark_stack_len = orig_argc; /* for GC */ th->mark_stack_len = orig_argc; /* for GC */
blockval = th_make_proc(th, th->cfp, blockptr); blockval = vm_make_proc(th, th->cfp, blockptr);
th->mark_stack_len = 0; th->mark_stack_len = 0;
GetProcPtr(blockval, proc); GetProcPtr(blockval, proc);
@ -318,7 +314,7 @@ caller_setup_args(rb_thread_t *th, rb_control_frame_t *cfp,
/* expand top of stack? */ /* expand top of stack? */
if (flag & VM_CALL_ARGS_SPLAT_BIT) { if (flag & VM_CALL_ARGS_SPLAT_BIT) {
VALUE ary = *(cfp->sp - 1); VALUE ary = *(cfp->sp - 1);
VALUE *ptr, *dst; VALUE *ptr;
int i; int i;
VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_splat"); VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_splat");
@ -351,8 +347,8 @@ vm_call_cfunc(rb_thread_t *th, rb_control_frame_t *reg_cfp, int num,
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, id, klass); EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, id, klass);
{ {
rb_control_frame_t *cfp = rb_control_frame_t *cfp =
push_frame(th, 0, FRAME_MAGIC_CFUNC, vm_push_frame(th, 0, FRAME_MAGIC_CFUNC,
recv, (VALUE) blockptr, 0, reg_cfp->sp, 0, 1); recv, (VALUE) blockptr, 0, reg_cfp->sp, 0, 1);
cfp->method_id = id; cfp->method_id = id;
cfp->method_klass = klass; cfp->method_klass = klass;
@ -364,7 +360,7 @@ vm_call_cfunc(rb_thread_t *th, rb_control_frame_t *reg_cfp, int num,
if (reg_cfp != th->cfp + 1) { if (reg_cfp != th->cfp + 1) {
rb_bug("cfp consistency error - send"); rb_bug("cfp consistency error - send");
} }
pop_frame(th); vm_pop_frame(th);
} }
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, id, klass); EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, id, klass);
@ -384,7 +380,7 @@ vm_call_bmethod(rb_thread_t *th, ID id, VALUE procval, VALUE recv,
(cfp-2)->method_klass = klass; (cfp-2)->method_klass = klass;
GetProcPtr(procval, proc); GetProcPtr(procval, proc);
val = th_invoke_proc(th, proc, recv, argc, argv); val = vm_invoke_proc(th, proc, recv, argc, argv);
return val; return val;
} }
@ -416,14 +412,14 @@ vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp,
/* TODO: eliminate it */ /* TODO: eliminate it */
GetISeqPtr(iseqval, iseq); GetISeqPtr(iseqval, iseq);
opt_pc = callee_setup_arg(th, iseq, argc, rsp, &blockptr); opt_pc = vm_callee_setup_arg(th, iseq, argc, rsp, &blockptr);
sp = rsp + iseq->arg_size; sp = rsp + iseq->arg_size;
/* stack overflow check */ /* stack overflow check */
CHECK_STACK_OVERFLOW(cfp, iseq->stack_max + 0x10); CHECK_STACK_OVERFLOW(cfp, iseq->stack_max + 0x10);
if (flag & VM_CALL_TAILCALL_BIT) { if (flag & VM_CALL_TAILCALL_BIT) {
VALUE *p_rsp, *p_sp; VALUE *p_rsp;
cfp = ++th->cfp; /* pop cf */ cfp = ++th->cfp; /* pop cf */
p_rsp = th->cfp->sp; p_rsp = th->cfp->sp;
@ -439,9 +435,9 @@ vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp,
*sp++ = Qnil; *sp++ = Qnil;
} }
push_frame(th, iseq, vm_push_frame(th, iseq,
FRAME_MAGIC_METHOD, recv, (VALUE) blockptr, FRAME_MAGIC_METHOD, recv, (VALUE) blockptr,
iseq->iseq_encoded + opt_pc, sp, 0, 0); iseq->iseq_encoded + opt_pc, sp, 0, 0);
} }
else { else {
if (0) printf("local_size: %d, arg_size: %d\n", if (0) printf("local_size: %d, arg_size: %d\n",
@ -452,9 +448,9 @@ vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp,
*sp++ = Qnil; *sp++ = Qnil;
} }
push_frame(th, iseq, vm_push_frame(th, iseq,
FRAME_MAGIC_METHOD, recv, (VALUE) blockptr, FRAME_MAGIC_METHOD, recv, (VALUE) blockptr,
iseq->iseq_encoded + opt_pc, sp, 0, 0); iseq->iseq_encoded + opt_pc, sp, 0, 0);
cfp->sp = rsp - 1 /* recv */; cfp->sp = rsp - 1 /* recv */;
} }
@ -623,7 +619,7 @@ env_alloc(void)
static int check_env(rb_env_t *env); static int check_env(rb_env_t *env);
static VALUE static VALUE
th_make_env_each(rb_thread_t *th, rb_control_frame_t *cfp, vm_make_env_each(rb_thread_t *th, rb_control_frame_t *cfp,
VALUE *envptr, VALUE *endptr) VALUE *envptr, VALUE *endptr)
{ {
VALUE envval, penvval = 0; VALUE envval, penvval = 0;
@ -651,7 +647,7 @@ th_make_env_each(rb_thread_t *th, rb_control_frame_t *cfp,
exit(0); exit(0);
} }
} }
penvval = th_make_env_each(th, pcfp, penvptr, endptr); penvval = vm_make_env_each(th, pcfp, penvptr, endptr);
cfp->lfp = pcfp->lfp; cfp->lfp = pcfp->lfp;
*envptr = GC_GUARDED_PTR(pcfp->dfp); *envptr = GC_GUARDED_PTR(pcfp->dfp);
} }
@ -771,7 +767,7 @@ collect_local_variables_in_env(rb_env_t *env, VALUE ary)
} }
int int
th_collect_local_variables_in_heap(rb_thread_t *th, VALUE *dfp, VALUE ary) vm_collect_local_variables_in_heap(rb_thread_t *th, VALUE *dfp, VALUE ary)
{ {
if (ENV_IN_HEAP_P(dfp)) { if (ENV_IN_HEAP_P(dfp)) {
rb_env_t *env; rb_env_t *env;
@ -785,11 +781,11 @@ th_collect_local_variables_in_heap(rb_thread_t *th, VALUE *dfp, VALUE ary)
} }
VALUE VALUE
th_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp) vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp)
{ {
VALUE envval; VALUE envval;
// SDR2(cfp); // SDR2(cfp);
envval = th_make_env_each(th, cfp, cfp->dfp, cfp->lfp); envval = vm_make_env_each(th, cfp, cfp->dfp, cfp->lfp);
if (PROCDEBUG) { if (PROCDEBUG) {
check_env_value(envval); check_env_value(envval);
} }
@ -797,17 +793,17 @@ th_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp)
} }
void void
th_stack_to_heap(rb_thread_t *th) vm_stack_to_heap(rb_thread_t *th)
{ {
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
while ((cfp = th_get_ruby_level_cfp(th, cfp)) != 0) { while ((cfp = vm_get_ruby_level_cfp(th, cfp)) != 0) {
th_make_env_object(th, cfp); vm_make_env_object(th, cfp);
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
} }
} }
static VALUE static VALUE
th_make_proc_from_block(rb_thread_t *th, rb_control_frame_t *cfp, vm_make_proc_from_block(rb_thread_t *th, rb_control_frame_t *cfp,
rb_block_t *block) rb_block_t *block)
{ {
VALUE procval; VALUE procval;
@ -820,12 +816,12 @@ th_make_proc_from_block(rb_thread_t *th, rb_control_frame_t *cfp,
bcfp = RUBY_VM_GET_CFP_FROM_BLOCK_PTR(block); bcfp = RUBY_VM_GET_CFP_FROM_BLOCK_PTR(block);
bdfp = bcfp->dfp; bdfp = bcfp->dfp;
block->proc = procval = th_make_proc(th, bcfp, block); block->proc = procval = vm_make_proc(th, bcfp, block);
return procval; return procval;
} }
VALUE VALUE
th_make_proc(rb_thread_t *th, vm_make_proc(rb_thread_t *th,
rb_control_frame_t *cfp, rb_block_t *block) rb_control_frame_t *cfp, rb_block_t *block)
{ {
VALUE procval, envval, blockprocval = 0; VALUE procval, envval, blockprocval = 0;
@ -835,14 +831,14 @@ th_make_proc(rb_thread_t *th,
if (!RUBY_VM_CLASS_SPECIAL_P(cfp->lfp[0])) { if (!RUBY_VM_CLASS_SPECIAL_P(cfp->lfp[0])) {
rb_proc_t *p; rb_proc_t *p;
blockprocval = th_make_proc_from_block( blockprocval = vm_make_proc_from_block(
th, cfp, (rb_block_t *)GC_GUARDED_PTR_REF(*cfp->lfp)); th, cfp, (rb_block_t *)GC_GUARDED_PTR_REF(*cfp->lfp));
GetProcPtr(blockprocval, p); GetProcPtr(blockprocval, p);
*cfp->lfp = GC_GUARDED_PTR(&p->block); *cfp->lfp = GC_GUARDED_PTR(&p->block);
} }
} }
envval = th_make_env_object(th, cfp); envval = vm_make_env_object(th, cfp);
if (PROCDEBUG) { if (PROCDEBUG) {
check_env_value(envval); check_env_value(envval);
@ -872,7 +868,7 @@ th_make_proc(rb_thread_t *th,
} }
VALUE VALUE
th_call0(rb_thread_t *th, VALUE klass, VALUE recv, vm_call0(rb_thread_t *th, VALUE klass, VALUE recv,
VALUE id, ID oid, int argc, const VALUE *argv, VALUE id, ID oid, int argc, const VALUE *argv,
NODE * body, int nosuper) NODE * body, int nosuper)
{ {
@ -892,9 +888,8 @@ th_call0(rb_thread_t *th, VALUE klass, VALUE recv,
case RUBY_VM_METHOD_NODE:{ case RUBY_VM_METHOD_NODE:{
rb_control_frame_t *reg_cfp; rb_control_frame_t *reg_cfp;
int i; int i;
const int flag = 0;
th_set_finish_env(th); vm_set_finish_env(th);
reg_cfp = th->cfp; reg_cfp = th->cfp;
CHECK_STACK_OVERFLOW(reg_cfp, argc); CHECK_STACK_OVERFLOW(reg_cfp, argc);
@ -904,7 +899,7 @@ th_call0(rb_thread_t *th, VALUE klass, VALUE recv,
} }
vm_setup_method(th, reg_cfp, argc, blockptr, 0, (VALUE)body->nd_body, recv, klass); vm_setup_method(th, reg_cfp, argc, blockptr, 0, (VALUE)body->nd_body, recv, klass);
val = th_eval_body(th); val = vm_eval_body(th);
break; break;
} }
case NODE_CFUNC: { case NODE_CFUNC: {
@ -912,8 +907,8 @@ th_call0(rb_thread_t *th, VALUE klass, VALUE recv,
{ {
rb_control_frame_t *reg_cfp = th->cfp; rb_control_frame_t *reg_cfp = th->cfp;
rb_control_frame_t *cfp = rb_control_frame_t *cfp =
push_frame(th, 0, FRAME_MAGIC_CFUNC, vm_push_frame(th, 0, FRAME_MAGIC_CFUNC,
recv, (VALUE)blockptr, 0, reg_cfp->sp, 0, 1); recv, (VALUE)blockptr, 0, reg_cfp->sp, 0, 1);
cfp->method_id = id; cfp->method_id = id;
cfp->method_klass = klass; cfp->method_klass = klass;
@ -926,7 +921,7 @@ th_call0(rb_thread_t *th, VALUE klass, VALUE recv,
rb_bug("cfp consistency error - call0"); rb_bug("cfp consistency error - call0");
th->cfp = reg_cfp; th->cfp = reg_cfp;
} }
pop_frame(th); vm_pop_frame(th);
} }
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, id, klass); EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, id, klass);
break; break;
@ -953,7 +948,7 @@ th_call0(rb_thread_t *th, VALUE klass, VALUE recv,
break; break;
} }
default: default:
rb_bug("unsupported: th_call0"); rb_bug("unsupported: vm_call0");
} }
RUBY_VM_CHECK_INTS(); RUBY_VM_CHECK_INTS();
return val; return val;
@ -979,7 +974,7 @@ search_super_klass(VALUE klass, VALUE recv)
} }
static VALUE static VALUE
th_call_super(rb_thread_t *th, int argc, const VALUE *argv) vm_call_super(rb_thread_t *th, int argc, const VALUE *argv)
{ {
VALUE recv = th->cfp->self; VALUE recv = th->cfp->self;
VALUE klass; VALUE klass;
@ -999,7 +994,7 @@ th_call_super(rb_thread_t *th, int argc, const VALUE *argv)
id = cfp->method_id; id = cfp->method_id;
} }
else { else {
rb_bug("th_call_super: should not be reached"); rb_bug("vm_call_super: should not be reached");
} }
body = rb_method_node(klass, id); /* this returns NODE_METHOD */ body = rb_method_node(klass, id); /* this returns NODE_METHOD */
@ -1011,20 +1006,20 @@ th_call_super(rb_thread_t *th, int argc, const VALUE *argv)
dp(recv); dp(recv);
dp(klass); dp(klass);
dpi(id); dpi(id);
rb_bug("th_call_super: not found"); rb_bug("vm_call_super: not found");
} }
return th_call0(th, klass, recv, id, id, argc, argv, body, nosuper); return vm_call0(th, klass, recv, id, id, argc, argv, body, nosuper);
} }
VALUE VALUE
rb_call_super(int argc, const VALUE *argv) rb_call_super(int argc, const VALUE *argv)
{ {
return th_call_super(GET_THREAD(), argc, argv); return vm_call_super(GET_THREAD(), argc, argv);
} }
static inline VALUE static inline VALUE
th_yield_with_cfunc(rb_thread_t *th, rb_block_t *block, vm_yield_with_cfunc(rb_thread_t *th, rb_block_t *block,
VALUE self, int argc, VALUE *argv) VALUE self, int argc, VALUE *argv)
{ {
NODE *ifunc = (NODE *) block->iseq; NODE *ifunc = (NODE *) block->iseq;
@ -1041,9 +1036,9 @@ th_yield_with_cfunc(rb_thread_t *th, rb_block_t *block,
arg = rb_ary_new(); arg = rb_ary_new();
} }
push_frame(th, 0, FRAME_MAGIC_IFUNC, vm_push_frame(th, 0, FRAME_MAGIC_IFUNC,
self, (VALUE)block->dfp, self, (VALUE)block->dfp,
0, th->cfp->sp, block->lfp, 1); 0, th->cfp->sp, block->lfp, 1);
val = (*ifunc->nd_cfnc) (arg, ifunc->nd_tval, Qnil); val = (*ifunc->nd_cfnc) (arg, ifunc->nd_tval, Qnil);
@ -1052,7 +1047,7 @@ th_yield_with_cfunc(rb_thread_t *th, rb_block_t *block,
} }
static inline int static inline int
th_yield_setup_args(rb_thread_t *th, rb_iseq_t *iseq, vm_yield_setup_args(rb_thread_t *th, rb_iseq_t *iseq,
int argc, VALUE *argv, int lambda) int argc, VALUE *argv, int lambda)
{ {
int i, arg_n = iseq->argc + (iseq->arg_rest == -1 ? 0 : 1); int i, arg_n = iseq->argc + (iseq->arg_rest == -1 ? 0 : 1);
@ -1149,7 +1144,7 @@ invoke_block(rb_thread_t *th, rb_block_t *block, VALUE self, int argc, VALUE *ar
int magic = block_proc_is_lambda(block->proc) ? int magic = block_proc_is_lambda(block->proc) ?
FRAME_MAGIC_LAMBDA : FRAME_MAGIC_BLOCK; FRAME_MAGIC_LAMBDA : FRAME_MAGIC_BLOCK;
th_set_finish_env(th); vm_set_finish_env(th);
CHECK_STACK_OVERFLOW(th->cfp, argc); CHECK_STACK_OVERFLOW(th->cfp, argc);
CHECK_STACK_OVERFLOW(th->cfp, iseq->stack_max); CHECK_STACK_OVERFLOW(th->cfp, iseq->stack_max);
@ -1158,14 +1153,14 @@ invoke_block(rb_thread_t *th, rb_block_t *block, VALUE self, int argc, VALUE *ar
th->cfp->sp[i] = argv[i]; th->cfp->sp[i] = argv[i];
} }
argc = th_yield_setup_args(th, iseq, argc, th->cfp->sp, magic == FRAME_MAGIC_LAMBDA); argc = vm_yield_setup_args(th, iseq, argc, th->cfp->sp, magic == FRAME_MAGIC_LAMBDA);
th->cfp->sp += argc; th->cfp->sp += argc;
push_frame(th, iseq, magic, vm_push_frame(th, iseq, magic,
self, GC_GUARDED_PTR(block->dfp), self, GC_GUARDED_PTR(block->dfp),
iseq->iseq_encoded, th->cfp->sp, block->lfp, iseq->iseq_encoded, th->cfp->sp, block->lfp,
iseq->local_size - argc); iseq->local_size - argc);
val = th_eval_body(th); val = vm_eval_body(th);
} }
else { else {
if (((NODE*)block->iseq)->u3.state == 1) { if (((NODE*)block->iseq)->u3.state == 1) {
@ -1173,25 +1168,25 @@ invoke_block(rb_thread_t *th, rb_block_t *block, VALUE self, int argc, VALUE *ar
argc = 1; argc = 1;
argv = &args; argv = &args;
} }
val = th_yield_with_cfunc(th, block, block->self, argc, argv); val = vm_yield_with_cfunc(th, block, block->self, argc, argv);
} }
return val; return val;
} }
VALUE VALUE
th_yield(rb_thread_t *th, int argc, VALUE *argv) vm_yield(rb_thread_t *th, int argc, VALUE *argv)
{ {
rb_block_t *block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]); rb_block_t *block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
if (block == 0) { if (block == 0) {
th_localjump_error("no block given", Qnil, 0); vm_localjump_error("no block given", Qnil, 0);
} }
return invoke_block(th, block, block->self, argc, argv); return invoke_block(th, block, block->self, argc, argv);
} }
VALUE VALUE
th_invoke_proc(rb_thread_t *th, rb_proc_t *proc, vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc,
VALUE self, int argc, VALUE *argv) VALUE self, int argc, VALUE *argv)
{ {
VALUE val = Qundef; VALUE val = Qundef;
@ -1284,7 +1279,7 @@ lfp_svar(VALUE *lfp, int cnt)
VALUE * VALUE *
th_cfp_svar(rb_control_frame_t *cfp, int cnt) vm_cfp_svar(rb_control_frame_t *cfp, int cnt)
{ {
while (cfp->pc == 0) { while (cfp->pc == 0) {
cfp++; cfp++;
@ -1293,16 +1288,16 @@ th_cfp_svar(rb_control_frame_t *cfp, int cnt)
} }
static VALUE * static VALUE *
th_svar(rb_thread_t *th, int cnt) vm_svar(rb_thread_t *th, int cnt)
{ {
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
return th_cfp_svar(cfp, cnt); return vm_cfp_svar(cfp, cnt);
} }
VALUE * VALUE *
rb_svar(int cnt) rb_svar(int cnt)
{ {
return th_svar(GET_THREAD(), cnt); return vm_svar(GET_THREAD(), cnt);
} }
VALUE VALUE
@ -1340,7 +1335,7 @@ rb_lastline_set(VALUE val)
} }
int int
th_get_sourceline(rb_control_frame_t *cfp) vm_get_sourceline(rb_control_frame_t *cfp)
{ {
int line_no = 0; int line_no = 0;
rb_iseq_t *iseq = cfp->iseq; rb_iseq_t *iseq = cfp->iseq;
@ -1362,7 +1357,7 @@ th_get_sourceline(rb_control_frame_t *cfp)
} }
static VALUE static VALUE
th_backtrace_each(rb_thread_t *th, vm_backtrace_each(rb_thread_t *th,
rb_control_frame_t *limit_cfp, rb_control_frame_t *limit_cfp,
rb_control_frame_t *cfp, rb_control_frame_t *cfp,
char *file, int line_no, VALUE ary) char *file, int line_no, VALUE ary)
@ -1375,7 +1370,7 @@ th_backtrace_each(rb_thread_t *th,
if (cfp->pc != 0) { if (cfp->pc != 0) {
rb_iseq_t *iseq = cfp->iseq; rb_iseq_t *iseq = cfp->iseq;
line_no = th_get_sourceline(cfp); line_no = vm_get_sourceline(cfp);
file = RSTRING_PTR(iseq->filename); file = RSTRING_PTR(iseq->filename);
str = rb_sprintf("%s:%d:in `%s'", str = rb_sprintf("%s:%d:in `%s'",
file, line_no, RSTRING_PTR(iseq->name)); file, line_no, RSTRING_PTR(iseq->name));
@ -1394,7 +1389,7 @@ th_backtrace_each(rb_thread_t *th,
} }
VALUE VALUE
th_backtrace(rb_thread_t *th, int lev) vm_backtrace(rb_thread_t *th, int lev)
{ {
VALUE ary; VALUE ary;
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
@ -1415,7 +1410,7 @@ th_backtrace(rb_thread_t *th, int lev)
ary = rb_ary_new(); ary = rb_ary_new();
} }
ary = th_backtrace_each(th, RUBY_VM_NEXT_CONTROL_FRAME(cfp), ary = vm_backtrace_each(th, RUBY_VM_NEXT_CONTROL_FRAME(cfp),
top_of_cfp, "", 0, ary); top_of_cfp, "", 0, ary);
return ary; return ary;
} }
@ -1425,7 +1420,7 @@ thread_backtrace(VALUE self, int level)
{ {
rb_thread_t *th; rb_thread_t *th;
GetThreadPtr(self, th); GetThreadPtr(self, th);
return th_backtrace(th, level); return vm_backtrace(th, level);
} }
/* /*
@ -1484,7 +1479,7 @@ lfp_set_special_cref(VALUE *lfp, NODE * cref)
} }
NODE * NODE *
th_set_special_cref(rb_thread_t *th, VALUE *lfp, NODE * cref_stack) vm_set_special_cref(rb_thread_t *th, VALUE *lfp, NODE * cref_stack)
{ {
return lfp_set_special_cref(lfp, cref_stack); return lfp_set_special_cref(lfp, cref_stack);
} }
@ -1516,16 +1511,16 @@ get_cref(rb_iseq_t *iseq, VALUE *lfp)
} }
NODE * NODE *
th_get_cref(rb_thread_t *th, rb_iseq_t *iseq, rb_control_frame_t *cfp) vm_get_cref(rb_thread_t *th, rb_iseq_t *iseq, rb_control_frame_t *cfp)
{ {
return get_cref(iseq, cfp->lfp); return get_cref(iseq, cfp->lfp);
} }
NODE * NODE *
th_cref_push(rb_thread_t *th, VALUE klass, int noex) vm_cref_push(rb_thread_t *th, VALUE klass, int noex)
{ {
NODE *cref = NEW_BLOCK(klass); NODE *cref = NEW_BLOCK(klass);
rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp); rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
cref->nd_file = 0; cref->nd_file = 0;
cref->nd_next = get_cref(cfp->iseq, cfp->lfp); cref->nd_next = get_cref(cfp->iseq, cfp->lfp);
@ -1534,9 +1529,9 @@ th_cref_push(rb_thread_t *th, VALUE klass, int noex)
} }
VALUE VALUE
th_get_cbase(rb_thread_t *th) vm_get_cbase(rb_thread_t *th)
{ {
rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp); rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
NODE *cref = get_cref(cfp->iseq, cfp->lfp); NODE *cref = get_cref(cfp->iseq, cfp->lfp);
VALUE klass = Qundef; VALUE klass = Qundef;
@ -1549,9 +1544,9 @@ th_get_cbase(rb_thread_t *th)
return klass; return klass;
} }
EVALBODY_HELPER_FUNCTION VALUE static inline VALUE
eval_get_ev_const(rb_thread_t *th, rb_iseq_t *iseq, vm_get_ev_const(rb_thread_t *th, rb_iseq_t *iseq,
VALUE klass, ID id, int is_defined) VALUE klass, ID id, int is_defined)
{ {
VALUE val; VALUE val;
@ -1620,8 +1615,8 @@ eval_get_ev_const(rb_thread_t *th, rb_iseq_t *iseq,
} }
} }
EVALBODY_HELPER_FUNCTION VALUE static inline VALUE
eval_get_cvar_base(rb_thread_t *th, rb_iseq_t *iseq) vm_get_cvar_base(rb_thread_t *th, rb_iseq_t *iseq)
{ {
NODE *cref = get_cref(iseq, th->cfp->lfp); NODE *cref = get_cref(iseq, th->cfp->lfp);
VALUE klass = Qnil; VALUE klass = Qnil;
@ -1638,8 +1633,8 @@ eval_get_cvar_base(rb_thread_t *th, rb_iseq_t *iseq)
return klass; return klass;
} }
EVALBODY_HELPER_FUNCTION void static inline void
eval_define_method(rb_thread_t *th, VALUE obj, vm_define_method(rb_thread_t *th, VALUE obj,
ID id, rb_iseq_t *miseq, rb_num_t is_singleton, NODE *cref) ID id, rb_iseq_t *miseq, rb_num_t is_singleton, NODE *cref)
{ {
NODE *newbody; NODE *newbody;
@ -1674,8 +1669,8 @@ eval_define_method(rb_thread_t *th, VALUE obj,
INC_VM_STATE_VERSION(); INC_VM_STATE_VERSION();
} }
EVALBODY_HELPER_FUNCTION NODE * static inline NODE *
eval_method_search(VALUE id, VALUE klass, IC ic) vm_method_search(VALUE id, VALUE klass, IC ic)
{ {
NODE *mn; NODE *mn;
@ -1698,12 +1693,6 @@ eval_method_search(VALUE id, VALUE klass, IC ic)
return mn; return mn;
} }
static void
call_yarv_end_proc(VALUE data)
{
rb_proc_call(data, rb_ary_new2(0));
}
static inline int static inline int
block_proc_is_lambda(VALUE procval) block_proc_is_lambda(VALUE procval)
{ {
@ -1718,6 +1707,12 @@ block_proc_is_lambda(VALUE procval)
} }
} }
static void
call_yarv_end_proc(VALUE data)
{
rb_proc_call(data, rb_ary_new2(0));
}
/*********************************************************/ /*********************************************************/
/*********************************************************/ /*********************************************************/
@ -1756,14 +1751,14 @@ make_localjump_error(const char *mesg, VALUE value, int reason)
} }
void void
th_localjump_error(const char *mesg, VALUE value, int reason) vm_localjump_error(const char *mesg, VALUE value, int reason)
{ {
VALUE exc = make_localjump_error(mesg, value, reason); VALUE exc = make_localjump_error(mesg, value, reason);
rb_exc_raise(exc); rb_exc_raise(exc);
} }
VALUE VALUE
th_make_jump_tag_but_local_jump(int state, VALUE val) vm_make_jump_tag_but_local_jump(int state, VALUE val)
{ {
VALUE result = Qnil; VALUE result = Qnil;
@ -1794,9 +1789,9 @@ th_make_jump_tag_but_local_jump(int state, VALUE val)
} }
void void
th_jump_tag_but_local_jump(int state, VALUE val) vm_jump_tag_but_local_jump(int state, VALUE val)
{ {
VALUE exc = th_make_jump_tag_but_local_jump(state, val); VALUE exc = vm_make_jump_tag_but_local_jump(state, val);
if (val != Qnil) { if (val != Qnil) {
rb_exc_raise(exc); rb_exc_raise(exc);
} }
@ -1804,7 +1799,7 @@ th_jump_tag_but_local_jump(int state, VALUE val)
} }
void void
th_iter_break(rb_thread_t *th) vm_iter_break(rb_thread_t *th)
{ {
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
VALUE *dfp = GC_GUARDED_PTR_REF(*cfp->dfp); VALUE *dfp = GC_GUARDED_PTR_REF(*cfp->dfp);
@ -1987,7 +1982,7 @@ yarv_init_redefined_flag(void)
VALUE VALUE
th_eval_body(rb_thread_t *th) vm_eval_body(rb_thread_t *th)
{ {
int state; int state;
VALUE result, err; VALUE result, err;
@ -1996,7 +1991,7 @@ th_eval_body(rb_thread_t *th)
TH_PUSH_TAG(th); TH_PUSH_TAG(th);
if ((state = EXEC_TAG()) == 0) { if ((state = EXEC_TAG()) == 0) {
vm_loop_start: vm_loop_start:
result = th_eval(th, initial); result = vm_eval(th, initial);
if ((state = th->state) != 0) { if ((state = th->state) != 0) {
err = result; err = result;
th->state = 0; th->state = 0;
@ -2165,9 +2160,9 @@ th_eval_body(rb_thread_t *th)
/* push block frame */ /* push block frame */
cfp->sp[0] = err; cfp->sp[0] = err;
push_frame(th, catch_iseq, FRAME_MAGIC_BLOCK, vm_push_frame(th, catch_iseq, FRAME_MAGIC_BLOCK,
cfp->self, (VALUE)cfp->dfp, catch_iseq->iseq_encoded, cfp->self, (VALUE)cfp->dfp, catch_iseq->iseq_encoded,
cfp->sp + 1, cfp->lfp, catch_iseq->local_size - 1); cfp->sp + 1, cfp->lfp, catch_iseq->local_size - 1);
state = 0; state = 0;
th->errinfo = Qnil; th->errinfo = Qnil;
@ -2179,7 +2174,7 @@ th_eval_body(rb_thread_t *th)
goto exception_handler; goto exception_handler;
} }
else { else {
pop_frame(th); vm_pop_frame(th);
th->errinfo = err; th->errinfo = err;
TH_POP_TAG2(); TH_POP_TAG2();
JUMP_TAG(state); JUMP_TAG(state);
@ -2197,12 +2192,12 @@ rb_thread_eval(rb_thread_t *th, VALUE iseqval)
VALUE val; VALUE val;
volatile VALUE tmp; volatile VALUE tmp;
th_set_top_stack(th, iseqval); vm_set_top_stack(th, iseqval);
if (!rb_const_defined(rb_cObject, rb_intern("TOPLEVEL_BINDING"))) { if (!rb_const_defined(rb_cObject, rb_intern("TOPLEVEL_BINDING"))) {
rb_define_global_const("TOPLEVEL_BINDING", rb_binding_new()); rb_define_global_const("TOPLEVEL_BINDING", rb_binding_new());
} }
val = th_eval_body(th); val = vm_eval_body(th);
tmp = iseqval; /* prohibit tail call optimization */ tmp = iseqval; /* prohibit tail call optimization */
return val; return val;
} }
@ -2238,7 +2233,7 @@ rb_thread_current_status(rb_thread_t *th)
if (cfp->iseq != 0) { if (cfp->iseq != 0) {
if (cfp->pc != 0) { if (cfp->pc != 0) {
rb_iseq_t *iseq = cfp->iseq; rb_iseq_t *iseq = cfp->iseq;
int line_no = th_get_sourceline(cfp); int line_no = vm_get_sourceline(cfp);
char *file = RSTRING_PTR(iseq->filename); char *file = RSTRING_PTR(iseq->filename);
str = rb_sprintf("%s:%d:in `%s'", str = rb_sprintf("%s:%d:in `%s'",
file, line_no, RSTRING_PTR(iseq->name)); file, line_no, RSTRING_PTR(iseq->name));
@ -2261,9 +2256,9 @@ rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, rb_block_t *blockp
volatile VALUE iseq = rb_iseq_new(0, filename, filename, 0, ISEQ_TYPE_TOP); volatile VALUE iseq = rb_iseq_new(0, filename, filename, 0, ISEQ_TYPE_TOP);
VALUE val; VALUE val;
push_frame(th, DATA_PTR(iseq), FRAME_MAGIC_TOP, vm_push_frame(th, DATA_PTR(iseq), FRAME_MAGIC_TOP,
recv, (VALUE)blockptr, 0, reg_cfp->sp, 0, 1); recv, (VALUE)blockptr, 0, reg_cfp->sp, 0, 1);
val = (*func)(arg); val = (*func)(arg);
pop_frame(th); vm_pop_frame(th);
return val; return val;
} }

View File

@ -100,7 +100,7 @@ control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
else { else {
pc = cfp->pc - cfp->iseq->iseq_encoded; pc = cfp->pc - cfp->iseq->iseq_encoded;
iseq_name = RSTRING_PTR(cfp->iseq->name); iseq_name = RSTRING_PTR(cfp->iseq->name);
line = th_get_sourceline(cfp); line = vm_get_sourceline(cfp);
if (line) { if (line) {
char fn[MAX_POSBUF+1]; char fn[MAX_POSBUF+1];
snprintf(fn, MAX_POSBUF, "%s", RSTRING_PTR(cfp->iseq->filename)); snprintf(fn, MAX_POSBUF, "%s", RSTRING_PTR(cfp->iseq->filename));
@ -141,12 +141,12 @@ control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
void void
vm_stack_dump_raw(rb_thread_t *th, rb_control_frame_t *cfp) vm_stack_dump_raw(rb_thread_t *th, rb_control_frame_t *cfp)
{ {
#if 0
VALUE *sp = cfp->sp, *bp = cfp->bp; VALUE *sp = cfp->sp, *bp = cfp->bp;
VALUE *lfp = cfp->lfp; VALUE *lfp = cfp->lfp;
VALUE *dfp = cfp->dfp; VALUE *dfp = cfp->dfp;
VALUE *p, *st, *t; VALUE *p, *st, *t;
#if 0
fprintf(stderr, "-- stack frame ------------\n"); fprintf(stderr, "-- stack frame ------------\n");
for (p = st = th->stack; p < sp; p++) { for (p = st = th->stack; p < sp; p++) {
fprintf(stderr, "%04ld (%p): %08lx", p - st, p, *p); fprintf(stderr, "%04ld (%p): %08lx", p - st, p, *p);
@ -166,6 +166,7 @@ vm_stack_dump_raw(rb_thread_t *th, rb_control_frame_t *cfp)
fprintf(stderr, "\n"); fprintf(stderr, "\n");
} }
#endif #endif
fprintf(stderr, "-- control frame ----------\n"); fprintf(stderr, "-- control frame ----------\n");
while ((void *)cfp < (void *)(th->stack + th->stack_size)) { while ((void *)cfp < (void *)(th->stack + th->stack_size)) {
control_frame_dump(th, cfp); control_frame_dump(th, cfp);
@ -587,7 +588,7 @@ yarv_bug(void)
int i; int i;
SDR(); SDR();
bt = th_backtrace(th, 0); bt = vm_backtrace(th, 0);
if (TYPE(bt) == T_ARRAY) if (TYPE(bt) == T_ARRAY)
for (i = 0; i < RARRAY_LEN(bt); i++) { for (i = 0; i < RARRAY_LEN(bt); i++) {
dp(RARRAY_PTR(bt)[i]); dp(RARRAY_PTR(bt)[i]);

View File

@ -30,7 +30,7 @@ typedef rb_iseq_t *ISEQ;
#if !OPT_CALL_THREADED_CODE #if !OPT_CALL_THREADED_CODE
VALUE VALUE
th_eval(rb_thread_t *th, VALUE initial) vm_eval(rb_thread_t *th, VALUE initial)
{ {
#if OPT_STACK_CACHING #if OPT_STACK_CACHING
@ -97,13 +97,13 @@ th_eval(rb_thread_t *th, VALUE initial)
first: first:
INSN_DISPATCH(); INSN_DISPATCH();
/******************/ /*****************/
#include "vm.inc" #include "vm.inc"
/******************/ /*****************/
END_INSNS_DISPATCH(); END_INSNS_DISPATCH();
/* unreachable */ /* unreachable */
rb_bug("th_eval_iseq: unreachable"); rb_bug("vm_eval: unreachable");
return Qundef; return Qundef;
} }
@ -119,7 +119,7 @@ get_insns_address_table()
} }
VALUE VALUE
th_eval(rb_thread_t *th, VALUE initial) vm_eval(rb_thread_t *th, VALUE initial)
{ {
register rb_control_frame_t *reg_cfp = th->cfp; register rb_control_frame_t *reg_cfp = th->cfp;
SET_PC(reg_cfp->iseq->iseq_encoded); SET_PC(reg_cfp->iseq->iseq_encoded);

View File

@ -75,7 +75,6 @@ ID id__send_bang;
rb_thread_t *ruby_current_thread = 0; rb_thread_t *ruby_current_thread = 0;
rb_vm_t *ruby_current_vm = 0; rb_vm_t *ruby_current_vm = 0;
static VALUE ruby_vm_list = Qnil;
RUBY_EXTERN int ruby_nerrs; RUBY_EXTERN int ruby_nerrs;
@ -99,7 +98,7 @@ yarvcore_eval_iseq(VALUE iseq)
} }
static VALUE static VALUE
th_compile_from_node(rb_thread_t *th, NODE * node, VALUE file) vm_compile_from_node(rb_thread_t *th, NODE * node, VALUE file)
{ {
VALUE iseq; VALUE iseq;
if (th->base_block) { if (th->base_block) {
@ -117,16 +116,16 @@ th_compile_from_node(rb_thread_t *th, NODE * node, VALUE file)
} }
VALUE VALUE
th_compile(rb_thread_t *th, VALUE str, VALUE file, VALUE line) vm_compile(rb_thread_t *th, VALUE str, VALUE file, VALUE line)
{ {
NODE *node = (NODE *) compile_string(str, file, line); NODE *node = (NODE *) compile_string(str, file, line);
return th_compile_from_node(th, (NODE *) node, file); return vm_compile_from_node(th, (NODE *) node, file);
} }
VALUE VALUE
yarvcore_eval_parsed(NODE *node, VALUE file) yarvcore_eval_parsed(NODE *node, VALUE file)
{ {
VALUE iseq = th_compile_from_node(GET_THREAD(), node, file); VALUE iseq = vm_compile_from_node(GET_THREAD(), node, file);
return yarvcore_eval_iseq(iseq); return yarvcore_eval_iseq(iseq);
} }

View File

@ -653,19 +653,19 @@ void rb_enable_interrupt(void);
void rb_disable_interrupt(void); void rb_disable_interrupt(void);
int rb_thread_method_id_and_klass(rb_thread_t *th, ID *idp, VALUE *klassp); int rb_thread_method_id_and_klass(rb_thread_t *th, ID *idp, VALUE *klassp);
VALUE th_eval_body(rb_thread_t *th); VALUE vm_eval_body(rb_thread_t *th);
VALUE th_set_eval_stack(rb_thread_t *, VALUE iseq); VALUE vm_set_eval_stack(rb_thread_t *, VALUE iseq);
VALUE th_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self, int argc, VALUE *argv); VALUE vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self, int argc, VALUE *argv);
VALUE th_make_proc(rb_thread_t *th, rb_control_frame_t *cfp, rb_block_t *block); VALUE vm_make_proc(rb_thread_t *th, rb_control_frame_t *cfp, rb_block_t *block);
VALUE th_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp); VALUE vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp);
VALUE th_backtrace(rb_thread_t *, int); VALUE vm_backtrace(rb_thread_t *, int);
VALUE th_yield(rb_thread_t *th, int argc, VALUE *argv); VALUE vm_yield(rb_thread_t *th, int argc, VALUE *argv);
VALUE th_call0(rb_thread_t *th, VALUE klass, VALUE recv, VALUE vm_call0(rb_thread_t *th, VALUE klass, VALUE recv,
VALUE id, ID oid, int argc, const VALUE *argv, VALUE id, ID oid, int argc, const VALUE *argv,
NODE * body, int nosuper); NODE * body, int nosuper);
int th_get_sourceline(rb_control_frame_t *); int vm_get_sourceline(rb_control_frame_t *);
VALUE yarvcore_eval_parsed(NODE *node, VALUE file); VALUE yarvcore_eval_parsed(NODE *node, VALUE file);
VALUE yarvcore_eval(VALUE self, VALUE str, VALUE file, VALUE line); VALUE yarvcore_eval(VALUE self, VALUE str, VALUE file, VALUE line);