1 /*
2 * Copyright (c) 2011, 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 package jdk.vm.ci.hotspot;
24
25 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntimeProvider.getArrayBaseOffset;
26 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntimeProvider.getArrayIndexScale;
27 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
28
29 import java.lang.reflect.Array;
30
31 import jdk.vm.ci.common.JVMCIError;
32 import jdk.vm.ci.meta.Constant;
33 import jdk.vm.ci.meta.JavaConstant;
34 import jdk.vm.ci.meta.JavaKind;
35 import jdk.vm.ci.meta.MemoryAccessProvider;
36 import jdk.vm.ci.meta.MetaAccessProvider;
37 import jdk.vm.ci.meta.PrimitiveConstant;
38 import jdk.vm.ci.meta.ResolvedJavaField;
39 import jdk.vm.ci.meta.ResolvedJavaType;
40
41 /**
42 * HotSpot implementation of {@link MemoryAccessProvider}.
43 */
44 class HotSpotMemoryAccessProviderImpl implements HotSpotMemoryAccessProvider {
45
46 protected final HotSpotJVMCIRuntimeProvider runtime;
47
48 HotSpotMemoryAccessProviderImpl(HotSpotJVMCIRuntimeProvider runtime) {
49 this.runtime = runtime;
50 }
51
52 /**
53 * Gets the object boxed by {@code base} that is about to have a value of kind {@code kind} read
54 * from it at the offset {@code displacement}.
55 *
56 * @param base constant value containing the base address for a pending read
57 * @return {@code null} if {@code base} does not box an object otherwise the object boxed in
58 * {@code base}
59 */
60 private Object asObject(Constant base, JavaKind kind, long displacement) {
61 if (base instanceof HotSpotObjectConstantImpl) {
62 HotSpotObjectConstantImpl constant = (HotSpotObjectConstantImpl) base;
63 HotSpotResolvedObjectType type = constant.getType();
64 Object object = constant.object();
65 checkRead(kind, displacement, type, object);
66 return object;
67 }
68 return null;
69 }
70
71 /**
72 * Offset of injected {@code java.lang.Class::oop_size} field. No need to make {@code volatile}
73 * as initialization is idempotent.
74 */
75 private long oopSizeOffset;
76
77 private static int computeOopSizeOffset(HotSpotJVMCIRuntimeProvider runtime) {
78 MetaAccessProvider metaAccess = runtime.getHostJVMCIBackend().getMetaAccess();
79 ResolvedJavaType staticType = metaAccess.lookupJavaType(Class.class);
80 for (ResolvedJavaField f : staticType.getInstanceFields(false)) {
81 if (f.getName().equals("oop_size")) {
82 int offset = ((HotSpotResolvedJavaField) f).offset();
83 assert offset != 0 : "not expecting offset of java.lang.Class::oop_size to be 0";
84 return offset;
85 }
86 }
87 throw new JVMCIError("Could not find injected java.lang.Class::oop_size field");
88 }
89
90 private boolean checkRead(JavaKind kind, long displacement, HotSpotResolvedObjectType type, Object object) {
91 if (type.isArray()) {
92 ResolvedJavaType componentType = type.getComponentType();
93 JavaKind componentKind = componentType.getJavaKind();
94 final int headerSize = getArrayBaseOffset(componentKind);
95 int sizeOfElement = getArrayIndexScale(componentKind);
96 int length = Array.getLength(object);
97 long arrayEnd = headerSize + (sizeOfElement * length);
98 boolean aligned = ((displacement - headerSize) % sizeOfElement) == 0;
99 if (displacement < 0 || displacement > (arrayEnd - sizeOfElement) || (kind == JavaKind.Object && !aligned)) {
100 int index = (int) ((displacement - headerSize) / sizeOfElement);
101 throw new IllegalArgumentException("Unsafe array access: reading element of kind " + kind +
102 " at offset " + displacement + " (index ~ " + index + ") in " +
103 type.toJavaName() + " object of length " + length);
104 }
105 } else if (kind != JavaKind.Object) {
106 long size;
107 if (object instanceof Class) {
108 if (oopSizeOffset == 0) {
109 oopSizeOffset = computeOopSizeOffset(runtime);
110 }
111 int wordSize = runtime.getHostJVMCIBackend().getCodeCache().getTarget().wordSize;
112 size = UNSAFE.getInt(object, oopSizeOffset) * wordSize;
113 } else {
114 size = Math.abs(type.instanceSize());
115 }
116 int bytesToRead = kind.getByteCount();
117 if (displacement + bytesToRead > size || displacement < 0) {
118 throw new IllegalArgumentException("Unsafe access: reading " + bytesToRead + " bytes at offset " + displacement + " in " +
119 type.toJavaName() + " object of size " + size);
120 }
121 } else {
122 ResolvedJavaField field = type.findInstanceFieldWithOffset(displacement, JavaKind.Object);
123 if (field == null && object instanceof Class) {
124 // Read of a static field
125 MetaAccessProvider metaAccess = runtime.getHostJVMCIBackend().getMetaAccess();
126 HotSpotResolvedObjectTypeImpl staticFieldsHolder = (HotSpotResolvedObjectTypeImpl) metaAccess.lookupJavaType((Class<?>) object);
127 field = staticFieldsHolder.findStaticFieldWithOffset(displacement, JavaKind.Object);
128 }
129 if (field == null) {
130 throw new IllegalArgumentException("Unsafe object access: field not found for read of kind Object" +
131 " at offset " + displacement + " in " + type.toJavaName() + " object");
132 }
133 if (field.getJavaKind() != JavaKind.Object) {
134 throw new IllegalArgumentException("Unsafe object access: field " + field.format("%H.%n:%T") + " not of expected kind Object" +
135 " at offset " + displacement + " in " + type.toJavaName() + " object");
136 }
137 }
138 return true;
139 }
140
141 private boolean isValidObjectFieldDisplacement(Constant base, long displacement) {
142 if (base instanceof HotSpotMetaspaceConstant) {
143 MetaspaceWrapperObject metaspaceObject = HotSpotMetaspaceConstantImpl.getMetaspaceObject(base);
144 if (metaspaceObject instanceof HotSpotResolvedObjectTypeImpl) {
145 if (displacement == runtime.getConfig().classMirrorOffset) {
146 // Klass::_java_mirror is valid for all Klass* values
147 return true;
148 }
149 } else {
150 throw new IllegalArgumentException(String.valueOf(metaspaceObject));
151 }
152 }
153 return false;
154 }
155
156 private static long asRawPointer(Constant base) {
157 if (base instanceof HotSpotMetaspaceConstantImpl) {
158 MetaspaceWrapperObject meta = HotSpotMetaspaceConstantImpl.getMetaspaceObject(base);
159 return meta.getMetaspacePointer();
160 } else if (base instanceof PrimitiveConstant) {
161 PrimitiveConstant prim = (PrimitiveConstant) base;
162 if (prim.getJavaKind().isNumericInteger()) {
163 return prim.asLong();
164 }
165 }
166 throw new IllegalArgumentException(String.valueOf(base));
167 }
168
169 private long readRawValue(Constant baseConstant, long displacement, JavaKind kind, int bits) {
170 Object base = asObject(baseConstant, kind, displacement);
171 if (base != null) {
172 switch (bits) {
173 case Byte.SIZE:
174 return UNSAFE.getByte(base, displacement);
175 case Short.SIZE:
176 return UNSAFE.getShort(base, displacement);
177 case Integer.SIZE:
178 return UNSAFE.getInt(base, displacement);
179 case Long.SIZE:
180 return UNSAFE.getLong(base, displacement);
181 default:
182 throw new IllegalArgumentException(String.valueOf(bits));
183 }
184 } else {
185 long pointer = asRawPointer(baseConstant);
186 switch (bits) {
187 case Byte.SIZE:
188 return UNSAFE.getByte(pointer + displacement);
189 case Short.SIZE:
190 return UNSAFE.getShort(pointer + displacement);
191 case Integer.SIZE:
192 return UNSAFE.getInt(pointer + displacement);
193 case Long.SIZE:
194 return UNSAFE.getLong(pointer + displacement);
195 default:
196 throw new IllegalArgumentException(String.valueOf(bits));
197 }
198 }
199 }
200
201 private boolean verifyReadRawObject(Object expected, Constant base, long displacement) {
202 if (base instanceof HotSpotMetaspaceConstant) {
203 MetaspaceWrapperObject metaspaceObject = HotSpotMetaspaceConstantImpl.getMetaspaceObject(base);
204 if (metaspaceObject instanceof HotSpotResolvedObjectTypeImpl) {
205 if (displacement == runtime.getConfig().classMirrorOffset) {
206 assert expected == ((HotSpotResolvedObjectTypeImpl) metaspaceObject).mirror();
207 }
208 }
209 }
210 return true;
211 }
212
213 private Object readRawObject(Constant baseConstant, long initialDisplacement, boolean compressed) {
214 long displacement = initialDisplacement;
215 Object ret;
216 Object base = asObject(baseConstant, JavaKind.Object, displacement);
217 if (base == null) {
218 assert !compressed;
219 displacement += asRawPointer(baseConstant);
220 ret = UNSAFE.getUncompressedObject(displacement);
221 assert verifyReadRawObject(ret, baseConstant, initialDisplacement);
222 } else {
223 assert runtime.getConfig().useCompressedOops == compressed;
224 ret = UNSAFE.getObject(base, displacement);
225 }
226 return ret;
227 }
228
229 JavaConstant readFieldValue(HotSpotResolvedJavaField field, Object obj) {
230 assert obj != null;
231 assert !field.isStatic() || obj instanceof Class;
232 long displacement = field.offset();
233 assert checkRead(field.getJavaKind(), displacement, (HotSpotResolvedObjectType) runtime.getHostJVMCIBackend().getMetaAccess().lookupJavaType(obj.getClass()), obj);
234 if (field.getJavaKind() == JavaKind.Object) {
235 Object o = UNSAFE.getObject(obj, displacement);
236 return HotSpotObjectConstantImpl.forObject(o);
237 } else {
238 JavaKind kind = field.getJavaKind();
239 switch (kind) {
240 case Boolean:
241 return JavaConstant.forBoolean(UNSAFE.getBoolean(obj, displacement));
242 case Byte:
243 return JavaConstant.forByte(UNSAFE.getByte(obj, displacement));
244 case Char:
245 return JavaConstant.forChar(UNSAFE.getChar(obj, displacement));
246 case Short:
247 return JavaConstant.forShort(UNSAFE.getShort(obj, displacement));
248 case Int:
249 return JavaConstant.forInt(UNSAFE.getInt(obj, displacement));
250 case Long:
251 return JavaConstant.forLong(UNSAFE.getLong(obj, displacement));
252 case Float:
253 return JavaConstant.forFloat(UNSAFE.getFloat(obj, displacement));
254 case Double:
255 return JavaConstant.forDouble(UNSAFE.getDouble(obj, displacement));
256 default:
257 throw new IllegalArgumentException("Unsupported kind: " + kind);
258 }
259 }
260 }
261
262 @Override
263 public JavaConstant readPrimitiveConstant(JavaKind kind, Constant baseConstant, long initialDisplacement, int bits) {
264 try {
265 long rawValue = readRawValue(baseConstant, initialDisplacement, kind, bits);
266 switch (kind) {
267 case Boolean:
268 return JavaConstant.forBoolean(rawValue != 0);
269 case Byte:
270 return JavaConstant.forByte((byte) rawValue);
271 case Char:
272 return JavaConstant.forChar((char) rawValue);
273 case Short:
274 return JavaConstant.forShort((short) rawValue);
275 case Int:
276 return JavaConstant.forInt((int) rawValue);
277 case Long:
278 return JavaConstant.forLong(rawValue);
279 case Float:
280 return JavaConstant.forFloat(Float.intBitsToFloat((int) rawValue));
281 case Double:
282 return JavaConstant.forDouble(Double.longBitsToDouble(rawValue));
283 default:
284 throw new IllegalArgumentException("Unsupported kind: " + kind);
285 }
286 } catch (NullPointerException e) {
287 return null;
288 }
289 }
290
291 @Override
292 public JavaConstant readObjectConstant(Constant base, long displacement) {
293 if (base instanceof HotSpotObjectConstantImpl) {
294 Object o = readRawObject(base, displacement, runtime.getConfig().useCompressedOops);
295 return HotSpotObjectConstantImpl.forObject(o);
296 }
297 if (!isValidObjectFieldDisplacement(base, displacement)) {
298 return null;
299 }
300 return HotSpotObjectConstantImpl.forObject(readRawObject(base, displacement, false));
301 }
302
303 @Override
304 public JavaConstant readNarrowOopConstant(Constant base, long displacement) {
305 return HotSpotObjectConstantImpl.forObject(readRawObject(base, displacement, true), true);
306 }
307
308 private HotSpotResolvedObjectTypeImpl readKlass(Constant base, long displacement, boolean compressed) {
309 assert (base instanceof HotSpotMetaspaceConstantImpl) || (base instanceof HotSpotObjectConstantImpl) : base.getClass();
310 Object baseObject = (base instanceof HotSpotMetaspaceConstantImpl) ? ((HotSpotMetaspaceConstantImpl) base).asResolvedJavaType() : ((HotSpotObjectConstantImpl) base).object();
311 return runtime.getCompilerToVM().getResolvedJavaType(baseObject, displacement, compressed);
312 }
313
314 @Override
315 public Constant readKlassPointerConstant(Constant base, long displacement) {
316 HotSpotResolvedObjectTypeImpl klass = readKlass(base, displacement, false);
317 if (klass == null) {
318 return JavaConstant.NULL_POINTER;
319 }
320 return HotSpotMetaspaceConstantImpl.forMetaspaceObject(klass, false);
321 }
322
323 @Override
324 public Constant readNarrowKlassPointerConstant(Constant base, long displacement) {
325 HotSpotResolvedObjectTypeImpl klass = readKlass(base, displacement, true);
326 if (klass == null) {
327 return HotSpotCompressedNullConstant.COMPRESSED_NULL;
328 }
329 return HotSpotMetaspaceConstantImpl.forMetaspaceObject(klass, true);
330 }
331
332 @Override
333 public Constant readMethodPointerConstant(Constant base, long displacement) {
334 assert (base instanceof HotSpotObjectConstantImpl);
335 Object baseObject = ((HotSpotObjectConstantImpl) base).object();
336 HotSpotResolvedJavaMethodImpl method = runtime.getCompilerToVM().getResolvedJavaMethod(baseObject, displacement);
337 return HotSpotMetaspaceConstantImpl.forMetaspaceObject(method, false);
338 }
339 }