Ruby 1.9.3p327(2012-11-10revision37606)
|
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