00001
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
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 rb_num_t key = (rb_num_t)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 rb_num_t key = (rb_num_t)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
00856 for (i = 0; i < RARRAY_LEN(ary); i++) {
00857
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
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 (void)val;
00962
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
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
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 );
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:
01339 case 3:
01340
01341
01342 if (super == Qnil) {
01343 super = rb_cObject;
01344 }
01345
01346 vm_check_if_namespace(cbase);
01347
01348
01349 rb_autoload_load(cbase, id);
01350 if ((klass = vm_search_const_defined_class(cbase, id)) != 0) {
01351
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
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
01377
01378 klass = rb_singleton_class(cbase);
01379 break;
01380 case 2:
01381 case 5:
01382
01383
01384
01385 vm_check_if_namespace(cbase);
01386
01387
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
01391 if (TYPE(klass) != T_MODULE) {
01392 rb_raise(rb_eTypeError, "%s is not a module", rb_id2name(id));
01393 }
01394 }
01395 else {
01396
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
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
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
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
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
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
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:
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
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
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
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
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
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
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
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
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
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
