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