1 /* 2 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. 3 * Copyright 2008, 2009, 2010 Red Hat, Inc. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "interpreter/bytecodes.hpp" 28 #include "shark/llvmHeaders.hpp" 29 #include "shark/llvmValue.hpp" 30 #include "shark/sharkBlock.hpp" 31 #include "shark/sharkBuilder.hpp" 32 #include "shark/sharkConstant.hpp" 33 #include "shark/sharkState.hpp" 34 #include "shark/sharkValue.hpp" 35 #include "shark/shark_globals.hpp" 36 #include "utilities/debug.hpp" 37 38 using namespace llvm; 39 40 void SharkBlock::parse_bytecode(int start, int limit) { 41 SharkValue *a, *b, *c, *d; 42 int i; 43 44 // Ensure the current state is initialized before we emit any code, 45 // so that any setup code for the state is at the start of the block 46 current_state(); 47 48 // Parse the bytecodes 49 iter()->reset_to_bci(start); 50 while (iter()->next_bci() < limit) { 51 NOT_PRODUCT(a = b = c = d = NULL); 52 iter()->next(); 53 54 if (SharkTraceBytecodes) 55 tty->print_cr("%4d: %s", bci(), Bytecodes::name(bc())); 56 57 if (has_trap() && trap_bci() == bci()) { 58 do_trap(trap_request()); 59 return; 60 } 61 62 if (UseLoopSafepoints) { 63 // XXX if a lcmp is followed by an if_?? then C2 maybe-inserts 64 // the safepoint before the lcmp rather than before the if. 65 // Maybe we should do this too. See parse2.cpp for details. 66 switch (bc()) { 67 case Bytecodes::_goto: 68 case Bytecodes::_ifnull: 69 case Bytecodes::_ifnonnull: 70 case Bytecodes::_if_acmpeq: 71 case Bytecodes::_if_acmpne: 72 case Bytecodes::_ifeq: 73 case Bytecodes::_ifne: 74 case Bytecodes::_iflt: 75 case Bytecodes::_ifle: 76 case Bytecodes::_ifgt: 77 case Bytecodes::_ifge: 78 case Bytecodes::_if_icmpeq: 79 case Bytecodes::_if_icmpne: 80 case Bytecodes::_if_icmplt: 81 case Bytecodes::_if_icmple: 82 case Bytecodes::_if_icmpgt: 83 case Bytecodes::_if_icmpge: 84 if (iter()->get_dest() <= bci()) 85 maybe_add_backedge_safepoint(); 86 break; 87 88 case Bytecodes::_goto_w: 89 if (iter()->get_far_dest() <= bci()) 90 maybe_add_backedge_safepoint(); 91 break; 92 93 case Bytecodes::_tableswitch: 94 case Bytecodes::_lookupswitch: 95 if (switch_default_dest() <= bci()) { 96 maybe_add_backedge_safepoint(); 97 break; 98 } 99 int len = switch_table_length(); 100 for (int i = 0; i < len; i++) { 101 if (switch_dest(i) <= bci()) { 102 maybe_add_backedge_safepoint(); 103 break; 104 } 105 } 106 break; 107 } 108 } 109 110 switch (bc()) { 111 case Bytecodes::_nop: 112 break; 113 114 case Bytecodes::_aconst_null: 115 push(SharkValue::null()); 116 break; 117 118 case Bytecodes::_iconst_m1: 119 push(SharkValue::jint_constant(-1)); 120 break; 121 case Bytecodes::_iconst_0: 122 push(SharkValue::jint_constant(0)); 123 break; 124 case Bytecodes::_iconst_1: 125 push(SharkValue::jint_constant(1)); 126 break; 127 case Bytecodes::_iconst_2: 128 push(SharkValue::jint_constant(2)); 129 break; 130 case Bytecodes::_iconst_3: 131 push(SharkValue::jint_constant(3)); 132 break; 133 case Bytecodes::_iconst_4: 134 push(SharkValue::jint_constant(4)); 135 break; 136 case Bytecodes::_iconst_5: 137 push(SharkValue::jint_constant(5)); 138 break; 139 140 case Bytecodes::_lconst_0: 141 push(SharkValue::jlong_constant(0)); 142 break; 143 case Bytecodes::_lconst_1: 144 push(SharkValue::jlong_constant(1)); 145 break; 146 147 case Bytecodes::_fconst_0: 148 push(SharkValue::jfloat_constant(0)); 149 break; 150 case Bytecodes::_fconst_1: 151 push(SharkValue::jfloat_constant(1)); 152 break; 153 case Bytecodes::_fconst_2: 154 push(SharkValue::jfloat_constant(2)); 155 break; 156 157 case Bytecodes::_dconst_0: 158 push(SharkValue::jdouble_constant(0)); 159 break; 160 case Bytecodes::_dconst_1: 161 push(SharkValue::jdouble_constant(1)); 162 break; 163 164 case Bytecodes::_bipush: 165 push(SharkValue::jint_constant(iter()->get_constant_u1())); 166 break; 167 case Bytecodes::_sipush: 168 push(SharkValue::jint_constant(iter()->get_constant_u2())); 169 break; 170 171 case Bytecodes::_ldc: 172 case Bytecodes::_ldc_w: 173 case Bytecodes::_ldc2_w: { 174 SharkConstant* constant = SharkConstant::for_ldc(iter()); 175 assert(constant->is_loaded(), "trap should handle unloaded classes"); 176 push(constant->value(builder())); 177 break; 178 } 179 case Bytecodes::_iload_0: 180 case Bytecodes::_lload_0: 181 case Bytecodes::_fload_0: 182 case Bytecodes::_dload_0: 183 case Bytecodes::_aload_0: 184 push(local(0)); 185 break; 186 case Bytecodes::_iload_1: 187 case Bytecodes::_lload_1: 188 case Bytecodes::_fload_1: 189 case Bytecodes::_dload_1: 190 case Bytecodes::_aload_1: 191 push(local(1)); 192 break; 193 case Bytecodes::_iload_2: 194 case Bytecodes::_lload_2: 195 case Bytecodes::_fload_2: 196 case Bytecodes::_dload_2: 197 case Bytecodes::_aload_2: 198 push(local(2)); 199 break; 200 case Bytecodes::_iload_3: 201 case Bytecodes::_lload_3: 202 case Bytecodes::_fload_3: 203 case Bytecodes::_dload_3: 204 case Bytecodes::_aload_3: 205 push(local(3)); 206 break; 207 case Bytecodes::_iload: 208 case Bytecodes::_lload: 209 case Bytecodes::_fload: 210 case Bytecodes::_dload: 211 case Bytecodes::_aload: 212 push(local(iter()->get_index())); 213 break; 214 215 case Bytecodes::_baload: 216 do_aload(T_BYTE); 217 break; 218 case Bytecodes::_caload: 219 do_aload(T_CHAR); 220 break; 221 case Bytecodes::_saload: 222 do_aload(T_SHORT); 223 break; 224 case Bytecodes::_iaload: 225 do_aload(T_INT); 226 break; 227 case Bytecodes::_laload: 228 do_aload(T_LONG); 229 break; 230 case Bytecodes::_faload: 231 do_aload(T_FLOAT); 232 break; 233 case Bytecodes::_daload: 234 do_aload(T_DOUBLE); 235 break; 236 case Bytecodes::_aaload: 237 do_aload(T_OBJECT); 238 break; 239 240 case Bytecodes::_istore_0: 241 case Bytecodes::_lstore_0: 242 case Bytecodes::_fstore_0: 243 case Bytecodes::_dstore_0: 244 case Bytecodes::_astore_0: 245 set_local(0, pop()); 246 break; 247 case Bytecodes::_istore_1: 248 case Bytecodes::_lstore_1: 249 case Bytecodes::_fstore_1: 250 case Bytecodes::_dstore_1: 251 case Bytecodes::_astore_1: 252 set_local(1, pop()); 253 break; 254 case Bytecodes::_istore_2: 255 case Bytecodes::_lstore_2: 256 case Bytecodes::_fstore_2: 257 case Bytecodes::_dstore_2: 258 case Bytecodes::_astore_2: 259 set_local(2, pop()); 260 break; 261 case Bytecodes::_istore_3: 262 case Bytecodes::_lstore_3: 263 case Bytecodes::_fstore_3: 264 case Bytecodes::_dstore_3: 265 case Bytecodes::_astore_3: 266 set_local(3, pop()); 267 break; 268 case Bytecodes::_istore: 269 case Bytecodes::_lstore: 270 case Bytecodes::_fstore: 271 case Bytecodes::_dstore: 272 case Bytecodes::_astore: 273 set_local(iter()->get_index(), pop()); 274 break; 275 276 case Bytecodes::_bastore: 277 do_astore(T_BYTE); 278 break; 279 case Bytecodes::_castore: 280 do_astore(T_CHAR); 281 break; 282 case Bytecodes::_sastore: 283 do_astore(T_SHORT); 284 break; 285 case Bytecodes::_iastore: 286 do_astore(T_INT); 287 break; 288 case Bytecodes::_lastore: 289 do_astore(T_LONG); 290 break; 291 case Bytecodes::_fastore: 292 do_astore(T_FLOAT); 293 break; 294 case Bytecodes::_dastore: 295 do_astore(T_DOUBLE); 296 break; 297 case Bytecodes::_aastore: 298 do_astore(T_OBJECT); 299 break; 300 301 case Bytecodes::_pop: 302 xpop(); 303 break; 304 case Bytecodes::_pop2: 305 xpop(); 306 xpop(); 307 break; 308 case Bytecodes::_swap: 309 a = xpop(); 310 b = xpop(); 311 xpush(a); 312 xpush(b); 313 break; 314 case Bytecodes::_dup: 315 a = xpop(); 316 xpush(a); 317 xpush(a); 318 break; 319 case Bytecodes::_dup_x1: 320 a = xpop(); 321 b = xpop(); 322 xpush(a); 323 xpush(b); 324 xpush(a); 325 break; 326 case Bytecodes::_dup_x2: 327 a = xpop(); 328 b = xpop(); 329 c = xpop(); 330 xpush(a); 331 xpush(c); 332 xpush(b); 333 xpush(a); 334 break; 335 case Bytecodes::_dup2: 336 a = xpop(); 337 b = xpop(); 338 xpush(b); 339 xpush(a); 340 xpush(b); 341 xpush(a); 342 break; 343 case Bytecodes::_dup2_x1: 344 a = xpop(); 345 b = xpop(); 346 c = xpop(); 347 xpush(b); 348 xpush(a); 349 xpush(c); 350 xpush(b); 351 xpush(a); 352 break; 353 case Bytecodes::_dup2_x2: 354 a = xpop(); 355 b = xpop(); 356 c = xpop(); 357 d = xpop(); 358 xpush(b); 359 xpush(a); 360 xpush(d); 361 xpush(c); 362 xpush(b); 363 xpush(a); 364 break; 365 366 case Bytecodes::_arraylength: 367 do_arraylength(); 368 break; 369 370 case Bytecodes::_getfield: 371 do_getfield(); 372 break; 373 case Bytecodes::_getstatic: 374 do_getstatic(); 375 break; 376 case Bytecodes::_putfield: 377 do_putfield(); 378 break; 379 case Bytecodes::_putstatic: 380 do_putstatic(); 381 break; 382 383 case Bytecodes::_iadd: 384 b = pop(); 385 a = pop(); 386 push(SharkValue::create_jint( 387 builder()->CreateAdd(a->jint_value(), b->jint_value()), false)); 388 break; 389 case Bytecodes::_isub: 390 b = pop(); 391 a = pop(); 392 push(SharkValue::create_jint( 393 builder()->CreateSub(a->jint_value(), b->jint_value()), false)); 394 break; 395 case Bytecodes::_imul: 396 b = pop(); 397 a = pop(); 398 push(SharkValue::create_jint( 399 builder()->CreateMul(a->jint_value(), b->jint_value()), false)); 400 break; 401 case Bytecodes::_idiv: 402 do_idiv(); 403 break; 404 case Bytecodes::_irem: 405 do_irem(); 406 break; 407 case Bytecodes::_ineg: 408 a = pop(); 409 push(SharkValue::create_jint( 410 builder()->CreateNeg(a->jint_value()), a->zero_checked())); 411 break; 412 case Bytecodes::_ishl: 413 b = pop(); 414 a = pop(); 415 push(SharkValue::create_jint( 416 builder()->CreateShl( 417 a->jint_value(), 418 builder()->CreateAnd( 419 b->jint_value(), LLVMValue::jint_constant(0x1f))), false)); 420 break; 421 case Bytecodes::_ishr: 422 b = pop(); 423 a = pop(); 424 push(SharkValue::create_jint( 425 builder()->CreateAShr( 426 a->jint_value(), 427 builder()->CreateAnd( 428 b->jint_value(), LLVMValue::jint_constant(0x1f))), false)); 429 break; 430 case Bytecodes::_iushr: 431 b = pop(); 432 a = pop(); 433 push(SharkValue::create_jint( 434 builder()->CreateLShr( 435 a->jint_value(), 436 builder()->CreateAnd( 437 b->jint_value(), LLVMValue::jint_constant(0x1f))), false)); 438 break; 439 case Bytecodes::_iand: 440 b = pop(); 441 a = pop(); 442 push(SharkValue::create_jint( 443 builder()->CreateAnd(a->jint_value(), b->jint_value()), false)); 444 break; 445 case Bytecodes::_ior: 446 b = pop(); 447 a = pop(); 448 push(SharkValue::create_jint( 449 builder()->CreateOr(a->jint_value(), b->jint_value()), 450 a->zero_checked() && b->zero_checked())); 451 break; 452 case Bytecodes::_ixor: 453 b = pop(); 454 a = pop(); 455 push(SharkValue::create_jint( 456 builder()->CreateXor(a->jint_value(), b->jint_value()), false)); 457 break; 458 459 case Bytecodes::_ladd: 460 b = pop(); 461 a = pop(); 462 push(SharkValue::create_jlong( 463 builder()->CreateAdd(a->jlong_value(), b->jlong_value()), false)); 464 break; 465 case Bytecodes::_lsub: 466 b = pop(); 467 a = pop(); 468 push(SharkValue::create_jlong( 469 builder()->CreateSub(a->jlong_value(), b->jlong_value()), false)); 470 break; 471 case Bytecodes::_lmul: 472 b = pop(); 473 a = pop(); 474 push(SharkValue::create_jlong( 475 builder()->CreateMul(a->jlong_value(), b->jlong_value()), false)); 476 break; 477 case Bytecodes::_ldiv: 478 do_ldiv(); 479 break; 480 case Bytecodes::_lrem: 481 do_lrem(); 482 break; 483 case Bytecodes::_lneg: 484 a = pop(); 485 push(SharkValue::create_jlong( 486 builder()->CreateNeg(a->jlong_value()), a->zero_checked())); 487 break; 488 case Bytecodes::_lshl: 489 b = pop(); 490 a = pop(); 491 push(SharkValue::create_jlong( 492 builder()->CreateShl( 493 a->jlong_value(), 494 builder()->CreateIntCast( 495 builder()->CreateAnd( 496 b->jint_value(), LLVMValue::jint_constant(0x3f)), 497 SharkType::jlong_type(), true)), false)); 498 break; 499 case Bytecodes::_lshr: 500 b = pop(); 501 a = pop(); 502 push(SharkValue::create_jlong( 503 builder()->CreateAShr( 504 a->jlong_value(), 505 builder()->CreateIntCast( 506 builder()->CreateAnd( 507 b->jint_value(), LLVMValue::jint_constant(0x3f)), 508 SharkType::jlong_type(), true)), false)); 509 break; 510 case Bytecodes::_lushr: 511 b = pop(); 512 a = pop(); 513 push(SharkValue::create_jlong( 514 builder()->CreateLShr( 515 a->jlong_value(), 516 builder()->CreateIntCast( 517 builder()->CreateAnd( 518 b->jint_value(), LLVMValue::jint_constant(0x3f)), 519 SharkType::jlong_type(), true)), false)); 520 break; 521 case Bytecodes::_land: 522 b = pop(); 523 a = pop(); 524 push(SharkValue::create_jlong( 525 builder()->CreateAnd(a->jlong_value(), b->jlong_value()), false)); 526 break; 527 case Bytecodes::_lor: 528 b = pop(); 529 a = pop(); 530 push(SharkValue::create_jlong( 531 builder()->CreateOr(a->jlong_value(), b->jlong_value()), 532 a->zero_checked() && b->zero_checked())); 533 break; 534 case Bytecodes::_lxor: 535 b = pop(); 536 a = pop(); 537 push(SharkValue::create_jlong( 538 builder()->CreateXor(a->jlong_value(), b->jlong_value()), false)); 539 break; 540 541 case Bytecodes::_fadd: 542 b = pop(); 543 a = pop(); 544 push(SharkValue::create_jfloat( 545 builder()->CreateFAdd(a->jfloat_value(), b->jfloat_value()))); 546 break; 547 case Bytecodes::_fsub: 548 b = pop(); 549 a = pop(); 550 push(SharkValue::create_jfloat( 551 builder()->CreateFSub(a->jfloat_value(), b->jfloat_value()))); 552 break; 553 case Bytecodes::_fmul: 554 b = pop(); 555 a = pop(); 556 push(SharkValue::create_jfloat( 557 builder()->CreateFMul(a->jfloat_value(), b->jfloat_value()))); 558 break; 559 case Bytecodes::_fdiv: 560 b = pop(); 561 a = pop(); 562 push(SharkValue::create_jfloat( 563 builder()->CreateFDiv(a->jfloat_value(), b->jfloat_value()))); 564 break; 565 case Bytecodes::_frem: 566 b = pop(); 567 a = pop(); 568 push(SharkValue::create_jfloat( 569 builder()->CreateFRem(a->jfloat_value(), b->jfloat_value()))); 570 break; 571 case Bytecodes::_fneg: 572 a = pop(); 573 push(SharkValue::create_jfloat( 574 builder()->CreateFNeg(a->jfloat_value()))); 575 break; 576 577 case Bytecodes::_dadd: 578 b = pop(); 579 a = pop(); 580 push(SharkValue::create_jdouble( 581 builder()->CreateFAdd(a->jdouble_value(), b->jdouble_value()))); 582 break; 583 case Bytecodes::_dsub: 584 b = pop(); 585 a = pop(); 586 push(SharkValue::create_jdouble( 587 builder()->CreateFSub(a->jdouble_value(), b->jdouble_value()))); 588 break; 589 case Bytecodes::_dmul: 590 b = pop(); 591 a = pop(); 592 push(SharkValue::create_jdouble( 593 builder()->CreateFMul(a->jdouble_value(), b->jdouble_value()))); 594 break; 595 case Bytecodes::_ddiv: 596 b = pop(); 597 a = pop(); 598 push(SharkValue::create_jdouble( 599 builder()->CreateFDiv(a->jdouble_value(), b->jdouble_value()))); 600 break; 601 case Bytecodes::_drem: 602 b = pop(); 603 a = pop(); 604 push(SharkValue::create_jdouble( 605 builder()->CreateFRem(a->jdouble_value(), b->jdouble_value()))); 606 break; 607 case Bytecodes::_dneg: 608 a = pop(); 609 push(SharkValue::create_jdouble( 610 builder()->CreateFNeg(a->jdouble_value()))); 611 break; 612 613 case Bytecodes::_iinc: 614 i = iter()->get_index(); 615 set_local( 616 i, 617 SharkValue::create_jint( 618 builder()->CreateAdd( 619 LLVMValue::jint_constant(iter()->get_iinc_con()), 620 local(i)->jint_value()), false)); 621 break; 622 623 case Bytecodes::_lcmp: 624 do_lcmp(); 625 break; 626 627 case Bytecodes::_fcmpl: 628 do_fcmp(false, false); 629 break; 630 case Bytecodes::_fcmpg: 631 do_fcmp(false, true); 632 break; 633 case Bytecodes::_dcmpl: 634 do_fcmp(true, false); 635 break; 636 case Bytecodes::_dcmpg: 637 do_fcmp(true, true); 638 break; 639 640 case Bytecodes::_i2l: 641 a = pop(); 642 push(SharkValue::create_jlong( 643 builder()->CreateIntCast( 644 a->jint_value(), SharkType::jlong_type(), true), a->zero_checked())); 645 break; 646 case Bytecodes::_i2f: 647 push(SharkValue::create_jfloat( 648 builder()->CreateSIToFP( 649 pop()->jint_value(), SharkType::jfloat_type()))); 650 break; 651 case Bytecodes::_i2d: 652 push(SharkValue::create_jdouble( 653 builder()->CreateSIToFP( 654 pop()->jint_value(), SharkType::jdouble_type()))); 655 break; 656 657 case Bytecodes::_l2i: 658 push(SharkValue::create_jint( 659 builder()->CreateIntCast( 660 pop()->jlong_value(), SharkType::jint_type(), true), false)); 661 break; 662 case Bytecodes::_l2f: 663 push(SharkValue::create_jfloat( 664 builder()->CreateSIToFP( 665 pop()->jlong_value(), SharkType::jfloat_type()))); 666 break; 667 case Bytecodes::_l2d: 668 push(SharkValue::create_jdouble( 669 builder()->CreateSIToFP( 670 pop()->jlong_value(), SharkType::jdouble_type()))); 671 break; 672 673 case Bytecodes::_f2i: 674 push(SharkValue::create_jint( 675 builder()->CreateCall( 676 builder()->f2i(), pop()->jfloat_value()), false)); 677 break; 678 case Bytecodes::_f2l: 679 push(SharkValue::create_jlong( 680 builder()->CreateCall( 681 builder()->f2l(), pop()->jfloat_value()), false)); 682 break; 683 case Bytecodes::_f2d: 684 push(SharkValue::create_jdouble( 685 builder()->CreateFPExt( 686 pop()->jfloat_value(), SharkType::jdouble_type()))); 687 break; 688 689 case Bytecodes::_d2i: 690 push(SharkValue::create_jint( 691 builder()->CreateCall( 692 builder()->d2i(), pop()->jdouble_value()), false)); 693 break; 694 case Bytecodes::_d2l: 695 push(SharkValue::create_jlong( 696 builder()->CreateCall( 697 builder()->d2l(), pop()->jdouble_value()), false)); 698 break; 699 case Bytecodes::_d2f: 700 push(SharkValue::create_jfloat( 701 builder()->CreateFPTrunc( 702 pop()->jdouble_value(), SharkType::jfloat_type()))); 703 break; 704 705 case Bytecodes::_i2b: 706 push(SharkValue::create_jint( 707 builder()->CreateAShr( 708 builder()->CreateShl( 709 pop()->jint_value(), 710 LLVMValue::jint_constant(24)), 711 LLVMValue::jint_constant(24)), false)); 712 break; 713 case Bytecodes::_i2c: 714 push(SharkValue::create_jint( 715 builder()->CreateAnd( 716 pop()->jint_value(), 717 LLVMValue::jint_constant(0xffff)), false)); 718 break; 719 case Bytecodes::_i2s: 720 push(SharkValue::create_jint( 721 builder()->CreateAShr( 722 builder()->CreateShl( 723 pop()->jint_value(), 724 LLVMValue::jint_constant(16)), 725 LLVMValue::jint_constant(16)), false)); 726 break; 727 728 case Bytecodes::_return: 729 do_return(T_VOID); 730 break; 731 case Bytecodes::_ireturn: 732 do_return(T_INT); 733 break; 734 case Bytecodes::_lreturn: 735 do_return(T_LONG); 736 break; 737 case Bytecodes::_freturn: 738 do_return(T_FLOAT); 739 break; 740 case Bytecodes::_dreturn: 741 do_return(T_DOUBLE); 742 break; 743 case Bytecodes::_areturn: 744 do_return(T_OBJECT); 745 break; 746 747 case Bytecodes::_athrow: 748 do_athrow(); 749 break; 750 751 case Bytecodes::_goto: 752 case Bytecodes::_goto_w: 753 do_goto(); 754 break; 755 756 case Bytecodes::_jsr: 757 case Bytecodes::_jsr_w: 758 do_jsr(); 759 break; 760 761 case Bytecodes::_ret: 762 do_ret(); 763 break; 764 765 case Bytecodes::_ifnull: 766 do_if(ICmpInst::ICMP_EQ, SharkValue::null(), pop()); 767 break; 768 case Bytecodes::_ifnonnull: 769 do_if(ICmpInst::ICMP_NE, SharkValue::null(), pop()); 770 break; 771 case Bytecodes::_if_acmpeq: 772 b = pop(); 773 a = pop(); 774 do_if(ICmpInst::ICMP_EQ, b, a); 775 break; 776 case Bytecodes::_if_acmpne: 777 b = pop(); 778 a = pop(); 779 do_if(ICmpInst::ICMP_NE, b, a); 780 break; 781 case Bytecodes::_ifeq: 782 do_if(ICmpInst::ICMP_EQ, SharkValue::jint_constant(0), pop()); 783 break; 784 case Bytecodes::_ifne: 785 do_if(ICmpInst::ICMP_NE, SharkValue::jint_constant(0), pop()); 786 break; 787 case Bytecodes::_iflt: 788 do_if(ICmpInst::ICMP_SLT, SharkValue::jint_constant(0), pop()); 789 break; 790 case Bytecodes::_ifle: 791 do_if(ICmpInst::ICMP_SLE, SharkValue::jint_constant(0), pop()); 792 break; 793 case Bytecodes::_ifgt: 794 do_if(ICmpInst::ICMP_SGT, SharkValue::jint_constant(0), pop()); 795 break; 796 case Bytecodes::_ifge: 797 do_if(ICmpInst::ICMP_SGE, SharkValue::jint_constant(0), pop()); 798 break; 799 case Bytecodes::_if_icmpeq: 800 b = pop(); 801 a = pop(); 802 do_if(ICmpInst::ICMP_EQ, b, a); 803 break; 804 case Bytecodes::_if_icmpne: 805 b = pop(); 806 a = pop(); 807 do_if(ICmpInst::ICMP_NE, b, a); 808 break; 809 case Bytecodes::_if_icmplt: 810 b = pop(); 811 a = pop(); 812 do_if(ICmpInst::ICMP_SLT, b, a); 813 break; 814 case Bytecodes::_if_icmple: 815 b = pop(); 816 a = pop(); 817 do_if(ICmpInst::ICMP_SLE, b, a); 818 break; 819 case Bytecodes::_if_icmpgt: 820 b = pop(); 821 a = pop(); 822 do_if(ICmpInst::ICMP_SGT, b, a); 823 break; 824 case Bytecodes::_if_icmpge: 825 b = pop(); 826 a = pop(); 827 do_if(ICmpInst::ICMP_SGE, b, a); 828 break; 829 830 case Bytecodes::_tableswitch: 831 case Bytecodes::_lookupswitch: 832 do_switch(); 833 break; 834 835 case Bytecodes::_invokestatic: 836 case Bytecodes::_invokespecial: 837 case Bytecodes::_invokevirtual: 838 case Bytecodes::_invokeinterface: 839 do_call(); 840 break; 841 842 case Bytecodes::_instanceof: 843 // This is a very common construct: 844 // 845 // if (object instanceof Klass) { 846 // something = (Klass) object; 847 // ... 848 // } 849 // 850 // which gets compiled to something like this: 851 // 852 // 28: aload 9 853 // 30: instanceof <Class Klass> 854 // 33: ifeq 52 855 // 36: aload 9 856 // 38: checkcast <Class Klass> 857 // 858 // Handling both bytecodes at once allows us 859 // to eliminate the checkcast. 860 if (iter()->next_bci() < limit && 861 (iter()->next_bc() == Bytecodes::_ifeq || 862 iter()->next_bc() == Bytecodes::_ifne) && 863 (!UseLoopSafepoints || 864 iter()->next_get_dest() > iter()->next_bci())) { 865 if (maybe_do_instanceof_if()) { 866 iter()->next(); 867 if (SharkTraceBytecodes) 868 tty->print_cr("%4d: %s", bci(), Bytecodes::name(bc())); 869 break; 870 } 871 } 872 // fall through 873 case Bytecodes::_checkcast: 874 do_instance_check(); 875 break; 876 877 case Bytecodes::_new: 878 do_new(); 879 break; 880 case Bytecodes::_newarray: 881 do_newarray(); 882 break; 883 case Bytecodes::_anewarray: 884 do_anewarray(); 885 break; 886 case Bytecodes::_multianewarray: 887 do_multianewarray(); 888 break; 889 890 case Bytecodes::_monitorenter: 891 do_monitorenter(); 892 break; 893 case Bytecodes::_monitorexit: 894 do_monitorexit(); 895 break; 896 897 default: 898 ShouldNotReachHere(); 899 } 900 } 901 } 902 903 SharkState* SharkBlock::initial_current_state() { 904 return entry_state()->copy(); 905 } 906 907 int SharkBlock::switch_default_dest() { 908 return iter()->get_dest_table(0); 909 } 910 911 int SharkBlock::switch_table_length() { 912 switch(bc()) { 913 case Bytecodes::_tableswitch: 914 return iter()->get_int_table(2) - iter()->get_int_table(1) + 1; 915 916 case Bytecodes::_lookupswitch: 917 return iter()->get_int_table(1); 918 919 default: 920 ShouldNotReachHere(); 921 } 922 } 923 924 int SharkBlock::switch_key(int i) { 925 switch(bc()) { 926 case Bytecodes::_tableswitch: 927 return iter()->get_int_table(1) + i; 928 929 case Bytecodes::_lookupswitch: 930 return iter()->get_int_table(2 + 2 * i); 931 932 default: 933 ShouldNotReachHere(); 934 } 935 } 936 937 int SharkBlock::switch_dest(int i) { 938 switch(bc()) { 939 case Bytecodes::_tableswitch: 940 return iter()->get_dest_table(i + 3); 941 942 case Bytecodes::_lookupswitch: 943 return iter()->get_dest_table(2 + 2 * i + 1); 944 945 default: 946 ShouldNotReachHere(); 947 } 948 } 949 950 void SharkBlock::do_div_or_rem(bool is_long, bool is_rem) { 951 SharkValue *sb = pop(); 952 SharkValue *sa = pop(); 953 954 check_divide_by_zero(sb); 955 956 Value *a, *b, *p, *q; 957 if (is_long) { 958 a = sa->jlong_value(); 959 b = sb->jlong_value(); 960 p = LLVMValue::jlong_constant(0x8000000000000000LL); 961 q = LLVMValue::jlong_constant(-1); 962 } 963 else { 964 a = sa->jint_value(); 965 b = sb->jint_value(); 966 p = LLVMValue::jint_constant(0x80000000); 967 q = LLVMValue::jint_constant(-1); 968 } 969 970 BasicBlock *ip = builder()->GetBlockInsertionPoint(); 971 BasicBlock *special_case = builder()->CreateBlock(ip, "special_case"); 972 BasicBlock *general_case = builder()->CreateBlock(ip, "general_case"); 973 BasicBlock *done = builder()->CreateBlock(ip, "done"); 974 975 builder()->CreateCondBr( 976 builder()->CreateAnd( 977 builder()->CreateICmpEQ(a, p), 978 builder()->CreateICmpEQ(b, q)), 979 special_case, general_case); 980 981 builder()->SetInsertPoint(special_case); 982 Value *special_result; 983 if (is_rem) { 984 if (is_long) 985 special_result = LLVMValue::jlong_constant(0); 986 else 987 special_result = LLVMValue::jint_constant(0); 988 } 989 else { 990 special_result = a; 991 } 992 builder()->CreateBr(done); 993 994 builder()->SetInsertPoint(general_case); 995 Value *general_result; 996 if (is_rem) 997 general_result = builder()->CreateSRem(a, b); 998 else 999 general_result = builder()->CreateSDiv(a, b); 1000 builder()->CreateBr(done); 1001 1002 builder()->SetInsertPoint(done); 1003 PHINode *result; 1004 if (is_long) 1005 result = builder()->CreatePHI(SharkType::jlong_type(), 0, "result"); 1006 else 1007 result = builder()->CreatePHI(SharkType::jint_type(), 0, "result"); 1008 result->addIncoming(special_result, special_case); 1009 result->addIncoming(general_result, general_case); 1010 1011 if (is_long) 1012 push(SharkValue::create_jlong(result, false)); 1013 else 1014 push(SharkValue::create_jint(result, false)); 1015 } 1016 1017 void SharkBlock::do_field_access(bool is_get, bool is_field) { 1018 bool will_link; 1019 ciField *field = iter()->get_field(will_link); 1020 assert(will_link, "typeflow responsibility"); 1021 assert(is_field != field->is_static(), "mismatch"); 1022 1023 // Pop the value off the stack where necessary 1024 SharkValue *value = NULL; 1025 if (!is_get) 1026 value = pop(); 1027 1028 // Find the object we're accessing, if necessary 1029 Value *object = NULL; 1030 if (is_field) { 1031 SharkValue *value = pop(); 1032 check_null(value); 1033 object = value->generic_value(); 1034 } 1035 if (is_get && field->is_constant() && field->is_static()) { 1036 SharkConstant *constant = SharkConstant::for_field(iter()); 1037 if (constant->is_loaded()) 1038 value = constant->value(builder()); 1039 } 1040 if (!is_get || value == NULL) { 1041 if (!is_field) { 1042 object = builder()->CreateInlineOop(field->holder()->java_mirror()); 1043 } 1044 BasicType basic_type = field->type()->basic_type(); 1045 Type *stack_type = SharkType::to_stackType(basic_type); 1046 Type *field_type = SharkType::to_arrayType(basic_type); 1047 Type *type = field_type; 1048 if (field->is_volatile()) { 1049 if (field_type == SharkType::jfloat_type()) { 1050 type = SharkType::jint_type(); 1051 } else if (field_type == SharkType::jdouble_type()) { 1052 type = SharkType::jlong_type(); 1053 } 1054 } 1055 Value *addr = builder()->CreateAddressOfStructEntry( 1056 object, in_ByteSize(field->offset_in_bytes()), 1057 PointerType::getUnqual(type), 1058 "addr"); 1059 1060 // Do the access 1061 if (is_get) { 1062 Value* field_value; 1063 if (field->is_volatile()) { 1064 field_value = builder()->CreateAtomicLoad(addr); 1065 field_value = builder()->CreateBitCast(field_value, field_type); 1066 } else { 1067 field_value = builder()->CreateLoad(addr); 1068 } 1069 if (field_type != stack_type) { 1070 field_value = builder()->CreateIntCast( 1071 field_value, stack_type, basic_type != T_CHAR); 1072 } 1073 1074 value = SharkValue::create_generic(field->type(), field_value, false); 1075 } 1076 else { 1077 Value *field_value = value->generic_value(); 1078 1079 if (field_type != stack_type) { 1080 field_value = builder()->CreateIntCast( 1081 field_value, field_type, basic_type != T_CHAR); 1082 } 1083 1084 if (field->is_volatile()) { 1085 field_value = builder()->CreateBitCast(field_value, type); 1086 builder()->CreateAtomicStore(field_value, addr); 1087 } else { 1088 builder()->CreateStore(field_value, addr); 1089 } 1090 1091 if (!field->type()->is_primitive_type()) { 1092 builder()->CreateUpdateBarrierSet(oopDesc::bs(), addr); 1093 } 1094 } 1095 } 1096 1097 // Push the value onto the stack where necessary 1098 if (is_get) 1099 push(value); 1100 } 1101 1102 void SharkBlock::do_lcmp() { 1103 Value *b = pop()->jlong_value(); 1104 Value *a = pop()->jlong_value(); 1105 1106 BasicBlock *ip = builder()->GetBlockInsertionPoint(); 1107 BasicBlock *ne = builder()->CreateBlock(ip, "lcmp_ne"); 1108 BasicBlock *lt = builder()->CreateBlock(ip, "lcmp_lt"); 1109 BasicBlock *gt = builder()->CreateBlock(ip, "lcmp_gt"); 1110 BasicBlock *done = builder()->CreateBlock(ip, "done"); 1111 1112 BasicBlock *eq = builder()->GetInsertBlock(); 1113 builder()->CreateCondBr(builder()->CreateICmpEQ(a, b), done, ne); 1114 1115 builder()->SetInsertPoint(ne); 1116 builder()->CreateCondBr(builder()->CreateICmpSLT(a, b), lt, gt); 1117 1118 builder()->SetInsertPoint(lt); 1119 builder()->CreateBr(done); 1120 1121 builder()->SetInsertPoint(gt); 1122 builder()->CreateBr(done); 1123 1124 builder()->SetInsertPoint(done); 1125 PHINode *result = builder()->CreatePHI(SharkType::jint_type(), 0, "result"); 1126 result->addIncoming(LLVMValue::jint_constant(-1), lt); 1127 result->addIncoming(LLVMValue::jint_constant(0), eq); 1128 result->addIncoming(LLVMValue::jint_constant(1), gt); 1129 1130 push(SharkValue::create_jint(result, false)); 1131 } 1132 1133 void SharkBlock::do_fcmp(bool is_double, bool unordered_is_greater) { 1134 Value *a, *b; 1135 if (is_double) { 1136 b = pop()->jdouble_value(); 1137 a = pop()->jdouble_value(); 1138 } 1139 else { 1140 b = pop()->jfloat_value(); 1141 a = pop()->jfloat_value(); 1142 } 1143 1144 BasicBlock *ip = builder()->GetBlockInsertionPoint(); 1145 BasicBlock *ordered = builder()->CreateBlock(ip, "ordered"); 1146 BasicBlock *ge = builder()->CreateBlock(ip, "fcmp_ge"); 1147 BasicBlock *lt = builder()->CreateBlock(ip, "fcmp_lt"); 1148 BasicBlock *eq = builder()->CreateBlock(ip, "fcmp_eq"); 1149 BasicBlock *gt = builder()->CreateBlock(ip, "fcmp_gt"); 1150 BasicBlock *done = builder()->CreateBlock(ip, "done"); 1151 1152 builder()->CreateCondBr( 1153 builder()->CreateFCmpUNO(a, b), 1154 unordered_is_greater ? gt : lt, ordered); 1155 1156 builder()->SetInsertPoint(ordered); 1157 builder()->CreateCondBr(builder()->CreateFCmpULT(a, b), lt, ge); 1158 1159 builder()->SetInsertPoint(ge); 1160 builder()->CreateCondBr(builder()->CreateFCmpUGT(a, b), gt, eq); 1161 1162 builder()->SetInsertPoint(lt); 1163 builder()->CreateBr(done); 1164 1165 builder()->SetInsertPoint(gt); 1166 builder()->CreateBr(done); 1167 1168 builder()->SetInsertPoint(eq); 1169 builder()->CreateBr(done); 1170 1171 builder()->SetInsertPoint(done); 1172 PHINode *result = builder()->CreatePHI(SharkType::jint_type(), 0, "result"); 1173 result->addIncoming(LLVMValue::jint_constant(-1), lt); 1174 result->addIncoming(LLVMValue::jint_constant(0), eq); 1175 result->addIncoming(LLVMValue::jint_constant(1), gt); 1176 1177 push(SharkValue::create_jint(result, false)); 1178 } 1179 1180 void SharkBlock::emit_IR() { 1181 ShouldNotCallThis(); 1182 } 1183 1184 SharkState* SharkBlock::entry_state() { 1185 ShouldNotCallThis(); 1186 } 1187 1188 void SharkBlock::do_zero_check(SharkValue* value) { 1189 ShouldNotCallThis(); 1190 } 1191 1192 void SharkBlock::maybe_add_backedge_safepoint() { 1193 ShouldNotCallThis(); 1194 } 1195 1196 bool SharkBlock::has_trap() { 1197 return false; 1198 } 1199 1200 int SharkBlock::trap_request() { 1201 ShouldNotCallThis(); 1202 } 1203 1204 int SharkBlock::trap_bci() { 1205 ShouldNotCallThis(); 1206 } 1207 1208 void SharkBlock::do_trap(int trap_request) { 1209 ShouldNotCallThis(); 1210 } 1211 1212 void SharkBlock::do_arraylength() { 1213 ShouldNotCallThis(); 1214 } 1215 1216 void SharkBlock::do_aload(BasicType basic_type) { 1217 ShouldNotCallThis(); 1218 } 1219 1220 void SharkBlock::do_astore(BasicType basic_type) { 1221 ShouldNotCallThis(); 1222 } 1223 1224 void SharkBlock::do_return(BasicType type) { 1225 ShouldNotCallThis(); 1226 } 1227 1228 void SharkBlock::do_athrow() { 1229 ShouldNotCallThis(); 1230 } 1231 1232 void SharkBlock::do_goto() { 1233 ShouldNotCallThis(); 1234 } 1235 1236 void SharkBlock::do_jsr() { 1237 ShouldNotCallThis(); 1238 } 1239 1240 void SharkBlock::do_ret() { 1241 ShouldNotCallThis(); 1242 } 1243 1244 void SharkBlock::do_if(ICmpInst::Predicate p, SharkValue* b, SharkValue* a) { 1245 ShouldNotCallThis(); 1246 } 1247 1248 void SharkBlock::do_switch() { 1249 ShouldNotCallThis(); 1250 } 1251 1252 void SharkBlock::do_call() { 1253 ShouldNotCallThis(); 1254 } 1255 1256 void SharkBlock::do_instance_check() { 1257 ShouldNotCallThis(); 1258 } 1259 1260 bool SharkBlock::maybe_do_instanceof_if() { 1261 ShouldNotCallThis(); 1262 } 1263 1264 void SharkBlock::do_new() { 1265 ShouldNotCallThis(); 1266 } 1267 1268 void SharkBlock::do_newarray() { 1269 ShouldNotCallThis(); 1270 } 1271 1272 void SharkBlock::do_anewarray() { 1273 ShouldNotCallThis(); 1274 } 1275 1276 void SharkBlock::do_multianewarray() { 1277 ShouldNotCallThis(); 1278 } 1279 1280 void SharkBlock::do_monitorenter() { 1281 ShouldNotCallThis(); 1282 } 1283 1284 void SharkBlock::do_monitorexit() { 1285 ShouldNotCallThis(); 1286 }