1 /*
2 * Copyright (c) 2011, 2015, 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.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) {
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 }
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();
153 int reasonValue = ((~constant.asInt()) >> config.deoptimizationReasonShift) & intMaskRight(config.deoptimizationReasonBits);
154 DeoptimizationReason reason = convertDeoptReason(reasonValue);
155 return reason;
156 }
157
158 public DeoptimizationAction decodeDeoptAction(JavaConstant constant) {
159 HotSpotVMConfig config = runtime.getConfig();
160 int actionValue = ((~constant.asInt()) >> config.deoptimizationActionShift) & intMaskRight(config.deoptimizationActionBits);
161 DeoptimizationAction action = convertDeoptAction(actionValue);
162 return action;
163 }
164
165 public int decodeDebugId(JavaConstant constant) {
166 HotSpotVMConfig config = runtime.getConfig();
167 return ((~constant.asInt()) >> config.deoptimizationDebugIdShift) & intMaskRight(config.deoptimizationDebugIdBits);
168 }
169
170 public int convertDeoptAction(DeoptimizationAction action) {
171 HotSpotVMConfig config = runtime.getConfig();
172 switch (action) {
173 case None:
174 return config.deoptActionNone;
175 case RecompileIfTooManyDeopts:
176 return config.deoptActionMaybeRecompile;
177 case InvalidateReprofile:
178 return config.deoptActionReinterpret;
179 case InvalidateRecompile:
180 return config.deoptActionMakeNotEntrant;
181 case InvalidateStopCompiling:
182 return config.deoptActionMakeNotCompilable;
183 default:
184 throw new JVMCIError("%s", action);
185 }
186 }
187
188 public DeoptimizationAction convertDeoptAction(int action) {
189 HotSpotVMConfig config = runtime.getConfig();
190 if (action == config.deoptActionNone) {
191 return DeoptimizationAction.None;
192 }
193 if (action == config.deoptActionMaybeRecompile) {
194 return DeoptimizationAction.RecompileIfTooManyDeopts;
195 }
196 if (action == config.deoptActionReinterpret) {
197 return DeoptimizationAction.InvalidateReprofile;
198 }
199 if (action == config.deoptActionMakeNotEntrant) {
200 return DeoptimizationAction.InvalidateRecompile;
201 }
202 if (action == config.deoptActionMakeNotCompilable) {
203 return DeoptimizationAction.InvalidateStopCompiling;
204 }
205 throw new JVMCIError("%d", action);
206 }
207
208 public int convertDeoptReason(DeoptimizationReason reason) {
209 HotSpotVMConfig config = runtime.getConfig();
210 switch (reason) {
211 case None:
212 return config.deoptReasonNone;
213 case NullCheckException:
214 return config.deoptReasonNullCheck;
215 case BoundsCheckException:
216 return config.deoptReasonRangeCheck;
217 case ClassCastException:
218 return config.deoptReasonClassCheck;
219 case ArrayStoreException:
220 return config.deoptReasonArrayCheck;
221 case UnreachedCode:
222 return config.deoptReasonUnreached0;
223 case TypeCheckedInliningViolated:
224 return config.deoptReasonTypeCheckInlining;
225 case OptimizedTypeCheckViolated:
226 return config.deoptReasonOptimizedTypeCheck;
227 case NotCompiledExceptionHandler:
228 return config.deoptReasonNotCompiledExceptionHandler;
229 case Unresolved:
230 return config.deoptReasonUnresolved;
231 case JavaSubroutineMismatch:
232 return config.deoptReasonJsrMismatch;
233 case ArithmeticException:
234 return config.deoptReasonDiv0Check;
235 case RuntimeConstraint:
236 return config.deoptReasonConstraint;
237 case LoopLimitCheck:
238 return config.deoptReasonLoopLimitCheck;
239 case Aliasing:
240 return config.deoptReasonAliasing;
241 case TransferToInterpreter:
242 return config.deoptReasonTransferToInterpreter;
243 default:
244 throw new JVMCIError("%s", reason);
245 }
246 }
247
248 public DeoptimizationReason convertDeoptReason(int reason) {
249 HotSpotVMConfig config = runtime.getConfig();
250 if (reason == config.deoptReasonNone) {
251 return DeoptimizationReason.None;
252 }
253 if (reason == config.deoptReasonNullCheck) {
254 return DeoptimizationReason.NullCheckException;
255 }
256 if (reason == config.deoptReasonRangeCheck) {
257 return DeoptimizationReason.BoundsCheckException;
258 }
259 if (reason == config.deoptReasonClassCheck) {
260 return DeoptimizationReason.ClassCastException;
261 }
262 if (reason == config.deoptReasonArrayCheck) {
263 return DeoptimizationReason.ArrayStoreException;
264 }
265 if (reason == config.deoptReasonUnreached0) {
266 return DeoptimizationReason.UnreachedCode;
267 }
268 if (reason == config.deoptReasonTypeCheckInlining) {
269 return DeoptimizationReason.TypeCheckedInliningViolated;
270 }
271 if (reason == config.deoptReasonOptimizedTypeCheck) {
272 return DeoptimizationReason.OptimizedTypeCheckViolated;
273 }
274 if (reason == config.deoptReasonNotCompiledExceptionHandler) {
275 return DeoptimizationReason.NotCompiledExceptionHandler;
276 }
277 if (reason == config.deoptReasonUnresolved) {
278 return DeoptimizationReason.Unresolved;
279 }
280 if (reason == config.deoptReasonJsrMismatch) {
281 return DeoptimizationReason.JavaSubroutineMismatch;
282 }
283 if (reason == config.deoptReasonDiv0Check) {
284 return DeoptimizationReason.ArithmeticException;
285 }
286 if (reason == config.deoptReasonConstraint) {
287 return DeoptimizationReason.RuntimeConstraint;
288 }
289 if (reason == config.deoptReasonLoopLimitCheck) {
290 return DeoptimizationReason.LoopLimitCheck;
291 }
292 if (reason == config.deoptReasonAliasing) {
293 return DeoptimizationReason.Aliasing;
294 }
295 if (reason == config.deoptReasonTransferToInterpreter) {
296 return DeoptimizationReason.TransferToInterpreter;
297 }
298 throw new JVMCIError("%x", reason);
299 }
300
301 @Override
302 public long getMemorySize(JavaConstant constant) {
303 if (constant.getJavaKind() == JavaKind.Object) {
304 HotSpotResolvedObjectType lookupJavaType = lookupJavaType(constant);
305
306 if (lookupJavaType == null) {
307 return 0;
308 } else {
309 if (lookupJavaType.isArray()) {
310 // TODO(tw): Add compressed pointer support.
311 int length = Array.getLength(((HotSpotObjectConstantImpl) constant).object());
312 ResolvedJavaType elementType = lookupJavaType.getComponentType();
313 JavaKind elementKind = elementType.getJavaKind();
314 final int headerSize = getArrayBaseOffset(elementKind);
315 TargetDescription target = runtime.getHostJVMCIBackend().getTarget();
316 int sizeOfElement = getArrayIndexScale(elementKind);
317 int alignment = target.wordSize;
318 int log2ElementSize = CodeUtil.log2(sizeOfElement);
319 return computeArrayAllocationSize(length, alignment, headerSize, log2ElementSize);
320 }
321 return lookupJavaType.instanceSize();
322 }
323 } else {
324 return constant.getJavaKind().getByteCount();
325 }
326 }
327
328 /**
329 * Computes the size of the memory chunk allocated for an array. This size accounts for the
330 * array header size, body size and any padding after the last element to satisfy object
331 * alignment requirements.
332 *
333 * @param length the number of elements in the array
334 * @param alignment the object alignment requirement
335 * @param headerSize the size of the array header
336 * @param log2ElementSize log2 of the size of an element in the array
337 */
338 public static int computeArrayAllocationSize(int length, int alignment, int headerSize, int log2ElementSize) {
339 int size = (length << log2ElementSize) + headerSize + (alignment - 1);
340 int mask = ~(alignment - 1);
341 return size & mask;
342 }
343 }