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