--- /dev/null 2016-02-18 23:37:48.897179021 +0300 +++ new/test/compiler/intrinsics/unsafe/AllocateUninitializedArray.java 2016-02-26 00:17:01.756555798 +0300 @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/* + * @test + * @bug 8150465 + * @summary Unsafe methods to produce uninitialized arrays + * @modules java.base/jdk.internal.misc + * @run main/othervm -ea -Diters=200 -Xint AllocateUninitializedArray + * @run main/othervm -ea -Diters=30000 -XX:TieredStopAtLevel=1 AllocateUninitializedArray + * @run main/othervm -ea -Diters=30000 -XX:TieredStopAtLevel=4 AllocateUninitializedArray + */ +import java.lang.reflect.Field; +import java.lang.reflect.Array; +import java.util.concurrent.Callable; + +public class AllocateUninitializedArray { + static final int ITERS = Integer.getInteger("iters", 1); + static final jdk.internal.misc.Unsafe UNSAFE; + + static { + try { + Field f = jdk.internal.misc.Unsafe.class.getDeclaredField("theUnsafe"); + f.setAccessible(true); + UNSAFE = (jdk.internal.misc.Unsafe) f.get(null); + } catch (Exception e) { + throw new RuntimeException("Unable to get Unsafe instance.", e); + } + } + + public static void main(String... args) throws Exception { + testIAE(AllConstants::testObject); + testIAE(LengthIsConstant::testObject); + testIAE(ClassIsConstant::testObject); + testIAE(NothingIsConstant::testObject); + + testIAE(AllConstants::testArray); + testIAE(LengthIsConstant::testArray); + testIAE(ClassIsConstant::testArray); + testIAE(NothingIsConstant::testArray); + + testIAE(AllConstants::testNull); + testIAE(LengthIsConstant::testNull); + testIAE(ClassIsConstant::testNull); + testIAE(NothingIsConstant::testNull); + + testOK(boolean[].class, 10, AllConstants::testBoolean); + testOK(byte[].class, 10, AllConstants::testByte); + testOK(short[].class, 10, AllConstants::testShort); + testOK(char[].class, 10, AllConstants::testChar); + testOK(int[].class, 10, AllConstants::testInt); + testOK(float[].class, 10, AllConstants::testFloat); + testOK(long[].class, 10, AllConstants::testLong); + testOK(double[].class, 10, AllConstants::testDouble); + + testOK(boolean[].class, 10, LengthIsConstant::testBoolean); + testOK(byte[].class, 10, LengthIsConstant::testByte); + testOK(short[].class, 10, LengthIsConstant::testShort); + testOK(char[].class, 10, LengthIsConstant::testChar); + testOK(int[].class, 10, LengthIsConstant::testInt); + testOK(float[].class, 10, LengthIsConstant::testFloat); + testOK(long[].class, 10, LengthIsConstant::testLong); + testOK(double[].class, 10, LengthIsConstant::testDouble); + + testOK(boolean[].class, 10, ClassIsConstant::testBoolean); + testOK(byte[].class, 10, ClassIsConstant::testByte); + testOK(short[].class, 10, ClassIsConstant::testShort); + testOK(char[].class, 10, ClassIsConstant::testChar); + testOK(int[].class, 10, ClassIsConstant::testInt); + testOK(float[].class, 10, ClassIsConstant::testFloat); + testOK(long[].class, 10, ClassIsConstant::testLong); + testOK(double[].class, 10, ClassIsConstant::testDouble); + + testOK(boolean[].class, 10, NothingIsConstant::testBoolean); + testOK(byte[].class, 10, NothingIsConstant::testByte); + testOK(short[].class, 10, NothingIsConstant::testShort); + testOK(char[].class, 10, NothingIsConstant::testChar); + testOK(int[].class, 10, NothingIsConstant::testInt); + testOK(float[].class, 10, NothingIsConstant::testFloat); + testOK(long[].class, 10, NothingIsConstant::testLong); + testOK(double[].class, 10, NothingIsConstant::testDouble); + } + + public static void testOK(Class expectClass, int expectLen, Callable test) throws Exception { + for (int c = 0; c < ITERS; c++) { + Object res = test.call(); + Class actualClass = res.getClass(); + if (!actualClass.equals(expectClass)) { + throw new IllegalStateException("Wrong class: expected = " + expectClass + ", but got " + actualClass); + } + int actualLen = Array.getLength(res); + if (actualLen != expectLen) { + throw new IllegalStateException("Wrong length: expected = " + expectLen + ", but got " + actualLen); + } + } + } + + static volatile Object sink; + + public static void testIAE(Callable test) throws Exception { + for (int c = 0; c < ITERS; c++) { + try { + sink = test.call(); + throw new IllegalStateException("Expected IAE"); + } catch (IllegalArgumentException iae) { + // expected + } + } + } + + static volatile int sampleLenNeg = -1; + static volatile int sampleLenZero = 0; + static volatile int sampleLen = 10; + + + static volatile Class classBoolean = boolean.class; + static volatile Class classByte = byte.class; + static volatile Class classShort = short.class; + static volatile Class classChar = char.class; + static volatile Class classInt = int.class; + static volatile Class classFloat = float.class; + static volatile Class classLong = long.class; + static volatile Class classDouble = double.class; + static volatile Class classObject = Object.class; + static volatile Class classArray = Object[].class; + static volatile Class classNull = null; + + static class AllConstants { + static Object testBoolean() { return UNSAFE.allocateUninitializedArray(boolean.class, 10); } + static Object testByte() { return UNSAFE.allocateUninitializedArray(byte.class, 10); } + static Object testShort() { return UNSAFE.allocateUninitializedArray(short.class, 10); } + static Object testChar() { return UNSAFE.allocateUninitializedArray(char.class, 10); } + static Object testInt() { return UNSAFE.allocateUninitializedArray(int.class, 10); } + static Object testFloat() { return UNSAFE.allocateUninitializedArray(float.class, 10); } + static Object testLong() { return UNSAFE.allocateUninitializedArray(long.class, 10); } + static Object testDouble() { return UNSAFE.allocateUninitializedArray(double.class, 10); } + static Object testObject() { return UNSAFE.allocateUninitializedArray(Object.class, 10); } + static Object testArray() { return UNSAFE.allocateUninitializedArray(Object[].class, 10); } + static Object testNull() { return UNSAFE.allocateUninitializedArray(null, 10); } + static Object testZero() { return UNSAFE.allocateUninitializedArray(int.class, 0); } + static Object testNeg() { return UNSAFE.allocateUninitializedArray(int.class, -1); } + } + + static class ClassIsConstant { + static Object testBoolean() { return UNSAFE.allocateUninitializedArray(boolean.class, sampleLen); } + static Object testByte() { return UNSAFE.allocateUninitializedArray(byte.class, sampleLen); } + static Object testShort() { return UNSAFE.allocateUninitializedArray(short.class, sampleLen); } + static Object testChar() { return UNSAFE.allocateUninitializedArray(char.class, sampleLen); } + static Object testInt() { return UNSAFE.allocateUninitializedArray(int.class, sampleLen); } + static Object testFloat() { return UNSAFE.allocateUninitializedArray(float.class, sampleLen); } + static Object testLong() { return UNSAFE.allocateUninitializedArray(long.class, sampleLen); } + static Object testDouble() { return UNSAFE.allocateUninitializedArray(double.class, sampleLen); } + static Object testObject() { return UNSAFE.allocateUninitializedArray(Object.class, sampleLen); } + static Object testArray() { return UNSAFE.allocateUninitializedArray(Object[].class, sampleLen); } + static Object testNull() { return UNSAFE.allocateUninitializedArray(null, sampleLen); } + static Object testZero() { return UNSAFE.allocateUninitializedArray(int.class, sampleLenZero); } + static Object testNeg() { return UNSAFE.allocateUninitializedArray(int.class, sampleLenNeg); } + } + + static class LengthIsConstant { + static Object testBoolean() { return UNSAFE.allocateUninitializedArray(classBoolean, 10); } + static Object testByte() { return UNSAFE.allocateUninitializedArray(classByte, 10); } + static Object testShort() { return UNSAFE.allocateUninitializedArray(classShort, 10); } + static Object testChar() { return UNSAFE.allocateUninitializedArray(classChar, 10); } + static Object testInt() { return UNSAFE.allocateUninitializedArray(classInt, 10); } + static Object testFloat() { return UNSAFE.allocateUninitializedArray(classFloat, 10); } + static Object testLong() { return UNSAFE.allocateUninitializedArray(classLong, 10); } + static Object testDouble() { return UNSAFE.allocateUninitializedArray(classDouble, 10); } + static Object testObject() { return UNSAFE.allocateUninitializedArray(classObject, 10); } + static Object testArray() { return UNSAFE.allocateUninitializedArray(classArray, 10); } + static Object testNull() { return UNSAFE.allocateUninitializedArray(classNull, 10); } + static Object testZero() { return UNSAFE.allocateUninitializedArray(classInt, 0); } + static Object testNeg() { return UNSAFE.allocateUninitializedArray(classInt, -1); } + } + + static class NothingIsConstant { + static Object testBoolean() { return UNSAFE.allocateUninitializedArray(classBoolean, sampleLen); } + static Object testByte() { return UNSAFE.allocateUninitializedArray(classByte, sampleLen); } + static Object testShort() { return UNSAFE.allocateUninitializedArray(classShort, sampleLen); } + static Object testChar() { return UNSAFE.allocateUninitializedArray(classChar, sampleLen); } + static Object testInt() { return UNSAFE.allocateUninitializedArray(classInt, sampleLen); } + static Object testFloat() { return UNSAFE.allocateUninitializedArray(classFloat, sampleLen); } + static Object testLong() { return UNSAFE.allocateUninitializedArray(classLong, sampleLen); } + static Object testDouble() { return UNSAFE.allocateUninitializedArray(classDouble, sampleLen); } + static Object testObject() { return UNSAFE.allocateUninitializedArray(classObject, sampleLen); } + static Object testArray() { return UNSAFE.allocateUninitializedArray(classArray, sampleLen); } + static Object testNull() { return UNSAFE.allocateUninitializedArray(classNull, sampleLen); } + static Object testZero() { return UNSAFE.allocateUninitializedArray(classInt, sampleLenZero); } + static Object testNeg() { return UNSAFE.allocateUninitializedArray(classInt, sampleLenNeg); } + } +} +