1 /*

     2  * Copyright (c) 2014, 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 8066103

    27  * @summary C2's range check smearing allows out of bound array accesses

    28  * @library /testlibrary /testlibrary/whitebox /compiler/whitebox /testlibrary/com/oracle/java/testlibrary

    29  * @build TestRangeCheckSmearing

    30  * @run main ClassFileInstaller sun.hotspot.WhiteBox

    31  * @run main ClassFileInstaller com.oracle.java.testlibrary.Platform

    32  * @run main/othervm -ea -Xmixed -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI

    33  *                   -XX:-BackgroundCompilation -XX:-UseOnStackReplacement TestRangeCheckSmearing

    34  *

    35  */

    36 

    37 import java.lang.annotation.*;

    38 import java.lang.reflect.*;

    39 import java.util.*;

    40 import sun.hotspot.WhiteBox;

    41 import sun.hotspot.code.NMethod;

    42 import com.oracle.java.testlibrary.Platform;

    43 

    44 public class TestRangeCheckSmearing {

    45     private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();

    46 

    47     @Retention(RetentionPolicy.RUNTIME)

    48     @interface Args { int[] value(); }

    49 

    50     // first range check is i + max of all constants

    51     @Args({0, 8})

    52     static int m1(int[] array, int i, boolean allaccesses) {

    53         int res = 0;

    54         res += array[i+9];

    55         if (allaccesses) {

    56             res += array[i+8];

    57             res += array[i+7];

    58             res += array[i+6];

    59             res += array[i+5];

    60             res += array[i+4];

    61             res += array[i+3];

    62             res += array[i+2];

    63             res += array[i+1];

    64         }

    65         return res;

    66     }

    67 

    68     // first range check is i + min of all constants

    69     @Args({0, -9})

    70     static int m2(int[] array, int i, boolean allaccesses) {

    71         int res = 0;

    72         res += array[i+1];

    73         if (allaccesses) {

    74             res += array[i+2];

    75             res += array[i+3];

    76             res += array[i+4];

    77             res += array[i+5];

    78             res += array[i+6];

    79             res += array[i+7];

    80             res += array[i+8];

    81             res += array[i+9];

    82         }

    83         return res;

    84     }

    85 

    86     // first range check is not i + min/max of all constants

    87     @Args({0, 8})

    88     static int m3(int[] array, int i, boolean allaccesses) {

    89         int res = 0;

    90         res += array[i+3];

    91         if (allaccesses) {

    92             res += array[i+2];

    93             res += array[i+1];

    94             res += array[i+4];

    95             res += array[i+5];

    96             res += array[i+6];

    97             res += array[i+7];

    98             res += array[i+8];

    99             res += array[i+9];

   100         }

   101         return res;

   102     }

   103 

   104     @Args({0, -9})

   105     static int m4(int[] array, int i, boolean allaccesses) {

   106         int res = 0;

   107         res += array[i+3];

   108         if (allaccesses) {

   109             res += array[i+4];

   110             res += array[i+1];

   111             res += array[i+2];

   112             res += array[i+5];

   113             res += array[i+6];

   114             res += array[i+7];

   115             res += array[i+8];

   116             res += array[i+9];

   117         }

   118         return res;

   119     }

   120 

   121     @Args({0, -3})

   122     static int m5(int[] array, int i, boolean allaccesses) {

   123         int res = 0;

   124         res += array[i+3];

   125         res += array[i+2];

   126         if (allaccesses) {

   127             res += array[i+1];

   128             res += array[i+4];

   129             res += array[i+5];

   130             res += array[i+6];

   131             res += array[i+7];

   132             res += array[i+8];

   133             res += array[i+9];

   134         }

   135         return res;

   136     }

   137 

   138     @Args({0, 6})

   139     static int m6(int[] array, int i, boolean allaccesses) {

   140         int res = 0;

   141         res += array[i+3];

   142         res += array[i+4];

   143         if (allaccesses) {

   144             res += array[i+2];

   145             res += array[i+1];

   146             res += array[i+5];

   147             res += array[i+6];

   148             res += array[i+7];

   149             res += array[i+8];

   150             res += array[i+9];

   151         }

   152         return res;

   153     }

   154 

   155     @Args({0, 6})

   156     static int m7(int[] array, int i, boolean allaccesses) {

   157         int res = 0;

   158         res += array[i+3];

   159         res += array[i+2];

   160         res += array[i+4];

   161         if (allaccesses) {

   162             res += array[i+1];

   163             res += array[i+5];

   164             res += array[i+6];

   165             res += array[i+7];

   166             res += array[i+8];

   167             res += array[i+9];

   168         }

   169         return res;

   170     }

   171 

   172     @Args({0, -3})

   173     static int m8(int[] array, int i, boolean allaccesses) {

   174         int res = 0;

   175         res += array[i+3];

   176         res += array[i+4];

   177         res += array[i+2];

   178         if (allaccesses) {

   179             res += array[i+1];

   180             res += array[i+5];

   181             res += array[i+6];

   182             res += array[i+7];

   183             res += array[i+8];

   184             res += array[i+9];

   185         }

   186         return res;

   187     }

   188 

   189     @Args({6, 15})

   190     static int m9(int[] array, int i, boolean allaccesses) {

   191         int res = 0;

   192         res += array[i+3];

   193         if (allaccesses) {

   194             res += array[i-2];

   195             res += array[i-1];

   196             res += array[i-4];

   197             res += array[i-5];

   198             res += array[i-6];

   199         }

   200         return res;

   201     }

   202 

   203     @Args({3, 12})

   204     static int m10(int[] array, int i, boolean allaccesses) {

   205         int res = 0;

   206         res += array[i+3];

   207         if (allaccesses) {

   208             res += array[i-2];

   209             res += array[i-1];

   210             res += array[i-3];

   211             res += array[i+4];

   212             res += array[i+5];

   213             res += array[i+6];

   214         }

   215         return res;

   216     }

   217 

   218     @Args({3, -3})

   219     static int m11(int[] array, int i, boolean allaccesses) {

   220         int res = 0;

   221         res += array[i+3];

   222         res += array[i-2];

   223         if (allaccesses) {

   224             res += array[i+5];

   225             res += array[i+6];

   226         }

   227         return res;

   228     }

   229 

   230     @Args({3, 6})

   231     static int m12(int[] array, int i, boolean allaccesses) {

   232         int res = 0;

   233         res += array[i+3];

   234         res += array[i+6];

   235         if (allaccesses) {

   236             res += array[i-2];

   237             res += array[i-3];

   238         }

   239         return res;

   240     }

   241 

   242     // check that identical range check is replaced by dominating one

   243     // only when correct

   244     @Args({0})

   245     static int m13(int[] array, int i, boolean ignore) {

   246         int res = 0;

   247         res += array[i+3];

   248         res += array[i+3];

   249         return res;

   250     }

   251 

   252     @Args({2, 0})

   253     static int m14(int[] array, int i, boolean ignore) {

   254         int res = 0;

   255 

   256         res += array[i];

   257         res += array[i-2];

   258         res += array[i]; // If range check below were to be removed first this cannot be considered identical to first range check

   259         res += array[i-1]; // range check removed so i-1 array access depends on previous check

   260 

   261         return res;

   262     }

   263 

   264     static int[] m15_dummy = new int[10];

   265     @Args({2, 0})

   266     static int m15(int[] array, int i, boolean ignore) {

   267         int res = 0;

   268         res += array[i];

   269 

   270         // When the loop is optimized out we don't want the

   271         // array[i-1] access which is dependent on array[i]'s

   272         // range check to become dependent on the identical range

   273         // check above.

   274 

   275         int[] array2 = m15_dummy;

   276         int j = 0;

   277         for (; j < 10; j++);

   278         if (j == 10) {

   279             array2 = array;

   280         }

   281 

   282         res += array2[i-2];

   283         res += array2[i];

   284         res += array2[i-1]; // range check removed so i-1 array access depends on previous check

   285 

   286         return res;

   287     }

   288 

   289     @Args({2, 0})

   290     static int m16(int[] array, int i, boolean ignore) {

   291         int res = 0;

   292 

   293         res += array[i];

   294         res += array[i-1];

   295         res += array[i-1];

   296         res += array[i-2];

   297 

   298         return res;

   299     }

   300 

   301     @Args({2, 0})

   302     static int m17(int[] array, int i, boolean ignore) {

   303         int res = 0;

   304 

   305         res += array[i];

   306         res += array[i-2];

   307         res += array[i-2];

   308         res += array[i+2];

   309         res += array[i+2];

   310         res += array[i-1];

   311         res += array[i-1];

   312 

   313         return res;

   314     }

   315 

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

   317         if (WHITE_BOX.getBooleanVMFlag("BackgroundCompilation")) {

   318             throw new AssertionError("Background compilation enabled");

   319         }

   320         new TestRangeCheckSmearing().doTests();

   321     }

   322     boolean success = true;

   323     boolean exception = false;

   324     final int[] array = new int[10];

   325     final HashMap<String,Method> tests = new HashMap<>();

   326     {

   327         final Class<?> TEST_PARAM_TYPES[] = { int[].class, int.class, boolean.class };

   328         for (Method m : this.getClass().getDeclaredMethods()) {

   329             if (m.getName().matches("m[0-9]+")) {

   330                 assert(Modifier.isStatic(m.getModifiers())) : m;

   331                 assert(m.getReturnType() == int.class) : m;

   332                 assert(Arrays.equals(m.getParameterTypes(), TEST_PARAM_TYPES)) : m;

   333                 tests.put(m.getName(), m);

   334             }

   335         }

   336     }

   337 

   338     void invokeTest(Method m, int[] array, int index, boolean z) {

   339         try {

   340             m.invoke(null, array, index, z);

   341         } catch (ReflectiveOperationException roe) {

   342             Throwable ex = roe.getCause();

   343             if (ex instanceof ArrayIndexOutOfBoundsException)

   344                 throw (ArrayIndexOutOfBoundsException) ex;

   345             throw new AssertionError(roe);

   346         }

   347     }

   348 

   349     void doTest(String name) {

   350         Method m = tests.get(name);

   351         tests.remove(name);

   352         int[] args = m.getAnnotation(Args.class).value();

   353         int index0 = args[0], index1;

   354         boolean exceptionRequired = true;

   355         if (args.length == 2) {

   356             index1 = args[1];

   357         } else {

   358             // no negative test for this one

   359             assert(args.length == 1);

   360             assert(name.equals("m13"));

   361             exceptionRequired = false;

   362             index1 = index0;

   363         }

   364         // Get the method compiled.

   365         if (!WHITE_BOX.isMethodCompiled(m)) {

   366             // If not, try to compile it with C2

   367             if(!WHITE_BOX.enqueueMethodForCompilation(m, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION)) {

   368                 // C2 compiler not available, try to compile with C1

   369                 WHITE_BOX.enqueueMethodForCompilation(m, CompilerWhiteBoxTest.COMP_LEVEL_SIMPLE);

   370             }

   371         }

   372         if (!WHITE_BOX.isMethodCompiled(m)) {

   373             throw new RuntimeException(m + " not compiled");

   374         }

   375 

   376         // valid access

   377         invokeTest(m, array, index0, true);

   378 

   379         if (!WHITE_BOX.isMethodCompiled(m)) {

   380             throw new RuntimeException(m + " deoptimized on valid array access");

   381         }

   382 

   383         exception = false;

   384         boolean test_success = true;

   385         try {

   386             invokeTest(m, array, index1, false);

   387         } catch(ArrayIndexOutOfBoundsException aioob) {

   388             exception = true;

   389             System.out.println("ArrayIndexOutOfBoundsException thrown in "+name);

   390         }

   391         if (!exception) {

   392             System.out.println("ArrayIndexOutOfBoundsException was not thrown in "+name);

   393         }

   394 

   395         if (Platform.isServer()) {

   396             if (exceptionRequired == WHITE_BOX.isMethodCompiled(m)) {

   397                 System.out.println((exceptionRequired?"Didn't deoptimized":"deoptimized") + " in "+name);

   398                 test_success = false;

   399             }

   400         }

   401 

   402         if (exception != exceptionRequired) {

   403             System.out.println((exceptionRequired?"exception required but not thrown":"not exception required but thrown") + " in "+name);

   404             test_success = false;

   405         }

   406 

   407         if (!test_success) {

   408             success = false;

   409             System.out.println("TEST FAILED: "+name);

   410         }

   411 

   412     }

   413     void doTests() {

   414         doTest("m1");

   415         doTest("m2");

   416         doTest("m3");

   417         doTest("m4");

   418         doTest("m5");

   419         doTest("m6");

   420         doTest("m7");

   421         doTest("m8");

   422         doTest("m9");

   423         doTest("m10");

   424         doTest("m11");

   425         doTest("m12");

   426         doTest("m13");

   427         doTest("m14");

   428         doTest("m15");

   429         doTest("m16");

   430         doTest("m17");

   431         if (!success) {

   432             throw new RuntimeException("Some tests failed");

   433         }

   434         assert(tests.isEmpty()) : tests;

   435     }

   436 }