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 TestIntBoxing
  29  * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
  30  * -XX:CompileCommand=exclude,TestIntBoxing.dummy -XX:CompileCommand=exclude,TestIntBoxing.foo -XX:CompileCommand=exclude,TestIntBoxing.foob TestIntBoxing
  31  * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
  32  * -XX:CompileCommand=exclude,TestIntBoxing.dummy -XX:CompileCommand=exclude,TestIntBoxing.foo -XX:CompileCommand=exclude,TestIntBoxing.foob TestIntBoxing
  33  *
  34  */
  35 
  36 public class TestIntBoxing {
  37 
  38   static final Integer ibc = new Integer(1);
  39 
  40   //===============================================
  41   // Non-inlined methods to test deoptimization info
  42   static void    dummy()     { }
  43   static int     foo(int i)  { return i; }
  44   static Integer foob(int i) { return Integer.valueOf(i); }
  45 
  46 
  47   static int simple(int i) {
  48     Integer ib = new Integer(i);
  49     return ib;
  50   }
  51 
  52   static int simpleb(int i) {
  53     Integer ib = Integer.valueOf(i);
  54     return ib;
  55   }
  56 
  57   static int simplec() {
  58     Integer ib = ibc;
  59     return ib;
  60   }
  61 
  62   static int simplef(int i) {
  63     Integer ib = foob(i);
  64     return ib;
  65   }
  66 
  67   static int simplep(Integer ib) {
  68     return ib;
  69   }
  70 
  71   static int simple2(int i) {
  72     Integer ib1 = new Integer(i);
  73     Integer ib2 = new Integer(i+1);
  74     return ib1 + ib2;
  75   }
  76 
  77   static int simpleb2(int i) {
  78     Integer ib1 = Integer.valueOf(i);
  79     Integer ib2 = Integer.valueOf(i+1);
  80     return ib1 + ib2;
  81   }
  82 
  83   static int simplem2(int i) {
  84     Integer ib1 = new Integer(i);
  85     Integer ib2 = Integer.valueOf(i+1);
  86     return ib1 + ib2;
  87   }
  88 
  89   static int simplep2(int i, Integer ib1) {
  90     Integer ib2 = Integer.valueOf(i+1);
  91     return ib1 + ib2;
  92   }
  93 
  94   static int simplec2(int i) {
  95     Integer ib1 = ibc;
  96     Integer ib2 = Integer.valueOf(i+1);
  97     return ib1 + ib2;
  98   }
  99 
 100   //===============================================
 101   static int test(int i) {
 102     Integer ib = new Integer(i);
 103     if ((i&1) == 0)
 104       ib = i+1;
 105     return ib;
 106   }
 107 
 108   static int testb(int i) {
 109     Integer ib = i;
 110     if ((i&1) == 0)
 111       ib = (i+1);
 112     return ib;
 113   }
 114 
 115   static int testm(int i) {
 116     Integer ib = i;
 117     if ((i&1) == 0)
 118       ib = new Integer(i+1);
 119     return ib;
 120   }
 121 
 122   static int testp(int i, Integer ib) {
 123     if ((i&1) == 0)
 124       ib = new Integer(i+1);
 125     return ib;
 126   }
 127 
 128   static int testc(int i) {
 129     Integer ib = ibc;
 130     if ((i&1) == 0)
 131       ib = new Integer(i+1);
 132     return ib;
 133   }
 134 
 135   static int test2(int i) {
 136     Integer ib1 = new Integer(i);
 137     Integer ib2 = new Integer(i+1);
 138     if ((i&1) == 0) {
 139       ib1 = new Integer(i+1);
 140       ib2 = new Integer(i+2);
 141     }
 142     return ib1+ib2;
 143   }
 144 
 145   static int testb2(int i) {
 146     Integer ib1 = i;
 147     Integer 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 int testm2(int i) {
 156     Integer ib1 = new Integer(i);
 157     Integer ib2 = i+1;
 158     if ((i&1) == 0) {
 159       ib1 = new Integer(i+1);
 160       ib2 = (i+2);
 161     }
 162     return ib1+ib2;
 163   }
 164 
 165   static int testp2(int i, Integer ib1) {
 166     Integer ib2 = i+1;
 167     if ((i&1) == 0) {
 168       ib1 = new Integer(i+1);
 169       ib2 = (i+2);
 170     }
 171     return ib1+ib2;
 172   }
 173 
 174   static int testc2(int i) {
 175     Integer ib1 = ibc;
 176     Integer 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 int sum(int[] a) {
 186     int result = 1;
 187     for (Integer i : a)
 188         result += i;
 189     return result;
 190   }
 191 
 192   static int sumb(int[] a) {
 193     Integer result = 1;
 194     for (Integer i : a)
 195         result += i;
 196     return result;
 197   }
 198 
 199   static int sumc(int[] a) {
 200     Integer result = ibc;
 201     for (Integer i : a)
 202         result += i;
 203     return result;
 204   }
 205 
 206   static int sumf(int[] a) {
 207     Integer result = foob(1);
 208     for (Integer i : a)
 209         result += i;
 210     return result;
 211   }
 212 
 213   static int sump(int[] a, Integer result) {
 214     for (Integer i : a)
 215         result += i;
 216     return result;
 217   }
 218 
 219   static int sum2(int[] a) {
 220     int result1 = 1;
 221     int result2 = 1;
 222     for (Integer i : a) {
 223         result1 += i;
 224         result2 += i + 1;
 225     }
 226     return result1 + result2;
 227   }
 228 
 229   static int sumb2(int[] a) {
 230     Integer result1 = 1;
 231     Integer result2 = 1;
 232     for (Integer i : a) {
 233         result1 += i;
 234         result2 += i + 1;
 235     }
 236     return result1 + result2;
 237   }
 238 
 239   static int summ2(int[] a) {
 240     Integer result1 = 1;
 241     Integer result2 = new Integer(1);
 242     for (Integer i : a) {
 243         result1 += i;
 244         result2 += new Integer(i + 1);
 245     }
 246     return result1 + result2;
 247   }
 248 
 249   static int sump2(int[] a, Integer result2) {
 250     Integer result1 = 1;
 251     for (Integer i : a) {
 252         result1 += i;
 253         result2 += i + 1;
 254     }
 255     return result1 + result2;
 256   }
 257 
 258   static int sumc2(int[] a) {
 259     Integer result1 = 1;
 260     Integer result2 = ibc;
 261     for (Integer i : a) {
 262         result1 += i;
 263         result2 += i + ibc;
 264     }
 265     return result1 + result2;
 266   }
 267 
 268   //===============================================
 269   static int remi_sum() {
 270     Integer j = new Integer(1);
 271     for (int i = 0; i< 1000; i++) {
 272       j = new Integer(j + 1);
 273     }
 274     return j;
 275   }
 276 
 277   static int remi_sumb() {
 278     Integer j = Integer.valueOf(1);
 279     for (int i = 0; i< 1000; i++) {
 280       j = j + 1;
 281     }
 282     return j;
 283   }
 284 
 285   static int remi_sumf() {
 286     Integer j = foob(1);
 287     for (int i = 0; i< 1000; i++) {
 288       j = j + 1;
 289     }
 290     return j;
 291   }
 292 
 293   static int remi_sump(Integer j) {
 294     for (int i = 0; i< 1000; i++) {
 295       j = new Integer(j + 1);
 296     }
 297     return j;
 298   }
 299 
 300   static int remi_sumc() {
 301     Integer j = ibc;
 302     for (int i = 0; i< 1000; i++) {
 303       j = j + ibc;
 304     }
 305     return j;
 306   }
 307 
 308   static int remi_sum2() {
 309     Integer j1 = new Integer(1);
 310     Integer j2 = new Integer(1);
 311     for (int i = 0; i< 1000; i++) {
 312       j1 = new Integer(j1 + 1);
 313       j2 = new Integer(j2 + 2);
 314     }
 315     return j1 + j2;
 316   }
 317 
 318   static int remi_sumb2() {
 319     Integer j1 = Integer.valueOf(1);
 320     Integer j2 = Integer.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 int remi_summ2() {
 329     Integer j1 = new Integer(1);
 330     Integer j2 = Integer.valueOf(1);
 331     for (int i = 0; i< 1000; i++) {
 332       j1 = new Integer(j1 + 1);
 333       j2 = j2 + 2;
 334     }
 335     return j1 + j2;
 336   }
 337 
 338   static int remi_sump2(Integer j1) {
 339     Integer j2 = Integer.valueOf(1);
 340     for (int i = 0; i< 1000; i++) {
 341       j1 = new Integer(j1 + 1);
 342       j2 = j2 + 2;
 343     }
 344     return j1 + j2;
 345   }
 346 
 347   static int remi_sumc2() {
 348     Integer j1 = ibc;
 349     Integer j2 = Integer.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 int simple_deop(int i) {
 361     Integer ib = new Integer(foo(i));
 362     dummy();
 363     return ib;
 364   }
 365 
 366   static int simpleb_deop(int i) {
 367     Integer ib = Integer.valueOf(foo(i));
 368     dummy();
 369     return ib;
 370   }
 371 
 372   static int simplef_deop(int i) {
 373     Integer ib = foob(i);
 374     dummy();
 375     return ib;
 376   }
 377 
 378   static int simplep_deop(Integer ib) {
 379     dummy();
 380     return ib;
 381   }
 382 
 383   static int simplec_deop(int i) {
 384     Integer ib = ibc;
 385     dummy();
 386     return ib;
 387   }
 388 
 389   static int test_deop(int i) {
 390     Integer ib = new Integer(foo(i));
 391     if ((i&1) == 0)
 392       ib = foo(i+1);
 393     dummy();
 394     return ib;
 395   }
 396 
 397   static int testb_deop(int i) {
 398     Integer ib = foo(i);
 399     if ((i&1) == 0)
 400       ib = foo(i+1);
 401     dummy();
 402     return ib;
 403   }
 404 
 405   static int testf_deop(int i) {
 406     Integer ib = foob(i);
 407     if ((i&1) == 0)
 408       ib = foo(i+1);
 409     dummy();
 410     return ib;
 411   }
 412 
 413   static int testp_deop(int i, Integer ib) {
 414     if ((i&1) == 0)
 415       ib = foo(i+1);
 416     dummy();
 417     return ib;
 418   }
 419 
 420   static int testc_deop(int i) {
 421     Integer ib = ibc;
 422     if ((i&1) == 0)
 423       ib = foo(i+1);
 424     dummy();
 425     return ib;
 426   }
 427 
 428   static int sum_deop(int[] a) {
 429     int result = 1;
 430     for (Integer i : a)
 431         result += foo(i);
 432     dummy();
 433     return result;
 434   }
 435 
 436   static int sumb_deop(int[] a) {
 437     Integer result = 1;
 438     for (Integer i : a)
 439         result += foo(i);
 440     dummy();
 441     return result;
 442   }
 443 
 444   static int sumf_deop(int[] a) {
 445     Integer result = 1;
 446     for (Integer i : a)
 447         result += foob(i);
 448     dummy();
 449     return result;
 450   }
 451 
 452   static int sump_deop(int[] a, Integer result) {
 453     for (Integer i : a)
 454         result += foob(i);
 455     dummy();
 456     return result;
 457   }
 458 
 459   static int sumc_deop(int[] a) {
 460     Integer result = ibc;
 461     for (Integer i : a)
 462         result += foo(i);
 463     dummy();
 464     return result;
 465   }
 466 
 467   static int remi_sum_deop() {
 468     Integer j = new Integer(foo(1));
 469     for (int i = 0; i< 1000; i++) {
 470       j = new Integer(foo(j + 1));
 471     }
 472     dummy();
 473     return j;
 474   }
 475 
 476   static int remi_sumb_deop() {
 477     Integer j = Integer.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 int remi_sumf_deop() {
 486     Integer 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 int remi_sump_deop(Integer j) {
 495     for (int i = 0; i< 1000; i++) {
 496       j = foo(j + 1);
 497     }
 498     dummy();
 499     return j;
 500   }
 501 
 502   static int remi_sumc_deop() {
 503     Integer 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 int remi_sum_cond() {
 514     Integer j = new Integer(1);
 515     for (int i = 0; i< 1000; i++) {
 516       if ((i&1) == 0) {
 517         j = new Integer(j + 1);
 518       }
 519     }
 520     return j;
 521   }
 522 
 523   static int remi_sumb_cond() {
 524     Integer j = Integer.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 int remi_sumf_cond() {
 534     Integer 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 int remi_sump_cond(Integer 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 int remi_sumc_cond() {
 553     Integer 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 int remi_sum2_cond() {
 563     Integer j1 = new Integer(1);
 564     Integer j2 = new Integer(1);
 565     for (int i = 0; i< 1000; i++) {
 566       if ((i&1) == 0) {
 567         j1 = new Integer(j1 + 1);
 568       } else {
 569         j2 = new Integer(j2 + 2);
 570       }
 571     }
 572     return j1 + j2;
 573   }
 574 
 575   static int remi_sumb2_cond() {
 576     Integer j1 = Integer.valueOf(1);
 577     Integer j2 = Integer.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 int remi_summ2_cond() {
 589     Integer j1 = new Integer(1);
 590     Integer j2 = Integer.valueOf(1);
 591     for (int i = 0; i< 1000; i++) {
 592       if ((i&1) == 0) {
 593         j1 = new Integer(j1 + 1);
 594       } else {
 595         j2 = j2 + 2;
 596       }
 597     }
 598     return j1 + j2;
 599   }
 600 
 601   static int remi_sump2_cond(Integer j1) {
 602     Integer j2 = Integer.valueOf(1);
 603     for (int i = 0; i< 1000; i++) {
 604       if ((i&1) == 0) {
 605         j1 = new Integer(j1 + 1);
 606       } else {
 607         j2 = j2 + 2;
 608       }
 609     }
 610     return j1 + j2;
 611   }
 612 
 613   static int remi_sumc2_cond() {
 614     Integer j1 = ibc;
 615     Integer j2 = Integer.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 int[] val = new int[] {
 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     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(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     int[] ia = new int[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, 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, 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, 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(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(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(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(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(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 }