1 /* 2 * Copyright (c) 2019, 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 8202414 27 * @summary Unsafe write after primitive array creation may result in array length change 28 * @run main/othervm compiler.c2.Test8202414 29 */ 30 31 package compiler.c2; 32 33 import sun.misc.Unsafe; 34 import java.lang.reflect.Field; 35 import java.security.AccessController; 36 import java.security.PrivilegedAction; 37 38 public class Test8202414 { 39 40 public static void main(String[] args) { 41 System.err.close(); 42 int count = 0; 43 while (count++ < 120000) { 44 test(); 45 } 46 } 47 48 public static void test() { 49 byte[] newBufb = serByte(397); 50 short[] newBufs = serShort(397); 51 int[] newBufi = serInt(397); 52 long[] newBufl = serLong(397); 53 if (newBufb.length != 397 || newBufs.length != 397 54 || newBufi.length != 397 || newBufl.length != 397) { 55 System.out.println("array length internal error"); 56 throw new RuntimeException("Test failed"); 57 } 58 59 } 60 61 public static byte[] serByte(int bufLen) { 62 byte[] buf = new byte[bufLen]; 63 THE_UNSAFE.putByte(buf, BYTE_ARRAY_BASE_OFFSET + 1, (byte) buf.length); 64 System.err.println("ref " + buf); 65 return buf; 66 } 67 68 public static short[] serShort(int bufLen) { 69 short[] buf = new short[bufLen]; 70 THE_UNSAFE.putShort(buf, SHORT_ARRAY_BASE_OFFSET + 1, (short) buf.length); 71 System.err.println("ref " + buf); 72 return buf; 73 } 74 75 public static int[] serInt(int bufLen) { 76 int[] buf = new int[bufLen]; 77 THE_UNSAFE.putInt(buf, INT_ARRAY_BASE_OFFSET + 1, buf.length); 78 System.err.println("ref " + buf); 79 return buf; 80 } 81 82 public static long[] serLong(int bufLen) { 83 long[] buf = new long[bufLen]; 84 THE_UNSAFE.putLong(buf, LONG_ARRAY_BASE_OFFSET + 1, buf.length); 85 System.err.println("ref " + buf); 86 return buf; 87 } 88 89 /* Unsafe fields and initialization 90 */ 91 static final Unsafe THE_UNSAFE; 92 static final long BYTE_ARRAY_BASE_OFFSET; 93 static final long SHORT_ARRAY_BASE_OFFSET; 94 static final long INT_ARRAY_BASE_OFFSET; 95 static final long LONG_ARRAY_BASE_OFFSET; 96 static { 97 THE_UNSAFE = (Unsafe) AccessController.doPrivileged ( 98 new PrivilegedAction<Object>() { 99 @Override 100 public Object run() { 101 try { 102 Field f = Unsafe.class.getDeclaredField("theUnsafe"); 103 f.setAccessible(true); 104 return f.get(null); 105 } catch (NoSuchFieldException | IllegalAccessException e) { 106 throw new Error(); 107 } 108 } 109 } 110 ); 111 BYTE_ARRAY_BASE_OFFSET = THE_UNSAFE.arrayBaseOffset(byte[].class); 112 SHORT_ARRAY_BASE_OFFSET = THE_UNSAFE.arrayBaseOffset(short[].class); 113 INT_ARRAY_BASE_OFFSET = THE_UNSAFE.arrayBaseOffset(int[].class); 114 LONG_ARRAY_BASE_OFFSET = THE_UNSAFE.arrayBaseOffset(long[].class); 115 } 116 }