1 /*
2 * Copyright (c) 2016, 2018, 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 8155781
27 * @modules java.base/jdk.internal.misc
28 *
29 * @run main/bootclasspath/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
30 * -XX:-TieredCompilation -Xbatch
31 * -XX:+UseCompressedOops -XX:+UseCompressedClassPointers
32 * -XX:CompileCommand=dontinline,compiler.unsafe.OpaqueAccesses::test*
33 * compiler.unsafe.OpaqueAccesses
34 * @run main/bootclasspath/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
35 * -XX:-TieredCompilation -Xbatch
36 * -XX:+UseCompressedOops -XX:-UseCompressedClassPointers
37 * -XX:CompileCommand=dontinline,compiler.unsafe.OpaqueAccesses::test*
38 * compiler.unsafe.OpaqueAccesses
39 * @run main/bootclasspath/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
40 * -XX:-TieredCompilation -Xbatch
41 * -XX:-UseCompressedOops -XX:+UseCompressedClassPointers
42 * -XX:CompileCommand=dontinline,compiler.unsafe.OpaqueAccesses::test*
43 * compiler.unsafe.OpaqueAccesses
44 * @run main/bootclasspath/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
45 * -XX:-TieredCompilation -Xbatch
46 * -XX:-UseCompressedOops -XX:-UseCompressedClassPointers
47 * -XX:CompileCommand=dontinline,compiler.unsafe.OpaqueAccesses::test*
48 * compiler.unsafe.OpaqueAccesses
49 */
50 package compiler.unsafe;
51
52 import jdk.internal.misc.Unsafe;
53
54 import java.lang.reflect.Field;
55
56 public class OpaqueAccesses {
57 private static final Unsafe UNSAFE = Unsafe.getUnsafe();
58
59 private static final Object INSTANCE = new OpaqueAccesses();
60
61 private static final Object[] ARRAY = new Object[10];
62
63 private static final long F_OFFSET;
64 private static final long E_OFFSET;
65
66 static {
67 try {
68 Field field = OpaqueAccesses.class.getDeclaredField("f");
69 F_OFFSET = UNSAFE.objectFieldOffset(field);
70
71 E_OFFSET = UNSAFE.arrayBaseOffset(ARRAY.getClass());
72 } catch (NoSuchFieldException e) {
73 throw new Error(e);
74 }
75 }
76
77 private Object f = new Object();
78 private long l1, l2;
79
80 static Object testFixedOffsetField(Object o) {
81 return UNSAFE.getReference(o, F_OFFSET);
82 }
83
84 static int testFixedOffsetHeader0(Object o) {
85 return UNSAFE.getInt(o, 0);
86 }
87
88 static int testFixedOffsetHeader4(Object o) {
89 return UNSAFE.getInt(o, 4);
90 }
91
92 static int testFixedOffsetHeader8(Object o) {
93 return UNSAFE.getInt(o, 8);
94 }
95
96 static int testFixedOffsetHeader12(Object o) {
97 return UNSAFE.getInt(o, 12);
98 }
99
100 static int testFixedOffsetHeader16(Object o) {
101 return UNSAFE.getInt(o, 16);
102 }
103
104 static int testFixedOffsetHeader17(Object o) {
105 return UNSAFE.getIntUnaligned(o, 17);
106 }
107
108 static Object testFixedBase(long off) {
109 return UNSAFE.getReference(INSTANCE, off);
110 }
111
112 static Object testOpaque(Object o, long off) {
113 return UNSAFE.getReference(o, off);
114 }
115
116 static int testFixedOffsetHeaderArray0(Object[] arr) {
117 return UNSAFE.getInt(arr, 0);
118 }
119
120 static int testFixedOffsetHeaderArray4(Object[] arr) {
121 return UNSAFE.getInt(arr, 4);
122 }
123
124 static int testFixedOffsetHeaderArray8(Object[] arr) {
125 return UNSAFE.getInt(arr, 8);
126 }
127
128 static int testFixedOffsetHeaderArray12(Object[] arr) {
129 return UNSAFE.getInt(arr, 12);
130 }
131
132 static int testFixedOffsetHeaderArray16(Object[] arr) {
133 return UNSAFE.getInt(arr, 16);
134 }
135
136 static int testFixedOffsetHeaderArray17(Object[] arr) {
137 return UNSAFE.getIntUnaligned(arr, 17);
138 }
139
140 static Object testFixedOffsetArray(Object[] arr) {
141 return UNSAFE.getReference(arr, E_OFFSET);
142 }
143
144 static Object testFixedBaseArray(long off) {
145 return UNSAFE.getReference(ARRAY, off);
146 }
147
148 static Object testOpaqueArray(Object[] o, long off) {
149 return UNSAFE.getReference(o, off);
150 }
151
152 static final long ADDR = UNSAFE.allocateMemory(10);
153 static boolean flag;
154
155 static int testMixedAccess() {
156 flag = !flag;
157 Object o = (flag ? INSTANCE : null);
158 long off = (flag ? F_OFFSET : ADDR);
159 return UNSAFE.getInt(o, off);
160 }
161
162 public static void main(String[] args) {
163 for (int i = 0; i < 20_000; i++) {
164 // Instance
165 testFixedOffsetField(INSTANCE);
166 testFixedOffsetHeader0(INSTANCE);
167 testFixedOffsetHeader4(INSTANCE);
168 testFixedOffsetHeader8(INSTANCE);
169 testFixedOffsetHeader12(INSTANCE);
170 testFixedOffsetHeader16(INSTANCE);
171 testFixedOffsetHeader17(INSTANCE);
172 testFixedBase(F_OFFSET);
173 testOpaque(INSTANCE, F_OFFSET);
174 testMixedAccess();
175
176 // Array
177 testFixedOffsetHeaderArray0(ARRAY);
178 testFixedOffsetHeaderArray4(ARRAY);
179 testFixedOffsetHeaderArray8(ARRAY);
180 testFixedOffsetHeaderArray12(ARRAY);
181 testFixedOffsetHeaderArray16(ARRAY);
182 testFixedOffsetHeaderArray17(ARRAY);
183 testFixedOffsetArray(ARRAY);
184 testFixedBaseArray(E_OFFSET);
185 testOpaqueArray(ARRAY, E_OFFSET);
186 }
187 System.out.println("TEST PASSED");
188 }
189 }