Ruby 1.9.3p327(2012-11-10revision37606)
vm.inc
Go to the documentation of this file.
00001 /* -*-c-*- *********************************************************/
00002 /*******************************************************************/
00003 /*******************************************************************/
00015 INSN_ENTRY(nop){
00016 {
00017 
00018 
00019   DEBUG_ENTER_INSN("nop");
00020   ADD_PC(1+0);
00021   PREFETCH(GET_PC());
00022   #define CURRENT_INSN_nop 1
00023   #define INSN_IS_SC()     0
00024   #define INSN_LABEL(lab)  LABEL_nop_##lab
00025   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00026   USAGE_ANALYSIS_INSN(BIN(nop));
00027 {
00028 #line 40 "insns.def"
00029     /* none */
00030 
00031 #line 32 "vm.inc"
00032 #undef CURRENT_INSN_nop
00033 #undef INSN_IS_SC
00034 #undef INSN_LABEL
00035 #undef LABEL_IS_SC
00036   END_INSN(nop);}}}
00037 INSN_ENTRY(getlocal){
00038 {
00039   VALUE val;
00040   lindex_t idx = (lindex_t)GET_OPERAND(1);
00041 
00042   DEBUG_ENTER_INSN("getlocal");
00043   ADD_PC(1+1);
00044   PREFETCH(GET_PC());
00045   #define CURRENT_INSN_getlocal 1
00046   #define INSN_IS_SC()     0
00047   #define INSN_LABEL(lab)  LABEL_getlocal_##lab
00048   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00049   USAGE_ANALYSIS_INSN(BIN(getlocal));
00050   USAGE_ANALYSIS_OPERAND(BIN(getlocal), 0, idx);
00051 {
00052 #line 58 "insns.def"
00053     val = *(GET_LFP() - idx);
00054 
00055 #line 56 "vm.inc"
00056   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00057   PUSH(val);
00058 #undef CURRENT_INSN_getlocal
00059 #undef INSN_IS_SC
00060 #undef INSN_LABEL
00061 #undef LABEL_IS_SC
00062   END_INSN(getlocal);}}}
00063 INSN_ENTRY(setlocal){
00064 {
00065   lindex_t idx = (lindex_t)GET_OPERAND(1);
00066   VALUE val = TOPN(0);
00067   DEBUG_ENTER_INSN("setlocal");
00068   ADD_PC(1+1);
00069   PREFETCH(GET_PC());
00070   POPN(1);
00071   #define CURRENT_INSN_setlocal 1
00072   #define INSN_IS_SC()     0
00073   #define INSN_LABEL(lab)  LABEL_setlocal_##lab
00074   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00075   USAGE_ANALYSIS_INSN(BIN(setlocal));
00076   USAGE_ANALYSIS_OPERAND(BIN(setlocal), 0, idx);
00077 {
00078 #line 72 "insns.def"
00079     (*(GET_LFP() - idx)) = val;
00080 
00081 #line 82 "vm.inc"
00082 #undef CURRENT_INSN_setlocal
00083 #undef INSN_IS_SC
00084 #undef INSN_LABEL
00085 #undef LABEL_IS_SC
00086   END_INSN(setlocal);}}}
00087 INSN_ENTRY(getspecial){
00088 {
00089   VALUE val;
00090   rb_num_t type = (rb_num_t)GET_OPERAND(2);
00091   VALUE key = (VALUE)GET_OPERAND(1);
00092 
00093   DEBUG_ENTER_INSN("getspecial");
00094   ADD_PC(1+2);
00095   PREFETCH(GET_PC());
00096   #define CURRENT_INSN_getspecial 1
00097   #define INSN_IS_SC()     0
00098   #define INSN_LABEL(lab)  LABEL_getspecial_##lab
00099   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00100   USAGE_ANALYSIS_INSN(BIN(getspecial));
00101   USAGE_ANALYSIS_OPERAND(BIN(getspecial), 0, key);
00102   USAGE_ANALYSIS_OPERAND(BIN(getspecial), 1, type);
00103 {
00104 #line 86 "insns.def"
00105     val = vm_getspecial(th, GET_LFP(), key, type);
00106 
00107 #line 108 "vm.inc"
00108   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00109   PUSH(val);
00110 #undef CURRENT_INSN_getspecial
00111 #undef INSN_IS_SC
00112 #undef INSN_LABEL
00113 #undef LABEL_IS_SC
00114   END_INSN(getspecial);}}}
00115 INSN_ENTRY(setspecial){
00116 {
00117   VALUE key = (VALUE)GET_OPERAND(1);
00118   VALUE obj = TOPN(0);
00119   DEBUG_ENTER_INSN("setspecial");
00120   ADD_PC(1+1);
00121   PREFETCH(GET_PC());
00122   POPN(1);
00123   #define CURRENT_INSN_setspecial 1
00124   #define INSN_IS_SC()     0
00125   #define INSN_LABEL(lab)  LABEL_setspecial_##lab
00126   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00127   USAGE_ANALYSIS_INSN(BIN(setspecial));
00128   USAGE_ANALYSIS_OPERAND(BIN(setspecial), 0, key);
00129 {
00130 #line 100 "insns.def"
00131     lfp_svar_set(th, GET_LFP(), key, obj);
00132 
00133 #line 134 "vm.inc"
00134 #undef CURRENT_INSN_setspecial
00135 #undef INSN_IS_SC
00136 #undef INSN_LABEL
00137 #undef LABEL_IS_SC
00138   END_INSN(setspecial);}}}
00139 INSN_ENTRY(getdynamic){
00140 {
00141   VALUE val;
00142   rb_num_t level = (rb_num_t)GET_OPERAND(2);
00143   dindex_t idx = (dindex_t)GET_OPERAND(1);
00144 
00145   DEBUG_ENTER_INSN("getdynamic");
00146   ADD_PC(1+2);
00147   PREFETCH(GET_PC());
00148   #define CURRENT_INSN_getdynamic 1
00149   #define INSN_IS_SC()     0
00150   #define INSN_LABEL(lab)  LABEL_getdynamic_##lab
00151   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00152   USAGE_ANALYSIS_INSN(BIN(getdynamic));
00153   USAGE_ANALYSIS_OPERAND(BIN(getdynamic), 0, idx);
00154   USAGE_ANALYSIS_OPERAND(BIN(getdynamic), 1, level);
00155 {
00156 #line 116 "insns.def"
00157     rb_num_t i;
00158     VALUE *dfp2 = GET_DFP();
00159     for (i = 0; i < level; i++) {
00160         dfp2 = GET_PREV_DFP(dfp2);
00161     }
00162     val = *(dfp2 - idx);
00163 
00164 #line 165 "vm.inc"
00165   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00166   PUSH(val);
00167 #undef CURRENT_INSN_getdynamic
00168 #undef INSN_IS_SC
00169 #undef INSN_LABEL
00170 #undef LABEL_IS_SC
00171   END_INSN(getdynamic);}}}
00172 INSN_ENTRY(setdynamic){
00173 {
00174   rb_num_t level = (rb_num_t)GET_OPERAND(2);
00175   dindex_t idx = (dindex_t)GET_OPERAND(1);
00176   VALUE val = TOPN(0);
00177   DEBUG_ENTER_INSN("setdynamic");
00178   ADD_PC(1+2);
00179   PREFETCH(GET_PC());
00180   POPN(1);
00181   #define CURRENT_INSN_setdynamic 1
00182   #define INSN_IS_SC()     0
00183   #define INSN_LABEL(lab)  LABEL_setdynamic_##lab
00184   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00185   USAGE_ANALYSIS_INSN(BIN(setdynamic));
00186   USAGE_ANALYSIS_OPERAND(BIN(setdynamic), 0, idx);
00187   USAGE_ANALYSIS_OPERAND(BIN(setdynamic), 1, level);
00188 {
00189 #line 137 "insns.def"
00190     rb_num_t i;
00191     VALUE *dfp2 = GET_DFP();
00192     for (i = 0; i < level; i++) {
00193         dfp2 = GET_PREV_DFP(dfp2);
00194     }
00195     *(dfp2 - idx) = val;
00196 
00197 #line 198 "vm.inc"
00198 #undef CURRENT_INSN_setdynamic
00199 #undef INSN_IS_SC
00200 #undef INSN_LABEL
00201 #undef LABEL_IS_SC
00202   END_INSN(setdynamic);}}}
00203 INSN_ENTRY(getinstancevariable){
00204 {
00205   VALUE val;
00206   IC ic = (IC)GET_OPERAND(2);
00207   ID id = (ID)GET_OPERAND(1);
00208 
00209   DEBUG_ENTER_INSN("getinstancevariable");
00210   ADD_PC(1+2);
00211   PREFETCH(GET_PC());
00212   #define CURRENT_INSN_getinstancevariable 1
00213   #define INSN_IS_SC()     0
00214   #define INSN_LABEL(lab)  LABEL_getinstancevariable_##lab
00215   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00216   USAGE_ANALYSIS_INSN(BIN(getinstancevariable));
00217   USAGE_ANALYSIS_OPERAND(BIN(getinstancevariable), 0, id);
00218   USAGE_ANALYSIS_OPERAND(BIN(getinstancevariable), 1, ic);
00219 {
00220 #line 157 "insns.def"
00221     val = vm_getivar(GET_SELF(), id, ic);
00222 
00223 #line 224 "vm.inc"
00224   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00225   PUSH(val);
00226 #undef CURRENT_INSN_getinstancevariable
00227 #undef INSN_IS_SC
00228 #undef INSN_LABEL
00229 #undef LABEL_IS_SC
00230   END_INSN(getinstancevariable);}}}
00231 INSN_ENTRY(setinstancevariable){
00232 {
00233   IC ic = (IC)GET_OPERAND(2);
00234   ID id = (ID)GET_OPERAND(1);
00235   VALUE val = TOPN(0);
00236   DEBUG_ENTER_INSN("setinstancevariable");
00237   ADD_PC(1+2);
00238   PREFETCH(GET_PC());
00239   POPN(1);
00240   #define CURRENT_INSN_setinstancevariable 1
00241   #define INSN_IS_SC()     0
00242   #define INSN_LABEL(lab)  LABEL_setinstancevariable_##lab
00243   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00244   USAGE_ANALYSIS_INSN(BIN(setinstancevariable));
00245   USAGE_ANALYSIS_OPERAND(BIN(setinstancevariable), 0, id);
00246   USAGE_ANALYSIS_OPERAND(BIN(setinstancevariable), 1, ic);
00247 {
00248 #line 172 "insns.def"
00249     vm_setivar(GET_SELF(), id, val, ic);
00250 
00251 #line 252 "vm.inc"
00252 #undef CURRENT_INSN_setinstancevariable
00253 #undef INSN_IS_SC
00254 #undef INSN_LABEL
00255 #undef LABEL_IS_SC
00256   END_INSN(setinstancevariable);}}}
00257 INSN_ENTRY(getclassvariable){
00258 {
00259   VALUE val;
00260   ID id = (ID)GET_OPERAND(1);
00261 
00262   DEBUG_ENTER_INSN("getclassvariable");
00263   ADD_PC(1+1);
00264   PREFETCH(GET_PC());
00265   #define CURRENT_INSN_getclassvariable 1
00266   #define INSN_IS_SC()     0
00267   #define INSN_LABEL(lab)  LABEL_getclassvariable_##lab
00268   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00269   USAGE_ANALYSIS_INSN(BIN(getclassvariable));
00270   USAGE_ANALYSIS_OPERAND(BIN(getclassvariable), 0, id);
00271 {
00272 #line 186 "insns.def"
00273     NODE * const cref = vm_get_cref(GET_ISEQ(), GET_LFP(), GET_DFP());
00274     val = rb_cvar_get(vm_get_cvar_base(cref), id);
00275 
00276 #line 277 "vm.inc"
00277   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00278   PUSH(val);
00279 #undef CURRENT_INSN_getclassvariable
00280 #undef INSN_IS_SC
00281 #undef INSN_LABEL
00282 #undef LABEL_IS_SC
00283   END_INSN(getclassvariable);}}}
00284 INSN_ENTRY(setclassvariable){
00285 {
00286   ID id = (ID)GET_OPERAND(1);
00287   VALUE val = TOPN(0);
00288   DEBUG_ENTER_INSN("setclassvariable");
00289   ADD_PC(1+1);
00290   PREFETCH(GET_PC());
00291   POPN(1);
00292   #define CURRENT_INSN_setclassvariable 1
00293   #define INSN_IS_SC()     0
00294   #define INSN_LABEL(lab)  LABEL_setclassvariable_##lab
00295   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00296   USAGE_ANALYSIS_INSN(BIN(setclassvariable));
00297   USAGE_ANALYSIS_OPERAND(BIN(setclassvariable), 0, id);
00298 {
00299 #line 201 "insns.def"
00300     NODE * const cref = vm_get_cref(GET_ISEQ(), GET_LFP(), GET_DFP());
00301     rb_cvar_set(vm_get_cvar_base(cref), id, val);
00302 
00303 #line 304 "vm.inc"
00304 #undef CURRENT_INSN_setclassvariable
00305 #undef INSN_IS_SC
00306 #undef INSN_LABEL
00307 #undef LABEL_IS_SC
00308   END_INSN(setclassvariable);}}}
00309 INSN_ENTRY(getconstant){
00310 {
00311   VALUE val;
00312   ID id = (ID)GET_OPERAND(1);
00313   VALUE klass = TOPN(0);
00314   DEBUG_ENTER_INSN("getconstant");
00315   ADD_PC(1+1);
00316   PREFETCH(GET_PC());
00317   POPN(1);
00318   #define CURRENT_INSN_getconstant 1
00319   #define INSN_IS_SC()     0
00320   #define INSN_LABEL(lab)  LABEL_getconstant_##lab
00321   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00322   USAGE_ANALYSIS_INSN(BIN(getconstant));
00323   USAGE_ANALYSIS_OPERAND(BIN(getconstant), 0, id);
00324 {
00325 #line 223 "insns.def"
00326     val = vm_get_ev_const(th, GET_ISEQ(), klass, id, 0);
00327 
00328 #line 329 "vm.inc"
00329   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00330   PUSH(val);
00331 #undef CURRENT_INSN_getconstant
00332 #undef INSN_IS_SC
00333 #undef INSN_LABEL
00334 #undef LABEL_IS_SC
00335   END_INSN(getconstant);}}}
00336 INSN_ENTRY(setconstant){
00337 {
00338   ID id = (ID)GET_OPERAND(1);
00339   VALUE val = TOPN(1);
00340   VALUE cbase = TOPN(0);
00341   DEBUG_ENTER_INSN("setconstant");
00342   ADD_PC(1+1);
00343   PREFETCH(GET_PC());
00344   POPN(2);
00345   #define CURRENT_INSN_setconstant 1
00346   #define INSN_IS_SC()     0
00347   #define INSN_LABEL(lab)  LABEL_setconstant_##lab
00348   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00349   USAGE_ANALYSIS_INSN(BIN(setconstant));
00350   USAGE_ANALYSIS_OPERAND(BIN(setconstant), 0, id);
00351 {
00352 #line 245 "insns.def"
00353     vm_check_if_namespace(cbase);
00354     rb_const_set(cbase, id, val);
00355     INC_VM_STATE_VERSION();
00356 
00357 #line 358 "vm.inc"
00358 #undef CURRENT_INSN_setconstant
00359 #undef INSN_IS_SC
00360 #undef INSN_LABEL
00361 #undef LABEL_IS_SC
00362   END_INSN(setconstant);}}}
00363 INSN_ENTRY(getglobal){
00364 {
00365   VALUE val;
00366   GENTRY entry = (GENTRY)GET_OPERAND(1);
00367 
00368   DEBUG_ENTER_INSN("getglobal");
00369   ADD_PC(1+1);
00370   PREFETCH(GET_PC());
00371   #define CURRENT_INSN_getglobal 1
00372   #define INSN_IS_SC()     0
00373   #define INSN_LABEL(lab)  LABEL_getglobal_##lab
00374   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00375   USAGE_ANALYSIS_INSN(BIN(getglobal));
00376   USAGE_ANALYSIS_OPERAND(BIN(getglobal), 0, entry);
00377 {
00378 #line 261 "insns.def"
00379     val = GET_GLOBAL((VALUE)entry);
00380 
00381 #line 382 "vm.inc"
00382   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00383   PUSH(val);
00384 #undef CURRENT_INSN_getglobal
00385 #undef INSN_IS_SC
00386 #undef INSN_LABEL
00387 #undef LABEL_IS_SC
00388   END_INSN(getglobal);}}}
00389 INSN_ENTRY(setglobal){
00390 {
00391   GENTRY entry = (GENTRY)GET_OPERAND(1);
00392   VALUE val = TOPN(0);
00393   DEBUG_ENTER_INSN("setglobal");
00394   ADD_PC(1+1);
00395   PREFETCH(GET_PC());
00396   POPN(1);
00397   #define CURRENT_INSN_setglobal 1
00398   #define INSN_IS_SC()     0
00399   #define INSN_LABEL(lab)  LABEL_setglobal_##lab
00400   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00401   USAGE_ANALYSIS_INSN(BIN(setglobal));
00402   USAGE_ANALYSIS_OPERAND(BIN(setglobal), 0, entry);
00403 {
00404 #line 275 "insns.def"
00405     SET_GLOBAL((VALUE)entry, val);
00406 
00407 #line 408 "vm.inc"
00408 #undef CURRENT_INSN_setglobal
00409 #undef INSN_IS_SC
00410 #undef INSN_LABEL
00411 #undef LABEL_IS_SC
00412   END_INSN(setglobal);}}}
00413 INSN_ENTRY(putnil){
00414 {
00415   VALUE val;
00416 
00417 
00418   DEBUG_ENTER_INSN("putnil");
00419   ADD_PC(1+0);
00420   PREFETCH(GET_PC());
00421   #define CURRENT_INSN_putnil 1
00422   #define INSN_IS_SC()     0
00423   #define INSN_LABEL(lab)  LABEL_putnil_##lab
00424   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00425   USAGE_ANALYSIS_INSN(BIN(putnil));
00426 {
00427 #line 294 "insns.def"
00428     val = Qnil;
00429 
00430 #line 431 "vm.inc"
00431   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00432   PUSH(val);
00433 #undef CURRENT_INSN_putnil
00434 #undef INSN_IS_SC
00435 #undef INSN_LABEL
00436 #undef LABEL_IS_SC
00437   END_INSN(putnil);}}}
00438 INSN_ENTRY(putself){
00439 {
00440   VALUE val;
00441 
00442 
00443   DEBUG_ENTER_INSN("putself");
00444   ADD_PC(1+0);
00445   PREFETCH(GET_PC());
00446   #define CURRENT_INSN_putself 1
00447   #define INSN_IS_SC()     0
00448   #define INSN_LABEL(lab)  LABEL_putself_##lab
00449   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00450   USAGE_ANALYSIS_INSN(BIN(putself));
00451 {
00452 #line 308 "insns.def"
00453     val = GET_SELF();
00454 
00455 #line 456 "vm.inc"
00456   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00457   PUSH(val);
00458 #undef CURRENT_INSN_putself
00459 #undef INSN_IS_SC
00460 #undef INSN_LABEL
00461 #undef LABEL_IS_SC
00462   END_INSN(putself);}}}
00463 INSN_ENTRY(putobject){
00464 {
00465   VALUE val = (VALUE)GET_OPERAND(1);
00466 
00467   DEBUG_ENTER_INSN("putobject");
00468   ADD_PC(1+1);
00469   PREFETCH(GET_PC());
00470   #define CURRENT_INSN_putobject 1
00471   #define INSN_IS_SC()     0
00472   #define INSN_LABEL(lab)  LABEL_putobject_##lab
00473   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00474   USAGE_ANALYSIS_INSN(BIN(putobject));
00475   USAGE_ANALYSIS_OPERAND(BIN(putobject), 0, val);
00476 {
00477 #line 324 "insns.def"
00478     /* */
00479 
00480 #line 481 "vm.inc"
00481   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00482   PUSH(val);
00483 #undef CURRENT_INSN_putobject
00484 #undef INSN_IS_SC
00485 #undef INSN_LABEL
00486 #undef LABEL_IS_SC
00487   END_INSN(putobject);}}}
00488 INSN_ENTRY(putspecialobject){
00489 {
00490   VALUE val;
00491   rb_num_t value_type = (rb_num_t)GET_OPERAND(1);
00492 
00493   DEBUG_ENTER_INSN("putspecialobject");
00494   ADD_PC(1+1);
00495   PREFETCH(GET_PC());
00496   #define CURRENT_INSN_putspecialobject 1
00497   #define INSN_IS_SC()     0
00498   #define INSN_LABEL(lab)  LABEL_putspecialobject_##lab
00499   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00500   USAGE_ANALYSIS_INSN(BIN(putspecialobject));
00501   USAGE_ANALYSIS_OPERAND(BIN(putspecialobject), 0, value_type);
00502 {
00503 #line 339 "insns.def"
00504     enum vm_special_object_type type = (enum vm_special_object_type)value_type;
00505 
00506     switch (type) {
00507       case VM_SPECIAL_OBJECT_VMCORE:
00508         val = rb_mRubyVMFrozenCore;
00509         break;
00510       case VM_SPECIAL_OBJECT_CBASE:
00511         val = vm_get_cbase(GET_ISEQ(), GET_LFP(), GET_DFP());
00512         break;
00513       case VM_SPECIAL_OBJECT_CONST_BASE:
00514         val = vm_get_const_base(GET_ISEQ(), GET_LFP(), GET_DFP());
00515         break;
00516       default:
00517         rb_bug("putspecialobject insn: unknown value_type");
00518     }
00519 
00520 #line 521 "vm.inc"
00521   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00522   PUSH(val);
00523 #undef CURRENT_INSN_putspecialobject
00524 #undef INSN_IS_SC
00525 #undef INSN_LABEL
00526 #undef LABEL_IS_SC
00527   END_INSN(putspecialobject);}}}
00528 INSN_ENTRY(putiseq){
00529 {
00530   VALUE ret;
00531   ISEQ iseq = (ISEQ)GET_OPERAND(1);
00532 
00533   DEBUG_ENTER_INSN("putiseq");
00534   ADD_PC(1+1);
00535   PREFETCH(GET_PC());
00536   #define CURRENT_INSN_putiseq 1
00537   #define INSN_IS_SC()     0
00538   #define INSN_LABEL(lab)  LABEL_putiseq_##lab
00539   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00540   USAGE_ANALYSIS_INSN(BIN(putiseq));
00541   USAGE_ANALYSIS_OPERAND(BIN(putiseq), 0, iseq);
00542 {
00543 #line 367 "insns.def"
00544     ret = iseq->self;
00545 
00546 #line 547 "vm.inc"
00547   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00548   PUSH(ret);
00549 #undef CURRENT_INSN_putiseq
00550 #undef INSN_IS_SC
00551 #undef INSN_LABEL
00552 #undef LABEL_IS_SC
00553   END_INSN(putiseq);}}}
00554 INSN_ENTRY(putstring){
00555 {
00556   VALUE val;
00557   VALUE str = (VALUE)GET_OPERAND(1);
00558 
00559   DEBUG_ENTER_INSN("putstring");
00560   ADD_PC(1+1);
00561   PREFETCH(GET_PC());
00562   #define CURRENT_INSN_putstring 1
00563   #define INSN_IS_SC()     0
00564   #define INSN_LABEL(lab)  LABEL_putstring_##lab
00565   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00566   USAGE_ANALYSIS_INSN(BIN(putstring));
00567   USAGE_ANALYSIS_OPERAND(BIN(putstring), 0, str);
00568 {
00569 #line 381 "insns.def"
00570     val = rb_str_resurrect(str);
00571 
00572 #line 573 "vm.inc"
00573   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00574   PUSH(val);
00575 #undef CURRENT_INSN_putstring
00576 #undef INSN_IS_SC
00577 #undef INSN_LABEL
00578 #undef LABEL_IS_SC
00579   END_INSN(putstring);}}}
00580 INSN_ENTRY(concatstrings){
00581 {
00582   VALUE val;
00583   rb_num_t num = (rb_num_t)GET_OPERAND(1);
00584 
00585   DEBUG_ENTER_INSN("concatstrings");
00586   ADD_PC(1+1);
00587   PREFETCH(GET_PC());
00588   #define CURRENT_INSN_concatstrings 1
00589   #define INSN_IS_SC()     0
00590   #define INSN_LABEL(lab)  LABEL_concatstrings_##lab
00591   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00592   USAGE_ANALYSIS_INSN(BIN(concatstrings));
00593   USAGE_ANALYSIS_OPERAND(BIN(concatstrings), 0, num);
00594 {
00595 #line 395 "insns.def"
00596     rb_num_t i = num - 1;
00597 
00598     val = rb_str_resurrect(TOPN(i));
00599     while (i-- > 0) {
00600         const VALUE v = TOPN(i);
00601         rb_str_append(val, v);
00602     }
00603     POPN(num);
00604 
00605 #line 606 "vm.inc"
00606   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00607   PUSH(val);
00608 #undef CURRENT_INSN_concatstrings
00609 #undef INSN_IS_SC
00610 #undef INSN_LABEL
00611 #undef LABEL_IS_SC
00612   END_INSN(concatstrings);}}}
00613 INSN_ENTRY(tostring){
00614 {
00615 
00616   VALUE val = TOPN(0);
00617   DEBUG_ENTER_INSN("tostring");
00618   ADD_PC(1+0);
00619   PREFETCH(GET_PC());
00620   POPN(1);
00621   #define CURRENT_INSN_tostring 1
00622   #define INSN_IS_SC()     0
00623   #define INSN_LABEL(lab)  LABEL_tostring_##lab
00624   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00625   USAGE_ANALYSIS_INSN(BIN(tostring));
00626 {
00627 #line 416 "insns.def"
00628     val = rb_obj_as_string(val);
00629 
00630 #line 631 "vm.inc"
00631   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00632   PUSH(val);
00633 #undef CURRENT_INSN_tostring
00634 #undef INSN_IS_SC
00635 #undef INSN_LABEL
00636 #undef LABEL_IS_SC
00637   END_INSN(tostring);}}}
00638 INSN_ENTRY(toregexp){
00639 {
00640   VALUE val;
00641   rb_num_t cnt = (rb_num_t)GET_OPERAND(2);
00642   rb_num_t opt = (rb_num_t)GET_OPERAND(1);
00643 
00644   DEBUG_ENTER_INSN("toregexp");
00645   ADD_PC(1+2);
00646   PREFETCH(GET_PC());
00647   #define CURRENT_INSN_toregexp 1
00648   #define INSN_IS_SC()     0
00649   #define INSN_LABEL(lab)  LABEL_toregexp_##lab
00650   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00651   USAGE_ANALYSIS_INSN(BIN(toregexp));
00652   USAGE_ANALYSIS_OPERAND(BIN(toregexp), 0, opt);
00653   USAGE_ANALYSIS_OPERAND(BIN(toregexp), 1, cnt);
00654 {
00655 #line 431 "insns.def"
00656     VALUE rb_reg_new_ary(VALUE ary, int options);
00657     rb_num_t i;
00658     const VALUE ary = rb_ary_tmp_new(cnt);
00659     for (i = 0; i < cnt; i++) {
00660         rb_ary_store(ary, cnt-i-1, TOPN(i));
00661     }
00662     POPN(cnt);
00663     val = rb_reg_new_ary(ary, (int)opt);
00664     rb_ary_clear(ary);
00665 
00666 #line 667 "vm.inc"
00667   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00668   PUSH(val);
00669 #undef CURRENT_INSN_toregexp
00670 #undef INSN_IS_SC
00671 #undef INSN_LABEL
00672 #undef LABEL_IS_SC
00673   END_INSN(toregexp);}}}
00674 INSN_ENTRY(newarray){
00675 {
00676   VALUE val;
00677   rb_num_t num = (rb_num_t)GET_OPERAND(1);
00678 
00679   DEBUG_ENTER_INSN("newarray");
00680   ADD_PC(1+1);
00681   PREFETCH(GET_PC());
00682   #define CURRENT_INSN_newarray 1
00683   #define INSN_IS_SC()     0
00684   #define INSN_LABEL(lab)  LABEL_newarray_##lab
00685   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00686   USAGE_ANALYSIS_INSN(BIN(newarray));
00687   USAGE_ANALYSIS_OPERAND(BIN(newarray), 0, num);
00688 {
00689 #line 453 "insns.def"
00690     val = rb_ary_new4((long)num, STACK_ADDR_FROM_TOP(num));
00691     POPN(num);
00692 
00693 #line 694 "vm.inc"
00694   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00695   PUSH(val);
00696 #undef CURRENT_INSN_newarray
00697 #undef INSN_IS_SC
00698 #undef INSN_LABEL
00699 #undef LABEL_IS_SC
00700   END_INSN(newarray);}}}
00701 INSN_ENTRY(duparray){
00702 {
00703   VALUE val;
00704   VALUE ary = (VALUE)GET_OPERAND(1);
00705 
00706   DEBUG_ENTER_INSN("duparray");
00707   ADD_PC(1+1);
00708   PREFETCH(GET_PC());
00709   #define CURRENT_INSN_duparray 1
00710   #define INSN_IS_SC()     0
00711   #define INSN_LABEL(lab)  LABEL_duparray_##lab
00712   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00713   USAGE_ANALYSIS_INSN(BIN(duparray));
00714   USAGE_ANALYSIS_OPERAND(BIN(duparray), 0, ary);
00715 {
00716 #line 468 "insns.def"
00717     val = rb_ary_resurrect(ary);
00718 
00719 #line 720 "vm.inc"
00720   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00721   PUSH(val);
00722 #undef CURRENT_INSN_duparray
00723 #undef INSN_IS_SC
00724 #undef INSN_LABEL
00725 #undef LABEL_IS_SC
00726   END_INSN(duparray);}}}
00727 INSN_ENTRY(expandarray){
00728 {
00729   rb_num_t flag = (rb_num_t)GET_OPERAND(2);
00730   rb_num_t num = (rb_num_t)GET_OPERAND(1);
00731   VALUE ary = TOPN(0);
00732   DEBUG_ENTER_INSN("expandarray");
00733   ADD_PC(1+2);
00734   PREFETCH(GET_PC());
00735   POPN(1);
00736   #define CURRENT_INSN_expandarray 1
00737   #define INSN_IS_SC()     0
00738   #define INSN_LABEL(lab)  LABEL_expandarray_##lab
00739   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00740   USAGE_ANALYSIS_INSN(BIN(expandarray));
00741   USAGE_ANALYSIS_OPERAND(BIN(expandarray), 0, num);
00742   USAGE_ANALYSIS_OPERAND(BIN(expandarray), 1, flag);
00743 {
00744 #line 489 "insns.def"
00745     vm_expandarray(GET_CFP(), ary, num, (int)flag);
00746 
00747 #line 748 "vm.inc"
00748 #undef CURRENT_INSN_expandarray
00749 #undef INSN_IS_SC
00750 #undef INSN_LABEL
00751 #undef LABEL_IS_SC
00752   END_INSN(expandarray);}}}
00753 INSN_ENTRY(concatarray){
00754 {
00755   VALUE ary;
00756 
00757   VALUE ary1 = TOPN(1);
00758   VALUE ary2st = TOPN(0);
00759   DEBUG_ENTER_INSN("concatarray");
00760   ADD_PC(1+0);
00761   PREFETCH(GET_PC());
00762   POPN(2);
00763   #define CURRENT_INSN_concatarray 1
00764   #define INSN_IS_SC()     0
00765   #define INSN_LABEL(lab)  LABEL_concatarray_##lab
00766   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00767   USAGE_ANALYSIS_INSN(BIN(concatarray));
00768 {
00769 #line 503 "insns.def"
00770     const VALUE ary2 = ary2st;
00771     VALUE tmp1 = rb_check_convert_type(ary1, T_ARRAY, "Array", "to_a");
00772     VALUE tmp2 = rb_check_convert_type(ary2, T_ARRAY, "Array", "to_a");
00773 
00774     if (NIL_P(tmp1)) {
00775         tmp1 = rb_ary_new3(1, ary1);
00776     }
00777 
00778     if (NIL_P(tmp2)) {
00779         tmp2 = rb_ary_new3(1, ary2);
00780     }
00781 
00782     if (tmp1 == ary1) {
00783         tmp1 = rb_ary_dup(ary1);
00784     }
00785     ary = rb_ary_concat(tmp1, tmp2);
00786 
00787 #line 788 "vm.inc"
00788   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00789   PUSH(ary);
00790 #undef CURRENT_INSN_concatarray
00791 #undef INSN_IS_SC
00792 #undef INSN_LABEL
00793 #undef LABEL_IS_SC
00794   END_INSN(concatarray);}}}
00795 INSN_ENTRY(splatarray){
00796 {
00797   VALUE obj;
00798   VALUE flag = (VALUE)GET_OPERAND(1);
00799   VALUE ary = TOPN(0);
00800   DEBUG_ENTER_INSN("splatarray");
00801   ADD_PC(1+1);
00802   PREFETCH(GET_PC());
00803   POPN(1);
00804   #define CURRENT_INSN_splatarray 1
00805   #define INSN_IS_SC()     0
00806   #define INSN_LABEL(lab)  LABEL_splatarray_##lab
00807   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00808   USAGE_ANALYSIS_INSN(BIN(splatarray));
00809   USAGE_ANALYSIS_OPERAND(BIN(splatarray), 0, flag);
00810 {
00811 #line 532 "insns.def"
00812     VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_a");
00813     if (NIL_P(tmp)) {
00814         tmp = rb_ary_new3(1, ary);
00815     }
00816     else if (RTEST(flag)) {
00817         tmp = rb_ary_dup(tmp);
00818     }
00819     obj = tmp;
00820 
00821 #line 822 "vm.inc"
00822   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00823   PUSH(obj);
00824 #undef CURRENT_INSN_splatarray
00825 #undef INSN_IS_SC
00826 #undef INSN_LABEL
00827 #undef LABEL_IS_SC
00828   END_INSN(splatarray);}}}
00829 INSN_ENTRY(checkincludearray){
00830 {
00831   VALUE result;
00832   VALUE flag = (VALUE)GET_OPERAND(1);
00833   VALUE obj = TOPN(1);
00834   VALUE ary = TOPN(0);
00835   DEBUG_ENTER_INSN("checkincludearray");
00836   ADD_PC(1+1);
00837   PREFETCH(GET_PC());
00838   POPN(2);
00839   #define CURRENT_INSN_checkincludearray 1
00840   #define INSN_IS_SC()     0
00841   #define INSN_LABEL(lab)  LABEL_checkincludearray_##lab
00842   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00843   USAGE_ANALYSIS_INSN(BIN(checkincludearray));
00844   USAGE_ANALYSIS_OPERAND(BIN(checkincludearray), 0, flag);
00845 {
00846 #line 553 "insns.def"
00847     int i;
00848     result = Qfalse;
00849 
00850     if (TYPE(ary) != T_ARRAY) {
00851         ary = rb_Array(ary);
00852     }
00853 
00854     if (flag == Qtrue) {
00855         /* NODE_CASE */
00856         for (i = 0; i < RARRAY_LEN(ary); i++) {
00857             /* TODO: fix me (use another method dispatch) */
00858             if (RTEST(rb_funcall2(RARRAY_PTR(ary)[i], idEqq, 1, &obj))) {
00859                 result = Qtrue;
00860                 break;
00861             }
00862         }
00863     }
00864     else {
00865         obj = Qfalse;
00866         /* NODE_WHEN */
00867         for (i = 0; i < RARRAY_LEN(ary); i++) {
00868             if (RTEST(RARRAY_PTR(ary)[i])) {
00869                 obj = result = Qtrue;
00870                 break;
00871             }
00872         }
00873     }
00874 
00875 #line 876 "vm.inc"
00876   CHECK_STACK_OVERFLOW(REG_CFP, 2);
00877   PUSH(obj);
00878   PUSH(result);
00879 #undef CURRENT_INSN_checkincludearray
00880 #undef INSN_IS_SC
00881 #undef INSN_LABEL
00882 #undef LABEL_IS_SC
00883   END_INSN(checkincludearray);}}}
00884 INSN_ENTRY(newhash){
00885 {
00886   VALUE val;
00887   rb_num_t num = (rb_num_t)GET_OPERAND(1);
00888 
00889   DEBUG_ENTER_INSN("newhash");
00890   ADD_PC(1+1);
00891   PREFETCH(GET_PC());
00892   #define CURRENT_INSN_newhash 1
00893   #define INSN_IS_SC()     0
00894   #define INSN_LABEL(lab)  LABEL_newhash_##lab
00895   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00896   USAGE_ANALYSIS_INSN(BIN(newhash));
00897   USAGE_ANALYSIS_OPERAND(BIN(newhash), 0, num);
00898 {
00899 #line 594 "insns.def"
00900     rb_num_t i;
00901     val = rb_hash_new();
00902 
00903     for (i = num; i > 0; i -= 2) {
00904         const VALUE v = TOPN(i - 2);
00905         const VALUE k = TOPN(i - 1);
00906         rb_hash_aset(val, k, v);
00907     }
00908     POPN(num);
00909 
00910 #line 911 "vm.inc"
00911   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00912   PUSH(val);
00913 #undef CURRENT_INSN_newhash
00914 #undef INSN_IS_SC
00915 #undef INSN_LABEL
00916 #undef LABEL_IS_SC
00917   END_INSN(newhash);}}}
00918 INSN_ENTRY(newrange){
00919 {
00920   VALUE val;
00921   rb_num_t flag = (rb_num_t)GET_OPERAND(1);
00922   VALUE low = TOPN(1);
00923   VALUE high = TOPN(0);
00924   DEBUG_ENTER_INSN("newrange");
00925   ADD_PC(1+1);
00926   PREFETCH(GET_PC());
00927   POPN(2);
00928   #define CURRENT_INSN_newrange 1
00929   #define INSN_IS_SC()     0
00930   #define INSN_LABEL(lab)  LABEL_newrange_##lab
00931   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00932   USAGE_ANALYSIS_INSN(BIN(newrange));
00933   USAGE_ANALYSIS_OPERAND(BIN(newrange), 0, flag);
00934 {
00935 #line 616 "insns.def"
00936     val = rb_range_new(low, high, (int)flag);
00937 
00938 #line 939 "vm.inc"
00939   CHECK_STACK_OVERFLOW(REG_CFP, 1);
00940   PUSH(val);
00941 #undef CURRENT_INSN_newrange
00942 #undef INSN_IS_SC
00943 #undef INSN_LABEL
00944 #undef LABEL_IS_SC
00945   END_INSN(newrange);}}}
00946 INSN_ENTRY(pop){
00947 {
00948 
00949   VALUE val = TOPN(0);
00950   DEBUG_ENTER_INSN("pop");
00951   ADD_PC(1+0);
00952   PREFETCH(GET_PC());
00953   POPN(1);
00954   #define CURRENT_INSN_pop 1
00955   #define INSN_IS_SC()     0
00956   #define INSN_LABEL(lab)  LABEL_pop_##lab
00957   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00958   USAGE_ANALYSIS_INSN(BIN(pop));
00959 {
00960 #line 634 "insns.def"
00961     val = val;
00962     /* none */
00963 
00964 #line 965 "vm.inc"
00965 #undef CURRENT_INSN_pop
00966 #undef INSN_IS_SC
00967 #undef INSN_LABEL
00968 #undef LABEL_IS_SC
00969   END_INSN(pop);}}}
00970 INSN_ENTRY(dup){
00971 {
00972   VALUE val2;
00973   VALUE val1;
00974 
00975   VALUE val = TOPN(0);
00976   DEBUG_ENTER_INSN("dup");
00977   ADD_PC(1+0);
00978   PREFETCH(GET_PC());
00979   POPN(1);
00980   #define CURRENT_INSN_dup 1
00981   #define INSN_IS_SC()     0
00982   #define INSN_LABEL(lab)  LABEL_dup_##lab
00983   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00984   USAGE_ANALYSIS_INSN(BIN(dup));
00985 {
00986 #line 649 "insns.def"
00987     val1 = val2 = val;
00988 
00989 #line 990 "vm.inc"
00990   CHECK_STACK_OVERFLOW(REG_CFP, 2);
00991   PUSH(val1);
00992   PUSH(val2);
00993 #undef CURRENT_INSN_dup
00994 #undef INSN_IS_SC
00995 #undef INSN_LABEL
00996 #undef LABEL_IS_SC
00997   END_INSN(dup);}}}
00998 INSN_ENTRY(dupn){
00999 {
01000   rb_num_t n = (rb_num_t)GET_OPERAND(1);
01001 
01002   DEBUG_ENTER_INSN("dupn");
01003   ADD_PC(1+1);
01004   PREFETCH(GET_PC());
01005   #define CURRENT_INSN_dupn 1
01006   #define INSN_IS_SC()     0
01007   #define INSN_LABEL(lab)  LABEL_dupn_##lab
01008   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01009   USAGE_ANALYSIS_INSN(BIN(dupn));
01010   USAGE_ANALYSIS_OPERAND(BIN(dupn), 0, n);
01011 {
01012 #line 663 "insns.def"
01013     rb_num_t i;
01014     VALUE *sp = STACK_ADDR_FROM_TOP(n);
01015     for (i = 0; i < n; i++) {
01016         GET_SP()[i] = sp[i];
01017     }
01018     INC_SP(n);
01019 
01020 #line 1021 "vm.inc"
01021 #undef CURRENT_INSN_dupn
01022 #undef INSN_IS_SC
01023 #undef INSN_LABEL
01024 #undef LABEL_IS_SC
01025   END_INSN(dupn);}}}
01026 INSN_ENTRY(swap){
01027 {
01028 
01029   VALUE val = TOPN(1);
01030   VALUE obj = TOPN(0);
01031   DEBUG_ENTER_INSN("swap");
01032   ADD_PC(1+0);
01033   PREFETCH(GET_PC());
01034   POPN(2);
01035   #define CURRENT_INSN_swap 1
01036   #define INSN_IS_SC()     0
01037   #define INSN_LABEL(lab)  LABEL_swap_##lab
01038   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01039   USAGE_ANALYSIS_INSN(BIN(swap));
01040 {
01041 #line 683 "insns.def"
01042     /* none */
01043 
01044 #line 1045 "vm.inc"
01045   CHECK_STACK_OVERFLOW(REG_CFP, 2);
01046   PUSH(obj);
01047   PUSH(val);
01048 #undef CURRENT_INSN_swap
01049 #undef INSN_IS_SC
01050 #undef INSN_LABEL
01051 #undef LABEL_IS_SC
01052   END_INSN(swap);}}}
01053 INSN_ENTRY(reput){
01054 {
01055 
01056   VALUE val = TOPN(0);
01057   DEBUG_ENTER_INSN("reput");
01058   ADD_PC(1+0);
01059   PREFETCH(GET_PC());
01060   POPN(1);
01061   #define CURRENT_INSN_reput 1
01062   #define INSN_IS_SC()     0
01063   #define INSN_LABEL(lab)  LABEL_reput_##lab
01064   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01065   USAGE_ANALYSIS_INSN(BIN(reput));
01066 {
01067 #line 697 "insns.def"
01068     /* none */
01069 
01070 #line 1071 "vm.inc"
01071   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01072   PUSH(val);
01073 #undef CURRENT_INSN_reput
01074 #undef INSN_IS_SC
01075 #undef INSN_LABEL
01076 #undef LABEL_IS_SC
01077   END_INSN(reput);}}}
01078 INSN_ENTRY(topn){
01079 {
01080   VALUE val;
01081   rb_num_t n = (rb_num_t)GET_OPERAND(1);
01082 
01083   DEBUG_ENTER_INSN("topn");
01084   ADD_PC(1+1);
01085   PREFETCH(GET_PC());
01086   #define CURRENT_INSN_topn 1
01087   #define INSN_IS_SC()     0
01088   #define INSN_LABEL(lab)  LABEL_topn_##lab
01089   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01090   USAGE_ANALYSIS_INSN(BIN(topn));
01091   USAGE_ANALYSIS_OPERAND(BIN(topn), 0, n);
01092 {
01093 #line 711 "insns.def"
01094     val = TOPN(n);
01095 
01096 #line 1097 "vm.inc"
01097   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01098   PUSH(val);
01099 #undef CURRENT_INSN_topn
01100 #undef INSN_IS_SC
01101 #undef INSN_LABEL
01102 #undef LABEL_IS_SC
01103   END_INSN(topn);}}}
01104 INSN_ENTRY(setn){
01105 {
01106   rb_num_t n = (rb_num_t)GET_OPERAND(1);
01107   VALUE val = TOPN(0);
01108   DEBUG_ENTER_INSN("setn");
01109   ADD_PC(1+1);
01110   PREFETCH(GET_PC());
01111   POPN(1);
01112   #define CURRENT_INSN_setn 1
01113   #define INSN_IS_SC()     0
01114   #define INSN_LABEL(lab)  LABEL_setn_##lab
01115   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01116   USAGE_ANALYSIS_INSN(BIN(setn));
01117   USAGE_ANALYSIS_OPERAND(BIN(setn), 0, n);
01118 {
01119 #line 725 "insns.def"
01120     TOPN(n-1) = val;
01121 
01122 #line 1123 "vm.inc"
01123   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01124   PUSH(val);
01125 #undef CURRENT_INSN_setn
01126 #undef INSN_IS_SC
01127 #undef INSN_LABEL
01128 #undef LABEL_IS_SC
01129   END_INSN(setn);}}}
01130 INSN_ENTRY(adjuststack){
01131 {
01132   rb_num_t n = (rb_num_t)GET_OPERAND(1);
01133 
01134   DEBUG_ENTER_INSN("adjuststack");
01135   ADD_PC(1+1);
01136   PREFETCH(GET_PC());
01137   #define CURRENT_INSN_adjuststack 1
01138   #define INSN_IS_SC()     0
01139   #define INSN_LABEL(lab)  LABEL_adjuststack_##lab
01140   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01141   USAGE_ANALYSIS_INSN(BIN(adjuststack));
01142   USAGE_ANALYSIS_OPERAND(BIN(adjuststack), 0, n);
01143 {
01144 #line 739 "insns.def"
01145     DEC_SP(n);
01146 
01147 #line 1148 "vm.inc"
01148 #undef CURRENT_INSN_adjuststack
01149 #undef INSN_IS_SC
01150 #undef INSN_LABEL
01151 #undef LABEL_IS_SC
01152   END_INSN(adjuststack);}}}
01153 INSN_ENTRY(defined){
01154 {
01155   VALUE val;
01156   VALUE needstr = (VALUE)GET_OPERAND(3);
01157   VALUE obj = (VALUE)GET_OPERAND(2);
01158   rb_num_t op_type = (rb_num_t)GET_OPERAND(1);
01159   VALUE v = TOPN(0);
01160   DEBUG_ENTER_INSN("defined");
01161   ADD_PC(1+3);
01162   PREFETCH(GET_PC());
01163   POPN(1);
01164   #define CURRENT_INSN_defined 1
01165   #define INSN_IS_SC()     0
01166   #define INSN_LABEL(lab)  LABEL_defined_##lab
01167   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01168   USAGE_ANALYSIS_INSN(BIN(defined));
01169   USAGE_ANALYSIS_OPERAND(BIN(defined), 0, op_type);
01170   USAGE_ANALYSIS_OPERAND(BIN(defined), 1, obj);
01171   USAGE_ANALYSIS_OPERAND(BIN(defined), 2, needstr);
01172 {
01173 #line 758 "insns.def"
01174     VALUE klass;
01175     const char *expr_type = 0;
01176     enum defined_type type = (enum defined_type)op_type;
01177 
01178     val = Qnil;
01179 
01180     switch (type) {
01181       case DEFINED_IVAR:
01182         if (rb_ivar_defined(GET_SELF(), SYM2ID(obj))) {
01183             expr_type = "instance-variable";
01184         }
01185         break;
01186       case DEFINED_IVAR2:
01187         klass = vm_get_cbase(GET_ISEQ(), GET_LFP(), GET_DFP());
01188         break;
01189       case DEFINED_GVAR:
01190         if (rb_gvar_defined(rb_global_entry(SYM2ID(obj)))) {
01191             expr_type = "global-variable";
01192         }
01193         break;
01194       case DEFINED_CVAR:
01195         {
01196         NODE *cref = vm_get_cref(GET_ISEQ(), GET_LFP(), GET_DFP());
01197         klass = vm_get_cvar_base(cref);
01198         if (rb_cvar_defined(klass, SYM2ID(obj))) {
01199             expr_type = "class variable";
01200         }
01201         break;
01202         }
01203       case DEFINED_CONST:
01204         klass = v;
01205         if (vm_get_ev_const(th, GET_ISEQ(), klass, SYM2ID(obj), 1)) {
01206             expr_type = "constant";
01207         }
01208         break;
01209       case DEFINED_FUNC:
01210         klass = CLASS_OF(v);
01211         if (rb_method_boundp(klass, SYM2ID(obj), 0)) {
01212             expr_type = "method";
01213         }
01214         break;
01215       case DEFINED_METHOD:{
01216         VALUE klass = CLASS_OF(v);
01217         const rb_method_entry_t *me = rb_method_entry(klass, SYM2ID(obj));
01218 
01219         if (me) {
01220             if (!(me->flag & NOEX_PRIVATE)) {
01221                 if (!((me->flag & NOEX_PROTECTED) &&
01222                       !rb_obj_is_kind_of(GET_SELF(),
01223                                          rb_class_real(klass)))) {
01224                     expr_type = "method";
01225                 }
01226             }
01227         }
01228         {
01229             VALUE args[2];
01230             VALUE r;
01231 
01232             args[0] = obj; args[1] = Qfalse;
01233             r = rb_check_funcall(v, rb_intern("respond_to_missing?"), 2, args);
01234             if (r != Qundef && RTEST(r)) 
01235                 expr_type = "method";
01236         }
01237         break;
01238       }
01239       case DEFINED_YIELD:
01240         if (GET_BLOCK_PTR()) {
01241             expr_type = "yield";
01242         }
01243         break;
01244       case DEFINED_ZSUPER:{
01245         rb_iseq_t *iseq = GET_ISEQ();
01246         while (iseq) {
01247             if (iseq->defined_method_id) {
01248                 break;
01249             }
01250             iseq = iseq->parent_iseq;
01251         }
01252         if (iseq) {
01253             VALUE klass = vm_search_normal_superclass(iseq->klass, GET_SELF());
01254             if (rb_method_boundp(klass, iseq->defined_method_id, 0)) {
01255                 expr_type = "super";
01256             }
01257         }
01258         break;
01259       }
01260       case DEFINED_REF:{
01261         val = vm_getspecial(th, GET_LFP(), Qfalse, FIX2INT(obj));
01262         if (val != Qnil) {
01263             expr_type = "global-variable";
01264         }
01265         break;
01266       }
01267       default:
01268         rb_bug("unimplemented defined? type (VM)");
01269         break;
01270     }
01271     if (expr_type != 0) {
01272         if (needstr != Qfalse) {
01273             val = rb_str_new2(expr_type);
01274         }
01275         else {
01276             val = Qtrue;
01277         }
01278     }
01279 
01280 #line 1281 "vm.inc"
01281   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01282   PUSH(val);
01283 #undef CURRENT_INSN_defined
01284 #undef INSN_IS_SC
01285 #undef INSN_LABEL
01286 #undef LABEL_IS_SC
01287   END_INSN(defined);}}}
01288 INSN_ENTRY(trace){
01289 {
01290   rb_num_t nf = (rb_num_t)GET_OPERAND(1);
01291 
01292   DEBUG_ENTER_INSN("trace");
01293   ADD_PC(1+1);
01294   PREFETCH(GET_PC());
01295   #define CURRENT_INSN_trace 1
01296   #define INSN_IS_SC()     0
01297   #define INSN_LABEL(lab)  LABEL_trace_##lab
01298   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01299   USAGE_ANALYSIS_INSN(BIN(trace));
01300   USAGE_ANALYSIS_OPERAND(BIN(trace), 0, nf);
01301 {
01302 #line 876 "insns.def"
01303     rb_event_flag_t flag = (rb_event_flag_t)nf;
01304 
01305     EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0 /* TODO: id, klass */);
01306 
01307 #line 1308 "vm.inc"
01308 #undef CURRENT_INSN_trace
01309 #undef INSN_IS_SC
01310 #undef INSN_LABEL
01311 #undef LABEL_IS_SC
01312   END_INSN(trace);}}}
01313 INSN_ENTRY(defineclass){
01314 {
01315   VALUE val;
01316   rb_num_t define_type = (rb_num_t)GET_OPERAND(3);
01317   ISEQ class_iseq = (ISEQ)GET_OPERAND(2);
01318   ID id = (ID)GET_OPERAND(1);
01319   VALUE cbase = TOPN(1);
01320   VALUE super = TOPN(0);
01321   DEBUG_ENTER_INSN("defineclass");
01322   ADD_PC(1+3);
01323   PREFETCH(GET_PC());
01324   POPN(2);
01325   #define CURRENT_INSN_defineclass 1
01326   #define INSN_IS_SC()     0
01327   #define INSN_LABEL(lab)  LABEL_defineclass_##lab
01328   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01329   USAGE_ANALYSIS_INSN(BIN(defineclass));
01330   USAGE_ANALYSIS_OPERAND(BIN(defineclass), 0, id);
01331   USAGE_ANALYSIS_OPERAND(BIN(defineclass), 1, class_iseq);
01332   USAGE_ANALYSIS_OPERAND(BIN(defineclass), 2, define_type);
01333 {
01334 #line 900 "insns.def"
01335     VALUE klass;
01336 
01337     switch ((int)define_type) {
01338       case 0: /* scoped:   class Foo::Bar */
01339       case 3: /* no scope: class Bar */
01340         /* val is dummy.  classdef returns class scope value */
01341 
01342         if (super == Qnil) {
01343             super = rb_cObject;
01344         }
01345 
01346         vm_check_if_namespace(cbase);
01347 
01348         /* find klass */
01349         rb_autoload_load(cbase, id);
01350         if ((klass = vm_search_const_defined_class(cbase, id)) != 0) {
01351             /* already exist */
01352             klass = define_type == 0 ? rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id);
01353             if (TYPE(klass) != T_CLASS) {
01354                 rb_raise(rb_eTypeError, "%s is not a class", rb_id2name(id));
01355             }
01356 
01357             if (super != rb_cObject) {
01358                 VALUE tmp;
01359                 tmp = rb_class_real(RCLASS_SUPER(klass));
01360 
01361                 if (tmp != super) {
01362                     rb_raise(rb_eTypeError, "superclass mismatch for class %s",
01363                              rb_id2name(id));
01364                 }
01365             }
01366         }
01367         else {
01368             /* new class declaration */
01369             klass = rb_define_class_id(id, super);
01370             rb_set_class_path_string(klass, cbase, rb_id2str(id));
01371             rb_const_set(cbase, id, klass);
01372             rb_class_inherited(super, klass);
01373         }
01374         break;
01375       case 1:
01376         /* val is dummy.  classdef returns class scope value */
01377         /* super is dummy */
01378         klass = rb_singleton_class(cbase);
01379         break;
01380       case 2: /* scoped:   module Foo::Bar  or  module ::Bar */
01381       case 5: /* no scope: module Bar */
01382         /* val is dummy.  classdef returns class scope value */
01383         /* super is dummy */
01384 
01385         vm_check_if_namespace(cbase);
01386 
01387         /* find klass */
01388         if ((klass = vm_search_const_defined_class(cbase, id)) != 0) {
01389             klass = define_type == 2 ? rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id);
01390             /* already exist */
01391             if (TYPE(klass) != T_MODULE) {
01392                 rb_raise(rb_eTypeError, "%s is not a module", rb_id2name(id));
01393             }
01394         }
01395         else {
01396             /* new module declaration */
01397             klass = rb_define_module_id(id);
01398             rb_set_class_path_string(klass, cbase, rb_id2str(id));
01399             rb_const_set(cbase, id, klass);
01400         }
01401         break;
01402       default:
01403         rb_bug("unknown defineclass type: %d", (int)define_type);
01404     }
01405 
01406     COPY_CREF(class_iseq->cref_stack, vm_cref_push(th, klass, NOEX_PUBLIC, NULL));
01407 
01408     /* enter scope */
01409     vm_push_frame(th, class_iseq,
01410                   VM_FRAME_MAGIC_CLASS, klass, (VALUE) GET_BLOCK_PTR(),
01411                   class_iseq->iseq_encoded, GET_SP(), 0,
01412                   class_iseq->local_size);
01413     RESTORE_REGS();
01414 
01415     INC_VM_STATE_VERSION();
01416     NEXT_INSN();
01417 
01418 #line 1419 "vm.inc"
01419   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01420   PUSH(val);
01421 #undef CURRENT_INSN_defineclass
01422 #undef INSN_IS_SC
01423 #undef INSN_LABEL
01424 #undef LABEL_IS_SC
01425   END_INSN(defineclass);}}}
01426 INSN_ENTRY(send){
01427 {
01428   VALUE val;
01429   IC ic = (IC)GET_OPERAND(5);
01430   rb_num_t op_flag = (rb_num_t)GET_OPERAND(4);
01431   ISEQ blockiseq = (ISEQ)GET_OPERAND(3);
01432   rb_num_t op_argc = (rb_num_t)GET_OPERAND(2);
01433   ID op_id = (ID)GET_OPERAND(1);
01434 
01435   DEBUG_ENTER_INSN("send");
01436   ADD_PC(1+5);
01437   PREFETCH(GET_PC());
01438   #define CURRENT_INSN_send 1
01439   #define INSN_IS_SC()     0
01440   #define INSN_LABEL(lab)  LABEL_send_##lab
01441   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01442   USAGE_ANALYSIS_INSN(BIN(send));
01443   USAGE_ANALYSIS_OPERAND(BIN(send), 0, op_id);
01444   USAGE_ANALYSIS_OPERAND(BIN(send), 1, op_argc);
01445   USAGE_ANALYSIS_OPERAND(BIN(send), 2, blockiseq);
01446   USAGE_ANALYSIS_OPERAND(BIN(send), 3, op_flag);
01447   USAGE_ANALYSIS_OPERAND(BIN(send), 4, ic);
01448 {
01449 #line 1006 "insns.def"
01450     const rb_method_entry_t *me;
01451     VALUE recv, klass;
01452     rb_block_t *blockptr = 0;
01453     VALUE flag = op_flag;
01454     int num = caller_setup_args(th, GET_CFP(), flag, (int)op_argc,
01455                                 (rb_iseq_t *)blockiseq, &blockptr);
01456     ID id = op_id;
01457 
01458     /* get receiver */
01459     recv = TOPN(num);
01460     klass = CLASS_OF(recv);
01461     me = vm_method_search(id, klass, ic);
01462     CALL_METHOD(num, blockptr, flag, id, me, recv);
01463 
01464 #line 1465 "vm.inc"
01465   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01466   PUSH(val);
01467 #undef CURRENT_INSN_send
01468 #undef INSN_IS_SC
01469 #undef INSN_LABEL
01470 #undef LABEL_IS_SC
01471   END_INSN(send);}}}
01472 INSN_ENTRY(invokesuper){
01473 {
01474   VALUE val;
01475   rb_num_t op_flag = (rb_num_t)GET_OPERAND(3);
01476   ISEQ blockiseq = (ISEQ)GET_OPERAND(2);
01477   rb_num_t op_argc = (rb_num_t)GET_OPERAND(1);
01478 
01479   DEBUG_ENTER_INSN("invokesuper");
01480   ADD_PC(1+3);
01481   PREFETCH(GET_PC());
01482   #define CURRENT_INSN_invokesuper 1
01483   #define INSN_IS_SC()     0
01484   #define INSN_LABEL(lab)  LABEL_invokesuper_##lab
01485   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01486   USAGE_ANALYSIS_INSN(BIN(invokesuper));
01487   USAGE_ANALYSIS_OPERAND(BIN(invokesuper), 0, op_argc);
01488   USAGE_ANALYSIS_OPERAND(BIN(invokesuper), 1, blockiseq);
01489   USAGE_ANALYSIS_OPERAND(BIN(invokesuper), 2, op_flag);
01490 {
01491 #line 1034 "insns.def"
01492     rb_block_t *blockptr = !(op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? GET_BLOCK_PTR() : 0;
01493     VALUE flag = op_flag;
01494     int num = caller_setup_args(th, GET_CFP(), flag,
01495                                 (int)op_argc, blockiseq, &blockptr);
01496     VALUE recv, klass;
01497     ID id;
01498     const rb_method_entry_t *me;
01499 
01500     flag = VM_CALL_SUPER_BIT | VM_CALL_FCALL_BIT;
01501 
01502     recv = GET_SELF();
01503     vm_search_superclass(GET_CFP(), GET_ISEQ(), recv, TOPN(num), &id, &klass);
01504 
01505     /* temporary measure for [Bug #2402] [Bug #2502] [Bug #3136] */
01506     if (!rb_obj_is_kind_of(recv, klass)) {
01507         rb_raise(rb_eNotImpError, "super from singleton method that is defined to multiple classes is not supported; this will be fixed in 1.9.3 or later");
01508     }
01509 
01510     me = rb_method_entry(klass, id);
01511 
01512     CALL_METHOD(num, blockptr, flag, id, me, recv);
01513 
01514 #line 1515 "vm.inc"
01515   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01516   PUSH(val);
01517 #undef CURRENT_INSN_invokesuper
01518 #undef INSN_IS_SC
01519 #undef INSN_LABEL
01520 #undef LABEL_IS_SC
01521   END_INSN(invokesuper);}}}
01522 INSN_ENTRY(invokeblock){
01523 {
01524   VALUE val;
01525   rb_num_t flag = (rb_num_t)GET_OPERAND(2);
01526   rb_num_t num = (rb_num_t)GET_OPERAND(1);
01527 
01528   DEBUG_ENTER_INSN("invokeblock");
01529   ADD_PC(1+2);
01530   PREFETCH(GET_PC());
01531   #define CURRENT_INSN_invokeblock 1
01532   #define INSN_IS_SC()     0
01533   #define INSN_LABEL(lab)  LABEL_invokeblock_##lab
01534   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01535   USAGE_ANALYSIS_INSN(BIN(invokeblock));
01536   USAGE_ANALYSIS_OPERAND(BIN(invokeblock), 0, num);
01537   USAGE_ANALYSIS_OPERAND(BIN(invokeblock), 1, flag);
01538 {
01539 #line 1069 "insns.def"
01540     val = vm_invoke_block(th, GET_CFP(), num, flag);
01541     if (val == Qundef) {
01542         RESTORE_REGS();
01543         NEXT_INSN();
01544     }
01545 
01546 #line 1547 "vm.inc"
01547   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01548   PUSH(val);
01549 #undef CURRENT_INSN_invokeblock
01550 #undef INSN_IS_SC
01551 #undef INSN_LABEL
01552 #undef LABEL_IS_SC
01553   END_INSN(invokeblock);}}}
01554 INSN_ENTRY(leave){
01555 {
01556 
01557   VALUE val = TOPN(0);
01558   DEBUG_ENTER_INSN("leave");
01559   ADD_PC(1+0);
01560   PREFETCH(GET_PC());
01561   POPN(1);
01562   #define CURRENT_INSN_leave 1
01563   #define INSN_IS_SC()     0
01564   #define INSN_LABEL(lab)  LABEL_leave_##lab
01565   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01566   USAGE_ANALYSIS_INSN(BIN(leave));
01567 {
01568 #line 1087 "insns.def"
01569     if (OPT_CHECKED_RUN) {
01570         if (reg_cfp->sp != reg_cfp->bp) {
01571             rb_bug("Stack consistency error (sp: %"PRIdPTRDIFF", bp: %"PRIdPTRDIFF")",
01572                    VM_SP_CNT(th, reg_cfp->sp), VM_SP_CNT(th, reg_cfp->bp));
01573         }
01574     }
01575 
01576     RUBY_VM_CHECK_INTS();
01577     vm_pop_frame(th);
01578     RESTORE_REGS();
01579 
01580 #line 1581 "vm.inc"
01581   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01582   PUSH(val);
01583 #undef CURRENT_INSN_leave
01584 #undef INSN_IS_SC
01585 #undef INSN_LABEL
01586 #undef LABEL_IS_SC
01587   END_INSN(leave);}}}
01588 INSN_ENTRY(finish){
01589 {
01590 
01591   VALUE val = TOPN(0);
01592   DEBUG_ENTER_INSN("finish");
01593   ADD_PC(1+0);
01594   PREFETCH(GET_PC());
01595   POPN(1);
01596   #define CURRENT_INSN_finish 1
01597   #define INSN_IS_SC()     0
01598   #define INSN_LABEL(lab)  LABEL_finish_##lab
01599   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01600   USAGE_ANALYSIS_INSN(BIN(finish));
01601 {
01602 #line 1110 "insns.def"
01603 #if OPT_CALL_THREADED_CODE
01604     rb_bug("unused instruction on OPT_CALL_THREADED_CODE");
01605 #else
01606     th->cfp++;
01607     return val;
01608 #endif
01609 
01610 #line 1611 "vm.inc"
01611   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01612   PUSH(val);
01613 #undef CURRENT_INSN_finish
01614 #undef INSN_IS_SC
01615 #undef INSN_LABEL
01616 #undef LABEL_IS_SC
01617   END_INSN(finish);}}}
01618 INSN_ENTRY(throw){
01619 {
01620   VALUE val;
01621   rb_num_t throw_state = (rb_num_t)GET_OPERAND(1);
01622   VALUE throwobj = TOPN(0);
01623   DEBUG_ENTER_INSN("throw");
01624   ADD_PC(1+1);
01625   PREFETCH(GET_PC());
01626   POPN(1);
01627   #define CURRENT_INSN_throw 1
01628   #define INSN_IS_SC()     0
01629   #define INSN_LABEL(lab)  LABEL_throw_##lab
01630   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01631   USAGE_ANALYSIS_INSN(BIN(throw));
01632   USAGE_ANALYSIS_OPERAND(BIN(throw), 0, throw_state);
01633 {
01634 #line 1133 "insns.def"
01635     RUBY_VM_CHECK_INTS();
01636     val = vm_throw(th, GET_CFP(), throw_state, throwobj);
01637     THROW_EXCEPTION(val);
01638     /* unreachable */
01639 
01640 #line 1641 "vm.inc"
01641   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01642   PUSH(val);
01643 #undef CURRENT_INSN_throw
01644 #undef INSN_IS_SC
01645 #undef INSN_LABEL
01646 #undef LABEL_IS_SC
01647   END_INSN(throw);}}}
01648 INSN_ENTRY(jump){
01649 {
01650   OFFSET dst = (OFFSET)GET_OPERAND(1);
01651 
01652   DEBUG_ENTER_INSN("jump");
01653   ADD_PC(1+1);
01654   PREFETCH(GET_PC());
01655   #define CURRENT_INSN_jump 1
01656   #define INSN_IS_SC()     0
01657   #define INSN_LABEL(lab)  LABEL_jump_##lab
01658   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01659   USAGE_ANALYSIS_INSN(BIN(jump));
01660   USAGE_ANALYSIS_OPERAND(BIN(jump), 0, dst);
01661 {
01662 #line 1154 "insns.def"
01663     RUBY_VM_CHECK_INTS();
01664     JUMP(dst);
01665 
01666 #line 1667 "vm.inc"
01667 #undef CURRENT_INSN_jump
01668 #undef INSN_IS_SC
01669 #undef INSN_LABEL
01670 #undef LABEL_IS_SC
01671   END_INSN(jump);}}}
01672 INSN_ENTRY(branchif){
01673 {
01674   OFFSET dst = (OFFSET)GET_OPERAND(1);
01675   VALUE val = TOPN(0);
01676   DEBUG_ENTER_INSN("branchif");
01677   ADD_PC(1+1);
01678   PREFETCH(GET_PC());
01679   POPN(1);
01680   #define CURRENT_INSN_branchif 1
01681   #define INSN_IS_SC()     0
01682   #define INSN_LABEL(lab)  LABEL_branchif_##lab
01683   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01684   USAGE_ANALYSIS_INSN(BIN(branchif));
01685   USAGE_ANALYSIS_OPERAND(BIN(branchif), 0, dst);
01686 {
01687 #line 1169 "insns.def"
01688     if (RTEST(val)) {
01689         RUBY_VM_CHECK_INTS();
01690         JUMP(dst);
01691     }
01692 
01693 #line 1694 "vm.inc"
01694 #undef CURRENT_INSN_branchif
01695 #undef INSN_IS_SC
01696 #undef INSN_LABEL
01697 #undef LABEL_IS_SC
01698   END_INSN(branchif);}}}
01699 INSN_ENTRY(branchunless){
01700 {
01701   OFFSET dst = (OFFSET)GET_OPERAND(1);
01702   VALUE val = TOPN(0);
01703   DEBUG_ENTER_INSN("branchunless");
01704   ADD_PC(1+1);
01705   PREFETCH(GET_PC());
01706   POPN(1);
01707   #define CURRENT_INSN_branchunless 1
01708   #define INSN_IS_SC()     0
01709   #define INSN_LABEL(lab)  LABEL_branchunless_##lab
01710   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01711   USAGE_ANALYSIS_INSN(BIN(branchunless));
01712   USAGE_ANALYSIS_OPERAND(BIN(branchunless), 0, dst);
01713 {
01714 #line 1186 "insns.def"
01715     if (!RTEST(val)) {
01716         RUBY_VM_CHECK_INTS();
01717         JUMP(dst);
01718     }
01719 
01720 #line 1721 "vm.inc"
01721 #undef CURRENT_INSN_branchunless
01722 #undef INSN_IS_SC
01723 #undef INSN_LABEL
01724 #undef LABEL_IS_SC
01725   END_INSN(branchunless);}}}
01726 INSN_ENTRY(getinlinecache){
01727 {
01728   VALUE val;
01729   IC ic = (IC)GET_OPERAND(2);
01730   OFFSET dst = (OFFSET)GET_OPERAND(1);
01731 
01732   DEBUG_ENTER_INSN("getinlinecache");
01733   ADD_PC(1+2);
01734   PREFETCH(GET_PC());
01735   #define CURRENT_INSN_getinlinecache 1
01736   #define INSN_IS_SC()     0
01737   #define INSN_LABEL(lab)  LABEL_getinlinecache_##lab
01738   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01739   USAGE_ANALYSIS_INSN(BIN(getinlinecache));
01740   USAGE_ANALYSIS_OPERAND(BIN(getinlinecache), 0, dst);
01741   USAGE_ANALYSIS_OPERAND(BIN(getinlinecache), 1, ic);
01742 {
01743 #line 1208 "insns.def"
01744     if (ic->ic_vmstat == GET_VM_STATE_VERSION()) {
01745         val = ic->ic_value.value;
01746         JUMP(dst);
01747     }
01748     else {
01749         /* none */
01750         val = Qnil;
01751     }
01752 
01753 #line 1754 "vm.inc"
01754   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01755   PUSH(val);
01756 #undef CURRENT_INSN_getinlinecache
01757 #undef INSN_IS_SC
01758 #undef INSN_LABEL
01759 #undef LABEL_IS_SC
01760   END_INSN(getinlinecache);}}}
01761 INSN_ENTRY(onceinlinecache){
01762 {
01763   VALUE val;
01764   IC ic = (IC)GET_OPERAND(2);
01765   OFFSET dst = (OFFSET)GET_OPERAND(1);
01766 
01767   DEBUG_ENTER_INSN("onceinlinecache");
01768   ADD_PC(1+2);
01769   PREFETCH(GET_PC());
01770   #define CURRENT_INSN_onceinlinecache 1
01771   #define INSN_IS_SC()     0
01772   #define INSN_LABEL(lab)  LABEL_onceinlinecache_##lab
01773   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01774   USAGE_ANALYSIS_INSN(BIN(onceinlinecache));
01775   USAGE_ANALYSIS_OPERAND(BIN(onceinlinecache), 0, dst);
01776   USAGE_ANALYSIS_OPERAND(BIN(onceinlinecache), 1, ic);
01777 {
01778 #line 1229 "insns.def"
01779   retry:
01780     if (ic->ic_vmstat) {
01781         val = ic->ic_value.value;
01782         JUMP(dst);
01783     }
01784     else if (ic->ic_value.value == Qundef)
01785     {
01786         RUBY_VM_CHECK_INTS();
01787         rb_thread_schedule();
01788         goto retry;
01789     }
01790     else {
01791         /* none */
01792         ic->ic_value.value = Qundef;
01793         val = Qnil;
01794     }
01795 
01796 #line 1797 "vm.inc"
01797   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01798   PUSH(val);
01799 #undef CURRENT_INSN_onceinlinecache
01800 #undef INSN_IS_SC
01801 #undef INSN_LABEL
01802 #undef LABEL_IS_SC
01803   END_INSN(onceinlinecache);}}}
01804 INSN_ENTRY(setinlinecache){
01805 {
01806   IC ic = (IC)GET_OPERAND(1);
01807   VALUE val = TOPN(0);
01808   DEBUG_ENTER_INSN("setinlinecache");
01809   ADD_PC(1+1);
01810   PREFETCH(GET_PC());
01811   POPN(1);
01812   #define CURRENT_INSN_setinlinecache 1
01813   #define INSN_IS_SC()     0
01814   #define INSN_LABEL(lab)  LABEL_setinlinecache_##lab
01815   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01816   USAGE_ANALYSIS_INSN(BIN(setinlinecache));
01817   USAGE_ANALYSIS_OPERAND(BIN(setinlinecache), 0, ic);
01818 {
01819 #line 1258 "insns.def"
01820     if (ic->ic_value.value == Qundef) {
01821         rb_ary_push(GET_ISEQ()->mark_ary, val);
01822     }
01823     ic->ic_value.value = val;
01824     ic->ic_vmstat = GET_VM_STATE_VERSION() - ruby_vm_const_missing_count;
01825     ruby_vm_const_missing_count = 0;
01826 
01827 #line 1828 "vm.inc"
01828   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01829   PUSH(val);
01830 #undef CURRENT_INSN_setinlinecache
01831 #undef INSN_IS_SC
01832 #undef INSN_LABEL
01833 #undef LABEL_IS_SC
01834   END_INSN(setinlinecache);}}}
01835 INSN_ENTRY(opt_case_dispatch){
01836 {
01837   OFFSET else_offset = (OFFSET)GET_OPERAND(2);
01838   CDHASH hash = (CDHASH)GET_OPERAND(1);
01839   VALUE key = TOPN(0);
01840   DEBUG_ENTER_INSN("opt_case_dispatch");
01841   ADD_PC(1+2);
01842   PREFETCH(GET_PC());
01843   POPN(1);
01844   #define CURRENT_INSN_opt_case_dispatch 1
01845   #define INSN_IS_SC()     0
01846   #define INSN_LABEL(lab)  LABEL_opt_case_dispatch_##lab
01847   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01848   USAGE_ANALYSIS_INSN(BIN(opt_case_dispatch));
01849   USAGE_ANALYSIS_OPERAND(BIN(opt_case_dispatch), 0, hash);
01850   USAGE_ANALYSIS_OPERAND(BIN(opt_case_dispatch), 1, else_offset);
01851 {
01852 #line 1277 "insns.def"
01853     switch(TYPE(key)) {
01854       case T_FLOAT: {
01855         double ival;
01856         if (modf(RFLOAT_VALUE(key), &ival) == 0.0) {
01857             key = FIXABLE(ival) ? LONG2FIX((long)ival) : rb_dbl2big(ival);
01858         }
01859       }
01860       case T_SYMBOL: /* fall through */
01861       case T_FIXNUM:
01862       case T_BIGNUM:
01863       case T_STRING:
01864         if (BASIC_OP_UNREDEFINED_P(BOP_EQQ)) {
01865             st_data_t val;
01866             if (st_lookup(RHASH_TBL(hash), key, &val)) {
01867                 JUMP(FIX2INT((VALUE)val));
01868             }
01869             else {
01870                 JUMP(else_offset);
01871             }
01872             break;
01873         }
01874       default:
01875         break;
01876     }
01877 
01878 #line 1879 "vm.inc"
01879 #undef CURRENT_INSN_opt_case_dispatch
01880 #undef INSN_IS_SC
01881 #undef INSN_LABEL
01882 #undef LABEL_IS_SC
01883   END_INSN(opt_case_dispatch);}}}
01884 INSN_ENTRY(opt_checkenv){
01885 {
01886 
01887 
01888   DEBUG_ENTER_INSN("opt_checkenv");
01889   ADD_PC(1+0);
01890   PREFETCH(GET_PC());
01891   #define CURRENT_INSN_opt_checkenv 1
01892   #define INSN_IS_SC()     0
01893   #define INSN_LABEL(lab)  LABEL_opt_checkenv_##lab
01894   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01895   USAGE_ANALYSIS_INSN(BIN(opt_checkenv));
01896 {
01897 #line 1314 "insns.def"
01898     if (GET_CFP()->bp != GET_DFP() + 1) {
01899         VALUE *new_dfp = GET_CFP()->bp - 1;
01900         /* TODO: copy env and clean stack at creating env? */
01901         *new_dfp = *GET_DFP();
01902         SET_DFP(new_dfp);
01903     }
01904 
01905 #line 1906 "vm.inc"
01906 #undef CURRENT_INSN_opt_checkenv
01907 #undef INSN_IS_SC
01908 #undef INSN_LABEL
01909 #undef LABEL_IS_SC
01910   END_INSN(opt_checkenv);}}}
01911 INSN_ENTRY(opt_plus){
01912 {
01913   VALUE val;
01914   IC ic = (IC)GET_OPERAND(1);
01915   VALUE recv = TOPN(1);
01916   VALUE obj = TOPN(0);
01917   DEBUG_ENTER_INSN("opt_plus");
01918   ADD_PC(1+1);
01919   PREFETCH(GET_PC());
01920   POPN(2);
01921   #define CURRENT_INSN_opt_plus 1
01922   #define INSN_IS_SC()     0
01923   #define INSN_LABEL(lab)  LABEL_opt_plus_##lab
01924   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01925   USAGE_ANALYSIS_INSN(BIN(opt_plus));
01926   USAGE_ANALYSIS_OPERAND(BIN(opt_plus), 0, ic);
01927 {
01928 #line 1336 "insns.def"
01929     if (0) {
01930 
01931     }
01932 #if 1
01933     else if (FIXNUM_2_P(recv, obj) &&
01934              BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
01935         /* fixnum + fixnum */
01936 #ifndef LONG_LONG_VALUE
01937         val = (recv + (obj & (~1)));
01938         if ((~(recv ^ obj) & (recv ^ val)) &
01939             ((VALUE)0x01 << ((sizeof(VALUE) * CHAR_BIT) - 1))) {
01940             val = rb_big_plus(rb_int2big(FIX2LONG(recv)),
01941                               rb_int2big(FIX2LONG(obj)));
01942         }
01943 #else
01944         long a, b, c;
01945         a = FIX2LONG(recv);
01946         b = FIX2LONG(obj);
01947         c = a + b;
01948         if (FIXABLE(c)) {
01949             val = LONG2FIX(c);
01950         }
01951         else {
01952             val = rb_big_plus(rb_int2big(a), rb_int2big(b));
01953         }
01954 #endif
01955     }
01956 #endif
01957 
01958     else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
01959         if (0) {
01960         }
01961 #if 1
01962         else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
01963                  HEAP_CLASS_OF(obj) == rb_cFloat &&
01964                  BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
01965             val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
01966         }
01967 #endif
01968 
01969 #if 1
01970         else if (HEAP_CLASS_OF(recv) == rb_cString &&
01971                  HEAP_CLASS_OF(obj) == rb_cString &&
01972                  BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
01973             val = rb_str_plus(recv, obj);
01974         }
01975 #endif
01976 #if 1
01977         else if (HEAP_CLASS_OF(recv) == rb_cArray &&
01978                  BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
01979             val = rb_ary_plus(recv, obj);
01980         }
01981 #endif
01982         else {
01983             goto INSN_LABEL(normal_dispatch);
01984         }
01985     }
01986     else {
01987       INSN_LABEL(normal_dispatch):
01988         PUSH(recv);
01989         PUSH(obj);
01990         CALL_SIMPLE_METHOD(1, idPLUS, recv);
01991     }
01992 
01993 #line 1994 "vm.inc"
01994   CHECK_STACK_OVERFLOW(REG_CFP, 1);
01995   PUSH(val);
01996 #undef CURRENT_INSN_opt_plus
01997 #undef INSN_IS_SC
01998 #undef INSN_LABEL
01999 #undef LABEL_IS_SC
02000   END_INSN(opt_plus);}}}
02001 INSN_ENTRY(opt_minus){
02002 {
02003   VALUE val;
02004   IC ic = (IC)GET_OPERAND(1);
02005   VALUE recv = TOPN(1);
02006   VALUE obj = TOPN(0);
02007   DEBUG_ENTER_INSN("opt_minus");
02008   ADD_PC(1+1);
02009   PREFETCH(GET_PC());
02010   POPN(2);
02011   #define CURRENT_INSN_opt_minus 1
02012   #define INSN_IS_SC()     0
02013   #define INSN_LABEL(lab)  LABEL_opt_minus_##lab
02014   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02015   USAGE_ANALYSIS_INSN(BIN(opt_minus));
02016   USAGE_ANALYSIS_OPERAND(BIN(opt_minus), 0, ic);
02017 {
02018 #line 1412 "insns.def"
02019     if (FIXNUM_2_P(recv, obj) &&
02020         BASIC_OP_UNREDEFINED_P(BOP_MINUS)) {
02021         long a, b, c;
02022 
02023         a = FIX2LONG(recv);
02024         b = FIX2LONG(obj);
02025         c = a - b;
02026 
02027         if (FIXABLE(c)) {
02028             val = LONG2FIX(c);
02029         }
02030         else {
02031             val = rb_big_minus(rb_int2big(a), rb_int2big(b));
02032         }
02033     }
02034     else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02035         if (0) {
02036         }
02037 #if 1
02038         else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02039                  HEAP_CLASS_OF(obj) == rb_cFloat  &&
02040                  BASIC_OP_UNREDEFINED_P(BOP_MINUS)) {
02041             val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
02042         }
02043 #endif
02044         else {
02045             goto INSN_LABEL(normal_dispatch);
02046         }
02047     }
02048     else {
02049         /* other */
02050       INSN_LABEL(normal_dispatch):
02051         PUSH(recv);
02052         PUSH(obj);
02053         CALL_SIMPLE_METHOD(1, idMINUS, recv);
02054     }
02055 
02056 #line 2057 "vm.inc"
02057   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02058   PUSH(val);
02059 #undef CURRENT_INSN_opt_minus
02060 #undef INSN_IS_SC
02061 #undef INSN_LABEL
02062 #undef LABEL_IS_SC
02063   END_INSN(opt_minus);}}}
02064 INSN_ENTRY(opt_mult){
02065 {
02066   VALUE val;
02067   IC ic = (IC)GET_OPERAND(1);
02068   VALUE recv = TOPN(1);
02069   VALUE obj = TOPN(0);
02070   DEBUG_ENTER_INSN("opt_mult");
02071   ADD_PC(1+1);
02072   PREFETCH(GET_PC());
02073   POPN(2);
02074   #define CURRENT_INSN_opt_mult 1
02075   #define INSN_IS_SC()     0
02076   #define INSN_LABEL(lab)  LABEL_opt_mult_##lab
02077   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02078   USAGE_ANALYSIS_INSN(BIN(opt_mult));
02079   USAGE_ANALYSIS_OPERAND(BIN(opt_mult), 0, ic);
02080 {
02081 #line 1461 "insns.def"
02082     if (FIXNUM_2_P(recv, obj) &&
02083         BASIC_OP_UNREDEFINED_P(BOP_MULT)) {
02084         long a, b;
02085 
02086         a = FIX2LONG(recv);
02087         if (a == 0) {
02088             val = recv;
02089         }
02090         else {
02091             volatile long c;
02092             b = FIX2LONG(obj);
02093             c = a * b;
02094 
02095             if (FIXABLE(c) && c / a == b) {
02096                 val = LONG2FIX(c);
02097             }
02098             else {
02099                 val = rb_big_mul(rb_int2big(a), rb_int2big(b));
02100             }
02101         }
02102     }
02103     else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02104         if (0) {
02105         }
02106 #if 1
02107         else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02108                  HEAP_CLASS_OF(obj) == rb_cFloat  &&
02109                  BASIC_OP_UNREDEFINED_P(BOP_MULT)) {
02110             val = DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
02111         }
02112 #endif
02113         else {
02114             goto INSN_LABEL(normal_dispatch);
02115         }
02116     }
02117     else {
02118       INSN_LABEL(normal_dispatch):
02119         PUSH(recv);
02120         PUSH(obj);
02121         CALL_SIMPLE_METHOD(1, idMULT, recv);
02122     }
02123 
02124 #line 2125 "vm.inc"
02125   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02126   PUSH(val);
02127 #undef CURRENT_INSN_opt_mult
02128 #undef INSN_IS_SC
02129 #undef INSN_LABEL
02130 #undef LABEL_IS_SC
02131   END_INSN(opt_mult);}}}
02132 INSN_ENTRY(opt_div){
02133 {
02134   VALUE val;
02135   IC ic = (IC)GET_OPERAND(1);
02136   VALUE recv = TOPN(1);
02137   VALUE obj = TOPN(0);
02138   DEBUG_ENTER_INSN("opt_div");
02139   ADD_PC(1+1);
02140   PREFETCH(GET_PC());
02141   POPN(2);
02142   #define CURRENT_INSN_opt_div 1
02143   #define INSN_IS_SC()     0
02144   #define INSN_LABEL(lab)  LABEL_opt_div_##lab
02145   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02146   USAGE_ANALYSIS_INSN(BIN(opt_div));
02147   USAGE_ANALYSIS_OPERAND(BIN(opt_div), 0, ic);
02148 {
02149 #line 1515 "insns.def"
02150     if (FIXNUM_2_P(recv, obj) &&
02151         BASIC_OP_UNREDEFINED_P(BOP_DIV)) {
02152         long x, y, div;
02153 
02154         x = FIX2LONG(recv);
02155         y = FIX2LONG(obj);
02156         {
02157             /* copied from numeric.c#fixdivmod */
02158             long mod;
02159             if (y == 0)
02160                 goto INSN_LABEL(normal_dispatch);
02161             if (y < 0) {
02162                 if (x < 0)
02163                     div = -x / -y;
02164                 else
02165                     div = -(x / -y);
02166             }
02167             else {
02168                 if (x < 0)
02169                     div = -(-x / y);
02170                 else
02171                     div = x / y;
02172             }
02173             mod = x - div * y;
02174             if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) {
02175                 mod += y;
02176                 div -= 1;
02177             }
02178         }
02179         val = LONG2NUM(div);
02180     }
02181     else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02182         if (0) {
02183         }
02184 #if 1
02185         else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02186                  HEAP_CLASS_OF(obj) == rb_cFloat  &&
02187                  BASIC_OP_UNREDEFINED_P(BOP_DIV)) {
02188             val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj));
02189         }
02190 #endif
02191         else {
02192             goto INSN_LABEL(normal_dispatch);
02193         }
02194     }
02195     else {
02196       INSN_LABEL(normal_dispatch):
02197         PUSH(recv);
02198         PUSH(obj);
02199         CALL_SIMPLE_METHOD(1, idDIV, recv);
02200     }
02201 
02202 #line 2203 "vm.inc"
02203   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02204   PUSH(val);
02205 #undef CURRENT_INSN_opt_div
02206 #undef INSN_IS_SC
02207 #undef INSN_LABEL
02208 #undef LABEL_IS_SC
02209   END_INSN(opt_div);}}}
02210 INSN_ENTRY(opt_mod){
02211 {
02212   VALUE val;
02213   IC ic = (IC)GET_OPERAND(1);
02214   VALUE recv = TOPN(1);
02215   VALUE obj = TOPN(0);
02216   DEBUG_ENTER_INSN("opt_mod");
02217   ADD_PC(1+1);
02218   PREFETCH(GET_PC());
02219   POPN(2);
02220   #define CURRENT_INSN_opt_mod 1
02221   #define INSN_IS_SC()     0
02222   #define INSN_LABEL(lab)  LABEL_opt_mod_##lab
02223   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02224   USAGE_ANALYSIS_INSN(BIN(opt_mod));
02225   USAGE_ANALYSIS_OPERAND(BIN(opt_mod), 0, ic);
02226 {
02227 #line 1579 "insns.def"
02228     if (FIXNUM_2_P(recv, obj) &&
02229         BASIC_OP_UNREDEFINED_P(BOP_MOD)) {
02230         long x, y, mod;
02231 
02232         x = FIX2LONG(recv);
02233         y = FIX2LONG(obj);
02234         {
02235             /* copied from numeric.c#fixdivmod */
02236             long div;
02237 
02238             if (y == 0)
02239                 rb_num_zerodiv();
02240             if (y < 0) {
02241                 if (x < 0)
02242                     div = -x / -y;
02243                 else
02244                     div = -(x / -y);
02245             }
02246             else {
02247                 if (x < 0)
02248                     div = -(-x / y);
02249                 else
02250                     div = x / y;
02251             }
02252             mod = x - div * y;
02253             if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) {
02254                 mod += y;
02255                 div -= 1;
02256             }
02257         }
02258         val = LONG2FIX(mod);
02259     }
02260     else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02261         if (0) {
02262         }
02263         else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02264                  HEAP_CLASS_OF(obj) == rb_cFloat &&
02265                  BASIC_OP_UNREDEFINED_P(BOP_MOD)) {
02266             val = DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
02267         }
02268         else {
02269             goto INSN_LABEL(normal_dispatch);
02270         }
02271     }
02272     else {
02273       INSN_LABEL(normal_dispatch):
02274         PUSH(recv);
02275         PUSH(obj);
02276         CALL_SIMPLE_METHOD(1, idMOD, recv);
02277     }
02278 
02279 #line 2280 "vm.inc"
02280   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02281   PUSH(val);
02282 #undef CURRENT_INSN_opt_mod
02283 #undef INSN_IS_SC
02284 #undef INSN_LABEL
02285 #undef LABEL_IS_SC
02286   END_INSN(opt_mod);}}}
02287 INSN_ENTRY(opt_eq){
02288 {
02289   VALUE val;
02290   IC ic = (IC)GET_OPERAND(1);
02291   VALUE recv = TOPN(1);
02292   VALUE obj = TOPN(0);
02293   DEBUG_ENTER_INSN("opt_eq");
02294   ADD_PC(1+1);
02295   PREFETCH(GET_PC());
02296   POPN(2);
02297   #define CURRENT_INSN_opt_eq 1
02298   #define INSN_IS_SC()     0
02299   #define INSN_LABEL(lab)  LABEL_opt_eq_##lab
02300   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02301   USAGE_ANALYSIS_INSN(BIN(opt_eq));
02302   USAGE_ANALYSIS_OPERAND(BIN(opt_eq), 0, ic);
02303 {
02304 #line 1642 "insns.def"
02305     val = opt_eq_func(recv, obj, ic);
02306 
02307     if (val == Qundef) {
02308         /* other */
02309         PUSH(recv);
02310         PUSH(obj);
02311         CALL_SIMPLE_METHOD(1, idEq, recv);
02312     }
02313 
02314 #line 2315 "vm.inc"
02315   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02316   PUSH(val);
02317 #undef CURRENT_INSN_opt_eq
02318 #undef INSN_IS_SC
02319 #undef INSN_LABEL
02320 #undef LABEL_IS_SC
02321   END_INSN(opt_eq);}}}
02322 INSN_ENTRY(opt_neq){
02323 {
02324   VALUE val;
02325   IC ic_eq = (IC)GET_OPERAND(2);
02326   IC ic = (IC)GET_OPERAND(1);
02327   VALUE recv = TOPN(1);
02328   VALUE obj = TOPN(0);
02329   DEBUG_ENTER_INSN("opt_neq");
02330   ADD_PC(1+2);
02331   PREFETCH(GET_PC());
02332   POPN(2);
02333   #define CURRENT_INSN_opt_neq 1
02334   #define INSN_IS_SC()     0
02335   #define INSN_LABEL(lab)  LABEL_opt_neq_##lab
02336   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02337   USAGE_ANALYSIS_INSN(BIN(opt_neq));
02338   USAGE_ANALYSIS_OPERAND(BIN(opt_neq), 0, ic);
02339   USAGE_ANALYSIS_OPERAND(BIN(opt_neq), 1, ic_eq);
02340 {
02341 #line 1663 "insns.def"
02342     extern VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2);
02343     const rb_method_entry_t *me = vm_method_search(idNeq, CLASS_OF(recv), ic);
02344     val = Qundef;
02345 
02346     if (check_cfunc(me, rb_obj_not_equal)) {
02347         val = opt_eq_func(recv, obj, ic_eq);
02348 
02349         if (val != Qundef) {
02350             val = RTEST(val) ? Qfalse : Qtrue;
02351         }
02352     }
02353 
02354     if (val == Qundef) {
02355         /* other */
02356         PUSH(recv);
02357         PUSH(obj);
02358         CALL_SIMPLE_METHOD(1, idNeq, recv);
02359     }
02360 
02361 #line 2362 "vm.inc"
02362   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02363   PUSH(val);
02364 #undef CURRENT_INSN_opt_neq
02365 #undef INSN_IS_SC
02366 #undef INSN_LABEL
02367 #undef LABEL_IS_SC
02368   END_INSN(opt_neq);}}}
02369 INSN_ENTRY(opt_lt){
02370 {
02371   VALUE val;
02372   IC ic = (IC)GET_OPERAND(1);
02373   VALUE recv = TOPN(1);
02374   VALUE obj = TOPN(0);
02375   DEBUG_ENTER_INSN("opt_lt");
02376   ADD_PC(1+1);
02377   PREFETCH(GET_PC());
02378   POPN(2);
02379   #define CURRENT_INSN_opt_lt 1
02380   #define INSN_IS_SC()     0
02381   #define INSN_LABEL(lab)  LABEL_opt_lt_##lab
02382   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02383   USAGE_ANALYSIS_INSN(BIN(opt_lt));
02384   USAGE_ANALYSIS_OPERAND(BIN(opt_lt), 0, ic);
02385 {
02386 #line 1694 "insns.def"
02387     if (FIXNUM_2_P(recv, obj) &&
02388         BASIC_OP_UNREDEFINED_P(BOP_LT)) {
02389         SIGNED_VALUE a = recv, b = obj;
02390 
02391         if (a < b) {
02392             val = Qtrue;
02393         }
02394         else {
02395             val = Qfalse;
02396         }
02397     }
02398     else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02399         if (0) {
02400         }
02401 #if 1
02402         else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02403                  HEAP_CLASS_OF(obj) == rb_cFloat  &&
02404                  BASIC_OP_UNREDEFINED_P(BOP_LT)) {
02405             double a = RFLOAT_VALUE(recv);
02406             double b = RFLOAT_VALUE(obj);
02407 #if defined(_MSC_VER) && _MSC_VER < 1300
02408             if (isnan(a) || isnan(b)) val = Qfalse;
02409             else
02410 #endif
02411             val = a < b ? Qtrue : Qfalse;
02412         }
02413 #endif
02414         else {
02415             goto INSN_LABEL(normal_dispatch);
02416         }
02417     }
02418     else {
02419       INSN_LABEL(normal_dispatch):
02420         PUSH(recv);
02421         PUSH(obj);
02422         CALL_SIMPLE_METHOD(1, idLT, recv);
02423     }
02424 
02425 #line 2426 "vm.inc"
02426   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02427   PUSH(val);
02428 #undef CURRENT_INSN_opt_lt
02429 #undef INSN_IS_SC
02430 #undef INSN_LABEL
02431 #undef LABEL_IS_SC
02432   END_INSN(opt_lt);}}}
02433 INSN_ENTRY(opt_le){
02434 {
02435   VALUE val;
02436   IC ic = (IC)GET_OPERAND(1);
02437   VALUE recv = TOPN(1);
02438   VALUE obj = TOPN(0);
02439   DEBUG_ENTER_INSN("opt_le");
02440   ADD_PC(1+1);
02441   PREFETCH(GET_PC());
02442   POPN(2);
02443   #define CURRENT_INSN_opt_le 1
02444   #define INSN_IS_SC()     0
02445   #define INSN_LABEL(lab)  LABEL_opt_le_##lab
02446   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02447   USAGE_ANALYSIS_INSN(BIN(opt_le));
02448   USAGE_ANALYSIS_OPERAND(BIN(opt_le), 0, ic);
02449 {
02450 #line 1744 "insns.def"
02451     if (FIXNUM_2_P(recv, obj) &&
02452         BASIC_OP_UNREDEFINED_P(BOP_LE)) {
02453         SIGNED_VALUE a = recv, b = obj;
02454 
02455         if (a <= b) {
02456             val = Qtrue;
02457         }
02458         else {
02459             val = Qfalse;
02460         }
02461     }
02462     else {
02463         /* other */
02464         PUSH(recv);
02465         PUSH(obj);
02466         CALL_SIMPLE_METHOD(1, idLE, recv);
02467     }
02468 
02469 #line 2470 "vm.inc"
02470   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02471   PUSH(val);
02472 #undef CURRENT_INSN_opt_le
02473 #undef INSN_IS_SC
02474 #undef INSN_LABEL
02475 #undef LABEL_IS_SC
02476   END_INSN(opt_le);}}}
02477 INSN_ENTRY(opt_gt){
02478 {
02479   VALUE val;
02480   IC ic = (IC)GET_OPERAND(1);
02481   VALUE recv = TOPN(1);
02482   VALUE obj = TOPN(0);
02483   DEBUG_ENTER_INSN("opt_gt");
02484   ADD_PC(1+1);
02485   PREFETCH(GET_PC());
02486   POPN(2);
02487   #define CURRENT_INSN_opt_gt 1
02488   #define INSN_IS_SC()     0
02489   #define INSN_LABEL(lab)  LABEL_opt_gt_##lab
02490   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02491   USAGE_ANALYSIS_INSN(BIN(opt_gt));
02492   USAGE_ANALYSIS_OPERAND(BIN(opt_gt), 0, ic);
02493 {
02494 #line 1774 "insns.def"
02495     if (FIXNUM_2_P(recv, obj) &&
02496         BASIC_OP_UNREDEFINED_P(BOP_GT)) {
02497         SIGNED_VALUE a = recv, b = obj;
02498 
02499         if (a > b) {
02500             val = Qtrue;
02501         }
02502         else {
02503             val = Qfalse;
02504         }
02505     }
02506     else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02507         if (0) {
02508         }
02509 #if 1
02510         else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02511                  HEAP_CLASS_OF(obj) == rb_cFloat  &&
02512                  BASIC_OP_UNREDEFINED_P(BOP_GT)) {
02513             double a = RFLOAT_VALUE(recv);
02514             double b = RFLOAT_VALUE(obj);
02515 #if defined(_MSC_VER) && _MSC_VER < 1300
02516             if (isnan(a) || isnan(b)) val = Qfalse;
02517             else
02518 #endif
02519             val = a > b ? Qtrue : Qfalse;
02520         }
02521 #endif
02522         else {
02523             goto INSN_LABEL(normal_dispatch);
02524         }
02525     }
02526     else {
02527       INSN_LABEL(normal_dispatch):
02528         PUSH(recv);
02529         PUSH(obj);
02530         CALL_SIMPLE_METHOD(1, idGT, recv);
02531     }
02532 
02533 #line 2534 "vm.inc"
02534   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02535   PUSH(val);
02536 #undef CURRENT_INSN_opt_gt
02537 #undef INSN_IS_SC
02538 #undef INSN_LABEL
02539 #undef LABEL_IS_SC
02540   END_INSN(opt_gt);}}}
02541 INSN_ENTRY(opt_ge){
02542 {
02543   VALUE val;
02544   IC ic = (IC)GET_OPERAND(1);
02545   VALUE recv = TOPN(1);
02546   VALUE obj = TOPN(0);
02547   DEBUG_ENTER_INSN("opt_ge");
02548   ADD_PC(1+1);
02549   PREFETCH(GET_PC());
02550   POPN(2);
02551   #define CURRENT_INSN_opt_ge 1
02552   #define INSN_IS_SC()     0
02553   #define INSN_LABEL(lab)  LABEL_opt_ge_##lab
02554   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02555   USAGE_ANALYSIS_INSN(BIN(opt_ge));
02556   USAGE_ANALYSIS_OPERAND(BIN(opt_ge), 0, ic);
02557 {
02558 #line 1824 "insns.def"
02559     if (FIXNUM_2_P(recv, obj) &&
02560         BASIC_OP_UNREDEFINED_P(BOP_GE)) {
02561         SIGNED_VALUE a = recv, b = obj;
02562 
02563         if (a >= b) {
02564             val = Qtrue;
02565         }
02566         else {
02567             val = Qfalse;
02568         }
02569     }
02570     else {
02571         PUSH(recv);
02572         PUSH(obj);
02573         CALL_SIMPLE_METHOD(1, idGE, recv);
02574     }
02575 
02576 #line 2577 "vm.inc"
02577   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02578   PUSH(val);
02579 #undef CURRENT_INSN_opt_ge
02580 #undef INSN_IS_SC
02581 #undef INSN_LABEL
02582 #undef LABEL_IS_SC
02583   END_INSN(opt_ge);}}}
02584 INSN_ENTRY(opt_ltlt){
02585 {
02586   VALUE val;
02587   IC ic = (IC)GET_OPERAND(1);
02588   VALUE recv = TOPN(1);
02589   VALUE obj = TOPN(0);
02590   DEBUG_ENTER_INSN("opt_ltlt");
02591   ADD_PC(1+1);
02592   PREFETCH(GET_PC());
02593   POPN(2);
02594   #define CURRENT_INSN_opt_ltlt 1
02595   #define INSN_IS_SC()     0
02596   #define INSN_LABEL(lab)  LABEL_opt_ltlt_##lab
02597   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02598   USAGE_ANALYSIS_INSN(BIN(opt_ltlt));
02599   USAGE_ANALYSIS_OPERAND(BIN(opt_ltlt), 0, ic);
02600 {
02601 #line 1853 "insns.def"
02602     if (!SPECIAL_CONST_P(recv)) {
02603         if (0) {
02604         }
02605         else if (HEAP_CLASS_OF(recv) == rb_cString &&
02606                  BASIC_OP_UNREDEFINED_P(BOP_LTLT)) {
02607             val = rb_str_concat(recv, obj);
02608         }
02609         else if (HEAP_CLASS_OF(recv) == rb_cArray &&
02610                  BASIC_OP_UNREDEFINED_P(BOP_LTLT)) {
02611             val = rb_ary_push(recv, obj);
02612         }
02613         else {
02614             goto INSN_LABEL(normal_dispatch);
02615         }
02616     }
02617     else {
02618       INSN_LABEL(normal_dispatch):
02619         PUSH(recv);
02620         PUSH(obj);
02621         CALL_SIMPLE_METHOD(1, idLTLT, recv);
02622     }
02623 
02624 #line 2625 "vm.inc"
02625   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02626   PUSH(val);
02627 #undef CURRENT_INSN_opt_ltlt
02628 #undef INSN_IS_SC
02629 #undef INSN_LABEL
02630 #undef LABEL_IS_SC
02631   END_INSN(opt_ltlt);}}}
02632 INSN_ENTRY(opt_aref){
02633 {
02634   VALUE val;
02635   IC ic = (IC)GET_OPERAND(1);
02636   VALUE recv = TOPN(1);
02637   VALUE obj = TOPN(0);
02638   DEBUG_ENTER_INSN("opt_aref");
02639   ADD_PC(1+1);
02640   PREFETCH(GET_PC());
02641   POPN(2);
02642   #define CURRENT_INSN_opt_aref 1
02643   #define INSN_IS_SC()     0
02644   #define INSN_LABEL(lab)  LABEL_opt_aref_##lab
02645   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02646   USAGE_ANALYSIS_INSN(BIN(opt_aref));
02647   USAGE_ANALYSIS_OPERAND(BIN(opt_aref), 0, ic);
02648 {
02649 #line 1887 "insns.def"
02650     if (!SPECIAL_CONST_P(recv) && BASIC_OP_UNREDEFINED_P(BOP_AREF)) {
02651         if (HEAP_CLASS_OF(recv) == rb_cArray && FIXNUM_P(obj)) {
02652             val = rb_ary_entry(recv, FIX2LONG(obj));
02653         }
02654         else if (HEAP_CLASS_OF(recv) == rb_cHash) {
02655             val = rb_hash_aref(recv, obj);
02656         }
02657         else {
02658             goto INSN_LABEL(normal_dispatch);
02659         }
02660     }
02661     else {
02662       INSN_LABEL(normal_dispatch):
02663         PUSH(recv);
02664         PUSH(obj);
02665         CALL_SIMPLE_METHOD(1, idAREF, recv);
02666     }
02667 
02668 #line 2669 "vm.inc"
02669   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02670   PUSH(val);
02671 #undef CURRENT_INSN_opt_aref
02672 #undef INSN_IS_SC
02673 #undef INSN_LABEL
02674 #undef LABEL_IS_SC
02675   END_INSN(opt_aref);}}}
02676 INSN_ENTRY(opt_aset){
02677 {
02678   VALUE val;
02679   IC ic = (IC)GET_OPERAND(1);
02680   VALUE recv = TOPN(2);
02681   VALUE obj = TOPN(1);
02682   VALUE set = TOPN(0);
02683   DEBUG_ENTER_INSN("opt_aset");
02684   ADD_PC(1+1);
02685   PREFETCH(GET_PC());
02686   POPN(3);
02687   #define CURRENT_INSN_opt_aset 1
02688   #define INSN_IS_SC()     0
02689   #define INSN_LABEL(lab)  LABEL_opt_aset_##lab
02690   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02691   USAGE_ANALYSIS_INSN(BIN(opt_aset));
02692   USAGE_ANALYSIS_OPERAND(BIN(opt_aset), 0, ic);
02693 {
02694 #line 1917 "insns.def"
02695     if (!SPECIAL_CONST_P(recv) &&
02696         BASIC_OP_UNREDEFINED_P(BOP_ASET)) {
02697         if (HEAP_CLASS_OF(recv) == rb_cArray && FIXNUM_P(obj)) {
02698             rb_ary_store(recv, FIX2LONG(obj), set);
02699             val = set;
02700         }
02701         else if (HEAP_CLASS_OF(recv) == rb_cHash) {
02702             rb_hash_aset(recv, obj, set);
02703             val = set;
02704         }
02705         else {
02706             goto INSN_LABEL(normal_dispatch);
02707         }
02708     }
02709     else {
02710       INSN_LABEL(normal_dispatch):
02711         PUSH(recv);
02712         PUSH(obj);
02713         PUSH(set);
02714         CALL_SIMPLE_METHOD(2, idASET, recv);
02715     }
02716 
02717 #line 2718 "vm.inc"
02718   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02719   PUSH(val);
02720 #undef CURRENT_INSN_opt_aset
02721 #undef INSN_IS_SC
02722 #undef INSN_LABEL
02723 #undef LABEL_IS_SC
02724   END_INSN(opt_aset);}}}
02725 INSN_ENTRY(opt_length){
02726 {
02727   VALUE val;
02728   IC ic = (IC)GET_OPERAND(1);
02729   VALUE recv = TOPN(0);
02730   DEBUG_ENTER_INSN("opt_length");
02731   ADD_PC(1+1);
02732   PREFETCH(GET_PC());
02733   POPN(1);
02734   #define CURRENT_INSN_opt_length 1
02735   #define INSN_IS_SC()     0
02736   #define INSN_LABEL(lab)  LABEL_opt_length_##lab
02737   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02738   USAGE_ANALYSIS_INSN(BIN(opt_length));
02739   USAGE_ANALYSIS_OPERAND(BIN(opt_length), 0, ic);
02740 {
02741 #line 1951 "insns.def"
02742     if (LIKELY(!SPECIAL_CONST_P(recv) &&
02743                BASIC_OP_UNREDEFINED_P(BOP_LENGTH))) {
02744         if (HEAP_CLASS_OF(recv) == rb_cString) {
02745             val = rb_str_length(recv);
02746         }
02747         else if (HEAP_CLASS_OF(recv) == rb_cArray) {
02748             val = LONG2NUM(RARRAY_LEN(recv));
02749         }
02750         else if (HEAP_CLASS_OF(recv) == rb_cHash) {
02751             val = INT2FIX(RHASH_SIZE(recv));
02752         }
02753         else {
02754             goto INSN_LABEL(normal_dispatch);
02755         }
02756     }
02757     else {
02758       INSN_LABEL(normal_dispatch):
02759         PUSH(recv);
02760         CALL_SIMPLE_METHOD(0, idLength, recv);
02761     }
02762 
02763 #line 2764 "vm.inc"
02764   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02765   PUSH(val);
02766 #undef CURRENT_INSN_opt_length
02767 #undef INSN_IS_SC
02768 #undef INSN_LABEL
02769 #undef LABEL_IS_SC
02770   END_INSN(opt_length);}}}
02771 INSN_ENTRY(opt_size){
02772 {
02773   VALUE val;
02774   IC ic = (IC)GET_OPERAND(1);
02775   VALUE recv = TOPN(0);
02776   DEBUG_ENTER_INSN("opt_size");
02777   ADD_PC(1+1);
02778   PREFETCH(GET_PC());
02779   POPN(1);
02780   #define CURRENT_INSN_opt_size 1
02781   #define INSN_IS_SC()     0
02782   #define INSN_LABEL(lab)  LABEL_opt_size_##lab
02783   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02784   USAGE_ANALYSIS_INSN(BIN(opt_size));
02785   USAGE_ANALYSIS_OPERAND(BIN(opt_size), 0, ic);
02786 {
02787 #line 1984 "insns.def"
02788     if (LIKELY(BASIC_OP_UNREDEFINED_P(BOP_SIZE) &&
02789                !SPECIAL_CONST_P(recv))) {
02790         if (HEAP_CLASS_OF(recv) == rb_cString) {
02791             val = rb_str_length(recv);
02792         }
02793         else if (HEAP_CLASS_OF(recv) == rb_cArray) {
02794             val = LONG2NUM(RARRAY_LEN(recv));
02795         }
02796         else if (HEAP_CLASS_OF(recv) == rb_cHash) {
02797             val = INT2FIX(RHASH_SIZE(recv));
02798         }
02799         else {
02800             goto INSN_LABEL(normal_dispatch);
02801         }
02802     }
02803     else {
02804       INSN_LABEL(normal_dispatch):
02805         PUSH(recv);
02806         CALL_SIMPLE_METHOD(0, idSize, recv);
02807     }
02808 
02809 #line 2810 "vm.inc"
02810   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02811   PUSH(val);
02812 #undef CURRENT_INSN_opt_size
02813 #undef INSN_IS_SC
02814 #undef INSN_LABEL
02815 #undef LABEL_IS_SC
02816   END_INSN(opt_size);}}}
02817 INSN_ENTRY(opt_succ){
02818 {
02819   VALUE val;
02820   IC ic = (IC)GET_OPERAND(1);
02821   VALUE recv = TOPN(0);
02822   DEBUG_ENTER_INSN("opt_succ");
02823   ADD_PC(1+1);
02824   PREFETCH(GET_PC());
02825   POPN(1);
02826   #define CURRENT_INSN_opt_succ 1
02827   #define INSN_IS_SC()     0
02828   #define INSN_LABEL(lab)  LABEL_opt_succ_##lab
02829   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02830   USAGE_ANALYSIS_INSN(BIN(opt_succ));
02831   USAGE_ANALYSIS_OPERAND(BIN(opt_succ), 0, ic);
02832 {
02833 #line 2017 "insns.def"
02834     if (SPECIAL_CONST_P(recv)) {
02835         if (FIXNUM_P(recv) &&
02836             BASIC_OP_UNREDEFINED_P(BOP_SUCC)) {
02837             const VALUE obj = INT2FIX(1);
02838             /* fixnum + INT2FIX(1) */
02839             val = (recv + (obj & (~1)));
02840             if ((~(recv ^ obj) & (recv ^ val)) & ((unsigned long)LONG_MAX + 1)) {
02841                 val = rb_big_plus(rb_int2big(FIX2LONG(recv)),
02842                                   rb_int2big(FIX2LONG(obj)));
02843             }
02844         }
02845         else {
02846             goto INSN_LABEL(normal_dispatch);
02847         }
02848     }
02849     else {
02850         if (HEAP_CLASS_OF(recv) == rb_cString &&
02851             BASIC_OP_UNREDEFINED_P(BOP_SUCC)) {
02852             val = rb_str_succ(recv);
02853         }
02854         else if (HEAP_CLASS_OF(recv) == rb_cTime &&
02855                  BASIC_OP_UNREDEFINED_P(BOP_SUCC)) {
02856             val = rb_time_succ(recv);
02857         }
02858         else
02859           {
02860             goto INSN_LABEL(normal_dispatch);
02861         }
02862     }
02863     if (0) {
02864       INSN_LABEL(normal_dispatch):
02865         PUSH(recv);
02866         CALL_SIMPLE_METHOD(0, idSucc, recv);
02867     }
02868 
02869 #line 2870 "vm.inc"
02870   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02871   PUSH(val);
02872 #undef CURRENT_INSN_opt_succ
02873 #undef INSN_IS_SC
02874 #undef INSN_LABEL
02875 #undef LABEL_IS_SC
02876   END_INSN(opt_succ);}}}
02877 INSN_ENTRY(opt_not){
02878 {
02879   VALUE val;
02880   IC ic = (IC)GET_OPERAND(1);
02881   VALUE recv = TOPN(0);
02882   DEBUG_ENTER_INSN("opt_not");
02883   ADD_PC(1+1);
02884   PREFETCH(GET_PC());
02885   POPN(1);
02886   #define CURRENT_INSN_opt_not 1
02887   #define INSN_IS_SC()     0
02888   #define INSN_LABEL(lab)  LABEL_opt_not_##lab
02889   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02890   USAGE_ANALYSIS_INSN(BIN(opt_not));
02891   USAGE_ANALYSIS_OPERAND(BIN(opt_not), 0, ic);
02892 {
02893 #line 2064 "insns.def"
02894     extern VALUE rb_obj_not(VALUE obj);
02895     const rb_method_entry_t *me = vm_method_search(idNot, CLASS_OF(recv), ic);
02896 
02897     if (check_cfunc(me, rb_obj_not)) {
02898         val = RTEST(recv) ? Qfalse : Qtrue;
02899     }
02900     else {
02901         PUSH(recv);
02902         CALL_SIMPLE_METHOD(0, idNot, recv);
02903     }
02904 
02905 #line 2906 "vm.inc"
02906   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02907   PUSH(val);
02908 #undef CURRENT_INSN_opt_not
02909 #undef INSN_IS_SC
02910 #undef INSN_LABEL
02911 #undef LABEL_IS_SC
02912   END_INSN(opt_not);}}}
02913 INSN_ENTRY(opt_regexpmatch1){
02914 {
02915   VALUE val;
02916   VALUE r = (VALUE)GET_OPERAND(1);
02917   VALUE obj = TOPN(0);
02918   DEBUG_ENTER_INSN("opt_regexpmatch1");
02919   ADD_PC(1+1);
02920   PREFETCH(GET_PC());
02921   POPN(1);
02922   #define CURRENT_INSN_opt_regexpmatch1 1
02923   #define INSN_IS_SC()     0
02924   #define INSN_LABEL(lab)  LABEL_opt_regexpmatch1_##lab
02925   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02926   USAGE_ANALYSIS_INSN(BIN(opt_regexpmatch1));
02927   USAGE_ANALYSIS_OPERAND(BIN(opt_regexpmatch1), 0, r);
02928 {
02929 #line 2088 "insns.def"
02930     val = rb_reg_match(r, obj);
02931 
02932 #line 2933 "vm.inc"
02933   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02934   PUSH(val);
02935 #undef CURRENT_INSN_opt_regexpmatch1
02936 #undef INSN_IS_SC
02937 #undef INSN_LABEL
02938 #undef LABEL_IS_SC
02939   END_INSN(opt_regexpmatch1);}}}
02940 INSN_ENTRY(opt_regexpmatch2){
02941 {
02942   VALUE val;
02943 
02944   VALUE obj2 = TOPN(1);
02945   VALUE obj1 = TOPN(0);
02946   DEBUG_ENTER_INSN("opt_regexpmatch2");
02947   ADD_PC(1+0);
02948   PREFETCH(GET_PC());
02949   POPN(2);
02950   #define CURRENT_INSN_opt_regexpmatch2 1
02951   #define INSN_IS_SC()     0
02952   #define INSN_LABEL(lab)  LABEL_opt_regexpmatch2_##lab
02953   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02954   USAGE_ANALYSIS_INSN(BIN(opt_regexpmatch2));
02955 {
02956 #line 2102 "insns.def"
02957     if (TYPE(obj2) == T_STRING) {
02958         val = rb_reg_match(obj1, obj2);
02959     }
02960     else {
02961         val = rb_funcall(obj2, idEqTilde, 1, obj1);
02962     }
02963 
02964 #line 2965 "vm.inc"
02965   CHECK_STACK_OVERFLOW(REG_CFP, 1);
02966   PUSH(val);
02967 #undef CURRENT_INSN_opt_regexpmatch2
02968 #undef INSN_IS_SC
02969 #undef INSN_LABEL
02970 #undef LABEL_IS_SC
02971   END_INSN(opt_regexpmatch2);}}}
02972 INSN_ENTRY(opt_call_c_function){
02973 {
02974   rb_insn_func_t funcptr = (rb_insn_func_t)GET_OPERAND(1);
02975 
02976   DEBUG_ENTER_INSN("opt_call_c_function");
02977   ADD_PC(1+1);
02978   PREFETCH(GET_PC());
02979   #define CURRENT_INSN_opt_call_c_function 1
02980   #define INSN_IS_SC()     0
02981   #define INSN_LABEL(lab)  LABEL_opt_call_c_function_##lab
02982   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02983   USAGE_ANALYSIS_INSN(BIN(opt_call_c_function));
02984   USAGE_ANALYSIS_OPERAND(BIN(opt_call_c_function), 0, funcptr);
02985 {
02986 #line 2121 "insns.def"
02987     reg_cfp = (funcptr)(th, reg_cfp);
02988 
02989     if (reg_cfp == 0) {
02990         VALUE err = th->errinfo;
02991         th->errinfo = Qnil;
02992         THROW_EXCEPTION(err);
02993     }
02994 
02995     RESTORE_REGS();
02996     NEXT_INSN();
02997 
02998 #line 2999 "vm.inc"
02999 #undef CURRENT_INSN_opt_call_c_function
03000 #undef INSN_IS_SC
03001 #undef INSN_LABEL
03002 #undef LABEL_IS_SC
03003   END_INSN(opt_call_c_function);}}}
03004 INSN_ENTRY(bitblt){
03005 {
03006   VALUE ret;
03007 
03008 
03009   DEBUG_ENTER_INSN("bitblt");
03010   ADD_PC(1+0);
03011   PREFETCH(GET_PC());
03012   #define CURRENT_INSN_bitblt 1
03013   #define INSN_IS_SC()     0
03014   #define INSN_LABEL(lab)  LABEL_bitblt_##lab
03015   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
03016   USAGE_ANALYSIS_INSN(BIN(bitblt));
03017 {
03018 #line 2144 "insns.def"
03019     ret = rb_str_new2("a bit of bacon, lettuce and tomato");
03020 
03021 #line 3022 "vm.inc"
03022   CHECK_STACK_OVERFLOW(REG_CFP, 1);
03023   PUSH(ret);
03024 #undef CURRENT_INSN_bitblt
03025 #undef INSN_IS_SC
03026 #undef INSN_LABEL
03027 #undef LABEL_IS_SC
03028   END_INSN(bitblt);}}}
03029 INSN_ENTRY(answer){
03030 {
03031   VALUE ret;
03032 
03033 
03034   DEBUG_ENTER_INSN("answer");
03035   ADD_PC(1+0);
03036   PREFETCH(GET_PC());
03037   #define CURRENT_INSN_answer 1
03038   #define INSN_IS_SC()     0
03039   #define INSN_LABEL(lab)  LABEL_answer_##lab
03040   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
03041   USAGE_ANALYSIS_INSN(BIN(answer));
03042 {
03043 #line 2158 "insns.def"
03044     ret = INT2FIX(42);
03045 
03046 #line 3047 "vm.inc"
03047   CHECK_STACK_OVERFLOW(REG_CFP, 1);
03048   PUSH(ret);
03049 #undef CURRENT_INSN_answer
03050 #undef INSN_IS_SC
03051 #undef INSN_LABEL
03052 #undef LABEL_IS_SC
03053   END_INSN(answer);}}}
03054 
03055