AllocateUninitializedArray.java revision 12290:8953c0318163 
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.
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 8150465
27 * @summary Unsafe methods to produce uninitialized arrays
28 * @modules java.base/jdk.internal.misc:+open
29 *
30 * @run main/othervm -ea -Diters=200   -Xint
31 *      compiler.intrinsics.unsafe.AllocateUninitializedArray
32 * @run main/othervm -ea -Diters=30000 -XX:TieredStopAtLevel=1
33 *      compiler.intrinsics.unsafe.AllocateUninitializedArray
34 * @run main/othervm -ea -Diters=30000 -XX:TieredStopAtLevel=4
35 *      compiler.intrinsics.unsafe.AllocateUninitializedArray
36 */
37
38package compiler.intrinsics.unsafe;
39
40import java.lang.reflect.Array;
41import java.lang.reflect.Field;
42import java.util.concurrent.Callable;
43
44public class AllocateUninitializedArray {
45    static final int ITERS = Integer.getInteger("iters", 1);
46    static final jdk.internal.misc.Unsafe UNSAFE;
47
48    static {
49        try {
50            Field f = jdk.internal.misc.Unsafe.class.getDeclaredField("theUnsafe");
51            f.setAccessible(true);
52            UNSAFE = (jdk.internal.misc.Unsafe) f.get(null);
53        } catch (Exception e) {
54            throw new RuntimeException("Unable to get Unsafe instance.", e);
55        }
56    }
57
58    public static void main(String... args) throws Exception {
59        testIAE(AllConstants::testObject);
60        testIAE(LengthIsConstant::testObject);
61        testIAE(ClassIsConstant::testObject);
62        testIAE(NothingIsConstant::testObject);
63
64        testIAE(AllConstants::testArray);
65        testIAE(LengthIsConstant::testArray);
66        testIAE(ClassIsConstant::testArray);
67        testIAE(NothingIsConstant::testArray);
68
69        testIAE(AllConstants::testNull);
70        testIAE(LengthIsConstant::testNull);
71        testIAE(ClassIsConstant::testNull);
72        testIAE(NothingIsConstant::testNull);
73
74        testOK(boolean[].class, 10, AllConstants::testBoolean);
75        testOK(byte[].class,    10, AllConstants::testByte);
76        testOK(short[].class,   10, AllConstants::testShort);
77        testOK(char[].class,    10, AllConstants::testChar);
78        testOK(int[].class,     10, AllConstants::testInt);
79        testOK(float[].class,   10, AllConstants::testFloat);
80        testOK(long[].class,    10, AllConstants::testLong);
81        testOK(double[].class,  10, AllConstants::testDouble);
82
83        testOK(boolean[].class, 10, LengthIsConstant::testBoolean);
84        testOK(byte[].class,    10, LengthIsConstant::testByte);
85        testOK(short[].class,   10, LengthIsConstant::testShort);
86        testOK(char[].class,    10, LengthIsConstant::testChar);
87        testOK(int[].class,     10, LengthIsConstant::testInt);
88        testOK(float[].class,   10, LengthIsConstant::testFloat);
89        testOK(long[].class,    10, LengthIsConstant::testLong);
90        testOK(double[].class,  10, LengthIsConstant::testDouble);
91
92        testOK(boolean[].class, 10, ClassIsConstant::testBoolean);
93        testOK(byte[].class,    10, ClassIsConstant::testByte);
94        testOK(short[].class,   10, ClassIsConstant::testShort);
95        testOK(char[].class,    10, ClassIsConstant::testChar);
96        testOK(int[].class,     10, ClassIsConstant::testInt);
97        testOK(float[].class,   10, ClassIsConstant::testFloat);
98        testOK(long[].class,    10, ClassIsConstant::testLong);
99        testOK(double[].class,  10, ClassIsConstant::testDouble);
100
101        testOK(boolean[].class, 10, NothingIsConstant::testBoolean);
102        testOK(byte[].class,    10, NothingIsConstant::testByte);
103        testOK(short[].class,   10, NothingIsConstant::testShort);
104        testOK(char[].class,    10, NothingIsConstant::testChar);
105        testOK(int[].class,     10, NothingIsConstant::testInt);
106        testOK(float[].class,   10, NothingIsConstant::testFloat);
107        testOK(long[].class,    10, NothingIsConstant::testLong);
108        testOK(double[].class,  10, NothingIsConstant::testDouble);
109    }
110
111    public static void testOK(Class<?> expectClass, int expectLen, Callable<Object> test) throws Exception {
112        for (int c = 0; c < ITERS; c++) {
113            Object res = test.call();
114            Class<?> actualClass = res.getClass();
115            if (!actualClass.equals(expectClass)) {
116                throw new IllegalStateException("Wrong class: expected = " + expectClass + ", but got " + actualClass);
117            }
118            int actualLen = Array.getLength(res);
119            if (actualLen != expectLen) {
120                throw new IllegalStateException("Wrong length: expected = " + expectLen + ", but got " + actualLen);
121            }
122        }
123    }
124
125    static volatile Object sink;
126
127    public static void testIAE(Callable<Object> test) throws Exception {
128        for (int c = 0; c < ITERS; c++) {
129            try {
130               sink = test.call();
131               throw new IllegalStateException("Expected IAE");
132            } catch (IllegalArgumentException iae) {
133               // expected
134            }
135        }
136    }
137
138    static volatile int sampleLenNeg  = -1;
139    static volatile int sampleLenZero = 0;
140    static volatile int sampleLen     = 10;
141
142
143    static volatile Class<?> classBoolean = boolean.class;
144    static volatile Class<?> classByte    = byte.class;
145    static volatile Class<?> classShort   = short.class;
146    static volatile Class<?> classChar    = char.class;
147    static volatile Class<?> classInt     = int.class;
148    static volatile Class<?> classFloat   = float.class;
149    static volatile Class<?> classLong    = long.class;
150    static volatile Class<?> classDouble  = double.class;
151    static volatile Class<?> classObject  = Object.class;
152    static volatile Class<?> classArray   = Object[].class;
153    static volatile Class<?> classNull    = null;
154
155    static class AllConstants {
156        static Object testBoolean() { return UNSAFE.allocateUninitializedArray(boolean.class,  10); }
157        static Object testByte()    { return UNSAFE.allocateUninitializedArray(byte.class,     10); }
158        static Object testShort()   { return UNSAFE.allocateUninitializedArray(short.class,    10); }
159        static Object testChar()    { return UNSAFE.allocateUninitializedArray(char.class,     10); }
160        static Object testInt()     { return UNSAFE.allocateUninitializedArray(int.class,      10); }
161        static Object testFloat()   { return UNSAFE.allocateUninitializedArray(float.class,    10); }
162        static Object testLong()    { return UNSAFE.allocateUninitializedArray(long.class,     10); }
163        static Object testDouble()  { return UNSAFE.allocateUninitializedArray(double.class,   10); }
164        static Object testObject()  { return UNSAFE.allocateUninitializedArray(Object.class,   10); }
165        static Object testArray()   { return UNSAFE.allocateUninitializedArray(Object[].class, 10); }
166        static Object testNull()    { return UNSAFE.allocateUninitializedArray(null,           10); }
167        static Object testZero()    { return UNSAFE.allocateUninitializedArray(int.class,      0);  }
168        static Object testNeg()     { return UNSAFE.allocateUninitializedArray(int.class,      -1); }
169    }
170
171    static class ClassIsConstant {
172        static Object testBoolean() { return UNSAFE.allocateUninitializedArray(boolean.class,  sampleLen); }
173        static Object testByte()    { return UNSAFE.allocateUninitializedArray(byte.class,     sampleLen); }
174        static Object testShort()   { return UNSAFE.allocateUninitializedArray(short.class,    sampleLen); }
175        static Object testChar()    { return UNSAFE.allocateUninitializedArray(char.class,     sampleLen); }
176        static Object testInt()     { return UNSAFE.allocateUninitializedArray(int.class,      sampleLen); }
177        static Object testFloat()   { return UNSAFE.allocateUninitializedArray(float.class,    sampleLen); }
178        static Object testLong()    { return UNSAFE.allocateUninitializedArray(long.class,     sampleLen); }
179        static Object testDouble()  { return UNSAFE.allocateUninitializedArray(double.class,   sampleLen); }
180        static Object testObject()  { return UNSAFE.allocateUninitializedArray(Object.class,   sampleLen); }
181        static Object testArray()   { return UNSAFE.allocateUninitializedArray(Object[].class, sampleLen); }
182        static Object testNull()    { return UNSAFE.allocateUninitializedArray(null,           sampleLen); }
183        static Object testZero()    { return UNSAFE.allocateUninitializedArray(int.class,      sampleLenZero); }
184        static Object testNeg()     { return UNSAFE.allocateUninitializedArray(int.class,      sampleLenNeg); }
185    }
186
187    static class LengthIsConstant {
188        static Object testBoolean() { return UNSAFE.allocateUninitializedArray(classBoolean, 10); }
189        static Object testByte()    { return UNSAFE.allocateUninitializedArray(classByte,    10); }
190        static Object testShort()   { return UNSAFE.allocateUninitializedArray(classShort,   10); }
191        static Object testChar()    { return UNSAFE.allocateUninitializedArray(classChar,    10); }
192        static Object testInt()     { return UNSAFE.allocateUninitializedArray(classInt,     10); }
193        static Object testFloat()   { return UNSAFE.allocateUninitializedArray(classFloat,   10); }
194        static Object testLong()    { return UNSAFE.allocateUninitializedArray(classLong,    10); }
195        static Object testDouble()  { return UNSAFE.allocateUninitializedArray(classDouble,  10); }
196        static Object testObject()  { return UNSAFE.allocateUninitializedArray(classObject,  10); }
197        static Object testArray()   { return UNSAFE.allocateUninitializedArray(classArray,   10); }
198        static Object testNull()    { return UNSAFE.allocateUninitializedArray(classNull,    10); }
199        static Object testZero()    { return UNSAFE.allocateUninitializedArray(classInt,     0);  }
200        static Object testNeg()     { return UNSAFE.allocateUninitializedArray(classInt,     -1); }
201    }
202
203    static class NothingIsConstant {
204        static Object testBoolean() { return UNSAFE.allocateUninitializedArray(classBoolean, sampleLen); }
205        static Object testByte()    { return UNSAFE.allocateUninitializedArray(classByte,    sampleLen); }
206        static Object testShort()   { return UNSAFE.allocateUninitializedArray(classShort,   sampleLen); }
207        static Object testChar()    { return UNSAFE.allocateUninitializedArray(classChar,    sampleLen); }
208        static Object testInt()     { return UNSAFE.allocateUninitializedArray(classInt,     sampleLen); }
209        static Object testFloat()   { return UNSAFE.allocateUninitializedArray(classFloat,   sampleLen); }
210        static Object testLong()    { return UNSAFE.allocateUninitializedArray(classLong,    sampleLen); }
211        static Object testDouble()  { return UNSAFE.allocateUninitializedArray(classDouble,  sampleLen); }
212        static Object testObject()  { return UNSAFE.allocateUninitializedArray(classObject,  sampleLen); }
213        static Object testArray()   { return UNSAFE.allocateUninitializedArray(classArray,   sampleLen); }
214        static Object testNull()    { return UNSAFE.allocateUninitializedArray(classNull,    sampleLen); }
215        static Object testZero()    { return UNSAFE.allocateUninitializedArray(classInt,     sampleLenZero); }
216        static Object testNeg()     { return UNSAFE.allocateUninitializedArray(classInt,     sampleLenNeg); }
217    }
218}
219
220