• Main Page
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

vm_insnhelper.c

Go to the documentation of this file.
00001 /**********************************************************************
00002 
00003   vm_insnhelper.c - instruction helper functions.
00004 
00005   $Author: yugui $
00006 
00007   Copyright (C) 2007 Koichi Sasada
00008 
00009 **********************************************************************/
00010 
00011 /* finish iseq array */
00012 #include "insns.inc"
00013 #include <math.h>
00014 
00015 /* control stack frame */
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     /* setup vm value stack */
00037 
00038     /* nil initialize */
00039     for (i=0; i < local_size; i++) {
00040         *sp = Qnil;
00041         sp++;
00042     }
00043 
00044     /* set special val */
00045     *sp = GC_GUARDED_PTR(specval);
00046 
00047     if (lfp == 0) {
00048         lfp = sp;
00049     }
00050 
00051     /* setup vm control frame stack */
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 /* c method? */) {
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 /* method dispatch */
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         /* simple check */ \
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     /* mandatory */
00158     if (argc < (m + iseq->arg_post_len)) { /* check with post arg */
00159         argument_error(iseq, argc, m + iseq->arg_post_len);
00160     }
00161 
00162     argv += m;
00163     argc -= m;
00164 
00165     /* post arguments */
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     /* opt arguments */
00178     if (iseq->arg_opts) {
00179         const int opts = iseq->arg_opts - 1 /* no opt */;
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]; /* no opt */
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     /* rest arguments */
00201     if (iseq->arg_rest != -1) {
00202         orig_argv[iseq->arg_rest] = rb_ary_new4(argc, argv);
00203         argc = 0;
00204     }
00205 
00206     /* block arguments */
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             /* make Proc object */
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; /* Proc or nil */
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     /* expand top of stack? */
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             /* do nothing */
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     /* printf("len: %d, argc: %d\n", len, argc); */
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; /* not reached */
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     /* control block frame */
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     /* stack overflow check */
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         /* clear local variables */
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 /* recv */;
00485     }
00486     else {
00487         VALUE *p_rsp;
00488         th->cfp++; /* pop cf */
00489         p_rsp = th->cfp->sp;
00490 
00491         /* copy arguments */
00492         for (i=0; i < (sp - rsp); i++) {
00493             p_rsp[i] = rsp[i];
00494         }
00495 
00496         sp -= rsp - p_rsp;
00497 
00498         /* clear local variables */
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                     /* shift arguments */
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         /* method missing */
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 /* yield */
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  * @brief on supplied all of optional, rest and post parameters.
00741  * @pre iseq is block style (not lambda style)
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;    /* # of arguments which did not consumed yet */
00754     int psize = rsize > len ? len : rsize;  /* # of post arguments */
00755     int osize = 0;  /* # of opt arguments */
00756     VALUE ary;
00757 
00758     /* reserves arguments for post parameters */
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         /* copy post argument */
00783         MEMMOVE(&argv[start], &argv[m+osize], VALUE, psize);
00784     }
00785     else {
00786         ary = rb_ary_new4(rsize, &argv[r]);
00787 
00788         /* copy post argument */
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      * yield [1, 2]
00815      *  => {|a|} => a = [1, 2]
00816      *  => {|a, b|} => a, b = [1, 2]
00817      */
00818     arg0 = argv[0];
00819     if (!(iseq->arg_simple & 0x02) &&          /* exclude {|a|} */
00820             (m + iseq->arg_post_len) > 0 &&    /* this process is meaningful */
00821             argc == 1 && !NIL_P(ary = rb_check_array_type(arg0))) { /* rhs is only an array */
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              * yield 1, 2
00841              * => {|a|} # truncate
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) { /* TODO: implement simple version for (iseq->arg_post_len==0 && iseq->arg_opts > 0) */
00851             opt_pc = vm_yield_setup_block_args_complex(th, iseq, argc, argv);
00852         }
00853         else {
00854             if (argc < r) {
00855                 /* yield 1
00856                  * => {|a, b, *r|}
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     /* {|&b|} */
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) { /* for debug */
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         /* call as method */
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); /* TODO: should put before C/yield? */
00953         return val;
00954     }
00955 }
00956 
00957 /* svar */
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         /* in current lexical scope */
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         /* search self */
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; /* inline cache hit */
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             /* fall through */
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         /* defined by Module#define_method() */
01404         rb_control_frame_t *lcfp = GET_CFP();
01405 
01406         if (!sigval) {
01407             /* zsuper */
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         /* temporary measure for [Bug #2420] [Bug #3136] */
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                     /* lambda{... break ...} */
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                 /* check orphan and get dfp */
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                                     /* in lambda */
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         /* continue throw */
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             /*th->state = FIX2INT(rb_ivar_get(err, idThrowState));*/
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         /* post: ..., nil ,ary[-1], ..., ary[0..-num] # top */
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         /* normal: ary[num..-1], ary[num-2], ary[num-3], ..., ary[0] # top */
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 

Generated on Sat Jul 7 2012 15:29:25 for Ruby by  doxygen 1.7.1