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