1 /*
   2  * Copyright (c) 2016, 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.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * @test
  28  * @summary tests on constant folding of unsafe get operations from stable arrays
  29  * @library /testlibrary /test/lib
  30  * @ignore 8151137
  31  *
  32  * @requires vm.flavor != "client"
  33  *
  34  * @run main/bootclasspath -XX:+UnlockDiagnosticVMOptions
  35  *                   -Xbatch -XX:-TieredCompilation
  36  *                   -XX:+FoldStableValues
  37  *                   -XX:CompileCommand=dontinline,*Test::test*
  38  *                   UnsafeGetStableArrayElement
  39  */
  40 import jdk.internal.misc.Unsafe;
  41 import jdk.internal.vm.annotation.Stable;
  42 import java.util.concurrent.Callable;
  43 
  44 import static jdk.internal.misc.Unsafe.*;
  45 import static jdk.test.lib.Asserts.*;
  46 
  47 public class UnsafeGetStableArrayElement {
  48     @Stable static final boolean[] STABLE_BOOLEAN_ARRAY = new boolean[16];
  49     @Stable static final    byte[]    STABLE_BYTE_ARRAY = new    byte[16];
  50     @Stable static final   short[]   STABLE_SHORT_ARRAY = new   short[8];
  51     @Stable static final    char[]    STABLE_CHAR_ARRAY = new    char[8];
  52     @Stable static final     int[]     STABLE_INT_ARRAY = new     int[4];
  53     @Stable static final    long[]    STABLE_LONG_ARRAY = new    long[2];
  54     @Stable static final   float[]   STABLE_FLOAT_ARRAY = new   float[4];
  55     @Stable static final  double[]  STABLE_DOUBLE_ARRAY = new  double[2];
  56     @Stable static final  Object[]  STABLE_OBJECT_ARRAY = new  Object[4];
  57 
  58     static {
  59         Setter.reset();
  60     }
  61     static final Unsafe U = Unsafe.getUnsafe();
  62 
  63     static class Setter {
  64         private static void setZ(boolean defaultVal) { STABLE_BOOLEAN_ARRAY[0] = defaultVal ? false :                true; }
  65         private static void setB(boolean defaultVal) { STABLE_BYTE_ARRAY[0]    = defaultVal ?     0 :      Byte.MAX_VALUE; }
  66         private static void setS(boolean defaultVal) { STABLE_SHORT_ARRAY[0]   = defaultVal ?     0 :     Short.MAX_VALUE; }
  67         private static void setC(boolean defaultVal) { STABLE_CHAR_ARRAY[0]    = defaultVal ?     0 : Character.MAX_VALUE; }
  68         private static void setI(boolean defaultVal) { STABLE_INT_ARRAY[0]     = defaultVal ?     0 :   Integer.MAX_VALUE; }
  69         private static void setJ(boolean defaultVal) { STABLE_LONG_ARRAY[0]    = defaultVal ?     0 :      Long.MAX_VALUE; }
  70         private static void setF(boolean defaultVal) { STABLE_FLOAT_ARRAY[0]   = defaultVal ?     0 :     Float.MAX_VALUE; }
  71         private static void setD(boolean defaultVal) { STABLE_DOUBLE_ARRAY[0]  = defaultVal ?     0 :    Double.MAX_VALUE; }
  72         private static void setL(boolean defaultVal) { STABLE_OBJECT_ARRAY[0]  = defaultVal ?  null :        new Object(); }
  73 
  74         static void reset() {
  75             setZ(false);
  76             setB(false);
  77             setS(false);
  78             setC(false);
  79             setI(false);
  80             setJ(false);
  81             setF(false);
  82             setD(false);
  83             setL(false);
  84         }
  85     }
  86 
  87     static class Test {
  88         static void changeZ() { Setter.setZ(true); }
  89         static void changeB() { Setter.setB(true); }
  90         static void changeS() { Setter.setS(true); }
  91         static void changeC() { Setter.setC(true); }
  92         static void changeI() { Setter.setI(true); }
  93         static void changeJ() { Setter.setJ(true); }
  94         static void changeF() { Setter.setF(true); }
  95         static void changeD() { Setter.setD(true); }
  96         static void changeL() { Setter.setL(true); }
  97 
  98         static boolean testZ_Z() { return U.getBoolean(STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
  99         static byte    testZ_B() { return U.getByte(   STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
 100         static short   testZ_S() { return U.getShort(  STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
 101         static char    testZ_C() { return U.getChar(   STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
 102         static int     testZ_I() { return U.getInt(    STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
 103         static long    testZ_J() { return U.getLong(   STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
 104         static float   testZ_F() { return U.getFloat(  STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
 105         static double  testZ_D() { return U.getDouble( STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
 106 
 107         static boolean testB_Z() { return U.getBoolean(STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
 108         static byte    testB_B() { return U.getByte(   STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
 109         static short   testB_S() { return U.getShort(  STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
 110         static char    testB_C() { return U.getChar(   STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
 111         static int     testB_I() { return U.getInt(    STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
 112         static long    testB_J() { return U.getLong(   STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
 113         static float   testB_F() { return U.getFloat(  STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
 114         static double  testB_D() { return U.getDouble( STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
 115 
 116         static boolean testS_Z() { return U.getBoolean(STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
 117         static byte    testS_B() { return U.getByte(   STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
 118         static short   testS_S() { return U.getShort(  STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
 119         static char    testS_C() { return U.getChar(   STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
 120         static int     testS_I() { return U.getInt(    STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
 121         static long    testS_J() { return U.getLong(   STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
 122         static float   testS_F() { return U.getFloat(  STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
 123         static double  testS_D() { return U.getDouble( STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
 124 
 125         static boolean testC_Z() { return U.getBoolean(STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
 126         static byte    testC_B() { return U.getByte(   STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
 127         static short   testC_S() { return U.getShort(  STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
 128         static char    testC_C() { return U.getChar(   STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
 129         static int     testC_I() { return U.getInt(    STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
 130         static long    testC_J() { return U.getLong(   STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
 131         static float   testC_F() { return U.getFloat(  STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
 132         static double  testC_D() { return U.getDouble( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
 133 
 134         static boolean testI_Z() { return U.getBoolean(STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
 135         static byte    testI_B() { return U.getByte(   STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
 136         static short   testI_S() { return U.getShort(  STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
 137         static char    testI_C() { return U.getChar(   STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
 138         static int     testI_I() { return U.getInt(    STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
 139         static long    testI_J() { return U.getLong(   STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
 140         static float   testI_F() { return U.getFloat(  STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
 141         static double  testI_D() { return U.getDouble( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
 142 
 143         static boolean testJ_Z() { return U.getBoolean(STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
 144         static byte    testJ_B() { return U.getByte(   STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
 145         static short   testJ_S() { return U.getShort(  STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
 146         static char    testJ_C() { return U.getChar(   STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
 147         static int     testJ_I() { return U.getInt(    STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
 148         static long    testJ_J() { return U.getLong(   STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
 149         static float   testJ_F() { return U.getFloat(  STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
 150         static double  testJ_D() { return U.getDouble( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
 151 
 152         static boolean testF_Z() { return U.getBoolean(STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
 153         static byte    testF_B() { return U.getByte(   STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
 154         static short   testF_S() { return U.getShort(  STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
 155         static char    testF_C() { return U.getChar(   STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
 156         static int     testF_I() { return U.getInt(    STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
 157         static long    testF_J() { return U.getLong(   STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
 158         static float   testF_F() { return U.getFloat(  STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
 159         static double  testF_D() { return U.getDouble( STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
 160 
 161         static boolean testD_Z() { return U.getBoolean(STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
 162         static byte    testD_B() { return U.getByte(   STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
 163         static short   testD_S() { return U.getShort(  STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
 164         static char    testD_C() { return U.getChar(   STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
 165         static int     testD_I() { return U.getInt(    STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
 166         static long    testD_J() { return U.getLong(   STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
 167         static float   testD_F() { return U.getFloat(  STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
 168         static double  testD_D() { return U.getDouble( STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
 169 
 170         static Object  testL_L() { return U.getObject( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 171         static boolean testL_Z() { return U.getBoolean(STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 172         static byte    testL_B() { return U.getByte(   STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 173         static short   testL_S() { return U.getShort(  STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 174         static char    testL_C() { return U.getChar(   STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 175         static int     testL_I() { return U.getInt(    STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 176         static long    testL_J() { return U.getLong(   STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 177         static float   testL_F() { return U.getFloat(  STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 178         static double  testL_D() { return U.getDouble( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
 179 
 180         static short   testS_U() { return U.getShortUnaligned(STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET + 1); }
 181         static char    testC_U() { return U.getCharUnaligned(  STABLE_CHAR_ARRAY,  ARRAY_CHAR_BASE_OFFSET + 1); }
 182         static int     testI_U() { return U.getIntUnaligned(    STABLE_INT_ARRAY,   ARRAY_INT_BASE_OFFSET + 1); }
 183         static long    testJ_U() { return U.getLongUnaligned(  STABLE_LONG_ARRAY,  ARRAY_LONG_BASE_OFFSET + 1); }
 184     }
 185 
 186     static void run(Callable<?> c) throws Exception {
 187         run(c, null, null);
 188     }
 189 
 190     static void run(Callable<?> c, Runnable sameResultAction, Runnable changeResultAction) throws Exception {
 191         Object first = c.call();
 192 
 193         // Trigger compilation.
 194         for (int i = 0; i < 20_000; i++) {
 195             // Don't compare results here, since most of Test::testL_* results vary across iterations (due to GC).
 196             c.call();
 197         }
 198 
 199         if (sameResultAction != null) {
 200             sameResultAction.run();
 201             assertEQ(first, c.call());
 202         }
 203 
 204         if (changeResultAction != null) {
 205             changeResultAction.run();
 206             assertNE(first, c.call());
 207             assertEQ(c.call(), c.call());
 208         }
 209     }
 210 
 211     static void testMatched(Callable<?> c, Runnable setDefaultAction) throws Exception {
 212         run(c, setDefaultAction, null);
 213         Setter.reset();
 214     }
 215 
 216     static void testMismatched(Callable<?> c, Runnable setDefaultAction) throws Exception {
 217         run(c, null, setDefaultAction);
 218         Setter.reset();
 219     }
 220 
 221     public static void main(String[] args) throws Exception {
 222         // boolean[], aligned accesses
 223         testMatched(   Test::testZ_Z, Test::changeZ);
 224         testMismatched(Test::testZ_B, Test::changeZ);
 225         testMismatched(Test::testZ_S, Test::changeZ);
 226         testMismatched(Test::testZ_C, Test::changeZ);
 227         testMismatched(Test::testZ_I, Test::changeZ);
 228         testMismatched(Test::testZ_J, Test::changeZ);
 229         testMismatched(Test::testZ_F, Test::changeZ);
 230         testMismatched(Test::testZ_D, Test::changeZ);
 231 
 232         // byte[], aligned accesses
 233         testMismatched(Test::testB_Z, Test::changeB);
 234         testMatched(   Test::testB_B, Test::changeB);
 235         testMismatched(Test::testB_S, Test::changeB);
 236         testMismatched(Test::testB_C, Test::changeB);
 237         testMismatched(Test::testB_I, Test::changeB);
 238         testMismatched(Test::testB_J, Test::changeB);
 239         testMismatched(Test::testB_F, Test::changeB);
 240         testMismatched(Test::testB_D, Test::changeB);
 241 
 242         // short[], aligned accesses
 243         testMismatched(Test::testS_Z, Test::changeS);
 244         testMismatched(Test::testS_B, Test::changeS);
 245         testMatched(   Test::testS_S, Test::changeS);
 246         testMismatched(Test::testS_C, Test::changeS);
 247         testMismatched(Test::testS_I, Test::changeS);
 248         testMismatched(Test::testS_J, Test::changeS);
 249         testMismatched(Test::testS_F, Test::changeS);
 250         testMismatched(Test::testS_D, Test::changeS);
 251 
 252         // char[], aligned accesses
 253         testMismatched(Test::testC_Z, Test::changeC);
 254         testMismatched(Test::testC_B, Test::changeC);
 255         testMismatched(Test::testC_S, Test::changeC);
 256         testMatched(   Test::testC_C, Test::changeC);
 257         testMismatched(Test::testC_I, Test::changeC);
 258         testMismatched(Test::testC_J, Test::changeC);
 259         testMismatched(Test::testC_F, Test::changeC);
 260         testMismatched(Test::testC_D, Test::changeC);
 261 
 262         // int[], aligned accesses
 263         testMismatched(Test::testI_Z, Test::changeI);
 264         testMismatched(Test::testI_B, Test::changeI);
 265         testMismatched(Test::testI_S, Test::changeI);
 266         testMismatched(Test::testI_C, Test::changeI);
 267         testMatched(   Test::testI_I, Test::changeI);
 268         testMismatched(Test::testI_J, Test::changeI);
 269         testMismatched(Test::testI_F, Test::changeI);
 270         testMismatched(Test::testI_D, Test::changeI);
 271 
 272         // long[], aligned accesses
 273         testMismatched(Test::testJ_Z, Test::changeJ);
 274         testMismatched(Test::testJ_B, Test::changeJ);
 275         testMismatched(Test::testJ_S, Test::changeJ);
 276         testMismatched(Test::testJ_C, Test::changeJ);
 277         testMismatched(Test::testJ_I, Test::changeJ);
 278         testMatched(   Test::testJ_J, Test::changeJ);
 279         testMismatched(Test::testJ_F, Test::changeJ);
 280         testMismatched(Test::testJ_D, Test::changeJ);
 281 
 282         // float[], aligned accesses
 283         testMismatched(Test::testF_Z, Test::changeF);
 284         testMismatched(Test::testF_B, Test::changeF);
 285         testMismatched(Test::testF_S, Test::changeF);
 286         testMismatched(Test::testF_C, Test::changeF);
 287         testMismatched(Test::testF_I, Test::changeF);
 288         testMismatched(Test::testF_J, Test::changeF);
 289         testMatched(   Test::testF_F, Test::changeF);
 290         testMismatched(Test::testF_D, Test::changeF);
 291 
 292         // double[], aligned accesses
 293         testMismatched(Test::testD_Z, Test::changeD);
 294         testMismatched(Test::testD_B, Test::changeD);
 295         testMismatched(Test::testD_S, Test::changeD);
 296         testMismatched(Test::testD_C, Test::changeD);
 297         testMismatched(Test::testD_I, Test::changeD);
 298         testMismatched(Test::testD_J, Test::changeD);
 299         testMismatched(Test::testD_F, Test::changeD);
 300         testMatched(   Test::testD_D, Test::changeD);
 301 
 302         // Object[], aligned accesses
 303         testMismatched(Test::testL_J, Test::changeL); // long & double are always as large as an OOP
 304         testMismatched(Test::testL_D, Test::changeL);
 305         testMatched(   Test::testL_L, Test::changeL);
 306 
 307         // Unaligned accesses
 308         testMismatched(Test::testS_U, Test::changeS);
 309         testMismatched(Test::testC_U, Test::changeC);
 310         testMismatched(Test::testI_U, Test::changeI);
 311         testMismatched(Test::testJ_U, Test::changeJ);
 312 
 313         // No way to reliably check the expected behavior:
 314         //   (1) OOPs change during GC;
 315         //   (2) there's no way to reliably change some part of an OOP (e.g., when reading a byte from it).
 316         //
 317         // Just trigger the compilation hoping to catch any problems with asserts.
 318         run(Test::testL_B);
 319         run(Test::testL_Z);
 320         run(Test::testL_S);
 321         run(Test::testL_C);
 322         run(Test::testL_I);
 323         run(Test::testL_F);
 324     }
 325 }
--- EOF ---