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 8024070

    27  * @summary Test that type speculation doesn't cause incorrect execution

    28  * @run main/othervm -XX:-UseOnStackReplacement -XX:-BackgroundCompilation -XX:TypeProfileLevel=222 TypeSpeculation

    29  *

    30  */

    31 

    32 public class TypeSpeculation {

    33 

    34     interface I {

    35     }

    36 

    37     static class A {

    38         int m() {

    39             return 1;

    40         }

    41     }

    42 

    43     static class B extends A implements I {

    44         int m() {

    45             return 2;

    46         }

    47     }

    48 

    49     static class C extends B {

    50         int m() {

    51             return 3;

    52         }

    53     }

    54 

    55     static int test1_invokevirtual(A a) {

    56         return a.m();

    57     }

    58 

    59     static int test1_1(A a) {

    60         return test1_invokevirtual(a);

    61     }

    62 

    63     static boolean test1() {

    64         A a = new A();

    65         B b = new B();

    66         C c = new C();

    67 

    68         // pollute profile at test1_invokevirtual to make sure the

    69         // compiler cannot rely on it

    70         for (int i = 0; i < 5000; i++) {

    71             test1_invokevirtual(a);

    72             test1_invokevirtual(b);

    73             test1_invokevirtual(c);

    74         }

    75 

    76         // profiling + speculation should make test1_invokevirtual

    77         // inline A.m() with a guard

    78         for (int i = 0; i < 20000; i++) {

    79             int res = test1_1(b);

    80             if (res != b.m()) {

    81                 System.out.println("test1 failed with class B");

    82                 return false;

    83             }

    84         }

    85         // check that the guard works as expected by passing a

    86         // different type

    87         int res = test1_1(a);

    88         if (res != a.m()) {

    89             System.out.println("test1 failed with class A");

    90             return false;

    91         }

    92         return true;

    93     }

    94 

    95     static int test2_invokevirtual(A a) {

    96         return a.m();

    97     }

    98 

    99     static int test2_1(A a, boolean t) {

   100         A aa;

   101         if (t) {

   102             aa = (B)a;

   103         } else {

   104             aa = a;

   105         }

   106         // if a of type B is passed to test2_1, the static type of aa

   107         // here is no better than A but the profiled type is B so this

   108         // should inline

   109         return test2_invokevirtual(aa);

   110     }

   111 

   112     static boolean test2() {

   113         A a = new A();

   114         B b = new B();

   115         C c = new C();

   116 

   117         // pollute profile at test2_invokevirtual to make sure the

   118         // compiler cannot rely on it

   119         for (int i = 0; i < 5000; i++) {

   120             test2_invokevirtual(a);

   121             test2_invokevirtual(b);

   122             test2_invokevirtual(c);

   123         }

   124 

   125         // profiling + speculation should make test2_invokevirtual

   126         // inline A.m() with a guard

   127         for (int i = 0; i < 20000; i++) {

   128             int res = test2_1(b, (i % 2) == 0);

   129             if (res != b.m()) {

   130                 System.out.println("test2 failed with class B");

   131                 return false;

   132             }

   133         }

   134         // check that the guard works as expected by passing a

   135         // different type

   136         int res = test2_1(a, false);

   137         if (res != a.m()) {

   138             System.out.println("test2 failed with class A");

   139             return false;

   140         }

   141         return true;

   142     }

   143 

   144     static int test3_invokevirtual(A a) {

   145         return a.m();

   146     }

   147 

   148     static void test3_2(A a) {

   149     }

   150 

   151     static int test3_1(A a, int i) {

   152         if (i == 0) {

   153             return 0;

   154         }

   155         // If we come here and a is of type B but parameter profiling

   156         // is polluted, both branches of the if below should have

   157         // profiling that tell us and inlining of the virtual call

   158         // should happen

   159         if (i == 1) {

   160             test3_2(a);

   161         } else {

   162             test3_2(a);

   163         }

   164         return test3_invokevirtual(a);

   165     }

   166 

   167     static boolean test3() {

   168         A a = new A();

   169         B b = new B();

   170         C c = new C();

   171 

   172         // pollute profile at test3_invokevirtual and test3_1 to make

   173         // sure the compiler cannot rely on it

   174         for (int i = 0; i < 3000; i++) {

   175             test3_invokevirtual(a);

   176             test3_invokevirtual(b);

   177             test3_invokevirtual(c);

   178             test3_1(a, 0);

   179             test3_1(b, 0);

   180         }

   181 

   182         // profiling + speculation should make test3_invokevirtual

   183         // inline A.m() with a guard

   184         for (int i = 0; i < 20000; i++) {

   185             int res = test3_1(b, (i % 2) + 1);

   186             if (res != b.m()) {

   187                 System.out.println("test3 failed with class B");

   188                 return false;

   189             }

   190         }

   191         // check that the guard works as expected by passing a

   192         // different type

   193         int res = test3_1(a, 1);

   194         if (res != a.m()) {

   195             System.out.println("test3 failed with class A");

   196             return false;

   197         }

   198         return true;

   199     }

   200 

   201     // Mix 2 incompatible profiled types

   202     static int test4_invokevirtual(A a) {

   203         return a.m();

   204     }

   205 

   206     static void test4_2(A a) {

   207     }

   208 

   209     static int test4_1(A a, boolean b) {

   210         if (b) {

   211             test4_2(a);

   212         } else {

   213             test4_2(a);

   214         }

   215         // shouldn't inline

   216         return test4_invokevirtual(a);

   217     }

   218 

   219     static boolean test4() {

   220         A a = new A();

   221         B b = new B();

   222         C c = new C();

   223 

   224         // pollute profile at test3_invokevirtual and test3_1 to make

   225         // sure the compiler cannot rely on it

   226         for (int i = 0; i < 3000; i++) {

   227             test4_invokevirtual(a);

   228             test4_invokevirtual(b);

   229             test4_invokevirtual(c);

   230         }

   231 

   232         for (int i = 0; i < 20000; i++) {

   233             if ((i % 2) == 0) {

   234                 int res = test4_1(a, true);

   235                 if (res != a.m()) {

   236                     System.out.println("test4 failed with class A");

   237                     return false;

   238                 }

   239             } else {

   240                 int res = test4_1(b, false);

   241                 if (res != b.m()) {

   242                     System.out.println("test4 failed with class B");

   243                     return false;

   244                 }

   245             }

   246         }

   247         return true;

   248     }

   249 

   250     // Mix one profiled type with an incompatible type

   251     static int test5_invokevirtual(A a) {

   252         return a.m();

   253     }

   254 

   255     static void test5_2(A a) {

   256     }

   257 

   258     static int test5_1(A a, boolean b) {

   259         if (b) {

   260             test5_2(a);

   261         } else {

   262             A aa = (B)a;

   263         }

   264         // shouldn't inline

   265         return test5_invokevirtual(a);

   266     }

   267 

   268     static boolean test5() {

   269         A a = new A();

   270         B b = new B();

   271         C c = new C();

   272 

   273         // pollute profile at test3_invokevirtual and test3_1 to make

   274         // sure the compiler cannot rely on it

   275         for (int i = 0; i < 3000; i++) {

   276             test5_invokevirtual(a);

   277             test5_invokevirtual(b);

   278             test5_invokevirtual(c);

   279         }

   280 

   281         for (int i = 0; i < 20000; i++) {

   282             if ((i % 2) == 0) {

   283                 int res = test5_1(a, true);

   284                 if (res != a.m()) {

   285                     System.out.println("test5 failed with class A");

   286                     return false;

   287                 }

   288             } else {

   289                 int res = test5_1(b, false);

   290                 if (res != b.m()) {

   291                     System.out.println("test5 failed with class B");

   292                     return false;

   293                 }

   294             }

   295         }

   296         return true;

   297     }

   298 

   299     // Mix incompatible profiled types

   300     static void test6_2(Object o) {

   301     }

   302 

   303     static Object test6_1(Object o, boolean b) {

   304         if (b) {

   305             test6_2(o);

   306         } else {

   307             test6_2(o);

   308         }

   309         return o;

   310     }

   311 

   312     static boolean test6() {

   313         A a = new A();

   314         A[] aa = new A[10];

   315 

   316         for (int i = 0; i < 20000; i++) {

   317             if ((i % 2) == 0) {

   318                 test6_1(a, true);

   319             } else {

   320                 test6_1(aa, false);

   321             }

   322         }

   323         return true;

   324     }

   325 

   326     // Mix a profiled type with an incompatible type

   327     static void test7_2(Object o) {

   328     }

   329 

   330     static Object test7_1(Object o, boolean b) {

   331         if (b) {

   332             test7_2(o);

   333         } else {

   334             Object oo = (A[])o;

   335         }

   336         return o;

   337     }

   338 

   339     static boolean test7() {

   340         A a = new A();

   341         A[] aa = new A[10];

   342 

   343         for (int i = 0; i < 20000; i++) {

   344             if ((i % 2) == 0) {

   345                 test7_1(a, true);

   346             } else {

   347                 test7_1(aa, false);

   348             }

   349         }

   350         return true;

   351     }

   352 

   353     // Mix a profiled type with an interface

   354     static void test8_2(Object o) {

   355     }

   356 

   357     static I test8_1(Object o) {

   358         test8_2(o);

   359         return (I)o;

   360     }

   361 

   362     static boolean test8() {

   363         A a = new A();

   364         B b = new B();

   365         C c = new C();

   366 

   367         for (int i = 0; i < 20000; i++) {

   368             test8_1(b);

   369         }

   370         return true;

   371     }

   372 

   373     // Mix a profiled type with a constant

   374     static void test9_2(Object o) {

   375     }

   376 

   377     static Object test9_1(Object o, boolean b) {

   378         Object oo;

   379         if (b) {

   380             test9_2(o);

   381             oo = o;

   382         } else {

   383             oo = "some string";

   384         }

   385         return oo;

   386     }

   387 

   388     static boolean test9() {

   389         A a = new A();

   390 

   391         for (int i = 0; i < 20000; i++) {

   392             if ((i % 2) == 0) {

   393                 test9_1(a, true);

   394             } else {

   395                 test9_1(a, false);

   396             }

   397         }

   398         return true;

   399     }

   400 

   401     static public void main(String[] args) {

   402         boolean success = true;

   403 

   404         success = test1() && success;

   405 

   406         success = test2() && success;

   407 

   408         success = test3() && success;

   409 

   410         success = test4() && success;

   411 

   412         success = test5() && success;

   413 

   414         success = test6() && success;

   415 

   416         success = test7() && success;

   417 

   418         success = test8() && success;

   419 

   420         success = test9() && success;

   421 

   422         if (success) {

   423             System.out.println("TEST PASSED");

   424         } else {

   425             throw new RuntimeException("TEST FAILED: erroneous bound check elimination");

   426         }

   427     }

   428 }