1/* -*-c-*- *********************************************************/ 2/*******************************************************************/ 3/*******************************************************************/ 4/** 5 This file is VM main loop. 6 7 ---- 8 This file is auto generated by insns2vm.rb 9 DO NOT TOUCH! 10 11 If you want to fix something, you must edit 'insns.c' 12 */ 13 14 15INSN_ENTRY(nop){ 16{ 17 18 19 DEBUG_ENTER_INSN("nop"); 20 ADD_PC(1+0); 21 PREFETCH(GET_PC()); 22 #define CURRENT_INSN_nop 1 23 #define INSN_IS_SC() 0 24 #define INSN_LABEL(lab) LABEL_nop_##lab 25 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 26 COLLECT_USAGE_INSN(BIN(nop)); 27{ 28#line 40 "insns.def" 29 /* none */ 30 31#line 32 "vm.inc" 32#undef CURRENT_INSN_nop 33#undef INSN_IS_SC 34#undef INSN_LABEL 35#undef LABEL_IS_SC 36 END_INSN(nop);}}} 37INSN_ENTRY(getlocal){ 38{ 39 VALUE val; 40 rb_num_t level = (rb_num_t)GET_OPERAND(2); 41 lindex_t idx = (lindex_t)GET_OPERAND(1); 42 43 DEBUG_ENTER_INSN("getlocal"); 44 ADD_PC(1+2); 45 PREFETCH(GET_PC()); 46 #define CURRENT_INSN_getlocal 1 47 #define INSN_IS_SC() 0 48 #define INSN_LABEL(lab) LABEL_getlocal_##lab 49 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 50 COLLECT_USAGE_INSN(BIN(getlocal)); 51 COLLECT_USAGE_OPERAND(BIN(getlocal), 0, idx); 52 COLLECT_USAGE_OPERAND(BIN(getlocal), 1, level); 53{ 54#line 60 "insns.def" 55 int i, lev = (int)level; 56 VALUE *ep = GET_EP(); 57 58 for (i = 0; i < lev; i++) { 59 ep = GET_PREV_EP(ep); 60 } 61 val = *(ep - idx); 62 63#line 64 "vm.inc" 64 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 65 PUSH(val); 66#undef CURRENT_INSN_getlocal 67#undef INSN_IS_SC 68#undef INSN_LABEL 69#undef LABEL_IS_SC 70 END_INSN(getlocal);}}} 71INSN_ENTRY(setlocal){ 72{ 73 rb_num_t level = (rb_num_t)GET_OPERAND(2); 74 lindex_t idx = (lindex_t)GET_OPERAND(1); 75 VALUE val = TOPN(0); 76 DEBUG_ENTER_INSN("setlocal"); 77 ADD_PC(1+2); 78 PREFETCH(GET_PC()); 79 POPN(1); 80 #define CURRENT_INSN_setlocal 1 81 #define INSN_IS_SC() 0 82 #define INSN_LABEL(lab) LABEL_setlocal_##lab 83 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 84 COLLECT_USAGE_INSN(BIN(setlocal)); 85 COLLECT_USAGE_OPERAND(BIN(setlocal), 0, idx); 86 COLLECT_USAGE_OPERAND(BIN(setlocal), 1, level); 87{ 88#line 82 "insns.def" 89 int i, lev = (int)level; 90 VALUE *ep = GET_EP(); 91 92 for (i = 0; i < lev; i++) { 93 ep = GET_PREV_EP(ep); 94 } 95 *(ep - idx) = val; 96 97#line 98 "vm.inc" 98#undef CURRENT_INSN_setlocal 99#undef INSN_IS_SC 100#undef INSN_LABEL 101#undef LABEL_IS_SC 102 END_INSN(setlocal);}}} 103INSN_ENTRY(getspecial){ 104{ 105 VALUE val; 106 rb_num_t type = (rb_num_t)GET_OPERAND(2); 107 rb_num_t key = (rb_num_t)GET_OPERAND(1); 108 109 DEBUG_ENTER_INSN("getspecial"); 110 ADD_PC(1+2); 111 PREFETCH(GET_PC()); 112 #define CURRENT_INSN_getspecial 1 113 #define INSN_IS_SC() 0 114 #define INSN_LABEL(lab) LABEL_getspecial_##lab 115 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 116 COLLECT_USAGE_INSN(BIN(getspecial)); 117 COLLECT_USAGE_OPERAND(BIN(getspecial), 0, key); 118 COLLECT_USAGE_OPERAND(BIN(getspecial), 1, type); 119{ 120#line 102 "insns.def" 121 val = vm_getspecial(th, GET_LEP(), key, type); 122 123#line 124 "vm.inc" 124 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 125 PUSH(val); 126#undef CURRENT_INSN_getspecial 127#undef INSN_IS_SC 128#undef INSN_LABEL 129#undef LABEL_IS_SC 130 END_INSN(getspecial);}}} 131INSN_ENTRY(setspecial){ 132{ 133 rb_num_t key = (rb_num_t)GET_OPERAND(1); 134 VALUE obj = TOPN(0); 135 DEBUG_ENTER_INSN("setspecial"); 136 ADD_PC(1+1); 137 PREFETCH(GET_PC()); 138 POPN(1); 139 #define CURRENT_INSN_setspecial 1 140 #define INSN_IS_SC() 0 141 #define INSN_LABEL(lab) LABEL_setspecial_##lab 142 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 143 COLLECT_USAGE_INSN(BIN(setspecial)); 144 COLLECT_USAGE_OPERAND(BIN(setspecial), 0, key); 145{ 146#line 116 "insns.def" 147 lep_svar_set(th, GET_LEP(), key, obj); 148 149#line 150 "vm.inc" 150#undef CURRENT_INSN_setspecial 151#undef INSN_IS_SC 152#undef INSN_LABEL 153#undef LABEL_IS_SC 154 END_INSN(setspecial);}}} 155INSN_ENTRY(getinstancevariable){ 156{ 157 VALUE val; 158 IC ic = (IC)GET_OPERAND(2); 159 ID id = (ID)GET_OPERAND(1); 160 161 DEBUG_ENTER_INSN("getinstancevariable"); 162 ADD_PC(1+2); 163 PREFETCH(GET_PC()); 164 #define CURRENT_INSN_getinstancevariable 1 165 #define INSN_IS_SC() 0 166 #define INSN_LABEL(lab) LABEL_getinstancevariable_##lab 167 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 168 COLLECT_USAGE_INSN(BIN(getinstancevariable)); 169 COLLECT_USAGE_OPERAND(BIN(getinstancevariable), 0, id); 170 COLLECT_USAGE_OPERAND(BIN(getinstancevariable), 1, ic); 171{ 172#line 131 "insns.def" 173 val = vm_getinstancevariable(GET_SELF(), id, ic); 174 175#line 176 "vm.inc" 176 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 177 PUSH(val); 178#undef CURRENT_INSN_getinstancevariable 179#undef INSN_IS_SC 180#undef INSN_LABEL 181#undef LABEL_IS_SC 182 END_INSN(getinstancevariable);}}} 183INSN_ENTRY(setinstancevariable){ 184{ 185 IC ic = (IC)GET_OPERAND(2); 186 ID id = (ID)GET_OPERAND(1); 187 VALUE val = TOPN(0); 188 DEBUG_ENTER_INSN("setinstancevariable"); 189 ADD_PC(1+2); 190 PREFETCH(GET_PC()); 191 POPN(1); 192 #define CURRENT_INSN_setinstancevariable 1 193 #define INSN_IS_SC() 0 194 #define INSN_LABEL(lab) LABEL_setinstancevariable_##lab 195 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 196 COLLECT_USAGE_INSN(BIN(setinstancevariable)); 197 COLLECT_USAGE_OPERAND(BIN(setinstancevariable), 0, id); 198 COLLECT_USAGE_OPERAND(BIN(setinstancevariable), 1, ic); 199{ 200#line 146 "insns.def" 201 vm_setinstancevariable(GET_SELF(), id, val, ic); 202 203#line 204 "vm.inc" 204#undef CURRENT_INSN_setinstancevariable 205#undef INSN_IS_SC 206#undef INSN_LABEL 207#undef LABEL_IS_SC 208 END_INSN(setinstancevariable);}}} 209INSN_ENTRY(getclassvariable){ 210{ 211 VALUE val; 212 ID id = (ID)GET_OPERAND(1); 213 214 DEBUG_ENTER_INSN("getclassvariable"); 215 ADD_PC(1+1); 216 PREFETCH(GET_PC()); 217 #define CURRENT_INSN_getclassvariable 1 218 #define INSN_IS_SC() 0 219 #define INSN_LABEL(lab) LABEL_getclassvariable_##lab 220 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 221 COLLECT_USAGE_INSN(BIN(getclassvariable)); 222 COLLECT_USAGE_OPERAND(BIN(getclassvariable), 0, id); 223{ 224#line 160 "insns.def" 225 NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP()); 226 val = rb_cvar_get(vm_get_cvar_base(cref, GET_CFP()), id); 227 228#line 229 "vm.inc" 229 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 230 PUSH(val); 231#undef CURRENT_INSN_getclassvariable 232#undef INSN_IS_SC 233#undef INSN_LABEL 234#undef LABEL_IS_SC 235 END_INSN(getclassvariable);}}} 236INSN_ENTRY(setclassvariable){ 237{ 238 ID id = (ID)GET_OPERAND(1); 239 VALUE val = TOPN(0); 240 DEBUG_ENTER_INSN("setclassvariable"); 241 ADD_PC(1+1); 242 PREFETCH(GET_PC()); 243 POPN(1); 244 #define CURRENT_INSN_setclassvariable 1 245 #define INSN_IS_SC() 0 246 #define INSN_LABEL(lab) LABEL_setclassvariable_##lab 247 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 248 COLLECT_USAGE_INSN(BIN(setclassvariable)); 249 COLLECT_USAGE_OPERAND(BIN(setclassvariable), 0, id); 250{ 251#line 175 "insns.def" 252 NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP()); 253 rb_cvar_set(vm_get_cvar_base(cref, GET_CFP()), id, val); 254 255#line 256 "vm.inc" 256#undef CURRENT_INSN_setclassvariable 257#undef INSN_IS_SC 258#undef INSN_LABEL 259#undef LABEL_IS_SC 260 END_INSN(setclassvariable);}}} 261INSN_ENTRY(getconstant){ 262{ 263 VALUE val; 264 ID id = (ID)GET_OPERAND(1); 265 VALUE klass = TOPN(0); 266 DEBUG_ENTER_INSN("getconstant"); 267 ADD_PC(1+1); 268 PREFETCH(GET_PC()); 269 POPN(1); 270 #define CURRENT_INSN_getconstant 1 271 #define INSN_IS_SC() 0 272 #define INSN_LABEL(lab) LABEL_getconstant_##lab 273 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 274 COLLECT_USAGE_INSN(BIN(getconstant)); 275 COLLECT_USAGE_OPERAND(BIN(getconstant), 0, id); 276{ 277#line 197 "insns.def" 278 val = vm_get_ev_const(th, GET_ISEQ(), klass, id, 0); 279 280#line 281 "vm.inc" 281 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 282 PUSH(val); 283#undef CURRENT_INSN_getconstant 284#undef INSN_IS_SC 285#undef INSN_LABEL 286#undef LABEL_IS_SC 287 END_INSN(getconstant);}}} 288INSN_ENTRY(setconstant){ 289{ 290 ID id = (ID)GET_OPERAND(1); 291 VALUE val = TOPN(1); 292 VALUE cbase = TOPN(0); 293 DEBUG_ENTER_INSN("setconstant"); 294 ADD_PC(1+1); 295 PREFETCH(GET_PC()); 296 POPN(2); 297 #define CURRENT_INSN_setconstant 1 298 #define INSN_IS_SC() 0 299 #define INSN_LABEL(lab) LABEL_setconstant_##lab 300 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 301 COLLECT_USAGE_INSN(BIN(setconstant)); 302 COLLECT_USAGE_OPERAND(BIN(setconstant), 0, id); 303{ 304#line 219 "insns.def" 305 vm_check_if_namespace(cbase); 306 rb_const_set(cbase, id, val); 307 INC_VM_STATE_VERSION(); 308 309#line 310 "vm.inc" 310#undef CURRENT_INSN_setconstant 311#undef INSN_IS_SC 312#undef INSN_LABEL 313#undef LABEL_IS_SC 314 END_INSN(setconstant);}}} 315INSN_ENTRY(getglobal){ 316{ 317 VALUE val; 318 GENTRY entry = (GENTRY)GET_OPERAND(1); 319 320 DEBUG_ENTER_INSN("getglobal"); 321 ADD_PC(1+1); 322 PREFETCH(GET_PC()); 323 #define CURRENT_INSN_getglobal 1 324 #define INSN_IS_SC() 0 325 #define INSN_LABEL(lab) LABEL_getglobal_##lab 326 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 327 COLLECT_USAGE_INSN(BIN(getglobal)); 328 COLLECT_USAGE_OPERAND(BIN(getglobal), 0, entry); 329{ 330#line 235 "insns.def" 331 val = GET_GLOBAL((VALUE)entry); 332 333#line 334 "vm.inc" 334 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 335 PUSH(val); 336#undef CURRENT_INSN_getglobal 337#undef INSN_IS_SC 338#undef INSN_LABEL 339#undef LABEL_IS_SC 340 END_INSN(getglobal);}}} 341INSN_ENTRY(setglobal){ 342{ 343 GENTRY entry = (GENTRY)GET_OPERAND(1); 344 VALUE val = TOPN(0); 345 DEBUG_ENTER_INSN("setglobal"); 346 ADD_PC(1+1); 347 PREFETCH(GET_PC()); 348 POPN(1); 349 #define CURRENT_INSN_setglobal 1 350 #define INSN_IS_SC() 0 351 #define INSN_LABEL(lab) LABEL_setglobal_##lab 352 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 353 COLLECT_USAGE_INSN(BIN(setglobal)); 354 COLLECT_USAGE_OPERAND(BIN(setglobal), 0, entry); 355{ 356#line 249 "insns.def" 357 SET_GLOBAL((VALUE)entry, val); 358 359#line 360 "vm.inc" 360#undef CURRENT_INSN_setglobal 361#undef INSN_IS_SC 362#undef INSN_LABEL 363#undef LABEL_IS_SC 364 END_INSN(setglobal);}}} 365INSN_ENTRY(putnil){ 366{ 367 VALUE val; 368 369 370 DEBUG_ENTER_INSN("putnil"); 371 ADD_PC(1+0); 372 PREFETCH(GET_PC()); 373 #define CURRENT_INSN_putnil 1 374 #define INSN_IS_SC() 0 375 #define INSN_LABEL(lab) LABEL_putnil_##lab 376 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 377 COLLECT_USAGE_INSN(BIN(putnil)); 378{ 379#line 268 "insns.def" 380 val = Qnil; 381 382#line 383 "vm.inc" 383 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 384 PUSH(val); 385#undef CURRENT_INSN_putnil 386#undef INSN_IS_SC 387#undef INSN_LABEL 388#undef LABEL_IS_SC 389 END_INSN(putnil);}}} 390INSN_ENTRY(putself){ 391{ 392 VALUE val; 393 394 395 DEBUG_ENTER_INSN("putself"); 396 ADD_PC(1+0); 397 PREFETCH(GET_PC()); 398 #define CURRENT_INSN_putself 1 399 #define INSN_IS_SC() 0 400 #define INSN_LABEL(lab) LABEL_putself_##lab 401 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 402 COLLECT_USAGE_INSN(BIN(putself)); 403{ 404#line 282 "insns.def" 405 val = GET_SELF(); 406 407#line 408 "vm.inc" 408 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 409 PUSH(val); 410#undef CURRENT_INSN_putself 411#undef INSN_IS_SC 412#undef INSN_LABEL 413#undef LABEL_IS_SC 414 END_INSN(putself);}}} 415INSN_ENTRY(putobject){ 416{ 417 VALUE val = (VALUE)GET_OPERAND(1); 418 419 DEBUG_ENTER_INSN("putobject"); 420 ADD_PC(1+1); 421 PREFETCH(GET_PC()); 422 #define CURRENT_INSN_putobject 1 423 #define INSN_IS_SC() 0 424 #define INSN_LABEL(lab) LABEL_putobject_##lab 425 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 426 COLLECT_USAGE_INSN(BIN(putobject)); 427 COLLECT_USAGE_OPERAND(BIN(putobject), 0, val); 428{ 429#line 298 "insns.def" 430 /* */ 431 432#line 433 "vm.inc" 433 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 434 PUSH(val); 435#undef CURRENT_INSN_putobject 436#undef INSN_IS_SC 437#undef INSN_LABEL 438#undef LABEL_IS_SC 439 END_INSN(putobject);}}} 440INSN_ENTRY(putspecialobject){ 441{ 442 VALUE val; 443 rb_num_t value_type = (rb_num_t)GET_OPERAND(1); 444 445 DEBUG_ENTER_INSN("putspecialobject"); 446 ADD_PC(1+1); 447 PREFETCH(GET_PC()); 448 #define CURRENT_INSN_putspecialobject 1 449 #define INSN_IS_SC() 0 450 #define INSN_LABEL(lab) LABEL_putspecialobject_##lab 451 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 452 COLLECT_USAGE_INSN(BIN(putspecialobject)); 453 COLLECT_USAGE_OPERAND(BIN(putspecialobject), 0, value_type); 454{ 455#line 313 "insns.def" 456 enum vm_special_object_type type = (enum vm_special_object_type)value_type; 457 458 switch (type) { 459 case VM_SPECIAL_OBJECT_VMCORE: 460 val = rb_mRubyVMFrozenCore; 461 break; 462 case VM_SPECIAL_OBJECT_CBASE: 463 val = vm_get_cbase(GET_ISEQ(), GET_EP()); 464 break; 465 case VM_SPECIAL_OBJECT_CONST_BASE: 466 val = vm_get_const_base(GET_ISEQ(), GET_EP()); 467 break; 468 default: 469 rb_bug("putspecialobject insn: unknown value_type"); 470 } 471 472#line 473 "vm.inc" 473 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 474 PUSH(val); 475#undef CURRENT_INSN_putspecialobject 476#undef INSN_IS_SC 477#undef INSN_LABEL 478#undef LABEL_IS_SC 479 END_INSN(putspecialobject);}}} 480INSN_ENTRY(putiseq){ 481{ 482 VALUE ret; 483 ISEQ iseq = (ISEQ)GET_OPERAND(1); 484 485 DEBUG_ENTER_INSN("putiseq"); 486 ADD_PC(1+1); 487 PREFETCH(GET_PC()); 488 #define CURRENT_INSN_putiseq 1 489 #define INSN_IS_SC() 0 490 #define INSN_LABEL(lab) LABEL_putiseq_##lab 491 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 492 COLLECT_USAGE_INSN(BIN(putiseq)); 493 COLLECT_USAGE_OPERAND(BIN(putiseq), 0, iseq); 494{ 495#line 341 "insns.def" 496 ret = iseq->self; 497 498#line 499 "vm.inc" 499 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 500 PUSH(ret); 501#undef CURRENT_INSN_putiseq 502#undef INSN_IS_SC 503#undef INSN_LABEL 504#undef LABEL_IS_SC 505 END_INSN(putiseq);}}} 506INSN_ENTRY(putstring){ 507{ 508 VALUE val; 509 VALUE str = (VALUE)GET_OPERAND(1); 510 511 DEBUG_ENTER_INSN("putstring"); 512 ADD_PC(1+1); 513 PREFETCH(GET_PC()); 514 #define CURRENT_INSN_putstring 1 515 #define INSN_IS_SC() 0 516 #define INSN_LABEL(lab) LABEL_putstring_##lab 517 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 518 COLLECT_USAGE_INSN(BIN(putstring)); 519 COLLECT_USAGE_OPERAND(BIN(putstring), 0, str); 520{ 521#line 355 "insns.def" 522 val = rb_str_resurrect(str); 523 524#line 525 "vm.inc" 525 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 526 PUSH(val); 527#undef CURRENT_INSN_putstring 528#undef INSN_IS_SC 529#undef INSN_LABEL 530#undef LABEL_IS_SC 531 END_INSN(putstring);}}} 532INSN_ENTRY(concatstrings){ 533{ 534 VALUE val; 535 rb_num_t num = (rb_num_t)GET_OPERAND(1); 536 537 DEBUG_ENTER_INSN("concatstrings"); 538 ADD_PC(1+1); 539 PREFETCH(GET_PC()); 540 #define CURRENT_INSN_concatstrings 1 541 #define INSN_IS_SC() 0 542 #define INSN_LABEL(lab) LABEL_concatstrings_##lab 543 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 544 COLLECT_USAGE_INSN(BIN(concatstrings)); 545 COLLECT_USAGE_OPERAND(BIN(concatstrings), 0, num); 546{ 547#line 369 "insns.def" 548 rb_num_t i = num - 1; 549 550 val = rb_str_resurrect(TOPN(i)); 551 while (i-- > 0) { 552 const VALUE v = TOPN(i); 553 rb_str_append(val, v); 554 } 555 POPN(num); 556 557#line 558 "vm.inc" 558 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 559 PUSH(val); 560#undef CURRENT_INSN_concatstrings 561#undef INSN_IS_SC 562#undef INSN_LABEL 563#undef LABEL_IS_SC 564 END_INSN(concatstrings);}}} 565INSN_ENTRY(tostring){ 566{ 567 568 VALUE val = TOPN(0); 569 DEBUG_ENTER_INSN("tostring"); 570 ADD_PC(1+0); 571 PREFETCH(GET_PC()); 572 POPN(1); 573 #define CURRENT_INSN_tostring 1 574 #define INSN_IS_SC() 0 575 #define INSN_LABEL(lab) LABEL_tostring_##lab 576 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 577 COLLECT_USAGE_INSN(BIN(tostring)); 578{ 579#line 390 "insns.def" 580 val = rb_obj_as_string(val); 581 582#line 583 "vm.inc" 583 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 584 PUSH(val); 585#undef CURRENT_INSN_tostring 586#undef INSN_IS_SC 587#undef INSN_LABEL 588#undef LABEL_IS_SC 589 END_INSN(tostring);}}} 590INSN_ENTRY(toregexp){ 591{ 592 VALUE val; 593 rb_num_t cnt = (rb_num_t)GET_OPERAND(2); 594 rb_num_t opt = (rb_num_t)GET_OPERAND(1); 595 596 DEBUG_ENTER_INSN("toregexp"); 597 ADD_PC(1+2); 598 PREFETCH(GET_PC()); 599 #define CURRENT_INSN_toregexp 1 600 #define INSN_IS_SC() 0 601 #define INSN_LABEL(lab) LABEL_toregexp_##lab 602 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 603 COLLECT_USAGE_INSN(BIN(toregexp)); 604 COLLECT_USAGE_OPERAND(BIN(toregexp), 0, opt); 605 COLLECT_USAGE_OPERAND(BIN(toregexp), 1, cnt); 606{ 607#line 405 "insns.def" 608 VALUE rb_reg_new_ary(VALUE ary, int options); 609 rb_num_t i; 610 const VALUE ary = rb_ary_tmp_new(cnt); 611 for (i = 0; i < cnt; i++) { 612 rb_ary_store(ary, cnt-i-1, TOPN(i)); 613 } 614 POPN(cnt); 615 val = rb_reg_new_ary(ary, (int)opt); 616 rb_ary_clear(ary); 617 618#line 619 "vm.inc" 619 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 620 PUSH(val); 621#undef CURRENT_INSN_toregexp 622#undef INSN_IS_SC 623#undef INSN_LABEL 624#undef LABEL_IS_SC 625 END_INSN(toregexp);}}} 626INSN_ENTRY(newarray){ 627{ 628 VALUE val; 629 rb_num_t num = (rb_num_t)GET_OPERAND(1); 630 631 DEBUG_ENTER_INSN("newarray"); 632 ADD_PC(1+1); 633 PREFETCH(GET_PC()); 634 #define CURRENT_INSN_newarray 1 635 #define INSN_IS_SC() 0 636 #define INSN_LABEL(lab) LABEL_newarray_##lab 637 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 638 COLLECT_USAGE_INSN(BIN(newarray)); 639 COLLECT_USAGE_OPERAND(BIN(newarray), 0, num); 640{ 641#line 427 "insns.def" 642 val = rb_ary_new4((long)num, STACK_ADDR_FROM_TOP(num)); 643 POPN(num); 644 645#line 646 "vm.inc" 646 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 647 PUSH(val); 648#undef CURRENT_INSN_newarray 649#undef INSN_IS_SC 650#undef INSN_LABEL 651#undef LABEL_IS_SC 652 END_INSN(newarray);}}} 653INSN_ENTRY(duparray){ 654{ 655 VALUE val; 656 VALUE ary = (VALUE)GET_OPERAND(1); 657 658 DEBUG_ENTER_INSN("duparray"); 659 ADD_PC(1+1); 660 PREFETCH(GET_PC()); 661 #define CURRENT_INSN_duparray 1 662 #define INSN_IS_SC() 0 663 #define INSN_LABEL(lab) LABEL_duparray_##lab 664 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 665 COLLECT_USAGE_INSN(BIN(duparray)); 666 COLLECT_USAGE_OPERAND(BIN(duparray), 0, ary); 667{ 668#line 442 "insns.def" 669 val = rb_ary_resurrect(ary); 670 671#line 672 "vm.inc" 672 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 673 PUSH(val); 674#undef CURRENT_INSN_duparray 675#undef INSN_IS_SC 676#undef INSN_LABEL 677#undef LABEL_IS_SC 678 END_INSN(duparray);}}} 679INSN_ENTRY(expandarray){ 680{ 681 rb_num_t flag = (rb_num_t)GET_OPERAND(2); 682 rb_num_t num = (rb_num_t)GET_OPERAND(1); 683 VALUE ary = TOPN(0); 684 DEBUG_ENTER_INSN("expandarray"); 685 ADD_PC(1+2); 686 PREFETCH(GET_PC()); 687 POPN(1); 688 #define CURRENT_INSN_expandarray 1 689 #define INSN_IS_SC() 0 690 #define INSN_LABEL(lab) LABEL_expandarray_##lab 691 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 692 COLLECT_USAGE_INSN(BIN(expandarray)); 693 COLLECT_USAGE_OPERAND(BIN(expandarray), 0, num); 694 COLLECT_USAGE_OPERAND(BIN(expandarray), 1, flag); 695{ 696#line 463 "insns.def" 697 vm_expandarray(GET_CFP(), ary, num, (int)flag); 698 699#line 700 "vm.inc" 700#undef CURRENT_INSN_expandarray 701#undef INSN_IS_SC 702#undef INSN_LABEL 703#undef LABEL_IS_SC 704 END_INSN(expandarray);}}} 705INSN_ENTRY(concatarray){ 706{ 707 VALUE ary; 708 709 VALUE ary1 = TOPN(1); 710 VALUE ary2st = TOPN(0); 711 DEBUG_ENTER_INSN("concatarray"); 712 ADD_PC(1+0); 713 PREFETCH(GET_PC()); 714 POPN(2); 715 #define CURRENT_INSN_concatarray 1 716 #define INSN_IS_SC() 0 717 #define INSN_LABEL(lab) LABEL_concatarray_##lab 718 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 719 COLLECT_USAGE_INSN(BIN(concatarray)); 720{ 721#line 477 "insns.def" 722 const VALUE ary2 = ary2st; 723 VALUE tmp1 = rb_check_convert_type(ary1, T_ARRAY, "Array", "to_a"); 724 VALUE tmp2 = rb_check_convert_type(ary2, T_ARRAY, "Array", "to_a"); 725 726 if (NIL_P(tmp1)) { 727 tmp1 = rb_ary_new3(1, ary1); 728 } 729 730 if (NIL_P(tmp2)) { 731 tmp2 = rb_ary_new3(1, ary2); 732 } 733 734 if (tmp1 == ary1) { 735 tmp1 = rb_ary_dup(ary1); 736 } 737 ary = rb_ary_concat(tmp1, tmp2); 738 739#line 740 "vm.inc" 740 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 741 PUSH(ary); 742#undef CURRENT_INSN_concatarray 743#undef INSN_IS_SC 744#undef INSN_LABEL 745#undef LABEL_IS_SC 746 END_INSN(concatarray);}}} 747INSN_ENTRY(splatarray){ 748{ 749 VALUE obj; 750 VALUE flag = (VALUE)GET_OPERAND(1); 751 VALUE ary = TOPN(0); 752 DEBUG_ENTER_INSN("splatarray"); 753 ADD_PC(1+1); 754 PREFETCH(GET_PC()); 755 POPN(1); 756 #define CURRENT_INSN_splatarray 1 757 #define INSN_IS_SC() 0 758 #define INSN_LABEL(lab) LABEL_splatarray_##lab 759 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 760 COLLECT_USAGE_INSN(BIN(splatarray)); 761 COLLECT_USAGE_OPERAND(BIN(splatarray), 0, flag); 762{ 763#line 506 "insns.def" 764 VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_a"); 765 if (NIL_P(tmp)) { 766 tmp = rb_ary_new3(1, ary); 767 } 768 else if (RTEST(flag)) { 769 tmp = rb_ary_dup(tmp); 770 } 771 obj = tmp; 772 773#line 774 "vm.inc" 774 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 775 PUSH(obj); 776#undef CURRENT_INSN_splatarray 777#undef INSN_IS_SC 778#undef INSN_LABEL 779#undef LABEL_IS_SC 780 END_INSN(splatarray);}}} 781INSN_ENTRY(newhash){ 782{ 783 VALUE val; 784 rb_num_t num = (rb_num_t)GET_OPERAND(1); 785 786 DEBUG_ENTER_INSN("newhash"); 787 ADD_PC(1+1); 788 PREFETCH(GET_PC()); 789 #define CURRENT_INSN_newhash 1 790 #define INSN_IS_SC() 0 791 #define INSN_LABEL(lab) LABEL_newhash_##lab 792 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 793 COLLECT_USAGE_INSN(BIN(newhash)); 794 COLLECT_USAGE_OPERAND(BIN(newhash), 0, num); 795{ 796#line 528 "insns.def" 797 rb_num_t i; 798 799 if(RUBY_DTRACE_HASH_CREATE_ENABLED()) { 800 RUBY_DTRACE_HASH_CREATE(num, rb_sourcefile(), rb_sourceline()); 801 } 802 803 val = rb_hash_new(); 804 805 for (i = num; i > 0; i -= 2) { 806 const VALUE v = TOPN(i - 2); 807 const VALUE k = TOPN(i - 1); 808 rb_hash_aset(val, k, v); 809 } 810 POPN(num); 811 812#line 813 "vm.inc" 813 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 814 PUSH(val); 815#undef CURRENT_INSN_newhash 816#undef INSN_IS_SC 817#undef INSN_LABEL 818#undef LABEL_IS_SC 819 END_INSN(newhash);}}} 820INSN_ENTRY(newrange){ 821{ 822 VALUE val; 823 rb_num_t flag = (rb_num_t)GET_OPERAND(1); 824 VALUE low = TOPN(1); 825 VALUE high = TOPN(0); 826 DEBUG_ENTER_INSN("newrange"); 827 ADD_PC(1+1); 828 PREFETCH(GET_PC()); 829 POPN(2); 830 #define CURRENT_INSN_newrange 1 831 #define INSN_IS_SC() 0 832 #define INSN_LABEL(lab) LABEL_newrange_##lab 833 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 834 COLLECT_USAGE_INSN(BIN(newrange)); 835 COLLECT_USAGE_OPERAND(BIN(newrange), 0, flag); 836{ 837#line 555 "insns.def" 838 val = rb_range_new(low, high, (int)flag); 839 840#line 841 "vm.inc" 841 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 842 PUSH(val); 843#undef CURRENT_INSN_newrange 844#undef INSN_IS_SC 845#undef INSN_LABEL 846#undef LABEL_IS_SC 847 END_INSN(newrange);}}} 848INSN_ENTRY(pop){ 849{ 850 851 VALUE val = TOPN(0); 852 DEBUG_ENTER_INSN("pop"); 853 ADD_PC(1+0); 854 PREFETCH(GET_PC()); 855 POPN(1); 856 #define CURRENT_INSN_pop 1 857 #define INSN_IS_SC() 0 858 #define INSN_LABEL(lab) LABEL_pop_##lab 859 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 860 COLLECT_USAGE_INSN(BIN(pop)); 861{ 862#line 573 "insns.def" 863 (void)val; 864 /* none */ 865 866#line 867 "vm.inc" 867#undef CURRENT_INSN_pop 868#undef INSN_IS_SC 869#undef INSN_LABEL 870#undef LABEL_IS_SC 871 END_INSN(pop);}}} 872INSN_ENTRY(dup){ 873{ 874 VALUE val2; 875 VALUE val1; 876 877 VALUE val = TOPN(0); 878 DEBUG_ENTER_INSN("dup"); 879 ADD_PC(1+0); 880 PREFETCH(GET_PC()); 881 POPN(1); 882 #define CURRENT_INSN_dup 1 883 #define INSN_IS_SC() 0 884 #define INSN_LABEL(lab) LABEL_dup_##lab 885 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 886 COLLECT_USAGE_INSN(BIN(dup)); 887{ 888#line 588 "insns.def" 889 val1 = val2 = val; 890 891#line 892 "vm.inc" 892 CHECK_VM_STACK_OVERFLOW(REG_CFP, 2); 893 PUSH(val1); 894 PUSH(val2); 895#undef CURRENT_INSN_dup 896#undef INSN_IS_SC 897#undef INSN_LABEL 898#undef LABEL_IS_SC 899 END_INSN(dup);}}} 900INSN_ENTRY(dupn){ 901{ 902 rb_num_t n = (rb_num_t)GET_OPERAND(1); 903 904 DEBUG_ENTER_INSN("dupn"); 905 ADD_PC(1+1); 906 PREFETCH(GET_PC()); 907 #define CURRENT_INSN_dupn 1 908 #define INSN_IS_SC() 0 909 #define INSN_LABEL(lab) LABEL_dupn_##lab 910 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 911 COLLECT_USAGE_INSN(BIN(dupn)); 912 COLLECT_USAGE_OPERAND(BIN(dupn), 0, n); 913{ 914#line 602 "insns.def" 915 rb_num_t i; 916 VALUE *sp = STACK_ADDR_FROM_TOP(n); 917 for (i = 0; i < n; i++) { 918 GET_SP()[i] = sp[i]; 919 } 920 INC_SP(n); 921 922#line 923 "vm.inc" 923#undef CURRENT_INSN_dupn 924#undef INSN_IS_SC 925#undef INSN_LABEL 926#undef LABEL_IS_SC 927 END_INSN(dupn);}}} 928INSN_ENTRY(swap){ 929{ 930 931 VALUE val = TOPN(1); 932 VALUE obj = TOPN(0); 933 DEBUG_ENTER_INSN("swap"); 934 ADD_PC(1+0); 935 PREFETCH(GET_PC()); 936 POPN(2); 937 #define CURRENT_INSN_swap 1 938 #define INSN_IS_SC() 0 939 #define INSN_LABEL(lab) LABEL_swap_##lab 940 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 941 COLLECT_USAGE_INSN(BIN(swap)); 942{ 943#line 622 "insns.def" 944 /* none */ 945 946#line 947 "vm.inc" 947 CHECK_VM_STACK_OVERFLOW(REG_CFP, 2); 948 PUSH(obj); 949 PUSH(val); 950#undef CURRENT_INSN_swap 951#undef INSN_IS_SC 952#undef INSN_LABEL 953#undef LABEL_IS_SC 954 END_INSN(swap);}}} 955INSN_ENTRY(reput){ 956{ 957 958 VALUE val = TOPN(0); 959 DEBUG_ENTER_INSN("reput"); 960 ADD_PC(1+0); 961 PREFETCH(GET_PC()); 962 POPN(1); 963 #define CURRENT_INSN_reput 1 964 #define INSN_IS_SC() 0 965 #define INSN_LABEL(lab) LABEL_reput_##lab 966 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 967 COLLECT_USAGE_INSN(BIN(reput)); 968{ 969#line 636 "insns.def" 970 /* none */ 971 972#line 973 "vm.inc" 973 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 974 PUSH(val); 975#undef CURRENT_INSN_reput 976#undef INSN_IS_SC 977#undef INSN_LABEL 978#undef LABEL_IS_SC 979 END_INSN(reput);}}} 980INSN_ENTRY(topn){ 981{ 982 VALUE val; 983 rb_num_t n = (rb_num_t)GET_OPERAND(1); 984 985 DEBUG_ENTER_INSN("topn"); 986 ADD_PC(1+1); 987 PREFETCH(GET_PC()); 988 #define CURRENT_INSN_topn 1 989 #define INSN_IS_SC() 0 990 #define INSN_LABEL(lab) LABEL_topn_##lab 991 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 992 COLLECT_USAGE_INSN(BIN(topn)); 993 COLLECT_USAGE_OPERAND(BIN(topn), 0, n); 994{ 995#line 650 "insns.def" 996 val = TOPN(n); 997 998#line 999 "vm.inc" 999 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1000 PUSH(val); 1001#undef CURRENT_INSN_topn 1002#undef INSN_IS_SC 1003#undef INSN_LABEL 1004#undef LABEL_IS_SC 1005 END_INSN(topn);}}} 1006INSN_ENTRY(setn){ 1007{ 1008 rb_num_t n = (rb_num_t)GET_OPERAND(1); 1009 VALUE val = TOPN(0); 1010 DEBUG_ENTER_INSN("setn"); 1011 ADD_PC(1+1); 1012 PREFETCH(GET_PC()); 1013 POPN(1); 1014 #define CURRENT_INSN_setn 1 1015 #define INSN_IS_SC() 0 1016 #define INSN_LABEL(lab) LABEL_setn_##lab 1017 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1018 COLLECT_USAGE_INSN(BIN(setn)); 1019 COLLECT_USAGE_OPERAND(BIN(setn), 0, n); 1020{ 1021#line 664 "insns.def" 1022 TOPN(n-1) = val; 1023 1024#line 1025 "vm.inc" 1025 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1026 PUSH(val); 1027#undef CURRENT_INSN_setn 1028#undef INSN_IS_SC 1029#undef INSN_LABEL 1030#undef LABEL_IS_SC 1031 END_INSN(setn);}}} 1032INSN_ENTRY(adjuststack){ 1033{ 1034 rb_num_t n = (rb_num_t)GET_OPERAND(1); 1035 1036 DEBUG_ENTER_INSN("adjuststack"); 1037 ADD_PC(1+1); 1038 PREFETCH(GET_PC()); 1039 #define CURRENT_INSN_adjuststack 1 1040 #define INSN_IS_SC() 0 1041 #define INSN_LABEL(lab) LABEL_adjuststack_##lab 1042 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1043 COLLECT_USAGE_INSN(BIN(adjuststack)); 1044 COLLECT_USAGE_OPERAND(BIN(adjuststack), 0, n); 1045{ 1046#line 678 "insns.def" 1047 DEC_SP(n); 1048 1049#line 1050 "vm.inc" 1050#undef CURRENT_INSN_adjuststack 1051#undef INSN_IS_SC 1052#undef INSN_LABEL 1053#undef LABEL_IS_SC 1054 END_INSN(adjuststack);}}} 1055INSN_ENTRY(defined){ 1056{ 1057 VALUE val; 1058 VALUE needstr = (VALUE)GET_OPERAND(3); 1059 VALUE obj = (VALUE)GET_OPERAND(2); 1060 rb_num_t op_type = (rb_num_t)GET_OPERAND(1); 1061 VALUE v = TOPN(0); 1062 DEBUG_ENTER_INSN("defined"); 1063 ADD_PC(1+3); 1064 PREFETCH(GET_PC()); 1065 POPN(1); 1066 #define CURRENT_INSN_defined 1 1067 #define INSN_IS_SC() 0 1068 #define INSN_LABEL(lab) LABEL_defined_##lab 1069 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1070 COLLECT_USAGE_INSN(BIN(defined)); 1071 COLLECT_USAGE_OPERAND(BIN(defined), 0, op_type); 1072 COLLECT_USAGE_OPERAND(BIN(defined), 1, obj); 1073 COLLECT_USAGE_OPERAND(BIN(defined), 2, needstr); 1074{ 1075#line 697 "insns.def" 1076 VALUE klass; 1077 enum defined_type expr_type = 0; 1078 enum defined_type type = (enum defined_type)op_type; 1079 1080 val = Qnil; 1081 1082 switch (type) { 1083 case DEFINED_IVAR: 1084 if (rb_ivar_defined(GET_SELF(), SYM2ID(obj))) { 1085 expr_type = DEFINED_IVAR; 1086 } 1087 break; 1088 case DEFINED_IVAR2: 1089 klass = vm_get_cbase(GET_ISEQ(), GET_EP()); 1090 break; 1091 case DEFINED_GVAR: 1092 if (rb_gvar_defined(rb_global_entry(SYM2ID(obj)))) { 1093 expr_type = DEFINED_GVAR; 1094 } 1095 break; 1096 case DEFINED_CVAR: { 1097 NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP()); 1098 klass = vm_get_cvar_base(cref, GET_CFP()); 1099 if (rb_cvar_defined(klass, SYM2ID(obj))) { 1100 expr_type = DEFINED_CVAR; 1101 } 1102 break; 1103 } 1104 case DEFINED_CONST: 1105 klass = v; 1106 if (vm_get_ev_const(th, GET_ISEQ(), klass, SYM2ID(obj), 1)) { 1107 expr_type = DEFINED_CONST; 1108 } 1109 break; 1110 case DEFINED_FUNC: 1111 klass = CLASS_OF(v); 1112 if (rb_method_boundp(klass, SYM2ID(obj), 0)) { 1113 expr_type = DEFINED_METHOD; 1114 } 1115 break; 1116 case DEFINED_METHOD:{ 1117 VALUE klass = CLASS_OF(v); 1118 const rb_method_entry_t *me = rb_method_entry(klass, SYM2ID(obj), 0); 1119 1120 if (me) { 1121 if (!(me->flag & NOEX_PRIVATE)) { 1122 if (!((me->flag & NOEX_PROTECTED) && 1123 !rb_obj_is_kind_of(GET_SELF(), 1124 rb_class_real(klass)))) { 1125 expr_type = DEFINED_METHOD; 1126 } 1127 } 1128 } 1129 { 1130 VALUE args[2]; 1131 VALUE r; 1132 1133 args[0] = obj; args[1] = Qfalse; 1134 r = rb_check_funcall(v, idRespond_to_missing, 2, args); 1135 if (r != Qundef && RTEST(r)) 1136 expr_type = DEFINED_METHOD; 1137 } 1138 break; 1139 } 1140 case DEFINED_YIELD: 1141 if (GET_BLOCK_PTR()) { 1142 expr_type = DEFINED_YIELD; 1143 } 1144 break; 1145 case DEFINED_ZSUPER:{ 1146 rb_call_info_t cit; 1147 if (vm_search_superclass(GET_CFP(), GET_ISEQ(), Qnil, &cit) == 0) { 1148 VALUE klass = cit.klass; 1149 ID id = cit.mid; 1150 if (rb_method_boundp(klass, id, 0)) { 1151 expr_type = DEFINED_ZSUPER; 1152 } 1153 } 1154 break; 1155 } 1156 case DEFINED_REF:{ 1157 val = vm_getspecial(th, GET_LEP(), Qfalse, FIX2INT(obj)); 1158 if (val != Qnil) { 1159 expr_type = DEFINED_GVAR; 1160 } 1161 break; 1162 } 1163 default: 1164 rb_bug("unimplemented defined? type (VM)"); 1165 break; 1166 } 1167 if (expr_type != 0) { 1168 if (needstr != Qfalse) { 1169 val = rb_iseq_defined_string(expr_type); 1170 } 1171 else { 1172 val = Qtrue; 1173 } 1174 } 1175 1176#line 1177 "vm.inc" 1177 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1178 PUSH(val); 1179#undef CURRENT_INSN_defined 1180#undef INSN_IS_SC 1181#undef INSN_LABEL 1182#undef LABEL_IS_SC 1183 END_INSN(defined);}}} 1184INSN_ENTRY(checkmatch){ 1185{ 1186 VALUE result; 1187 rb_num_t flag = (rb_num_t)GET_OPERAND(1); 1188 VALUE target = TOPN(1); 1189 VALUE pattern = TOPN(0); 1190 DEBUG_ENTER_INSN("checkmatch"); 1191 ADD_PC(1+1); 1192 PREFETCH(GET_PC()); 1193 POPN(2); 1194 #define CURRENT_INSN_checkmatch 1 1195 #define INSN_IS_SC() 0 1196 #define INSN_LABEL(lab) LABEL_checkmatch_##lab 1197 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1198 COLLECT_USAGE_INSN(BIN(checkmatch)); 1199 COLLECT_USAGE_OPERAND(BIN(checkmatch), 0, flag); 1200{ 1201#line 814 "insns.def" 1202 enum vm_check_match_type checkmatch_type = 1203 (enum vm_check_match_type)(flag & VM_CHECKMATCH_TYPE_MASK); 1204 result = Qfalse; 1205 1206 if (flag & VM_CHECKMATCH_ARRAY) { 1207 int i; 1208 for (i = 0; i < RARRAY_LEN(pattern); i++) { 1209 if (RTEST(check_match(RARRAY_PTR(pattern)[i], target, checkmatch_type))) { 1210 result = Qtrue; 1211 break; 1212 } 1213 } 1214 } 1215 else { 1216 if (RTEST(check_match(pattern, target, checkmatch_type))) { 1217 result = Qtrue; 1218 } 1219 } 1220 1221#line 1222 "vm.inc" 1222 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1223 PUSH(result); 1224#undef CURRENT_INSN_checkmatch 1225#undef INSN_IS_SC 1226#undef INSN_LABEL 1227#undef LABEL_IS_SC 1228 END_INSN(checkmatch);}}} 1229INSN_ENTRY(trace){ 1230{ 1231 rb_num_t nf = (rb_num_t)GET_OPERAND(1); 1232 1233 DEBUG_ENTER_INSN("trace"); 1234 ADD_PC(1+1); 1235 PREFETCH(GET_PC()); 1236 #define CURRENT_INSN_trace 1 1237 #define INSN_IS_SC() 0 1238 #define INSN_LABEL(lab) LABEL_trace_##lab 1239 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1240 COLLECT_USAGE_INSN(BIN(trace)); 1241 COLLECT_USAGE_OPERAND(BIN(trace), 0, nf); 1242{ 1243#line 845 "insns.def" 1244 rb_event_flag_t flag = (rb_event_flag_t)nf; 1245 1246 if (RUBY_DTRACE_METHOD_ENTRY_ENABLED() || 1247 RUBY_DTRACE_METHOD_RETURN_ENABLED() || 1248 RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() || 1249 RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) { 1250 1251 switch(flag) { 1252 case RUBY_EVENT_CALL: 1253 RUBY_DTRACE_METHOD_ENTRY_HOOK(th, 0, 0); 1254 break; 1255 case RUBY_EVENT_C_CALL: 1256 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(th, 0, 0); 1257 break; 1258 case RUBY_EVENT_RETURN: 1259 RUBY_DTRACE_METHOD_RETURN_HOOK(th, 0, 0); 1260 break; 1261 case RUBY_EVENT_C_RETURN: 1262 RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, 0, 0); 1263 break; 1264 } 1265 } 1266 1267 EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0 /* id and klass are resolved at callee */, 1268 (flag & (RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN)) ? TOPN(0) : Qundef); 1269 1270#line 1271 "vm.inc" 1271#undef CURRENT_INSN_trace 1272#undef INSN_IS_SC 1273#undef INSN_LABEL 1274#undef LABEL_IS_SC 1275 END_INSN(trace);}}} 1276INSN_ENTRY(defineclass){ 1277{ 1278 VALUE val; 1279 rb_num_t flags = (rb_num_t)GET_OPERAND(3); 1280 ISEQ class_iseq = (ISEQ)GET_OPERAND(2); 1281 ID id = (ID)GET_OPERAND(1); 1282 VALUE cbase = TOPN(1); 1283 VALUE super = TOPN(0); 1284 DEBUG_ENTER_INSN("defineclass"); 1285 ADD_PC(1+3); 1286 PREFETCH(GET_PC()); 1287 POPN(2); 1288 #define CURRENT_INSN_defineclass 1 1289 #define INSN_IS_SC() 0 1290 #define INSN_LABEL(lab) LABEL_defineclass_##lab 1291 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1292 COLLECT_USAGE_INSN(BIN(defineclass)); 1293 COLLECT_USAGE_OPERAND(BIN(defineclass), 0, id); 1294 COLLECT_USAGE_OPERAND(BIN(defineclass), 1, class_iseq); 1295 COLLECT_USAGE_OPERAND(BIN(defineclass), 2, flags); 1296{ 1297#line 891 "insns.def" 1298 VALUE klass; 1299 rb_vm_defineclass_type_t type = VM_DEFINECLASS_TYPE(flags); 1300 1301 switch (type) { 1302 case VM_DEFINECLASS_TYPE_CLASS: 1303 /* val is dummy. classdef returns class scope value */ 1304 1305 if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) && 1306 !RB_TYPE_P(super, T_CLASS)) { 1307 rb_raise(rb_eTypeError, "superclass must be a Class (%s given)", 1308 rb_obj_classname(super)); 1309 } 1310 1311 if (super == Qnil) { 1312 super = rb_cObject; 1313 } 1314 1315 vm_check_if_namespace(cbase); 1316 1317 /* find klass */ 1318 rb_autoload_load(cbase, id); 1319 if ((klass = vm_search_const_defined_class(cbase, id)) != 0) { 1320 /* already exist */ 1321 klass = VM_DEFINECLASS_SCOPED_P(flags) ? 1322 rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id); 1323 if (!RB_TYPE_P(klass, T_CLASS)) { 1324 rb_raise(rb_eTypeError, "%s is not a class", rb_id2name(id)); 1325 } 1326 1327 if (super != rb_cObject) { 1328 VALUE tmp; 1329 tmp = rb_class_real(RCLASS_SUPER(klass)); 1330 1331 if (tmp != super) { 1332 rb_raise(rb_eTypeError, "superclass mismatch for class %s", 1333 rb_id2name(id)); 1334 } 1335 } 1336 } 1337 else { 1338 /* new class declaration */ 1339 klass = rb_define_class_id(id, super); 1340 rb_set_class_path_string(klass, cbase, rb_id2str(id)); 1341 rb_const_set(cbase, id, klass); 1342 rb_class_inherited(super, klass); 1343 } 1344 break; 1345 case VM_DEFINECLASS_TYPE_SINGLETON_CLASS: 1346 /* val is dummy. classdef returns class scope value */ 1347 /* super is dummy */ 1348 klass = rb_singleton_class(cbase); 1349 break; 1350 case VM_DEFINECLASS_TYPE_MODULE: 1351 /* val is dummy. classdef returns class scope value */ 1352 /* super is dummy */ 1353 1354 vm_check_if_namespace(cbase); 1355 1356 /* find klass */ 1357 if ((klass = vm_search_const_defined_class(cbase, id)) != 0) { 1358 klass = VM_DEFINECLASS_SCOPED_P(flags) ? 1359 rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id); 1360 /* already exist */ 1361 if (!RB_TYPE_P(klass, T_MODULE)) { 1362 rb_raise(rb_eTypeError, "%s is not a module", rb_id2name(id)); 1363 } 1364 } 1365 else { 1366 /* new module declaration */ 1367 klass = rb_define_module_id(id); 1368 rb_set_class_path_string(klass, cbase, rb_id2str(id)); 1369 rb_const_set(cbase, id, klass); 1370 } 1371 break; 1372 default: 1373 rb_bug("unknown defineclass type: %d", (int)type); 1374 } 1375 1376 COPY_CREF(class_iseq->cref_stack, vm_cref_push(th, klass, NOEX_PUBLIC, NULL)); 1377 1378 /* enter scope */ 1379 vm_push_frame(th, class_iseq, VM_FRAME_MAGIC_CLASS, 1380 klass, 0, VM_ENVVAL_BLOCK_PTR(GET_BLOCK_PTR()), 1381 class_iseq->iseq_encoded, GET_SP(), 1382 class_iseq->local_size, 0); 1383 RESTORE_REGS(); 1384 1385 INC_VM_STATE_VERSION(); 1386 NEXT_INSN(); 1387 1388#line 1389 "vm.inc" 1389 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1390 PUSH(val); 1391#undef CURRENT_INSN_defineclass 1392#undef INSN_IS_SC 1393#undef INSN_LABEL 1394#undef LABEL_IS_SC 1395 END_INSN(defineclass);}}} 1396INSN_ENTRY(send){ 1397{ 1398 VALUE val; 1399 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 1400 1401 DEBUG_ENTER_INSN("send"); 1402 ADD_PC(1+1); 1403 PREFETCH(GET_PC()); 1404 #define CURRENT_INSN_send 1 1405 #define INSN_IS_SC() 0 1406 #define INSN_LABEL(lab) LABEL_send_##lab 1407 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1408 COLLECT_USAGE_INSN(BIN(send)); 1409 COLLECT_USAGE_OPERAND(BIN(send), 0, ci); 1410{ 1411#line 998 "insns.def" 1412 ci->argc = ci->orig_argc; 1413 ci->blockptr = 0; 1414 vm_caller_setup_args(th, reg_cfp, ci); 1415 vm_search_method(ci, ci->recv = TOPN(ci->argc)); 1416 CALL_METHOD(ci); 1417 1418#line 1419 "vm.inc" 1419 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1420 PUSH(val); 1421#undef CURRENT_INSN_send 1422#undef INSN_IS_SC 1423#undef INSN_LABEL 1424#undef LABEL_IS_SC 1425 END_INSN(send);}}} 1426INSN_ENTRY(opt_send_simple){ 1427{ 1428 VALUE val; 1429 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 1430 1431 DEBUG_ENTER_INSN("opt_send_simple"); 1432 ADD_PC(1+1); 1433 PREFETCH(GET_PC()); 1434 #define CURRENT_INSN_opt_send_simple 1 1435 #define INSN_IS_SC() 0 1436 #define INSN_LABEL(lab) LABEL_opt_send_simple_##lab 1437 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1438 COLLECT_USAGE_INSN(BIN(opt_send_simple)); 1439 COLLECT_USAGE_OPERAND(BIN(opt_send_simple), 0, ci); 1440{ 1441#line 1016 "insns.def" 1442 vm_search_method(ci, ci->recv = TOPN(ci->argc)); 1443 CALL_METHOD(ci); 1444 1445#line 1446 "vm.inc" 1446 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1447 PUSH(val); 1448#undef CURRENT_INSN_opt_send_simple 1449#undef INSN_IS_SC 1450#undef INSN_LABEL 1451#undef LABEL_IS_SC 1452 END_INSN(opt_send_simple);}}} 1453INSN_ENTRY(invokesuper){ 1454{ 1455 VALUE val; 1456 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 1457 1458 DEBUG_ENTER_INSN("invokesuper"); 1459 ADD_PC(1+1); 1460 PREFETCH(GET_PC()); 1461 #define CURRENT_INSN_invokesuper 1 1462 #define INSN_IS_SC() 0 1463 #define INSN_LABEL(lab) LABEL_invokesuper_##lab 1464 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1465 COLLECT_USAGE_INSN(BIN(invokesuper)); 1466 COLLECT_USAGE_OPERAND(BIN(invokesuper), 0, ci); 1467{ 1468#line 1031 "insns.def" 1469 ci->argc = ci->orig_argc; 1470 ci->blockptr = !(ci->flag & VM_CALL_ARGS_BLOCKARG) ? GET_BLOCK_PTR() : 0; 1471 1472 if (UNLIKELY(!(ci->flag & VM_CALL_ARGS_SKIP_SETUP))) { 1473 vm_caller_setup_args(th, reg_cfp, ci); 1474 } 1475 ci->recv = GET_SELF(); 1476 vm_search_super_method(th, GET_CFP(), ci); 1477 CALL_METHOD(ci); 1478 1479#line 1480 "vm.inc" 1480 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1481 PUSH(val); 1482#undef CURRENT_INSN_invokesuper 1483#undef INSN_IS_SC 1484#undef INSN_LABEL 1485#undef LABEL_IS_SC 1486 END_INSN(invokesuper);}}} 1487INSN_ENTRY(invokeblock){ 1488{ 1489 VALUE val; 1490 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 1491 1492 DEBUG_ENTER_INSN("invokeblock"); 1493 ADD_PC(1+1); 1494 PREFETCH(GET_PC()); 1495 #define CURRENT_INSN_invokeblock 1 1496 #define INSN_IS_SC() 0 1497 #define INSN_LABEL(lab) LABEL_invokeblock_##lab 1498 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1499 COLLECT_USAGE_INSN(BIN(invokeblock)); 1500 COLLECT_USAGE_OPERAND(BIN(invokeblock), 0, ci); 1501{ 1502#line 1053 "insns.def" 1503 ci->argc = ci->orig_argc; 1504 ci->blockptr = 0; 1505 ci->recv = GET_SELF(); 1506 val = vm_invoke_block(th, GET_CFP(), ci); 1507 if (val == Qundef) { 1508 RESTORE_REGS(); 1509 NEXT_INSN(); 1510 } 1511 1512#line 1513 "vm.inc" 1513 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1514 PUSH(val); 1515#undef CURRENT_INSN_invokeblock 1516#undef INSN_IS_SC 1517#undef INSN_LABEL 1518#undef LABEL_IS_SC 1519 END_INSN(invokeblock);}}} 1520INSN_ENTRY(leave){ 1521{ 1522 1523 VALUE val = TOPN(0); 1524 DEBUG_ENTER_INSN("leave"); 1525 ADD_PC(1+0); 1526 PREFETCH(GET_PC()); 1527 POPN(1); 1528 #define CURRENT_INSN_leave 1 1529 #define INSN_IS_SC() 0 1530 #define INSN_LABEL(lab) LABEL_leave_##lab 1531 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1532 COLLECT_USAGE_INSN(BIN(leave)); 1533{ 1534#line 1074 "insns.def" 1535 if (OPT_CHECKED_RUN) { 1536 if (reg_cfp->sp != vm_base_ptr(reg_cfp)) { 1537 rb_bug("Stack consistency error (sp: %"PRIdPTRDIFF", bp: %"PRIdPTRDIFF")", 1538 VM_SP_CNT(th, reg_cfp->sp), VM_SP_CNT(th, vm_base_ptr(reg_cfp))); 1539 } 1540 } 1541 1542 RUBY_VM_CHECK_INTS(th); 1543 1544 if (UNLIKELY(VM_FRAME_TYPE_FINISH_P(GET_CFP()))) { 1545 vm_pop_frame(th); 1546 1547#if OPT_CALL_THREADED_CODE 1548 th->retval = val; 1549 return 0; 1550#else 1551 return val; 1552#endif 1553 } 1554 else { 1555 vm_pop_frame(th); 1556 RESTORE_REGS(); 1557 } 1558 1559#line 1560 "vm.inc" 1560 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1561 PUSH(val); 1562#undef CURRENT_INSN_leave 1563#undef INSN_IS_SC 1564#undef INSN_LABEL 1565#undef LABEL_IS_SC 1566 END_INSN(leave);}}} 1567INSN_ENTRY(throw){ 1568{ 1569 VALUE val; 1570 rb_num_t throw_state = (rb_num_t)GET_OPERAND(1); 1571 VALUE throwobj = TOPN(0); 1572 DEBUG_ENTER_INSN("throw"); 1573 ADD_PC(1+1); 1574 PREFETCH(GET_PC()); 1575 POPN(1); 1576 #define CURRENT_INSN_throw 1 1577 #define INSN_IS_SC() 0 1578 #define INSN_LABEL(lab) LABEL_throw_##lab 1579 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1580 COLLECT_USAGE_INSN(BIN(throw)); 1581 COLLECT_USAGE_OPERAND(BIN(throw), 0, throw_state); 1582{ 1583#line 1114 "insns.def" 1584 RUBY_VM_CHECK_INTS(th); 1585 val = vm_throw(th, GET_CFP(), throw_state, throwobj); 1586 THROW_EXCEPTION(val); 1587 /* unreachable */ 1588 1589#line 1590 "vm.inc" 1590 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1591 PUSH(val); 1592#undef CURRENT_INSN_throw 1593#undef INSN_IS_SC 1594#undef INSN_LABEL 1595#undef LABEL_IS_SC 1596 END_INSN(throw);}}} 1597INSN_ENTRY(jump){ 1598{ 1599 OFFSET dst = (OFFSET)GET_OPERAND(1); 1600 1601 DEBUG_ENTER_INSN("jump"); 1602 ADD_PC(1+1); 1603 PREFETCH(GET_PC()); 1604 #define CURRENT_INSN_jump 1 1605 #define INSN_IS_SC() 0 1606 #define INSN_LABEL(lab) LABEL_jump_##lab 1607 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1608 COLLECT_USAGE_INSN(BIN(jump)); 1609 COLLECT_USAGE_OPERAND(BIN(jump), 0, dst); 1610{ 1611#line 1135 "insns.def" 1612 RUBY_VM_CHECK_INTS(th); 1613 JUMP(dst); 1614 1615#line 1616 "vm.inc" 1616#undef CURRENT_INSN_jump 1617#undef INSN_IS_SC 1618#undef INSN_LABEL 1619#undef LABEL_IS_SC 1620 END_INSN(jump);}}} 1621INSN_ENTRY(branchif){ 1622{ 1623 OFFSET dst = (OFFSET)GET_OPERAND(1); 1624 VALUE val = TOPN(0); 1625 DEBUG_ENTER_INSN("branchif"); 1626 ADD_PC(1+1); 1627 PREFETCH(GET_PC()); 1628 POPN(1); 1629 #define CURRENT_INSN_branchif 1 1630 #define INSN_IS_SC() 0 1631 #define INSN_LABEL(lab) LABEL_branchif_##lab 1632 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1633 COLLECT_USAGE_INSN(BIN(branchif)); 1634 COLLECT_USAGE_OPERAND(BIN(branchif), 0, dst); 1635{ 1636#line 1150 "insns.def" 1637 if (RTEST(val)) { 1638 RUBY_VM_CHECK_INTS(th); 1639 JUMP(dst); 1640 } 1641 1642#line 1643 "vm.inc" 1643#undef CURRENT_INSN_branchif 1644#undef INSN_IS_SC 1645#undef INSN_LABEL 1646#undef LABEL_IS_SC 1647 END_INSN(branchif);}}} 1648INSN_ENTRY(branchunless){ 1649{ 1650 OFFSET dst = (OFFSET)GET_OPERAND(1); 1651 VALUE val = TOPN(0); 1652 DEBUG_ENTER_INSN("branchunless"); 1653 ADD_PC(1+1); 1654 PREFETCH(GET_PC()); 1655 POPN(1); 1656 #define CURRENT_INSN_branchunless 1 1657 #define INSN_IS_SC() 0 1658 #define INSN_LABEL(lab) LABEL_branchunless_##lab 1659 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1660 COLLECT_USAGE_INSN(BIN(branchunless)); 1661 COLLECT_USAGE_OPERAND(BIN(branchunless), 0, dst); 1662{ 1663#line 1167 "insns.def" 1664 if (!RTEST(val)) { 1665 RUBY_VM_CHECK_INTS(th); 1666 JUMP(dst); 1667 } 1668 1669#line 1670 "vm.inc" 1670#undef CURRENT_INSN_branchunless 1671#undef INSN_IS_SC 1672#undef INSN_LABEL 1673#undef LABEL_IS_SC 1674 END_INSN(branchunless);}}} 1675INSN_ENTRY(getinlinecache){ 1676{ 1677 VALUE val; 1678 IC ic = (IC)GET_OPERAND(2); 1679 OFFSET dst = (OFFSET)GET_OPERAND(1); 1680 1681 DEBUG_ENTER_INSN("getinlinecache"); 1682 ADD_PC(1+2); 1683 PREFETCH(GET_PC()); 1684 #define CURRENT_INSN_getinlinecache 1 1685 #define INSN_IS_SC() 0 1686 #define INSN_LABEL(lab) LABEL_getinlinecache_##lab 1687 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1688 COLLECT_USAGE_INSN(BIN(getinlinecache)); 1689 COLLECT_USAGE_OPERAND(BIN(getinlinecache), 0, dst); 1690 COLLECT_USAGE_OPERAND(BIN(getinlinecache), 1, ic); 1691{ 1692#line 1189 "insns.def" 1693 if (ic->ic_vmstat == GET_VM_STATE_VERSION()) { 1694 val = ic->ic_value.value; 1695 JUMP(dst); 1696 } 1697 else { 1698 /* none */ 1699 val = Qnil; 1700 } 1701 1702#line 1703 "vm.inc" 1703 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1704 PUSH(val); 1705#undef CURRENT_INSN_getinlinecache 1706#undef INSN_IS_SC 1707#undef INSN_LABEL 1708#undef LABEL_IS_SC 1709 END_INSN(getinlinecache);}}} 1710INSN_ENTRY(onceinlinecache){ 1711{ 1712 VALUE val; 1713 IC ic = (IC)GET_OPERAND(2); 1714 OFFSET dst = (OFFSET)GET_OPERAND(1); 1715 1716 DEBUG_ENTER_INSN("onceinlinecache"); 1717 ADD_PC(1+2); 1718 PREFETCH(GET_PC()); 1719 #define CURRENT_INSN_onceinlinecache 1 1720 #define INSN_IS_SC() 0 1721 #define INSN_LABEL(lab) LABEL_onceinlinecache_##lab 1722 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1723 COLLECT_USAGE_INSN(BIN(onceinlinecache)); 1724 COLLECT_USAGE_OPERAND(BIN(onceinlinecache), 0, dst); 1725 COLLECT_USAGE_OPERAND(BIN(onceinlinecache), 1, ic); 1726{ 1727#line 1210 "insns.def" 1728 retry: 1729 if (ic->ic_vmstat) { 1730 val = ic->ic_value.value; 1731 JUMP(dst); 1732 } 1733 else if (ic->ic_value.value == Qundef) 1734 { 1735 RUBY_VM_CHECK_INTS(th); 1736 rb_thread_schedule(); 1737 goto retry; 1738 } 1739 else { 1740 /* none */ 1741 ic->ic_value.value = Qundef; 1742 val = Qnil; 1743 } 1744 1745#line 1746 "vm.inc" 1746 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1747 PUSH(val); 1748#undef CURRENT_INSN_onceinlinecache 1749#undef INSN_IS_SC 1750#undef INSN_LABEL 1751#undef LABEL_IS_SC 1752 END_INSN(onceinlinecache);}}} 1753INSN_ENTRY(setinlinecache){ 1754{ 1755 IC ic = (IC)GET_OPERAND(1); 1756 VALUE val = TOPN(0); 1757 DEBUG_ENTER_INSN("setinlinecache"); 1758 ADD_PC(1+1); 1759 PREFETCH(GET_PC()); 1760 POPN(1); 1761 #define CURRENT_INSN_setinlinecache 1 1762 #define INSN_IS_SC() 0 1763 #define INSN_LABEL(lab) LABEL_setinlinecache_##lab 1764 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1765 COLLECT_USAGE_INSN(BIN(setinlinecache)); 1766 COLLECT_USAGE_OPERAND(BIN(setinlinecache), 0, ic); 1767{ 1768#line 1239 "insns.def" 1769 if (ic->ic_value.value == Qundef) { 1770 rb_iseq_add_mark_object(GET_ISEQ(), val); 1771 } 1772 ic->ic_value.value = val; 1773 ic->ic_vmstat = GET_VM_STATE_VERSION() - ruby_vm_const_missing_count; 1774 ruby_vm_const_missing_count = 0; 1775 1776#line 1777 "vm.inc" 1777 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1778 PUSH(val); 1779#undef CURRENT_INSN_setinlinecache 1780#undef INSN_IS_SC 1781#undef INSN_LABEL 1782#undef LABEL_IS_SC 1783 END_INSN(setinlinecache);}}} 1784INSN_ENTRY(opt_case_dispatch){ 1785{ 1786 OFFSET else_offset = (OFFSET)GET_OPERAND(2); 1787 CDHASH hash = (CDHASH)GET_OPERAND(1); 1788 VALUE key = TOPN(0); 1789 DEBUG_ENTER_INSN("opt_case_dispatch"); 1790 ADD_PC(1+2); 1791 PREFETCH(GET_PC()); 1792 POPN(1); 1793 #define CURRENT_INSN_opt_case_dispatch 1 1794 #define INSN_IS_SC() 0 1795 #define INSN_LABEL(lab) LABEL_opt_case_dispatch_##lab 1796 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1797 COLLECT_USAGE_INSN(BIN(opt_case_dispatch)); 1798 COLLECT_USAGE_OPERAND(BIN(opt_case_dispatch), 0, hash); 1799 COLLECT_USAGE_OPERAND(BIN(opt_case_dispatch), 1, else_offset); 1800{ 1801#line 1258 "insns.def" 1802 switch(TYPE(key)) { 1803 case T_FLOAT: { 1804 double ival; 1805 if (modf(RFLOAT_VALUE(key), &ival) == 0.0) { 1806 key = FIXABLE(ival) ? LONG2FIX((long)ival) : rb_dbl2big(ival); 1807 } 1808 } 1809 case T_SYMBOL: /* fall through */ 1810 case T_FIXNUM: 1811 case T_BIGNUM: 1812 case T_STRING: 1813 if (BASIC_OP_UNREDEFINED_P(BOP_EQQ, 1814 SYMBOL_REDEFINED_OP_FLAG | 1815 FIXNUM_REDEFINED_OP_FLAG | 1816 BIGNUM_REDEFINED_OP_FLAG | 1817 STRING_REDEFINED_OP_FLAG)) { 1818 st_data_t val; 1819 if (st_lookup(RHASH_TBL(hash), key, &val)) { 1820 JUMP(FIX2INT((VALUE)val)); 1821 } 1822 else { 1823 JUMP(else_offset); 1824 } 1825 break; 1826 } 1827 default: 1828 break; 1829 } 1830 1831#line 1832 "vm.inc" 1832#undef CURRENT_INSN_opt_case_dispatch 1833#undef INSN_IS_SC 1834#undef INSN_LABEL 1835#undef LABEL_IS_SC 1836 END_INSN(opt_case_dispatch);}}} 1837INSN_ENTRY(opt_plus){ 1838{ 1839 VALUE val; 1840 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 1841 VALUE recv = TOPN(1); 1842 VALUE obj = TOPN(0); 1843 DEBUG_ENTER_INSN("opt_plus"); 1844 ADD_PC(1+1); 1845 PREFETCH(GET_PC()); 1846 POPN(2); 1847 #define CURRENT_INSN_opt_plus 1 1848 #define INSN_IS_SC() 0 1849 #define INSN_LABEL(lab) LABEL_opt_plus_##lab 1850 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1851 COLLECT_USAGE_INSN(BIN(opt_plus)); 1852 COLLECT_USAGE_OPERAND(BIN(opt_plus), 0, ci); 1853{ 1854#line 1301 "insns.def" 1855 if (FIXNUM_2_P(recv, obj) && 1856 BASIC_OP_UNREDEFINED_P(BOP_PLUS,FIXNUM_REDEFINED_OP_FLAG)) { 1857 /* fixnum + fixnum */ 1858#ifndef LONG_LONG_VALUE 1859 val = (recv + (obj & (~1))); 1860 if ((~(recv ^ obj) & (recv ^ val)) & 1861 ((VALUE)0x01 << ((sizeof(VALUE) * CHAR_BIT) - 1))) { 1862 val = rb_big_plus(rb_int2big(FIX2LONG(recv)), 1863 rb_int2big(FIX2LONG(obj))); 1864 } 1865#else 1866 long a, b, c; 1867 a = FIX2LONG(recv); 1868 b = FIX2LONG(obj); 1869 c = a + b; 1870 if (FIXABLE(c)) { 1871 val = LONG2FIX(c); 1872 } 1873 else { 1874 val = rb_big_plus(rb_int2big(a), rb_int2big(b)); 1875 } 1876#endif 1877 } 1878 else if (FLONUM_2_P(recv, obj) && 1879 BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) { 1880 val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj)); 1881 } 1882 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { 1883 if (HEAP_CLASS_OF(recv) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat && 1884 BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) { 1885 val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj)); 1886 } 1887 else if (HEAP_CLASS_OF(recv) == rb_cString && HEAP_CLASS_OF(obj) == rb_cString && 1888 BASIC_OP_UNREDEFINED_P(BOP_PLUS, STRING_REDEFINED_OP_FLAG)) { 1889 val = rb_str_plus(recv, obj); 1890 } 1891 else if (HEAP_CLASS_OF(recv) == rb_cArray && 1892 BASIC_OP_UNREDEFINED_P(BOP_PLUS, ARRAY_REDEFINED_OP_FLAG)) { 1893 val = rb_ary_plus(recv, obj); 1894 } 1895 else { 1896 goto INSN_LABEL(normal_dispatch); 1897 } 1898 } 1899 else { 1900 INSN_LABEL(normal_dispatch): 1901 PUSH(recv); 1902 PUSH(obj); 1903 CALL_SIMPLE_METHOD(recv); 1904 } 1905 1906#line 1907 "vm.inc" 1907 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1908 PUSH(val); 1909#undef CURRENT_INSN_opt_plus 1910#undef INSN_IS_SC 1911#undef INSN_LABEL 1912#undef LABEL_IS_SC 1913 END_INSN(opt_plus);}}} 1914INSN_ENTRY(opt_minus){ 1915{ 1916 VALUE val; 1917 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 1918 VALUE recv = TOPN(1); 1919 VALUE obj = TOPN(0); 1920 DEBUG_ENTER_INSN("opt_minus"); 1921 ADD_PC(1+1); 1922 PREFETCH(GET_PC()); 1923 POPN(2); 1924 #define CURRENT_INSN_opt_minus 1 1925 #define INSN_IS_SC() 0 1926 #define INSN_LABEL(lab) LABEL_opt_minus_##lab 1927 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1928 COLLECT_USAGE_INSN(BIN(opt_minus)); 1929 COLLECT_USAGE_OPERAND(BIN(opt_minus), 0, ci); 1930{ 1931#line 1364 "insns.def" 1932 if (FIXNUM_2_P(recv, obj) && 1933 BASIC_OP_UNREDEFINED_P(BOP_MINUS, FIXNUM_REDEFINED_OP_FLAG)) { 1934 long a, b, c; 1935 1936 a = FIX2LONG(recv); 1937 b = FIX2LONG(obj); 1938 c = a - b; 1939 1940 if (FIXABLE(c)) { 1941 val = LONG2FIX(c); 1942 } 1943 else { 1944 val = rb_big_minus(rb_int2big(a), rb_int2big(b)); 1945 } 1946 } 1947 else if (FLONUM_2_P(recv, obj) && 1948 BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) { 1949 val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj)); 1950 } 1951 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { 1952 if (HEAP_CLASS_OF(recv) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat && 1953 BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) { 1954 val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj)); 1955 } 1956 else { 1957 goto INSN_LABEL(normal_dispatch); 1958 } 1959 } 1960 else { 1961 /* other */ 1962 INSN_LABEL(normal_dispatch): 1963 PUSH(recv); 1964 PUSH(obj); 1965 CALL_SIMPLE_METHOD(recv); 1966 } 1967 1968#line 1969 "vm.inc" 1969 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 1970 PUSH(val); 1971#undef CURRENT_INSN_opt_minus 1972#undef INSN_IS_SC 1973#undef INSN_LABEL 1974#undef LABEL_IS_SC 1975 END_INSN(opt_minus);}}} 1976INSN_ENTRY(opt_mult){ 1977{ 1978 VALUE val; 1979 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 1980 VALUE recv = TOPN(1); 1981 VALUE obj = TOPN(0); 1982 DEBUG_ENTER_INSN("opt_mult"); 1983 ADD_PC(1+1); 1984 PREFETCH(GET_PC()); 1985 POPN(2); 1986 #define CURRENT_INSN_opt_mult 1 1987 #define INSN_IS_SC() 0 1988 #define INSN_LABEL(lab) LABEL_opt_mult_##lab 1989 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 1990 COLLECT_USAGE_INSN(BIN(opt_mult)); 1991 COLLECT_USAGE_OPERAND(BIN(opt_mult), 0, ci); 1992{ 1993#line 1412 "insns.def" 1994 if (FIXNUM_2_P(recv, obj) && 1995 BASIC_OP_UNREDEFINED_P(BOP_MULT, FIXNUM_REDEFINED_OP_FLAG)) { 1996 long a, b; 1997 1998 a = FIX2LONG(recv); 1999 if (a == 0) { 2000 val = recv; 2001 } 2002 else { 2003 b = FIX2LONG(obj); 2004 if (MUL_OVERFLOW_FIXNUM_P(a, b)) { 2005 val = rb_big_mul(rb_int2big(a), rb_int2big(b)); 2006 } 2007 else { 2008 val = LONG2FIX(a * b); 2009 } 2010 } 2011 } 2012 else if (FLONUM_2_P(recv, obj) && 2013 BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) { 2014 val = DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj)); 2015 } 2016 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { 2017 if (HEAP_CLASS_OF(recv) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat && 2018 BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) { 2019 val = DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj)); 2020 } 2021 else { 2022 goto INSN_LABEL(normal_dispatch); 2023 } 2024 } 2025 else { 2026 INSN_LABEL(normal_dispatch): 2027 PUSH(recv); 2028 PUSH(obj); 2029 CALL_SIMPLE_METHOD(recv); 2030 } 2031 2032#line 2033 "vm.inc" 2033 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2034 PUSH(val); 2035#undef CURRENT_INSN_opt_mult 2036#undef INSN_IS_SC 2037#undef INSN_LABEL 2038#undef LABEL_IS_SC 2039 END_INSN(opt_mult);}}} 2040INSN_ENTRY(opt_div){ 2041{ 2042 VALUE val; 2043 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2044 VALUE recv = TOPN(1); 2045 VALUE obj = TOPN(0); 2046 DEBUG_ENTER_INSN("opt_div"); 2047 ADD_PC(1+1); 2048 PREFETCH(GET_PC()); 2049 POPN(2); 2050 #define CURRENT_INSN_opt_div 1 2051 #define INSN_IS_SC() 0 2052 #define INSN_LABEL(lab) LABEL_opt_div_##lab 2053 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2054 COLLECT_USAGE_INSN(BIN(opt_div)); 2055 COLLECT_USAGE_OPERAND(BIN(opt_div), 0, ci); 2056{ 2057#line 1462 "insns.def" 2058 if (FIXNUM_2_P(recv, obj) && 2059 BASIC_OP_UNREDEFINED_P(BOP_DIV, FIXNUM_REDEFINED_OP_FLAG)) { 2060 long x, y, div; 2061 2062 x = FIX2LONG(recv); 2063 y = FIX2LONG(obj); 2064 { 2065 /* copied from numeric.c#fixdivmod */ 2066 long mod; 2067 if (y == 0) 2068 goto INSN_LABEL(normal_dispatch); 2069 if (y < 0) { 2070 if (x < 0) 2071 div = -x / -y; 2072 else 2073 div = -(x / -y); 2074 } 2075 else { 2076 if (x < 0) 2077 div = -(-x / y); 2078 else 2079 div = x / y; 2080 } 2081 mod = x - div * y; 2082 if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { 2083 mod += y; 2084 div -= 1; 2085 } 2086 } 2087 val = LONG2NUM(div); 2088 } 2089 else if (FLONUM_2_P(recv, obj) && 2090 BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) { 2091 val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj)); 2092 } 2093 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { 2094 if (HEAP_CLASS_OF(recv) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat && 2095 BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) { 2096 val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj)); 2097 } 2098 else { 2099 goto INSN_LABEL(normal_dispatch); 2100 } 2101 } 2102 else { 2103 INSN_LABEL(normal_dispatch): 2104 PUSH(recv); 2105 PUSH(obj); 2106 CALL_SIMPLE_METHOD(recv); 2107 } 2108 2109#line 2110 "vm.inc" 2110 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2111 PUSH(val); 2112#undef CURRENT_INSN_opt_div 2113#undef INSN_IS_SC 2114#undef INSN_LABEL 2115#undef LABEL_IS_SC 2116 END_INSN(opt_div);}}} 2117INSN_ENTRY(opt_mod){ 2118{ 2119 VALUE val; 2120 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2121 VALUE recv = TOPN(1); 2122 VALUE obj = TOPN(0); 2123 DEBUG_ENTER_INSN("opt_mod"); 2124 ADD_PC(1+1); 2125 PREFETCH(GET_PC()); 2126 POPN(2); 2127 #define CURRENT_INSN_opt_mod 1 2128 #define INSN_IS_SC() 0 2129 #define INSN_LABEL(lab) LABEL_opt_mod_##lab 2130 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2131 COLLECT_USAGE_INSN(BIN(opt_mod)); 2132 COLLECT_USAGE_OPERAND(BIN(opt_mod), 0, ci); 2133{ 2134#line 1525 "insns.def" 2135 if (FIXNUM_2_P(recv, obj) && 2136 BASIC_OP_UNREDEFINED_P(BOP_MOD, FIXNUM_REDEFINED_OP_FLAG )) { 2137 long x, y, mod; 2138 2139 x = FIX2LONG(recv); 2140 y = FIX2LONG(obj); 2141 { 2142 /* copied from numeric.c#fixdivmod */ 2143 long div; 2144 2145 if (y == 0) 2146 rb_num_zerodiv(); 2147 if (y < 0) { 2148 if (x < 0) 2149 div = -x / -y; 2150 else 2151 div = -(x / -y); 2152 } 2153 else { 2154 if (x < 0) 2155 div = -(-x / y); 2156 else 2157 div = x / y; 2158 } 2159 mod = x - div * y; 2160 if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { 2161 mod += y; 2162 div -= 1; 2163 } 2164 } 2165 val = LONG2FIX(mod); 2166 } 2167 else if (FLONUM_2_P(recv, obj) && 2168 BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) { 2169 val = DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj))); 2170 } 2171 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { 2172 if (HEAP_CLASS_OF(recv) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat && 2173 BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) { 2174 val = DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj))); 2175 } 2176 else { 2177 goto INSN_LABEL(normal_dispatch); 2178 } 2179 } 2180 else { 2181 INSN_LABEL(normal_dispatch): 2182 PUSH(recv); 2183 PUSH(obj); 2184 CALL_SIMPLE_METHOD(recv); 2185 } 2186 2187#line 2188 "vm.inc" 2188 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2189 PUSH(val); 2190#undef CURRENT_INSN_opt_mod 2191#undef INSN_IS_SC 2192#undef INSN_LABEL 2193#undef LABEL_IS_SC 2194 END_INSN(opt_mod);}}} 2195INSN_ENTRY(opt_eq){ 2196{ 2197 VALUE val; 2198 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2199 VALUE recv = TOPN(1); 2200 VALUE obj = TOPN(0); 2201 DEBUG_ENTER_INSN("opt_eq"); 2202 ADD_PC(1+1); 2203 PREFETCH(GET_PC()); 2204 POPN(2); 2205 #define CURRENT_INSN_opt_eq 1 2206 #define INSN_IS_SC() 0 2207 #define INSN_LABEL(lab) LABEL_opt_eq_##lab 2208 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2209 COLLECT_USAGE_INSN(BIN(opt_eq)); 2210 COLLECT_USAGE_OPERAND(BIN(opt_eq), 0, ci); 2211{ 2212#line 1589 "insns.def" 2213 val = opt_eq_func(recv, obj, ci); 2214 2215 if (val == Qundef) { 2216 /* other */ 2217 PUSH(recv); 2218 PUSH(obj); 2219 CALL_SIMPLE_METHOD(recv); 2220 } 2221 2222#line 2223 "vm.inc" 2223 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2224 PUSH(val); 2225#undef CURRENT_INSN_opt_eq 2226#undef INSN_IS_SC 2227#undef INSN_LABEL 2228#undef LABEL_IS_SC 2229 END_INSN(opt_eq);}}} 2230INSN_ENTRY(opt_neq){ 2231{ 2232 VALUE val; 2233 CALL_INFO ci_eq = (CALL_INFO)GET_OPERAND(2); 2234 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2235 VALUE recv = TOPN(1); 2236 VALUE obj = TOPN(0); 2237 DEBUG_ENTER_INSN("opt_neq"); 2238 ADD_PC(1+2); 2239 PREFETCH(GET_PC()); 2240 POPN(2); 2241 #define CURRENT_INSN_opt_neq 1 2242 #define INSN_IS_SC() 0 2243 #define INSN_LABEL(lab) LABEL_opt_neq_##lab 2244 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2245 COLLECT_USAGE_INSN(BIN(opt_neq)); 2246 COLLECT_USAGE_OPERAND(BIN(opt_neq), 0, ci); 2247 COLLECT_USAGE_OPERAND(BIN(opt_neq), 1, ci_eq); 2248{ 2249#line 1610 "insns.def" 2250 extern VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2); 2251 vm_search_method(ci, recv); 2252 val = Qundef; 2253 2254 if (check_cfunc(ci->me, rb_obj_not_equal)) { 2255 val = opt_eq_func(recv, obj, ci_eq); 2256 2257 if (val != Qundef) { 2258 val = RTEST(val) ? Qfalse : Qtrue; 2259 } 2260 } 2261 2262 if (val == Qundef) { 2263 /* other */ 2264 PUSH(recv); 2265 PUSH(obj); 2266 CALL_SIMPLE_METHOD(recv); 2267 } 2268 2269#line 2270 "vm.inc" 2270 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2271 PUSH(val); 2272#undef CURRENT_INSN_opt_neq 2273#undef INSN_IS_SC 2274#undef INSN_LABEL 2275#undef LABEL_IS_SC 2276 END_INSN(opt_neq);}}} 2277INSN_ENTRY(opt_lt){ 2278{ 2279 VALUE val; 2280 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2281 VALUE recv = TOPN(1); 2282 VALUE obj = TOPN(0); 2283 DEBUG_ENTER_INSN("opt_lt"); 2284 ADD_PC(1+1); 2285 PREFETCH(GET_PC()); 2286 POPN(2); 2287 #define CURRENT_INSN_opt_lt 1 2288 #define INSN_IS_SC() 0 2289 #define INSN_LABEL(lab) LABEL_opt_lt_##lab 2290 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2291 COLLECT_USAGE_INSN(BIN(opt_lt)); 2292 COLLECT_USAGE_OPERAND(BIN(opt_lt), 0, ci); 2293{ 2294#line 1641 "insns.def" 2295 if (FIXNUM_2_P(recv, obj) && 2296 BASIC_OP_UNREDEFINED_P(BOP_LT, FIXNUM_REDEFINED_OP_FLAG)) { 2297 SIGNED_VALUE a = recv, b = obj; 2298 2299 if (a < b) { 2300 val = Qtrue; 2301 } 2302 else { 2303 val = Qfalse; 2304 } 2305 } 2306 else if (FLONUM_2_P(recv, obj) && 2307 BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) { 2308 /* flonum is not NaN */ 2309 val = RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj) ? Qtrue : Qfalse; 2310 } 2311 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { 2312 if (HEAP_CLASS_OF(recv) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat && 2313 BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) { 2314 val = double_cmp_lt(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)); 2315 } 2316 else { 2317 goto INSN_LABEL(normal_dispatch); 2318 } 2319 } 2320 else { 2321 INSN_LABEL(normal_dispatch): 2322 PUSH(recv); 2323 PUSH(obj); 2324 CALL_SIMPLE_METHOD(recv); 2325 } 2326 2327#line 2328 "vm.inc" 2328 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2329 PUSH(val); 2330#undef CURRENT_INSN_opt_lt 2331#undef INSN_IS_SC 2332#undef INSN_LABEL 2333#undef LABEL_IS_SC 2334 END_INSN(opt_lt);}}} 2335INSN_ENTRY(opt_le){ 2336{ 2337 VALUE val; 2338 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2339 VALUE recv = TOPN(1); 2340 VALUE obj = TOPN(0); 2341 DEBUG_ENTER_INSN("opt_le"); 2342 ADD_PC(1+1); 2343 PREFETCH(GET_PC()); 2344 POPN(2); 2345 #define CURRENT_INSN_opt_le 1 2346 #define INSN_IS_SC() 0 2347 #define INSN_LABEL(lab) LABEL_opt_le_##lab 2348 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2349 COLLECT_USAGE_INSN(BIN(opt_le)); 2350 COLLECT_USAGE_OPERAND(BIN(opt_le), 0, ci); 2351{ 2352#line 1685 "insns.def" 2353 if (FIXNUM_2_P(recv, obj) && 2354 BASIC_OP_UNREDEFINED_P(BOP_LE, FIXNUM_REDEFINED_OP_FLAG)) { 2355 SIGNED_VALUE a = recv, b = obj; 2356 2357 if (a <= b) { 2358 val = Qtrue; 2359 } 2360 else { 2361 val = Qfalse; 2362 } 2363 } 2364 else if (FLONUM_2_P(recv, obj) && 2365 BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) { 2366 /* flonum is not NaN */ 2367 val = RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj) ? Qtrue : Qfalse; 2368 } 2369 else { 2370 /* other */ 2371 PUSH(recv); 2372 PUSH(obj); 2373 CALL_SIMPLE_METHOD(recv); 2374 } 2375 2376#line 2377 "vm.inc" 2377 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2378 PUSH(val); 2379#undef CURRENT_INSN_opt_le 2380#undef INSN_IS_SC 2381#undef INSN_LABEL 2382#undef LABEL_IS_SC 2383 END_INSN(opt_le);}}} 2384INSN_ENTRY(opt_gt){ 2385{ 2386 VALUE val; 2387 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2388 VALUE recv = TOPN(1); 2389 VALUE obj = TOPN(0); 2390 DEBUG_ENTER_INSN("opt_gt"); 2391 ADD_PC(1+1); 2392 PREFETCH(GET_PC()); 2393 POPN(2); 2394 #define CURRENT_INSN_opt_gt 1 2395 #define INSN_IS_SC() 0 2396 #define INSN_LABEL(lab) LABEL_opt_gt_##lab 2397 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2398 COLLECT_USAGE_INSN(BIN(opt_gt)); 2399 COLLECT_USAGE_OPERAND(BIN(opt_gt), 0, ci); 2400{ 2401#line 1720 "insns.def" 2402 if (FIXNUM_2_P(recv, obj) && 2403 BASIC_OP_UNREDEFINED_P(BOP_GT, FIXNUM_REDEFINED_OP_FLAG)) { 2404 SIGNED_VALUE a = recv, b = obj; 2405 2406 if (a > b) { 2407 val = Qtrue; 2408 } 2409 else { 2410 val = Qfalse; 2411 } 2412 } 2413 else if (FLONUM_2_P(recv, obj) && 2414 BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) { 2415 /* flonum is not NaN */ 2416 val = RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj) ? Qtrue : Qfalse; 2417 } 2418 else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { 2419 if (HEAP_CLASS_OF(recv) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat && 2420 BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) { 2421 val = double_cmp_gt(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)); 2422 } 2423 else { 2424 goto INSN_LABEL(normal_dispatch); 2425 } 2426 } 2427 else { 2428 INSN_LABEL(normal_dispatch): 2429 PUSH(recv); 2430 PUSH(obj); 2431 CALL_SIMPLE_METHOD(recv); 2432 } 2433 2434#line 2435 "vm.inc" 2435 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2436 PUSH(val); 2437#undef CURRENT_INSN_opt_gt 2438#undef INSN_IS_SC 2439#undef INSN_LABEL 2440#undef LABEL_IS_SC 2441 END_INSN(opt_gt);}}} 2442INSN_ENTRY(opt_ge){ 2443{ 2444 VALUE val; 2445 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2446 VALUE recv = TOPN(1); 2447 VALUE obj = TOPN(0); 2448 DEBUG_ENTER_INSN("opt_ge"); 2449 ADD_PC(1+1); 2450 PREFETCH(GET_PC()); 2451 POPN(2); 2452 #define CURRENT_INSN_opt_ge 1 2453 #define INSN_IS_SC() 0 2454 #define INSN_LABEL(lab) LABEL_opt_ge_##lab 2455 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2456 COLLECT_USAGE_INSN(BIN(opt_ge)); 2457 COLLECT_USAGE_OPERAND(BIN(opt_ge), 0, ci); 2458{ 2459#line 1764 "insns.def" 2460 if (FIXNUM_2_P(recv, obj) && 2461 BASIC_OP_UNREDEFINED_P(BOP_GE, FIXNUM_REDEFINED_OP_FLAG)) { 2462 SIGNED_VALUE a = recv, b = obj; 2463 2464 if (a >= b) { 2465 val = Qtrue; 2466 } 2467 else { 2468 val = Qfalse; 2469 } 2470 } 2471 else if (FLONUM_2_P(recv, obj) && 2472 BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) { 2473 /* flonum is not NaN */ 2474 val = RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj) ? Qtrue : Qfalse; 2475 } 2476 else { 2477 PUSH(recv); 2478 PUSH(obj); 2479 CALL_SIMPLE_METHOD(recv); 2480 } 2481 2482#line 2483 "vm.inc" 2483 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2484 PUSH(val); 2485#undef CURRENT_INSN_opt_ge 2486#undef INSN_IS_SC 2487#undef INSN_LABEL 2488#undef LABEL_IS_SC 2489 END_INSN(opt_ge);}}} 2490INSN_ENTRY(opt_ltlt){ 2491{ 2492 VALUE val; 2493 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2494 VALUE recv = TOPN(1); 2495 VALUE obj = TOPN(0); 2496 DEBUG_ENTER_INSN("opt_ltlt"); 2497 ADD_PC(1+1); 2498 PREFETCH(GET_PC()); 2499 POPN(2); 2500 #define CURRENT_INSN_opt_ltlt 1 2501 #define INSN_IS_SC() 0 2502 #define INSN_LABEL(lab) LABEL_opt_ltlt_##lab 2503 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2504 COLLECT_USAGE_INSN(BIN(opt_ltlt)); 2505 COLLECT_USAGE_OPERAND(BIN(opt_ltlt), 0, ci); 2506{ 2507#line 1798 "insns.def" 2508 if (!SPECIAL_CONST_P(recv)) { 2509 if (HEAP_CLASS_OF(recv) == rb_cString && 2510 BASIC_OP_UNREDEFINED_P(BOP_LTLT, STRING_REDEFINED_OP_FLAG)) { 2511 val = rb_str_concat(recv, obj); 2512 } 2513 else if (HEAP_CLASS_OF(recv) == rb_cArray && 2514 BASIC_OP_UNREDEFINED_P(BOP_LTLT, ARRAY_REDEFINED_OP_FLAG)) { 2515 val = rb_ary_push(recv, obj); 2516 } 2517 else { 2518 goto INSN_LABEL(normal_dispatch); 2519 } 2520 } 2521 else { 2522 INSN_LABEL(normal_dispatch): 2523 PUSH(recv); 2524 PUSH(obj); 2525 CALL_SIMPLE_METHOD(recv); 2526 } 2527 2528#line 2529 "vm.inc" 2529 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2530 PUSH(val); 2531#undef CURRENT_INSN_opt_ltlt 2532#undef INSN_IS_SC 2533#undef INSN_LABEL 2534#undef LABEL_IS_SC 2535 END_INSN(opt_ltlt);}}} 2536INSN_ENTRY(opt_aref){ 2537{ 2538 VALUE val; 2539 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2540 VALUE recv = TOPN(1); 2541 VALUE obj = TOPN(0); 2542 DEBUG_ENTER_INSN("opt_aref"); 2543 ADD_PC(1+1); 2544 PREFETCH(GET_PC()); 2545 POPN(2); 2546 #define CURRENT_INSN_opt_aref 1 2547 #define INSN_IS_SC() 0 2548 #define INSN_LABEL(lab) LABEL_opt_aref_##lab 2549 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2550 COLLECT_USAGE_INSN(BIN(opt_aref)); 2551 COLLECT_USAGE_OPERAND(BIN(opt_aref), 0, ci); 2552{ 2553#line 1830 "insns.def" 2554 if (!SPECIAL_CONST_P(recv)) { 2555 if (HEAP_CLASS_OF(recv) == rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_AREF, ARRAY_REDEFINED_OP_FLAG) && FIXNUM_P(obj)) { 2556 val = rb_ary_entry(recv, FIX2LONG(obj)); 2557 } 2558 else if (HEAP_CLASS_OF(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) { 2559 val = rb_hash_aref(recv, obj); 2560 } 2561 else { 2562 goto INSN_LABEL(normal_dispatch); 2563 } 2564 } 2565 else { 2566 INSN_LABEL(normal_dispatch): 2567 PUSH(recv); 2568 PUSH(obj); 2569 CALL_SIMPLE_METHOD(recv); 2570 } 2571 2572#line 2573 "vm.inc" 2573 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2574 PUSH(val); 2575#undef CURRENT_INSN_opt_aref 2576#undef INSN_IS_SC 2577#undef INSN_LABEL 2578#undef LABEL_IS_SC 2579 END_INSN(opt_aref);}}} 2580INSN_ENTRY(opt_aset){ 2581{ 2582 VALUE val; 2583 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2584 VALUE recv = TOPN(2); 2585 VALUE obj = TOPN(1); 2586 VALUE set = TOPN(0); 2587 DEBUG_ENTER_INSN("opt_aset"); 2588 ADD_PC(1+1); 2589 PREFETCH(GET_PC()); 2590 POPN(3); 2591 #define CURRENT_INSN_opt_aset 1 2592 #define INSN_IS_SC() 0 2593 #define INSN_LABEL(lab) LABEL_opt_aset_##lab 2594 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2595 COLLECT_USAGE_INSN(BIN(opt_aset)); 2596 COLLECT_USAGE_OPERAND(BIN(opt_aset), 0, ci); 2597{ 2598#line 1860 "insns.def" 2599 if (!SPECIAL_CONST_P(recv)) { 2600 if (HEAP_CLASS_OF(recv) == rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_ASET, ARRAY_REDEFINED_OP_FLAG) && FIXNUM_P(obj)) { 2601 rb_ary_store(recv, FIX2LONG(obj), set); 2602 val = set; 2603 } 2604 else if (HEAP_CLASS_OF(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) { 2605 rb_hash_aset(recv, obj, set); 2606 val = set; 2607 } 2608 else { 2609 goto INSN_LABEL(normal_dispatch); 2610 } 2611 } 2612 else { 2613 INSN_LABEL(normal_dispatch): 2614 PUSH(recv); 2615 PUSH(obj); 2616 PUSH(set); 2617 CALL_SIMPLE_METHOD(recv); 2618 } 2619 2620#line 2621 "vm.inc" 2621 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2622 PUSH(val); 2623#undef CURRENT_INSN_opt_aset 2624#undef INSN_IS_SC 2625#undef INSN_LABEL 2626#undef LABEL_IS_SC 2627 END_INSN(opt_aset);}}} 2628INSN_ENTRY(opt_length){ 2629{ 2630 VALUE val; 2631 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2632 VALUE recv = TOPN(0); 2633 DEBUG_ENTER_INSN("opt_length"); 2634 ADD_PC(1+1); 2635 PREFETCH(GET_PC()); 2636 POPN(1); 2637 #define CURRENT_INSN_opt_length 1 2638 #define INSN_IS_SC() 0 2639 #define INSN_LABEL(lab) LABEL_opt_length_##lab 2640 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2641 COLLECT_USAGE_INSN(BIN(opt_length)); 2642 COLLECT_USAGE_OPERAND(BIN(opt_length), 0, ci); 2643{ 2644#line 1893 "insns.def" 2645 if (!SPECIAL_CONST_P(recv)) { 2646 if (HEAP_CLASS_OF(recv) == rb_cString && 2647 BASIC_OP_UNREDEFINED_P(BOP_LENGTH, STRING_REDEFINED_OP_FLAG)) { 2648 val = rb_str_length(recv); 2649 } 2650 else if (HEAP_CLASS_OF(recv) == rb_cArray && 2651 BASIC_OP_UNREDEFINED_P(BOP_LENGTH, ARRAY_REDEFINED_OP_FLAG)) { 2652 val = LONG2NUM(RARRAY_LEN(recv)); 2653 } 2654 else if (HEAP_CLASS_OF(recv) == rb_cHash && 2655 BASIC_OP_UNREDEFINED_P(BOP_LENGTH, HASH_REDEFINED_OP_FLAG)) { 2656 val = INT2FIX(RHASH_SIZE(recv)); 2657 } 2658 else { 2659 goto INSN_LABEL(normal_dispatch); 2660 } 2661 } 2662 else { 2663 INSN_LABEL(normal_dispatch): 2664 PUSH(recv); 2665 CALL_SIMPLE_METHOD(recv); 2666 } 2667 2668#line 2669 "vm.inc" 2669 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2670 PUSH(val); 2671#undef CURRENT_INSN_opt_length 2672#undef INSN_IS_SC 2673#undef INSN_LABEL 2674#undef LABEL_IS_SC 2675 END_INSN(opt_length);}}} 2676INSN_ENTRY(opt_size){ 2677{ 2678 VALUE val; 2679 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2680 VALUE recv = TOPN(0); 2681 DEBUG_ENTER_INSN("opt_size"); 2682 ADD_PC(1+1); 2683 PREFETCH(GET_PC()); 2684 POPN(1); 2685 #define CURRENT_INSN_opt_size 1 2686 #define INSN_IS_SC() 0 2687 #define INSN_LABEL(lab) LABEL_opt_size_##lab 2688 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2689 COLLECT_USAGE_INSN(BIN(opt_size)); 2690 COLLECT_USAGE_OPERAND(BIN(opt_size), 0, ci); 2691{ 2692#line 1928 "insns.def" 2693 if (!SPECIAL_CONST_P(recv)) { 2694 if (HEAP_CLASS_OF(recv) == rb_cString && 2695 BASIC_OP_UNREDEFINED_P(BOP_SIZE, STRING_REDEFINED_OP_FLAG)) { 2696 val = rb_str_length(recv); 2697 } 2698 else if (HEAP_CLASS_OF(recv) == rb_cArray && 2699 BASIC_OP_UNREDEFINED_P(BOP_SIZE, ARRAY_REDEFINED_OP_FLAG)) { 2700 val = LONG2NUM(RARRAY_LEN(recv)); 2701 } 2702 else if (HEAP_CLASS_OF(recv) == rb_cHash && 2703 BASIC_OP_UNREDEFINED_P(BOP_SIZE, HASH_REDEFINED_OP_FLAG)) { 2704 val = INT2FIX(RHASH_SIZE(recv)); 2705 } 2706 else { 2707 goto INSN_LABEL(normal_dispatch); 2708 } 2709 } 2710 else { 2711 INSN_LABEL(normal_dispatch): 2712 PUSH(recv); 2713 CALL_SIMPLE_METHOD(recv); 2714 } 2715 2716#line 2717 "vm.inc" 2717 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2718 PUSH(val); 2719#undef CURRENT_INSN_opt_size 2720#undef INSN_IS_SC 2721#undef INSN_LABEL 2722#undef LABEL_IS_SC 2723 END_INSN(opt_size);}}} 2724INSN_ENTRY(opt_empty_p){ 2725{ 2726 VALUE val; 2727 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2728 VALUE recv = TOPN(0); 2729 DEBUG_ENTER_INSN("opt_empty_p"); 2730 ADD_PC(1+1); 2731 PREFETCH(GET_PC()); 2732 POPN(1); 2733 #define CURRENT_INSN_opt_empty_p 1 2734 #define INSN_IS_SC() 0 2735 #define INSN_LABEL(lab) LABEL_opt_empty_p_##lab 2736 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2737 COLLECT_USAGE_INSN(BIN(opt_empty_p)); 2738 COLLECT_USAGE_OPERAND(BIN(opt_empty_p), 0, ci); 2739{ 2740#line 1963 "insns.def" 2741 if (!SPECIAL_CONST_P(recv)) { 2742 if (HEAP_CLASS_OF(recv) == rb_cString && 2743 BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, STRING_REDEFINED_OP_FLAG)) { 2744 if (RSTRING_LEN(recv) == 0) val = Qtrue; 2745 else val = Qfalse; 2746 } 2747 else if (HEAP_CLASS_OF(recv) == rb_cArray && 2748 BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, ARRAY_REDEFINED_OP_FLAG)) { 2749 if (RARRAY_LEN(recv) == 0) val = Qtrue; 2750 else val = Qfalse; 2751 } 2752 else if (HEAP_CLASS_OF(recv) == rb_cHash && 2753 BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, HASH_REDEFINED_OP_FLAG)) { 2754 if (RHASH_EMPTY_P(recv)) val = Qtrue; 2755 else val = Qfalse; 2756 } 2757 else { 2758 goto INSN_LABEL(normal_dispatch); 2759 } 2760 } 2761 else { 2762 INSN_LABEL(normal_dispatch): 2763 PUSH(recv); 2764 CALL_SIMPLE_METHOD(recv); 2765 } 2766 2767#line 2768 "vm.inc" 2768 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2769 PUSH(val); 2770#undef CURRENT_INSN_opt_empty_p 2771#undef INSN_IS_SC 2772#undef INSN_LABEL 2773#undef LABEL_IS_SC 2774 END_INSN(opt_empty_p);}}} 2775INSN_ENTRY(opt_succ){ 2776{ 2777 VALUE val; 2778 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2779 VALUE recv = TOPN(0); 2780 DEBUG_ENTER_INSN("opt_succ"); 2781 ADD_PC(1+1); 2782 PREFETCH(GET_PC()); 2783 POPN(1); 2784 #define CURRENT_INSN_opt_succ 1 2785 #define INSN_IS_SC() 0 2786 #define INSN_LABEL(lab) LABEL_opt_succ_##lab 2787 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2788 COLLECT_USAGE_INSN(BIN(opt_succ)); 2789 COLLECT_USAGE_OPERAND(BIN(opt_succ), 0, ci); 2790{ 2791#line 2001 "insns.def" 2792 if (SPECIAL_CONST_P(recv)) { 2793 if (FIXNUM_P(recv) && 2794 BASIC_OP_UNREDEFINED_P(BOP_SUCC, FIXNUM_REDEFINED_OP_FLAG)) { 2795 const VALUE obj = INT2FIX(1); 2796 /* fixnum + INT2FIX(1) */ 2797 val = (recv + (obj & (~1))); 2798 if ((~(recv ^ obj) & (recv ^ val)) & ((unsigned long)LONG_MAX + 1)) { 2799 val = rb_big_plus(rb_int2big(FIX2LONG(recv)), 2800 rb_int2big(FIX2LONG(obj))); 2801 } 2802 } 2803 else { 2804 goto INSN_LABEL(normal_dispatch); 2805 } 2806 } 2807 else { 2808 if (HEAP_CLASS_OF(recv) == rb_cString && 2809 BASIC_OP_UNREDEFINED_P(BOP_SUCC, STRING_REDEFINED_OP_FLAG)) { 2810 val = rb_str_succ(recv); 2811 } 2812 else if (HEAP_CLASS_OF(recv) == rb_cTime && 2813 BASIC_OP_UNREDEFINED_P(BOP_SUCC, TIME_REDEFINED_OP_FLAG)) { 2814 val = rb_time_succ(recv); 2815 } 2816 else 2817 { 2818 goto INSN_LABEL(normal_dispatch); 2819 } 2820 } 2821 if (0) { 2822 INSN_LABEL(normal_dispatch): 2823 PUSH(recv); 2824 CALL_SIMPLE_METHOD(recv); 2825 } 2826 2827#line 2828 "vm.inc" 2828 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2829 PUSH(val); 2830#undef CURRENT_INSN_opt_succ 2831#undef INSN_IS_SC 2832#undef INSN_LABEL 2833#undef LABEL_IS_SC 2834 END_INSN(opt_succ);}}} 2835INSN_ENTRY(opt_not){ 2836{ 2837 VALUE val; 2838 CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); 2839 VALUE recv = TOPN(0); 2840 DEBUG_ENTER_INSN("opt_not"); 2841 ADD_PC(1+1); 2842 PREFETCH(GET_PC()); 2843 POPN(1); 2844 #define CURRENT_INSN_opt_not 1 2845 #define INSN_IS_SC() 0 2846 #define INSN_LABEL(lab) LABEL_opt_not_##lab 2847 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2848 COLLECT_USAGE_INSN(BIN(opt_not)); 2849 COLLECT_USAGE_OPERAND(BIN(opt_not), 0, ci); 2850{ 2851#line 2048 "insns.def" 2852 extern VALUE rb_obj_not(VALUE obj); 2853 vm_search_method(ci, recv); 2854 2855 if (check_cfunc(ci->me, rb_obj_not)) { 2856 val = RTEST(recv) ? Qfalse : Qtrue; 2857 } 2858 else { 2859 PUSH(recv); 2860 CALL_SIMPLE_METHOD(recv); 2861 } 2862 2863#line 2864 "vm.inc" 2864 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2865 PUSH(val); 2866#undef CURRENT_INSN_opt_not 2867#undef INSN_IS_SC 2868#undef INSN_LABEL 2869#undef LABEL_IS_SC 2870 END_INSN(opt_not);}}} 2871INSN_ENTRY(opt_regexpmatch1){ 2872{ 2873 VALUE val; 2874 VALUE r = (VALUE)GET_OPERAND(1); 2875 VALUE obj = TOPN(0); 2876 DEBUG_ENTER_INSN("opt_regexpmatch1"); 2877 ADD_PC(1+1); 2878 PREFETCH(GET_PC()); 2879 POPN(1); 2880 #define CURRENT_INSN_opt_regexpmatch1 1 2881 #define INSN_IS_SC() 0 2882 #define INSN_LABEL(lab) LABEL_opt_regexpmatch1_##lab 2883 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2884 COLLECT_USAGE_INSN(BIN(opt_regexpmatch1)); 2885 COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch1), 0, r); 2886{ 2887#line 2072 "insns.def" 2888 val = rb_reg_match(r, obj); 2889 2890#line 2891 "vm.inc" 2891 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2892 PUSH(val); 2893#undef CURRENT_INSN_opt_regexpmatch1 2894#undef INSN_IS_SC 2895#undef INSN_LABEL 2896#undef LABEL_IS_SC 2897 END_INSN(opt_regexpmatch1);}}} 2898INSN_ENTRY(opt_regexpmatch2){ 2899{ 2900 VALUE val; 2901 2902 VALUE obj2 = TOPN(1); 2903 VALUE obj1 = TOPN(0); 2904 DEBUG_ENTER_INSN("opt_regexpmatch2"); 2905 ADD_PC(1+0); 2906 PREFETCH(GET_PC()); 2907 POPN(2); 2908 #define CURRENT_INSN_opt_regexpmatch2 1 2909 #define INSN_IS_SC() 0 2910 #define INSN_LABEL(lab) LABEL_opt_regexpmatch2_##lab 2911 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2912 COLLECT_USAGE_INSN(BIN(opt_regexpmatch2)); 2913{ 2914#line 2086 "insns.def" 2915 if (RB_TYPE_P(obj2, T_STRING)) { 2916 val = rb_reg_match(obj1, obj2); 2917 } 2918 else { 2919 val = rb_funcall(obj2, idEqTilde, 1, obj1); 2920 } 2921 2922#line 2923 "vm.inc" 2923 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2924 PUSH(val); 2925#undef CURRENT_INSN_opt_regexpmatch2 2926#undef INSN_IS_SC 2927#undef INSN_LABEL 2928#undef LABEL_IS_SC 2929 END_INSN(opt_regexpmatch2);}}} 2930INSN_ENTRY(opt_call_c_function){ 2931{ 2932 rb_insn_func_t funcptr = (rb_insn_func_t)GET_OPERAND(1); 2933 2934 DEBUG_ENTER_INSN("opt_call_c_function"); 2935 ADD_PC(1+1); 2936 PREFETCH(GET_PC()); 2937 #define CURRENT_INSN_opt_call_c_function 1 2938 #define INSN_IS_SC() 0 2939 #define INSN_LABEL(lab) LABEL_opt_call_c_function_##lab 2940 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2941 COLLECT_USAGE_INSN(BIN(opt_call_c_function)); 2942 COLLECT_USAGE_OPERAND(BIN(opt_call_c_function), 0, funcptr); 2943{ 2944#line 2105 "insns.def" 2945 reg_cfp = (funcptr)(th, reg_cfp); 2946 2947 if (reg_cfp == 0) { 2948 VALUE err = th->errinfo; 2949 th->errinfo = Qnil; 2950 THROW_EXCEPTION(err); 2951 } 2952 2953 RESTORE_REGS(); 2954 NEXT_INSN(); 2955 2956#line 2957 "vm.inc" 2957#undef CURRENT_INSN_opt_call_c_function 2958#undef INSN_IS_SC 2959#undef INSN_LABEL 2960#undef LABEL_IS_SC 2961 END_INSN(opt_call_c_function);}}} 2962INSN_ENTRY(bitblt){ 2963{ 2964 VALUE ret; 2965 2966 2967 DEBUG_ENTER_INSN("bitblt"); 2968 ADD_PC(1+0); 2969 PREFETCH(GET_PC()); 2970 #define CURRENT_INSN_bitblt 1 2971 #define INSN_IS_SC() 0 2972 #define INSN_LABEL(lab) LABEL_bitblt_##lab 2973 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2974 COLLECT_USAGE_INSN(BIN(bitblt)); 2975{ 2976#line 2128 "insns.def" 2977 ret = rb_str_new2("a bit of bacon, lettuce and tomato"); 2978 2979#line 2980 "vm.inc" 2980 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 2981 PUSH(ret); 2982#undef CURRENT_INSN_bitblt 2983#undef INSN_IS_SC 2984#undef INSN_LABEL 2985#undef LABEL_IS_SC 2986 END_INSN(bitblt);}}} 2987INSN_ENTRY(answer){ 2988{ 2989 VALUE ret; 2990 2991 2992 DEBUG_ENTER_INSN("answer"); 2993 ADD_PC(1+0); 2994 PREFETCH(GET_PC()); 2995 #define CURRENT_INSN_answer 1 2996 #define INSN_IS_SC() 0 2997 #define INSN_LABEL(lab) LABEL_answer_##lab 2998 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 2999 COLLECT_USAGE_INSN(BIN(answer)); 3000{ 3001#line 2142 "insns.def" 3002 ret = INT2FIX(42); 3003 3004#line 3005 "vm.inc" 3005 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 3006 PUSH(ret); 3007#undef CURRENT_INSN_answer 3008#undef INSN_IS_SC 3009#undef INSN_LABEL 3010#undef LABEL_IS_SC 3011 END_INSN(answer);}}} 3012INSN_ENTRY(getlocal_OP__WC__0){ 3013{ 3014 VALUE val; 3015 #define level 0 3016 lindex_t idx = (lindex_t)GET_OPERAND(1); 3017 3018 DEBUG_ENTER_INSN("getlocal_OP__WC__0"); 3019 ADD_PC(1+1); 3020 PREFETCH(GET_PC()); 3021 #define CURRENT_INSN_getlocal_OP__WC__0 1 3022 #define INSN_IS_SC() 0 3023 #define INSN_LABEL(lab) LABEL_getlocal_OP__WC__0_##lab 3024 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 3025 COLLECT_USAGE_INSN(BIN(getlocal_OP__WC__0)); 3026 COLLECT_USAGE_OPERAND(BIN(getlocal_OP__WC__0), 0, idx); 3027{ 3028#line 60 "insns.def" 3029 int i, lev = (int)level; 3030 VALUE *ep = GET_EP(); 3031 3032 for (i = 0; i < lev; i++) { 3033 ep = GET_PREV_EP(ep); 3034 } 3035 val = *(ep - idx); 3036 3037#line 3038 "vm.inc" 3038 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 3039 PUSH(val); 3040#undef level 3041#undef CURRENT_INSN_getlocal_OP__WC__0 3042#undef INSN_IS_SC 3043#undef INSN_LABEL 3044#undef LABEL_IS_SC 3045 END_INSN(getlocal_OP__WC__0);}}} 3046INSN_ENTRY(getlocal_OP__WC__1){ 3047{ 3048 VALUE val; 3049 #define level 1 3050 lindex_t idx = (lindex_t)GET_OPERAND(1); 3051 3052 DEBUG_ENTER_INSN("getlocal_OP__WC__1"); 3053 ADD_PC(1+1); 3054 PREFETCH(GET_PC()); 3055 #define CURRENT_INSN_getlocal_OP__WC__1 1 3056 #define INSN_IS_SC() 0 3057 #define INSN_LABEL(lab) LABEL_getlocal_OP__WC__1_##lab 3058 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 3059 COLLECT_USAGE_INSN(BIN(getlocal_OP__WC__1)); 3060 COLLECT_USAGE_OPERAND(BIN(getlocal_OP__WC__1), 0, idx); 3061{ 3062#line 60 "insns.def" 3063 int i, lev = (int)level; 3064 VALUE *ep = GET_EP(); 3065 3066 for (i = 0; i < lev; i++) { 3067 ep = GET_PREV_EP(ep); 3068 } 3069 val = *(ep - idx); 3070 3071#line 3072 "vm.inc" 3072 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 3073 PUSH(val); 3074#undef level 3075#undef CURRENT_INSN_getlocal_OP__WC__1 3076#undef INSN_IS_SC 3077#undef INSN_LABEL 3078#undef LABEL_IS_SC 3079 END_INSN(getlocal_OP__WC__1);}}} 3080INSN_ENTRY(setlocal_OP__WC__0){ 3081{ 3082 #define level 0 3083 lindex_t idx = (lindex_t)GET_OPERAND(1); 3084 VALUE val = TOPN(0); 3085 DEBUG_ENTER_INSN("setlocal_OP__WC__0"); 3086 ADD_PC(1+1); 3087 PREFETCH(GET_PC()); 3088 POPN(1); 3089 #define CURRENT_INSN_setlocal_OP__WC__0 1 3090 #define INSN_IS_SC() 0 3091 #define INSN_LABEL(lab) LABEL_setlocal_OP__WC__0_##lab 3092 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 3093 COLLECT_USAGE_INSN(BIN(setlocal_OP__WC__0)); 3094 COLLECT_USAGE_OPERAND(BIN(setlocal_OP__WC__0), 0, idx); 3095{ 3096#line 82 "insns.def" 3097 int i, lev = (int)level; 3098 VALUE *ep = GET_EP(); 3099 3100 for (i = 0; i < lev; i++) { 3101 ep = GET_PREV_EP(ep); 3102 } 3103 *(ep - idx) = val; 3104 3105#line 3106 "vm.inc" 3106#undef level 3107#undef CURRENT_INSN_setlocal_OP__WC__0 3108#undef INSN_IS_SC 3109#undef INSN_LABEL 3110#undef LABEL_IS_SC 3111 END_INSN(setlocal_OP__WC__0);}}} 3112INSN_ENTRY(setlocal_OP__WC__1){ 3113{ 3114 #define level 1 3115 lindex_t idx = (lindex_t)GET_OPERAND(1); 3116 VALUE val = TOPN(0); 3117 DEBUG_ENTER_INSN("setlocal_OP__WC__1"); 3118 ADD_PC(1+1); 3119 PREFETCH(GET_PC()); 3120 POPN(1); 3121 #define CURRENT_INSN_setlocal_OP__WC__1 1 3122 #define INSN_IS_SC() 0 3123 #define INSN_LABEL(lab) LABEL_setlocal_OP__WC__1_##lab 3124 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 3125 COLLECT_USAGE_INSN(BIN(setlocal_OP__WC__1)); 3126 COLLECT_USAGE_OPERAND(BIN(setlocal_OP__WC__1), 0, idx); 3127{ 3128#line 82 "insns.def" 3129 int i, lev = (int)level; 3130 VALUE *ep = GET_EP(); 3131 3132 for (i = 0; i < lev; i++) { 3133 ep = GET_PREV_EP(ep); 3134 } 3135 *(ep - idx) = val; 3136 3137#line 3138 "vm.inc" 3138#undef level 3139#undef CURRENT_INSN_setlocal_OP__WC__1 3140#undef INSN_IS_SC 3141#undef INSN_LABEL 3142#undef LABEL_IS_SC 3143 END_INSN(setlocal_OP__WC__1);}}} 3144INSN_ENTRY(putobject_OP_INT2FIX_O_0_C_){ 3145{ 3146 #define val INT2FIX(0) 3147 3148 3149 DEBUG_ENTER_INSN("putobject_OP_INT2FIX_O_0_C_"); 3150 ADD_PC(1+0); 3151 PREFETCH(GET_PC()); 3152 #define CURRENT_INSN_putobject_OP_INT2FIX_O_0_C_ 1 3153 #define INSN_IS_SC() 0 3154 #define INSN_LABEL(lab) LABEL_putobject_OP_INT2FIX_O_0_C__##lab 3155 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 3156 COLLECT_USAGE_INSN(BIN(putobject_OP_INT2FIX_O_0_C_)); 3157{ 3158#line 298 "insns.def" 3159 /* */ 3160 3161#line 3162 "vm.inc" 3162 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 3163 PUSH(val); 3164#undef val 3165#undef CURRENT_INSN_putobject_OP_INT2FIX_O_0_C_ 3166#undef INSN_IS_SC 3167#undef INSN_LABEL 3168#undef LABEL_IS_SC 3169 END_INSN(putobject_OP_INT2FIX_O_0_C_);}}} 3170INSN_ENTRY(putobject_OP_INT2FIX_O_1_C_){ 3171{ 3172 #define val INT2FIX(1) 3173 3174 3175 DEBUG_ENTER_INSN("putobject_OP_INT2FIX_O_1_C_"); 3176 ADD_PC(1+0); 3177 PREFETCH(GET_PC()); 3178 #define CURRENT_INSN_putobject_OP_INT2FIX_O_1_C_ 1 3179 #define INSN_IS_SC() 0 3180 #define INSN_LABEL(lab) LABEL_putobject_OP_INT2FIX_O_1_C__##lab 3181 #define LABEL_IS_SC(lab) LABEL_##lab##_##t 3182 COLLECT_USAGE_INSN(BIN(putobject_OP_INT2FIX_O_1_C_)); 3183{ 3184#line 298 "insns.def" 3185 /* */ 3186 3187#line 3188 "vm.inc" 3188 CHECK_VM_STACK_OVERFLOW(REG_CFP, 1); 3189 PUSH(val); 3190#undef val 3191#undef CURRENT_INSN_putobject_OP_INT2FIX_O_1_C_ 3192#undef INSN_IS_SC 3193#undef INSN_LABEL 3194#undef LABEL_IS_SC 3195 END_INSN(putobject_OP_INT2FIX_O_1_C_);}}} 3196 3197