1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* vm.c: some refactoring.

Browse Source 
* 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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ChangeLog
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.

6
blockinlining.c
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;
} }

39
compile.c
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 {

24
eval_intern.h
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 */

1
eval_jump.h
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);

2
eval_load.c
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)) {

1
inits.c
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()

54
insns.def
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);
} }

2
process.c
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())

2
signal.c
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

16
thread.c
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)) {

6
version.h
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;
} }

7
vm_dump.c
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]);

12
vm_evalbody.ci
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);

9
yarvcore.c
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);
} }

18
yarvcore.h
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);