1 /*
   2  * Copyright (c) 2014, 2015, 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 /test/lib /
  29  * @modules java.base/jdk.internal.misc
  30  *          java.management
  31  * @ignore 8157984
  32  * @build TestRangeCheckSmearing
  33  * @run driver ClassFileInstaller sun.hotspot.WhiteBox
  34  *                                jdk.test.lib.Platform
  35  * @run main/othervm -ea -Xmixed -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
  36  *                   -XX:-BackgroundCompilation -XX:-UseOnStackReplacement TestRangeCheckSmearing
  37  *
  38  */
  39 
  40 import java.lang.annotation.*;
  41 import java.lang.reflect.*;
  42 import java.util.*;
  43 import sun.hotspot.WhiteBox;
  44 import sun.hotspot.code.NMethod;
  45 import jdk.test.lib.Platform;
  46 import compiler.whitebox.CompilerWhiteBoxTest;

  47 
  48 public class TestRangeCheckSmearing {
  49     private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
  50 
  51     @Retention(RetentionPolicy.RUNTIME)
  52     @interface Args { int[] value(); }
  53 
  54     // first range check is i + max of all constants
  55     @Args({0, 8})
  56     static int m1(int[] array, int i, boolean allaccesses) {
  57         int res = 0;
  58         res += array[i+9];
  59         if (allaccesses) {
  60             res += array[i+8];
  61             res += array[i+7];
  62             res += array[i+6];
  63             res += array[i+5];
  64             res += array[i+4];
  65             res += array[i+3];
  66             res += array[i+2];
  67             res += array[i+1];
  68         }
  69         return res;
  70     }
  71 
  72     // first range check is i + min of all constants
  73     @Args({0, -9})
  74     static int m2(int[] array, int i, boolean allaccesses) {
  75         int res = 0;
  76         res += array[i+1];
  77         if (allaccesses) {
  78             res += array[i+2];
  79             res += array[i+3];
  80             res += array[i+4];
  81             res += array[i+5];
  82             res += array[i+6];
  83             res += array[i+7];
  84             res += array[i+8];
  85             res += array[i+9];
  86         }
  87         return res;
  88     }
  89 
  90     // first range check is not i + min/max of all constants
  91     @Args({0, 8})
  92     static int m3(int[] array, int i, boolean allaccesses) {
  93         int res = 0;
  94         res += array[i+3];
  95         if (allaccesses) {
  96             res += array[i+2];
  97             res += array[i+1];
  98             res += array[i+4];
  99             res += array[i+5];
 100             res += array[i+6];
 101             res += array[i+7];
 102             res += array[i+8];
 103             res += array[i+9];
 104         }
 105         return res;
 106     }
 107 
 108     @Args({0, -9})
 109     static int m4(int[] array, int i, boolean allaccesses) {
 110         int res = 0;
 111         res += array[i+3];
 112         if (allaccesses) {
 113             res += array[i+4];
 114             res += array[i+1];
 115             res += array[i+2];
 116             res += array[i+5];
 117             res += array[i+6];
 118             res += array[i+7];
 119             res += array[i+8];
 120             res += array[i+9];
 121         }
 122         return res;
 123     }
 124 
 125     @Args({0, -3})
 126     static int m5(int[] array, int i, boolean allaccesses) {
 127         int res = 0;
 128         res += array[i+3];
 129         res += array[i+2];
 130         if (allaccesses) {
 131             res += array[i+1];
 132             res += array[i+4];
 133             res += array[i+5];
 134             res += array[i+6];
 135             res += array[i+7];
 136             res += array[i+8];
 137             res += array[i+9];
 138         }
 139         return res;
 140     }
 141 
 142     @Args({0, 6})
 143     static int m6(int[] array, int i, boolean allaccesses) {
 144         int res = 0;
 145         res += array[i+3];
 146         res += array[i+4];
 147         if (allaccesses) {
 148             res += array[i+2];
 149             res += array[i+1];
 150             res += array[i+5];
 151             res += array[i+6];
 152             res += array[i+7];
 153             res += array[i+8];
 154             res += array[i+9];
 155         }
 156         return res;
 157     }
 158 
 159     @Args({0, 6})
 160     static int m7(int[] array, int i, boolean allaccesses) {
 161         int res = 0;
 162         res += array[i+3];
 163         res += array[i+2];
 164         res += array[i+4];
 165         if (allaccesses) {
 166             res += array[i+1];
 167             res += array[i+5];
 168             res += array[i+6];
 169             res += array[i+7];
 170             res += array[i+8];
 171             res += array[i+9];
 172         }
 173         return res;
 174     }
 175 
 176     @Args({0, -3})
 177     static int m8(int[] array, int i, boolean allaccesses) {
 178         int res = 0;
 179         res += array[i+3];
 180         res += array[i+4];
 181         res += array[i+2];
 182         if (allaccesses) {
 183             res += array[i+1];
 184             res += array[i+5];
 185             res += array[i+6];
 186             res += array[i+7];
 187             res += array[i+8];
 188             res += array[i+9];
 189         }
 190         return res;
 191     }
 192 
 193     @Args({6, 15})
 194     static int m9(int[] array, int i, boolean allaccesses) {
 195         int res = 0;
 196         res += array[i+3];
 197         if (allaccesses) {
 198             res += array[i-2];
 199             res += array[i-1];
 200             res += array[i-4];
 201             res += array[i-5];
 202             res += array[i-6];
 203         }
 204         return res;
 205     }
 206 
 207     @Args({3, 12})
 208     static int m10(int[] array, int i, boolean allaccesses) {
 209         int res = 0;
 210         res += array[i+3];
 211         if (allaccesses) {
 212             res += array[i-2];
 213             res += array[i-1];
 214             res += array[i-3];
 215             res += array[i+4];
 216             res += array[i+5];
 217             res += array[i+6];
 218         }
 219         return res;
 220     }
 221 
 222     @Args({3, -3})
 223     static int m11(int[] array, int i, boolean allaccesses) {
 224         int res = 0;
 225         res += array[i+3];
 226         res += array[i-2];
 227         if (allaccesses) {
 228             res += array[i+5];
 229             res += array[i+6];
 230         }
 231         return res;
 232     }
 233 
 234     @Args({3, 6})
 235     static int m12(int[] array, int i, boolean allaccesses) {
 236         int res = 0;
 237         res += array[i+3];
 238         res += array[i+6];
 239         if (allaccesses) {
 240             res += array[i-2];
 241             res += array[i-3];
 242         }
 243         return res;
 244     }
 245 
 246     // check that identical range check is replaced by dominating one
 247     // only when correct
 248     @Args({0})
 249     static int m13(int[] array, int i, boolean ignore) {
 250         int res = 0;
 251         res += array[i+3];
 252         res += array[i+3];
 253         return res;
 254     }
 255 
 256     @Args({2, 0})
 257     static int m14(int[] array, int i, boolean ignore) {
 258         int res = 0;
 259 
 260         res += array[i];
 261         res += array[i-2];
 262         res += array[i]; // If range check below were to be removed first this cannot be considered identical to first range check
 263         res += array[i-1]; // range check removed so i-1 array access depends on previous check
 264 
 265         return res;
 266     }
 267 
 268     static int[] m15_dummy = new int[10];
 269     @Args({2, 0})
 270     static int m15(int[] array, int i, boolean ignore) {
 271         int res = 0;
 272         res += array[i];
 273 
 274         // When the loop is optimized out we don't want the
 275         // array[i-1] access which is dependent on array[i]'s
 276         // range check to become dependent on the identical range
 277         // check above.
 278 
 279         int[] array2 = m15_dummy;
 280         int j = 0;
 281         for (; j < 10; j++);
 282         if (j == 10) {
 283             array2 = array;
 284         }
 285 
 286         res += array2[i-2];
 287         res += array2[i];
 288         res += array2[i-1]; // range check removed so i-1 array access depends on previous check
 289 
 290         return res;
 291     }
 292 
 293     @Args({2, 0})
 294     static int m16(int[] array, int i, boolean ignore) {
 295         int res = 0;
 296 
 297         res += array[i];
 298         res += array[i-1];
 299         res += array[i-1];
 300         res += array[i-2];
 301 
 302         return res;
 303     }
 304 
 305     @Args({2, 0})
 306     static int m17(int[] array, int i, boolean ignore) {
 307         int res = 0;
 308 
 309         res += array[i];
 310         res += array[i-2];
 311         res += array[i-2];
 312         res += array[i+2];
 313         res += array[i+2];
 314         res += array[i-1];
 315         res += array[i-1];
 316 
 317         return res;
 318     }
 319 
 320     static public void main(String[] args) {
 321         if (WHITE_BOX.getBooleanVMFlag("BackgroundCompilation")) {
 322             throw new AssertionError("Background compilation enabled");
 323         }
 324         new TestRangeCheckSmearing().doTests();
 325     }
 326     boolean success = true;
 327     boolean exception = false;
 328     final int[] array = new int[10];
 329     final HashMap<String,Method> tests = new HashMap<>();
 330     {
 331         final Class<?> TEST_PARAM_TYPES[] = { int[].class, int.class, boolean.class };
 332         for (Method m : this.getClass().getDeclaredMethods()) {
 333             if (m.getName().matches("m[0-9]+")) {
 334                 assert(Modifier.isStatic(m.getModifiers())) : m;
 335                 assert(m.getReturnType() == int.class) : m;
 336                 assert(Arrays.equals(m.getParameterTypes(), TEST_PARAM_TYPES)) : m;
 337                 tests.put(m.getName(), m);
 338             }
 339         }
 340     }
 341 
 342     void invokeTest(Method m, int[] array, int index, boolean z) {
 343         try {
 344             m.invoke(null, array, index, z);
 345         } catch (ReflectiveOperationException roe) {
 346             Throwable ex = roe.getCause();
 347             if (ex instanceof ArrayIndexOutOfBoundsException)
 348                 throw (ArrayIndexOutOfBoundsException) ex;
 349             throw new AssertionError(roe);
 350         }
 351     }
 352 
 353     void doTest(String name) {
 354         Method m = tests.get(name);
 355         tests.remove(name);
 356         int[] args = m.getAnnotation(Args.class).value();
 357         int index0 = args[0], index1;
 358         boolean exceptionRequired = true;
 359         if (args.length == 2) {
 360             index1 = args[1];
 361         } else {
 362             // no negative test for this one
 363             assert(args.length == 1);
 364             assert(name.equals("m13"));
 365             exceptionRequired = false;
 366             index1 = index0;
 367         }
 368         // Get the method compiled.
 369         if (!WHITE_BOX.isMethodCompiled(m)) {
 370             // If not, try to compile it with C2
 371             if(!WHITE_BOX.enqueueMethodForCompilation(m, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION)) {
 372                 // C2 compiler not available, try to compile with C1
 373                 WHITE_BOX.enqueueMethodForCompilation(m, CompilerWhiteBoxTest.COMP_LEVEL_SIMPLE);
 374             }
 375         }
 376         if (!WHITE_BOX.isMethodCompiled(m)) {
 377             throw new RuntimeException(m + " not compiled");
 378         }
 379 
 380         // valid access
 381         invokeTest(m, array, index0, true);
 382 
 383         if (!WHITE_BOX.isMethodCompiled(m)) {
 384             throw new RuntimeException(m + " deoptimized on valid array access");
 385         }
 386 
 387         exception = false;
 388         boolean test_success = true;
 389         try {
 390             invokeTest(m, array, index1, false);
 391         } catch(ArrayIndexOutOfBoundsException aioob) {
 392             exception = true;
 393             System.out.println("ArrayIndexOutOfBoundsException thrown in "+name);
 394         }
 395         if (!exception) {
 396             System.out.println("ArrayIndexOutOfBoundsException was not thrown in "+name);
 397         }
 398 
 399         if (Platform.isServer()) {
 400             if (exceptionRequired == WHITE_BOX.isMethodCompiled(m)) {
 401                 System.out.println((exceptionRequired?"Didn't deoptimized":"deoptimized") + " in "+name);
 402                 test_success = false;
 403             }
 404         }
 405 
 406         if (exception != exceptionRequired) {
 407             System.out.println((exceptionRequired?"exception required but not thrown":"not exception required but thrown") + " in "+name);
 408             test_success = false;
 409         }
 410 
 411         if (!test_success) {
 412             success = false;
 413             System.out.println("TEST FAILED: "+name);
 414         }
 415 
 416     }
 417     void doTests() {
 418         doTest("m1");
 419         doTest("m2");
 420         doTest("m3");
 421         doTest("m4");
 422         doTest("m5");
 423         doTest("m6");
 424         doTest("m7");
 425         doTest("m8");
 426         doTest("m9");
 427         doTest("m10");
 428         doTest("m11");
 429         doTest("m12");
 430         doTest("m13");
 431         doTest("m14");
 432         doTest("m15");
 433         doTest("m16");
 434         doTest("m17");
 435         if (!success) {
 436             throw new RuntimeException("Some tests failed");
 437         }
 438         assert(tests.isEmpty()) : tests;
 439     }
 440 }
--- EOF ---