--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.base/share/classes/java/lang/invoke/VarHandles.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,540 @@
+/*
+ * Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.invoke;
+
+import static java.lang.invoke.MethodHandleStatics.UNSAFE;
+
+final class VarHandles {
+
+ static VarHandle makeFieldHandle(MemberName f, Class<?> refc, Class<?> type, boolean isWriteAllowedOnFinalFields) {
+ if (!f.isStatic()) {
+ long foffset = MethodHandleNatives.objectFieldOffset(f);
+ if (!type.isPrimitive()) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleObjects.FieldInstanceReadOnly(refc, foffset, type)
+ : new VarHandleObjects.FieldInstanceReadWrite(refc, foffset, type);
+ }
+ else if (type == boolean.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleBooleans.FieldInstanceReadOnly(refc, foffset)
+ : new VarHandleBooleans.FieldInstanceReadWrite(refc, foffset);
+ }
+ else if (type == byte.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleBytes.FieldInstanceReadOnly(refc, foffset)
+ : new VarHandleBytes.FieldInstanceReadWrite(refc, foffset);
+ }
+ else if (type == short.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleShorts.FieldInstanceReadOnly(refc, foffset)
+ : new VarHandleShorts.FieldInstanceReadWrite(refc, foffset);
+ }
+ else if (type == char.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleChars.FieldInstanceReadOnly(refc, foffset)
+ : new VarHandleChars.FieldInstanceReadWrite(refc, foffset);
+ }
+ else if (type == int.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleInts.FieldInstanceReadOnly(refc, foffset)
+ : new VarHandleInts.FieldInstanceReadWrite(refc, foffset);
+ }
+ else if (type == long.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleLongs.FieldInstanceReadOnly(refc, foffset)
+ : new VarHandleLongs.FieldInstanceReadWrite(refc, foffset);
+ }
+ else if (type == float.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleFloats.FieldInstanceReadOnly(refc, foffset)
+ : new VarHandleFloats.FieldInstanceReadWrite(refc, foffset);
+ }
+ else if (type == double.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleDoubles.FieldInstanceReadOnly(refc, foffset)
+ : new VarHandleDoubles.FieldInstanceReadWrite(refc, foffset);
+ }
+ else {
+ throw new UnsupportedOperationException();
+ }
+ }
+ else {
+ // TODO This is not lazy on first invocation
+ // and might cause some circular initialization issues
+
+ // Replace with something similar to direct method handles
+ // where a barrier is used then elided after use
+
+ if (UNSAFE.shouldBeInitialized(refc))
+ UNSAFE.ensureClassInitialized(refc);
+
+ Object base = MethodHandleNatives.staticFieldBase(f);
+ long foffset = MethodHandleNatives.staticFieldOffset(f);
+ if (!type.isPrimitive()) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleObjects.FieldStaticReadOnly(base, foffset, type)
+ : new VarHandleObjects.FieldStaticReadWrite(base, foffset, type);
+ }
+ else if (type == boolean.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleBooleans.FieldStaticReadOnly(base, foffset)
+ : new VarHandleBooleans.FieldStaticReadWrite(base, foffset);
+ }
+ else if (type == byte.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleBytes.FieldStaticReadOnly(base, foffset)
+ : new VarHandleBytes.FieldStaticReadWrite(base, foffset);
+ }
+ else if (type == short.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleShorts.FieldStaticReadOnly(base, foffset)
+ : new VarHandleShorts.FieldStaticReadWrite(base, foffset);
+ }
+ else if (type == char.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleChars.FieldStaticReadOnly(base, foffset)
+ : new VarHandleChars.FieldStaticReadWrite(base, foffset);
+ }
+ else if (type == int.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleInts.FieldStaticReadOnly(base, foffset)
+ : new VarHandleInts.FieldStaticReadWrite(base, foffset);
+ }
+ else if (type == long.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleLongs.FieldStaticReadOnly(base, foffset)
+ : new VarHandleLongs.FieldStaticReadWrite(base, foffset);
+ }
+ else if (type == float.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleFloats.FieldStaticReadOnly(base, foffset)
+ : new VarHandleFloats.FieldStaticReadWrite(base, foffset);
+ }
+ else if (type == double.class) {
+ return f.isFinal() && !isWriteAllowedOnFinalFields
+ ? new VarHandleDoubles.FieldStaticReadOnly(base, foffset)
+ : new VarHandleDoubles.FieldStaticReadWrite(base, foffset);
+ }
+ else {
+ throw new UnsupportedOperationException();
+ }
+ }
+ }
+
+ static VarHandle makeArrayElementHandle(Class<?> arrayClass) {
+ if (!arrayClass.isArray())
+ throw new IllegalArgumentException("not an array: " + arrayClass);
+
+ Class<?> componentType = arrayClass.getComponentType();
+
+ int aoffset = UNSAFE.arrayBaseOffset(arrayClass);
+ int ascale = UNSAFE.arrayIndexScale(arrayClass);
+ int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
+
+ if (!componentType.isPrimitive()) {
+ return new VarHandleObjects.Array(aoffset, ashift, arrayClass);
+ }
+ else if (componentType == boolean.class) {
+ return new VarHandleBooleans.Array(aoffset, ashift);
+ }
+ else if (componentType == byte.class) {
+ return new VarHandleBytes.Array(aoffset, ashift);
+ }
+ else if (componentType == short.class) {
+ return new VarHandleShorts.Array(aoffset, ashift);
+ }
+ else if (componentType == char.class) {
+ return new VarHandleChars.Array(aoffset, ashift);
+ }
+ else if (componentType == int.class) {
+ return new VarHandleInts.Array(aoffset, ashift);
+ }
+ else if (componentType == long.class) {
+ return new VarHandleLongs.Array(aoffset, ashift);
+ }
+ else if (componentType == float.class) {
+ return new VarHandleFloats.Array(aoffset, ashift);
+ }
+ else if (componentType == double.class) {
+ return new VarHandleDoubles.Array(aoffset, ashift);
+ }
+ else {
+ throw new UnsupportedOperationException();
+ }
+ }
+
+ static VarHandle byteArrayViewHandle(Class<?> viewArrayClass,
+ boolean be) {
+ if (!viewArrayClass.isArray())
+ throw new IllegalArgumentException("not an array: " + viewArrayClass);
+
+ Class<?> viewComponentType = viewArrayClass.getComponentType();
+
+ if (viewComponentType == long.class) {
+ return new VarHandleByteArrayAsLongs.ArrayHandle(be);
+ }
+ else if (viewComponentType == int.class) {
+ return new VarHandleByteArrayAsInts.ArrayHandle(be);
+ }
+ else if (viewComponentType == short.class) {
+ return new VarHandleByteArrayAsShorts.ArrayHandle(be);
+ }
+ else if (viewComponentType == char.class) {
+ return new VarHandleByteArrayAsChars.ArrayHandle(be);
+ }
+ else if (viewComponentType == double.class) {
+ return new VarHandleByteArrayAsDoubles.ArrayHandle(be);
+ }
+ else if (viewComponentType == float.class) {
+ return new VarHandleByteArrayAsFloats.ArrayHandle(be);
+ }
+
+ throw new UnsupportedOperationException();
+ }
+
+ static VarHandle makeByteBufferViewHandle(Class<?> viewArrayClass,
+ boolean be) {
+ if (!viewArrayClass.isArray())
+ throw new IllegalArgumentException("not an array: " + viewArrayClass);
+
+ Class<?> viewComponentType = viewArrayClass.getComponentType();
+
+ if (viewComponentType == long.class) {
+ return new VarHandleByteArrayAsLongs.ByteBufferHandle(be);
+ }
+ else if (viewComponentType == int.class) {
+ return new VarHandleByteArrayAsInts.ByteBufferHandle(be);
+ }
+ else if (viewComponentType == short.class) {
+ return new VarHandleByteArrayAsShorts.ByteBufferHandle(be);
+ }
+ else if (viewComponentType == char.class) {
+ return new VarHandleByteArrayAsChars.ByteBufferHandle(be);
+ }
+ else if (viewComponentType == double.class) {
+ return new VarHandleByteArrayAsDoubles.ByteBufferHandle(be);
+ }
+ else if (viewComponentType == float.class) {
+ return new VarHandleByteArrayAsFloats.ByteBufferHandle(be);
+ }
+
+ throw new UnsupportedOperationException();
+ }
+
+// /**
+// * A helper program to generate the VarHandleGuards class with a set of
+// * static guard methods each of which corresponds to a particular shape and
+// * performs a type check of the symbolic type descriptor with the VarHandle
+// * type descriptor before linking/invoking to the underlying operation as
+// * characterized by the operation member name on the VarForm of the
+// * VarHandle.
+// * <p>
+// * The generated class essentially encapsulates pre-compiled LambdaForms,
+// * one for each method, for the most set of common method signatures.
+// * This reduces static initialization costs, footprint costs, and circular
+// * dependencies that may arise if a class is generated per LambdaForm.
+// * <p>
+// * A maximum of L*T*S methods will be generated where L is the number of
+// * access modes kinds (or unique operation signatures) and T is the number
+// * of variable types and S is the number of shapes (such as instance field,
+// * static field, or array access).
+// * If there are 4 unique operation signatures, 5 basic types (Object, int,
+// * long, float, double), and 3 shapes then a maximum of 60 methods will be
+// * generated. However, the number is likely to be less since there
+// * be duplicate signatures.
+// * <p>
+// * Each method is annotated with @LambdaForm.Compiled to inform the runtime
+// * that such methods should be treated as if a method of a class that is the
+// * result of compiling a LambdaForm. Annotation of such methods is
+// * important for correct evaluation of certain assertions and method return
+// * type profiling in HotSpot.
+// */
+// public static class GuardMethodGenerator {
+//
+// static final String GUARD_METHOD_SIG_TEMPLATE = "<RETURN> <NAME>_<SIGNATURE>(<PARAMS>)";
+//
+// static final String GUARD_METHOD_TEMPLATE =
+// "@ForceInline\n" +
+// "@LambdaForm.Compiled\n" +
+// "final static <METHOD> throws Throwable {\n" +
+// " if (handle.vform.methodType_table[ad.type] == ad.symbolicMethodType) {\n" +
+// " <RESULT_ERASED>MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);<RETURN_ERASED>\n" +
+// " }\n" +
+// " else {\n" +
+// " MethodHandle mh = handle.getMethodHandle(ad.mode);\n" +
+// " <RETURN>mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);\n" +
+// " }\n" +
+// "}";
+//
+// static final String GUARD_METHOD_TEMPLATE_V =
+// "@ForceInline\n" +
+// "@LambdaForm.Compiled\n" +
+// "final static <METHOD> throws Throwable {\n" +
+// " if (handle.vform.methodType_table[ad.type] == ad.symbolicMethodType) {\n" +
+// " MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);\n" +
+// " }\n" +
+// " else if (handle.vform.getMethodType_V(ad.type) == ad.symbolicMethodType) {\n" +
+// " MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);\n" +
+// " }\n" +
+// " else {\n" +
+// " MethodHandle mh = handle.getMethodHandle(ad.mode);\n" +
+// " mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);\n" +
+// " }\n" +
+// "}";
+//
+// // A template for deriving the operations
+// // could be supported by annotating VarHandle directly with the
+// // operation kind and shape
+// interface VarHandleTemplate {
+// Object get();
+//
+// void set(Object value);
+//
+// boolean compareAndSwap(Object actualValue, Object expectedValue);
+//
+// Object compareAndExchange(Object actualValue, Object expectedValue);
+//
+// Object getAndUpdate(Object value);
+// }
+//
+// static class HandleType {
+// final Class<?> receiver;
+// final Class<?>[] intermediates;
+// final Class<?> value;
+//
+// HandleType(Class<?> receiver, Class<?> value, Class<?>... intermediates) {
+// this.receiver = receiver;
+// this.intermediates = intermediates;
+// this.value = value;
+// }
+// }
+//
+// /**
+// * @param args parameters
+// */
+// public static void main(String[] args) {
+// System.out.println("package java.lang.invoke;");
+// System.out.println();
+// System.out.println("import jdk.internal.vm.annotation.ForceInline;");
+// System.out.println();
+// System.out.println("// This class is auto-generated by " +
+// GuardMethodGenerator.class.getName() +
+// ". Do not edit.");
+// System.out.println("final class VarHandleGuards {");
+//
+// System.out.println();
+//
+// // Declare the stream of shapes
+// Stream<HandleType> hts = Stream.of(
+// // Object->Object
+// new HandleType(Object.class, Object.class),
+// // Object->int
+// new HandleType(Object.class, int.class),
+// // Object->long
+// new HandleType(Object.class, long.class),
+// // Object->float
+// new HandleType(Object.class, float.class),
+// // Object->double
+// new HandleType(Object.class, double.class),
+//
+// // <static>->Object
+// new HandleType(null, Object.class),
+// // <static>->int
+// new HandleType(null, int.class),
+// // <static>->long
+// new HandleType(null, long.class),
+// // <static>->float
+// new HandleType(null, float.class),
+// // <static>->double
+// new HandleType(null, double.class),
+//
+// // Array[int]->Object
+// new HandleType(Object.class, Object.class, int.class),
+// // Array[int]->int
+// new HandleType(Object.class, int.class, int.class),
+// // Array[int]->long
+// new HandleType(Object.class, long.class, int.class),
+// // Array[int]->float
+// new HandleType(Object.class, float.class, int.class),
+// // Array[int]->double
+// new HandleType(Object.class, double.class, int.class),
+//
+// // Array[long]->int
+// new HandleType(Object.class, int.class, long.class),
+// // Array[long]->long
+// new HandleType(Object.class, long.class, long.class)
+// );
+//
+// hts.flatMap(ht -> Stream.of(VarHandleTemplate.class.getMethods()).
+// map(m -> generateMethodType(m, ht.receiver, ht.value, ht.intermediates))).
+// distinct().
+// map(mt -> generateMethod(mt)).
+// forEach(s -> {
+// System.out.println(s);
+// System.out.println();
+// });
+//
+// System.out.println("}");
+// }
+//
+// static MethodType generateMethodType(Method m, Class<?> receiver, Class<?> value, Class<?>... intermediates) {
+// Class<?> returnType = m.getReturnType() == Object.class
+// ? value : m.getReturnType();
+//
+// List<Class<?>> params = new ArrayList<>();
+// if (receiver != null)
+// params.add(receiver);
+// for (int i = 0; i < intermediates.length; i++) {
+// params.add(intermediates[i]);
+// }
+// for (Parameter p : m.getParameters()) {
+// params.add(value);
+// }
+// return MethodType.methodType(returnType, params);
+// }
+//
+// static String generateMethod(MethodType mt) {
+// Class<?> returnType = mt.returnType();
+//
+// LinkedHashMap<String, Class<?>> params = new LinkedHashMap<>();
+// params.put("handle", VarHandle.class);
+// for (int i = 0; i < mt.parameterCount(); i++) {
+// params.put("arg" + i, mt.parameterType(i));
+// }
+// params.put("ad", VarHandle.AccessDescriptor.class);
+//
+// // Generate method signature line
+// String RETURN = className(returnType);
+// String NAME = "guard";
+// String SIGNATURE = getSignature(mt);
+// String PARAMS = params.entrySet().stream().
+// map(e -> className(e.getValue()) + " " + e.getKey()).
+// collect(joining(", "));
+// String METHOD = GUARD_METHOD_SIG_TEMPLATE.
+// replace("<RETURN>", RETURN).
+// replace("<NAME>", NAME).
+// replace("<SIGNATURE>", SIGNATURE).
+// replace("<PARAMS>", PARAMS);
+//
+// // Generate method
+// params.remove("ad");
+//
+// List<String> LINK_TO_STATIC_ARGS = params.keySet().stream().
+// collect(toList());
+// LINK_TO_STATIC_ARGS.add("handle.vform.getMemberName(ad.mode)");
+// List<String> LINK_TO_STATIC_ARGS_V = params.keySet().stream().
+// collect(toList());
+// LINK_TO_STATIC_ARGS_V.add("handle.vform.getMemberName_V(ad.mode)");
+//
+// List<String> LINK_TO_INVOKER_ARGS = params.keySet().stream().
+// collect(toList());
+//
+// RETURN = returnType == void.class
+// ? ""
+// : returnType == Object.class
+// ? "return "
+// : "return (" + returnType.getName() + ") ";
+//
+// String RESULT_ERASED = returnType == void.class
+// ? ""
+// : returnType != Object.class
+// ? "return (" + returnType.getName() + ") "
+// : "Object r = ";
+//
+// String RETURN_ERASED = returnType != Object.class
+// ? ""
+// : " return ad.returnType.cast(r);";
+//
+// String template = returnType == void.class
+// ? GUARD_METHOD_TEMPLATE_V
+// : GUARD_METHOD_TEMPLATE;
+// return template.
+// replace("<METHOD>", METHOD).
+// replace("<NAME>", NAME).
+// replaceAll("<RETURN>", RETURN).
+// replace("<RESULT_ERASED>", RESULT_ERASED).
+// replace("<RETURN_ERASED>", RETURN_ERASED).
+// replaceAll("<LINK_TO_STATIC_ARGS>", LINK_TO_STATIC_ARGS.stream().
+// collect(joining(", "))).
+// replaceAll("<LINK_TO_STATIC_ARGS_V>", LINK_TO_STATIC_ARGS_V.stream().
+// collect(joining(", "))).
+// replace("<LINK_TO_INVOKER_ARGS>", LINK_TO_INVOKER_ARGS.stream().
+// collect(joining(", ")))
+// ;
+// }
+//
+// static String className(Class<?> c) {
+// String n = c.getName();
+// if (n.startsWith("java.lang.")) {
+// n = n.replace("java.lang.", "");
+// if (n.startsWith("invoke.")) {
+// n = n.replace("invoke.", "");
+// }
+// }
+// return n.replace('$', '.');
+// }
+//
+// static String getSignature(MethodType m) {
+// StringBuilder sb = new StringBuilder(m.parameterCount() + 1);
+//
+// for (int i = 0; i < m.parameterCount(); i++) {
+// Class<?> pt = m.parameterType(i);
+// sb.append(getCharType(pt));
+// }
+//
+// sb.append('_').append(getCharType(m.returnType()));
+//
+// return sb.toString();
+// }
+//
+// static char getCharType(Class<?> pt) {
+// if (pt == void.class) {
+// return 'V';
+// }
+// else if (!pt.isPrimitive()) {
+// return 'L';
+// }
+// else if (pt == boolean.class) {
+// return 'Z';
+// }
+// else if (pt == int.class) {
+// return 'I';
+// }
+// else if (pt == long.class) {
+// return 'J';
+// }
+// else if (pt == float.class) {
+// return 'F';
+// }
+// else if (pt == double.class) {
+// return 'D';
+// }
+// else {
+// throw new IllegalStateException(pt.getName());
+// }
+// }
+// }
+}