00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include "insns.inc"
00013 #include <math.h>
00014
00015
00016
00017 #ifndef INLINE
00018 #define INLINE inline
00019 #endif
00020
00021 static rb_control_frame_t *vm_get_ruby_level_caller_cfp(rb_thread_t *th, rb_control_frame_t *cfp);
00022
00023 static inline rb_control_frame_t *
00024 vm_push_frame(rb_thread_t * th, const rb_iseq_t * iseq,
00025 VALUE type, VALUE self, VALUE specval,
00026 const VALUE *pc, VALUE *sp, VALUE *lfp,
00027 int local_size)
00028 {
00029 rb_control_frame_t * const cfp = th->cfp - 1;
00030 int i;
00031
00032 if ((void *)(sp + local_size) >= (void *)cfp) {
00033 rb_exc_raise(sysstack_error);
00034 }
00035 th->cfp = cfp;
00036
00037
00038
00039 for (i=0; i < local_size; i++) {
00040 *sp = Qnil;
00041 sp++;
00042 }
00043
00044
00045 *sp = GC_GUARDED_PTR(specval);
00046
00047 if (lfp == 0) {
00048 lfp = sp;
00049 }
00050
00051
00052
00053 cfp->pc = (VALUE *)pc;
00054 cfp->sp = sp + 1;
00055 cfp->bp = sp + 1;
00056 cfp->iseq = (rb_iseq_t *) iseq;
00057 cfp->flag = type;
00058 cfp->self = self;
00059 cfp->lfp = lfp;
00060 cfp->dfp = sp;
00061 cfp->block_iseq = 0;
00062 cfp->proc = 0;
00063 cfp->me = 0;
00064
00065 #define COLLECT_PROFILE 0
00066 #if COLLECT_PROFILE
00067 cfp->prof_time_self = clock();
00068 cfp->prof_time_chld = 0;
00069 #endif
00070
00071 if (VMDEBUG == 2) {
00072 SDR();
00073 }
00074
00075 return cfp;
00076 }
00077
00078 static inline void
00079 vm_pop_frame(rb_thread_t *th)
00080 {
00081 #if COLLECT_PROFILE
00082 rb_control_frame_t *cfp = th->cfp;
00083
00084 if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
00085 VALUE current_time = clock();
00086 rb_control_frame_t *cfp = th->cfp;
00087 cfp->prof_time_self = current_time - cfp->prof_time_self;
00088 (cfp+1)->prof_time_chld += cfp->prof_time_self;
00089
00090 cfp->iseq->profile.count++;
00091 cfp->iseq->profile.time_cumu = cfp->prof_time_self;
00092 cfp->iseq->profile.time_self = cfp->prof_time_self - cfp->prof_time_chld;
00093 }
00094 else if (0 ) {
00095
00096 }
00097 #endif
00098 th->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
00099
00100 if (VMDEBUG == 2) {
00101 SDR();
00102 }
00103 }
00104
00105
00106
00107 NORETURN(static void argument_error(const rb_iseq_t *iseq, int miss_argc, int correct_argc));
00108 static void
00109 argument_error(const rb_iseq_t *iseq, int miss_argc, int correct_argc)
00110 {
00111 VALUE mesg = rb_sprintf("wrong number of arguments (%d for %d)", miss_argc, correct_argc);
00112 VALUE exc = rb_exc_new3(rb_eArgError, mesg);
00113 VALUE bt = rb_make_backtrace();
00114 VALUE err_line = 0;
00115
00116 if (iseq) {
00117 int line_no = 1;
00118
00119 if (iseq->insn_info_size) {
00120 line_no = iseq->insn_info_table[0].line_no;
00121 }
00122
00123 err_line = rb_sprintf("%s:%d:in `%s'",
00124 RSTRING_PTR(iseq->filename),
00125 line_no, RSTRING_PTR(iseq->name));
00126 rb_funcall(bt, rb_intern("unshift"), 1, err_line);
00127 }
00128
00129 rb_funcall(exc, rb_intern("set_backtrace"), 1, bt);
00130 rb_exc_raise(exc);
00131 }
00132
00133 #define VM_CALLEE_SETUP_ARG(ret, th, iseq, orig_argc, orig_argv, block) \
00134 if (LIKELY(iseq->arg_simple & 0x01)) { \
00135 \
00136 if (orig_argc != iseq->argc) { \
00137 argument_error(iseq, orig_argc, iseq->argc); \
00138 } \
00139 ret = 0; \
00140 } \
00141 else { \
00142 ret = vm_callee_setup_arg_complex(th, iseq, orig_argc, orig_argv, block); \
00143 }
00144
00145 static inline int
00146 vm_callee_setup_arg_complex(rb_thread_t *th, const rb_iseq_t * iseq,
00147 int orig_argc, VALUE * orig_argv,
00148 const rb_block_t **block)
00149 {
00150 const int m = iseq->argc;
00151 int argc = orig_argc;
00152 VALUE *argv = orig_argv;
00153 rb_num_t opt_pc = 0;
00154
00155 th->mark_stack_len = argc + iseq->arg_size;
00156
00157
00158 if (argc < (m + iseq->arg_post_len)) {
00159 argument_error(iseq, argc, m + iseq->arg_post_len);
00160 }
00161
00162 argv += m;
00163 argc -= m;
00164
00165
00166 if (iseq->arg_post_len) {
00167 if (!(orig_argc < iseq->arg_post_start)) {
00168 VALUE *new_argv = ALLOCA_N(VALUE, argc);
00169 MEMCPY(new_argv, argv, VALUE, argc);
00170 argv = new_argv;
00171 }
00172
00173 MEMCPY(&orig_argv[iseq->arg_post_start], &argv[argc -= iseq->arg_post_len],
00174 VALUE, iseq->arg_post_len);
00175 }
00176
00177
00178 if (iseq->arg_opts) {
00179 const int opts = iseq->arg_opts - 1 ;
00180
00181 if (iseq->arg_rest == -1 && argc > opts) {
00182 argument_error(iseq, orig_argc, m + opts + iseq->arg_post_len);
00183 }
00184
00185 if (argc > opts) {
00186 argc -= opts;
00187 argv += opts;
00188 opt_pc = iseq->arg_opt_table[opts];
00189 }
00190 else {
00191 int i;
00192 for (i = argc; i<opts; i++) {
00193 orig_argv[i + m] = Qnil;
00194 }
00195 opt_pc = iseq->arg_opt_table[argc];
00196 argc = 0;
00197 }
00198 }
00199
00200
00201 if (iseq->arg_rest != -1) {
00202 orig_argv[iseq->arg_rest] = rb_ary_new4(argc, argv);
00203 argc = 0;
00204 }
00205
00206
00207 if (block && iseq->arg_block != -1) {
00208 VALUE blockval = Qnil;
00209 const rb_block_t *blockptr = *block;
00210
00211 if (argc != 0) {
00212 argument_error(iseq, orig_argc, m + iseq->arg_post_len);
00213 }
00214
00215 if (blockptr) {
00216
00217 if (blockptr->proc == 0) {
00218 rb_proc_t *proc;
00219 blockval = rb_vm_make_proc(th, blockptr, rb_cProc);
00220 GetProcPtr(blockval, proc);
00221 *block = &proc->block;
00222 }
00223 else {
00224 blockval = blockptr->proc;
00225 }
00226 }
00227
00228 orig_argv[iseq->arg_block] = blockval;
00229 }
00230
00231 th->mark_stack_len = 0;
00232 return (int)opt_pc;
00233 }
00234
00235 static inline int
00236 caller_setup_args(const rb_thread_t *th, rb_control_frame_t *cfp, VALUE flag,
00237 int argc, rb_iseq_t *blockiseq, rb_block_t **block)
00238 {
00239 rb_block_t *blockptr = 0;
00240
00241 if (block) {
00242 if (flag & VM_CALL_ARGS_BLOCKARG_BIT) {
00243 rb_proc_t *po;
00244 VALUE proc;
00245
00246 proc = *(--cfp->sp);
00247
00248 if (proc != Qnil) {
00249 if (!rb_obj_is_proc(proc)) {
00250 VALUE b = rb_check_convert_type(proc, T_DATA, "Proc", "to_proc");
00251 if (NIL_P(b) || !rb_obj_is_proc(b)) {
00252 rb_raise(rb_eTypeError,
00253 "wrong argument type %s (expected Proc)",
00254 rb_obj_classname(proc));
00255 }
00256 proc = b;
00257 }
00258 GetProcPtr(proc, po);
00259 blockptr = &po->block;
00260 RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp)->proc = proc;
00261 *block = blockptr;
00262 }
00263 }
00264 else if (blockiseq) {
00265 blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
00266 blockptr->iseq = blockiseq;
00267 blockptr->proc = 0;
00268 *block = blockptr;
00269 }
00270 }
00271
00272
00273 if (flag & VM_CALL_ARGS_SPLAT_BIT) {
00274 VALUE ary = *(cfp->sp - 1);
00275 VALUE *ptr;
00276 int i;
00277 VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_a");
00278
00279 if (NIL_P(tmp)) {
00280
00281 }
00282 else {
00283 long len = RARRAY_LEN(tmp);
00284 ptr = RARRAY_PTR(tmp);
00285 cfp->sp -= 1;
00286
00287 CHECK_STACK_OVERFLOW(cfp, len);
00288
00289 for (i = 0; i < len; i++) {
00290 *cfp->sp++ = ptr[i];
00291 }
00292 argc += i-1;
00293 }
00294 }
00295
00296 return argc;
00297 }
00298
00299 static inline VALUE
00300 call_cfunc(VALUE (*func)(), VALUE recv,
00301 int len, int argc, const VALUE *argv)
00302 {
00303
00304
00305 if (len >= 0 && argc != len) {
00306 rb_raise(rb_eArgError, "wrong number of arguments(%d for %d)",
00307 argc, len);
00308 }
00309
00310 switch (len) {
00311 case -2:
00312 return (*func) (recv, rb_ary_new4(argc, argv));
00313 break;
00314 case -1:
00315 return (*func) (argc, argv, recv);
00316 break;
00317 case 0:
00318 return (*func) (recv);
00319 break;
00320 case 1:
00321 return (*func) (recv, argv[0]);
00322 break;
00323 case 2:
00324 return (*func) (recv, argv[0], argv[1]);
00325 break;
00326 case 3:
00327 return (*func) (recv, argv[0], argv[1], argv[2]);
00328 break;
00329 case 4:
00330 return (*func) (recv, argv[0], argv[1], argv[2], argv[3]);
00331 break;
00332 case 5:
00333 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4]);
00334 break;
00335 case 6:
00336 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00337 argv[5]);
00338 break;
00339 case 7:
00340 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00341 argv[5], argv[6]);
00342 break;
00343 case 8:
00344 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00345 argv[5], argv[6], argv[7]);
00346 break;
00347 case 9:
00348 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00349 argv[5], argv[6], argv[7], argv[8]);
00350 break;
00351 case 10:
00352 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00353 argv[5], argv[6], argv[7], argv[8], argv[9]);
00354 break;
00355 case 11:
00356 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00357 argv[5], argv[6], argv[7], argv[8], argv[9],
00358 argv[10]);
00359 break;
00360 case 12:
00361 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00362 argv[5], argv[6], argv[7], argv[8], argv[9],
00363 argv[10], argv[11]);
00364 break;
00365 case 13:
00366 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00367 argv[5], argv[6], argv[7], argv[8], argv[9], argv[10],
00368 argv[11], argv[12]);
00369 break;
00370 case 14:
00371 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00372 argv[5], argv[6], argv[7], argv[8], argv[9], argv[10],
00373 argv[11], argv[12], argv[13]);
00374 break;
00375 case 15:
00376 return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4],
00377 argv[5], argv[6], argv[7], argv[8], argv[9], argv[10],
00378 argv[11], argv[12], argv[13], argv[14]);
00379 break;
00380 default:
00381 rb_raise(rb_eArgError, "too many arguments(%d)", len);
00382 return Qundef;
00383 }
00384 }
00385
00386 static inline VALUE
00387 vm_call_cfunc(rb_thread_t *th, rb_control_frame_t *reg_cfp,
00388 int num, VALUE recv, const rb_block_t *blockptr,
00389 const rb_method_entry_t *me)
00390 {
00391 VALUE val = 0;
00392 const rb_method_definition_t *def = me->def;
00393 rb_control_frame_t *cfp;
00394
00395 EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, me->called_id, me->klass);
00396
00397 cfp = vm_push_frame(th, 0, VM_FRAME_MAGIC_CFUNC,
00398 recv, (VALUE) blockptr, 0, reg_cfp->sp, 0, 1);
00399 cfp->me = me;
00400 reg_cfp->sp -= num + 1;
00401
00402 val = call_cfunc(def->body.cfunc.func, recv, (int)def->body.cfunc.argc, num, reg_cfp->sp + 1);
00403
00404 if (reg_cfp != th->cfp + 1) {
00405 rb_bug("cfp consistency error - send");
00406 }
00407
00408 vm_pop_frame(th);
00409
00410 EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, me->called_id, me->klass);
00411
00412 return val;
00413 }
00414
00415 static inline VALUE
00416 vm_call_bmethod(rb_thread_t *th, VALUE recv, int argc, const VALUE *argv,
00417 const rb_block_t *blockptr, const rb_method_entry_t *me)
00418 {
00419 rb_proc_t *proc;
00420 VALUE val;
00421
00422 EXEC_EVENT_HOOK(th, RUBY_EVENT_CALL, recv, me->called_id, me->klass);
00423
00424
00425 th->passed_me = me;
00426 GetProcPtr(me->def->body.proc, proc);
00427 val = rb_vm_invoke_proc(th, proc, recv, argc, argv, blockptr);
00428
00429 EXEC_EVENT_HOOK(th, RUBY_EVENT_RETURN, recv, me->called_id, me->klass);
00430
00431 return val;
00432 }
00433
00434 static inline void
00435 vm_method_missing_args(rb_thread_t *th, VALUE *argv,
00436 int num, const rb_block_t *blockptr, int opt)
00437 {
00438 rb_control_frame_t * const reg_cfp = th->cfp;
00439 MEMCPY(argv, STACK_ADDR_FROM_TOP(num + 1), VALUE, num + 1);
00440 th->method_missing_reason = opt;
00441 th->passed_block = blockptr;
00442 POPN(num + 1);
00443 }
00444
00445 static inline VALUE
00446 vm_method_missing(rb_thread_t *th, ID id, VALUE recv,
00447 int num, const rb_block_t *blockptr, int opt)
00448 {
00449 VALUE *argv = ALLOCA_N(VALUE, num + 1);
00450 vm_method_missing_args(th, argv, num, blockptr, opt);
00451 argv[0] = ID2SYM(id);
00452 return rb_funcall2(recv, idMethodMissing, num + 1, argv);
00453 }
00454
00455 static inline void
00456 vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp,
00457 VALUE recv, int argc, const rb_block_t *blockptr, VALUE flag,
00458 const rb_method_entry_t *me)
00459 {
00460 int opt_pc, i;
00461 VALUE *sp, *rsp = cfp->sp - argc;
00462 rb_iseq_t *iseq = me->def->body.iseq;
00463
00464 VM_CALLEE_SETUP_ARG(opt_pc, th, iseq, argc, rsp, &blockptr);
00465
00466
00467 CHECK_STACK_OVERFLOW(cfp, iseq->stack_max);
00468
00469 sp = rsp + iseq->arg_size;
00470
00471 if (LIKELY(!(flag & VM_CALL_TAILCALL_BIT))) {
00472 if (0) printf("local_size: %d, arg_size: %d\n",
00473 iseq->local_size, iseq->arg_size);
00474
00475
00476 for (i = 0; i < iseq->local_size - iseq->arg_size; i++) {
00477 *sp++ = Qnil;
00478 }
00479
00480 vm_push_frame(th, iseq,
00481 VM_FRAME_MAGIC_METHOD, recv, (VALUE) blockptr,
00482 iseq->iseq_encoded + opt_pc, sp, 0, 0);
00483
00484 cfp->sp = rsp - 1 ;
00485 }
00486 else {
00487 VALUE *p_rsp;
00488 th->cfp++;
00489 p_rsp = th->cfp->sp;
00490
00491
00492 for (i=0; i < (sp - rsp); i++) {
00493 p_rsp[i] = rsp[i];
00494 }
00495
00496 sp -= rsp - p_rsp;
00497
00498
00499 for (i = 0; i < iseq->local_size - iseq->arg_size; i++) {
00500 *sp++ = Qnil;
00501 }
00502
00503 vm_push_frame(th, iseq,
00504 VM_FRAME_MAGIC_METHOD, recv, (VALUE) blockptr,
00505 iseq->iseq_encoded + opt_pc, sp, 0, 0);
00506 }
00507 }
00508
00509 static inline VALUE
00510 vm_call_method(rb_thread_t *th, rb_control_frame_t *cfp,
00511 int num, const rb_block_t *blockptr, VALUE flag,
00512 ID id, const rb_method_entry_t *me, VALUE recv)
00513 {
00514 VALUE val;
00515
00516 start_method_dispatch:
00517
00518 if (me != 0) {
00519 if ((me->flag == 0)) {
00520 normal_method_dispatch:
00521 switch (me->def->type) {
00522 case VM_METHOD_TYPE_ISEQ:{
00523 vm_setup_method(th, cfp, recv, num, blockptr, flag, me);
00524 return Qundef;
00525 }
00526 case VM_METHOD_TYPE_NOTIMPLEMENTED:
00527 case VM_METHOD_TYPE_CFUNC:{
00528 val = vm_call_cfunc(th, cfp, num, recv, blockptr, me);
00529 break;
00530 }
00531 case VM_METHOD_TYPE_ATTRSET:{
00532 if (num != 1) {
00533 rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", num);
00534 }
00535 val = rb_ivar_set(recv, me->def->body.attr.id, *(cfp->sp - 1));
00536 cfp->sp -= 2;
00537 break;
00538 }
00539 case VM_METHOD_TYPE_IVAR:{
00540 if (num != 0) {
00541 rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", num);
00542 }
00543 val = rb_attr_get(recv, me->def->body.attr.id);
00544 cfp->sp -= 1;
00545 break;
00546 }
00547 case VM_METHOD_TYPE_MISSING:{
00548 VALUE *argv = ALLOCA_N(VALUE, num+1);
00549 argv[0] = ID2SYM(me->def->original_id);
00550 MEMCPY(argv+1, cfp->sp - num, VALUE, num);
00551 cfp->sp += - num - 1;
00552 val = rb_funcall2(recv, rb_intern("method_missing"), num+1, argv);
00553 break;
00554 }
00555 case VM_METHOD_TYPE_BMETHOD:{
00556 VALUE *argv = ALLOCA_N(VALUE, num);
00557 MEMCPY(argv, cfp->sp - num, VALUE, num);
00558 cfp->sp += - num - 1;
00559 val = vm_call_bmethod(th, recv, num, argv, blockptr, me);
00560 break;
00561 }
00562 case VM_METHOD_TYPE_ZSUPER:{
00563 VALUE klass = RCLASS_SUPER(me->klass);
00564 me = rb_method_entry(klass, id);
00565
00566 if (me != 0) {
00567 goto normal_method_dispatch;
00568 }
00569 else {
00570 goto start_method_dispatch;
00571 }
00572 }
00573 case VM_METHOD_TYPE_OPTIMIZED:{
00574 switch (me->def->body.optimize_type) {
00575 case OPTIMIZED_METHOD_TYPE_SEND: {
00576 rb_control_frame_t *reg_cfp = cfp;
00577 rb_num_t i = num - 1;
00578 VALUE sym;
00579
00580 if (num == 0) {
00581 rb_raise(rb_eArgError, "no method name given");
00582 }
00583
00584 sym = TOPN(i);
00585 id = SYMBOL_P(sym) ? SYM2ID(sym) : rb_to_id(sym);
00586
00587 if (i > 0) {
00588 MEMMOVE(&TOPN(i), &TOPN(i-1), VALUE, i);
00589 }
00590 me = rb_method_entry(CLASS_OF(recv), id);
00591 num -= 1;
00592 DEC_SP(1);
00593 flag |= VM_CALL_FCALL_BIT | VM_CALL_OPT_SEND_BIT;
00594
00595 goto start_method_dispatch;
00596 }
00597 case OPTIMIZED_METHOD_TYPE_CALL: {
00598 rb_proc_t *proc;
00599 int argc = num;
00600 VALUE *argv = ALLOCA_N(VALUE, num);
00601 GetProcPtr(recv, proc);
00602 MEMCPY(argv, cfp->sp - num, VALUE, num);
00603 cfp->sp -= num + 1;
00604
00605 val = rb_vm_invoke_proc(th, proc, proc->block.self, argc, argv, blockptr);
00606 break;
00607 }
00608 default:
00609 rb_bug("eval_invoke_method: unsupported optimized method type (%d)",
00610 me->def->body.optimize_type);
00611 }
00612 break;
00613 }
00614 default:{
00615 rb_bug("eval_invoke_method: unsupported method type (%d)", me->def->type);
00616 break;
00617 }
00618 }
00619 }
00620 else {
00621 int noex_safe;
00622
00623 if (!(flag & VM_CALL_FCALL_BIT) &&
00624 (me->flag & NOEX_MASK) & NOEX_PRIVATE) {
00625 int stat = NOEX_PRIVATE;
00626
00627 if (flag & VM_CALL_VCALL_BIT) {
00628 stat |= NOEX_VCALL;
00629 }
00630 val = vm_method_missing(th, id, recv, num, blockptr, stat);
00631 }
00632 else if (!(flag & VM_CALL_OPT_SEND_BIT) && (me->flag & NOEX_MASK) & NOEX_PROTECTED) {
00633 VALUE defined_class = me->klass;
00634
00635 if (TYPE(defined_class) == T_ICLASS) {
00636 defined_class = RBASIC(defined_class)->klass;
00637 }
00638
00639 if (!rb_obj_is_kind_of(cfp->self, defined_class)) {
00640 val = vm_method_missing(th, id, recv, num, blockptr, NOEX_PROTECTED);
00641 }
00642 else {
00643 goto normal_method_dispatch;
00644 }
00645 }
00646 else if ((noex_safe = NOEX_SAFE(me->flag)) > th->safe_level &&
00647 (noex_safe > 2)) {
00648 rb_raise(rb_eSecurityError, "calling insecure method: %s", rb_id2name(id));
00649 }
00650 else {
00651 goto normal_method_dispatch;
00652 }
00653 }
00654 }
00655 else {
00656
00657 int stat = 0;
00658 if (flag & VM_CALL_VCALL_BIT) {
00659 stat |= NOEX_VCALL;
00660 }
00661 if (flag & VM_CALL_SUPER_BIT) {
00662 stat |= NOEX_SUPER;
00663 }
00664 if (id == idMethodMissing) {
00665 VALUE *argv = ALLOCA_N(VALUE, num);
00666 vm_method_missing_args(th, argv, num - 1, 0, stat);
00667 rb_raise_method_missing(th, num, argv, recv, stat);
00668 }
00669 else {
00670 val = vm_method_missing(th, id, recv, num, blockptr, stat);
00671 }
00672 }
00673
00674 RUBY_VM_CHECK_INTS();
00675 return val;
00676 }
00677
00678
00679
00680 static inline int
00681 block_proc_is_lambda(const VALUE procval)
00682 {
00683 rb_proc_t *proc;
00684
00685 if (procval) {
00686 GetProcPtr(procval, proc);
00687 return proc->is_lambda;
00688 }
00689 else {
00690 return 0;
00691 }
00692 }
00693
00694 static inline VALUE
00695 vm_yield_with_cfunc(rb_thread_t *th, const rb_block_t *block,
00696 VALUE self, int argc, const VALUE *argv,
00697 const rb_block_t *blockargptr)
00698 {
00699 NODE *ifunc = (NODE *) block->iseq;
00700 VALUE val, arg, blockarg;
00701 int lambda = block_proc_is_lambda(block->proc);
00702
00703 if (lambda) {
00704 arg = rb_ary_new4(argc, argv);
00705 }
00706 else if (argc == 0) {
00707 arg = Qnil;
00708 }
00709 else {
00710 arg = argv[0];
00711 }
00712
00713 if (blockargptr) {
00714 if (blockargptr->proc) {
00715 blockarg = blockargptr->proc;
00716 }
00717 else {
00718 blockarg = rb_vm_make_proc(th, blockargptr, rb_cProc);
00719 }
00720 }
00721 else {
00722 blockarg = Qnil;
00723 }
00724
00725 vm_push_frame(th, 0, VM_FRAME_MAGIC_IFUNC,
00726 self, (VALUE)block->dfp,
00727 0, th->cfp->sp, block->lfp, 1);
00728
00729 if (blockargptr) {
00730 th->cfp->lfp[0] = GC_GUARDED_PTR((VALUE)blockargptr);
00731 }
00732 val = (*ifunc->nd_cfnc) (arg, ifunc->nd_tval, argc, argv, blockarg);
00733
00734 th->cfp++;
00735 return val;
00736 }
00737
00738
00739
00740
00741
00742
00743 static inline int
00744 vm_yield_setup_block_args_complex(rb_thread_t *th, const rb_iseq_t *iseq,
00745 int argc, VALUE *argv)
00746 {
00747 rb_num_t opt_pc = 0;
00748 int i;
00749 const int m = iseq->argc;
00750 const int r = iseq->arg_rest;
00751 int len = iseq->arg_post_len;
00752 int start = iseq->arg_post_start;
00753 int rsize = argc > m ? argc - m : 0;
00754 int psize = rsize > len ? len : rsize;
00755 int osize = 0;
00756 VALUE ary;
00757
00758
00759 rsize -= psize;
00760
00761 if (iseq->arg_opts) {
00762 const int opts = iseq->arg_opts - 1;
00763 if (rsize > opts) {
00764 osize = opts;
00765 opt_pc = iseq->arg_opt_table[opts];
00766 }
00767 else {
00768 osize = rsize;
00769 opt_pc = iseq->arg_opt_table[rsize];
00770 }
00771 }
00772 rsize -= osize;
00773
00774 if (0) {
00775 printf(" argc: %d\n", argc);
00776 printf(" len: %d\n", len);
00777 printf("start: %d\n", start);
00778 printf("rsize: %d\n", rsize);
00779 }
00780
00781 if (r == -1) {
00782
00783 MEMMOVE(&argv[start], &argv[m+osize], VALUE, psize);
00784 }
00785 else {
00786 ary = rb_ary_new4(rsize, &argv[r]);
00787
00788
00789 MEMMOVE(&argv[start], &argv[m+rsize+osize], VALUE, psize);
00790 argv[r] = ary;
00791 }
00792
00793 for (i=psize; i<len; i++) {
00794 argv[start + i] = Qnil;
00795 }
00796
00797 return (int)opt_pc;
00798 }
00799
00800 static inline int
00801 vm_yield_setup_block_args(rb_thread_t *th, const rb_iseq_t * iseq,
00802 int orig_argc, VALUE *argv,
00803 const rb_block_t *blockptr)
00804 {
00805 int i;
00806 int argc = orig_argc;
00807 const int m = iseq->argc;
00808 VALUE ary, arg0;
00809 int opt_pc = 0;
00810
00811 th->mark_stack_len = argc;
00812
00813
00814
00815
00816
00817
00818 arg0 = argv[0];
00819 if (!(iseq->arg_simple & 0x02) &&
00820 (m + iseq->arg_post_len) > 0 &&
00821 argc == 1 && !NIL_P(ary = rb_check_array_type(arg0))) {
00822 th->mark_stack_len = argc = RARRAY_LENINT(ary);
00823
00824 CHECK_STACK_OVERFLOW(th->cfp, argc);
00825
00826 MEMCPY(argv, RARRAY_PTR(ary), VALUE, argc);
00827 }
00828 else {
00829 argv[0] = arg0;
00830 }
00831
00832 for (i=argc; i<m; i++) {
00833 argv[i] = Qnil;
00834 }
00835
00836 if (iseq->arg_rest == -1 && iseq->arg_opts == 0) {
00837 const int arg_size = iseq->arg_size;
00838 if (arg_size < argc) {
00839
00840
00841
00842
00843 th->mark_stack_len = argc = arg_size;
00844 }
00845 }
00846 else {
00847 int r = iseq->arg_rest;
00848
00849 if (iseq->arg_post_len ||
00850 iseq->arg_opts) {
00851 opt_pc = vm_yield_setup_block_args_complex(th, iseq, argc, argv);
00852 }
00853 else {
00854 if (argc < r) {
00855
00856
00857
00858 for (i=argc; i<r; i++) {
00859 argv[i] = Qnil;
00860 }
00861 argv[r] = rb_ary_new();
00862 }
00863 else {
00864 argv[r] = rb_ary_new4(argc-r, &argv[r]);
00865 }
00866 }
00867
00868 th->mark_stack_len = iseq->arg_size;
00869 }
00870
00871
00872 if (iseq->arg_block != -1) {
00873 VALUE procval = Qnil;
00874
00875 if (blockptr) {
00876 if (blockptr->proc == 0) {
00877 procval = rb_vm_make_proc(th, blockptr, rb_cProc);
00878 }
00879 else {
00880 procval = blockptr->proc;
00881 }
00882 }
00883
00884 argv[iseq->arg_block] = procval;
00885 }
00886
00887 th->mark_stack_len = 0;
00888 return opt_pc;
00889 }
00890
00891 static inline int
00892 vm_yield_setup_args(rb_thread_t * const th, const rb_iseq_t *iseq,
00893 int argc, VALUE *argv,
00894 const rb_block_t *blockptr, int lambda)
00895 {
00896 if (0) {
00897 printf(" argc: %d\n", argc);
00898 printf("iseq argc: %d\n", iseq->argc);
00899 printf("iseq opts: %d\n", iseq->arg_opts);
00900 printf("iseq rest: %d\n", iseq->arg_rest);
00901 printf("iseq post: %d\n", iseq->arg_post_len);
00902 printf("iseq blck: %d\n", iseq->arg_block);
00903 printf("iseq smpl: %d\n", iseq->arg_simple);
00904 printf(" lambda: %s\n", lambda ? "true" : "false");
00905 }
00906
00907 if (lambda) {
00908
00909 int opt_pc;
00910 VM_CALLEE_SETUP_ARG(opt_pc, th, iseq, argc, argv, &blockptr);
00911 return opt_pc;
00912 }
00913 else {
00914 return vm_yield_setup_block_args(th, iseq, argc, argv, blockptr);
00915 }
00916 }
00917
00918 static VALUE
00919 vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_num_t num, rb_num_t flag)
00920 {
00921 const rb_block_t *block = GET_BLOCK_PTR();
00922 rb_iseq_t *iseq;
00923 int argc = (int)num;
00924 VALUE type = GET_ISEQ()->local_iseq->type;
00925
00926 if ((type != ISEQ_TYPE_METHOD && type != ISEQ_TYPE_CLASS) || block == 0) {
00927 rb_vm_localjump_error("no block given (yield)", Qnil, 0);
00928 }
00929 iseq = block->iseq;
00930
00931 argc = caller_setup_args(th, GET_CFP(), flag, argc, 0, 0);
00932
00933 if (BUILTIN_TYPE(iseq) != T_NODE) {
00934 int opt_pc;
00935 const int arg_size = iseq->arg_size;
00936 VALUE * const rsp = GET_SP() - argc;
00937 SET_SP(rsp);
00938
00939 CHECK_STACK_OVERFLOW(GET_CFP(), iseq->stack_max);
00940 opt_pc = vm_yield_setup_args(th, iseq, argc, rsp, 0,
00941 block_proc_is_lambda(block->proc));
00942
00943 vm_push_frame(th, iseq,
00944 VM_FRAME_MAGIC_BLOCK, block->self, (VALUE) block->dfp,
00945 iseq->iseq_encoded + opt_pc, rsp + arg_size, block->lfp,
00946 iseq->local_size - arg_size);
00947
00948 return Qundef;
00949 }
00950 else {
00951 VALUE val = vm_yield_with_cfunc(th, block, block->self, argc, STACK_ADDR_FROM_TOP(argc), 0);
00952 POPN(argc);
00953 return val;
00954 }
00955 }
00956
00957
00958
00959 static inline NODE *
00960 lfp_svar_place(rb_thread_t *th, VALUE *lfp)
00961 {
00962 VALUE *svar;
00963
00964 if (lfp && th->local_lfp != lfp) {
00965 svar = &lfp[-1];
00966 }
00967 else {
00968 svar = &th->local_svar;
00969 }
00970 if (NIL_P(*svar)) {
00971 *svar = (VALUE)NEW_IF(Qnil, Qnil, Qnil);
00972 }
00973 return (NODE *)*svar;
00974 }
00975
00976 static VALUE
00977 lfp_svar_get(rb_thread_t *th, VALUE *lfp, VALUE key)
00978 {
00979 NODE *svar = lfp_svar_place(th, lfp);
00980
00981 switch (key) {
00982 case 0:
00983 return svar->u1.value;
00984 case 1:
00985 return svar->u2.value;
00986 default: {
00987 const VALUE hash = svar->u3.value;
00988
00989 if (hash == Qnil) {
00990 return Qnil;
00991 }
00992 else {
00993 return rb_hash_lookup(hash, key);
00994 }
00995 }
00996 }
00997 }
00998
00999 static void
01000 lfp_svar_set(rb_thread_t *th, VALUE *lfp, VALUE key, VALUE val)
01001 {
01002 NODE *svar = lfp_svar_place(th, lfp);
01003
01004 switch (key) {
01005 case 0:
01006 svar->u1.value = val;
01007 return;
01008 case 1:
01009 svar->u2.value = val;
01010 return;
01011 default: {
01012 VALUE hash = svar->u3.value;
01013
01014 if (hash == Qnil) {
01015 svar->u3.value = hash = rb_hash_new();
01016 }
01017 rb_hash_aset(hash, key, val);
01018 }
01019 }
01020 }
01021
01022 static inline VALUE
01023 vm_getspecial(rb_thread_t *th, VALUE *lfp, VALUE key, rb_num_t type)
01024 {
01025 VALUE val;
01026
01027 if (type == 0) {
01028 VALUE k = key;
01029 if (FIXNUM_P(key)) {
01030 k = FIX2INT(key);
01031 }
01032 val = lfp_svar_get(th, lfp, k);
01033 }
01034 else {
01035 VALUE backref = lfp_svar_get(th, lfp, 1);
01036
01037 if (type & 0x01) {
01038 switch (type >> 1) {
01039 case '&':
01040 val = rb_reg_last_match(backref);
01041 break;
01042 case '`':
01043 val = rb_reg_match_pre(backref);
01044 break;
01045 case '\'':
01046 val = rb_reg_match_post(backref);
01047 break;
01048 case '+':
01049 val = rb_reg_match_last(backref);
01050 break;
01051 default:
01052 rb_bug("unexpected back-ref");
01053 }
01054 }
01055 else {
01056 val = rb_reg_nth_match((int)(type >> 1), backref);
01057 }
01058 }
01059 return val;
01060 }
01061
01062 static NODE *
01063 vm_get_cref0(const rb_iseq_t *iseq, const VALUE *lfp, const VALUE *dfp)
01064 {
01065 while (1) {
01066 if (lfp == dfp) {
01067 return iseq->cref_stack;
01068 }
01069 else if (dfp[-1] != Qnil) {
01070 return (NODE *)dfp[-1];
01071 }
01072 dfp = GET_PREV_DFP(dfp);
01073 }
01074 }
01075
01076 static NODE *
01077 vm_get_cref(const rb_iseq_t *iseq, const VALUE *lfp, const VALUE *dfp)
01078 {
01079 NODE *cref = vm_get_cref0(iseq, lfp, dfp);
01080
01081 if (cref == 0) {
01082 rb_bug("vm_get_cref: unreachable");
01083 }
01084 return cref;
01085 }
01086
01087 static NODE *
01088 vm_cref_push(rb_thread_t *th, VALUE klass, int noex, rb_block_t *blockptr)
01089 {
01090 rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(th, th->cfp);
01091 NODE *cref = NEW_BLOCK(klass);
01092 cref->nd_file = 0;
01093 cref->nd_visi = noex;
01094
01095 if (blockptr) {
01096 cref->nd_next = vm_get_cref0(blockptr->iseq, blockptr->lfp, blockptr->dfp);
01097 }
01098 else if (cfp) {
01099 cref->nd_next = vm_get_cref0(cfp->iseq, cfp->lfp, cfp->dfp);
01100 }
01101
01102 return cref;
01103 }
01104
01105 static inline VALUE
01106 vm_get_cbase(const rb_iseq_t *iseq, const VALUE *lfp, const VALUE *dfp)
01107 {
01108 NODE *cref = vm_get_cref(iseq, lfp, dfp);
01109 VALUE klass = Qundef;
01110
01111 while (cref) {
01112 if ((klass = cref->nd_clss) != 0) {
01113 break;
01114 }
01115 cref = cref->nd_next;
01116 }
01117
01118 return klass;
01119 }
01120
01121 static inline VALUE
01122 vm_get_const_base(const rb_iseq_t *iseq, const VALUE *lfp, const VALUE *dfp)
01123 {
01124 NODE *cref = vm_get_cref(iseq, lfp, dfp);
01125 VALUE klass = Qundef;
01126
01127 while (cref) {
01128 if (!(cref->flags & NODE_FL_CREF_PUSHED_BY_EVAL) &&
01129 (klass = cref->nd_clss) != 0) {
01130 break;
01131 }
01132 cref = cref->nd_next;
01133 }
01134
01135 return klass;
01136 }
01137
01138 static inline void
01139 vm_check_if_namespace(VALUE klass)
01140 {
01141 VALUE str;
01142 switch (TYPE(klass)) {
01143 case T_CLASS:
01144 case T_MODULE:
01145 break;
01146 default:
01147 str = rb_inspect(klass);
01148 rb_raise(rb_eTypeError, "%s is not a class/module",
01149 StringValuePtr(str));
01150 }
01151 }
01152
01153 static inline VALUE
01154 vm_get_ev_const(rb_thread_t *th, const rb_iseq_t *iseq,
01155 VALUE orig_klass, ID id, int is_defined)
01156 {
01157 VALUE val;
01158
01159 if (orig_klass == Qnil) {
01160
01161 const NODE *cref = vm_get_cref(iseq, th->cfp->lfp, th->cfp->dfp);
01162 const NODE *root_cref = NULL;
01163 VALUE klass = orig_klass;
01164
01165 while (cref && cref->nd_next) {
01166 if (!(cref->flags & NODE_FL_CREF_PUSHED_BY_EVAL)) {
01167 klass = cref->nd_clss;
01168 if (root_cref == NULL)
01169 root_cref = cref;
01170 }
01171 cref = cref->nd_next;
01172
01173 if (!NIL_P(klass)) {
01174 VALUE am = 0;
01175 search_continue:
01176 if (RCLASS_IV_TBL(klass) &&
01177 st_lookup(RCLASS_IV_TBL(klass), id, &val)) {
01178 if (val == Qundef) {
01179 if (am == klass) break;
01180 am = klass;
01181 rb_autoload_load(klass, id);
01182 goto search_continue;
01183 }
01184 else {
01185 if (is_defined) {
01186 return 1;
01187 }
01188 else {
01189 return val;
01190 }
01191 }
01192 }
01193 }
01194 }
01195
01196
01197 if (root_cref && !NIL_P(root_cref->nd_clss)) {
01198 klass = root_cref->nd_clss;
01199 }
01200 else {
01201 klass = CLASS_OF(th->cfp->self);
01202 }
01203
01204 if (is_defined) {
01205 return rb_const_defined(klass, id);
01206 }
01207 else {
01208 return rb_const_get(klass, id);
01209 }
01210 }
01211 else {
01212 vm_check_if_namespace(orig_klass);
01213 if (is_defined) {
01214 return rb_const_defined_from(orig_klass, id);
01215 }
01216 else {
01217 return rb_const_get_from(orig_klass, id);
01218 }
01219 }
01220 }
01221
01222 static inline VALUE
01223 vm_get_cvar_base(NODE *cref)
01224 {
01225 VALUE klass;
01226
01227 while (cref && cref->nd_next &&
01228 (NIL_P(cref->nd_clss) || FL_TEST(cref->nd_clss, FL_SINGLETON) ||
01229 (cref->flags & NODE_FL_CREF_PUSHED_BY_EVAL))) {
01230 cref = cref->nd_next;
01231
01232 if (!cref->nd_next) {
01233 rb_warn("class variable access from toplevel");
01234 }
01235 }
01236
01237 klass = cref->nd_clss;
01238
01239 if (NIL_P(klass)) {
01240 rb_raise(rb_eTypeError, "no class variables available");
01241 }
01242 return klass;
01243 }
01244
01245
01246 #ifndef USE_IC_FOR_IVAR
01247 #define USE_IC_FOR_IVAR 1
01248 #endif
01249
01250 static VALUE
01251 vm_getivar(VALUE obj, ID id, IC ic)
01252 {
01253 #if USE_IC_FOR_IVAR
01254 if (TYPE(obj) == T_OBJECT) {
01255 VALUE val = Qundef;
01256 VALUE klass = RBASIC(obj)->klass;
01257
01258 if (LIKELY(ic->ic_class == klass &&
01259 ic->ic_vmstat == GET_VM_STATE_VERSION())) {
01260 long index = ic->ic_value.index;
01261 long len = ROBJECT_NUMIV(obj);
01262 VALUE *ptr = ROBJECT_IVPTR(obj);
01263
01264 if (index < len) {
01265 val = ptr[index];
01266 }
01267 }
01268 else {
01269 st_data_t index;
01270 long len = ROBJECT_NUMIV(obj);
01271 VALUE *ptr = ROBJECT_IVPTR(obj);
01272 struct st_table *iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
01273
01274 if (iv_index_tbl) {
01275 if (st_lookup(iv_index_tbl, id, &index)) {
01276 if ((long)index < len) {
01277 val = ptr[index];
01278 }
01279 ic->ic_class = klass;
01280 ic->ic_value.index = index;
01281 ic->ic_vmstat = GET_VM_STATE_VERSION();
01282 }
01283 }
01284 }
01285 if (UNLIKELY(val == Qundef)) {
01286 rb_warning("instance variable %s not initialized", rb_id2name(id));
01287 val = Qnil;
01288 }
01289 return val;
01290 }
01291 else {
01292 return rb_ivar_get(obj, id);
01293 }
01294 #else
01295 return rb_ivar_get(obj, id);
01296 #endif
01297 }
01298
01299 static void
01300 vm_setivar(VALUE obj, ID id, VALUE val, IC ic)
01301 {
01302 #if USE_IC_FOR_IVAR
01303 if (!OBJ_UNTRUSTED(obj) && rb_safe_level() >= 4) {
01304 rb_raise(rb_eSecurityError, "Insecure: can't modify instance variable");
01305 }
01306 if (OBJ_FROZEN(obj)) {
01307 rb_error_frozen("object");
01308 }
01309
01310 if (TYPE(obj) == T_OBJECT) {
01311 VALUE klass = RBASIC(obj)->klass;
01312 st_data_t index;
01313
01314 if (LIKELY(ic->ic_class == klass &&
01315 ic->ic_vmstat == GET_VM_STATE_VERSION())) {
01316 long index = ic->ic_value.index;
01317 long len = ROBJECT_NUMIV(obj);
01318 VALUE *ptr = ROBJECT_IVPTR(obj);
01319
01320 if (index < len) {
01321 ptr[index] = val;
01322 return;
01323 }
01324 }
01325 else {
01326 struct st_table *iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
01327
01328 if (iv_index_tbl && st_lookup(iv_index_tbl, (st_data_t)id, &index)) {
01329 ic->ic_class = klass;
01330 ic->ic_value.index = index;
01331 ic->ic_vmstat = GET_VM_STATE_VERSION();
01332 }
01333
01334 }
01335 }
01336 rb_ivar_set(obj, id, val);
01337 #else
01338 rb_ivar_set(obj, id, val);
01339 #endif
01340 }
01341
01342 static inline const rb_method_entry_t *
01343 vm_method_search(VALUE id, VALUE klass, IC ic)
01344 {
01345 rb_method_entry_t *me;
01346 #if OPT_INLINE_METHOD_CACHE
01347 if (LIKELY(klass == ic->ic_class) &&
01348 LIKELY(GET_VM_STATE_VERSION() == ic->ic_vmstat)) {
01349 me = ic->ic_value.method;
01350 }
01351 else {
01352 me = rb_method_entry(klass, id);
01353 ic->ic_class = klass;
01354 ic->ic_value.method = me;
01355 ic->ic_vmstat = GET_VM_STATE_VERSION();
01356 }
01357 #else
01358 me = rb_method_entry(klass, id);
01359 #endif
01360 return me;
01361 }
01362
01363 static inline VALUE
01364 vm_search_normal_superclass(VALUE klass, VALUE recv)
01365 {
01366 if (BUILTIN_TYPE(klass) == T_CLASS) {
01367 return RCLASS_SUPER(klass);
01368 }
01369 else if (BUILTIN_TYPE(klass) == T_MODULE) {
01370 VALUE k = CLASS_OF(recv);
01371 while (k) {
01372 if (BUILTIN_TYPE(k) == T_ICLASS && RBASIC(k)->klass == klass) {
01373 return RCLASS_SUPER(k);
01374 }
01375 k = RCLASS_SUPER(k);
01376 }
01377 return rb_cObject;
01378 }
01379 else {
01380 rb_bug("vm_search_normal_superclass: should not be reach here");
01381 }
01382 }
01383
01384 static void
01385 vm_search_superclass(rb_control_frame_t *reg_cfp, rb_iseq_t *ip,
01386 VALUE recv, VALUE sigval,
01387 ID *idp, VALUE *klassp)
01388 {
01389 ID id;
01390 VALUE klass;
01391
01392 while (ip && !ip->klass) {
01393 ip = ip->parent_iseq;
01394 }
01395
01396 if (ip == 0) {
01397 rb_raise(rb_eNoMethodError, "super called outside of method");
01398 }
01399
01400 id = ip->defined_method_id;
01401
01402 if (ip != ip->local_iseq) {
01403
01404 rb_control_frame_t *lcfp = GET_CFP();
01405
01406 if (!sigval) {
01407
01408 rb_raise(rb_eRuntimeError, "implicit argument passing of super from method defined by define_method() is not supported. Specify all arguments explicitly.");
01409 }
01410
01411 while (lcfp->iseq != ip) {
01412 rb_thread_t *th = GET_THREAD();
01413 VALUE *tdfp = GET_PREV_DFP(lcfp->dfp);
01414 while (1) {
01415 lcfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(lcfp);
01416 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, lcfp)) {
01417 rb_raise(rb_eNoMethodError,
01418 "super called outside of method");
01419 }
01420 if (lcfp->dfp == tdfp) {
01421 break;
01422 }
01423 }
01424 }
01425
01426
01427 if (!lcfp->me) {
01428 rb_raise(rb_eNoMethodError, "super called outside of method");
01429 }
01430
01431 id = lcfp->me->def->original_id;
01432 klass = vm_search_normal_superclass(lcfp->me->klass, recv);
01433 }
01434 else {
01435 klass = vm_search_normal_superclass(ip->klass, recv);
01436 }
01437
01438 *idp = id;
01439 *klassp = klass;
01440 }
01441
01442 static VALUE
01443 vm_throw(rb_thread_t *th, rb_control_frame_t *reg_cfp,
01444 rb_num_t throw_state, VALUE throwobj)
01445 {
01446 int state = (int)(throw_state & 0xff);
01447 int flag = (int)(throw_state & 0x8000);
01448 rb_num_t level = throw_state >> 16;
01449
01450 if (state != 0) {
01451 VALUE *pt = 0;
01452 if (flag != 0) {
01453 pt = (void *) 1;
01454 }
01455 else {
01456 if (state == TAG_BREAK) {
01457 rb_control_frame_t *cfp = GET_CFP();
01458 VALUE *dfp = GET_DFP();
01459 int is_orphan = 1;
01460 rb_iseq_t *base_iseq = GET_ISEQ();
01461
01462 search_parent:
01463 if (cfp->iseq->type != ISEQ_TYPE_BLOCK) {
01464 if (cfp->iseq->type == ISEQ_TYPE_CLASS) {
01465 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
01466 dfp = cfp->dfp;
01467 goto search_parent;
01468 }
01469 dfp = GC_GUARDED_PTR_REF((VALUE *) *dfp);
01470 base_iseq = base_iseq->parent_iseq;
01471
01472 while ((VALUE *) cfp < th->stack + th->stack_size) {
01473 if (cfp->dfp == dfp) {
01474 goto search_parent;
01475 }
01476 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
01477 }
01478 rb_bug("VM (throw): can't find break base.");
01479 }
01480
01481 if (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_LAMBDA) {
01482
01483 is_orphan = 0;
01484 pt = cfp->dfp;
01485 state = TAG_RETURN;
01486 }
01487 else {
01488 dfp = GC_GUARDED_PTR_REF((VALUE *) *dfp);
01489
01490 while ((VALUE *)cfp < th->stack + th->stack_size) {
01491 if (cfp->dfp == dfp) {
01492 VALUE epc = cfp->pc - cfp->iseq->iseq_encoded;
01493 rb_iseq_t *iseq = cfp->iseq;
01494 int i;
01495
01496 for (i=0; i<iseq->catch_table_size; i++) {
01497 struct iseq_catch_table_entry *entry = &iseq->catch_table[i];
01498
01499 if (entry->type == CATCH_TYPE_BREAK &&
01500 entry->start < epc && entry->end >= epc) {
01501 if (entry->cont == epc) {
01502 goto found;
01503 }
01504 else {
01505 break;
01506 }
01507 }
01508 }
01509 break;
01510
01511 found:
01512 pt = dfp;
01513 is_orphan = 0;
01514 break;
01515 }
01516 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
01517 }
01518 }
01519
01520 if (is_orphan) {
01521 rb_vm_localjump_error("break from proc-closure", throwobj, TAG_BREAK);
01522 }
01523 }
01524 else if (state == TAG_RETRY) {
01525 rb_num_t i;
01526 pt = GC_GUARDED_PTR_REF((VALUE *) * GET_DFP());
01527 for (i = 0; i < level; i++) {
01528 pt = GC_GUARDED_PTR_REF((VALUE *) * pt);
01529 }
01530 }
01531 else if (state == TAG_RETURN) {
01532 rb_control_frame_t *cfp = GET_CFP();
01533 VALUE *dfp = GET_DFP();
01534 VALUE *lfp = GET_LFP();
01535
01536
01537 while ((VALUE *) cfp < th->stack + th->stack_size) {
01538 if (!lfp) {
01539 lfp = cfp->lfp;
01540 }
01541 if (cfp->dfp == lfp && cfp->iseq->type == ISEQ_TYPE_CLASS) {
01542 lfp = 0;
01543 }
01544
01545 if (cfp->lfp == lfp) {
01546 if (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_LAMBDA) {
01547 VALUE *tdfp = dfp;
01548
01549 while (lfp != tdfp) {
01550 if (cfp->dfp == tdfp) {
01551
01552 dfp = cfp->dfp;
01553 goto valid_return;
01554 }
01555 tdfp = GC_GUARDED_PTR_REF((VALUE *)*tdfp);
01556 }
01557 }
01558 }
01559
01560 if (cfp->dfp == lfp && cfp->iseq->type == ISEQ_TYPE_METHOD) {
01561 dfp = lfp;
01562 goto valid_return;
01563 }
01564
01565 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
01566 }
01567
01568 rb_vm_localjump_error("unexpected return", throwobj, TAG_RETURN);
01569
01570 valid_return:
01571 pt = dfp;
01572 }
01573 else {
01574 rb_bug("isns(throw): unsupport throw type");
01575 }
01576 }
01577 th->state = state;
01578 return (VALUE)NEW_THROW_OBJECT(throwobj, (VALUE) pt, state);
01579 }
01580 else {
01581
01582 VALUE err = throwobj;
01583
01584 if (FIXNUM_P(err)) {
01585 th->state = FIX2INT(err);
01586 }
01587 else if (SYMBOL_P(err)) {
01588 th->state = TAG_THROW;
01589 }
01590 else if (BUILTIN_TYPE(err) == T_NODE) {
01591 th->state = GET_THROWOBJ_STATE(err);
01592 }
01593 else {
01594 th->state = TAG_RAISE;
01595
01596 }
01597 return err;
01598 }
01599 }
01600
01601 static inline void
01602 vm_expandarray(rb_control_frame_t *cfp, VALUE ary, rb_num_t num, int flag)
01603 {
01604 int is_splat = flag & 0x01;
01605 rb_num_t space_size = num + is_splat;
01606 VALUE *base = cfp->sp, *ptr;
01607 volatile VALUE tmp_ary;
01608 rb_num_t len;
01609
01610 if (TYPE(ary) != T_ARRAY) {
01611 ary = rb_ary_to_ary(ary);
01612 }
01613
01614 cfp->sp += space_size;
01615
01616 tmp_ary = ary;
01617 ptr = RARRAY_PTR(ary);
01618 len = (rb_num_t)RARRAY_LEN(ary);
01619
01620 if (flag & 0x02) {
01621
01622 rb_num_t i = 0, j;
01623
01624 if (len < num) {
01625 for (i=0; i<num-len; i++) {
01626 *base++ = Qnil;
01627 }
01628 }
01629 for (j=0; i<num; i++, j++) {
01630 VALUE v = ptr[len - j - 1];
01631 *base++ = v;
01632 }
01633 if (is_splat) {
01634 *base = rb_ary_new4(len - j, ptr);
01635 }
01636 }
01637 else {
01638
01639 rb_num_t i;
01640 VALUE *bptr = &base[space_size - 1];
01641
01642 for (i=0; i<num; i++) {
01643 if (len <= i) {
01644 for (; i<num; i++) {
01645 *bptr-- = Qnil;
01646 }
01647 break;
01648 }
01649 *bptr-- = ptr[i];
01650 }
01651 if (is_splat) {
01652 if (num > len) {
01653 *bptr = rb_ary_new();
01654 }
01655 else {
01656 *bptr = rb_ary_new4(len - num, ptr + num);
01657 }
01658 }
01659 }
01660 }
01661
01662 static inline int
01663 check_cfunc(const rb_method_entry_t *me, VALUE (*func)())
01664 {
01665 if (me && me->def->type == VM_METHOD_TYPE_CFUNC &&
01666 me->def->body.cfunc.func == func) {
01667 return 1;
01668 }
01669 else {
01670 return 0;
01671 }
01672 }
01673
01674 static
01675 #ifndef NO_BIG_INLINE
01676 inline
01677 #endif
01678 VALUE
01679 opt_eq_func(VALUE recv, VALUE obj, IC ic)
01680 {
01681 if (FIXNUM_2_P(recv, obj) &&
01682 BASIC_OP_UNREDEFINED_P(BOP_EQ)) {
01683 return (recv == obj) ? Qtrue : Qfalse;
01684 }
01685 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
01686 if (HEAP_CLASS_OF(recv) == rb_cFloat &&
01687 HEAP_CLASS_OF(obj) == rb_cFloat &&
01688 BASIC_OP_UNREDEFINED_P(BOP_EQ)) {
01689 double a = RFLOAT_VALUE(recv);
01690 double b = RFLOAT_VALUE(obj);
01691
01692 if (isnan(a) || isnan(b)) {
01693 return Qfalse;
01694 }
01695 return (a == b) ? Qtrue : Qfalse;
01696 }
01697 else if (HEAP_CLASS_OF(recv) == rb_cString &&
01698 HEAP_CLASS_OF(obj) == rb_cString &&
01699 BASIC_OP_UNREDEFINED_P(BOP_EQ)) {
01700 return rb_str_equal(recv, obj);
01701 }
01702 }
01703
01704 {
01705 const rb_method_entry_t *me = vm_method_search(idEq, CLASS_OF(recv), ic);
01706 extern VALUE rb_obj_equal(VALUE obj1, VALUE obj2);
01707
01708 if (check_cfunc(me, rb_obj_equal)) {
01709 return recv == obj ? Qtrue : Qfalse;
01710 }
01711 }
01712
01713 return Qundef;
01714 }
01715
01716 struct opt_case_dispatch_i_arg {
01717 VALUE obj;
01718 int label;
01719 };
01720
01721 static int
01722 opt_case_dispatch_i(st_data_t key, st_data_t data, st_data_t p)
01723 {
01724 struct opt_case_dispatch_i_arg *arg = (void *)p;
01725
01726 if (RTEST(rb_funcall((VALUE)key, idEqq, 1, arg->obj))) {
01727 arg->label = FIX2INT((VALUE)data);
01728 return ST_STOP;
01729 }
01730 else {
01731 return ST_CONTINUE;
01732 }
01733 }
01734
01735