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 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
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 obj = tmp;
00817
00818 #line 819 "vm.inc"
00819 CHECK_STACK_OVERFLOW(REG_CFP, 1);
00820 PUSH(obj);
00821 #undef CURRENT_INSN_splatarray
00822 #undef INSN_IS_SC
00823 #undef INSN_LABEL
00824 #undef LABEL_IS_SC
00825 END_INSN(splatarray);}}}
00826 INSN_ENTRY(checkincludearray){
00827 {
00828 VALUE result;
00829 VALUE flag = (VALUE)GET_OPERAND(1);
00830 VALUE obj = TOPN(1);
00831 VALUE ary = TOPN(0);
00832 DEBUG_ENTER_INSN("checkincludearray");
00833 ADD_PC(1+1);
00834 PREFETCH(GET_PC());
00835 POPN(2);
00836 #define CURRENT_INSN_checkincludearray 1
00837 #define INSN_IS_SC() 0
00838 #define INSN_LABEL(lab) LABEL_checkincludearray_##lab
00839 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00840 USAGE_ANALYSIS_INSN(BIN(checkincludearray));
00841 USAGE_ANALYSIS_OPERAND(BIN(checkincludearray), 0, flag);
00842 {
00843 #line 550 "insns.def"
00844 int i;
00845 result = Qfalse;
00846
00847 if (TYPE(ary) != T_ARRAY) {
00848 ary = rb_Array(ary);
00849 }
00850
00851 if (flag == Qtrue) {
00852
00853 for (i = 0; i < RARRAY_LEN(ary); i++) {
00854
00855 if (RTEST(rb_funcall2(RARRAY_PTR(ary)[i], idEqq, 1, &obj))) {
00856 result = Qtrue;
00857 break;
00858 }
00859 }
00860 }
00861 else {
00862 obj = Qfalse;
00863
00864 for (i = 0; i < RARRAY_LEN(ary); i++) {
00865 if (RTEST(RARRAY_PTR(ary)[i])) {
00866 obj = result = Qtrue;
00867 break;
00868 }
00869 }
00870 }
00871
00872 #line 873 "vm.inc"
00873 CHECK_STACK_OVERFLOW(REG_CFP, 2);
00874 PUSH(obj);
00875 PUSH(result);
00876 #undef CURRENT_INSN_checkincludearray
00877 #undef INSN_IS_SC
00878 #undef INSN_LABEL
00879 #undef LABEL_IS_SC
00880 END_INSN(checkincludearray);}}}
00881 INSN_ENTRY(newhash){
00882 {
00883 VALUE val;
00884 rb_num_t num = (rb_num_t)GET_OPERAND(1);
00885
00886 DEBUG_ENTER_INSN("newhash");
00887 ADD_PC(1+1);
00888 PREFETCH(GET_PC());
00889 #define CURRENT_INSN_newhash 1
00890 #define INSN_IS_SC() 0
00891 #define INSN_LABEL(lab) LABEL_newhash_##lab
00892 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00893 USAGE_ANALYSIS_INSN(BIN(newhash));
00894 USAGE_ANALYSIS_OPERAND(BIN(newhash), 0, num);
00895 {
00896 #line 591 "insns.def"
00897 rb_num_t i;
00898 val = rb_hash_new();
00899
00900 for (i = num; i > 0; i -= 2) {
00901 const VALUE v = TOPN(i - 2);
00902 const VALUE k = TOPN(i - 1);
00903 rb_hash_aset(val, k, v);
00904 }
00905 POPN(num);
00906
00907 #line 908 "vm.inc"
00908 CHECK_STACK_OVERFLOW(REG_CFP, 1);
00909 PUSH(val);
00910 #undef CURRENT_INSN_newhash
00911 #undef INSN_IS_SC
00912 #undef INSN_LABEL
00913 #undef LABEL_IS_SC
00914 END_INSN(newhash);}}}
00915 INSN_ENTRY(newrange){
00916 {
00917 VALUE val;
00918 rb_num_t flag = (rb_num_t)GET_OPERAND(1);
00919 VALUE low = TOPN(1);
00920 VALUE high = TOPN(0);
00921 DEBUG_ENTER_INSN("newrange");
00922 ADD_PC(1+1);
00923 PREFETCH(GET_PC());
00924 POPN(2);
00925 #define CURRENT_INSN_newrange 1
00926 #define INSN_IS_SC() 0
00927 #define INSN_LABEL(lab) LABEL_newrange_##lab
00928 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00929 USAGE_ANALYSIS_INSN(BIN(newrange));
00930 USAGE_ANALYSIS_OPERAND(BIN(newrange), 0, flag);
00931 {
00932 #line 613 "insns.def"
00933 val = rb_range_new(low, high, (int)flag);
00934
00935 #line 936 "vm.inc"
00936 CHECK_STACK_OVERFLOW(REG_CFP, 1);
00937 PUSH(val);
00938 #undef CURRENT_INSN_newrange
00939 #undef INSN_IS_SC
00940 #undef INSN_LABEL
00941 #undef LABEL_IS_SC
00942 END_INSN(newrange);}}}
00943 INSN_ENTRY(pop){
00944 {
00945
00946 VALUE val = TOPN(0);
00947 DEBUG_ENTER_INSN("pop");
00948 ADD_PC(1+0);
00949 PREFETCH(GET_PC());
00950 POPN(1);
00951 #define CURRENT_INSN_pop 1
00952 #define INSN_IS_SC() 0
00953 #define INSN_LABEL(lab) LABEL_pop_##lab
00954 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00955 USAGE_ANALYSIS_INSN(BIN(pop));
00956 {
00957 #line 631 "insns.def"
00958 val = val;
00959
00960
00961 #line 962 "vm.inc"
00962 #undef CURRENT_INSN_pop
00963 #undef INSN_IS_SC
00964 #undef INSN_LABEL
00965 #undef LABEL_IS_SC
00966 END_INSN(pop);}}}
00967 INSN_ENTRY(dup){
00968 {
00969 VALUE val2;
00970 VALUE val1;
00971
00972 VALUE val = TOPN(0);
00973 DEBUG_ENTER_INSN("dup");
00974 ADD_PC(1+0);
00975 PREFETCH(GET_PC());
00976 POPN(1);
00977 #define CURRENT_INSN_dup 1
00978 #define INSN_IS_SC() 0
00979 #define INSN_LABEL(lab) LABEL_dup_##lab
00980 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
00981 USAGE_ANALYSIS_INSN(BIN(dup));
00982 {
00983 #line 646 "insns.def"
00984 val1 = val2 = val;
00985
00986 #line 987 "vm.inc"
00987 CHECK_STACK_OVERFLOW(REG_CFP, 2);
00988 PUSH(val1);
00989 PUSH(val2);
00990 #undef CURRENT_INSN_dup
00991 #undef INSN_IS_SC
00992 #undef INSN_LABEL
00993 #undef LABEL_IS_SC
00994 END_INSN(dup);}}}
00995 INSN_ENTRY(dupn){
00996 {
00997 rb_num_t n = (rb_num_t)GET_OPERAND(1);
00998
00999 DEBUG_ENTER_INSN("dupn");
01000 ADD_PC(1+1);
01001 PREFETCH(GET_PC());
01002 #define CURRENT_INSN_dupn 1
01003 #define INSN_IS_SC() 0
01004 #define INSN_LABEL(lab) LABEL_dupn_##lab
01005 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01006 USAGE_ANALYSIS_INSN(BIN(dupn));
01007 USAGE_ANALYSIS_OPERAND(BIN(dupn), 0, n);
01008 {
01009 #line 660 "insns.def"
01010 rb_num_t i;
01011 VALUE *sp = STACK_ADDR_FROM_TOP(n);
01012 for (i = 0; i < n; i++) {
01013 GET_SP()[i] = sp[i];
01014 }
01015 INC_SP(n);
01016
01017 #line 1018 "vm.inc"
01018 #undef CURRENT_INSN_dupn
01019 #undef INSN_IS_SC
01020 #undef INSN_LABEL
01021 #undef LABEL_IS_SC
01022 END_INSN(dupn);}}}
01023 INSN_ENTRY(swap){
01024 {
01025
01026 VALUE val = TOPN(1);
01027 VALUE obj = TOPN(0);
01028 DEBUG_ENTER_INSN("swap");
01029 ADD_PC(1+0);
01030 PREFETCH(GET_PC());
01031 POPN(2);
01032 #define CURRENT_INSN_swap 1
01033 #define INSN_IS_SC() 0
01034 #define INSN_LABEL(lab) LABEL_swap_##lab
01035 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01036 USAGE_ANALYSIS_INSN(BIN(swap));
01037 {
01038 #line 680 "insns.def"
01039
01040
01041 #line 1042 "vm.inc"
01042 CHECK_STACK_OVERFLOW(REG_CFP, 2);
01043 PUSH(obj);
01044 PUSH(val);
01045 #undef CURRENT_INSN_swap
01046 #undef INSN_IS_SC
01047 #undef INSN_LABEL
01048 #undef LABEL_IS_SC
01049 END_INSN(swap);}}}
01050 INSN_ENTRY(reput){
01051 {
01052
01053 VALUE val = TOPN(0);
01054 DEBUG_ENTER_INSN("reput");
01055 ADD_PC(1+0);
01056 PREFETCH(GET_PC());
01057 POPN(1);
01058 #define CURRENT_INSN_reput 1
01059 #define INSN_IS_SC() 0
01060 #define INSN_LABEL(lab) LABEL_reput_##lab
01061 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01062 USAGE_ANALYSIS_INSN(BIN(reput));
01063 {
01064 #line 694 "insns.def"
01065
01066
01067 #line 1068 "vm.inc"
01068 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01069 PUSH(val);
01070 #undef CURRENT_INSN_reput
01071 #undef INSN_IS_SC
01072 #undef INSN_LABEL
01073 #undef LABEL_IS_SC
01074 END_INSN(reput);}}}
01075 INSN_ENTRY(topn){
01076 {
01077 VALUE val;
01078 rb_num_t n = (rb_num_t)GET_OPERAND(1);
01079
01080 DEBUG_ENTER_INSN("topn");
01081 ADD_PC(1+1);
01082 PREFETCH(GET_PC());
01083 #define CURRENT_INSN_topn 1
01084 #define INSN_IS_SC() 0
01085 #define INSN_LABEL(lab) LABEL_topn_##lab
01086 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01087 USAGE_ANALYSIS_INSN(BIN(topn));
01088 USAGE_ANALYSIS_OPERAND(BIN(topn), 0, n);
01089 {
01090 #line 708 "insns.def"
01091 val = TOPN(n);
01092
01093 #line 1094 "vm.inc"
01094 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01095 PUSH(val);
01096 #undef CURRENT_INSN_topn
01097 #undef INSN_IS_SC
01098 #undef INSN_LABEL
01099 #undef LABEL_IS_SC
01100 END_INSN(topn);}}}
01101 INSN_ENTRY(setn){
01102 {
01103 rb_num_t n = (rb_num_t)GET_OPERAND(1);
01104 VALUE val = TOPN(0);
01105 DEBUG_ENTER_INSN("setn");
01106 ADD_PC(1+1);
01107 PREFETCH(GET_PC());
01108 POPN(1);
01109 #define CURRENT_INSN_setn 1
01110 #define INSN_IS_SC() 0
01111 #define INSN_LABEL(lab) LABEL_setn_##lab
01112 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01113 USAGE_ANALYSIS_INSN(BIN(setn));
01114 USAGE_ANALYSIS_OPERAND(BIN(setn), 0, n);
01115 {
01116 #line 722 "insns.def"
01117 TOPN(n-1) = val;
01118
01119 #line 1120 "vm.inc"
01120 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01121 PUSH(val);
01122 #undef CURRENT_INSN_setn
01123 #undef INSN_IS_SC
01124 #undef INSN_LABEL
01125 #undef LABEL_IS_SC
01126 END_INSN(setn);}}}
01127 INSN_ENTRY(adjuststack){
01128 {
01129 rb_num_t n = (rb_num_t)GET_OPERAND(1);
01130
01131 DEBUG_ENTER_INSN("adjuststack");
01132 ADD_PC(1+1);
01133 PREFETCH(GET_PC());
01134 #define CURRENT_INSN_adjuststack 1
01135 #define INSN_IS_SC() 0
01136 #define INSN_LABEL(lab) LABEL_adjuststack_##lab
01137 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01138 USAGE_ANALYSIS_INSN(BIN(adjuststack));
01139 USAGE_ANALYSIS_OPERAND(BIN(adjuststack), 0, n);
01140 {
01141 #line 736 "insns.def"
01142 DEC_SP(n);
01143
01144 #line 1145 "vm.inc"
01145 #undef CURRENT_INSN_adjuststack
01146 #undef INSN_IS_SC
01147 #undef INSN_LABEL
01148 #undef LABEL_IS_SC
01149 END_INSN(adjuststack);}}}
01150 INSN_ENTRY(defined){
01151 {
01152 VALUE val;
01153 VALUE needstr = (VALUE)GET_OPERAND(3);
01154 VALUE obj = (VALUE)GET_OPERAND(2);
01155 rb_num_t op_type = (rb_num_t)GET_OPERAND(1);
01156 VALUE v = TOPN(0);
01157 DEBUG_ENTER_INSN("defined");
01158 ADD_PC(1+3);
01159 PREFETCH(GET_PC());
01160 POPN(1);
01161 #define CURRENT_INSN_defined 1
01162 #define INSN_IS_SC() 0
01163 #define INSN_LABEL(lab) LABEL_defined_##lab
01164 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01165 USAGE_ANALYSIS_INSN(BIN(defined));
01166 USAGE_ANALYSIS_OPERAND(BIN(defined), 0, op_type);
01167 USAGE_ANALYSIS_OPERAND(BIN(defined), 1, obj);
01168 USAGE_ANALYSIS_OPERAND(BIN(defined), 2, needstr);
01169 {
01170 #line 755 "insns.def"
01171 VALUE klass;
01172 const char *expr_type = 0;
01173 enum defined_type type = (enum defined_type)op_type;
01174
01175 val = Qnil;
01176
01177 switch (type) {
01178 case DEFINED_IVAR:
01179 if (rb_ivar_defined(GET_SELF(), SYM2ID(obj))) {
01180 expr_type = "instance-variable";
01181 }
01182 break;
01183 case DEFINED_IVAR2:
01184 klass = vm_get_cbase(GET_ISEQ(), GET_LFP(), GET_DFP());
01185 break;
01186 case DEFINED_GVAR:
01187 if (rb_gvar_defined(rb_global_entry(SYM2ID(obj)))) {
01188 expr_type = "global-variable";
01189 }
01190 break;
01191 case DEFINED_CVAR:
01192 {
01193 NODE *cref = vm_get_cref(GET_ISEQ(), GET_LFP(), GET_DFP());
01194 klass = vm_get_cvar_base(cref);
01195 if (rb_cvar_defined(klass, SYM2ID(obj))) {
01196 expr_type = "class variable";
01197 }
01198 break;
01199 }
01200 case DEFINED_CONST:
01201 klass = v;
01202 if (vm_get_ev_const(th, GET_ISEQ(), klass, SYM2ID(obj), 1)) {
01203 expr_type = "constant";
01204 }
01205 break;
01206 case DEFINED_FUNC:
01207 klass = CLASS_OF(v);
01208 if (rb_method_boundp(klass, SYM2ID(obj), 0)) {
01209 expr_type = "method";
01210 }
01211 break;
01212 case DEFINED_METHOD:{
01213 VALUE klass = CLASS_OF(v);
01214 const rb_method_entry_t *me = rb_method_entry(klass, SYM2ID(obj));
01215
01216 if (me) {
01217 if (!(me->flag & NOEX_PRIVATE)) {
01218 if (!((me->flag & NOEX_PROTECTED) &&
01219 !rb_obj_is_kind_of(GET_SELF(),
01220 rb_class_real(klass)))) {
01221 expr_type = "method";
01222 }
01223 }
01224 }
01225 {
01226 VALUE args[2];
01227 VALUE r;
01228
01229 args[0] = obj; args[1] = Qfalse;
01230 r = rb_check_funcall(v, rb_intern("respond_to_missing?"), 2, args);
01231 if (r != Qundef && RTEST(r))
01232 expr_type = "method";
01233 }
01234 break;
01235 }
01236 case DEFINED_YIELD:
01237 if (GET_BLOCK_PTR()) {
01238 expr_type = "yield";
01239 }
01240 break;
01241 case DEFINED_ZSUPER:{
01242 rb_iseq_t *iseq = GET_ISEQ();
01243 while (iseq) {
01244 if (iseq->defined_method_id) {
01245 break;
01246 }
01247 iseq = iseq->parent_iseq;
01248 }
01249 if (iseq) {
01250 VALUE klass = vm_search_normal_superclass(iseq->klass, GET_SELF());
01251 if (rb_method_boundp(klass, iseq->defined_method_id, 0)) {
01252 expr_type = "super";
01253 }
01254 }
01255 break;
01256 }
01257 case DEFINED_REF:{
01258 val = vm_getspecial(th, GET_LFP(), Qfalse, FIX2INT(obj));
01259 if (val != Qnil) {
01260 expr_type = "global-variable";
01261 }
01262 break;
01263 }
01264 default:
01265 rb_bug("unimplemented defined? type (VM)");
01266 break;
01267 }
01268 if (expr_type != 0) {
01269 if (needstr != Qfalse) {
01270 val = rb_str_new2(expr_type);
01271 }
01272 else {
01273 val = Qtrue;
01274 }
01275 }
01276
01277 #line 1278 "vm.inc"
01278 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01279 PUSH(val);
01280 #undef CURRENT_INSN_defined
01281 #undef INSN_IS_SC
01282 #undef INSN_LABEL
01283 #undef LABEL_IS_SC
01284 END_INSN(defined);}}}
01285 INSN_ENTRY(trace){
01286 {
01287 rb_num_t nf = (rb_num_t)GET_OPERAND(1);
01288
01289 DEBUG_ENTER_INSN("trace");
01290 ADD_PC(1+1);
01291 PREFETCH(GET_PC());
01292 #define CURRENT_INSN_trace 1
01293 #define INSN_IS_SC() 0
01294 #define INSN_LABEL(lab) LABEL_trace_##lab
01295 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01296 USAGE_ANALYSIS_INSN(BIN(trace));
01297 USAGE_ANALYSIS_OPERAND(BIN(trace), 0, nf);
01298 {
01299 #line 873 "insns.def"
01300 rb_event_flag_t flag = (rb_event_flag_t)nf;
01301
01302 EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0 );
01303
01304 #line 1305 "vm.inc"
01305 #undef CURRENT_INSN_trace
01306 #undef INSN_IS_SC
01307 #undef INSN_LABEL
01308 #undef LABEL_IS_SC
01309 END_INSN(trace);}}}
01310 INSN_ENTRY(defineclass){
01311 {
01312 VALUE val;
01313 rb_num_t define_type = (rb_num_t)GET_OPERAND(3);
01314 ISEQ class_iseq = (ISEQ)GET_OPERAND(2);
01315 ID id = (ID)GET_OPERAND(1);
01316 VALUE cbase = TOPN(1);
01317 VALUE super = TOPN(0);
01318 DEBUG_ENTER_INSN("defineclass");
01319 ADD_PC(1+3);
01320 PREFETCH(GET_PC());
01321 POPN(2);
01322 #define CURRENT_INSN_defineclass 1
01323 #define INSN_IS_SC() 0
01324 #define INSN_LABEL(lab) LABEL_defineclass_##lab
01325 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01326 USAGE_ANALYSIS_INSN(BIN(defineclass));
01327 USAGE_ANALYSIS_OPERAND(BIN(defineclass), 0, id);
01328 USAGE_ANALYSIS_OPERAND(BIN(defineclass), 1, class_iseq);
01329 USAGE_ANALYSIS_OPERAND(BIN(defineclass), 2, define_type);
01330 {
01331 #line 897 "insns.def"
01332 VALUE klass;
01333
01334 switch ((int)define_type) {
01335 case 0:
01336 case 3:
01337
01338
01339 if (super == Qnil) {
01340 super = rb_cObject;
01341 }
01342
01343 vm_check_if_namespace(cbase);
01344
01345
01346 rb_autoload_load(cbase, id);
01347 if ((klass = vm_search_const_defined_class(cbase, id)) != 0) {
01348
01349 klass = define_type == 0 ? rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id);
01350 if (TYPE(klass) != T_CLASS) {
01351 rb_raise(rb_eTypeError, "%s is not a class", rb_id2name(id));
01352 }
01353
01354 if (super != rb_cObject) {
01355 VALUE tmp;
01356 tmp = rb_class_real(RCLASS_SUPER(klass));
01357
01358 if (tmp != super) {
01359 rb_raise(rb_eTypeError, "superclass mismatch for class %s",
01360 rb_id2name(id));
01361 }
01362 }
01363 }
01364 else {
01365
01366 klass = rb_define_class_id(id, super);
01367 rb_set_class_path_string(klass, cbase, rb_id2str(id));
01368 rb_const_set(cbase, id, klass);
01369 rb_class_inherited(super, klass);
01370 }
01371 break;
01372 case 1:
01373
01374
01375 klass = rb_singleton_class(cbase);
01376 break;
01377 case 2:
01378 case 5:
01379
01380
01381
01382 vm_check_if_namespace(cbase);
01383
01384
01385 if ((klass = vm_search_const_defined_class(cbase, id)) != 0) {
01386 klass = define_type == 2 ? rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id);
01387
01388 if (TYPE(klass) != T_MODULE) {
01389 rb_raise(rb_eTypeError, "%s is not a module", rb_id2name(id));
01390 }
01391 }
01392 else {
01393
01394 klass = rb_define_module_id(id);
01395 rb_set_class_path_string(klass, cbase, rb_id2str(id));
01396 rb_const_set(cbase, id, klass);
01397 }
01398 break;
01399 default:
01400 rb_bug("unknown defineclass type: %d", (int)define_type);
01401 }
01402
01403 COPY_CREF(class_iseq->cref_stack, vm_cref_push(th, klass, NOEX_PUBLIC, NULL));
01404
01405
01406 vm_push_frame(th, class_iseq,
01407 VM_FRAME_MAGIC_CLASS, klass, (VALUE) GET_BLOCK_PTR(),
01408 class_iseq->iseq_encoded, GET_SP(), 0,
01409 class_iseq->local_size);
01410 RESTORE_REGS();
01411
01412 INC_VM_STATE_VERSION();
01413 NEXT_INSN();
01414
01415 #line 1416 "vm.inc"
01416 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01417 PUSH(val);
01418 #undef CURRENT_INSN_defineclass
01419 #undef INSN_IS_SC
01420 #undef INSN_LABEL
01421 #undef LABEL_IS_SC
01422 END_INSN(defineclass);}}}
01423 INSN_ENTRY(send){
01424 {
01425 VALUE val;
01426 IC ic = (IC)GET_OPERAND(5);
01427 rb_num_t op_flag = (rb_num_t)GET_OPERAND(4);
01428 ISEQ blockiseq = (ISEQ)GET_OPERAND(3);
01429 rb_num_t op_argc = (rb_num_t)GET_OPERAND(2);
01430 ID op_id = (ID)GET_OPERAND(1);
01431
01432 DEBUG_ENTER_INSN("send");
01433 ADD_PC(1+5);
01434 PREFETCH(GET_PC());
01435 #define CURRENT_INSN_send 1
01436 #define INSN_IS_SC() 0
01437 #define INSN_LABEL(lab) LABEL_send_##lab
01438 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01439 USAGE_ANALYSIS_INSN(BIN(send));
01440 USAGE_ANALYSIS_OPERAND(BIN(send), 0, op_id);
01441 USAGE_ANALYSIS_OPERAND(BIN(send), 1, op_argc);
01442 USAGE_ANALYSIS_OPERAND(BIN(send), 2, blockiseq);
01443 USAGE_ANALYSIS_OPERAND(BIN(send), 3, op_flag);
01444 USAGE_ANALYSIS_OPERAND(BIN(send), 4, ic);
01445 {
01446 #line 1003 "insns.def"
01447 const rb_method_entry_t *me;
01448 VALUE recv, klass;
01449 rb_block_t *blockptr = 0;
01450 VALUE flag = op_flag;
01451 int num = caller_setup_args(th, GET_CFP(), flag, (int)op_argc,
01452 (rb_iseq_t *)blockiseq, &blockptr);
01453 ID id = op_id;
01454
01455
01456 recv = TOPN(num);
01457 klass = CLASS_OF(recv);
01458 me = vm_method_search(id, klass, ic);
01459 CALL_METHOD(num, blockptr, flag, id, me, recv);
01460
01461 #line 1462 "vm.inc"
01462 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01463 PUSH(val);
01464 #undef CURRENT_INSN_send
01465 #undef INSN_IS_SC
01466 #undef INSN_LABEL
01467 #undef LABEL_IS_SC
01468 END_INSN(send);}}}
01469 INSN_ENTRY(invokesuper){
01470 {
01471 VALUE val;
01472 rb_num_t op_flag = (rb_num_t)GET_OPERAND(3);
01473 ISEQ blockiseq = (ISEQ)GET_OPERAND(2);
01474 rb_num_t op_argc = (rb_num_t)GET_OPERAND(1);
01475
01476 DEBUG_ENTER_INSN("invokesuper");
01477 ADD_PC(1+3);
01478 PREFETCH(GET_PC());
01479 #define CURRENT_INSN_invokesuper 1
01480 #define INSN_IS_SC() 0
01481 #define INSN_LABEL(lab) LABEL_invokesuper_##lab
01482 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01483 USAGE_ANALYSIS_INSN(BIN(invokesuper));
01484 USAGE_ANALYSIS_OPERAND(BIN(invokesuper), 0, op_argc);
01485 USAGE_ANALYSIS_OPERAND(BIN(invokesuper), 1, blockiseq);
01486 USAGE_ANALYSIS_OPERAND(BIN(invokesuper), 2, op_flag);
01487 {
01488 #line 1031 "insns.def"
01489 rb_block_t *blockptr = !(op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? GET_BLOCK_PTR() : 0;
01490 VALUE flag = op_flag;
01491 int num = caller_setup_args(th, GET_CFP(), flag,
01492 (int)op_argc, blockiseq, &blockptr);
01493 VALUE recv, klass;
01494 ID id;
01495 const rb_method_entry_t *me;
01496
01497 flag = VM_CALL_SUPER_BIT | VM_CALL_FCALL_BIT;
01498
01499 recv = GET_SELF();
01500 vm_search_superclass(GET_CFP(), GET_ISEQ(), recv, TOPN(num), &id, &klass);
01501
01502
01503 if (!rb_obj_is_kind_of(recv, klass)) {
01504 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");
01505 }
01506
01507 me = rb_method_entry(klass, id);
01508
01509 CALL_METHOD(num, blockptr, flag, id, me, recv);
01510
01511 #line 1512 "vm.inc"
01512 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01513 PUSH(val);
01514 #undef CURRENT_INSN_invokesuper
01515 #undef INSN_IS_SC
01516 #undef INSN_LABEL
01517 #undef LABEL_IS_SC
01518 END_INSN(invokesuper);}}}
01519 INSN_ENTRY(invokeblock){
01520 {
01521 VALUE val;
01522 rb_num_t flag = (rb_num_t)GET_OPERAND(2);
01523 rb_num_t num = (rb_num_t)GET_OPERAND(1);
01524
01525 DEBUG_ENTER_INSN("invokeblock");
01526 ADD_PC(1+2);
01527 PREFETCH(GET_PC());
01528 #define CURRENT_INSN_invokeblock 1
01529 #define INSN_IS_SC() 0
01530 #define INSN_LABEL(lab) LABEL_invokeblock_##lab
01531 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01532 USAGE_ANALYSIS_INSN(BIN(invokeblock));
01533 USAGE_ANALYSIS_OPERAND(BIN(invokeblock), 0, num);
01534 USAGE_ANALYSIS_OPERAND(BIN(invokeblock), 1, flag);
01535 {
01536 #line 1066 "insns.def"
01537 val = vm_invoke_block(th, GET_CFP(), num, flag);
01538 if (val == Qundef) {
01539 RESTORE_REGS();
01540 NEXT_INSN();
01541 }
01542
01543 #line 1544 "vm.inc"
01544 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01545 PUSH(val);
01546 #undef CURRENT_INSN_invokeblock
01547 #undef INSN_IS_SC
01548 #undef INSN_LABEL
01549 #undef LABEL_IS_SC
01550 END_INSN(invokeblock);}}}
01551 INSN_ENTRY(leave){
01552 {
01553
01554 VALUE val = TOPN(0);
01555 DEBUG_ENTER_INSN("leave");
01556 ADD_PC(1+0);
01557 PREFETCH(GET_PC());
01558 POPN(1);
01559 #define CURRENT_INSN_leave 1
01560 #define INSN_IS_SC() 0
01561 #define INSN_LABEL(lab) LABEL_leave_##lab
01562 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01563 USAGE_ANALYSIS_INSN(BIN(leave));
01564 {
01565 #line 1084 "insns.def"
01566 if (OPT_CHECKED_RUN) {
01567 if (reg_cfp->sp != reg_cfp->bp) {
01568 rb_bug("Stack consistency error (sp: %"PRIdPTRDIFF", bp: %"PRIdPTRDIFF")",
01569 VM_SP_CNT(th, reg_cfp->sp), VM_SP_CNT(th, reg_cfp->bp));
01570 }
01571 }
01572
01573 RUBY_VM_CHECK_INTS();
01574 vm_pop_frame(th);
01575 RESTORE_REGS();
01576
01577 #line 1578 "vm.inc"
01578 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01579 PUSH(val);
01580 #undef CURRENT_INSN_leave
01581 #undef INSN_IS_SC
01582 #undef INSN_LABEL
01583 #undef LABEL_IS_SC
01584 END_INSN(leave);}}}
01585 INSN_ENTRY(finish){
01586 {
01587
01588 VALUE val = TOPN(0);
01589 DEBUG_ENTER_INSN("finish");
01590 ADD_PC(1+0);
01591 PREFETCH(GET_PC());
01592 POPN(1);
01593 #define CURRENT_INSN_finish 1
01594 #define INSN_IS_SC() 0
01595 #define INSN_LABEL(lab) LABEL_finish_##lab
01596 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01597 USAGE_ANALYSIS_INSN(BIN(finish));
01598 {
01599 #line 1107 "insns.def"
01600 #if OPT_CALL_THREADED_CODE
01601 rb_bug("unused instruction on OPT_CALL_THREADED_CODE");
01602 #else
01603 th->cfp++;
01604 return val;
01605 #endif
01606
01607 #line 1608 "vm.inc"
01608 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01609 PUSH(val);
01610 #undef CURRENT_INSN_finish
01611 #undef INSN_IS_SC
01612 #undef INSN_LABEL
01613 #undef LABEL_IS_SC
01614 END_INSN(finish);}}}
01615 INSN_ENTRY(throw){
01616 {
01617 VALUE val;
01618 rb_num_t throw_state = (rb_num_t)GET_OPERAND(1);
01619 VALUE throwobj = TOPN(0);
01620 DEBUG_ENTER_INSN("throw");
01621 ADD_PC(1+1);
01622 PREFETCH(GET_PC());
01623 POPN(1);
01624 #define CURRENT_INSN_throw 1
01625 #define INSN_IS_SC() 0
01626 #define INSN_LABEL(lab) LABEL_throw_##lab
01627 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01628 USAGE_ANALYSIS_INSN(BIN(throw));
01629 USAGE_ANALYSIS_OPERAND(BIN(throw), 0, throw_state);
01630 {
01631 #line 1130 "insns.def"
01632 RUBY_VM_CHECK_INTS();
01633 val = vm_throw(th, GET_CFP(), throw_state, throwobj);
01634 THROW_EXCEPTION(val);
01635
01636
01637 #line 1638 "vm.inc"
01638 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01639 PUSH(val);
01640 #undef CURRENT_INSN_throw
01641 #undef INSN_IS_SC
01642 #undef INSN_LABEL
01643 #undef LABEL_IS_SC
01644 END_INSN(throw);}}}
01645 INSN_ENTRY(jump){
01646 {
01647 OFFSET dst = (OFFSET)GET_OPERAND(1);
01648
01649 DEBUG_ENTER_INSN("jump");
01650 ADD_PC(1+1);
01651 PREFETCH(GET_PC());
01652 #define CURRENT_INSN_jump 1
01653 #define INSN_IS_SC() 0
01654 #define INSN_LABEL(lab) LABEL_jump_##lab
01655 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01656 USAGE_ANALYSIS_INSN(BIN(jump));
01657 USAGE_ANALYSIS_OPERAND(BIN(jump), 0, dst);
01658 {
01659 #line 1151 "insns.def"
01660 RUBY_VM_CHECK_INTS();
01661 JUMP(dst);
01662
01663 #line 1664 "vm.inc"
01664 #undef CURRENT_INSN_jump
01665 #undef INSN_IS_SC
01666 #undef INSN_LABEL
01667 #undef LABEL_IS_SC
01668 END_INSN(jump);}}}
01669 INSN_ENTRY(branchif){
01670 {
01671 OFFSET dst = (OFFSET)GET_OPERAND(1);
01672 VALUE val = TOPN(0);
01673 DEBUG_ENTER_INSN("branchif");
01674 ADD_PC(1+1);
01675 PREFETCH(GET_PC());
01676 POPN(1);
01677 #define CURRENT_INSN_branchif 1
01678 #define INSN_IS_SC() 0
01679 #define INSN_LABEL(lab) LABEL_branchif_##lab
01680 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01681 USAGE_ANALYSIS_INSN(BIN(branchif));
01682 USAGE_ANALYSIS_OPERAND(BIN(branchif), 0, dst);
01683 {
01684 #line 1166 "insns.def"
01685 if (RTEST(val)) {
01686 RUBY_VM_CHECK_INTS();
01687 JUMP(dst);
01688 }
01689
01690 #line 1691 "vm.inc"
01691 #undef CURRENT_INSN_branchif
01692 #undef INSN_IS_SC
01693 #undef INSN_LABEL
01694 #undef LABEL_IS_SC
01695 END_INSN(branchif);}}}
01696 INSN_ENTRY(branchunless){
01697 {
01698 OFFSET dst = (OFFSET)GET_OPERAND(1);
01699 VALUE val = TOPN(0);
01700 DEBUG_ENTER_INSN("branchunless");
01701 ADD_PC(1+1);
01702 PREFETCH(GET_PC());
01703 POPN(1);
01704 #define CURRENT_INSN_branchunless 1
01705 #define INSN_IS_SC() 0
01706 #define INSN_LABEL(lab) LABEL_branchunless_##lab
01707 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01708 USAGE_ANALYSIS_INSN(BIN(branchunless));
01709 USAGE_ANALYSIS_OPERAND(BIN(branchunless), 0, dst);
01710 {
01711 #line 1183 "insns.def"
01712 if (!RTEST(val)) {
01713 RUBY_VM_CHECK_INTS();
01714 JUMP(dst);
01715 }
01716
01717 #line 1718 "vm.inc"
01718 #undef CURRENT_INSN_branchunless
01719 #undef INSN_IS_SC
01720 #undef INSN_LABEL
01721 #undef LABEL_IS_SC
01722 END_INSN(branchunless);}}}
01723 INSN_ENTRY(getinlinecache){
01724 {
01725 VALUE val;
01726 IC ic = (IC)GET_OPERAND(2);
01727 OFFSET dst = (OFFSET)GET_OPERAND(1);
01728
01729 DEBUG_ENTER_INSN("getinlinecache");
01730 ADD_PC(1+2);
01731 PREFETCH(GET_PC());
01732 #define CURRENT_INSN_getinlinecache 1
01733 #define INSN_IS_SC() 0
01734 #define INSN_LABEL(lab) LABEL_getinlinecache_##lab
01735 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01736 USAGE_ANALYSIS_INSN(BIN(getinlinecache));
01737 USAGE_ANALYSIS_OPERAND(BIN(getinlinecache), 0, dst);
01738 USAGE_ANALYSIS_OPERAND(BIN(getinlinecache), 1, ic);
01739 {
01740 #line 1205 "insns.def"
01741 if (ic->ic_vmstat == GET_VM_STATE_VERSION()) {
01742 val = ic->ic_value.value;
01743 JUMP(dst);
01744 }
01745 else {
01746
01747 val = Qnil;
01748 }
01749
01750 #line 1751 "vm.inc"
01751 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01752 PUSH(val);
01753 #undef CURRENT_INSN_getinlinecache
01754 #undef INSN_IS_SC
01755 #undef INSN_LABEL
01756 #undef LABEL_IS_SC
01757 END_INSN(getinlinecache);}}}
01758 INSN_ENTRY(onceinlinecache){
01759 {
01760 VALUE val;
01761 IC ic = (IC)GET_OPERAND(2);
01762 OFFSET dst = (OFFSET)GET_OPERAND(1);
01763
01764 DEBUG_ENTER_INSN("onceinlinecache");
01765 ADD_PC(1+2);
01766 PREFETCH(GET_PC());
01767 #define CURRENT_INSN_onceinlinecache 1
01768 #define INSN_IS_SC() 0
01769 #define INSN_LABEL(lab) LABEL_onceinlinecache_##lab
01770 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01771 USAGE_ANALYSIS_INSN(BIN(onceinlinecache));
01772 USAGE_ANALYSIS_OPERAND(BIN(onceinlinecache), 0, dst);
01773 USAGE_ANALYSIS_OPERAND(BIN(onceinlinecache), 1, ic);
01774 {
01775 #line 1226 "insns.def"
01776 retry:
01777 if (ic->ic_vmstat) {
01778 val = ic->ic_value.value;
01779 JUMP(dst);
01780 }
01781 else if (ic->ic_value.value == Qundef)
01782 {
01783 RUBY_VM_CHECK_INTS();
01784 rb_thread_schedule();
01785 goto retry;
01786 }
01787 else {
01788
01789 ic->ic_value.value = Qundef;
01790 val = Qnil;
01791 }
01792
01793 #line 1794 "vm.inc"
01794 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01795 PUSH(val);
01796 #undef CURRENT_INSN_onceinlinecache
01797 #undef INSN_IS_SC
01798 #undef INSN_LABEL
01799 #undef LABEL_IS_SC
01800 END_INSN(onceinlinecache);}}}
01801 INSN_ENTRY(setinlinecache){
01802 {
01803 IC ic = (IC)GET_OPERAND(1);
01804 VALUE val = TOPN(0);
01805 DEBUG_ENTER_INSN("setinlinecache");
01806 ADD_PC(1+1);
01807 PREFETCH(GET_PC());
01808 POPN(1);
01809 #define CURRENT_INSN_setinlinecache 1
01810 #define INSN_IS_SC() 0
01811 #define INSN_LABEL(lab) LABEL_setinlinecache_##lab
01812 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01813 USAGE_ANALYSIS_INSN(BIN(setinlinecache));
01814 USAGE_ANALYSIS_OPERAND(BIN(setinlinecache), 0, ic);
01815 {
01816 #line 1255 "insns.def"
01817 if (ic->ic_value.value == Qundef) {
01818 rb_ary_push(GET_ISEQ()->mark_ary, val);
01819 }
01820 ic->ic_value.value = val;
01821 ic->ic_vmstat = GET_VM_STATE_VERSION() - ruby_vm_const_missing_count;
01822 ruby_vm_const_missing_count = 0;
01823
01824 #line 1825 "vm.inc"
01825 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01826 PUSH(val);
01827 #undef CURRENT_INSN_setinlinecache
01828 #undef INSN_IS_SC
01829 #undef INSN_LABEL
01830 #undef LABEL_IS_SC
01831 END_INSN(setinlinecache);}}}
01832 INSN_ENTRY(opt_case_dispatch){
01833 {
01834 OFFSET else_offset = (OFFSET)GET_OPERAND(2);
01835 CDHASH hash = (CDHASH)GET_OPERAND(1);
01836 VALUE key = TOPN(0);
01837 DEBUG_ENTER_INSN("opt_case_dispatch");
01838 ADD_PC(1+2);
01839 PREFETCH(GET_PC());
01840 POPN(1);
01841 #define CURRENT_INSN_opt_case_dispatch 1
01842 #define INSN_IS_SC() 0
01843 #define INSN_LABEL(lab) LABEL_opt_case_dispatch_##lab
01844 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01845 USAGE_ANALYSIS_INSN(BIN(opt_case_dispatch));
01846 USAGE_ANALYSIS_OPERAND(BIN(opt_case_dispatch), 0, hash);
01847 USAGE_ANALYSIS_OPERAND(BIN(opt_case_dispatch), 1, else_offset);
01848 {
01849 #line 1274 "insns.def"
01850 switch(TYPE(key)) {
01851 case T_FLOAT: {
01852 double ival;
01853 if (modf(RFLOAT_VALUE(key), &ival) == 0.0) {
01854 key = FIXABLE(ival) ? LONG2FIX((long)ival) : rb_dbl2big(ival);
01855 }
01856 }
01857 case T_SYMBOL:
01858 case T_FIXNUM:
01859 case T_BIGNUM:
01860 case T_STRING:
01861 if (BASIC_OP_UNREDEFINED_P(BOP_EQQ)) {
01862 st_data_t val;
01863 if (st_lookup(RHASH_TBL(hash), key, &val)) {
01864 JUMP(FIX2INT((VALUE)val));
01865 }
01866 else {
01867 JUMP(else_offset);
01868 }
01869 break;
01870 }
01871 default:
01872 break;
01873 }
01874
01875 #line 1876 "vm.inc"
01876 #undef CURRENT_INSN_opt_case_dispatch
01877 #undef INSN_IS_SC
01878 #undef INSN_LABEL
01879 #undef LABEL_IS_SC
01880 END_INSN(opt_case_dispatch);}}}
01881 INSN_ENTRY(opt_checkenv){
01882 {
01883
01884
01885 DEBUG_ENTER_INSN("opt_checkenv");
01886 ADD_PC(1+0);
01887 PREFETCH(GET_PC());
01888 #define CURRENT_INSN_opt_checkenv 1
01889 #define INSN_IS_SC() 0
01890 #define INSN_LABEL(lab) LABEL_opt_checkenv_##lab
01891 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01892 USAGE_ANALYSIS_INSN(BIN(opt_checkenv));
01893 {
01894 #line 1311 "insns.def"
01895 if (GET_CFP()->bp != GET_DFP() + 1) {
01896 VALUE *new_dfp = GET_CFP()->bp - 1;
01897
01898 *new_dfp = *GET_DFP();
01899 SET_DFP(new_dfp);
01900 }
01901
01902 #line 1903 "vm.inc"
01903 #undef CURRENT_INSN_opt_checkenv
01904 #undef INSN_IS_SC
01905 #undef INSN_LABEL
01906 #undef LABEL_IS_SC
01907 END_INSN(opt_checkenv);}}}
01908 INSN_ENTRY(opt_plus){
01909 {
01910 VALUE val;
01911 IC ic = (IC)GET_OPERAND(1);
01912 VALUE recv = TOPN(1);
01913 VALUE obj = TOPN(0);
01914 DEBUG_ENTER_INSN("opt_plus");
01915 ADD_PC(1+1);
01916 PREFETCH(GET_PC());
01917 POPN(2);
01918 #define CURRENT_INSN_opt_plus 1
01919 #define INSN_IS_SC() 0
01920 #define INSN_LABEL(lab) LABEL_opt_plus_##lab
01921 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
01922 USAGE_ANALYSIS_INSN(BIN(opt_plus));
01923 USAGE_ANALYSIS_OPERAND(BIN(opt_plus), 0, ic);
01924 {
01925 #line 1333 "insns.def"
01926 if (0) {
01927
01928 }
01929 #if 1
01930 else if (FIXNUM_2_P(recv, obj) &&
01931 BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
01932
01933 #ifndef LONG_LONG_VALUE
01934 val = (recv + (obj & (~1)));
01935 if ((~(recv ^ obj) & (recv ^ val)) &
01936 ((VALUE)0x01 << ((sizeof(VALUE) * CHAR_BIT) - 1))) {
01937 val = rb_big_plus(rb_int2big(FIX2LONG(recv)),
01938 rb_int2big(FIX2LONG(obj)));
01939 }
01940 #else
01941 long a, b, c;
01942 a = FIX2LONG(recv);
01943 b = FIX2LONG(obj);
01944 c = a + b;
01945 if (FIXABLE(c)) {
01946 val = LONG2FIX(c);
01947 }
01948 else {
01949 val = rb_big_plus(rb_int2big(a), rb_int2big(b));
01950 }
01951 #endif
01952 }
01953 #endif
01954
01955 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
01956 if (0) {
01957 }
01958 #if 1
01959 else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
01960 HEAP_CLASS_OF(obj) == rb_cFloat &&
01961 BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
01962 val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
01963 }
01964 #endif
01965
01966 #if 1
01967 else if (HEAP_CLASS_OF(recv) == rb_cString &&
01968 HEAP_CLASS_OF(obj) == rb_cString &&
01969 BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
01970 val = rb_str_plus(recv, obj);
01971 }
01972 #endif
01973 #if 1
01974 else if (HEAP_CLASS_OF(recv) == rb_cArray &&
01975 BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
01976 val = rb_ary_plus(recv, obj);
01977 }
01978 #endif
01979 else {
01980 goto INSN_LABEL(normal_dispatch);
01981 }
01982 }
01983 else {
01984 INSN_LABEL(normal_dispatch):
01985 PUSH(recv);
01986 PUSH(obj);
01987 CALL_SIMPLE_METHOD(1, idPLUS, recv);
01988 }
01989
01990 #line 1991 "vm.inc"
01991 CHECK_STACK_OVERFLOW(REG_CFP, 1);
01992 PUSH(val);
01993 #undef CURRENT_INSN_opt_plus
01994 #undef INSN_IS_SC
01995 #undef INSN_LABEL
01996 #undef LABEL_IS_SC
01997 END_INSN(opt_plus);}}}
01998 INSN_ENTRY(opt_minus){
01999 {
02000 VALUE val;
02001 IC ic = (IC)GET_OPERAND(1);
02002 VALUE recv = TOPN(1);
02003 VALUE obj = TOPN(0);
02004 DEBUG_ENTER_INSN("opt_minus");
02005 ADD_PC(1+1);
02006 PREFETCH(GET_PC());
02007 POPN(2);
02008 #define CURRENT_INSN_opt_minus 1
02009 #define INSN_IS_SC() 0
02010 #define INSN_LABEL(lab) LABEL_opt_minus_##lab
02011 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02012 USAGE_ANALYSIS_INSN(BIN(opt_minus));
02013 USAGE_ANALYSIS_OPERAND(BIN(opt_minus), 0, ic);
02014 {
02015 #line 1409 "insns.def"
02016 if (FIXNUM_2_P(recv, obj) &&
02017 BASIC_OP_UNREDEFINED_P(BOP_MINUS)) {
02018 long a, b, c;
02019
02020 a = FIX2LONG(recv);
02021 b = FIX2LONG(obj);
02022 c = a - b;
02023
02024 if (FIXABLE(c)) {
02025 val = LONG2FIX(c);
02026 }
02027 else {
02028 val = rb_big_minus(rb_int2big(a), rb_int2big(b));
02029 }
02030 }
02031 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02032 if (0) {
02033 }
02034 #if 1
02035 else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02036 HEAP_CLASS_OF(obj) == rb_cFloat &&
02037 BASIC_OP_UNREDEFINED_P(BOP_MINUS)) {
02038 val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
02039 }
02040 #endif
02041 else {
02042 goto INSN_LABEL(normal_dispatch);
02043 }
02044 }
02045 else {
02046
02047 INSN_LABEL(normal_dispatch):
02048 PUSH(recv);
02049 PUSH(obj);
02050 CALL_SIMPLE_METHOD(1, idMINUS, recv);
02051 }
02052
02053 #line 2054 "vm.inc"
02054 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02055 PUSH(val);
02056 #undef CURRENT_INSN_opt_minus
02057 #undef INSN_IS_SC
02058 #undef INSN_LABEL
02059 #undef LABEL_IS_SC
02060 END_INSN(opt_minus);}}}
02061 INSN_ENTRY(opt_mult){
02062 {
02063 VALUE val;
02064 IC ic = (IC)GET_OPERAND(1);
02065 VALUE recv = TOPN(1);
02066 VALUE obj = TOPN(0);
02067 DEBUG_ENTER_INSN("opt_mult");
02068 ADD_PC(1+1);
02069 PREFETCH(GET_PC());
02070 POPN(2);
02071 #define CURRENT_INSN_opt_mult 1
02072 #define INSN_IS_SC() 0
02073 #define INSN_LABEL(lab) LABEL_opt_mult_##lab
02074 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02075 USAGE_ANALYSIS_INSN(BIN(opt_mult));
02076 USAGE_ANALYSIS_OPERAND(BIN(opt_mult), 0, ic);
02077 {
02078 #line 1458 "insns.def"
02079 if (FIXNUM_2_P(recv, obj) &&
02080 BASIC_OP_UNREDEFINED_P(BOP_MULT)) {
02081 long a, b;
02082
02083 a = FIX2LONG(recv);
02084 if (a == 0) {
02085 val = recv;
02086 }
02087 else {
02088 volatile long c;
02089 b = FIX2LONG(obj);
02090 c = a * b;
02091
02092 if (FIXABLE(c) && c / a == b) {
02093 val = LONG2FIX(c);
02094 }
02095 else {
02096 val = rb_big_mul(rb_int2big(a), rb_int2big(b));
02097 }
02098 }
02099 }
02100 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02101 if (0) {
02102 }
02103 #if 1
02104 else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02105 HEAP_CLASS_OF(obj) == rb_cFloat &&
02106 BASIC_OP_UNREDEFINED_P(BOP_MULT)) {
02107 val = DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
02108 }
02109 #endif
02110 else {
02111 goto INSN_LABEL(normal_dispatch);
02112 }
02113 }
02114 else {
02115 INSN_LABEL(normal_dispatch):
02116 PUSH(recv);
02117 PUSH(obj);
02118 CALL_SIMPLE_METHOD(1, idMULT, recv);
02119 }
02120
02121 #line 2122 "vm.inc"
02122 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02123 PUSH(val);
02124 #undef CURRENT_INSN_opt_mult
02125 #undef INSN_IS_SC
02126 #undef INSN_LABEL
02127 #undef LABEL_IS_SC
02128 END_INSN(opt_mult);}}}
02129 INSN_ENTRY(opt_div){
02130 {
02131 VALUE val;
02132 IC ic = (IC)GET_OPERAND(1);
02133 VALUE recv = TOPN(1);
02134 VALUE obj = TOPN(0);
02135 DEBUG_ENTER_INSN("opt_div");
02136 ADD_PC(1+1);
02137 PREFETCH(GET_PC());
02138 POPN(2);
02139 #define CURRENT_INSN_opt_div 1
02140 #define INSN_IS_SC() 0
02141 #define INSN_LABEL(lab) LABEL_opt_div_##lab
02142 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02143 USAGE_ANALYSIS_INSN(BIN(opt_div));
02144 USAGE_ANALYSIS_OPERAND(BIN(opt_div), 0, ic);
02145 {
02146 #line 1512 "insns.def"
02147 if (FIXNUM_2_P(recv, obj) &&
02148 BASIC_OP_UNREDEFINED_P(BOP_DIV)) {
02149 long x, y, div;
02150
02151 x = FIX2LONG(recv);
02152 y = FIX2LONG(obj);
02153 {
02154
02155 long mod;
02156 if (y == 0)
02157 goto INSN_LABEL(normal_dispatch);
02158 if (y < 0) {
02159 if (x < 0)
02160 div = -x / -y;
02161 else
02162 div = -(x / -y);
02163 }
02164 else {
02165 if (x < 0)
02166 div = -(-x / y);
02167 else
02168 div = x / y;
02169 }
02170 mod = x - div * y;
02171 if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) {
02172 mod += y;
02173 div -= 1;
02174 }
02175 }
02176 val = LONG2NUM(div);
02177 }
02178 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02179 if (0) {
02180 }
02181 #if 1
02182 else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02183 HEAP_CLASS_OF(obj) == rb_cFloat &&
02184 BASIC_OP_UNREDEFINED_P(BOP_DIV)) {
02185 val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj));
02186 }
02187 #endif
02188 else {
02189 goto INSN_LABEL(normal_dispatch);
02190 }
02191 }
02192 else {
02193 INSN_LABEL(normal_dispatch):
02194 PUSH(recv);
02195 PUSH(obj);
02196 CALL_SIMPLE_METHOD(1, idDIV, recv);
02197 }
02198
02199 #line 2200 "vm.inc"
02200 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02201 PUSH(val);
02202 #undef CURRENT_INSN_opt_div
02203 #undef INSN_IS_SC
02204 #undef INSN_LABEL
02205 #undef LABEL_IS_SC
02206 END_INSN(opt_div);}}}
02207 INSN_ENTRY(opt_mod){
02208 {
02209 VALUE val;
02210 IC ic = (IC)GET_OPERAND(1);
02211 VALUE recv = TOPN(1);
02212 VALUE obj = TOPN(0);
02213 DEBUG_ENTER_INSN("opt_mod");
02214 ADD_PC(1+1);
02215 PREFETCH(GET_PC());
02216 POPN(2);
02217 #define CURRENT_INSN_opt_mod 1
02218 #define INSN_IS_SC() 0
02219 #define INSN_LABEL(lab) LABEL_opt_mod_##lab
02220 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02221 USAGE_ANALYSIS_INSN(BIN(opt_mod));
02222 USAGE_ANALYSIS_OPERAND(BIN(opt_mod), 0, ic);
02223 {
02224 #line 1576 "insns.def"
02225 if (FIXNUM_2_P(recv, obj) &&
02226 BASIC_OP_UNREDEFINED_P(BOP_MOD)) {
02227 long x, y, mod;
02228
02229 x = FIX2LONG(recv);
02230 y = FIX2LONG(obj);
02231 {
02232
02233 long div;
02234
02235 if (y == 0)
02236 rb_num_zerodiv();
02237 if (y < 0) {
02238 if (x < 0)
02239 div = -x / -y;
02240 else
02241 div = -(x / -y);
02242 }
02243 else {
02244 if (x < 0)
02245 div = -(-x / y);
02246 else
02247 div = x / y;
02248 }
02249 mod = x - div * y;
02250 if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) {
02251 mod += y;
02252 div -= 1;
02253 }
02254 }
02255 val = LONG2FIX(mod);
02256 }
02257 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02258 if (0) {
02259 }
02260 else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02261 HEAP_CLASS_OF(obj) == rb_cFloat &&
02262 BASIC_OP_UNREDEFINED_P(BOP_MOD)) {
02263 val = DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
02264 }
02265 else {
02266 goto INSN_LABEL(normal_dispatch);
02267 }
02268 }
02269 else {
02270 INSN_LABEL(normal_dispatch):
02271 PUSH(recv);
02272 PUSH(obj);
02273 CALL_SIMPLE_METHOD(1, idMOD, recv);
02274 }
02275
02276 #line 2277 "vm.inc"
02277 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02278 PUSH(val);
02279 #undef CURRENT_INSN_opt_mod
02280 #undef INSN_IS_SC
02281 #undef INSN_LABEL
02282 #undef LABEL_IS_SC
02283 END_INSN(opt_mod);}}}
02284 INSN_ENTRY(opt_eq){
02285 {
02286 VALUE val;
02287 IC ic = (IC)GET_OPERAND(1);
02288 VALUE recv = TOPN(1);
02289 VALUE obj = TOPN(0);
02290 DEBUG_ENTER_INSN("opt_eq");
02291 ADD_PC(1+1);
02292 PREFETCH(GET_PC());
02293 POPN(2);
02294 #define CURRENT_INSN_opt_eq 1
02295 #define INSN_IS_SC() 0
02296 #define INSN_LABEL(lab) LABEL_opt_eq_##lab
02297 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02298 USAGE_ANALYSIS_INSN(BIN(opt_eq));
02299 USAGE_ANALYSIS_OPERAND(BIN(opt_eq), 0, ic);
02300 {
02301 #line 1639 "insns.def"
02302 val = opt_eq_func(recv, obj, ic);
02303
02304 if (val == Qundef) {
02305
02306 PUSH(recv);
02307 PUSH(obj);
02308 CALL_SIMPLE_METHOD(1, idEq, recv);
02309 }
02310
02311 #line 2312 "vm.inc"
02312 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02313 PUSH(val);
02314 #undef CURRENT_INSN_opt_eq
02315 #undef INSN_IS_SC
02316 #undef INSN_LABEL
02317 #undef LABEL_IS_SC
02318 END_INSN(opt_eq);}}}
02319 INSN_ENTRY(opt_neq){
02320 {
02321 VALUE val;
02322 IC ic_eq = (IC)GET_OPERAND(2);
02323 IC ic = (IC)GET_OPERAND(1);
02324 VALUE recv = TOPN(1);
02325 VALUE obj = TOPN(0);
02326 DEBUG_ENTER_INSN("opt_neq");
02327 ADD_PC(1+2);
02328 PREFETCH(GET_PC());
02329 POPN(2);
02330 #define CURRENT_INSN_opt_neq 1
02331 #define INSN_IS_SC() 0
02332 #define INSN_LABEL(lab) LABEL_opt_neq_##lab
02333 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02334 USAGE_ANALYSIS_INSN(BIN(opt_neq));
02335 USAGE_ANALYSIS_OPERAND(BIN(opt_neq), 0, ic);
02336 USAGE_ANALYSIS_OPERAND(BIN(opt_neq), 1, ic_eq);
02337 {
02338 #line 1660 "insns.def"
02339 extern VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2);
02340 const rb_method_entry_t *me = vm_method_search(idNeq, CLASS_OF(recv), ic);
02341 val = Qundef;
02342
02343 if (check_cfunc(me, rb_obj_not_equal)) {
02344 val = opt_eq_func(recv, obj, ic_eq);
02345
02346 if (val != Qundef) {
02347 val = RTEST(val) ? Qfalse : Qtrue;
02348 }
02349 }
02350
02351 if (val == Qundef) {
02352
02353 PUSH(recv);
02354 PUSH(obj);
02355 CALL_SIMPLE_METHOD(1, idNeq, recv);
02356 }
02357
02358 #line 2359 "vm.inc"
02359 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02360 PUSH(val);
02361 #undef CURRENT_INSN_opt_neq
02362 #undef INSN_IS_SC
02363 #undef INSN_LABEL
02364 #undef LABEL_IS_SC
02365 END_INSN(opt_neq);}}}
02366 INSN_ENTRY(opt_lt){
02367 {
02368 VALUE val;
02369 IC ic = (IC)GET_OPERAND(1);
02370 VALUE recv = TOPN(1);
02371 VALUE obj = TOPN(0);
02372 DEBUG_ENTER_INSN("opt_lt");
02373 ADD_PC(1+1);
02374 PREFETCH(GET_PC());
02375 POPN(2);
02376 #define CURRENT_INSN_opt_lt 1
02377 #define INSN_IS_SC() 0
02378 #define INSN_LABEL(lab) LABEL_opt_lt_##lab
02379 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02380 USAGE_ANALYSIS_INSN(BIN(opt_lt));
02381 USAGE_ANALYSIS_OPERAND(BIN(opt_lt), 0, ic);
02382 {
02383 #line 1691 "insns.def"
02384 if (FIXNUM_2_P(recv, obj) &&
02385 BASIC_OP_UNREDEFINED_P(BOP_LT)) {
02386 SIGNED_VALUE a = recv, b = obj;
02387
02388 if (a < b) {
02389 val = Qtrue;
02390 }
02391 else {
02392 val = Qfalse;
02393 }
02394 }
02395 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02396 if (0) {
02397 }
02398 #if 1
02399 else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02400 HEAP_CLASS_OF(obj) == rb_cFloat &&
02401 BASIC_OP_UNREDEFINED_P(BOP_LT)) {
02402 double a = RFLOAT_VALUE(recv);
02403 double b = RFLOAT_VALUE(obj);
02404 #if defined(_MSC_VER) && _MSC_VER < 1300
02405 if (isnan(a) || isnan(b)) val = Qfalse;
02406 else
02407 #endif
02408 val = a < b ? Qtrue : Qfalse;
02409 }
02410 #endif
02411 else {
02412 goto INSN_LABEL(normal_dispatch);
02413 }
02414 }
02415 else {
02416 INSN_LABEL(normal_dispatch):
02417 PUSH(recv);
02418 PUSH(obj);
02419 CALL_SIMPLE_METHOD(1, idLT, recv);
02420 }
02421
02422 #line 2423 "vm.inc"
02423 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02424 PUSH(val);
02425 #undef CURRENT_INSN_opt_lt
02426 #undef INSN_IS_SC
02427 #undef INSN_LABEL
02428 #undef LABEL_IS_SC
02429 END_INSN(opt_lt);}}}
02430 INSN_ENTRY(opt_le){
02431 {
02432 VALUE val;
02433 IC ic = (IC)GET_OPERAND(1);
02434 VALUE recv = TOPN(1);
02435 VALUE obj = TOPN(0);
02436 DEBUG_ENTER_INSN("opt_le");
02437 ADD_PC(1+1);
02438 PREFETCH(GET_PC());
02439 POPN(2);
02440 #define CURRENT_INSN_opt_le 1
02441 #define INSN_IS_SC() 0
02442 #define INSN_LABEL(lab) LABEL_opt_le_##lab
02443 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02444 USAGE_ANALYSIS_INSN(BIN(opt_le));
02445 USAGE_ANALYSIS_OPERAND(BIN(opt_le), 0, ic);
02446 {
02447 #line 1741 "insns.def"
02448 if (FIXNUM_2_P(recv, obj) &&
02449 BASIC_OP_UNREDEFINED_P(BOP_LE)) {
02450 SIGNED_VALUE a = recv, b = obj;
02451
02452 if (a <= b) {
02453 val = Qtrue;
02454 }
02455 else {
02456 val = Qfalse;
02457 }
02458 }
02459 else {
02460
02461 PUSH(recv);
02462 PUSH(obj);
02463 CALL_SIMPLE_METHOD(1, idLE, recv);
02464 }
02465
02466 #line 2467 "vm.inc"
02467 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02468 PUSH(val);
02469 #undef CURRENT_INSN_opt_le
02470 #undef INSN_IS_SC
02471 #undef INSN_LABEL
02472 #undef LABEL_IS_SC
02473 END_INSN(opt_le);}}}
02474 INSN_ENTRY(opt_gt){
02475 {
02476 VALUE val;
02477 IC ic = (IC)GET_OPERAND(1);
02478 VALUE recv = TOPN(1);
02479 VALUE obj = TOPN(0);
02480 DEBUG_ENTER_INSN("opt_gt");
02481 ADD_PC(1+1);
02482 PREFETCH(GET_PC());
02483 POPN(2);
02484 #define CURRENT_INSN_opt_gt 1
02485 #define INSN_IS_SC() 0
02486 #define INSN_LABEL(lab) LABEL_opt_gt_##lab
02487 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02488 USAGE_ANALYSIS_INSN(BIN(opt_gt));
02489 USAGE_ANALYSIS_OPERAND(BIN(opt_gt), 0, ic);
02490 {
02491 #line 1771 "insns.def"
02492 if (FIXNUM_2_P(recv, obj) &&
02493 BASIC_OP_UNREDEFINED_P(BOP_GT)) {
02494 SIGNED_VALUE a = recv, b = obj;
02495
02496 if (a > b) {
02497 val = Qtrue;
02498 }
02499 else {
02500 val = Qfalse;
02501 }
02502 }
02503 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
02504 if (0) {
02505 }
02506 #if 1
02507 else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
02508 HEAP_CLASS_OF(obj) == rb_cFloat &&
02509 BASIC_OP_UNREDEFINED_P(BOP_GT)) {
02510 double a = RFLOAT_VALUE(recv);
02511 double b = RFLOAT_VALUE(obj);
02512 #if defined(_MSC_VER) && _MSC_VER < 1300
02513 if (isnan(a) || isnan(b)) val = Qfalse;
02514 else
02515 #endif
02516 val = a > b ? Qtrue : Qfalse;
02517 }
02518 #endif
02519 else {
02520 goto INSN_LABEL(normal_dispatch);
02521 }
02522 }
02523 else {
02524 INSN_LABEL(normal_dispatch):
02525 PUSH(recv);
02526 PUSH(obj);
02527 CALL_SIMPLE_METHOD(1, idGT, recv);
02528 }
02529
02530 #line 2531 "vm.inc"
02531 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02532 PUSH(val);
02533 #undef CURRENT_INSN_opt_gt
02534 #undef INSN_IS_SC
02535 #undef INSN_LABEL
02536 #undef LABEL_IS_SC
02537 END_INSN(opt_gt);}}}
02538 INSN_ENTRY(opt_ge){
02539 {
02540 VALUE val;
02541 IC ic = (IC)GET_OPERAND(1);
02542 VALUE recv = TOPN(1);
02543 VALUE obj = TOPN(0);
02544 DEBUG_ENTER_INSN("opt_ge");
02545 ADD_PC(1+1);
02546 PREFETCH(GET_PC());
02547 POPN(2);
02548 #define CURRENT_INSN_opt_ge 1
02549 #define INSN_IS_SC() 0
02550 #define INSN_LABEL(lab) LABEL_opt_ge_##lab
02551 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02552 USAGE_ANALYSIS_INSN(BIN(opt_ge));
02553 USAGE_ANALYSIS_OPERAND(BIN(opt_ge), 0, ic);
02554 {
02555 #line 1821 "insns.def"
02556 if (FIXNUM_2_P(recv, obj) &&
02557 BASIC_OP_UNREDEFINED_P(BOP_GE)) {
02558 SIGNED_VALUE a = recv, b = obj;
02559
02560 if (a >= b) {
02561 val = Qtrue;
02562 }
02563 else {
02564 val = Qfalse;
02565 }
02566 }
02567 else {
02568 PUSH(recv);
02569 PUSH(obj);
02570 CALL_SIMPLE_METHOD(1, idGE, recv);
02571 }
02572
02573 #line 2574 "vm.inc"
02574 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02575 PUSH(val);
02576 #undef CURRENT_INSN_opt_ge
02577 #undef INSN_IS_SC
02578 #undef INSN_LABEL
02579 #undef LABEL_IS_SC
02580 END_INSN(opt_ge);}}}
02581 INSN_ENTRY(opt_ltlt){
02582 {
02583 VALUE val;
02584 IC ic = (IC)GET_OPERAND(1);
02585 VALUE recv = TOPN(1);
02586 VALUE obj = TOPN(0);
02587 DEBUG_ENTER_INSN("opt_ltlt");
02588 ADD_PC(1+1);
02589 PREFETCH(GET_PC());
02590 POPN(2);
02591 #define CURRENT_INSN_opt_ltlt 1
02592 #define INSN_IS_SC() 0
02593 #define INSN_LABEL(lab) LABEL_opt_ltlt_##lab
02594 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02595 USAGE_ANALYSIS_INSN(BIN(opt_ltlt));
02596 USAGE_ANALYSIS_OPERAND(BIN(opt_ltlt), 0, ic);
02597 {
02598 #line 1850 "insns.def"
02599 if (!SPECIAL_CONST_P(recv)) {
02600 if (0) {
02601 }
02602 else if (HEAP_CLASS_OF(recv) == rb_cString &&
02603 BASIC_OP_UNREDEFINED_P(BOP_LTLT)) {
02604 val = rb_str_concat(recv, obj);
02605 }
02606 else if (HEAP_CLASS_OF(recv) == rb_cArray &&
02607 BASIC_OP_UNREDEFINED_P(BOP_LTLT)) {
02608 val = rb_ary_push(recv, obj);
02609 }
02610 else {
02611 goto INSN_LABEL(normal_dispatch);
02612 }
02613 }
02614 else {
02615 INSN_LABEL(normal_dispatch):
02616 PUSH(recv);
02617 PUSH(obj);
02618 CALL_SIMPLE_METHOD(1, idLTLT, recv);
02619 }
02620
02621 #line 2622 "vm.inc"
02622 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02623 PUSH(val);
02624 #undef CURRENT_INSN_opt_ltlt
02625 #undef INSN_IS_SC
02626 #undef INSN_LABEL
02627 #undef LABEL_IS_SC
02628 END_INSN(opt_ltlt);}}}
02629 INSN_ENTRY(opt_aref){
02630 {
02631 VALUE val;
02632 IC ic = (IC)GET_OPERAND(1);
02633 VALUE recv = TOPN(1);
02634 VALUE obj = TOPN(0);
02635 DEBUG_ENTER_INSN("opt_aref");
02636 ADD_PC(1+1);
02637 PREFETCH(GET_PC());
02638 POPN(2);
02639 #define CURRENT_INSN_opt_aref 1
02640 #define INSN_IS_SC() 0
02641 #define INSN_LABEL(lab) LABEL_opt_aref_##lab
02642 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02643 USAGE_ANALYSIS_INSN(BIN(opt_aref));
02644 USAGE_ANALYSIS_OPERAND(BIN(opt_aref), 0, ic);
02645 {
02646 #line 1884 "insns.def"
02647 if (!SPECIAL_CONST_P(recv) && BASIC_OP_UNREDEFINED_P(BOP_AREF)) {
02648 if (HEAP_CLASS_OF(recv) == rb_cArray && FIXNUM_P(obj)) {
02649 val = rb_ary_entry(recv, FIX2LONG(obj));
02650 }
02651 else if (HEAP_CLASS_OF(recv) == rb_cHash) {
02652 val = rb_hash_aref(recv, obj);
02653 }
02654 else {
02655 goto INSN_LABEL(normal_dispatch);
02656 }
02657 }
02658 else {
02659 INSN_LABEL(normal_dispatch):
02660 PUSH(recv);
02661 PUSH(obj);
02662 CALL_SIMPLE_METHOD(1, idAREF, recv);
02663 }
02664
02665 #line 2666 "vm.inc"
02666 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02667 PUSH(val);
02668 #undef CURRENT_INSN_opt_aref
02669 #undef INSN_IS_SC
02670 #undef INSN_LABEL
02671 #undef LABEL_IS_SC
02672 END_INSN(opt_aref);}}}
02673 INSN_ENTRY(opt_aset){
02674 {
02675 VALUE val;
02676 IC ic = (IC)GET_OPERAND(1);
02677 VALUE recv = TOPN(2);
02678 VALUE obj = TOPN(1);
02679 VALUE set = TOPN(0);
02680 DEBUG_ENTER_INSN("opt_aset");
02681 ADD_PC(1+1);
02682 PREFETCH(GET_PC());
02683 POPN(3);
02684 #define CURRENT_INSN_opt_aset 1
02685 #define INSN_IS_SC() 0
02686 #define INSN_LABEL(lab) LABEL_opt_aset_##lab
02687 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02688 USAGE_ANALYSIS_INSN(BIN(opt_aset));
02689 USAGE_ANALYSIS_OPERAND(BIN(opt_aset), 0, ic);
02690 {
02691 #line 1914 "insns.def"
02692 if (!SPECIAL_CONST_P(recv) &&
02693 BASIC_OP_UNREDEFINED_P(BOP_ASET)) {
02694 if (HEAP_CLASS_OF(recv) == rb_cArray && FIXNUM_P(obj)) {
02695 rb_ary_store(recv, FIX2LONG(obj), set);
02696 val = set;
02697 }
02698 else if (HEAP_CLASS_OF(recv) == rb_cHash) {
02699 rb_hash_aset(recv, obj, set);
02700 val = set;
02701 }
02702 else {
02703 goto INSN_LABEL(normal_dispatch);
02704 }
02705 }
02706 else {
02707 INSN_LABEL(normal_dispatch):
02708 PUSH(recv);
02709 PUSH(obj);
02710 PUSH(set);
02711 CALL_SIMPLE_METHOD(2, idASET, recv);
02712 }
02713
02714 #line 2715 "vm.inc"
02715 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02716 PUSH(val);
02717 #undef CURRENT_INSN_opt_aset
02718 #undef INSN_IS_SC
02719 #undef INSN_LABEL
02720 #undef LABEL_IS_SC
02721 END_INSN(opt_aset);}}}
02722 INSN_ENTRY(opt_length){
02723 {
02724 VALUE val;
02725 IC ic = (IC)GET_OPERAND(1);
02726 VALUE recv = TOPN(0);
02727 DEBUG_ENTER_INSN("opt_length");
02728 ADD_PC(1+1);
02729 PREFETCH(GET_PC());
02730 POPN(1);
02731 #define CURRENT_INSN_opt_length 1
02732 #define INSN_IS_SC() 0
02733 #define INSN_LABEL(lab) LABEL_opt_length_##lab
02734 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02735 USAGE_ANALYSIS_INSN(BIN(opt_length));
02736 USAGE_ANALYSIS_OPERAND(BIN(opt_length), 0, ic);
02737 {
02738 #line 1948 "insns.def"
02739 if (LIKELY(!SPECIAL_CONST_P(recv) &&
02740 BASIC_OP_UNREDEFINED_P(BOP_LENGTH))) {
02741 if (HEAP_CLASS_OF(recv) == rb_cString) {
02742 val = rb_str_length(recv);
02743 }
02744 else if (HEAP_CLASS_OF(recv) == rb_cArray) {
02745 val = LONG2NUM(RARRAY_LEN(recv));
02746 }
02747 else if (HEAP_CLASS_OF(recv) == rb_cHash) {
02748 val = INT2FIX(RHASH_SIZE(recv));
02749 }
02750 else {
02751 goto INSN_LABEL(normal_dispatch);
02752 }
02753 }
02754 else {
02755 INSN_LABEL(normal_dispatch):
02756 PUSH(recv);
02757 CALL_SIMPLE_METHOD(0, idLength, recv);
02758 }
02759
02760 #line 2761 "vm.inc"
02761 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02762 PUSH(val);
02763 #undef CURRENT_INSN_opt_length
02764 #undef INSN_IS_SC
02765 #undef INSN_LABEL
02766 #undef LABEL_IS_SC
02767 END_INSN(opt_length);}}}
02768 INSN_ENTRY(opt_size){
02769 {
02770 VALUE val;
02771 IC ic = (IC)GET_OPERAND(1);
02772 VALUE recv = TOPN(0);
02773 DEBUG_ENTER_INSN("opt_size");
02774 ADD_PC(1+1);
02775 PREFETCH(GET_PC());
02776 POPN(1);
02777 #define CURRENT_INSN_opt_size 1
02778 #define INSN_IS_SC() 0
02779 #define INSN_LABEL(lab) LABEL_opt_size_##lab
02780 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02781 USAGE_ANALYSIS_INSN(BIN(opt_size));
02782 USAGE_ANALYSIS_OPERAND(BIN(opt_size), 0, ic);
02783 {
02784 #line 1981 "insns.def"
02785 if (LIKELY(BASIC_OP_UNREDEFINED_P(BOP_SIZE) &&
02786 !SPECIAL_CONST_P(recv))) {
02787 if (HEAP_CLASS_OF(recv) == rb_cString) {
02788 val = rb_str_length(recv);
02789 }
02790 else if (HEAP_CLASS_OF(recv) == rb_cArray) {
02791 val = LONG2NUM(RARRAY_LEN(recv));
02792 }
02793 else if (HEAP_CLASS_OF(recv) == rb_cHash) {
02794 val = INT2FIX(RHASH_SIZE(recv));
02795 }
02796 else {
02797 goto INSN_LABEL(normal_dispatch);
02798 }
02799 }
02800 else {
02801 INSN_LABEL(normal_dispatch):
02802 PUSH(recv);
02803 CALL_SIMPLE_METHOD(0, idSize, recv);
02804 }
02805
02806 #line 2807 "vm.inc"
02807 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02808 PUSH(val);
02809 #undef CURRENT_INSN_opt_size
02810 #undef INSN_IS_SC
02811 #undef INSN_LABEL
02812 #undef LABEL_IS_SC
02813 END_INSN(opt_size);}}}
02814 INSN_ENTRY(opt_succ){
02815 {
02816 VALUE val;
02817 IC ic = (IC)GET_OPERAND(1);
02818 VALUE recv = TOPN(0);
02819 DEBUG_ENTER_INSN("opt_succ");
02820 ADD_PC(1+1);
02821 PREFETCH(GET_PC());
02822 POPN(1);
02823 #define CURRENT_INSN_opt_succ 1
02824 #define INSN_IS_SC() 0
02825 #define INSN_LABEL(lab) LABEL_opt_succ_##lab
02826 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02827 USAGE_ANALYSIS_INSN(BIN(opt_succ));
02828 USAGE_ANALYSIS_OPERAND(BIN(opt_succ), 0, ic);
02829 {
02830 #line 2014 "insns.def"
02831 if (SPECIAL_CONST_P(recv)) {
02832 if (FIXNUM_P(recv) &&
02833 BASIC_OP_UNREDEFINED_P(BOP_SUCC)) {
02834 const VALUE obj = INT2FIX(1);
02835
02836 val = (recv + (obj & (~1)));
02837 if ((~(recv ^ obj) & (recv ^ val)) & ((unsigned long)LONG_MAX + 1)) {
02838 val = rb_big_plus(rb_int2big(FIX2LONG(recv)),
02839 rb_int2big(FIX2LONG(obj)));
02840 }
02841 }
02842 else {
02843 goto INSN_LABEL(normal_dispatch);
02844 }
02845 }
02846 else {
02847 if (HEAP_CLASS_OF(recv) == rb_cString &&
02848 BASIC_OP_UNREDEFINED_P(BOP_SUCC)) {
02849 val = rb_str_succ(recv);
02850 }
02851 else if (HEAP_CLASS_OF(recv) == rb_cTime &&
02852 BASIC_OP_UNREDEFINED_P(BOP_SUCC)) {
02853 val = rb_time_succ(recv);
02854 }
02855 else
02856 {
02857 goto INSN_LABEL(normal_dispatch);
02858 }
02859 }
02860 if (0) {
02861 INSN_LABEL(normal_dispatch):
02862 PUSH(recv);
02863 CALL_SIMPLE_METHOD(0, idSucc, recv);
02864 }
02865
02866 #line 2867 "vm.inc"
02867 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02868 PUSH(val);
02869 #undef CURRENT_INSN_opt_succ
02870 #undef INSN_IS_SC
02871 #undef INSN_LABEL
02872 #undef LABEL_IS_SC
02873 END_INSN(opt_succ);}}}
02874 INSN_ENTRY(opt_not){
02875 {
02876 VALUE val;
02877 IC ic = (IC)GET_OPERAND(1);
02878 VALUE recv = TOPN(0);
02879 DEBUG_ENTER_INSN("opt_not");
02880 ADD_PC(1+1);
02881 PREFETCH(GET_PC());
02882 POPN(1);
02883 #define CURRENT_INSN_opt_not 1
02884 #define INSN_IS_SC() 0
02885 #define INSN_LABEL(lab) LABEL_opt_not_##lab
02886 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02887 USAGE_ANALYSIS_INSN(BIN(opt_not));
02888 USAGE_ANALYSIS_OPERAND(BIN(opt_not), 0, ic);
02889 {
02890 #line 2061 "insns.def"
02891 extern VALUE rb_obj_not(VALUE obj);
02892 const rb_method_entry_t *me = vm_method_search(idNot, CLASS_OF(recv), ic);
02893
02894 if (check_cfunc(me, rb_obj_not)) {
02895 val = RTEST(recv) ? Qfalse : Qtrue;
02896 }
02897 else {
02898 PUSH(recv);
02899 CALL_SIMPLE_METHOD(0, idNot, recv);
02900 }
02901
02902 #line 2903 "vm.inc"
02903 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02904 PUSH(val);
02905 #undef CURRENT_INSN_opt_not
02906 #undef INSN_IS_SC
02907 #undef INSN_LABEL
02908 #undef LABEL_IS_SC
02909 END_INSN(opt_not);}}}
02910 INSN_ENTRY(opt_regexpmatch1){
02911 {
02912 VALUE val;
02913 VALUE r = (VALUE)GET_OPERAND(1);
02914 VALUE obj = TOPN(0);
02915 DEBUG_ENTER_INSN("opt_regexpmatch1");
02916 ADD_PC(1+1);
02917 PREFETCH(GET_PC());
02918 POPN(1);
02919 #define CURRENT_INSN_opt_regexpmatch1 1
02920 #define INSN_IS_SC() 0
02921 #define INSN_LABEL(lab) LABEL_opt_regexpmatch1_##lab
02922 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02923 USAGE_ANALYSIS_INSN(BIN(opt_regexpmatch1));
02924 USAGE_ANALYSIS_OPERAND(BIN(opt_regexpmatch1), 0, r);
02925 {
02926 #line 2085 "insns.def"
02927 val = rb_reg_match(r, obj);
02928
02929 #line 2930 "vm.inc"
02930 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02931 PUSH(val);
02932 #undef CURRENT_INSN_opt_regexpmatch1
02933 #undef INSN_IS_SC
02934 #undef INSN_LABEL
02935 #undef LABEL_IS_SC
02936 END_INSN(opt_regexpmatch1);}}}
02937 INSN_ENTRY(opt_regexpmatch2){
02938 {
02939 VALUE val;
02940
02941 VALUE obj2 = TOPN(1);
02942 VALUE obj1 = TOPN(0);
02943 DEBUG_ENTER_INSN("opt_regexpmatch2");
02944 ADD_PC(1+0);
02945 PREFETCH(GET_PC());
02946 POPN(2);
02947 #define CURRENT_INSN_opt_regexpmatch2 1
02948 #define INSN_IS_SC() 0
02949 #define INSN_LABEL(lab) LABEL_opt_regexpmatch2_##lab
02950 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02951 USAGE_ANALYSIS_INSN(BIN(opt_regexpmatch2));
02952 {
02953 #line 2099 "insns.def"
02954 if (TYPE(obj2) == T_STRING) {
02955 val = rb_reg_match(obj1, obj2);
02956 }
02957 else {
02958 val = rb_funcall(obj2, idEqTilde, 1, obj1);
02959 }
02960
02961 #line 2962 "vm.inc"
02962 CHECK_STACK_OVERFLOW(REG_CFP, 1);
02963 PUSH(val);
02964 #undef CURRENT_INSN_opt_regexpmatch2
02965 #undef INSN_IS_SC
02966 #undef INSN_LABEL
02967 #undef LABEL_IS_SC
02968 END_INSN(opt_regexpmatch2);}}}
02969 INSN_ENTRY(opt_call_c_function){
02970 {
02971 rb_insn_func_t funcptr = (rb_insn_func_t)GET_OPERAND(1);
02972
02973 DEBUG_ENTER_INSN("opt_call_c_function");
02974 ADD_PC(1+1);
02975 PREFETCH(GET_PC());
02976 #define CURRENT_INSN_opt_call_c_function 1
02977 #define INSN_IS_SC() 0
02978 #define INSN_LABEL(lab) LABEL_opt_call_c_function_##lab
02979 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
02980 USAGE_ANALYSIS_INSN(BIN(opt_call_c_function));
02981 USAGE_ANALYSIS_OPERAND(BIN(opt_call_c_function), 0, funcptr);
02982 {
02983 #line 2118 "insns.def"
02984 reg_cfp = (funcptr)(th, reg_cfp);
02985
02986 if (reg_cfp == 0) {
02987 VALUE err = th->errinfo;
02988 th->errinfo = Qnil;
02989 THROW_EXCEPTION(err);
02990 }
02991
02992 RESTORE_REGS();
02993 NEXT_INSN();
02994
02995 #line 2996 "vm.inc"
02996 #undef CURRENT_INSN_opt_call_c_function
02997 #undef INSN_IS_SC
02998 #undef INSN_LABEL
02999 #undef LABEL_IS_SC
03000 END_INSN(opt_call_c_function);}}}
03001 INSN_ENTRY(bitblt){
03002 {
03003 VALUE ret;
03004
03005
03006 DEBUG_ENTER_INSN("bitblt");
03007 ADD_PC(1+0);
03008 PREFETCH(GET_PC());
03009 #define CURRENT_INSN_bitblt 1
03010 #define INSN_IS_SC() 0
03011 #define INSN_LABEL(lab) LABEL_bitblt_##lab
03012 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
03013 USAGE_ANALYSIS_INSN(BIN(bitblt));
03014 {
03015 #line 2141 "insns.def"
03016 ret = rb_str_new2("a bit of bacon, lettuce and tomato");
03017
03018 #line 3019 "vm.inc"
03019 CHECK_STACK_OVERFLOW(REG_CFP, 1);
03020 PUSH(ret);
03021 #undef CURRENT_INSN_bitblt
03022 #undef INSN_IS_SC
03023 #undef INSN_LABEL
03024 #undef LABEL_IS_SC
03025 END_INSN(bitblt);}}}
03026 INSN_ENTRY(answer){
03027 {
03028 VALUE ret;
03029
03030
03031 DEBUG_ENTER_INSN("answer");
03032 ADD_PC(1+0);
03033 PREFETCH(GET_PC());
03034 #define CURRENT_INSN_answer 1
03035 #define INSN_IS_SC() 0
03036 #define INSN_LABEL(lab) LABEL_answer_##lab
03037 #define LABEL_IS_SC(lab) LABEL_##lab##_##t
03038 USAGE_ANALYSIS_INSN(BIN(answer));
03039 {
03040 #line 2155 "insns.def"
03041 ret = INT2FIX(42);
03042
03043 #line 3044 "vm.inc"
03044 CHECK_STACK_OVERFLOW(REG_CFP, 1);
03045 PUSH(ret);
03046 #undef CURRENT_INSN_answer
03047 #undef INSN_IS_SC
03048 #undef INSN_LABEL
03049 #undef LABEL_IS_SC
03050 END_INSN(answer);}}}
03051
03052
