1 /*
2 * Copyright (c) 2014, 2018, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.lang.invoke;
27
28 import java.lang.reflect.Field;
29 import java.lang.reflect.Modifier;
30
31 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
32
33 final class VarHandles {
34
35 static VarHandle makeFieldHandle(MemberName f, Class<?> refc, Class<?> type, boolean isWriteAllowedOnFinalFields) {
36 if (!f.isStatic()) {
37 long foffset = MethodHandleNatives.objectFieldOffset(f);
38 if (!type.isPrimitive()) {
39 if (f.isFlattened()) {
40 return f.isFinal() && !isWriteAllowedOnFinalFields
41 ? new VarHandleReferences.FlatValueFieldInstanceReadOnly(refc, foffset, type)
42 : new VarHandleReferences.FlatValueFieldInstanceReadWrite(refc, foffset, type);
43 } else {
44 return f.isFinal() && !isWriteAllowedOnFinalFields
45 ? new VarHandleReferences.FieldInstanceReadOnly(refc, foffset, type)
46 : new VarHandleReferences.FieldInstanceReadWrite(refc, foffset, type, f.isInlineableField());
47 }
48 }
49 else if (type == boolean.class) {
50 return f.isFinal() && !isWriteAllowedOnFinalFields
51 ? new VarHandleBooleans.FieldInstanceReadOnly(refc, foffset)
52 : new VarHandleBooleans.FieldInstanceReadWrite(refc, foffset);
53 }
54 else if (type == byte.class) {
55 return f.isFinal() && !isWriteAllowedOnFinalFields
56 ? new VarHandleBytes.FieldInstanceReadOnly(refc, foffset)
57 : new VarHandleBytes.FieldInstanceReadWrite(refc, foffset);
58 }
59 else if (type == short.class) {
60 return f.isFinal() && !isWriteAllowedOnFinalFields
61 ? new VarHandleShorts.FieldInstanceReadOnly(refc, foffset)
62 : new VarHandleShorts.FieldInstanceReadWrite(refc, foffset);
63 }
64 else if (type == char.class) {
65 return f.isFinal() && !isWriteAllowedOnFinalFields
66 ? new VarHandleChars.FieldInstanceReadOnly(refc, foffset)
67 : new VarHandleChars.FieldInstanceReadWrite(refc, foffset);
68 }
69 else if (type == int.class) {
70 return f.isFinal() && !isWriteAllowedOnFinalFields
71 ? new VarHandleInts.FieldInstanceReadOnly(refc, foffset)
72 : new VarHandleInts.FieldInstanceReadWrite(refc, foffset);
73 }
74 else if (type == long.class) {
75 return f.isFinal() && !isWriteAllowedOnFinalFields
76 ? new VarHandleLongs.FieldInstanceReadOnly(refc, foffset)
77 : new VarHandleLongs.FieldInstanceReadWrite(refc, foffset);
78 }
79 else if (type == float.class) {
80 return f.isFinal() && !isWriteAllowedOnFinalFields
81 ? new VarHandleFloats.FieldInstanceReadOnly(refc, foffset)
82 : new VarHandleFloats.FieldInstanceReadWrite(refc, foffset);
83 }
84 else if (type == double.class) {
85 return f.isFinal() && !isWriteAllowedOnFinalFields
86 ? new VarHandleDoubles.FieldInstanceReadOnly(refc, foffset)
87 : new VarHandleDoubles.FieldInstanceReadWrite(refc, foffset);
88 }
89 else {
90 throw new UnsupportedOperationException();
91 }
92 }
93 else {
94 // TODO This is not lazy on first invocation
95 // and might cause some circular initialization issues
96
97 // Replace with something similar to direct method handles
98 // where a barrier is used then elided after use
99
100 if (UNSAFE.shouldBeInitialized(refc))
101 UNSAFE.ensureClassInitialized(refc);
102
103 Object base = MethodHandleNatives.staticFieldBase(f);
104 long foffset = MethodHandleNatives.staticFieldOffset(f);
105 if (!type.isPrimitive()) {
106 assert(!f.isFlattened()); // static field is not flattened
107 return f.isFinal() && !isWriteAllowedOnFinalFields
108 ? new VarHandleReferences.FieldStaticReadOnly(base, foffset, type)
109 : new VarHandleReferences.FieldStaticReadWrite(base, foffset, type, f.isInlineableField());
110 }
111 else if (type == boolean.class) {
112 return f.isFinal() && !isWriteAllowedOnFinalFields
113 ? new VarHandleBooleans.FieldStaticReadOnly(base, foffset)
114 : new VarHandleBooleans.FieldStaticReadWrite(base, foffset);
115 }
116 else if (type == byte.class) {
117 return f.isFinal() && !isWriteAllowedOnFinalFields
118 ? new VarHandleBytes.FieldStaticReadOnly(base, foffset)
119 : new VarHandleBytes.FieldStaticReadWrite(base, foffset);
120 }
121 else if (type == short.class) {
122 return f.isFinal() && !isWriteAllowedOnFinalFields
123 ? new VarHandleShorts.FieldStaticReadOnly(base, foffset)
124 : new VarHandleShorts.FieldStaticReadWrite(base, foffset);
125 }
126 else if (type == char.class) {
127 return f.isFinal() && !isWriteAllowedOnFinalFields
128 ? new VarHandleChars.FieldStaticReadOnly(base, foffset)
129 : new VarHandleChars.FieldStaticReadWrite(base, foffset);
130 }
131 else if (type == int.class) {
132 return f.isFinal() && !isWriteAllowedOnFinalFields
133 ? new VarHandleInts.FieldStaticReadOnly(base, foffset)
134 : new VarHandleInts.FieldStaticReadWrite(base, foffset);
135 }
136 else if (type == long.class) {
137 return f.isFinal() && !isWriteAllowedOnFinalFields
138 ? new VarHandleLongs.FieldStaticReadOnly(base, foffset)
139 : new VarHandleLongs.FieldStaticReadWrite(base, foffset);
140 }
141 else if (type == float.class) {
142 return f.isFinal() && !isWriteAllowedOnFinalFields
143 ? new VarHandleFloats.FieldStaticReadOnly(base, foffset)
144 : new VarHandleFloats.FieldStaticReadWrite(base, foffset);
145 }
146 else if (type == double.class) {
147 return f.isFinal() && !isWriteAllowedOnFinalFields
148 ? new VarHandleDoubles.FieldStaticReadOnly(base, foffset)
149 : new VarHandleDoubles.FieldStaticReadWrite(base, foffset);
150 }
151 else {
152 throw new UnsupportedOperationException();
153 }
154 }
155 }
156
157 // Required by instance field handles
158 static Field getFieldFromReceiverAndOffset(Class<?> receiverType,
159 long offset,
160 Class<?> fieldType) {
161 for (Field f : receiverType.getDeclaredFields()) {
162 if (Modifier.isStatic(f.getModifiers())) continue;
163
164 if (offset == UNSAFE.objectFieldOffset(f)) {
165 assert f.getType() == fieldType;
166 return f;
167 }
168 }
169 throw new InternalError("Field not found at offset");
170 }
171
172 // Required by instance static field handles
173 static Field getStaticFieldFromBaseAndOffset(Object base,
174 long offset,
175 Class<?> fieldType) {
176 // @@@ This is a little fragile assuming the base is the class
177 Class<?> receiverType = (Class<?>) base;
178 for (Field f : receiverType.getDeclaredFields()) {
179 if (!Modifier.isStatic(f.getModifiers())) continue;
180
181 if (offset == UNSAFE.staticFieldOffset(f)) {
182 assert f.getType() == fieldType;
183 return f;
184 }
185 }
186 throw new InternalError("Static field not found at offset");
187 }
188
189 static VarHandle makeArrayElementHandle(Class<?> arrayClass) {
190 if (!arrayClass.isArray())
191 throw new IllegalArgumentException("not an array: " + arrayClass);
192
193 Class<?> componentType = arrayClass.getComponentType();
194
195 int aoffset = UNSAFE.arrayBaseOffset(arrayClass);
196 int ascale = UNSAFE.arrayIndexScale(arrayClass);
197 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
198
199 if (!componentType.isPrimitive()) {
200 // the redundant componentType.isValue() check is there to
201 // minimize the performance impact to non-value array.
202 // It should be removed when Unsafe::isFlattenedArray is intrinsified.
203 return componentType.isInlineClass() && UNSAFE.isFlattenedArray(arrayClass)
204 ? new VarHandleReferences.ValueArray(aoffset, ashift, arrayClass)
205 : new VarHandleReferences.Array(aoffset, ashift, arrayClass);
206 }
207 else if (componentType == boolean.class) {
208 return new VarHandleBooleans.Array(aoffset, ashift);
209 }
210 else if (componentType == byte.class) {
211 return new VarHandleBytes.Array(aoffset, ashift);
212 }
213 else if (componentType == short.class) {
214 return new VarHandleShorts.Array(aoffset, ashift);
215 }
216 else if (componentType == char.class) {
217 return new VarHandleChars.Array(aoffset, ashift);
218 }
219 else if (componentType == int.class) {
220 return new VarHandleInts.Array(aoffset, ashift);
221 }
222 else if (componentType == long.class) {
223 return new VarHandleLongs.Array(aoffset, ashift);
224 }
225 else if (componentType == float.class) {
226 return new VarHandleFloats.Array(aoffset, ashift);
227 }
228 else if (componentType == double.class) {
229 return new VarHandleDoubles.Array(aoffset, ashift);
230 }
231 else {
232 throw new UnsupportedOperationException();
233 }
234 }
235
236 static VarHandle byteArrayViewHandle(Class<?> viewArrayClass,
237 boolean be) {
238 if (!viewArrayClass.isArray())
239 throw new IllegalArgumentException("not an array: " + viewArrayClass);
240
241 Class<?> viewComponentType = viewArrayClass.getComponentType();
242
243 if (viewComponentType == long.class) {
244 return new VarHandleByteArrayAsLongs.ArrayHandle(be);
245 }
246 else if (viewComponentType == int.class) {
247 return new VarHandleByteArrayAsInts.ArrayHandle(be);
248 }
249 else if (viewComponentType == short.class) {
250 return new VarHandleByteArrayAsShorts.ArrayHandle(be);
251 }
252 else if (viewComponentType == char.class) {
253 return new VarHandleByteArrayAsChars.ArrayHandle(be);
254 }
255 else if (viewComponentType == double.class) {
256 return new VarHandleByteArrayAsDoubles.ArrayHandle(be);
257 }
258 else if (viewComponentType == float.class) {
259 return new VarHandleByteArrayAsFloats.ArrayHandle(be);
260 }
261
262 throw new UnsupportedOperationException();
263 }
264
265 static VarHandle makeByteBufferViewHandle(Class<?> viewArrayClass,
266 boolean be) {
267 if (!viewArrayClass.isArray())
268 throw new IllegalArgumentException("not an array: " + viewArrayClass);
269
270 Class<?> viewComponentType = viewArrayClass.getComponentType();
271
272 if (viewComponentType == long.class) {
273 return new VarHandleByteArrayAsLongs.ByteBufferHandle(be);
274 }
275 else if (viewComponentType == int.class) {
276 return new VarHandleByteArrayAsInts.ByteBufferHandle(be);
277 }
278 else if (viewComponentType == short.class) {
279 return new VarHandleByteArrayAsShorts.ByteBufferHandle(be);
280 }
281 else if (viewComponentType == char.class) {
282 return new VarHandleByteArrayAsChars.ByteBufferHandle(be);
283 }
284 else if (viewComponentType == double.class) {
285 return new VarHandleByteArrayAsDoubles.ByteBufferHandle(be);
286 }
287 else if (viewComponentType == float.class) {
288 return new VarHandleByteArrayAsFloats.ByteBufferHandle(be);
289 }
290
291 throw new UnsupportedOperationException();
292 }
293
294 // /**
295 // * A helper program to generate the VarHandleGuards class with a set of
296 // * static guard methods each of which corresponds to a particular shape and
297 // * performs a type check of the symbolic type descriptor with the VarHandle
298 // * type descriptor before linking/invoking to the underlying operation as
299 // * characterized by the operation member name on the VarForm of the
300 // * VarHandle.
301 // * <p>
302 // * The generated class essentially encapsulates pre-compiled LambdaForms,
303 // * one for each method, for the most set of common method signatures.
304 // * This reduces static initialization costs, footprint costs, and circular
305 // * dependencies that may arise if a class is generated per LambdaForm.
306 // * <p>
307 // * A maximum of L*T*S methods will be generated where L is the number of
308 // * access modes kinds (or unique operation signatures) and T is the number
309 // * of variable types and S is the number of shapes (such as instance field,
310 // * static field, or array access).
311 // * If there are 4 unique operation signatures, 5 basic types (Object, int,
312 // * long, float, double), and 3 shapes then a maximum of 60 methods will be
313 // * generated. However, the number is likely to be less since there
314 // * be duplicate signatures.
315 // * <p>
316 // * Each method is annotated with @LambdaForm.Compiled to inform the runtime
317 // * that such methods should be treated as if a method of a class that is the
318 // * result of compiling a LambdaForm. Annotation of such methods is
319 // * important for correct evaluation of certain assertions and method return
320 // * type profiling in HotSpot.
321 // */
322 // public static class GuardMethodGenerator {
323 //
324 // static final String GUARD_METHOD_SIG_TEMPLATE = "<RETURN> <NAME>_<SIGNATURE>(<PARAMS>)";
325 //
326 // static final String GUARD_METHOD_TEMPLATE =
327 // "@ForceInline\n" +
328 // "@LambdaForm.Compiled\n" +
329 // "final static <METHOD> throws Throwable {\n" +
330 // " if (handle.vform.methodType_table[ad.type] == ad.symbolicMethodType) {\n" +
331 // " <RESULT_ERASED>MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);<RETURN_ERASED>\n" +
332 // " }\n" +
333 // " else {\n" +
334 // " MethodHandle mh = handle.getMethodHandle(ad.mode);\n" +
335 // " <RETURN>mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);\n" +
336 // " }\n" +
337 // "}";
338 //
339 // static final String GUARD_METHOD_TEMPLATE_V =
340 // "@ForceInline\n" +
341 // "@LambdaForm.Compiled\n" +
342 // "final static <METHOD> throws Throwable {\n" +
343 // " if (handle.vform.methodType_table[ad.type] == ad.symbolicMethodType) {\n" +
344 // " MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);\n" +
345 // " }\n" +
346 // " else if (handle.vform.getMethodType_V(ad.type) == ad.symbolicMethodType) {\n" +
347 // " MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);\n" +
348 // " }\n" +
349 // " else {\n" +
350 // " MethodHandle mh = handle.getMethodHandle(ad.mode);\n" +
351 // " mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);\n" +
352 // " }\n" +
353 // "}";
354 //
355 // // A template for deriving the operations
356 // // could be supported by annotating VarHandle directly with the
357 // // operation kind and shape
358 // interface VarHandleTemplate {
359 // Object get();
360 //
361 // void set(Object value);
362 //
363 // boolean compareAndSet(Object actualValue, Object expectedValue);
364 //
365 // Object compareAndExchange(Object actualValue, Object expectedValue);
366 //
367 // Object getAndUpdate(Object value);
368 // }
369 //
370 // static class HandleType {
371 // final Class<?> receiver;
372 // final Class<?>[] intermediates;
373 // final Class<?> value;
374 //
375 // HandleType(Class<?> receiver, Class<?> value, Class<?>... intermediates) {
376 // this.receiver = receiver;
377 // this.intermediates = intermediates;
378 // this.value = value;
379 // }
380 // }
381 //
382 // /**
383 // * @param args parameters
384 // */
385 // public static void main(String[] args) {
386 // System.out.println("package java.lang.invoke;");
387 // System.out.println();
388 // System.out.println("import jdk.internal.vm.annotation.ForceInline;");
389 // System.out.println();
390 // System.out.println("// This class is auto-generated by " +
391 // GuardMethodGenerator.class.getName() +
392 // ". Do not edit.");
393 // System.out.println("final class VarHandleGuards {");
394 //
395 // System.out.println();
396 //
397 // // Declare the stream of shapes
398 // Stream<HandleType> hts = Stream.of(
399 // // Object->Object
400 // new HandleType(Object.class, Object.class),
401 // // Object->int
402 // new HandleType(Object.class, int.class),
403 // // Object->long
404 // new HandleType(Object.class, long.class),
405 // // Object->float
406 // new HandleType(Object.class, float.class),
407 // // Object->double
408 // new HandleType(Object.class, double.class),
409 //
410 // // <static>->Object
411 // new HandleType(null, Object.class),
412 // // <static>->int
413 // new HandleType(null, int.class),
414 // // <static>->long
415 // new HandleType(null, long.class),
416 // // <static>->float
417 // new HandleType(null, float.class),
418 // // <static>->double
419 // new HandleType(null, double.class),
420 //
421 // // Array[int]->Object
422 // new HandleType(Object.class, Object.class, int.class),
423 // // Array[int]->int
424 // new HandleType(Object.class, int.class, int.class),
425 // // Array[int]->long
426 // new HandleType(Object.class, long.class, int.class),
427 // // Array[int]->float
428 // new HandleType(Object.class, float.class, int.class),
429 // // Array[int]->double
430 // new HandleType(Object.class, double.class, int.class),
431 //
432 // // Array[long]->int
433 // new HandleType(Object.class, int.class, long.class),
434 // // Array[long]->long
435 // new HandleType(Object.class, long.class, long.class)
436 // );
437 //
438 // hts.flatMap(ht -> Stream.of(VarHandleTemplate.class.getMethods()).
439 // map(m -> generateMethodType(m, ht.receiver, ht.value, ht.intermediates))).
440 // distinct().
441 // map(mt -> generateMethod(mt)).
442 // forEach(s -> {
443 // System.out.println(s);
444 // System.out.println();
445 // });
446 //
447 // System.out.println("}");
448 // }
449 //
450 // static MethodType generateMethodType(Method m, Class<?> receiver, Class<?> value, Class<?>... intermediates) {
451 // Class<?> returnType = m.getReturnType() == Object.class
452 // ? value : m.getReturnType();
453 //
454 // List<Class<?>> params = new ArrayList<>();
455 // if (receiver != null)
456 // params.add(receiver);
457 // for (int i = 0; i < intermediates.length; i++) {
458 // params.add(intermediates[i]);
459 // }
460 // for (Parameter p : m.getParameters()) {
461 // params.add(value);
462 // }
463 // return MethodType.methodType(returnType, params);
464 // }
465 //
466 // static String generateMethod(MethodType mt) {
467 // Class<?> returnType = mt.returnType();
468 //
469 // LinkedHashMap<String, Class<?>> params = new LinkedHashMap<>();
470 // params.put("handle", VarHandle.class);
471 // for (int i = 0; i < mt.parameterCount(); i++) {
472 // params.put("arg" + i, mt.parameterType(i));
473 // }
474 // params.put("ad", VarHandle.AccessDescriptor.class);
475 //
476 // // Generate method signature line
477 // String RETURN = className(returnType);
478 // String NAME = "guard";
479 // String SIGNATURE = getSignature(mt);
480 // String PARAMS = params.entrySet().stream().
481 // map(e -> className(e.getValue()) + " " + e.getKey()).
482 // collect(joining(", "));
483 // String METHOD = GUARD_METHOD_SIG_TEMPLATE.
484 // replace("<RETURN>", RETURN).
485 // replace("<NAME>", NAME).
486 // replace("<SIGNATURE>", SIGNATURE).
487 // replace("<PARAMS>", PARAMS);
488 //
489 // // Generate method
490 // params.remove("ad");
491 //
492 // List<String> LINK_TO_STATIC_ARGS = params.keySet().stream().
493 // collect(toList());
494 // LINK_TO_STATIC_ARGS.add("handle.vform.getMemberName(ad.mode)");
495 // List<String> LINK_TO_STATIC_ARGS_V = params.keySet().stream().
496 // collect(toList());
497 // LINK_TO_STATIC_ARGS_V.add("handle.vform.getMemberName_V(ad.mode)");
498 //
499 // List<String> LINK_TO_INVOKER_ARGS = params.keySet().stream().
500 // collect(toList());
501 //
502 // RETURN = returnType == void.class
503 // ? ""
504 // : returnType == Object.class
505 // ? "return "
506 // : "return (" + returnType.getName() + ") ";
507 //
508 // String RESULT_ERASED = returnType == void.class
509 // ? ""
510 // : returnType != Object.class
511 // ? "return (" + returnType.getName() + ") "
512 // : "Object r = ";
513 //
514 // String RETURN_ERASED = returnType != Object.class
515 // ? ""
516 // : " return ad.returnType.cast(r);";
517 //
518 // String template = returnType == void.class
519 // ? GUARD_METHOD_TEMPLATE_V
520 // : GUARD_METHOD_TEMPLATE;
521 // return template.
522 // replace("<METHOD>", METHOD).
523 // replace("<NAME>", NAME).
524 // replaceAll("<RETURN>", RETURN).
525 // replace("<RESULT_ERASED>", RESULT_ERASED).
526 // replace("<RETURN_ERASED>", RETURN_ERASED).
527 // replaceAll("<LINK_TO_STATIC_ARGS>", LINK_TO_STATIC_ARGS.stream().
528 // collect(joining(", "))).
529 // replaceAll("<LINK_TO_STATIC_ARGS_V>", LINK_TO_STATIC_ARGS_V.stream().
530 // collect(joining(", "))).
531 // replace("<LINK_TO_INVOKER_ARGS>", LINK_TO_INVOKER_ARGS.stream().
532 // collect(joining(", ")))
533 // ;
534 // }
535 //
536 // static String className(Class<?> c) {
537 // String n = c.getName();
538 // if (n.startsWith("java.lang.")) {
539 // n = n.replace("java.lang.", "");
540 // if (n.startsWith("invoke.")) {
541 // n = n.replace("invoke.", "");
542 // }
543 // }
544 // return n.replace('$', '.');
545 // }
546 //
547 // static String getSignature(MethodType m) {
548 // StringBuilder sb = new StringBuilder(m.parameterCount() + 1);
549 //
550 // for (int i = 0; i < m.parameterCount(); i++) {
551 // Class<?> pt = m.parameterType(i);
552 // sb.append(getCharType(pt));
553 // }
554 //
555 // sb.append('_').append(getCharType(m.returnType()));
556 //
557 // return sb.toString();
558 // }
559 //
560 // static char getCharType(Class<?> pt) {
561 // if (pt == void.class) {
562 // return 'V';
563 // }
564 // else if (!pt.isPrimitive()) {
565 // return 'L';
566 // }
567 // else if (pt == boolean.class) {
568 // return 'Z';
569 // }
570 // else if (pt == int.class) {
571 // return 'I';
572 // }
573 // else if (pt == long.class) {
574 // return 'J';
575 // }
576 // else if (pt == float.class) {
577 // return 'F';
578 // }
579 // else if (pt == double.class) {
580 // return 'D';
581 // }
582 // else {
583 // throw new IllegalStateException(pt.getName());
584 // }
585 // }
586 // }
587 }