1/******************************** -*- C -*- **************************** 2 * 3 * Interpreter definitions. 4 * 5 * 6 ***********************************************************************/ 7 8/*********************************************************************** 9 * 10 * Copyright 2003, 2006, 2008, 2009 Free Software Foundation, Inc. 11 * Written by Steve Byrne and Paolo Bonzini. 12 * 13 * This file is part of GNU Smalltalk. 14 * 15 * GNU Smalltalk is free software; you can redistribute it and/or modify it 16 * under the terms of the GNU General Public License as published by the Free 17 * Software Foundation; either version 2, or (at your option) any later 18 * version. 19 * 20 * Linking GNU Smalltalk statically or dynamically with other modules is 21 * making a combined work based on GNU Smalltalk. Thus, the terms and 22 * conditions of the GNU General Public License cover the whole 23 * combination. 24 * 25 * In addition, as a special exception, the Free Software Foundation 26 * give you permission to combine GNU Smalltalk with free software 27 * programs or libraries that are released under the GNU LGPL and with 28 * independent programs running under the GNU Smalltalk virtual machine. 29 * 30 * You may copy and distribute such a system following the terms of the 31 * GNU GPL for GNU Smalltalk and the licenses of the other code 32 * concerned, provided that you include the source code of that other 33 * code when and as the GNU GPL requires distribution of source code. 34 * 35 * Note that people who make modified versions of GNU Smalltalk are not 36 * obligated to grant this special exception for their modified 37 * versions; it is their choice whether to do so. The GNU General 38 * Public License gives permission to release a modified version without 39 * this exception; this exception also makes it possible to release a 40 * modified version which carries forward this exception. 41 * 42 * GNU Smalltalk is distributed in the hope that it will be useful, but WITHOUT 43 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 44 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 45 * more details. 46 * 47 * You should have received a copy of the GNU General Public License along with 48 * GNU Smalltalk; see the file COPYING. If not, write to the Free Software 49 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 50 * 51 ***********************************************************************/ 52 53/* This has two kinds of declarations: 54 - operations are C code together with the stack effect that it should have; 55 so far, this is used only to avoid specifying pushes and pops, but it 56 might be used to combine the accesses to the stack and do some great 57 optimization of the superoperators. `break' inside an operation has the 58 nice effect of getting out of it. 59 60 They can have parameters which are specified between the name and the 61 stack effect. Both the formal parameters, and the stack slots, are 62 guaranteed to be lvalues. 63 64 - tables are, well, dispatching tables for bytecodes expressed in a short, 65 useful syntax. Inside tables one defines bytecodes, which are sequences 66 of operations which expand the operations and use the input code stream 67 to pass them actual parameters. 68 69 Preprocessor statements are passed through without any change. */ 70 71 72#define SEND_TO_SUPER(sendSelector, sendArgs, methodClass) \ 73 _gst_send_message_internal(sendSelector, sendArgs, _gst_self, methodClass) 74 75#if REG_AVAILABILITY >= 2 && defined(LOCAL_REGS) 76#define RECEIVER_VARIABLE(index) INSTANCE_VARIABLE (self_cache, index) 77#define METHOD_TEMPORARY(index) temp_cache[index] 78#define METHOD_LITERAL(index) lit_cache[index] 79#define STORE_RECEIVER_VARIABLE(index, oop) STORE_INSTANCE_VARIABLE (self_cache, index, oop) 80#define STORE_METHOD_TEMPORARY(index, oop) temp_cache[index] = (oop) 81#define STORE_METHOD_LITERAL(index, oop) lit_cache[index] = (oop) 82#else 83#define RECEIVER_VARIABLE(index) INSTANCE_VARIABLE (_gst_self, index) 84#define METHOD_TEMPORARY(index) _gst_temporaries[index] 85#define METHOD_LITERAL(index) _gst_literals[index] 86#define STORE_RECEIVER_VARIABLE(index, oop) STORE_INSTANCE_VARIABLE (_gst_self, index, oop) 87#define STORE_METHOD_TEMPORARY(index, oop) _gst_temporaries[index] = (oop) 88#define STORE_METHOD_LITERAL(index, oop) _gst_literals[index] = (oop) 89#endif 90 91#ifndef OPEN_CODE_MATH 92 93#define RAW_INT_OP(op, op1, op2, iop) 94#define RAW_FLOATD_OP(op, op1, op2, fop) 95#define INTERP_BASIC_OP(op, op1, op2, iop, fop) 96#define INTERP_BASIC_BOOL(op, op1, op2, operator) 97 98#else 99 100#define RAW_INT_OP(op, op1, op2, iop) \ 101{ \ 102 mst_Boolean overflow; \ 103 OOP result = iop; \ 104 if(COMMON (!overflow)) { \ 105 op = result; \ 106 break; \ 107 } \ 108} 109 110#define RAW_FLOATD_OP(op, op1, op2, fop) \ 111{ \ 112 double farg1, farg2; \ 113 farg1 = IS_INT (op1) ? TO_INT (op1) : FLOATD_OOP_VALUE(op1); \ 114 farg2 = IS_INT (op2) ? TO_INT (op2) : FLOATD_OOP_VALUE(op2); \ 115 EXPORT_REGS(); \ 116 op = floatd_new(fop); \ 117 IMPORT_REGS(); \ 118 break; \ 119} 120 121#define INTERP_BASIC_OP(op, op1, op2, iop, fop) { \ 122 if COMMON (ARE_INTS(op1, op2)) { \ 123 RAW_INT_OP(op, op1, op2, iop); \ 124 } else if COMMON ((IS_INT (op1) || OOP_CLASS(op1) == _gst_floatd_class) \ 125 && (IS_INT (op2) || OOP_CLASS(op2) == _gst_floatd_class)) \ 126 RAW_FLOATD_OP(op, op1, op2, fop); \ 127} 128 129#define INTERP_BASIC_BOOL(op, op1, op2, operator) { \ 130 if COMMON (ARE_INTS(op1, op2)) { \ 131 POP_N_OOPS (2); \ 132 if (((intptr_t) op1) operator ((intptr_t) op2)) \ 133 DISPATCH(true_byte_codes); \ 134 else \ 135 DISPATCH(false_byte_codes); \ 136 } else if COMMON ((IS_INT (op1) || OOP_CLASS(op1) == _gst_floatd_class) \ 137 && (IS_INT (op2) || OOP_CLASS(op2) == _gst_floatd_class)) { \ 138 double farg1 = IS_INT (op1) ? TO_INT (op1) : FLOATD_OOP_VALUE(op1); \ 139 double farg2 = IS_INT (op2) ? TO_INT (op2) : FLOATD_OOP_VALUE(op2); \ 140 POP_N_OOPS (2); \ 141 if (farg1 operator farg2) \ 142 DISPATCH(true_byte_codes); \ 143 else \ 144 DISPATCH(false_byte_codes); \ 145 } \ 146} 147#endif 148 149/* FETCH loads the whole queue. 150 FETCH_VEC does the same, but uses the given vector to execute the next 151 bytecode. 152 DISPATCH keeps the current queue and dispatches the next bytecode to its 153 execution routine. 154 PREFETCH prepares to execute the next bytecode, including advancing ip. 155 PREFETCH_VEC does the same, but uses the given vector to execute the next 156 bytecode. 157 NEXT_BC assumes that the next bytecode was prefetched, loads its argument 158 and dispatches it to the current dispatch vector. 159 NEXT_BC_VEC assumes that the next bytecode was prefetched with PREFETCH_VEC, 160 loads its argument and dispatches it to the current dispatch vector. 161 NEXT_BC_NO_ARG does the same, and avoids loading the argument for the next 162 bytecode. 163 GET_ARG holds a pointer to the (possibly prefetched) argument of the next 164 bytecode. */ 165#ifdef PIPELINING 166#define FETCH goto *(t = dispatch_vec[*ip], b2 = ip[2], b4 = ip[4], \ 167 arg = ip[1], arg2 = ip[3], t2 = dispatch_vec[b2], t) 168#define FETCH_VEC(v) goto *(t = (v)[*ip], b2 = ip[2], b4 = ip[4], \ 169 arg = ip[1], arg2 = ip[3], t2 = dispatch_vec[b2], t) 170 171#define PREFETCH (t = t2, t2 = dispatch_vec[b4], \ 172 arg2 = ip[3], b2 = b4, b4 = ip[6], \ 173 ip += 2) 174#define PREFETCH_VEC(v) (t = (v)[b2], t2 = dispatch_vec[b4], \ 175 arg2 = ip[3], b2 = b4, b4 = ip[6], \ 176 ip += 2) 177 178#define NEXT_BC goto *(arg = GET_ARG, t) 179#define NEXT_BC_VEC(v) goto *(arg = GET_ARG, t) 180#define NEXT_BC_NO_ARG(v) goto *t 181#define GET_ARG arg2 182 183#elif REG_AVAILABILITY >= 1 184#define FETCH goto *(arg = GET_ARG, dispatch_vec[*ip]) 185#define FETCH_VEC(v) goto *(arg = GET_ARG, (v)[*ip]) 186#define PREFETCH (ip += 2, prefetch = dispatch_vec[*ip]) 187#define PREFETCH_VEC(v) (ip += 2, prefetch = (v)[*ip]) 188#define NEXT_BC goto *(arg = GET_ARG, prefetch) 189#define NEXT_BC_VEC(v) goto *(arg = GET_ARG, prefetch) 190#define NEXT_BC_NO_ARG(v) goto *prefetch 191#define GET_ARG (ip[1]) 192 193#else 194#define FETCH NEXT_BC 195#define FETCH_VEC(v) NEXT_BC_VEC(v) 196#define PREFETCH (ip += 2) 197#define PREFETCH_VEC(v) (ip += 2) 198#define NEXT_BC goto *(arg = GET_ARG, dispatch_vec[*ip]) 199#define NEXT_BC_VEC(v) goto *(arg = GET_ARG, (v)[*ip]) 200#define NEXT_BC_NO_ARG(v) goto *(v)[*ip] 201#define GET_ARG (ip[1]) 202#endif 203 204#define DISPATCH(v) goto *(arg = GET_ARG, (v)[*ip]) 205 206operation PREFETCH ( -- ) { 207 PREFETCH; 208 LOCAL_COUNTER++; 209} 210 211operation ADVANCE ( -- ) { 212 ip += 2; 213 LOCAL_COUNTER++; 214} 215 216/* EXT_BYTE extends the argument of the next bytecode; it includes a 217 separate prefetching routine which avoids interrupts (because the 218 two are effectively a single bytecode). */ 219operation EXT_BYTE ( -- ) { 220 PREFETCH_VEC (normal_byte_codes); 221 arg = (arg << 8) | GET_ARG; 222 NEXT_BC_NO_ARG (normal_byte_codes); 223} 224 225operation INVALID arg ( -- ) { 226 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 227} 228 229operation PLUS_SPECIAL ( op1 op2 -- op ) { 230 INTERP_BASIC_OP (op, op1, op2, 231 add_with_check (op1, op2, &overflow), 232 farg1 + farg2); 233 PREPARE_STACK (); 234 EXPORT_REGS (); 235 SEND_MESSAGE (_gst_builtin_selectors[PLUS_SPECIAL].symbol, 1); 236 IMPORT_REGS (); 237 FETCH; 238} 239 240operation MINUS_SPECIAL ( op1 op2 -- op ) { 241 INTERP_BASIC_OP (op, op1, op2, 242 sub_with_check (op1, op2, &overflow), 243 farg1 - farg2); 244 PREPARE_STACK (); 245 EXPORT_REGS (); 246 SEND_MESSAGE (_gst_builtin_selectors[MINUS_SPECIAL].symbol, 1); 247 IMPORT_REGS (); 248 FETCH; 249} 250 251operation LESS_THAN_SPECIAL ( op1 op2 -- op ) { 252 PREPARE_STACK (); 253 INTERP_BASIC_BOOL (op, op1, op2, <); 254 EXPORT_REGS (); 255 SEND_MESSAGE (_gst_builtin_selectors[LESS_THAN_SPECIAL].symbol, 1); 256 IMPORT_REGS (); 257 FETCH; 258} 259 260operation GREATER_THAN_SPECIAL ( op1 op2 -- op ) { 261 PREPARE_STACK (); 262 INTERP_BASIC_BOOL (op, op1, op2, >); 263 EXPORT_REGS (); 264 SEND_MESSAGE (_gst_builtin_selectors[GREATER_THAN_SPECIAL].symbol, 1); 265 IMPORT_REGS (); 266 FETCH; 267} 268 269operation LESS_EQUAL_SPECIAL ( op1 op2 -- op ) { 270 PREPARE_STACK (); 271 INTERP_BASIC_BOOL (op, op1, op2, <=); 272 EXPORT_REGS (); 273 SEND_MESSAGE (_gst_builtin_selectors[LESS_EQUAL_SPECIAL].symbol, 1); 274 IMPORT_REGS (); 275 FETCH; 276} 277 278operation GREATER_EQUAL_SPECIAL ( op1 op2 -- op ) { 279 PREPARE_STACK (); 280 INTERP_BASIC_BOOL (op, op1, op2, >=); 281 EXPORT_REGS (); 282 SEND_MESSAGE (_gst_builtin_selectors[GREATER_EQUAL_SPECIAL].symbol, 1); 283 IMPORT_REGS (); 284 FETCH; 285} 286 287operation EQUAL_SPECIAL ( op1 op2 -- op ) { 288 PREPARE_STACK (); 289 INTERP_BASIC_BOOL (op, op1, op2, ==); 290 EXPORT_REGS (); 291 SEND_MESSAGE (_gst_builtin_selectors[EQUAL_SPECIAL].symbol, 1); 292 IMPORT_REGS (); 293 FETCH; 294} 295 296operation NOT_EQUAL_SPECIAL ( op1 op2 -- op ) { 297 PREPARE_STACK (); 298 INTERP_BASIC_BOOL (op, op1, op2, !=); 299 EXPORT_REGS (); 300 SEND_MESSAGE (_gst_builtin_selectors[NOT_EQUAL_SPECIAL].symbol, 1); 301 IMPORT_REGS (); 302 FETCH; 303} 304 305operation TIMES_SPECIAL ( op1 op2 -- op ) { 306 INTERP_BASIC_OP (op, op1, op2, 307 mul_with_check (op1, op2, &overflow), 308 farg1 * farg2); 309 PREPARE_STACK (); 310 EXPORT_REGS (); 311 SEND_MESSAGE (_gst_builtin_selectors[TIMES_SPECIAL].symbol, 1); 312 IMPORT_REGS (); 313 FETCH; 314} 315 316operation DIVIDE_SPECIAL ( op1 op2 -- op ) { 317 if COMMON (!ARE_INTS (op1, op2) 318 && (IS_INT (op1) || OOP_CLASS(op1) == _gst_floatd_class) 319 && (IS_INT (op2) || OOP_CLASS(op2) == _gst_floatd_class)) 320 { 321 RAW_FLOATD_OP(op, op1, op2, farg1 / farg2); 322 } 323 324 PREPARE_STACK (); 325 EXPORT_REGS(); 326 if (COMMON (ARE_INTS (op1, op2))) 327 { 328 if (!VMpr_SmallInteger_divide (10, 1)) 329 { 330 IMPORT_REGS (); 331 NEXT_BC; 332 } 333 } 334 335 SEND_MESSAGE (_gst_builtin_selectors[DIVIDE_SPECIAL].symbol, 1); 336 IMPORT_REGS (); 337 FETCH; 338} 339 340operation REMAINDER_SPECIAL ( op1 op2 -- op ) { 341 PREPARE_STACK (); 342 EXPORT_REGS(); 343 if (IS_INT (op1) && IS_INT (op2) 344 && !VMpr_SmallInteger_modulo (11, 1)) 345 { 346 IMPORT_REGS (); 347 NEXT_BC; 348 } 349 350 SEND_MESSAGE (_gst_builtin_selectors[REMAINDER_SPECIAL].symbol, 1); 351 IMPORT_REGS (); 352 FETCH; 353} 354 355operation BIT_XOR_SPECIAL ( op1 op2 -- op ) { 356 if COMMON (ARE_INTS (op1, op2)) 357 { 358 op = tagged_xor (op1, op2); 359 break; 360 } 361 362 PREPARE_STACK (); 363 EXPORT_REGS (); 364 SEND_MESSAGE (_gst_builtin_selectors[BIT_XOR_SPECIAL].symbol, 1); 365 IMPORT_REGS (); 366 FETCH; 367} 368 369operation BIT_SHIFT_SPECIAL ( op1 op2 -- op ) { 370 if COMMON (IS_INT (op2) && IS_INT (op1)) 371 { 372 intptr_t iarg1, iarg2; 373 iarg1 = TO_INT (op1); 374 iarg2 = TO_INT (op2); 375 if (iarg2 < 0) 376 { 377 if COMMON (iarg2 >= -ST_INT_SIZE) 378 op = FROM_INT (iarg1 >> -iarg2); 379 else 380 op = FROM_INT (iarg1 >> ST_INT_SIZE); 381 382 break; 383 } 384 else if COMMON (iarg2 < ST_INT_SIZE) 385 { 386 intptr_t result = iarg1 << iarg2; 387 if COMMON ((result >> iarg2) == iarg1 && !INT_OVERFLOW(result)) 388 { 389 op = FROM_INT (result); 390 break; 391 } 392 } 393 } 394 395 PREPARE_STACK (); 396 EXPORT_REGS (); 397 SEND_MESSAGE (_gst_builtin_selectors[BIT_SHIFT_SPECIAL].symbol, 1); 398 IMPORT_REGS (); 399 FETCH; 400} 401 402operation INTEGER_DIVIDE_SPECIAL ( op1 op2 -- op1 op2 ) { 403 PREPARE_STACK (); 404 EXPORT_REGS(); 405 if (IS_INT (op1) && IS_INT (op2) 406 && !VMpr_SmallInteger_intDiv (12, 1)) 407 { 408 IMPORT_REGS (); 409 NEXT_BC; 410 } 411 412 SEND_MESSAGE (_gst_builtin_selectors[INTEGER_DIVIDE_SPECIAL].symbol, 1); 413 IMPORT_REGS (); 414 FETCH; 415} 416 417operation BIT_AND_SPECIAL ( op1 op2 -- op ) { 418 op = tagged_and (op1, op2); 419 if COMMON (IS_INT (op)) 420 break; 421 422 PREPARE_STACK (); 423 EXPORT_REGS (); 424 SEND_MESSAGE (_gst_builtin_selectors[BIT_AND_SPECIAL].symbol, 1); 425 IMPORT_REGS (); 426 FETCH; 427} 428 429operation BIT_OR_SPECIAL ( op1 op2 -- op ) { 430 if COMMON (ARE_INTS (op1, op2)) 431 { 432 op = tagged_or (op1, op2); 433 break; 434 } 435 436 PREPARE_STACK (); 437 EXPORT_REGS (); 438 SEND_MESSAGE (_gst_builtin_selectors[BIT_OR_SPECIAL].symbol, 1); 439 IMPORT_REGS (); 440 FETCH; 441} 442 443operation AT_SPECIAL ( rec idx -- val ) { 444 OOP classOOP; 445 PREPARE_STACK (); 446 EXPORT_REGS (); 447 if UNCOMMON (IS_INT (rec)) 448 { 449 SEND_MESSAGE (_gst_builtin_selectors[AT_SPECIAL].symbol, 1); 450 IMPORT_REGS (); 451 FETCH; 452 } 453 454 if COMMON (at_cache_class == (classOOP = OOP_CLASS (rec)) 455 && !cached_index_oop_primitive (rec, idx, at_cache_spec)) 456 { 457 IMPORT_REGS (); 458 NEXT_BC; 459 } 460 461 /* Not the same class that is in the cache, or the primitive failed -- 462 send the message, and modify the cache if the send is resolved to 463 a primitive. */ 464 last_primitive = 0; 465 SEND_MESSAGE (_gst_builtin_selectors[AT_SPECIAL].symbol, 1); 466 IMPORT_REGS (); 467 if (_gst_primitive_table[last_primitive].id == 60) 468 { 469 at_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 470 at_cache_class = classOOP; 471 NEXT_BC; 472 } 473 FETCH; 474} 475 476operation AT_PUT_SPECIAL ( rec idx val -- res ) { 477 OOP classOOP; 478 PREPARE_STACK (); 479 EXPORT_REGS (); 480 if UNCOMMON (IS_INT (rec)) 481 { 482 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 483 IMPORT_REGS (); 484 FETCH; 485 } 486 487 if COMMON (at_put_cache_class == (classOOP = OOP_CLASS (rec)) 488 && !cached_index_oop_put_primitive (rec, idx, val, at_put_cache_spec)) 489 { 490 IMPORT_REGS (); 491 NEXT_BC; 492 } 493 494 /* Not the same class that is in the cache, or the primitive failed -- 495 send the message, and modify the cache if the send is resolved to 496 a primitive. */ 497 last_primitive = 0; 498 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 499 IMPORT_REGS (); 500 if (_gst_primitive_table[last_primitive].id == 61) 501 { 502 at_put_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 503 at_put_cache_class = classOOP; 504 NEXT_BC; 505 } 506 FETCH; 507} 508 509operation SIZE_SPECIAL ( rec -- val ) { 510 OOP classOOP; 511 PREPARE_STACK (); 512 EXPORT_REGS (); 513 if UNCOMMON (IS_INT (rec)) 514 { 515 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 516 IMPORT_REGS (); 517 FETCH; 518 } 519 520 if COMMON (size_cache_class == (classOOP = OOP_CLASS (rec)) 521 && !execute_primitive_operation (size_cache_prim, 0)) 522 { 523 IMPORT_REGS (); 524 NEXT_BC; 525 } 526 527 /* Not the same class that is in the cache, or the primitive failed -- 528 send the message, and modify the cache if the send is resolved to 529 a primitive. */ 530 last_primitive = 0; 531 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 532 IMPORT_REGS (); 533 if COMMON (last_primitive) 534 { 535 size_cache_prim = last_primitive; 536 size_cache_class = classOOP; 537 NEXT_BC; 538 } 539 FETCH; 540} 541 542operation CLASS_SPECIAL ( rec -- val ) { 543 OOP classOOP; 544 PREPARE_STACK (); 545 EXPORT_REGS (); 546 if UNCOMMON (IS_INT (rec)) 547 { 548 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 549 IMPORT_REGS (); 550 FETCH; 551 } 552 553 if COMMON (class_cache_class == (classOOP = OOP_CLASS (rec)) 554 && !execute_primitive_operation (class_cache_prim, 1)) 555 { 556 IMPORT_REGS (); 557 NEXT_BC; 558 } 559 560 /* Not the same class that is in the cache, or the primitive failed -- 561 send the message, and modify the cache if the send is resolved to 562 a primitive. */ 563 last_primitive = 0; 564 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 565 IMPORT_REGS (); 566 if COMMON (last_primitive) 567 { 568 class_cache_prim = last_primitive; 569 class_cache_class = classOOP; 570 NEXT_BC; 571 } 572 FETCH; 573} 574 575operation IS_NIL_SPECIAL ( rec -- val ) { 576 /* DO_JUMP_LOOKAHEAD (rec == _gst_nil_oop); */ 577 val = rec == _gst_nil_oop ? _gst_true_oop : _gst_false_oop; 578} 579 580operation NOT_NIL_SPECIAL ( rec -- val ) { 581 /* DO_JUMP_LOOKAHEAD (rec != _gst_nil_oop); */ 582 val = rec != _gst_nil_oop ? _gst_true_oop : _gst_false_oop; 583} 584 585operation VALUE_SPECIAL ( rec -- rec ) { 586 PREPARE_STACK (); 587 EXPORT_REGS (); 588 if (UNCOMMON (IS_INT (rec)) 589 || UNCOMMON (OOP_CLASS (rec) != _gst_block_closure_class) 590 || UNCOMMON (send_block_value (0, 0))) 591 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 592 593 IMPORT_REGS (); 594 FETCH; 595} 596 597operation VALUE_COLON_SPECIAL ( rec blk_arg -- rec blk_arg ) { 598 PREPARE_STACK (); 599 EXPORT_REGS (); 600 if (UNCOMMON (IS_INT (rec)) 601 || UNCOMMON (OOP_CLASS (rec) != _gst_block_closure_class) 602 || UNCOMMON (send_block_value (1, 0))) 603 SEND_MESSAGE (_gst_builtin_selectors[VALUE_COLON_SPECIAL].symbol, 1); 604 605 IMPORT_REGS (); 606 FETCH; 607} 608 609operation SAME_OBJECT_SPECIAL ( op1 op2 -- op ) { 610 /* DO_JUMP_LOOKAHEAD (op1 == op2); */ 611 op = (op1 == op2) ? _gst_true_oop : _gst_false_oop; 612} 613 614operation JAVA_AS_INT_SPECIAL ( rec -- val ) { 615 if COMMON (IS_INT (rec) || is_c_int_32 (rec)) 616 { 617 val = rec; 618 break; 619 } 620 621 PREPARE_STACK (); 622 EXPORT_REGS (); 623 SEND_MESSAGE (_gst_builtin_selectors[JAVA_AS_INT_SPECIAL].symbol, 0); 624 IMPORT_REGS (); 625 FETCH; 626} 627 628operation JAVA_AS_LONG_SPECIAL ( rec -- val ) { 629 if COMMON (IS_INT (rec) || is_c_int_64 (rec)) 630 { 631 val = rec; 632 break; 633 } 634 635 PREPARE_STACK (); 636 EXPORT_REGS (); 637 SEND_MESSAGE (_gst_builtin_selectors[JAVA_AS_LONG_SPECIAL].symbol, 0); 638 IMPORT_REGS (); 639 FETCH; 640} 641 642operation SEND sel n ( -- ) { 643 PREPARE_STACK (); 644 EXPORT_REGS (); 645 SEND_MESSAGE (METHOD_LITERAL (sel), n); 646 IMPORT_REGS (); 647 FETCH; 648} 649 650operation SEND_SUPER sel n ( -- ) { 651 OOP classOOP; 652 PREPARE_STACK (); 653 classOOP = POP_OOP (); 654 655 EXPORT_REGS (); 656 SEND_TO_SUPER (METHOD_LITERAL (sel), n, classOOP); 657 IMPORT_REGS (); 658 FETCH; 659} 660 661operation SEND_IMMEDIATE n ( -- ) { 662 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 663 PREPARE_STACK (); 664 EXPORT_REGS (); 665 SEND_MESSAGE (bs->symbol, bs->numArgs); 666 IMPORT_REGS (); 667 FETCH; 668} 669 670operation SEND_SUPER_IMMEDIATE n ( -- ) { 671 OOP classOOP; 672 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 673 PREPARE_STACK (); 674 classOOP = POP_OOP (); 675 676 EXPORT_REGS (); 677 SEND_TO_SUPER (bs->symbol, bs->numArgs, classOOP); 678 IMPORT_REGS (); 679 FETCH; 680} 681 682operation PUSH_TEMPORARY_VARIABLE n ( -- tos ) { 683 tos = METHOD_TEMPORARY (n); 684} 685 686operation PUSH_OUTER_TEMP n scopes ( -- tos ) { 687 OOP contextOOP; 688 gst_block_context context; 689 690 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 691 do 692 { 693 contextOOP = context->outerContext; 694 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 695 } 696 while (--scopes); 697 698 tos = context->contextStack[n]; 699} 700 701operation PUSH_LIT_VARIABLE n ( -- tos ) { 702 tos = METHOD_LITERAL (n); 703 if (UNCOMMON (IS_INT (tos)) 704 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 705 { 706 PREPARE_STACK (); 707 PUSH_OOP (tos); 708 EXPORT_REGS (); 709 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 710 IMPORT_REGS (); 711 FETCH; 712 } 713 else 714 tos = ASSOCIATION_VALUE (tos); 715} 716 717operation PUSH_RECEIVER_VARIABLE n ( -- tos ) { 718 tos = RECEIVER_VARIABLE (n); 719} 720 721operation STORE_TEMPORARY_VARIABLE n ( tos -- tos ) { 722 STORE_METHOD_TEMPORARY (n, tos); 723} 724 725operation STORE_OUTER_TEMP n scopes ( tos -- tos ) { 726 OOP contextOOP; 727 gst_block_context context; 728 729 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 730 do 731 { 732 contextOOP = context->outerContext; 733 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 734 } 735 while (--scopes); 736 737 context->contextStack[n] = tos; 738} 739 740operation STORE_LIT_VARIABLE n ( tos -- tos ) { 741 OOP var = METHOD_LITERAL (n), value = tos; 742 if (UNCOMMON (IS_INT (var)) 743 || UNCOMMON (!is_a_kind_of (OOP_CLASS (var), _gst_association_class))) 744 { 745 PREPARE_STACK (); 746 SET_STACKTOP (var); 747 PUSH_OOP (value); 748 EXPORT_REGS (); 749 SEND_MESSAGE (_gst_builtin_selectors[VALUE_COLON_SPECIAL].symbol, 1); 750 IMPORT_REGS (); 751 FETCH; 752 } 753 else 754 SET_ASSOCIATION_VALUE (var, value); 755} 756 757operation STORE_RECEIVER_VARIABLE n ( tos -- tos ) { 758 STORE_RECEIVER_VARIABLE (n, tos); 759} 760 761operation JUMP_BACK n ( -- ) { 762 PREPARE_STACK (); 763 ip -= n; 764 FETCH; 765} 766 767operation JUMP n ( -- ) { 768 PREPARE_STACK (); 769 ip += n; 770 FETCH; 771} 772 773operation POP_JUMP_FALSE n ( tos -- ) { 774 if UNCOMMON (tos == _gst_false_oop) 775 { 776 PREPARE_STACK (); 777 POP_N_OOPS(1); 778 ip += n; 779 FETCH; 780 } 781 else if UNCOMMON (tos != _gst_true_oop) 782 { 783 ip += n; 784 PREPARE_STACK (); 785 EXPORT_REGS(); 786 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 787 IMPORT_REGS(); 788 FETCH; 789 } 790} 791 792operation POP_JUMP_TRUE n ( tos -- ) { 793 if UNCOMMON (tos == _gst_true_oop) 794 { 795 PREPARE_STACK (); 796 POP_N_OOPS(1); 797 ip += n; 798 FETCH; 799 } 800 else if UNCOMMON (tos != _gst_false_oop) 801 { 802 ip += n; 803 PREPARE_STACK (); 804 EXPORT_REGS(); 805 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 806 IMPORT_REGS(); 807 FETCH; 808 } 809} 810 811operation PUSH_INTEGER n ( -- tos ) { 812 tos = FROM_INT (n); 813} 814 815operation PUSH_SPECIAL n ( -- tos ) { 816 tos = _gst_nil_oop + (n - NIL_INDEX); 817} 818 819operation PUSH_LIT_CONSTANT n ( -- tos ) { 820 tos = METHOD_LITERAL (n); 821} 822 823operation POP_INTO_NEW_STACKTOP n ( obj val -- obj ) { 824 STORE_INSTANCE_VARIABLE (obj, n, val); 825} 826 827operation POP_STACK_TOP ( tos -- ) { 828} 829 830operation MAKE_DIRTY_BLOCK ( block -- closure ) { 831 EXPORT_REGS (); 832 closure = _gst_make_block_closure (block); 833 IMPORT_REGS(); 834} 835 836operation RETURN_METHOD_STACK_TOP ( val -- val ) { 837 EXPORT_REGS (); 838 if UNCOMMON (!unwind_method ()) 839 { 840 SEND_MESSAGE (_gst_bad_return_error_symbol, 0); 841 IMPORT_REGS (); 842 } 843 else 844 { 845 IMPORT_REGS (); 846 SET_STACKTOP (val); 847 } 848 FETCH; 849} 850 851operation RETURN_CONTEXT_STACK_TOP ( val -- val ) { 852 EXPORT_REGS (); 853 unwind_context (); 854 IMPORT_REGS (); 855 SET_STACKTOP (val); 856 FETCH; 857} 858 859operation DUP_STACK_TOP ( tos -- tos tos2 ) { 860 tos2 = tos; 861} 862 863operation EXIT_INTERPRETER ( val -- val ) { 864 /* This fixes a very rare condition, but it can happen: GC can 865 happen because send_message_internal allocates a context 866 while the interpreter is checking last_primitive to fill 867 the special cache for #at:, #at:put: and #size. If there 868 are finalizable objects, the finalization callins might 869 change last_primitive to a bogus value. To fix the 870 problem, we invalidate last_primitive every time the 871 interpreter exits. */ 872 last_primitive = 0; 873 874 { 875 OOP activeProcessOOP = get_scheduled_process (); 876 gst_callin_process process = (gst_callin_process) OOP_TO_OBJ (activeProcessOOP); 877 if (IS_NIL (activeProcessOOP)) 878 abort (); 879 880 if (process->objClass == _gst_callin_process_class) 881 process->returnedValue = val; 882 _gst_terminate_process (activeProcessOOP); 883 if (processOOP == activeProcessOOP) 884 SET_EXCEPT_FLAG (true); 885 } 886 FETCH; 887} 888 889operation LINE_NUMBER_BYTECODE ( -- ) { 890} 891 892operation PUSH_SELF ( -- tos ) { 893 tos = _gst_self; 894} 895 896table monitored_byte_codes { 897 0..255 = monitor_byte_codes 898} 899 900/* for jump lookahead */ 901table true_byte_codes { 902 0..41 = lookahead_failed_true, 903 42 = bc41, /* pop/jump if true ==> jump */ 904 43 = bc54, /* pop/jump if false ==> nop */ 905 44..51 = lookahead_failed_true, 906 52 = lookahead_dup_true, 907 53..255 = lookahead_failed_true 908} 909 910table false_byte_codes { 911 0..41 = lookahead_failed_false, 912 42 = bc54, /* pop/jump if true ==> nop */ 913 43 = bc41, /* pop/jump if false ==> jump */ 914 44..51 = lookahead_failed_false, 915 52 = lookahead_dup_false, 916 53..255 = lookahead_failed_false 917} 918 919/* Automatically generated by superops. Do not modify past this line! */ 920table normal_byte_codes { 921 0 = bytecode bc0 { 922 PREFETCH (); 923 PLUS_SPECIAL (); 924 } 925 926 1 = bytecode bc1 { 927 PREFETCH (); 928 MINUS_SPECIAL (); 929 } 930 931 2 = bytecode bc2 { 932 PREFETCH (); 933 LESS_THAN_SPECIAL (); 934 } 935 936 3 = bytecode bc3 { 937 PREFETCH (); 938 GREATER_THAN_SPECIAL (); 939 } 940 941 4 = bytecode bc4 { 942 PREFETCH (); 943 LESS_EQUAL_SPECIAL (); 944 } 945 946 5 = bytecode bc5 { 947 PREFETCH (); 948 GREATER_EQUAL_SPECIAL (); 949 } 950 951 6 = bytecode bc6 { 952 PREFETCH (); 953 EQUAL_SPECIAL (); 954 } 955 956 7 = bytecode bc7 { 957 PREFETCH (); 958 NOT_EQUAL_SPECIAL (); 959 } 960 961 8 = bytecode bc8 { 962 PREFETCH (); 963 TIMES_SPECIAL (); 964 } 965 966 9 = bytecode bc9 { 967 PREFETCH (); 968 DIVIDE_SPECIAL (); 969 } 970 971 10 = bytecode bc10 { 972 PREFETCH (); 973 REMAINDER_SPECIAL (); 974 } 975 976 11 = bytecode bc11 { 977 PREFETCH (); 978 BIT_XOR_SPECIAL (); 979 } 980 981 12 = bytecode bc12 { 982 PREFETCH (); 983 BIT_SHIFT_SPECIAL (); 984 } 985 986 13 = bytecode bc13 { 987 PREFETCH (); 988 INTEGER_DIVIDE_SPECIAL (); 989 } 990 991 14 = bytecode bc14 { 992 PREFETCH (); 993 BIT_AND_SPECIAL (); 994 } 995 996 15 = bytecode bc15 { 997 PREFETCH (); 998 BIT_OR_SPECIAL (); 999 } 1000 1001 16 = bytecode bc16 { 1002 PREFETCH (); 1003 AT_SPECIAL (); 1004 } 1005 1006 17 = bytecode bc17 { 1007 PREFETCH (); 1008 AT_PUT_SPECIAL (); 1009 } 1010 1011 18 = bytecode bc18 { 1012 PREFETCH (); 1013 SIZE_SPECIAL (); 1014 } 1015 1016 19 = bytecode bc19 { 1017 PREFETCH (); 1018 CLASS_SPECIAL (); 1019 } 1020 1021 20 = bytecode bc20 { 1022 PREFETCH (); 1023 IS_NIL_SPECIAL (); 1024 } 1025 1026 21 = bytecode bc21 { 1027 PREFETCH (); 1028 NOT_NIL_SPECIAL (); 1029 } 1030 1031 22 = bytecode bc22 { 1032 PREFETCH (); 1033 VALUE_SPECIAL (); 1034 } 1035 1036 23 = bytecode bc23 { 1037 PREFETCH (); 1038 VALUE_COLON_SPECIAL (); 1039 } 1040 1041 24 = bytecode bc24 { 1042 PREFETCH (); 1043 SAME_OBJECT_SPECIAL (); 1044 } 1045 1046 25 = bytecode bc25 { 1047 PREFETCH (); 1048 JAVA_AS_INT_SPECIAL (); 1049 } 1050 1051 26 = bytecode bc26 { 1052 PREFETCH (); 1053 JAVA_AS_LONG_SPECIAL (); 1054 } 1055 1056 27 = bytecode bc27 { 1057 PREFETCH (); 1058 INVALID (arg); 1059 } 1060 1061 28 = bytecode bc28 { 1062 PREFETCH (); 1063 SEND (arg >> 8, arg & 255); 1064 } 1065 1066 29 = bytecode bc29 { 1067 PREFETCH (); 1068 SEND_SUPER (arg >> 8, arg & 255); 1069 } 1070 1071 30 = bytecode bc30 { 1072 PREFETCH (); 1073 SEND_IMMEDIATE (arg); 1074 } 1075 1076 31 = bytecode bc31 { 1077 PREFETCH (); 1078 SEND_SUPER_IMMEDIATE (arg); 1079 } 1080 1081 32 = bytecode bc32 { 1082 PREFETCH (); 1083 PUSH_TEMPORARY_VARIABLE (arg); 1084 } 1085 1086 33 = bytecode bc33 { 1087 PREFETCH (); 1088 PUSH_OUTER_TEMP (arg >> 8, arg & 255); 1089 } 1090 1091 34 = bytecode bc34 { 1092 PREFETCH (); 1093 PUSH_LIT_VARIABLE (arg); 1094 } 1095 1096 35 = bytecode bc35 { 1097 PREFETCH (); 1098 PUSH_RECEIVER_VARIABLE (arg); 1099 } 1100 1101 36 = bytecode bc36 { 1102 PREFETCH (); 1103 STORE_TEMPORARY_VARIABLE (arg); 1104 } 1105 1106 37 = bytecode bc37 { 1107 PREFETCH (); 1108 STORE_OUTER_TEMP (arg >> 8, arg & 255); 1109 } 1110 1111 38 = bytecode bc38 { 1112 PREFETCH (); 1113 STORE_LIT_VARIABLE (arg); 1114 } 1115 1116 39 = bytecode bc39 { 1117 PREFETCH (); 1118 STORE_RECEIVER_VARIABLE (arg); 1119 } 1120 1121 40 = bytecode bc40 { 1122 ADVANCE (); 1123 JUMP_BACK (arg); 1124 } 1125 1126 41 = bytecode bc41 { 1127 ADVANCE (); 1128 JUMP (arg); 1129 } 1130 1131 42 = bytecode bc42 { 1132 PREFETCH (); 1133 POP_JUMP_TRUE (arg); 1134 } 1135 1136 43 = bytecode bc43 { 1137 PREFETCH (); 1138 POP_JUMP_FALSE (arg); 1139 } 1140 1141 44 = bytecode bc44 { 1142 PREFETCH (); 1143 PUSH_INTEGER (arg); 1144 } 1145 1146 45 = bytecode bc45 { 1147 PREFETCH (); 1148 PUSH_SPECIAL (arg); 1149 } 1150 1151 46 = bytecode bc46 { 1152 PREFETCH (); 1153 PUSH_LIT_CONSTANT (arg); 1154 } 1155 1156 47 = bytecode bc47 { 1157 PREFETCH (); 1158 POP_INTO_NEW_STACKTOP (arg); 1159 } 1160 1161 48 = bytecode bc48 { 1162 PREFETCH (); 1163 POP_STACK_TOP (); 1164 } 1165 1166 49 = bytecode bc49 { 1167 PREFETCH (); 1168 MAKE_DIRTY_BLOCK (); 1169 } 1170 1171 50 = bytecode bc50 { 1172 PREFETCH (); 1173 RETURN_METHOD_STACK_TOP (); 1174 } 1175 1176 51 = bytecode bc51 { 1177 PREFETCH (); 1178 RETURN_CONTEXT_STACK_TOP (); 1179 } 1180 1181 52 = bytecode bc52 { 1182 PREFETCH (); 1183 DUP_STACK_TOP (); 1184 } 1185 1186 53 = bytecode bc53 { 1187 PREFETCH (); 1188 EXIT_INTERPRETER (); 1189 } 1190 1191 54 = bytecode bc54 { 1192 PREFETCH (); 1193 LINE_NUMBER_BYTECODE (); 1194 } 1195 1196 55 = bytecode bc55 { 1197 EXT_BYTE (); 1198 } 1199 1200 56 = bytecode bc56 { 1201 PREFETCH (); 1202 PUSH_SELF (); 1203 } 1204 1205 57 = bytecode bc57 { 1206 PREFETCH (); 1207 INVALID (arg); 1208 } 1209 1210 58 = bytecode bc58 { 1211 PREFETCH (); 1212 INVALID (arg); 1213 } 1214 1215 59 = bytecode bc59 { 1216 PREFETCH (); 1217 INVALID (arg); 1218 } 1219 1220 60 = bytecode bc60 { 1221 PREFETCH (); 1222 INVALID (arg); 1223 } 1224 1225 61 = bytecode bc61 { 1226 PREFETCH (); 1227 INVALID (arg); 1228 } 1229 1230 62 = bytecode bc62 { 1231 PREFETCH (); 1232 INVALID (arg); 1233 } 1234 1235 63 = bytecode bc63 { 1236 PREFETCH (); 1237 INVALID (arg); 1238 } 1239 1240 64 = bytecode bc64 { 1241 PREFETCH (); 1242 SEND (arg, 1); 1243 } 1244 1245 65 = bytecode bc65 { 1246 PREFETCH (); 1247 SEND (arg, 0); 1248 } 1249 1250 66 = bytecode bc66 { 1251 PREFETCH (); 1252 PUSH_SELF (); 1253 RETURN_CONTEXT_STACK_TOP (); 1254 } 1255 1256 67 = bytecode bc67 { 1257 PREFETCH (); 1258 LINE_NUMBER_BYTECODE (); 1259 PUSH_SELF (); 1260 } 1261 1262 68 = bytecode bc68 { 1263 PREFETCH (); 1264 LINE_NUMBER_BYTECODE (); 1265 POP_STACK_TOP (); 1266 } 1267 1268 69 = bytecode bc69 { 1269 PREFETCH (); 1270 LINE_NUMBER_BYTECODE (); 1271 PUSH_TEMPORARY_VARIABLE (0); 1272 } 1273 1274 70 = bytecode bc70 { 1275 PREFETCH (); 1276 PUSH_LIT_CONSTANT (arg); 1277 MAKE_DIRTY_BLOCK (); 1278 } 1279 1280 71 = bytecode bc71 { 1281 PREFETCH (); 1282 SEND (arg, 2); 1283 } 1284 1285 72 = bytecode bc72 { 1286 PREFETCH (); 1287 POP_STACK_TOP (); 1288 DUP_STACK_TOP (); 1289 } 1290 1291 73 = bytecode bc73 { 1292 PREFETCH (); 1293 PUSH_TEMPORARY_VARIABLE (0); 1294 SEND_IMMEDIATE (arg); 1295 } 1296 1297 74 = bytecode bc74 { 1298 PREFETCH (); 1299 PUSH_SELF (); 1300 SEND (arg, 0); 1301 } 1302 1303 75 = bytecode bc75 { 1304 PREFETCH (); 1305 PUSH_SPECIAL (arg); 1306 RETURN_CONTEXT_STACK_TOP (); 1307 } 1308 1309 76 = bytecode bc76 { 1310 PREFETCH (); 1311 PUSH_SELF (); 1312 SEND_IMMEDIATE (arg); 1313 } 1314 1315 77 = bytecode bc77 { 1316 PREFETCH (); 1317 PUSH_OUTER_TEMP (arg, 1); 1318 } 1319 1320 78 = bytecode bc78 { 1321 PREFETCH (); 1322 STORE_TEMPORARY_VARIABLE (arg); 1323 POP_STACK_TOP (); 1324 } 1325 1326 79 = bytecode bc79 { 1327 PREFETCH (); 1328 PUSH_SELF (); 1329 PUSH_TEMPORARY_VARIABLE (arg); 1330 } 1331 1332 80 = bytecode bc80 { 1333 PREFETCH (); 1334 STORE_RECEIVER_VARIABLE (arg); 1335 PUSH_SELF (); 1336 RETURN_CONTEXT_STACK_TOP (); 1337 } 1338 1339 81 = bytecode bc81 { 1340 PREFETCH (); 1341 PUSH_INTEGER (arg); 1342 PLUS_SPECIAL (); 1343 } 1344 1345 82 = bytecode bc82 { 1346 PREFETCH (); 1347 LINE_NUMBER_BYTECODE (); 1348 PUSH_LIT_VARIABLE (0); 1349 } 1350 1351 83 = bytecode bc83 { 1352 PREFETCH (); 1353 PUSH_TEMPORARY_VARIABLE (0); 1354 PUSH_TEMPORARY_VARIABLE (arg); 1355 } 1356 1357 84 = bytecode bc84 { 1358 PREFETCH (); 1359 PUSH_TEMPORARY_VARIABLE (0); 1360 SEND (arg >> 8, arg & 255); 1361 } 1362 1363 85 = bytecode bc85 { 1364 PREFETCH (); 1365 LINE_NUMBER_BYTECODE (); 1366 PUSH_TEMPORARY_VARIABLE (1); 1367 } 1368 1369 86 = bytecode bc86 { 1370 PREFETCH (); 1371 IS_NIL_SPECIAL (); 1372 POP_JUMP_FALSE (arg); 1373 } 1374 1375 87 = bytecode bc87 { 1376 PREFETCH (); 1377 PUSH_INTEGER (arg); 1378 EQUAL_SPECIAL (); 1379 } 1380 1381 88 = bytecode bc88 { 1382 PREFETCH (); 1383 SEND (arg, 3); 1384 } 1385 1386 89 = bytecode bc89 { 1387 PREFETCH (); 1388 PUSH_TEMPORARY_VARIABLE (0); 1389 SEND (arg, 1); 1390 } 1391 1392 90 = bytecode bc90 { 1393 PREFETCH (); 1394 LINE_NUMBER_BYTECODE (); 1395 PUSH_SELF (); 1396 SEND (0, 0); 1397 } 1398 1399 91 = bytecode bc91 { 1400 PREFETCH (); 1401 PUSH_TEMPORARY_VARIABLE (arg); 1402 RETURN_CONTEXT_STACK_TOP (); 1403 } 1404 1405 92 = bytecode bc92 { 1406 PREFETCH (); 1407 PUSH_LIT_CONSTANT (arg); 1408 SEND_IMMEDIATE (36); 1409 } 1410 1411 93 = bytecode bc93 { 1412 PREFETCH (); 1413 SAME_OBJECT_SPECIAL (); 1414 POP_JUMP_FALSE (arg); 1415 } 1416 1417 94 = bytecode bc94 { 1418 PREFETCH (); 1419 PUSH_LIT_CONSTANT (arg); 1420 SEND (1, 1); 1421 } 1422 1423 95 = bytecode bc95 { 1424 PREFETCH (); 1425 LINE_NUMBER_BYTECODE (); 1426 POP_STACK_TOP (); 1427 PUSH_SELF (); 1428 } 1429 1430 96 = bytecode bc96 { 1431 PREFETCH (); 1432 POP_STACK_TOP (); 1433 DUP_STACK_TOP (); 1434 LINE_NUMBER_BYTECODE (); 1435 } 1436 1437 97 = bytecode bc97 { 1438 PREFETCH (); 1439 PUSH_TEMPORARY_VARIABLE (0); 1440 SEND (arg, 0); 1441 } 1442 1443 98 = bytecode bc98 { 1444 PREFETCH (); 1445 PUSH_TEMPORARY_VARIABLE (1); 1446 SEND_IMMEDIATE (arg); 1447 } 1448 1449 99 = bytecode bc99 { 1450 PREFETCH (); 1451 PUSH_LIT_CONSTANT (arg); 1452 EQUAL_SPECIAL (); 1453 } 1454 1455 100 = bytecode bc100 { 1456 PREFETCH (); 1457 PUSH_INTEGER (arg); 1458 MINUS_SPECIAL (); 1459 } 1460 1461 101 = bytecode bc101 { 1462 PREFETCH (); 1463 DUP_STACK_TOP (); 1464 POP_JUMP_FALSE (arg); 1465 } 1466 1467 102 = bytecode bc102 { 1468 PREFETCH (); 1469 POP_STACK_TOP (); 1470 LINE_NUMBER_BYTECODE (); 1471 } 1472 1473 103 = bytecode bc103 { 1474 PREFETCH (); 1475 PUSH_INTEGER (arg); 1476 SEND_IMMEDIATE (32); 1477 } 1478 1479 104 = bytecode bc104 { 1480 PREFETCH (); 1481 PUSH_TEMPORARY_VARIABLE (arg); 1482 SIZE_SPECIAL (); 1483 } 1484 1485 105 = bytecode bc105 { 1486 PREFETCH (); 1487 PUSH_SELF (); 1488 SEND (arg >> 8, arg & 255); 1489 } 1490 1491 106 = bytecode bc106 { 1492 PREFETCH (); 1493 LINE_NUMBER_BYTECODE (); 1494 PUSH_TEMPORARY_VARIABLE (2); 1495 } 1496 1497 107 = bytecode bc107 { 1498 PREFETCH (); 1499 POP_STACK_TOP (); 1500 SEND_IMMEDIATE (arg); 1501 } 1502 1503 108 = bytecode bc108 { 1504 PREFETCH (); 1505 PUSH_TEMPORARY_VARIABLE (arg); 1506 PUSH_INTEGER (1); 1507 PLUS_SPECIAL (); 1508 } 1509 1510 109 = bytecode bc109 { 1511 PREFETCH (); 1512 LINE_NUMBER_BYTECODE (); 1513 PUSH_RECEIVER_VARIABLE (0); 1514 } 1515 1516 110 = bytecode bc110 { 1517 PREFETCH (); 1518 PUSH_LIT_CONSTANT (arg); 1519 SEND_IMMEDIATE (38); 1520 } 1521 1522 111 = bytecode bc111 { 1523 PREFETCH (); 1524 PUSH_INTEGER (arg); 1525 AT_SPECIAL (); 1526 } 1527 1528 112 = bytecode bc112 { 1529 PREFETCH (); 1530 LINE_NUMBER_BYTECODE (); 1531 PUSH_RECEIVER_VARIABLE (1); 1532 } 1533 1534 113 = bytecode bc113 { 1535 PREFETCH (); 1536 PUSH_TEMPORARY_VARIABLE (0); 1537 PUSH_LIT_CONSTANT (arg); 1538 } 1539 1540 114 = bytecode bc114 { 1541 PREFETCH (); 1542 DUP_STACK_TOP (); 1543 POP_JUMP_TRUE (arg); 1544 } 1545 1546 115 = bytecode bc115 { 1547 PREFETCH (); 1548 PUSH_TEMPORARY_VARIABLE (arg); 1549 AT_SPECIAL (); 1550 } 1551 1552 116 = bytecode bc116 { 1553 PREFETCH (); 1554 PUSH_TEMPORARY_VARIABLE (2); 1555 SEND_IMMEDIATE (arg); 1556 } 1557 1558 117 = bytecode bc117 { 1559 PREFETCH (); 1560 PUSH_LIT_CONSTANT (arg); 1561 SEND_IMMEDIATE (49); 1562 } 1563 1564 118 = bytecode bc118 { 1565 PREFETCH (); 1566 STORE_TEMPORARY_VARIABLE (1); 1567 LINE_NUMBER_BYTECODE (); 1568 POP_STACK_TOP (); 1569 } 1570 1571 119 = bytecode bc119 { 1572 PREFETCH (); 1573 PUSH_TEMPORARY_VARIABLE (1); 1574 SEND (arg, 1); 1575 } 1576 1577 120 = bytecode bc120 { 1578 PREFETCH (); 1579 STORE_RECEIVER_VARIABLE (arg); 1580 POP_STACK_TOP (); 1581 } 1582 1583 121 = bytecode bc121 { 1584 PREFETCH (); 1585 STORE_OUTER_TEMP (arg, 1); 1586 } 1587 1588 122 = bytecode bc122 { 1589 PREFETCH (); 1590 PUSH_INTEGER (arg); 1591 SEND_IMMEDIATE (96); 1592 } 1593 1594 123 = bytecode bc123 { 1595 PREFETCH (); 1596 POP_STACK_TOP (); 1597 PUSH_TEMPORARY_VARIABLE (arg); 1598 } 1599 1600 124 = bytecode bc124 { 1601 PREFETCH (); 1602 PUSH_RECEIVER_VARIABLE (arg); 1603 RETURN_CONTEXT_STACK_TOP (); 1604 } 1605 1606 125 = bytecode bc125 { 1607 PREFETCH (); 1608 LINE_NUMBER_BYTECODE (); 1609 POP_STACK_TOP (); 1610 PUSH_TEMPORARY_VARIABLE (1); 1611 } 1612 1613 126 = bytecode bc126 { 1614 PREFETCH (); 1615 LINE_NUMBER_BYTECODE (); 1616 POP_STACK_TOP (); 1617 PUSH_TEMPORARY_VARIABLE (0); 1618 } 1619 1620 127 = bytecode bc127 { 1621 PREFETCH (); 1622 LINE_NUMBER_BYTECODE (); 1623 PUSH_SELF (); 1624 PUSH_LIT_CONSTANT (0); 1625 } 1626 1627 128 = bytecode bc128 { 1628 PREFETCH (); 1629 PUSH_LIT_CONSTANT (arg); 1630 RETURN_CONTEXT_STACK_TOP (); 1631 } 1632 1633 129 = bytecode bc129 { 1634 PREFETCH (); 1635 PUSH_SELF (); 1636 SIZE_SPECIAL (); 1637 } 1638 1639 130 = bytecode bc130 { 1640 PREFETCH (); 1641 IS_NIL_SPECIAL (); 1642 POP_JUMP_TRUE (arg); 1643 } 1644 1645 131 = bytecode bc131 { 1646 PREFETCH (); 1647 PUSH_TEMPORARY_VARIABLE (arg); 1648 AT_PUT_SPECIAL (); 1649 } 1650 1651 132 = bytecode bc132 { 1652 PREFETCH (); 1653 LINE_NUMBER_BYTECODE (); 1654 PUSH_LIT_VARIABLE (1); 1655 } 1656 1657 133 = bytecode bc133 { 1658 PREFETCH (); 1659 PUSH_TEMPORARY_VARIABLE (arg); 1660 PLUS_SPECIAL (); 1661 } 1662 1663 134 = bytecode bc134 { 1664 ADVANCE (); 1665 POP_STACK_TOP (); 1666 JUMP_BACK (arg); 1667 } 1668 1669 135 = bytecode bc135 { 1670 PREFETCH (); 1671 POP_STACK_TOP (); 1672 PUSH_LIT_VARIABLE (arg); 1673 } 1674 1675 136 = bytecode bc136 { 1676 PREFETCH (); 1677 PUSH_INTEGER (1); 1678 STORE_TEMPORARY_VARIABLE (arg); 1679 } 1680 1681 137 = bytecode bc137 { 1682 PREFETCH (); 1683 PUSH_LIT_CONSTANT (arg); 1684 SEND (2, 1); 1685 } 1686 1687 138 = bytecode bc138 { 1688 PREFETCH (); 1689 LINE_NUMBER_BYTECODE (); 1690 PUSH_TEMPORARY_VARIABLE (3); 1691 } 1692 1693 139 = bytecode bc139 { 1694 PREFETCH (); 1695 LINE_NUMBER_BYTECODE (); 1696 PUSH_OUTER_TEMP (0, 1); 1697 } 1698 1699 140 = bytecode bc140 { 1700 PREFETCH (); 1701 PUSH_RECEIVER_VARIABLE (arg); 1702 SEND (0, 0); 1703 } 1704 1705 141 = bytecode bc141 { 1706 PREFETCH (); 1707 PUSH_INTEGER (arg); 1708 GREATER_THAN_SPECIAL (); 1709 } 1710 1711 142 = bytecode bc142 { 1712 PREFETCH (); 1713 PUSH_TEMPORARY_VARIABLE (arg); 1714 VALUE_SPECIAL (); 1715 } 1716 1717 143 = bytecode bc143 { 1718 PREFETCH (); 1719 PUSH_TEMPORARY_VARIABLE (arg); 1720 MINUS_SPECIAL (); 1721 } 1722 1723 144 = bytecode bc144 { 1724 PREFETCH (); 1725 PUSH_LIT_CONSTANT (arg); 1726 SEND (3, 1); 1727 } 1728 1729 145 = bytecode bc145 { 1730 PREFETCH (); 1731 PUSH_SPECIAL (0); 1732 SAME_OBJECT_SPECIAL (); 1733 POP_JUMP_FALSE (arg); 1734 } 1735 1736 146 = bytecode bc146 { 1737 PREFETCH (); 1738 STORE_TEMPORARY_VARIABLE (2); 1739 LINE_NUMBER_BYTECODE (); 1740 POP_STACK_TOP (); 1741 } 1742 1743 147 = bytecode bc147 { 1744 PREFETCH (); 1745 SAME_OBJECT_SPECIAL (); 1746 POP_JUMP_TRUE (arg); 1747 } 1748 1749 148 = bytecode bc148 { 1750 PREFETCH (); 1751 PUSH_INTEGER (arg); 1752 TIMES_SPECIAL (); 1753 } 1754 1755 149 = bytecode bc149 { 1756 PREFETCH (); 1757 LINE_NUMBER_BYTECODE (); 1758 PUSH_RECEIVER_VARIABLE (2); 1759 } 1760 1761 150 = bytecode bc150 { 1762 PREFETCH (); 1763 PUSH_INTEGER (arg); 1764 LESS_THAN_SPECIAL (); 1765 } 1766 1767 151 = bytecode bc151 { 1768 PREFETCH (); 1769 PUSH_LIT_CONSTANT (arg); 1770 AT_PUT_SPECIAL (); 1771 } 1772 1773 152 = bytecode bc152 { 1774 PREFETCH (); 1775 PUSH_OUTER_TEMP (arg, 2); 1776 } 1777 1778 153 = bytecode bc153 { 1779 PREFETCH (); 1780 LINE_NUMBER_BYTECODE (); 1781 PUSH_SELF (); 1782 PUSH_TEMPORARY_VARIABLE (0); 1783 SEND (0, 1); 1784 } 1785 1786 154 = bytecode bc154 { 1787 PREFETCH (); 1788 PUSH_SELF (); 1789 PUSH_TEMPORARY_VARIABLE (0); 1790 SEND (arg, 1); 1791 } 1792 1793 155 = bytecode bc155 { 1794 PREFETCH (); 1795 LINE_NUMBER_BYTECODE (); 1796 PUSH_SELF (); 1797 SEND_IMMEDIATE (40); 1798 } 1799 1800 156 = bytecode bc156 { 1801 PREFETCH (); 1802 PUSH_TEMPORARY_VARIABLE (arg); 1803 PUSH_TEMPORARY_VARIABLE (3); 1804 } 1805 1806 157 = bytecode bc157 { 1807 PREFETCH (); 1808 STORE_TEMPORARY_VARIABLE (1); 1809 LINE_NUMBER_BYTECODE (); 1810 } 1811 1812 158 = bytecode bc158 { 1813 PREFETCH (); 1814 LINE_NUMBER_BYTECODE (); 1815 PUSH_TEMPORARY_VARIABLE (0); 1816 SEND (0, 0); 1817 } 1818 1819 159 = bytecode bc159 { 1820 PREFETCH (); 1821 PUSH_INTEGER (arg); 1822 BIT_AND_SPECIAL (); 1823 } 1824 1825 160 = bytecode bc160 { 1826 PREFETCH (); 1827 PUSH_TEMPORARY_VARIABLE (2); 1828 SEND (arg, 0); 1829 } 1830 1831 161 = bytecode bc161 { 1832 PREFETCH (); 1833 PUSH_TEMPORARY_VARIABLE (0); 1834 PUSH_TEMPORARY_VARIABLE (1); 1835 SEND (arg >> 8, arg & 255); 1836 } 1837 1838 162 = bytecode bc162 { 1839 PREFETCH (); 1840 LINE_NUMBER_BYTECODE (); 1841 PUSH_SELF (); 1842 PUSH_TEMPORARY_VARIABLE (0); 1843 } 1844 1845 163 = bytecode bc163 { 1846 PREFETCH (); 1847 LINE_NUMBER_BYTECODE (); 1848 PUSH_RECEIVER_VARIABLE (3); 1849 } 1850 1851 164 = bytecode bc164 { 1852 PREFETCH (); 1853 PUSH_TEMPORARY_VARIABLE (2); 1854 SEND (arg, 1); 1855 } 1856 1857 165 = bytecode bc165 { 1858 PREFETCH (); 1859 NOT_NIL_SPECIAL (); 1860 POP_JUMP_FALSE (arg); 1861 } 1862 1863 166 = bytecode bc166 { 1864 PREFETCH (); 1865 STORE_TEMPORARY_VARIABLE (2); 1866 LINE_NUMBER_BYTECODE (); 1867 } 1868 1869 167 = bytecode bc167 { 1870 PREFETCH (); 1871 STORE_TEMPORARY_VARIABLE (3); 1872 LINE_NUMBER_BYTECODE (); 1873 POP_STACK_TOP (); 1874 } 1875 1876 168 = bytecode bc168 { 1877 PREFETCH (); 1878 PUSH_LIT_CONSTANT (1); 1879 SEND_IMMEDIATE (arg); 1880 } 1881 1882 169 = bytecode bc169 { 1883 PREFETCH (); 1884 PUSH_TEMPORARY_VARIABLE (arg); 1885 EQUAL_SPECIAL (); 1886 } 1887 1888 170 = bytecode bc170 { 1889 PREFETCH (); 1890 POP_STACK_TOP (); 1891 DUP_STACK_TOP (); 1892 PUSH_TEMPORARY_VARIABLE (arg); 1893 PUSH_INTEGER (1); 1894 PLUS_SPECIAL (); 1895 } 1896 1897 171 = bytecode bc171 { 1898 PREFETCH (); 1899 PUSH_SELF (); 1900 SEND (arg, 1); 1901 } 1902 1903 172 = bytecode bc172 { 1904 PREFETCH (); 1905 STORE_TEMPORARY_VARIABLE (0); 1906 LINE_NUMBER_BYTECODE (); 1907 POP_STACK_TOP (); 1908 } 1909 1910 173 = bytecode bc173 { 1911 PREFETCH (); 1912 DUP_STACK_TOP (); 1913 LINE_NUMBER_BYTECODE (); 1914 } 1915 1916 174 = bytecode bc174 { 1917 PREFETCH (); 1918 PUSH_SELF (); 1919 PUSH_LIT_CONSTANT (arg); 1920 SEND_IMMEDIATE (49); 1921 } 1922 1923 175 = bytecode bc175 { 1924 PREFETCH (); 1925 POP_STACK_TOP (); 1926 PUSH_RECEIVER_VARIABLE (arg); 1927 } 1928 1929 176 = bytecode bc176 { 1930 PREFETCH (); 1931 LINE_NUMBER_BYTECODE (); 1932 PUSH_SELF (); 1933 SEND_IMMEDIATE (84); 1934 } 1935 1936 177 = bytecode bc177 { 1937 PREFETCH (); 1938 LINE_NUMBER_BYTECODE (); 1939 PUSH_LIT_VARIABLE (2); 1940 } 1941 1942 178 = bytecode bc178 { 1943 PREFETCH (); 1944 PUSH_LIT_CONSTANT (arg); 1945 MAKE_DIRTY_BLOCK (); 1946 SEND (3, 1); 1947 } 1948 1949 179 = bytecode bc179 { 1950 PREFETCH (); 1951 LINE_NUMBER_BYTECODE (); 1952 PUSH_LIT_CONSTANT (0); 1953 } 1954 1955 180 = bytecode bc180 { 1956 PREFETCH (); 1957 DUP_STACK_TOP (); 1958 PUSH_LIT_CONSTANT (arg); 1959 SEND_IMMEDIATE (36); 1960 } 1961 1962 181 = bytecode bc181 { 1963 PREFETCH (); 1964 LINE_NUMBER_BYTECODE (); 1965 PUSH_OUTER_TEMP (1, 1); 1966 } 1967 1968 182 = bytecode bc182 { 1969 PREFETCH (); 1970 PUSH_INTEGER (arg); 1971 INTEGER_DIVIDE_SPECIAL (); 1972 } 1973 1974 183 = bytecode bc183 { 1975 PREFETCH (); 1976 PUSH_LIT_CONSTANT (1); 1977 MAKE_DIRTY_BLOCK (); 1978 SEND_IMMEDIATE (arg); 1979 } 1980 1981 184 = bytecode bc184 { 1982 PREFETCH (); 1983 PUSH_TEMPORARY_VARIABLE (3); 1984 SEND_IMMEDIATE (arg); 1985 } 1986 1987 185 = bytecode bc185 { 1988 PREFETCH (); 1989 LINE_NUMBER_BYTECODE (); 1990 PUSH_SPECIAL (0); 1991 RETURN_CONTEXT_STACK_TOP (); 1992 } 1993 1994 186 = bytecode bc186 { 1995 PREFETCH (); 1996 LINE_NUMBER_BYTECODE (); 1997 PUSH_RECEIVER_VARIABLE (5); 1998 } 1999 2000 187 = bytecode bc187 { 2001 PREFETCH (); 2002 PUSH_LIT_CONSTANT (arg); 2003 MAKE_DIRTY_BLOCK (); 2004 SEND (2, 1); 2005 } 2006 2007 188 = bytecode bc188 { 2008 PREFETCH (); 2009 PUSH_TEMPORARY_VARIABLE (arg); 2010 VALUE_COLON_SPECIAL (); 2011 } 2012 2013 189 = bytecode bc189 { 2014 PREFETCH (); 2015 PUSH_INTEGER (arg); 2016 RETURN_CONTEXT_STACK_TOP (); 2017 } 2018 2019 190 = bytecode bc190 { 2020 PREFETCH (); 2021 PUSH_TEMPORARY_VARIABLE (0); 2022 SEND (arg, 2); 2023 } 2024 2025 191 = bytecode bc191 { 2026 PREFETCH (); 2027 PUSH_TEMPORARY_VARIABLE (arg); 2028 PUSH_INTEGER (1); 2029 MINUS_SPECIAL (); 2030 } 2031 2032 192 = bytecode bc192 { 2033 PREFETCH (); 2034 PUSH_SELF (); 2035 PUSH_LIT_CONSTANT (arg); 2036 } 2037 2038 193 = bytecode bc193 { 2039 PREFETCH (); 2040 LINE_NUMBER_BYTECODE (); 2041 PUSH_RECEIVER_VARIABLE (4); 2042 } 2043 2044 194 = bytecode bc194 { 2045 PREFETCH (); 2046 PUSH_OUTER_TEMP (0, 1); 2047 SEND_IMMEDIATE (arg); 2048 } 2049 2050 195 = bytecode bc195 { 2051 PREFETCH (); 2052 LINE_NUMBER_BYTECODE (); 2053 PUSH_SELF (); 2054 SEND (1, 0); 2055 } 2056 2057 196 = bytecode bc196 { 2058 PREFETCH (); 2059 PUSH_OUTER_TEMP (0, 1); 2060 SEND (arg, 1); 2061 } 2062 2063 197 = bytecode bc197 { 2064 PREFETCH (); 2065 PUSH_TEMPORARY_VARIABLE (4); 2066 SEND_IMMEDIATE (arg); 2067 } 2068 2069 198 = bytecode bc198 { 2070 PREFETCH (); 2071 PUSH_INTEGER (arg); 2072 SEND_IMMEDIATE (41); 2073 } 2074 2075 199 = bytecode bc199 { 2076 PREFETCH (); 2077 SEND (arg, 4); 2078 } 2079 2080 200 = bytecode bc200 { 2081 PREFETCH (); 2082 PUSH_TEMPORARY_VARIABLE (arg); 2083 PUSH_TEMPORARY_VARIABLE (2); 2084 } 2085 2086 201 = bytecode bc201 { 2087 PREFETCH (); 2088 PUSH_SELF (); 2089 CLASS_SPECIAL (); 2090 } 2091 2092 202 = bytecode bc202 { 2093 PREFETCH (); 2094 PUSH_TEMPORARY_VARIABLE (1); 2095 SEND (arg >> 8, arg & 255); 2096 } 2097 2098 203 = bytecode bc203 { 2099 PREFETCH (); 2100 PUSH_SELF (); 2101 PUSH_TEMPORARY_VARIABLE (1); 2102 SEND (arg, 1); 2103 } 2104 2105 204 = bytecode bc204 { 2106 PREFETCH (); 2107 PUSH_LIT_CONSTANT (arg); 2108 SEND (4, 1); 2109 } 2110 2111 205 = bytecode bc205 { 2112 PREFETCH (); 2113 PUSH_INTEGER (arg); 2114 SEND (0, 1); 2115 } 2116 2117 206 = bytecode bc206 { 2118 PREFETCH (); 2119 PUSH_RECEIVER_VARIABLE (arg); 2120 SIZE_SPECIAL (); 2121 } 2122 2123 207 = bytecode bc207 { 2124 PREFETCH (); 2125 PUSH_TEMPORARY_VARIABLE (1); 2126 SEND (arg, 2); 2127 } 2128 2129 208 = bytecode bc208 { 2130 PREFETCH (); 2131 PUSH_TEMPORARY_VARIABLE (0); 2132 PUSH_TEMPORARY_VARIABLE (1); 2133 SEND (arg, 2); 2134 } 2135 2136 209 = bytecode bc209 { 2137 PREFETCH (); 2138 PUSH_TEMPORARY_VARIABLE (arg); 2139 POP_INTO_NEW_STACKTOP (0); 2140 } 2141 2142 210 = bytecode bc210 { 2143 PREFETCH (); 2144 PUSH_LIT_CONSTANT (arg); 2145 MAKE_DIRTY_BLOCK (); 2146 SEND (5, 1); 2147 } 2148 2149 211 = bytecode bc211 { 2150 PREFETCH (); 2151 SEND_SUPER (arg, 1); 2152 } 2153 2154 212 = bytecode bc212 { 2155 PREFETCH (); 2156 PUSH_LIT_CONSTANT (arg); 2157 MAKE_DIRTY_BLOCK (); 2158 SEND (4, 1); 2159 } 2160 2161 213 = bytecode bc213 { 2162 PREFETCH (); 2163 PUSH_RECEIVER_VARIABLE (1); 2164 SEND_IMMEDIATE (arg); 2165 } 2166 2167 214 = bytecode bc214 { 2168 PREFETCH (); 2169 STORE_OUTER_TEMP (arg, 1); 2170 RETURN_CONTEXT_STACK_TOP (); 2171 } 2172 2173 215 = bytecode bc215 { 2174 PREFETCH (); 2175 POP_STACK_TOP (); 2176 LINE_NUMBER_BYTECODE (); 2177 SEND_IMMEDIATE (37); 2178 } 2179 2180 216 = bytecode bc216 { 2181 PREFETCH (); 2182 LINE_NUMBER_BYTECODE (); 2183 PUSH_SELF (); 2184 CLASS_SPECIAL (); 2185 } 2186 2187 217 = bytecode bc217 { 2188 PREFETCH (); 2189 PUSH_TEMPORARY_VARIABLE (1); 2190 SEND (arg, 0); 2191 } 2192 2193 218 = bytecode bc218 { 2194 PREFETCH (); 2195 LINE_NUMBER_BYTECODE (); 2196 PUSH_SELF (); 2197 SEND_IMMEDIATE (130); 2198 } 2199 2200 219 = bytecode bc219 { 2201 PREFETCH (); 2202 PUSH_RECEIVER_VARIABLE (0); 2203 SEND_IMMEDIATE (arg); 2204 } 2205 2206 220 = bytecode bc220 { 2207 PREFETCH (); 2208 PUSH_TEMPORARY_VARIABLE (0); 2209 PUSH_LIT_VARIABLE (arg); 2210 } 2211 2212 221 = bytecode bc221 { 2213 PREFETCH (); 2214 STORE_TEMPORARY_VARIABLE (0); 2215 LINE_NUMBER_BYTECODE (); 2216 } 2217 2218 222 = bytecode bc222 { 2219 PREFETCH (); 2220 PUSH_RECEIVER_VARIABLE (2); 2221 SEND_IMMEDIATE (arg); 2222 } 2223 2224 223 = bytecode bc223 { 2225 PREFETCH (); 2226 LINE_NUMBER_BYTECODE (); 2227 PUSH_SELF (); 2228 SEND (2, 0); 2229 } 2230 2231 224 = bytecode bc224 { 2232 PREFETCH (); 2233 LINE_NUMBER_BYTECODE (); 2234 POP_STACK_TOP (); 2235 PUSH_TEMPORARY_VARIABLE (2); 2236 } 2237 2238 225 = bytecode bc225 { 2239 PREFETCH (); 2240 PUSH_LIT_CONSTANT (arg); 2241 MAKE_DIRTY_BLOCK (); 2242 SEND (6, 1); 2243 } 2244 2245 226 = bytecode bc226 { 2246 PREFETCH (); 2247 PUSH_SPECIAL (arg); 2248 RETURN_METHOD_STACK_TOP (); 2249 } 2250 2251 227 = bytecode bc227 { 2252 PREFETCH (); 2253 PUSH_INTEGER (arg); 2254 GREATER_EQUAL_SPECIAL (); 2255 } 2256 2257 228 = bytecode bc228 { 2258 PREFETCH (); 2259 LINE_NUMBER_BYTECODE (); 2260 POP_STACK_TOP (); 2261 PUSH_RECEIVER_VARIABLE (1); 2262 } 2263 2264 229 = bytecode bc229 { 2265 PREFETCH (); 2266 LINE_NUMBER_BYTECODE (); 2267 PUSH_LIT_VARIABLE (3); 2268 } 2269 2270 230 = bytecode bc230 { 2271 PREFETCH (); 2272 PUSH_LIT_CONSTANT (2); 2273 SEND_IMMEDIATE (arg); 2274 } 2275 2276 231 = bytecode bc231 { 2277 PREFETCH (); 2278 SEND_SUPER (arg, 0); 2279 } 2280 2281 232 = bytecode bc232 { 2282 PREFETCH (); 2283 PUSH_SPECIAL (0); 2284 STORE_RECEIVER_VARIABLE (arg); 2285 } 2286 2287 233 = bytecode bc233 { 2288 PREFETCH (); 2289 PUSH_SELF (); 2290 PUSH_TEMPORARY_VARIABLE (arg); 2291 SEND (0, 1); 2292 } 2293 2294 234 = bytecode bc234 { 2295 PREFETCH (); 2296 LINE_NUMBER_BYTECODE (); 2297 POP_STACK_TOP (); 2298 PUSH_TEMPORARY_VARIABLE (0); 2299 RETURN_CONTEXT_STACK_TOP (); 2300 } 2301 2302 235 = bytecode bc235 { 2303 PREFETCH (); 2304 PUSH_LIT_CONSTANT (arg); 2305 SAME_OBJECT_SPECIAL (); 2306 } 2307 2308 236 = bytecode bc236 { 2309 PREFETCH (); 2310 PUSH_LIT_CONSTANT (arg); 2311 MAKE_DIRTY_BLOCK (); 2312 SEND (1, 1); 2313 } 2314 2315 237 = bytecode bc237 { 2316 PREFETCH (); 2317 LINE_NUMBER_BYTECODE (); 2318 POP_STACK_TOP (); 2319 PUSH_TEMPORARY_VARIABLE (3); 2320 } 2321 2322 238 = bytecode bc238 { 2323 PREFETCH (); 2324 POP_STACK_TOP (); 2325 DUP_STACK_TOP (); 2326 SEND_IMMEDIATE (arg); 2327 } 2328 2329 239 = bytecode bc239 { 2330 PREFETCH (); 2331 PUSH_LIT_CONSTANT (arg); 2332 PUSH_TEMPORARY_VARIABLE (0); 2333 AT_PUT_SPECIAL (); 2334 } 2335 2336 240 = bytecode bc240 { 2337 PREFETCH (); 2338 DUP_STACK_TOP (); 2339 PUSH_TEMPORARY_VARIABLE (arg); 2340 PUSH_INTEGER (1); 2341 PLUS_SPECIAL (); 2342 } 2343 2344 241 = bytecode bc241 { 2345 PREFETCH (); 2346 LINE_NUMBER_BYTECODE (); 2347 PUSH_TEMPORARY_VARIABLE (4); 2348 } 2349 2350 242 = bytecode bc242 { 2351 PREFETCH (); 2352 POP_STACK_TOP (); 2353 LINE_NUMBER_BYTECODE (); 2354 PUSH_LIT_VARIABLE (1); 2355 } 2356 2357 243 = bytecode bc243 { 2358 PREFETCH (); 2359 DUP_STACK_TOP (); 2360 PUSH_LIT_CONSTANT (arg); 2361 SEND (1, 1); 2362 } 2363 2364 244 = bytecode bc244 { 2365 PREFETCH (); 2366 POP_INTO_NEW_STACKTOP (1); 2367 SEND (arg, 1); 2368 } 2369 2370 245 = bytecode bc245 { 2371 PREFETCH (); 2372 LINE_NUMBER_BYTECODE (); 2373 POP_STACK_TOP (); 2374 PUSH_TEMPORARY_VARIABLE (1); 2375 RETURN_CONTEXT_STACK_TOP (); 2376 } 2377 2378 246 = bytecode bc246 { 2379 PREFETCH (); 2380 STORE_TEMPORARY_VARIABLE (3); 2381 LINE_NUMBER_BYTECODE (); 2382 } 2383 2384 247 = bytecode bc247 { 2385 PREFETCH (); 2386 DUP_STACK_TOP (); 2387 SEND (arg, 0); 2388 } 2389 2390 248 = bytecode bc248 { 2391 PREFETCH (); 2392 STORE_RECEIVER_VARIABLE (arg); 2393 RETURN_CONTEXT_STACK_TOP (); 2394 } 2395 2396 249 = bytecode bc249 { 2397 PREFETCH (); 2398 LINE_NUMBER_BYTECODE (); 2399 PUSH_SELF (); 2400 SEND (3, 0); 2401 } 2402 2403 250 = bytecode bc250 { 2404 PREFETCH (); 2405 NOT_NIL_SPECIAL (); 2406 DUP_STACK_TOP (); 2407 POP_JUMP_FALSE (arg); 2408 } 2409 2410 251 = bytecode bc251 { 2411 PREFETCH (); 2412 DUP_STACK_TOP (); 2413 PUSH_LIT_CONSTANT (arg); 2414 } 2415 2416 252 = bytecode bc252 { 2417 PREFETCH (); 2418 LINE_NUMBER_BYTECODE (); 2419 PUSH_TEMPORARY_VARIABLE (0); 2420 RETURN_CONTEXT_STACK_TOP (); 2421 } 2422 2423 253 = bytecode bc253 { 2424 PREFETCH (); 2425 PUSH_INTEGER (arg); 2426 AT_PUT_SPECIAL (); 2427 } 2428 2429 254 = bytecode bc254 { 2430 PREFETCH (); 2431 PUSH_TEMPORARY_VARIABLE (arg); 2432 CLASS_SPECIAL (); 2433 } 2434 2435 255 = bytecode bc255 { 2436 PREFETCH (); 2437 LINE_NUMBER_BYTECODE (); 2438 PUSH_OUTER_TEMP (2, 1); 2439 } 2440 2441} 2442