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.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 {
61 }
62
63 public ResolvedJavaType lookupJavaType(Class<?> clazz) {
64 if (clazz == null) {
65 throw new IllegalArgumentException("Class parameter was null");
66 }
67 return runtime.fromClass(clazz);
68 }
69
70 public HotSpotResolvedObjectType lookupJavaType(JavaConstant constant) {
71 if (constant.isNull() || !(constant instanceof HotSpotObjectConstant)) {
72 return null;
73 }
74 return ((HotSpotObjectConstant) constant).getType();
75 }
76
77 public Signature parseMethodDescriptor(String signature) {
78 return new HotSpotSignature(runtime, signature);
79 }
80
81 /**
82 * {@link Field} object of {@link Method#slot}.
83 */
84 private Field reflectionMethodSlot = getReflectionSlotField(Method.class);
85
86 /**
87 * {@link Field} object of {@link Constructor#slot}.
88 */
89 private Field reflectionConstructorSlot = getReflectionSlotField(Constructor.class);
90
91 private static Field getReflectionSlotField(Class<?> reflectionClass) {
92 try {
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 }
|
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.HotSpotResolvedObjectTypeImpl.fromObjectClass;
28 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
29
30 import java.lang.reflect.Array;
31 import java.lang.reflect.Executable;
32 import java.lang.reflect.Field;
33 import java.lang.reflect.Modifier;
34 import java.util.Objects;
35
36 import jdk.vm.ci.code.CodeUtil;
37 import jdk.vm.ci.code.TargetDescription;
38 import jdk.vm.ci.common.JVMCIError;
39 import jdk.vm.ci.meta.DeoptimizationAction;
40 import jdk.vm.ci.meta.DeoptimizationReason;
41 import jdk.vm.ci.meta.JavaConstant;
42 import jdk.vm.ci.meta.JavaKind;
43 import jdk.vm.ci.meta.MetaAccessProvider;
44 import jdk.vm.ci.meta.ResolvedJavaField;
45 import jdk.vm.ci.meta.ResolvedJavaMethod;
46 import jdk.vm.ci.meta.ResolvedJavaType;
47 import jdk.vm.ci.meta.Signature;
48
49 // JaCoCo Exclude
50
51 /**
52 * HotSpot implementation of {@link MetaAccessProvider}.
53 */
54 public class HotSpotMetaAccessProvider implements MetaAccessProvider {
60 }
61
62 public ResolvedJavaType lookupJavaType(Class<?> clazz) {
63 if (clazz == null) {
64 throw new IllegalArgumentException("Class parameter was null");
65 }
66 return runtime.fromClass(clazz);
67 }
68
69 public HotSpotResolvedObjectType lookupJavaType(JavaConstant constant) {
70 if (constant.isNull() || !(constant instanceof HotSpotObjectConstant)) {
71 return null;
72 }
73 return ((HotSpotObjectConstant) constant).getType();
74 }
75
76 public Signature parseMethodDescriptor(String signature) {
77 return new HotSpotSignature(runtime, signature);
78 }
79
80 public ResolvedJavaMethod lookupJavaMethod(Executable reflectionMethod) {
81 return runtime.getCompilerToVM().asResolvedJavaMethod(Objects.requireNonNull(reflectionMethod));
82 }
83
84 public ResolvedJavaField lookupJavaField(Field reflectionField) {
85 Class<?> fieldHolder = reflectionField.getDeclaringClass();
86
87 HotSpotResolvedObjectType holder = fromObjectClass(fieldHolder);
88 if (Modifier.isStatic(reflectionField.getModifiers())) {
89 final long offset = UNSAFE.staticFieldOffset(reflectionField);
90 for (ResolvedJavaField field : holder.getStaticFields()) {
91 if (offset == ((HotSpotResolvedJavaField) field).offset()) {
92 return field;
93 }
94 }
95 } else {
96 final long offset = UNSAFE.objectFieldOffset(reflectionField);
97 for (ResolvedJavaField field : holder.getInstanceFields(false)) {
98 if (offset == ((HotSpotResolvedJavaField) field).offset()) {
99 return field;
100 }
101 }
|