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