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
30 *
31 * @requires vm.flavor == "server"
32 *
33 * @modules java.base/jdk.internal.vm.annotation
34 * java.base/jdk.internal.misc
35
36 * @run main/bootclasspath/othervm -XX:+UnlockDiagnosticVMOptions
37 * -Xbatch -XX:-TieredCompilation
38 * -XX:+FoldStableValues
39 * -XX:CompileCommand=dontinline,*Test::test*
40 * compiler.unsafe.UnsafeGetStableArrayElement
41 */
42
43 package compiler.unsafe;
44
45 import jdk.internal.misc.Unsafe;
46 import jdk.internal.vm.annotation.Stable;
47 import jdk.test.lib.Platform;
48
49 import java.util.concurrent.Callable;
50
51 import static jdk.internal.misc.Unsafe.*;
52 import static jdk.test.lib.Asserts.assertEQ;
53 import static jdk.test.lib.Asserts.assertNE;
54
55 public class UnsafeGetStableArrayElement {
56 @Stable static final boolean[] STABLE_BOOLEAN_ARRAY = new boolean[16];
57 @Stable static final byte[] STABLE_BYTE_ARRAY = new byte[16];
58 @Stable static final short[] STABLE_SHORT_ARRAY = new short[8];
59 @Stable static final char[] STABLE_CHAR_ARRAY = new char[8];
60 @Stable static final int[] STABLE_INT_ARRAY = new int[4];
61 @Stable static final long[] STABLE_LONG_ARRAY = new long[2];
62 @Stable static final float[] STABLE_FLOAT_ARRAY = new float[4];
63 @Stable static final double[] STABLE_DOUBLE_ARRAY = new double[2];
64 @Stable static final Object[] STABLE_OBJECT_ARRAY = new Object[4];
65
66 static {
67 Setter.reset();
68 }
69 static final Unsafe U = Unsafe.getUnsafe();
70
71 static class Setter {
72 private static void setZ(boolean defaultVal) { STABLE_BOOLEAN_ARRAY[0] = defaultVal ? false : true; }
73 private static void setB(boolean defaultVal) { STABLE_BYTE_ARRAY[0] = defaultVal ? 0 : Byte.MAX_VALUE; }
74 private static void setS(boolean defaultVal) { STABLE_SHORT_ARRAY[0] = defaultVal ? 0 : Short.MAX_VALUE; }
75 private static void setC(boolean defaultVal) { STABLE_CHAR_ARRAY[0] = defaultVal ? 0 : Character.MAX_VALUE; }
76 private static void setI(boolean defaultVal) { STABLE_INT_ARRAY[0] = defaultVal ? 0 : Integer.MAX_VALUE; }
77 private static void setJ(boolean defaultVal) { STABLE_LONG_ARRAY[0] = defaultVal ? 0 : Long.MAX_VALUE; }
78 private static void setF(boolean defaultVal) { STABLE_FLOAT_ARRAY[0] = defaultVal ? 0 : Float.MAX_VALUE; }
79 private static void setD(boolean defaultVal) { STABLE_DOUBLE_ARRAY[0] = defaultVal ? 0 : Double.MAX_VALUE; }
80 private static void setL(boolean defaultVal) { STABLE_OBJECT_ARRAY[0] = defaultVal ? null : new Object(); }
81
82 static void reset() {
83 setZ(false);
84 setB(false);
85 setS(false);
86 setC(false);
87 setI(false);
88 setJ(false);
89 setF(false);
90 setD(false);
91 setL(false);
92 }
93 }
94
95 static class Test {
96 static void changeZ() { Setter.setZ(true); }
97 static void changeB() { Setter.setB(true); }
98 static void changeS() { Setter.setS(true); }
99 static void changeC() { Setter.setC(true); }
100 static void changeI() { Setter.setI(true); }
101 static void changeJ() { Setter.setJ(true); }
102 static void changeF() { Setter.setF(true); }
103 static void changeD() { Setter.setD(true); }
104 static void changeL() { Setter.setL(true); }
105
106 static boolean testZ_Z() { return U.getBoolean(STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
107 static byte testZ_B() { return U.getByte( STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
108 static short testZ_S() { return U.getShort( STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
109 static char testZ_C() { return U.getChar( STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
110 static int testZ_I() { return U.getInt( STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
111 static long testZ_J() { return U.getLong( STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
112 static float testZ_F() { return U.getFloat( STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
113 static double testZ_D() { return U.getDouble( STABLE_BOOLEAN_ARRAY, ARRAY_BOOLEAN_BASE_OFFSET); }
114
115 static boolean testB_Z() { return U.getBoolean(STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
116 static byte testB_B() { return U.getByte( STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
117 static short testB_S() { return U.getShort( STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
118 static char testB_C() { return U.getChar( STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
119 static int testB_I() { return U.getInt( STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
120 static long testB_J() { return U.getLong( STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
121 static float testB_F() { return U.getFloat( STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
122 static double testB_D() { return U.getDouble( STABLE_BYTE_ARRAY, ARRAY_BYTE_BASE_OFFSET); }
123
124 static boolean testS_Z() { return U.getBoolean(STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
125 static byte testS_B() { return U.getByte( STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
126 static short testS_S() { return U.getShort( STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
127 static char testS_C() { return U.getChar( STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
128 static int testS_I() { return U.getInt( STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
129 static long testS_J() { return U.getLong( STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
130 static float testS_F() { return U.getFloat( STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
131 static double testS_D() { return U.getDouble( STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET); }
132
133 static boolean testC_Z() { return U.getBoolean(STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
134 static byte testC_B() { return U.getByte( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
135 static short testC_S() { return U.getShort( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
136 static char testC_C() { return U.getChar( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
137 static int testC_I() { return U.getInt( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
138 static long testC_J() { return U.getLong( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
139 static float testC_F() { return U.getFloat( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
140 static double testC_D() { return U.getDouble( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET); }
141
142 static boolean testI_Z() { return U.getBoolean(STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
143 static byte testI_B() { return U.getByte( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
144 static short testI_S() { return U.getShort( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
145 static char testI_C() { return U.getChar( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
146 static int testI_I() { return U.getInt( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
147 static long testI_J() { return U.getLong( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
148 static float testI_F() { return U.getFloat( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
149 static double testI_D() { return U.getDouble( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET); }
150
151 static boolean testJ_Z() { return U.getBoolean(STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
152 static byte testJ_B() { return U.getByte( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
153 static short testJ_S() { return U.getShort( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
154 static char testJ_C() { return U.getChar( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
155 static int testJ_I() { return U.getInt( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
156 static long testJ_J() { return U.getLong( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
157 static float testJ_F() { return U.getFloat( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
158 static double testJ_D() { return U.getDouble( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET); }
159
160 static boolean testF_Z() { return U.getBoolean(STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
161 static byte testF_B() { return U.getByte( STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
162 static short testF_S() { return U.getShort( STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
163 static char testF_C() { return U.getChar( STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
164 static int testF_I() { return U.getInt( STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
165 static long testF_J() { return U.getLong( STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
166 static float testF_F() { return U.getFloat( STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
167 static double testF_D() { return U.getDouble( STABLE_FLOAT_ARRAY, ARRAY_FLOAT_BASE_OFFSET); }
168
169 static boolean testD_Z() { return U.getBoolean(STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
170 static byte testD_B() { return U.getByte( STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
171 static short testD_S() { return U.getShort( STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
172 static char testD_C() { return U.getChar( STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
173 static int testD_I() { return U.getInt( STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
174 static long testD_J() { return U.getLong( STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
175 static float testD_F() { return U.getFloat( STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
176 static double testD_D() { return U.getDouble( STABLE_DOUBLE_ARRAY, ARRAY_DOUBLE_BASE_OFFSET); }
177
178 static Object testL_L() { return U.getObject( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
179 static boolean testL_Z() { return U.getBoolean(STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
180 static byte testL_B() { return U.getByte( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
181 static short testL_S() { return U.getShort( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
182 static char testL_C() { return U.getChar( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
183 static int testL_I() { return U.getInt( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
184 static long testL_J() { return U.getLong( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
185 static float testL_F() { return U.getFloat( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
186 static double testL_D() { return U.getDouble( STABLE_OBJECT_ARRAY, ARRAY_OBJECT_BASE_OFFSET); }
187
188 static short testS_U() { return U.getShortUnaligned(STABLE_SHORT_ARRAY, ARRAY_SHORT_BASE_OFFSET + 1); }
189 static char testC_U() { return U.getCharUnaligned( STABLE_CHAR_ARRAY, ARRAY_CHAR_BASE_OFFSET + 1); }
190 static int testI_U() { return U.getIntUnaligned( STABLE_INT_ARRAY, ARRAY_INT_BASE_OFFSET + 1); }
191 static long testJ_U() { return U.getLongUnaligned( STABLE_LONG_ARRAY, ARRAY_LONG_BASE_OFFSET + 1); }
192 }
193
194 static void run(Callable<?> c) throws Exception {
195 run(c, null, null);
196 }
197
198 static void run(Callable<?> c, Runnable sameResultAction, Runnable changeResultAction) throws Exception {
199 Object first = c.call();
200
201 // Trigger compilation.
202 for (int i = 0; i < 20_000; i++) {
203 // Don't compare results here, since most of Test::testL_* results vary across iterations (due to GC).
204 c.call();
205 }
206
207 if (sameResultAction != null) {
208 sameResultAction.run();
209 assertEQ(first, c.call());
210 }
211
212 if (changeResultAction != null) {
213 changeResultAction.run();
214 assertNE(first, c.call());
215 assertEQ(c.call(), c.call());
216 }
217 }
218
219 static void testMatched(Callable<?> c, Runnable setDefaultAction) throws Exception {
220 run(c, setDefaultAction, null);
221 Setter.reset();
222 }
223
224 static void testMismatched(Callable<?> c, Runnable setDefaultAction) throws Exception {
225 run(c, null, setDefaultAction);
226 Setter.reset();
227 }
228
229 static void testUnsafeAccess() throws Exception {
230 // boolean[], aligned accesses
231 testMatched( Test::testZ_Z, Test::changeZ);
232 testMismatched(Test::testZ_B, Test::changeZ);
233 testMismatched(Test::testZ_S, Test::changeZ);
234 testMismatched(Test::testZ_C, Test::changeZ);
235 testMismatched(Test::testZ_I, Test::changeZ);
236 testMismatched(Test::testZ_J, Test::changeZ);
237 testMismatched(Test::testZ_F, Test::changeZ);
238 testMismatched(Test::testZ_D, Test::changeZ);
239
240 // byte[], aligned accesses
241 testMismatched(Test::testB_Z, Test::changeB);
242 testMatched( Test::testB_B, Test::changeB);
243 testMismatched(Test::testB_S, Test::changeB);
244 testMismatched(Test::testB_C, Test::changeB);
245 testMismatched(Test::testB_I, Test::changeB);
246 testMismatched(Test::testB_J, Test::changeB);
247 testMismatched(Test::testB_F, Test::changeB);
248 testMismatched(Test::testB_D, Test::changeB);
249
250 // short[], aligned accesses
251 testMismatched(Test::testS_Z, Test::changeS);
252 testMismatched(Test::testS_B, Test::changeS);
253 testMatched( Test::testS_S, Test::changeS);
254 testMismatched(Test::testS_C, Test::changeS);
255 testMismatched(Test::testS_I, Test::changeS);
256 testMismatched(Test::testS_J, Test::changeS);
257 testMismatched(Test::testS_F, Test::changeS);
258 testMismatched(Test::testS_D, Test::changeS);
259
260 // char[], aligned accesses
261 testMismatched(Test::testC_Z, Test::changeC);
262 testMismatched(Test::testC_B, Test::changeC);
263 testMismatched(Test::testC_S, Test::changeC);
264 testMatched( Test::testC_C, Test::changeC);
265 testMismatched(Test::testC_I, Test::changeC);
266 testMismatched(Test::testC_J, Test::changeC);
267 testMismatched(Test::testC_F, Test::changeC);
268 testMismatched(Test::testC_D, Test::changeC);
269
270 // int[], aligned accesses
271 testMismatched(Test::testI_Z, Test::changeI);
272 testMismatched(Test::testI_B, Test::changeI);
273 testMismatched(Test::testI_S, Test::changeI);
274 testMismatched(Test::testI_C, Test::changeI);
275 testMatched( Test::testI_I, Test::changeI);
276 testMismatched(Test::testI_J, Test::changeI);
277 testMismatched(Test::testI_F, Test::changeI);
278 testMismatched(Test::testI_D, Test::changeI);
279
280 // long[], aligned accesses
281 testMismatched(Test::testJ_Z, Test::changeJ);
282 testMismatched(Test::testJ_B, Test::changeJ);
283 testMismatched(Test::testJ_S, Test::changeJ);
284 testMismatched(Test::testJ_C, Test::changeJ);
285 testMismatched(Test::testJ_I, Test::changeJ);
286 testMatched( Test::testJ_J, Test::changeJ);
287 testMismatched(Test::testJ_F, Test::changeJ);
288 testMismatched(Test::testJ_D, Test::changeJ);
289
290 // float[], aligned accesses
291 testMismatched(Test::testF_Z, Test::changeF);
292 testMismatched(Test::testF_B, Test::changeF);
293 testMismatched(Test::testF_S, Test::changeF);
294 testMismatched(Test::testF_C, Test::changeF);
295 testMismatched(Test::testF_I, Test::changeF);
296 testMismatched(Test::testF_J, Test::changeF);
297 testMatched( Test::testF_F, Test::changeF);
298 testMismatched(Test::testF_D, Test::changeF);
299
300 // double[], aligned accesses
301 testMismatched(Test::testD_Z, Test::changeD);
302 testMismatched(Test::testD_B, Test::changeD);
303 testMismatched(Test::testD_S, Test::changeD);
304 testMismatched(Test::testD_C, Test::changeD);
305 testMismatched(Test::testD_I, Test::changeD);
306 testMismatched(Test::testD_J, Test::changeD);
307 testMismatched(Test::testD_F, Test::changeD);
308 testMatched( Test::testD_D, Test::changeD);
309
310 // Object[], aligned accesses
311 testMismatched(Test::testL_J, Test::changeL); // long & double are always as large as an OOP
312 testMismatched(Test::testL_D, Test::changeL);
313 testMatched( Test::testL_L, Test::changeL);
314
315 // Unaligned accesses
316 testMismatched(Test::testS_U, Test::changeS);
317 testMismatched(Test::testC_U, Test::changeC);
318 testMismatched(Test::testI_U, Test::changeI);
319 testMismatched(Test::testJ_U, Test::changeJ);
320
321 // No way to reliably check the expected behavior:
322 // (1) OOPs change during GC;
323 // (2) there's no way to reliably change some part of an OOP (e.g., when reading a byte from it).
324 //
325 // Just trigger the compilation hoping to catch any problems with asserts.
326 run(Test::testL_B);
327 run(Test::testL_Z);
328 run(Test::testL_S);
329 run(Test::testL_C);
330 run(Test::testL_I);
331 run(Test::testL_F);
332 }
333
334 public static void main(String[] args) throws Exception {
335 if (!Platform.isServer()) {
336 throw new Error("TESTBUG: Not server VM");
337 }
338 testUnsafeAccess();
339 System.out.println("TEST PASSED");
340 }
341 }