src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java
Index
Unified diffs
Context diffs
Sdiffs
Frames
Patch
New
Old
Previous File
Next File
open Cdiff src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java
src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java
Print this page
*** 1,7 ****
/*
! * Copyright (c) 2011, 2018, 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.
--- 1,7 ----
/*
! * Copyright (c) 2011, 2019, 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.
*** 29,42 ****
import static jdk.vm.ci.hotspot.HotSpotModifiers.jvmClassModifiers;
import static jdk.vm.ci.hotspot.HotSpotVMConfig.config;
import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
import java.lang.annotation.Annotation;
- import java.lang.reflect.Array;
- import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
- import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.nio.ByteOrder;
import java.util.HashMap;
import jdk.vm.ci.common.JVMCIError;
--- 29,39 ----
*** 54,161 ****
import jdk.vm.ci.meta.ResolvedJavaType;
import jdk.vm.ci.meta.UnresolvedJavaField;
import jdk.vm.ci.meta.UnresolvedJavaType;
/**
! * Implementation of {@link JavaType} for resolved non-primitive HotSpot classes.
*/
! final class HotSpotResolvedObjectTypeImpl extends HotSpotResolvedJavaType implements HotSpotResolvedObjectType, MetaspaceWrapperObject {
private static final HotSpotResolvedJavaField[] NO_FIELDS = new HotSpotResolvedJavaField[0];
private static final int METHOD_CACHE_ARRAY_CAPACITY = 8;
/**
* The Java class this type represents.
*/
! private final Class<?> javaClass;
private HotSpotResolvedJavaMethodImpl[] methodCacheArray;
private HashMap<Long, HotSpotResolvedJavaMethodImpl> methodCacheHashMap;
! private HotSpotResolvedJavaField[] instanceFields;
! private HotSpotResolvedObjectTypeImpl[] interfaces;
private HotSpotConstantPool constantPool;
- final HotSpotJVMCIMetaAccessContext context;
private HotSpotResolvedObjectType arrayOfType;
/**
! * Managed exclusively by {@link HotSpotResolvedJavaFieldImpl#toJava}.
*/
HashMap<HotSpotResolvedJavaFieldImpl, Field> reflectionFieldCache;
! /**
! * Gets the JVMCI mirror for a {@link Class} object.
! *
! * @return the {@link HotSpotResolvedJavaType} corresponding to {@code javaClass}
! */
! static HotSpotResolvedObjectTypeImpl fromObjectClass(Class<?> javaClass) {
! return (HotSpotResolvedObjectTypeImpl) runtime().fromClass(javaClass);
}
/**
! * Gets the JVMCI mirror from a HotSpot type. Since {@link Class} is already a proxy for the
! * underlying Klass*, it is used instead of the raw Klass*.
*
* Called from the VM.
*
! * @param javaClass a {@link Class} object
* @return the {@link ResolvedJavaType} corresponding to {@code javaClass}
*/
@SuppressWarnings("unused")
! private static HotSpotResolvedObjectTypeImpl fromMetaspace(Class<?> javaClass) {
! return fromObjectClass(javaClass);
}
/**
* Creates the JVMCI mirror for a {@link Class} object.
*
- * <p>
* <b>NOTE</b>: Creating an instance of this class does not install the mirror for the
! * {@link Class} type. Use {@link #fromObjectClass(Class)} or {@link #fromMetaspace(Class)}
! * instead.
* </p>
*
! * @param javaClass the Class to create the mirror for
! * @param context
*/
! HotSpotResolvedObjectTypeImpl(Class<?> javaClass, HotSpotJVMCIMetaAccessContext context) {
! super(getSignatureName(javaClass));
! this.javaClass = javaClass;
! this.context = context;
assert getName().charAt(0) != '[' || isArray() : getName();
}
/**
- * Returns the name of this type as it would appear in a signature.
- */
- private static String getSignatureName(Class<?> javaClass) {
- if (javaClass.isArray()) {
- return javaClass.getName().replace('.', '/');
- }
- return "L" + javaClass.getName().replace('.', '/') + ";";
- }
-
- /**
* Gets the metaspace Klass for this type.
*/
long getMetaspaceKlass() {
! if (HotSpotJVMCIRuntime.getHostWordKind() == JavaKind.Long) {
! return UNSAFE.getLong(javaClass, config().klassOffset);
}
! return UNSAFE.getInt(javaClass, config().klassOffset) & 0xFFFFFFFFL;
}
@Override
public long getMetaspacePointer() {
! return getMetaspaceKlass();
! }
!
! /**
! * The Klass* for this object is kept alive by the direct reference to {@link #javaClass} so no
! * extra work is required.
! */
! @Override
! public boolean isRegistered() {
! return true;
}
@Override
public int getModifiers() {
if (isArray()) {
--- 51,137 ----
import jdk.vm.ci.meta.ResolvedJavaType;
import jdk.vm.ci.meta.UnresolvedJavaField;
import jdk.vm.ci.meta.UnresolvedJavaType;
/**
! * Implementation of {@link JavaType} for resolved non-primitive HotSpot classes. This class is not
! * an {@link MetaspaceHandleObject} because it doesn't have to be scanned for GC. It's liveness is
! * maintained by a reference to the {@link Class} instance.
*/
! final class HotSpotResolvedObjectTypeImpl extends HotSpotResolvedJavaType implements HotSpotResolvedObjectType, MetaspaceObject {
private static final HotSpotResolvedJavaField[] NO_FIELDS = new HotSpotResolvedJavaField[0];
private static final int METHOD_CACHE_ARRAY_CAPACITY = 8;
/**
* The Java class this type represents.
*/
! private final long metadataPointer;
!
private HotSpotResolvedJavaMethodImpl[] methodCacheArray;
private HashMap<Long, HotSpotResolvedJavaMethodImpl> methodCacheHashMap;
! private volatile HotSpotResolvedJavaField[] instanceFields;
! private volatile HotSpotResolvedObjectTypeImpl[] interfaces;
private HotSpotConstantPool constantPool;
private HotSpotResolvedObjectType arrayOfType;
+ private final JavaConstant mirror;
+ private HotSpotResolvedObjectTypeImpl superClass;
/**
! * Managed exclusively by {@link HotSpotJDKReflection#getField}.
*/
HashMap<HotSpotResolvedJavaFieldImpl, Field> reflectionFieldCache;
! static HotSpotResolvedObjectTypeImpl getJavaLangObject() {
! return runtime().getJavaLangObject();
}
/**
! * Gets the JVMCI mirror from a HotSpot type.
*
* Called from the VM.
*
! * @param klassPointer a native pointer to the Klass*
* @return the {@link ResolvedJavaType} corresponding to {@code javaClass}
*/
@SuppressWarnings("unused")
! @VMEntryPoint
! private static HotSpotResolvedObjectTypeImpl fromMetaspace(long klassPointer, String signature) {
! return runtime().fromMetaspace(klassPointer, signature);
}
/**
* Creates the JVMCI mirror for a {@link Class} object.
*
* <b>NOTE</b>: Creating an instance of this class does not install the mirror for the
! * {@link Class} type. {@link #fromMetaspace} instead.
* </p>
*
! * @param metadataPointer the Klass* to create the mirror for
*/
! HotSpotResolvedObjectTypeImpl(long metadataPointer, String name) {
! super(name);
! this.metadataPointer = metadataPointer;
! this.mirror = runtime().compilerToVm.getJavaMirror(this);
! assert metadataPointer != 0;
assert getName().charAt(0) != '[' || isArray() : getName();
}
/**
* Gets the metaspace Klass for this type.
*/
long getMetaspaceKlass() {
! long metaspacePointer = getMetaspacePointer();
! if (metaspacePointer == 0) {
! throw new NullPointerException("Klass* is null");
}
! return metaspacePointer;
}
@Override
public long getMetaspacePointer() {
! return metadataPointer;
}
@Override
public int getModifiers() {
if (isArray()) {
*** 171,189 ****
}
@Override
public HotSpotResolvedObjectType getArrayClass() {
if (arrayOfType == null) {
! arrayOfType = fromObjectClass(Array.newInstance(mirror(), 0).getClass());
}
return arrayOfType;
}
@Override
public ResolvedJavaType getComponentType() {
! Class<?> javaComponentType = mirror().getComponentType();
! return javaComponentType == null ? null : runtime().fromClass(javaComponentType);
}
@Override
public AssumptionResult<ResolvedJavaType> findLeafConcreteSubtype() {
if (isLeaf()) {
--- 147,168 ----
}
@Override
public HotSpotResolvedObjectType getArrayClass() {
if (arrayOfType == null) {
! try {
! arrayOfType = (HotSpotResolvedObjectType) runtime().compilerToVm.lookupType("[" + getName(), this, true);
! } catch (ClassNotFoundException e) {
! throw new JVMCIError(e);
! }
}
return arrayOfType;
}
@Override
public ResolvedJavaType getComponentType() {
! return runtime().compilerToVm.getComponentType(this);
}
@Override
public AssumptionResult<ResolvedJavaType> findLeafConcreteSubtype() {
if (isLeaf()) {
*** 277,299 ****
return compilerToVM().getResolvedJavaType(this, config().subklassOffset, false);
}
@Override
public HotSpotResolvedObjectTypeImpl getSuperclass() {
! Class<?> javaSuperclass = mirror().getSuperclass();
! return javaSuperclass == null ? null : fromObjectClass(javaSuperclass);
}
@Override
public HotSpotResolvedObjectTypeImpl[] getInterfaces() {
if (interfaces == null) {
! Class<?>[] javaInterfaces = mirror().getInterfaces();
! HotSpotResolvedObjectTypeImpl[] result = new HotSpotResolvedObjectTypeImpl[javaInterfaces.length];
! for (int i = 0; i < javaInterfaces.length; i++) {
! result[i] = fromObjectClass(javaInterfaces[i]);
}
- interfaces = result;
}
return interfaces;
}
@Override
--- 256,294 ----
return compilerToVM().getResolvedJavaType(this, config().subklassOffset, false);
}
@Override
public HotSpotResolvedObjectTypeImpl getSuperclass() {
! if (isInterface()) {
! return null;
! }
! HotSpotResolvedObjectTypeImpl javaLangObject = runtime().getJavaLangObject();
! if (this.equals(javaLangObject)) {
! return null;
! }
! if (isArray()) {
! return javaLangObject;
! }
!
! // Cache result of native call
! if (superClass == null) {
! superClass = compilerToVM().getResolvedJavaType(this, config().superOffset, false);
! }
! return superClass;
}
@Override
public HotSpotResolvedObjectTypeImpl[] getInterfaces() {
if (interfaces == null) {
! if (isArray()) {
! HotSpotResolvedObjectTypeImpl[] types = new HotSpotResolvedObjectTypeImpl[2];
! types[0] = runtime().getJavaLangCloneable();
! types[1] = runtime().getJavaLangSerializable();
! this.interfaces = types;
! } else {
! interfaces = runtime().compilerToVm.getInterfaces(this);
}
}
return interfaces;
}
@Override
*** 306,322 ****
@Override
public HotSpotResolvedObjectTypeImpl getSupertype() {
if (isArray()) {
ResolvedJavaType componentType = getComponentType();
! if (mirror() == Object[].class || componentType.isPrimitive()) {
! return fromObjectClass(Object.class);
}
! return (HotSpotResolvedObjectTypeImpl) ((HotSpotResolvedObjectTypeImpl) componentType).getSupertype().getArrayClass();
}
if (isInterface()) {
! return fromObjectClass(Object.class);
}
return getSuperclass();
}
@Override
--- 301,318 ----
@Override
public HotSpotResolvedObjectTypeImpl getSupertype() {
if (isArray()) {
ResolvedJavaType componentType = getComponentType();
! if (componentType.equals(getJavaLangObject()) || componentType.isPrimitive()) {
! return getJavaLangObject();
}
! HotSpotResolvedObjectTypeImpl supertype = ((HotSpotResolvedObjectTypeImpl) componentType).getSupertype();
! return (HotSpotResolvedObjectTypeImpl) supertype.getArrayClass();
}
if (isInterface()) {
! return getJavaLangObject();
}
return getSuperclass();
}
@Override
*** 352,373 ****
public boolean hasFinalizer() {
return (getAccessFlags() & config().jvmAccHasFinalizer) != 0;
}
@Override
- public boolean isPrimitive() {
- return false;
- }
-
- @Override
public boolean isArray() {
! return mirror().isArray();
}
@Override
public boolean isEnum() {
! return mirror().isEnum();
}
@Override
public boolean isInitialized() {
return isArray() ? true : getInitState() == config().instanceKlassStateFullyInitialized;
--- 348,365 ----
public boolean hasFinalizer() {
return (getAccessFlags() & config().jvmAccHasFinalizer) != 0;
}
@Override
public boolean isArray() {
! return layoutHelper() < config().klassLayoutHelperNeutralValue;
}
@Override
public boolean isEnum() {
! HotSpotResolvedObjectTypeImpl superclass = getSuperclass();
! return superclass != null && superclass.equals(runtime().getJavaLangEnum());
}
@Override
public boolean isInitialized() {
return isArray() ? true : getInitState() == config().instanceKlassStateFullyInitialized;
*** 390,408 ****
}
@Override
public void initialize() {
if (!isInitialized()) {
! UNSAFE.ensureClassInitialized(mirror());
assert isInitialized();
}
}
@Override
public boolean isInstance(JavaConstant obj) {
if (obj.getJavaKind() == JavaKind.Object && !obj.isNull()) {
! return mirror().isInstance(((HotSpotObjectConstantImpl) obj).object());
}
return false;
}
@Override
--- 382,400 ----
}
@Override
public void initialize() {
if (!isInitialized()) {
! runtime().compilerToVm.ensureInitialized(this);
assert isInitialized();
}
}
@Override
public boolean isInstance(JavaConstant obj) {
if (obj.getJavaKind() == JavaKind.Object && !obj.isNull()) {
! return runtime().reflection.isInstance(this, (HotSpotObjectConstantImpl) obj);
}
return false;
}
@Override
*** 410,428 ****
return !isArray() && !isInterface();
}
@Override
public boolean isInterface() {
! return mirror().isInterface();
}
@Override
public boolean isAssignableFrom(ResolvedJavaType other) {
assert other != null;
if (other instanceof HotSpotResolvedObjectTypeImpl) {
HotSpotResolvedObjectTypeImpl otherType = (HotSpotResolvedObjectTypeImpl) other;
! return mirror().isAssignableFrom(otherType.mirror());
}
return false;
}
@Override
--- 402,420 ----
return !isArray() && !isInterface();
}
@Override
public boolean isInterface() {
! return (getAccessFlags() & config().jvmAccInterface) != 0;
}
@Override
public boolean isAssignableFrom(ResolvedJavaType other) {
assert other != null;
if (other instanceof HotSpotResolvedObjectTypeImpl) {
HotSpotResolvedObjectTypeImpl otherType = (HotSpotResolvedObjectTypeImpl) other;
! return runtime().reflection.isAssignableFrom(this, otherType);
}
return false;
}
@Override
*** 433,443 ****
return compilerToVM().getHostClass(this);
}
@Override
public boolean isJavaLangObject() {
! return javaClass.equals(Object.class);
}
@Override
public JavaKind getJavaKind() {
return JavaKind.Object;
--- 425,435 ----
return compilerToVM().getHostClass(this);
}
@Override
public boolean isJavaLangObject() {
! return getName().equals("Ljava/lang/Object;");
}
@Override
public JavaKind getJavaKind() {
return JavaKind.Object;
*** 499,531 ****
}
@Override
public int layoutHelper() {
HotSpotVMConfig config = config();
return UNSAFE.getInt(getMetaspaceKlass() + config.klassLayoutHelperOffset);
}
@Override
public long getFingerprint() {
return compilerToVM().getFingerprint(getMetaspaceKlass());
}
! synchronized HotSpotResolvedJavaMethod createMethod(long metaspaceMethod) {
// Maintain cache as array.
if (methodCacheArray == null) {
methodCacheArray = new HotSpotResolvedJavaMethodImpl[METHOD_CACHE_ARRAY_CAPACITY];
}
int i = 0;
for (; i < methodCacheArray.length; ++i) {
HotSpotResolvedJavaMethodImpl curMethod = methodCacheArray[i];
if (curMethod == null) {
! HotSpotResolvedJavaMethodImpl newMethod = new HotSpotResolvedJavaMethodImpl(this, metaspaceMethod);
methodCacheArray[i] = newMethod;
- context.add(newMethod);
return newMethod;
! } else if (curMethod.getMetaspacePointer() == metaspaceMethod) {
return curMethod;
}
}
// Fall-back to hash table.
--- 491,524 ----
}
@Override
public int layoutHelper() {
HotSpotVMConfig config = config();
+ assert getMetaspaceKlass() != 0 : getName();
return UNSAFE.getInt(getMetaspaceKlass() + config.klassLayoutHelperOffset);
}
@Override
public long getFingerprint() {
return compilerToVM().getFingerprint(getMetaspaceKlass());
}
! synchronized HotSpotResolvedJavaMethod createMethod(long metaspaceHandle) {
! long metaspaceMethod = UNSAFE.getLong(metaspaceHandle);
// Maintain cache as array.
if (methodCacheArray == null) {
methodCacheArray = new HotSpotResolvedJavaMethodImpl[METHOD_CACHE_ARRAY_CAPACITY];
}
int i = 0;
for (; i < methodCacheArray.length; ++i) {
HotSpotResolvedJavaMethodImpl curMethod = methodCacheArray[i];
if (curMethod == null) {
! HotSpotResolvedJavaMethodImpl newMethod = new HotSpotResolvedJavaMethodImpl(this, metaspaceHandle);
methodCacheArray[i] = newMethod;
return newMethod;
! } else if (curMethod.getMetaspaceMethod() == metaspaceMethod) {
return curMethod;
}
}
// Fall-back to hash table.
*** 533,545 ****
methodCacheHashMap = new HashMap<>();
}
HotSpotResolvedJavaMethodImpl lookupResult = methodCacheHashMap.get(metaspaceMethod);
if (lookupResult == null) {
! HotSpotResolvedJavaMethodImpl newMethod = new HotSpotResolvedJavaMethodImpl(this, metaspaceMethod);
methodCacheHashMap.put(metaspaceMethod, newMethod);
- context.add(lookupResult);
return newMethod;
} else {
return lookupResult;
}
}
--- 526,537 ----
methodCacheHashMap = new HashMap<>();
}
HotSpotResolvedJavaMethodImpl lookupResult = methodCacheHashMap.get(metaspaceMethod);
if (lookupResult == null) {
! HotSpotResolvedJavaMethodImpl newMethod = new HotSpotResolvedJavaMethodImpl(this, metaspaceHandle);
methodCacheHashMap.put(metaspaceMethod, newMethod);
return newMethod;
} else {
return lookupResult;
}
}
*** 597,606 ****
--- 589,619 ----
FieldInfo createFieldInfo(int index) {
return new FieldInfo(index);
}
+ public void ensureInitialized() {
+ runtime().compilerToVm.ensureInitialized(this);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof HotSpotResolvedObjectTypeImpl)) {
+ return false;
+ }
+ HotSpotResolvedObjectTypeImpl that = (HotSpotResolvedObjectTypeImpl) obj;
+ return getMetaspaceKlass() == that.getMetaspaceKlass();
+ }
+
+ @Override
+ JavaConstant getJavaMirror() {
+ return mirror;
+ }
+
/**
* This class represents the field information for one field contained in the fields array of an
* {@code InstanceKlass}. The implementation is similar to the native {@code FieldInfo} class.
*/
class FieldInfo {
*** 780,794 ****
return result;
}
@Override
- public Class<?> mirror() {
- return javaClass;
- }
-
- @Override
public String getSourceFileName() {
HotSpotVMConfig config = config();
final int sourceFileNameIndex = UNSAFE.getChar(getMetaspaceKlass() + config.instanceKlassSourceFileNameIndexOffset);
if (sourceFileNameIndex == 0) {
return null;
--- 793,802 ----
*** 796,816 ****
return getConstantPool().lookupUtf8(sourceFileNameIndex);
}
@Override
public Annotation[] getAnnotations() {
! return mirror().getAnnotations();
}
@Override
public Annotation[] getDeclaredAnnotations() {
! return mirror().getDeclaredAnnotations();
}
@Override
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
! return mirror().getAnnotation(annotationClass);
}
/**
* Performs a fast-path check that this type is resolved in the context of a given accessing
* class. A negative result does not mean this type is not resolved with respect to
--- 804,824 ----
return getConstantPool().lookupUtf8(sourceFileNameIndex);
}
@Override
public Annotation[] getAnnotations() {
! return runtime().reflection.getAnnotations(this);
}
@Override
public Annotation[] getDeclaredAnnotations() {
! return runtime().reflection.getDeclaredAnnotations(this);
}
@Override
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
! return runtime().reflection.getAnnotation(this, annotationClass);
}
/**
* Performs a fast-path check that this type is resolved in the context of a given accessing
* class. A negative result does not mean this type is not resolved with respect to
*** 826,841 ****
// Primitive type resolution is context free.
return true;
}
if (elementType.getName().startsWith("Ljava/")) {
// Classes in a java.* package can only be defined by the
! // boot or platform class loader.
return true;
}
! ClassLoader thisCl = mirror().getClassLoader();
! ClassLoader accessingClassCl = ((HotSpotResolvedObjectTypeImpl) accessingClass).mirror().getClassLoader();
! return thisCl == accessingClassCl;
}
@Override
public ResolvedJavaType resolve(ResolvedJavaType accessingClass) {
if (isDefinitelyResolvedWithRespectTo(requireNonNull(accessingClass))) {
--- 834,854 ----
// Primitive type resolution is context free.
return true;
}
if (elementType.getName().startsWith("Ljava/")) {
// Classes in a java.* package can only be defined by the
! // boot class loader. This is enforced by ClassLoader.preDefineClass()
! assert hasSameClassLoader(runtime().getJavaLangObject());
return true;
}
! HotSpotResolvedObjectTypeImpl otherMirror = ((HotSpotResolvedObjectTypeImpl) accessingClass);
! return hasSameClassLoader(otherMirror);
! }
!
! private boolean hasSameClassLoader(HotSpotResolvedObjectTypeImpl otherMirror) {
! return UnsafeAccess.UNSAFE.getAddress(getMetaspaceKlass() + config().classLoaderDataOffset) == UnsafeAccess.UNSAFE.getAddress(
! otherMirror.getMetaspaceKlass() + config().classLoaderDataOffset);
}
@Override
public ResolvedJavaType resolve(ResolvedJavaType accessingClass) {
if (isDefinitelyResolvedWithRespectTo(requireNonNull(accessingClass))) {
*** 885,904 ****
return findFieldWithOffset(offset, expectedEntryKind, declaredFields);
}
private static ResolvedJavaField findFieldWithOffset(long offset, JavaKind expectedEntryKind, ResolvedJavaField[] declaredFields) {
for (ResolvedJavaField field : declaredFields) {
! HotSpotResolvedJavaField resolvedField = (HotSpotResolvedJavaField) field;
! long resolvedFieldOffset = resolvedField.getOffset();
// @formatter:off
if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN &&
expectedEntryKind.isPrimitive() &&
!expectedEntryKind.equals(JavaKind.Void) &&
! resolvedField.getJavaKind().isPrimitive()) {
resolvedFieldOffset +=
! resolvedField.getJavaKind().getByteCount() -
! Math.min(resolvedField.getJavaKind().getByteCount(), 4 + expectedEntryKind.getByteCount());
}
if (resolvedFieldOffset == offset) {
return field;
}
// @formatter:on
--- 898,916 ----
return findFieldWithOffset(offset, expectedEntryKind, declaredFields);
}
private static ResolvedJavaField findFieldWithOffset(long offset, JavaKind expectedEntryKind, ResolvedJavaField[] declaredFields) {
for (ResolvedJavaField field : declaredFields) {
! long resolvedFieldOffset = field.getOffset();
// @formatter:off
if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN &&
expectedEntryKind.isPrimitive() &&
!expectedEntryKind.equals(JavaKind.Void) &&
! field.getJavaKind().isPrimitive()) {
resolvedFieldOffset +=
! field.getJavaKind().getByteCount() -
! Math.min(field.getJavaKind().getByteCount(), 4 + expectedEntryKind.getByteCount());
}
if (resolvedFieldOffset == offset) {
return field;
}
// @formatter:on
*** 906,949 ****
return null;
}
@Override
public boolean isLocal() {
! return mirror().isLocalClass();
}
@Override
public boolean isMember() {
! return mirror().isMemberClass();
}
@Override
! public HotSpotResolvedObjectTypeImpl getEnclosingType() {
! final Class<?> encl = mirror().getEnclosingClass();
! return encl == null ? null : fromObjectClass(encl);
}
@Override
public ResolvedJavaMethod[] getDeclaredConstructors() {
! Constructor<?>[] constructors = mirror().getDeclaredConstructors();
! ResolvedJavaMethod[] result = new ResolvedJavaMethod[constructors.length];
! for (int i = 0; i < constructors.length; i++) {
! result[i] = runtime().getHostJVMCIBackend().getMetaAccess().lookupJavaMethod(constructors[i]);
! assert result[i].isConstructor();
! }
! return result;
}
@Override
public ResolvedJavaMethod[] getDeclaredMethods() {
! Method[] methods = mirror().getDeclaredMethods();
! ResolvedJavaMethod[] result = new ResolvedJavaMethod[methods.length];
! for (int i = 0; i < methods.length; i++) {
! result[i] = runtime().getHostJVMCIBackend().getMetaAccess().lookupJavaMethod(methods[i]);
! assert !result[i].isConstructor();
! }
! return result;
}
@Override
public ResolvedJavaMethod getClassInitializer() {
if (!isArray()) {
--- 918,948 ----
return null;
}
@Override
public boolean isLocal() {
! return runtime().reflection.isLocalClass(this);
}
@Override
public boolean isMember() {
! return runtime().reflection.isMemberClass(this);
}
@Override
! public HotSpotResolvedObjectType getEnclosingType() {
! return runtime().reflection.getEnclosingClass(this);
}
@Override
public ResolvedJavaMethod[] getDeclaredConstructors() {
! return runtime().compilerToVm.getDeclaredConstructors(this);
}
@Override
public ResolvedJavaMethod[] getDeclaredMethods() {
! return runtime().compilerToVm.getDeclaredMethods(this);
}
@Override
public ResolvedJavaMethod getClassInitializer() {
if (!isArray()) {
*** 984,993 ****
--- 983,996 ----
@Override
public boolean isCloneableWithAllocation() {
return (getAccessFlags() & config().jvmAccIsCloneableFast) != 0;
}
+ JavaConstant readFieldValue(HotSpotResolvedJavaField field, boolean isVolatile) {
+ return runtime().reflection.readFieldValue(this, field, isVolatile);
+ }
+
private int getMiscFlags() {
return UNSAFE.getInt(getMetaspaceKlass() + config().instanceKlassMiscFlagsOffset);
}
@Override
src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java
Index
Unified diffs
Context diffs
Sdiffs
Frames
Patch
New
Old
Previous File
Next File