1 /* 2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @bug 6934604 27 * @summary enable parts of EliminateAutoBox by default 28 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestLongBoxing 29 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox 30 * -XX:CompileCommand=exclude,TestLongBoxing.dummy -XX:CompileCommand=exclude,TestLongBoxing.foo -XX:CompileCommand=exclude,TestLongBoxing.foob TestLongBoxing 31 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox 32 * -XX:CompileCommand=exclude,TestLongBoxing.dummy -XX:CompileCommand=exclude,TestLongBoxing.foo -XX:CompileCommand=exclude,TestLongBoxing.foob TestLongBoxing 33 * 34 */ 35 36 public class TestLongBoxing { 37 38 static final Long ibc = new Long(1); 39 40 //=============================================== 41 // Non-inlined methods to test deoptimization info 42 static void dummy() { } 43 static long foo(long i) { return i; } 44 static Long foob(long i) { return Long.valueOf(i); } 45 46 47 static long simple(long i) { 48 Long ib = new Long(i); 49 return ib; 50 } 51 52 static long simpleb(long i) { 53 Long ib = Long.valueOf(i); 54 return ib; 55 } 56 57 static long simplec() { 58 Long ib = ibc; 59 return ib; 60 } 61 62 static long simplef(long i) { 63 Long ib = foob(i); 64 return ib; 65 } 66 67 static long simplep(Long ib) { 68 return ib; 69 } 70 71 static long simple2(long i) { 72 Long ib1 = new Long(i); 73 Long ib2 = new Long(i+1); 74 return ib1 + ib2; 75 } 76 77 static long simpleb2(long i) { 78 Long ib1 = Long.valueOf(i); 79 Long ib2 = Long.valueOf(i+1); 80 return ib1 + ib2; 81 } 82 83 static long simplem2(long i) { 84 Long ib1 = new Long(i); 85 Long ib2 = Long.valueOf(i+1); 86 return ib1 + ib2; 87 } 88 89 static long simplep2(long i, Long ib1) { 90 Long ib2 = Long.valueOf(i+1); 91 return ib1 + ib2; 92 } 93 94 static long simplec2(long i) { 95 Long ib1 = ibc; 96 Long ib2 = Long.valueOf(i+1); 97 return ib1 + ib2; 98 } 99 100 //=============================================== 101 static long test(long i) { 102 Long ib = new Long(i); 103 if ((i&1) == 0) 104 ib = i+1; 105 return ib; 106 } 107 108 static long testb(long i) { 109 Long ib = i; 110 if ((i&1) == 0) 111 ib = (i+1); 112 return ib; 113 } 114 115 static long testm(long i) { 116 Long ib = i; 117 if ((i&1) == 0) 118 ib = new Long(i+1); 119 return ib; 120 } 121 122 static long testp(long i, Long ib) { 123 if ((i&1) == 0) 124 ib = new Long(i+1); 125 return ib; 126 } 127 128 static long testc(long i) { 129 Long ib = ibc; 130 if ((i&1) == 0) 131 ib = new Long(i+1); 132 return ib; 133 } 134 135 static long test2(long i) { 136 Long ib1 = new Long(i); 137 Long ib2 = new Long(i+1); 138 if ((i&1) == 0) { 139 ib1 = new Long(i+1); 140 ib2 = new Long(i+2); 141 } 142 return ib1+ib2; 143 } 144 145 static long testb2(long i) { 146 Long ib1 = i; 147 Long ib2 = i+1; 148 if ((i&1) == 0) { 149 ib1 = (i+1); 150 ib2 = (i+2); 151 } 152 return ib1+ib2; 153 } 154 155 static long testm2(long i) { 156 Long ib1 = new Long(i); 157 Long ib2 = i+1; 158 if ((i&1) == 0) { 159 ib1 = new Long(i+1); 160 ib2 = (i+2); 161 } 162 return ib1+ib2; 163 } 164 165 static long testp2(long i, Long ib1) { 166 Long ib2 = i+1; 167 if ((i&1) == 0) { 168 ib1 = new Long(i+1); 169 ib2 = (i+2); 170 } 171 return ib1+ib2; 172 } 173 174 static long testc2(long i) { 175 Long ib1 = ibc; 176 Long ib2 = i+1; 177 if ((i&1) == 0) { 178 ib1 = (ibc+1); 179 ib2 = (i+2); 180 } 181 return ib1+ib2; 182 } 183 184 //=============================================== 185 static long sum(long[] a) { 186 long result = 1; 187 for (Long i : a) 188 result += i; 189 return result; 190 } 191 192 static long sumb(long[] a) { 193 Long result = 1l; 194 for (Long i : a) 195 result += i; 196 return result; 197 } 198 199 static long sumc(long[] a) { 200 Long result = ibc; 201 for (Long i : a) 202 result += i; 203 return result; 204 } 205 206 static long sumf(long[] a) { 207 Long result = foob(1); 208 for (Long i : a) 209 result += i; 210 return result; 211 } 212 213 static long sump(long[] a, Long result) { 214 for (Long i : a) 215 result += i; 216 return result; 217 } 218 219 static long sum2(long[] a) { 220 long result1 = 1; 221 long result2 = 1; 222 for (Long i : a) { 223 result1 += i; 224 result2 += i + 1; 225 } 226 return result1 + result2; 227 } 228 229 static long sumb2(long[] a) { 230 Long result1 = 1l; 231 Long result2 = 1l; 232 for (Long i : a) { 233 result1 += i; 234 result2 += i + 1; 235 } 236 return result1 + result2; 237 } 238 239 static long summ2(long[] a) { 240 Long result1 = 1l; 241 Long result2 = new Long(1); 242 for (Long i : a) { 243 result1 += i; 244 result2 += new Long(i + 1); 245 } 246 return result1 + result2; 247 } 248 249 static long sump2(long[] a, Long result2) { 250 Long result1 = 1l; 251 for (Long i : a) { 252 result1 += i; 253 result2 += i + 1; 254 } 255 return result1 + result2; 256 } 257 258 static long sumc2(long[] a) { 259 Long result1 = 1l; 260 Long result2 = ibc; 261 for (Long i : a) { 262 result1 += i; 263 result2 += i + ibc; 264 } 265 return result1 + result2; 266 } 267 268 //=============================================== 269 static long remi_sum() { 270 Long j = new Long(1); 271 for (int i = 0; i< 1000; i++) { 272 j = new Long(j + 1); 273 } 274 return j; 275 } 276 277 static long remi_sumb() { 278 Long j = Long.valueOf(1); 279 for (int i = 0; i< 1000; i++) { 280 j = j + 1; 281 } 282 return j; 283 } 284 285 static long remi_sumf() { 286 Long j = foob(1); 287 for (int i = 0; i< 1000; i++) { 288 j = j + 1; 289 } 290 return j; 291 } 292 293 static long remi_sump(Long j) { 294 for (int i = 0; i< 1000; i++) { 295 j = new Long(j + 1); 296 } 297 return j; 298 } 299 300 static long remi_sumc() { 301 Long j = ibc; 302 for (int i = 0; i< 1000; i++) { 303 j = j + ibc; 304 } 305 return j; 306 } 307 308 static long remi_sum2() { 309 Long j1 = new Long(1); 310 Long j2 = new Long(1); 311 for (int i = 0; i< 1000; i++) { 312 j1 = new Long(j1 + 1); 313 j2 = new Long(j2 + 2); 314 } 315 return j1 + j2; 316 } 317 318 static long remi_sumb2() { 319 Long j1 = Long.valueOf(1); 320 Long j2 = Long.valueOf(1); 321 for (int i = 0; i< 1000; i++) { 322 j1 = j1 + 1; 323 j2 = j2 + 2; 324 } 325 return j1 + j2; 326 } 327 328 static long remi_summ2() { 329 Long j1 = new Long(1); 330 Long j2 = Long.valueOf(1); 331 for (int i = 0; i< 1000; i++) { 332 j1 = new Long(j1 + 1); 333 j2 = j2 + 2; 334 } 335 return j1 + j2; 336 } 337 338 static long remi_sump2(Long j1) { 339 Long j2 = Long.valueOf(1); 340 for (int i = 0; i< 1000; i++) { 341 j1 = new Long(j1 + 1); 342 j2 = j2 + 2; 343 } 344 return j1 + j2; 345 } 346 347 static long remi_sumc2() { 348 Long j1 = ibc; 349 Long j2 = Long.valueOf(1); 350 for (int i = 0; i< 1000; i++) { 351 j1 = j1 + ibc; 352 j2 = j2 + 2; 353 } 354 return j1 + j2; 355 } 356 357 358 //=============================================== 359 // Safepointa and debug info for deoptimization 360 static long simple_deop(long i) { 361 Long ib = new Long(foo(i)); 362 dummy(); 363 return ib; 364 } 365 366 static long simpleb_deop(long i) { 367 Long ib = Long.valueOf(foo(i)); 368 dummy(); 369 return ib; 370 } 371 372 static long simplef_deop(long i) { 373 Long ib = foob(i); 374 dummy(); 375 return ib; 376 } 377 378 static long simplep_deop(Long ib) { 379 dummy(); 380 return ib; 381 } 382 383 static long simplec_deop(long i) { 384 Long ib = ibc; 385 dummy(); 386 return ib; 387 } 388 389 static long test_deop(long i) { 390 Long ib = new Long(foo(i)); 391 if ((i&1) == 0) 392 ib = foo(i+1); 393 dummy(); 394 return ib; 395 } 396 397 static long testb_deop(long i) { 398 Long ib = foo(i); 399 if ((i&1) == 0) 400 ib = foo(i+1); 401 dummy(); 402 return ib; 403 } 404 405 static long testf_deop(long i) { 406 Long ib = foob(i); 407 if ((i&1) == 0) 408 ib = foo(i+1); 409 dummy(); 410 return ib; 411 } 412 413 static long testp_deop(long i, Long ib) { 414 if ((i&1) == 0) 415 ib = foo(i+1); 416 dummy(); 417 return ib; 418 } 419 420 static long testc_deop(long i) { 421 Long ib = ibc; 422 if ((i&1) == 0) 423 ib = foo(i+1); 424 dummy(); 425 return ib; 426 } 427 428 static long sum_deop(long[] a) { 429 long result = 1; 430 for (Long i : a) 431 result += foo(i); 432 dummy(); 433 return result; 434 } 435 436 static long sumb_deop(long[] a) { 437 Long result = 1l; 438 for (Long i : a) 439 result += foo(i); 440 dummy(); 441 return result; 442 } 443 444 static long sumf_deop(long[] a) { 445 Long result = 1l; 446 for (Long i : a) 447 result += foob(i); 448 dummy(); 449 return result; 450 } 451 452 static long sump_deop(long[] a, Long result) { 453 for (Long i : a) 454 result += foob(i); 455 dummy(); 456 return result; 457 } 458 459 static long sumc_deop(long[] a) { 460 Long result = ibc; 461 for (Long i : a) 462 result += foo(i); 463 dummy(); 464 return result; 465 } 466 467 static long remi_sum_deop() { 468 Long j = new Long(foo(1)); 469 for (int i = 0; i< 1000; i++) { 470 j = new Long(foo(j + 1)); 471 } 472 dummy(); 473 return j; 474 } 475 476 static long remi_sumb_deop() { 477 Long j = Long.valueOf(foo(1)); 478 for (int i = 0; i< 1000; i++) { 479 j = foo(j + 1); 480 } 481 dummy(); 482 return j; 483 } 484 485 static long remi_sumf_deop() { 486 Long j = foob(1); 487 for (int i = 0; i< 1000; i++) { 488 j = foo(j + 1); 489 } 490 dummy(); 491 return j; 492 } 493 494 static long remi_sump_deop(Long j) { 495 for (int i = 0; i< 1000; i++) { 496 j = foo(j + 1); 497 } 498 dummy(); 499 return j; 500 } 501 502 static long remi_sumc_deop() { 503 Long j = ibc; 504 for (int i = 0; i< 1000; i++) { 505 j = foo(j + 1); 506 } 507 dummy(); 508 return j; 509 } 510 511 //=============================================== 512 // Conditional increment 513 static long remi_sum_cond() { 514 Long j = new Long(1); 515 for (int i = 0; i< 1000; i++) { 516 if ((i&1) == 0) { 517 j = new Long(j + 1); 518 } 519 } 520 return j; 521 } 522 523 static long remi_sumb_cond() { 524 Long j = Long.valueOf(1); 525 for (int i = 0; i< 1000; i++) { 526 if ((i&1) == 0) { 527 j = j + 1; 528 } 529 } 530 return j; 531 } 532 533 static long remi_sumf_cond() { 534 Long j = foob(1); 535 for (int i = 0; i< 1000; i++) { 536 if ((i&1) == 0) { 537 j = j + 1; 538 } 539 } 540 return j; 541 } 542 543 static long remi_sump_cond(Long j) { 544 for (int i = 0; i< 1000; i++) { 545 if ((i&1) == 0) { 546 j = j + 1; 547 } 548 } 549 return j; 550 } 551 552 static long remi_sumc_cond() { 553 Long j = ibc; 554 for (int i = 0; i< 1000; i++) { 555 if ((i&1) == 0) { 556 j = j + ibc; 557 } 558 } 559 return j; 560 } 561 562 static long remi_sum2_cond() { 563 Long j1 = new Long(1); 564 Long j2 = new Long(1); 565 for (int i = 0; i< 1000; i++) { 566 if ((i&1) == 0) { 567 j1 = new Long(j1 + 1); 568 } else { 569 j2 = new Long(j2 + 2); 570 } 571 } 572 return j1 + j2; 573 } 574 575 static long remi_sumb2_cond() { 576 Long j1 = Long.valueOf(1); 577 Long j2 = Long.valueOf(1); 578 for (int i = 0; i< 1000; i++) { 579 if ((i&1) == 0) { 580 j1 = j1 + 1; 581 } else { 582 j2 = j2 + 2; 583 } 584 } 585 return j1 + j2; 586 } 587 588 static long remi_summ2_cond() { 589 Long j1 = new Long(1); 590 Long j2 = Long.valueOf(1); 591 for (int i = 0; i< 1000; i++) { 592 if ((i&1) == 0) { 593 j1 = new Long(j1 + 1); 594 } else { 595 j2 = j2 + 2; 596 } 597 } 598 return j1 + j2; 599 } 600 601 static long remi_sump2_cond(Long j1) { 602 Long j2 = Long.valueOf(1); 603 for (int i = 0; i< 1000; i++) { 604 if ((i&1) == 0) { 605 j1 = new Long(j1 + 1); 606 } else { 607 j2 = j2 + 2; 608 } 609 } 610 return j1 + j2; 611 } 612 613 static long remi_sumc2_cond() { 614 Long j1 = ibc; 615 Long j2 = Long.valueOf(1); 616 for (int i = 0; i< 1000; i++) { 617 if ((i&1) == 0) { 618 j1 = j1 + ibc; 619 } else { 620 j2 = j2 + 2; 621 } 622 } 623 return j1 + j2; 624 } 625 626 627 public static void main(String[] args) { 628 final int ntests = 70; 629 630 String[] test_name = new String[] { 631 "simple", "simpleb", "simplec", "simplef", "simplep", 632 "simple2", "simpleb2", "simplec2", "simplem2", "simplep2", 633 "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop", 634 "test", "testb", "testc", "testm", "testp", 635 "test2", "testb2", "testc2", "testm2", "testp2", 636 "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop", 637 "sum", "sumb", "sumc", "sumf", "sump", 638 "sum2", "sumb2", "sumc2", "summ2", "sump2", 639 "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop", 640 "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump", 641 "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2", 642 "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop", 643 "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond", 644 "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond" 645 }; 646 647 final long[] val = new long[] { 648 71994000, 71994000, 12000, 71994000, 71994000, 649 144000000, 144000000, 72018000, 144000000, 144000000, 650 71994000, 71994000, 12000, 71994000, 71994000, 651 72000000, 72000000, 36006000, 72000000, 72000000, 652 144012000, 144012000, 72030000, 144012000, 144012000, 653 72000000, 72000000, 36006000, 72000000, 72000000, 654 499501, 499501, 499501, 499501, 499501, 655 1000002, 1000002, 1000002, 1000002, 1000002, 656 499501, 499501, 499501, 499501, 499501, 657 1001, 1001, 1001, 1001, 1001, 658 3002, 3002, 3002, 3002, 3002, 659 1001, 1001, 1001, 1001, 1001, 660 501, 501, 501, 501, 501, 661 1502, 1502, 1502, 1502, 1502 662 }; 663 664 long[] res = new long[ntests]; 665 for (int i = 0; i < ntests; i++) { 666 res[i] = 0; 667 } 668 669 670 for (long i = 0; i < 12000; i++) { 671 res[0] += simple(i); 672 res[1] += simpleb(i); 673 res[2] += simplec(); 674 res[3] += simplef(i); 675 res[4] += simplep(i); 676 677 res[5] += simple2(i); 678 res[6] += simpleb2(i); 679 res[7] += simplec2(i); 680 res[8] += simplem2(i); 681 res[9] += simplep2(i, i); 682 683 res[10] += simple_deop(i); 684 res[11] += simpleb_deop(i); 685 res[12] += simplec_deop(i); 686 res[13] += simplef_deop(i); 687 res[14] += simplep_deop(i); 688 689 res[15] += test(i); 690 res[16] += testb(i); 691 res[17] += testc(i); 692 res[18] += testm(i); 693 res[19] += testp(i, i); 694 695 res[20] += test2(i); 696 res[21] += testb2(i); 697 res[22] += testc2(i); 698 res[23] += testm2(i); 699 res[24] += testp2(i, i); 700 701 res[25] += test_deop(i); 702 res[26] += testb_deop(i); 703 res[27] += testc_deop(i); 704 res[28] += testf_deop(i); 705 res[29] += testp_deop(i, i); 706 } 707 708 long[] ia = new long[1000]; 709 for (int i = 0; i < 1000; i++) { 710 ia[i] = i; 711 } 712 713 for (int i = 0; i < 100; i++) { 714 res[30] = sum(ia); 715 res[31] = sumb(ia); 716 res[32] = sumc(ia); 717 res[33] = sumf(ia); 718 res[34] = sump(ia, (long)1); 719 720 res[35] = sum2(ia); 721 res[36] = sumb2(ia); 722 res[37] = sumc2(ia); 723 res[38] = summ2(ia); 724 res[39] = sump2(ia, (long)1); 725 726 res[40] = sum_deop(ia); 727 res[41] = sumb_deop(ia); 728 res[42] = sumc_deop(ia); 729 res[43] = sumf_deop(ia); 730 res[44] = sump_deop(ia, (long)1); 731 732 res[45] = remi_sum(); 733 res[46] = remi_sumb(); 734 res[47] = remi_sumc(); 735 res[48] = remi_sumf(); 736 res[49] = remi_sump((long)1); 737 738 res[50] = remi_sum2(); 739 res[51] = remi_sumb2(); 740 res[52] = remi_sumc2(); 741 res[53] = remi_summ2(); 742 res[54] = remi_sump2((long)1); 743 744 res[55] = remi_sum_deop(); 745 res[56] = remi_sumb_deop(); 746 res[57] = remi_sumc_deop(); 747 res[58] = remi_sumf_deop(); 748 res[59] = remi_sump_deop((long)1); 749 750 res[60] = remi_sum_cond(); 751 res[61] = remi_sumb_cond(); 752 res[62] = remi_sumc_cond(); 753 res[63] = remi_sumf_cond(); 754 res[64] = remi_sump_cond((long)1); 755 756 res[65] = remi_sum2_cond(); 757 res[66] = remi_sumb2_cond(); 758 res[67] = remi_sumc2_cond(); 759 res[68] = remi_summ2_cond(); 760 res[69] = remi_sump2_cond((long)1); 761 } 762 763 int failed = 0; 764 for (int i = 0; i < ntests; i++) { 765 if (res[i] != val[i]) { 766 System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]); 767 failed++; 768 } 769 } 770 if (failed > 0) { 771 System.err.println("Failed " + failed + " tests."); 772 throw new InternalError(); 773 } else { 774 System.out.println("Passed."); 775 } 776 } 777 }