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.HotSpotResolvedObjectTypeImpl.fromObjectClass;
28 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
29
30 import java.lang.reflect.Array;
31 import java.lang.reflect.Constructor;
32 import java.lang.reflect.Executable;
33 import java.lang.reflect.Field;
34 import java.lang.reflect.Method;
35 import java.lang.reflect.Modifier;
36
37 import jdk.vm.ci.code.CodeUtil;
38 import jdk.vm.ci.code.TargetDescription;
39 import jdk.vm.ci.common.JVMCIError;
40 import jdk.vm.ci.meta.DeoptimizationAction;
41 import jdk.vm.ci.meta.DeoptimizationReason;
42 import jdk.vm.ci.meta.JavaConstant;
43 import jdk.vm.ci.meta.JavaKind;
44 import jdk.vm.ci.meta.JavaType;
45 import jdk.vm.ci.meta.MetaAccessProvider;
46 import jdk.vm.ci.meta.ResolvedJavaField;
47 import jdk.vm.ci.meta.ResolvedJavaMethod;
48 import jdk.vm.ci.meta.ResolvedJavaType;
49 import jdk.vm.ci.meta.Signature;
50
51 // JaCoCo Exclude
52
53 /**
54 * HotSpot implementation of {@link MetaAccessProvider}.
55 */
56 public class HotSpotMetaAccessProvider implements MetaAccessProvider, HotSpotProxified {
57
58 protected final HotSpotJVMCIRuntimeProvider runtime;
59
60 public HotSpotMetaAccessProvider(HotSpotJVMCIRuntimeProvider runtime) {
61 this.runtime = runtime;
62 }
63
64 public ResolvedJavaType lookupJavaType(Class<?> clazz) {
94 Field field = reflectionClass.getDeclaredField("slot");
95 field.setAccessible(true);
96 return field;
97 } catch (NoSuchFieldException | SecurityException e) {
98 throw new JVMCIError(e);
99 }
100 }
101
102 public ResolvedJavaMethod lookupJavaMethod(Executable reflectionMethod) {
103 try {
104 Class<?> holder = reflectionMethod.getDeclaringClass();
105 Field slotField = reflectionMethod instanceof Constructor ? reflectionConstructorSlot : reflectionMethodSlot;
106 final int slot = slotField.getInt(reflectionMethod);
107 return runtime.getCompilerToVM().getResolvedJavaMethodAtSlot(holder, slot);
108 } catch (IllegalArgumentException | IllegalAccessException e) {
109 throw new JVMCIError(e);
110 }
111 }
112
113 public ResolvedJavaField lookupJavaField(Field reflectionField) {
114 String name = reflectionField.getName();
115 Class<?> fieldHolder = reflectionField.getDeclaringClass();
116 Class<?> fieldType = reflectionField.getType();
117 // java.lang.reflect.Field's modifiers should be enough here since VM internal modifier bits
118 // are not used (yet).
119 final int modifiers = reflectionField.getModifiers();
120 final long offset = Modifier.isStatic(modifiers) ? UNSAFE.staticFieldOffset(reflectionField) : UNSAFE.objectFieldOffset(reflectionField);
121
122 HotSpotResolvedObjectType holder = fromObjectClass(fieldHolder);
123 JavaType type = runtime.fromClass(fieldType);
124
125 if (offset != -1) {
126 HotSpotResolvedObjectType resolved = holder;
127 return resolved.createField(name, type, offset, modifiers);
128 } else {
129 throw new JVMCIError("unresolved field %s", reflectionField);
130 }
131 }
132
133 private static int intMaskRight(int n) {
134 assert n <= 32;
135 return n == 32 ? -1 : (1 << n) - 1;
136 }
137
138 @Override
139 public JavaConstant encodeDeoptActionAndReason(DeoptimizationAction action, DeoptimizationReason reason, int debugId) {
140 HotSpotVMConfig config = runtime.getConfig();
141 int actionValue = convertDeoptAction(action);
142 int reasonValue = convertDeoptReason(reason);
143 int debugValue = debugId & intMaskRight(config.deoptimizationDebugIdBits);
144 JavaConstant c = JavaConstant.forInt(~((debugValue << config.deoptimizationDebugIdShift) | (reasonValue << config.deoptimizationReasonShift) | (actionValue << config.deoptimizationActionShift)));
145 assert c.asInt() < 0;
146 return c;
147 }
148
149 public DeoptimizationReason decodeDeoptReason(JavaConstant constant) {
150 HotSpotVMConfig config = runtime.getConfig();
|
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.HotSpotResolvedObjectTypeImpl.fromObjectClass;
28 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
29
30 import java.lang.reflect.Array;
31 import java.lang.reflect.Constructor;
32 import java.lang.reflect.Executable;
33 import java.lang.reflect.Field;
34 import java.lang.reflect.Method;
35 import java.lang.reflect.Modifier;
36
37 import jdk.vm.ci.code.CodeUtil;
38 import jdk.vm.ci.code.TargetDescription;
39 import jdk.vm.ci.common.JVMCIError;
40 import jdk.vm.ci.meta.DeoptimizationAction;
41 import jdk.vm.ci.meta.DeoptimizationReason;
42 import jdk.vm.ci.meta.JavaConstant;
43 import jdk.vm.ci.meta.JavaKind;
44 import jdk.vm.ci.meta.MetaAccessProvider;
45 import jdk.vm.ci.meta.ResolvedJavaField;
46 import jdk.vm.ci.meta.ResolvedJavaMethod;
47 import jdk.vm.ci.meta.ResolvedJavaType;
48 import jdk.vm.ci.meta.Signature;
49
50 // JaCoCo Exclude
51
52 /**
53 * HotSpot implementation of {@link MetaAccessProvider}.
54 */
55 public class HotSpotMetaAccessProvider implements MetaAccessProvider, HotSpotProxified {
56
57 protected final HotSpotJVMCIRuntimeProvider runtime;
58
59 public HotSpotMetaAccessProvider(HotSpotJVMCIRuntimeProvider runtime) {
60 this.runtime = runtime;
61 }
62
63 public ResolvedJavaType lookupJavaType(Class<?> clazz) {
93 Field field = reflectionClass.getDeclaredField("slot");
94 field.setAccessible(true);
95 return field;
96 } catch (NoSuchFieldException | SecurityException e) {
97 throw new JVMCIError(e);
98 }
99 }
100
101 public ResolvedJavaMethod lookupJavaMethod(Executable reflectionMethod) {
102 try {
103 Class<?> holder = reflectionMethod.getDeclaringClass();
104 Field slotField = reflectionMethod instanceof Constructor ? reflectionConstructorSlot : reflectionMethodSlot;
105 final int slot = slotField.getInt(reflectionMethod);
106 return runtime.getCompilerToVM().getResolvedJavaMethodAtSlot(holder, slot);
107 } catch (IllegalArgumentException | IllegalAccessException e) {
108 throw new JVMCIError(e);
109 }
110 }
111
112 public ResolvedJavaField lookupJavaField(Field reflectionField) {
113 Class<?> fieldHolder = reflectionField.getDeclaringClass();
114
115 HotSpotResolvedObjectType holder = fromObjectClass(fieldHolder);
116 if (Modifier.isStatic(reflectionField.getModifiers())) {
117 final long offset = UNSAFE.staticFieldOffset(reflectionField);
118 for (ResolvedJavaField field : holder.getStaticFields()) {
119 if (offset == ((HotSpotResolvedJavaField) field).offset()) {
120 return field;
121 }
122 }
123 } else {
124 final long offset = UNSAFE.objectFieldOffset(reflectionField);
125 for (ResolvedJavaField field : holder.getInstanceFields(false)) {
126 if (offset == ((HotSpotResolvedJavaField) field).offset()) {
127 return field;
128 }
129 }
130 }
131
132 throw new JVMCIError("unresolved field %s", reflectionField);
133 }
134
135 private static int intMaskRight(int n) {
136 assert n <= 32;
137 return n == 32 ? -1 : (1 << n) - 1;
138 }
139
140 @Override
141 public JavaConstant encodeDeoptActionAndReason(DeoptimizationAction action, DeoptimizationReason reason, int debugId) {
142 HotSpotVMConfig config = runtime.getConfig();
143 int actionValue = convertDeoptAction(action);
144 int reasonValue = convertDeoptReason(reason);
145 int debugValue = debugId & intMaskRight(config.deoptimizationDebugIdBits);
146 JavaConstant c = JavaConstant.forInt(~((debugValue << config.deoptimizationDebugIdShift) | (reasonValue << config.deoptimizationReasonShift) | (actionValue << config.deoptimizationActionShift)));
147 assert c.asInt() < 0;
148 return c;
149 }
150
151 public DeoptimizationReason decodeDeoptReason(JavaConstant constant) {
152 HotSpotVMConfig config = runtime.getConfig();
|