21 * questions.
22 */
23 package jdk.vm.ci.hotspot;
24
25 import static java.util.Objects.requireNonNull;
26 import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
27 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
28 import static jdk.vm.ci.hotspot.HotSpotVMConfig.config;
29 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
30
31 import java.lang.annotation.Annotation;
32 import java.lang.reflect.Array;
33 import java.lang.reflect.Constructor;
34 import java.lang.reflect.Method;
35 import java.lang.reflect.Modifier;
36 import java.nio.ByteOrder;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.HashMap;
40
41 import jdk.vm.ci.common.JVMCIError;
42 import jdk.vm.ci.meta.Assumptions.AssumptionResult;
43 import jdk.vm.ci.meta.Assumptions.ConcreteMethod;
44 import jdk.vm.ci.meta.Assumptions.ConcreteSubtype;
45 import jdk.vm.ci.meta.Assumptions.LeafType;
46 import jdk.vm.ci.meta.Assumptions.NoFinalizableSubclass;
47 import jdk.vm.ci.meta.Constant;
48 import jdk.vm.ci.meta.JavaConstant;
49 import jdk.vm.ci.meta.JavaKind;
50 import jdk.vm.ci.meta.JavaType;
51 import jdk.vm.ci.meta.ModifiersProvider;
52 import jdk.vm.ci.meta.ResolvedJavaField;
53 import jdk.vm.ci.meta.ResolvedJavaMethod;
54 import jdk.vm.ci.meta.ResolvedJavaType;
55
56 /**
57 * Implementation of {@link JavaType} for resolved non-primitive HotSpot classes.
58 */
59 final class HotSpotResolvedObjectTypeImpl extends HotSpotResolvedJavaType implements HotSpotResolvedObjectType, HotSpotProxified, MetaspaceWrapperObject {
60
61 /**
110 this.javaClass = javaClass;
111 this.context = context;
112 assert getName().charAt(0) != '[' || isArray() : getName();
113 }
114
115 /**
116 * Returns the name of this type as it would appear in a signature.
117 */
118 private static String getSignatureName(Class<?> javaClass) {
119 if (javaClass.isArray()) {
120 return javaClass.getName().replace('.', '/');
121 }
122 return "L" + javaClass.getName().replace('.', '/') + ";";
123 }
124
125 /**
126 * Gets the metaspace Klass for this type.
127 */
128 long getMetaspaceKlass() {
129 if (HotSpotJVMCIRuntime.getHostWordKind() == JavaKind.Long) {
130 return UNSAFE.getLong(javaClass, (long) config().klassOffset);
131 }
132 return UNSAFE.getInt(javaClass, (long) config().klassOffset) & 0xFFFFFFFFL;
133 }
134
135 public long getMetaspacePointer() {
136 return getMetaspaceKlass();
137 }
138
139 @Override
140 public int getModifiers() {
141 if (isArray()) {
142 return (getElementalType().getModifiers() & (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED)) | Modifier.FINAL | Modifier.ABSTRACT;
143 } else {
144 return getAccessFlags() & ModifiersProvider.jvmClassModifiers();
145 }
146 }
147
148 public int getAccessFlags() {
149 HotSpotVMConfig config = config();
150 return UNSAFE.getInt(getMetaspaceKlass() + config.klassAccessFlagsOffset);
151 }
152
239 Class<?> javaSuperclass = mirror().getSuperclass();
240 return javaSuperclass == null ? null : fromObjectClass(javaSuperclass);
241 }
242
243 @Override
244 public HotSpotResolvedObjectTypeImpl[] getInterfaces() {
245 if (interfaces == null) {
246 Class<?>[] javaInterfaces = mirror().getInterfaces();
247 HotSpotResolvedObjectTypeImpl[] result = new HotSpotResolvedObjectTypeImpl[javaInterfaces.length];
248 for (int i = 0; i < javaInterfaces.length; i++) {
249 result[i] = fromObjectClass(javaInterfaces[i]);
250 }
251 interfaces = result;
252 }
253 return interfaces;
254 }
255
256 @Override
257 public HotSpotResolvedObjectTypeImpl getSingleImplementor() {
258 if (!isInterface()) {
259 throw new JVMCIError("Cannot call getSingleImplementor() on a non-interface type: %s", this);
260 }
261 return compilerToVM().getImplementor(this);
262 }
263
264 public HotSpotResolvedObjectTypeImpl getSupertype() {
265 if (isArray()) {
266 ResolvedJavaType componentType = getComponentType();
267 if (mirror() == Object[].class || componentType.isPrimitive()) {
268 return fromObjectClass(Object.class);
269 }
270 return (HotSpotResolvedObjectTypeImpl) ((HotSpotResolvedObjectTypeImpl) componentType).getSupertype().getArrayClass();
271 }
272 if (isInterface()) {
273 return fromObjectClass(Object.class);
274 }
275 return getSuperclass();
276 }
277
278 @Override
279 public HotSpotResolvedObjectType findLeastCommonAncestor(ResolvedJavaType otherType) {
|
21 * questions.
22 */
23 package jdk.vm.ci.hotspot;
24
25 import static java.util.Objects.requireNonNull;
26 import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
27 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
28 import static jdk.vm.ci.hotspot.HotSpotVMConfig.config;
29 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
30
31 import java.lang.annotation.Annotation;
32 import java.lang.reflect.Array;
33 import java.lang.reflect.Constructor;
34 import java.lang.reflect.Method;
35 import java.lang.reflect.Modifier;
36 import java.nio.ByteOrder;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.HashMap;
40
41 import jdk.vm.ci.meta.Assumptions.AssumptionResult;
42 import jdk.vm.ci.meta.Assumptions.ConcreteMethod;
43 import jdk.vm.ci.meta.Assumptions.ConcreteSubtype;
44 import jdk.vm.ci.meta.Assumptions.LeafType;
45 import jdk.vm.ci.meta.Assumptions.NoFinalizableSubclass;
46 import jdk.vm.ci.meta.Constant;
47 import jdk.vm.ci.meta.JavaConstant;
48 import jdk.vm.ci.meta.JavaKind;
49 import jdk.vm.ci.meta.JavaType;
50 import jdk.vm.ci.meta.ModifiersProvider;
51 import jdk.vm.ci.meta.ResolvedJavaField;
52 import jdk.vm.ci.meta.ResolvedJavaMethod;
53 import jdk.vm.ci.meta.ResolvedJavaType;
54
55 /**
56 * Implementation of {@link JavaType} for resolved non-primitive HotSpot classes.
57 */
58 final class HotSpotResolvedObjectTypeImpl extends HotSpotResolvedJavaType implements HotSpotResolvedObjectType, HotSpotProxified, MetaspaceWrapperObject {
59
60 /**
109 this.javaClass = javaClass;
110 this.context = context;
111 assert getName().charAt(0) != '[' || isArray() : getName();
112 }
113
114 /**
115 * Returns the name of this type as it would appear in a signature.
116 */
117 private static String getSignatureName(Class<?> javaClass) {
118 if (javaClass.isArray()) {
119 return javaClass.getName().replace('.', '/');
120 }
121 return "L" + javaClass.getName().replace('.', '/') + ";";
122 }
123
124 /**
125 * Gets the metaspace Klass for this type.
126 */
127 long getMetaspaceKlass() {
128 if (HotSpotJVMCIRuntime.getHostWordKind() == JavaKind.Long) {
129 return UNSAFE.getLong(javaClass, config().klassOffset);
130 }
131 return UNSAFE.getInt(javaClass, config().klassOffset) & 0xFFFFFFFFL;
132 }
133
134 public long getMetaspacePointer() {
135 return getMetaspaceKlass();
136 }
137
138 @Override
139 public int getModifiers() {
140 if (isArray()) {
141 return (getElementalType().getModifiers() & (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED)) | Modifier.FINAL | Modifier.ABSTRACT;
142 } else {
143 return getAccessFlags() & ModifiersProvider.jvmClassModifiers();
144 }
145 }
146
147 public int getAccessFlags() {
148 HotSpotVMConfig config = config();
149 return UNSAFE.getInt(getMetaspaceKlass() + config.klassAccessFlagsOffset);
150 }
151
238 Class<?> javaSuperclass = mirror().getSuperclass();
239 return javaSuperclass == null ? null : fromObjectClass(javaSuperclass);
240 }
241
242 @Override
243 public HotSpotResolvedObjectTypeImpl[] getInterfaces() {
244 if (interfaces == null) {
245 Class<?>[] javaInterfaces = mirror().getInterfaces();
246 HotSpotResolvedObjectTypeImpl[] result = new HotSpotResolvedObjectTypeImpl[javaInterfaces.length];
247 for (int i = 0; i < javaInterfaces.length; i++) {
248 result[i] = fromObjectClass(javaInterfaces[i]);
249 }
250 interfaces = result;
251 }
252 return interfaces;
253 }
254
255 @Override
256 public HotSpotResolvedObjectTypeImpl getSingleImplementor() {
257 if (!isInterface()) {
258 throw new InternalError("Cannot call getSingleImplementor() on a non-interface type: " + this);
259 }
260 return compilerToVM().getImplementor(this);
261 }
262
263 public HotSpotResolvedObjectTypeImpl getSupertype() {
264 if (isArray()) {
265 ResolvedJavaType componentType = getComponentType();
266 if (mirror() == Object[].class || componentType.isPrimitive()) {
267 return fromObjectClass(Object.class);
268 }
269 return (HotSpotResolvedObjectTypeImpl) ((HotSpotResolvedObjectTypeImpl) componentType).getSupertype().getArrayClass();
270 }
271 if (isInterface()) {
272 return fromObjectClass(Object.class);
273 }
274 return getSuperclass();
275 }
276
277 @Override
278 public HotSpotResolvedObjectType findLeastCommonAncestor(ResolvedJavaType otherType) {
|