1 /*
2 * Copyright (c) 2014, 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.CompilerToVM.compilerToVM;
26 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
27
28 import java.lang.invoke.MethodHandle;
29
30 import jdk.vm.ci.common.JVMCIError;
31 import jdk.vm.ci.common.NativeImageReinitialize;
32 import jdk.vm.ci.hotspot.HotSpotMethodData.VMState;
33 import jdk.vm.ci.meta.ConstantReflectionProvider;
34 import jdk.vm.ci.meta.JavaConstant;
35 import jdk.vm.ci.meta.MethodHandleAccessProvider;
36 import jdk.vm.ci.meta.ResolvedJavaField;
37 import jdk.vm.ci.meta.ResolvedJavaMethod;
38 import jdk.vm.ci.meta.ResolvedJavaType;
39
40 public class HotSpotMethodHandleAccessProvider implements MethodHandleAccessProvider {
41
42 private final ConstantReflectionProvider constantReflection;
43
44 public HotSpotMethodHandleAccessProvider(ConstantReflectionProvider constantReflection) {
45 this.constantReflection = constantReflection;
46 }
47
48 /**
49 * Lazy initialized reflection on {@link MethodHandle} internals. Field and method lookup is
50 * only possible after the {@link HotSpotJVMCIRuntime} is fully initialized.
51 */
52 static final class Internals {
53 final ResolvedJavaType lambdaFormType;
54 final ResolvedJavaField methodHandleFormField;
55 final ResolvedJavaField lambdaFormVmentryField;
56 final HotSpotResolvedJavaField callSiteTargetField;
57 final ResolvedJavaField methodField;
58 final HotSpotResolvedJavaField vmtargetField;
59
60 /**
61 * Search for an instance field with the given name in a class.
62 *
63 * @param declaringType the type declaring the field
64 * @param fieldName name of the field to be searched
65 * @param fieldType resolved Java type of the field
66 * @return resolved Java field
67 * @throws NoSuchFieldError
68 */
69 private static ResolvedJavaField findFieldInClass(ResolvedJavaType declaringType, String fieldName, ResolvedJavaType fieldType) {
70 ResolvedJavaField[] fields = declaringType.getInstanceFields(false);
71 for (ResolvedJavaField field : fields) {
72 if (field.getName().equals(fieldName) && field.getType().equals(fieldType)) {
73 return field;
74 }
75 }
76 throw new NoSuchFieldError(declaringType + "." + fieldName);
77 }
78
79 private static ResolvedJavaType resolveType(String className) {
80 return (ResolvedJavaType) runtime().lookupTypeInternal(className, null, true);
81 }
82
83 private Internals() {
84 try {
85 ResolvedJavaType methodHandleType = resolveType("Ljava/lang/invoke/MethodHandle;");
86 ResolvedJavaType memberNameType = resolveType("Ljava/lang/invoke/MemberName;");
87 lambdaFormType = resolveType("Ljava/lang/invoke/LambdaForm;");
88 methodHandleFormField = findFieldInClass(methodHandleType, "form", lambdaFormType);
89 lambdaFormVmentryField = findFieldInClass(lambdaFormType, "vmentry", memberNameType);
90
91 ResolvedJavaType methodType = resolveType("Ljava/lang/invoke/ResolvedMethodName;");
92 methodField = findFieldInClass(memberNameType, "method", methodType);
93 vmtargetField = (HotSpotResolvedJavaField) findFieldInClass(methodType, "vmtarget", resolveType(Character.toString(HotSpotJVMCIRuntime.getHostWordKind().getTypeChar())));
94
95 ResolvedJavaType callSiteType = resolveType("Ljava/lang/invoke/CallSite;");
96 callSiteTargetField = (HotSpotResolvedJavaField) findFieldInClass(callSiteType, "target", methodHandleType);
97 } catch (Throwable ex) {
98 throw new JVMCIError(ex);
99 }
100 }
101
102 /**
103 * Singleton instance lazily initialized via double-checked locking.
104 */
105 @NativeImageReinitialize private static volatile Internals instance;
106
107 static Internals instance() {
108 Internals result = instance;
109 if (result == null) {
110 synchronized (VMState.class) {
111 result = instance;
112 if (result == null) {
113 instance = result = new Internals();
114 }
115 }
116 }
117 return result;
118 }
119
120 }
121
122
123 @Override
124 public IntrinsicMethod lookupMethodHandleIntrinsic(ResolvedJavaMethod method) {
125 int intrinsicId = ((HotSpotResolvedJavaMethodImpl) method).intrinsicId();
126 if (intrinsicId != 0) {
127 return getMethodHandleIntrinsic(intrinsicId);
128 }
129 return null;
130 }
131
132 public static IntrinsicMethod getMethodHandleIntrinsic(int intrinsicId) {
133 HotSpotVMConfig config = runtime().getConfig();
134 if (intrinsicId == config.vmIntrinsicInvokeBasic) {
135 return IntrinsicMethod.INVOKE_BASIC;
136 } else if (intrinsicId == config.vmIntrinsicLinkToInterface) {
137 return IntrinsicMethod.LINK_TO_INTERFACE;
138 } else if (intrinsicId == config.vmIntrinsicLinkToSpecial) {
139 return IntrinsicMethod.LINK_TO_SPECIAL;
140 } else if (intrinsicId == config.vmIntrinsicLinkToStatic) {
141 return IntrinsicMethod.LINK_TO_STATIC;
142 } else if (intrinsicId == config.vmIntrinsicLinkToVirtual) {
143 return IntrinsicMethod.LINK_TO_VIRTUAL;
144 }
145 return null;
146 }
147
148 @Override
149 public ResolvedJavaMethod resolveInvokeBasicTarget(JavaConstant methodHandle, boolean forceBytecodeGeneration) {
150 if (methodHandle.isNull()) {
151 return null;
152 }
153
154 /* Load non-public field: LambdaForm MethodHandle.form */
155 Internals internals = Internals.instance();
156 JavaConstant lambdaForm = constantReflection.readFieldValue(internals.methodHandleFormField, methodHandle);
157 if (lambdaForm == null || lambdaForm.isNull()) {
158 return null;
159 }
160
161 JavaConstant memberName = constantReflection.readFieldValue(internals.lambdaFormVmentryField, lambdaForm);
162 if (memberName.isNull() && forceBytecodeGeneration) {
163 compilerToVM().compileToBytecode((HotSpotObjectConstantImpl) lambdaForm);
164 memberName = constantReflection.readFieldValue(internals.lambdaFormVmentryField, lambdaForm);
165 assert memberName.isNonNull();
166 }
167 JavaConstant method = constantReflection.readFieldValue(internals.methodField, memberName);
168 return getTargetMethod(method);
169 }
170
171 @Override
172 public ResolvedJavaMethod resolveLinkToTarget(JavaConstant memberName) {
173 if (memberName.isNull()) {
174 return null;
175 }
176 JavaConstant method = constantReflection.readFieldValue(Internals.instance().methodField, memberName);
177 return getTargetMethod(method);
178 }
179
180 /**
181 * Returns the {@link ResolvedJavaMethod} for the method of a java.lang.invoke.MemberName.
182 */
183 private static ResolvedJavaMethod getTargetMethod(JavaConstant method) {
184 if (method == null) {
185 // If readFieldValue returns NULL the type was wrong
186 throw new IllegalArgumentException("unexpected type for memberName");
187 }
188
189 /* Read the ResolvedJavaMethod from the injected field MemberName.method.vmtarget */
190 return compilerToVM().getResolvedJavaMethod((HotSpotObjectConstantImpl) method, Internals.instance().vmtargetField.getOffset());
191 }
192 }