| /* |
| * Copyright (c) 2017, 2021, 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.runtime; |
| |
| import java.lang.invoke.ConstantCallSite; |
| import java.lang.invoke.MethodHandle; |
| import java.lang.invoke.MethodHandles; |
| import java.lang.invoke.MethodType; |
| import java.lang.invoke.TypeDescriptor; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Objects; |
| |
| /** |
| * Bootstrap methods for state-driven implementations of core methods, |
| * including {@link Object#equals(Object)}, {@link Object#hashCode()}, and |
| * {@link Object#toString()}. These methods may be used, for example, by |
| * Java compiler implementations to implement the bodies of {@link Object} |
| * methods for record classes. |
| * |
| * @since 16 |
| */ |
| public class ObjectMethods { |
| |
| private ObjectMethods() { } |
| |
| private static final MethodType DESCRIPTOR_MT = MethodType.methodType(MethodType.class); |
| private static final MethodType NAMES_MT = MethodType.methodType(List.class); |
| private static final MethodHandle FALSE = MethodHandles.constant(boolean.class, false); |
| private static final MethodHandle TRUE = MethodHandles.constant(boolean.class, true); |
| private static final MethodHandle ZERO = MethodHandles.constant(int.class, 0); |
| private static final MethodHandle CLASS_IS_INSTANCE; |
| private static final MethodHandle OBJECT_EQUALS; |
| private static final MethodHandle OBJECTS_EQUALS; |
| private static final MethodHandle OBJECTS_HASHCODE; |
| private static final MethodHandle OBJECTS_TOSTRING; |
| private static final MethodHandle OBJECT_EQ; |
| private static final MethodHandle OBJECT_HASHCODE; |
| private static final MethodHandle OBJECT_TO_STRING; |
| private static final MethodHandle STRING_FORMAT; |
| private static final MethodHandle HASH_COMBINER; |
| |
| private static final HashMap<Class<?>, MethodHandle> primitiveEquals = new HashMap<>(); |
| private static final HashMap<Class<?>, MethodHandle> primitiveHashers = new HashMap<>(); |
| private static final HashMap<Class<?>, MethodHandle> primitiveToString = new HashMap<>(); |
| |
| static { |
| try { |
| Class<ObjectMethods> OBJECT_METHODS_CLASS = ObjectMethods.class; |
| MethodHandles.Lookup publicLookup = MethodHandles.publicLookup(); |
| MethodHandles.Lookup lookup = MethodHandles.lookup(); |
| |
| @SuppressWarnings("removal") |
| ClassLoader loader = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { |
| @Override public ClassLoader run() { return ClassLoader.getPlatformClassLoader(); } |
| }); |
| |
| CLASS_IS_INSTANCE = publicLookup.findVirtual(Class.class, "isInstance", |
| MethodType.methodType(boolean.class, Object.class)); |
| OBJECT_EQUALS = publicLookup.findVirtual(Object.class, "equals", |
| MethodType.methodType(boolean.class, Object.class)); |
| OBJECT_HASHCODE = publicLookup.findVirtual(Object.class, "hashCode", |
| MethodType.fromMethodDescriptorString("()I", loader)); |
| OBJECT_TO_STRING = publicLookup.findVirtual(Object.class, "toString", |
| MethodType.methodType(String.class)); |
| STRING_FORMAT = publicLookup.findStatic(String.class, "format", |
| MethodType.methodType(String.class, String.class, Object[].class)); |
| OBJECTS_EQUALS = publicLookup.findStatic(Objects.class, "equals", |
| MethodType.methodType(boolean.class, Object.class, Object.class)); |
| OBJECTS_HASHCODE = publicLookup.findStatic(Objects.class, "hashCode", |
| MethodType.methodType(int.class, Object.class)); |
| OBJECTS_TOSTRING = publicLookup.findStatic(Objects.class, "toString", |
| MethodType.methodType(String.class, Object.class)); |
| |
| OBJECT_EQ = lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.methodType(boolean.class, Object.class, Object.class)); |
| HASH_COMBINER = lookup.findStatic(OBJECT_METHODS_CLASS, "hashCombiner", |
| MethodType.fromMethodDescriptorString("(II)I", loader)); |
| |
| primitiveEquals.put(byte.class, lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.fromMethodDescriptorString("(BB)Z", loader))); |
| primitiveEquals.put(short.class, lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.fromMethodDescriptorString("(SS)Z", loader))); |
| primitiveEquals.put(char.class, lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.fromMethodDescriptorString("(CC)Z", loader))); |
| primitiveEquals.put(int.class, lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.fromMethodDescriptorString("(II)Z", loader))); |
| primitiveEquals.put(long.class, lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.fromMethodDescriptorString("(JJ)Z", loader))); |
| primitiveEquals.put(float.class, lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.fromMethodDescriptorString("(FF)Z", loader))); |
| primitiveEquals.put(double.class, lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.fromMethodDescriptorString("(DD)Z", loader))); |
| primitiveEquals.put(boolean.class, lookup.findStatic(OBJECT_METHODS_CLASS, "eq", |
| MethodType.fromMethodDescriptorString("(ZZ)Z", loader))); |
| |
| primitiveHashers.put(byte.class, lookup.findStatic(Byte.class, "hashCode", |
| MethodType.fromMethodDescriptorString("(B)I", loader))); |
| primitiveHashers.put(short.class, lookup.findStatic(Short.class, "hashCode", |
| MethodType.fromMethodDescriptorString("(S)I", loader))); |
| primitiveHashers.put(char.class, lookup.findStatic(Character.class, "hashCode", |
| MethodType.fromMethodDescriptorString("(C)I", loader))); |
| primitiveHashers.put(int.class, lookup.findStatic(Integer.class, "hashCode", |
| MethodType.fromMethodDescriptorString("(I)I", loader))); |
| primitiveHashers.put(long.class, lookup.findStatic(Long.class, "hashCode", |
| MethodType.fromMethodDescriptorString("(J)I", loader))); |
| primitiveHashers.put(float.class, lookup.findStatic(Float.class, "hashCode", |
| MethodType.fromMethodDescriptorString("(F)I", loader))); |
| primitiveHashers.put(double.class, lookup.findStatic(Double.class, "hashCode", |
| MethodType.fromMethodDescriptorString("(D)I", loader))); |
| primitiveHashers.put(boolean.class, lookup.findStatic(Boolean.class, "hashCode", |
| MethodType.fromMethodDescriptorString("(Z)I", loader))); |
| |
| primitiveToString.put(byte.class, lookup.findStatic(Byte.class, "toString", |
| MethodType.methodType(String.class, byte.class))); |
| primitiveToString.put(short.class, lookup.findStatic(Short.class, "toString", |
| MethodType.methodType(String.class, short.class))); |
| primitiveToString.put(char.class, lookup.findStatic(Character.class, "toString", |
| MethodType.methodType(String.class, char.class))); |
| primitiveToString.put(int.class, lookup.findStatic(Integer.class, "toString", |
| MethodType.methodType(String.class, int.class))); |
| primitiveToString.put(long.class, lookup.findStatic(Long.class, "toString", |
| MethodType.methodType(String.class, long.class))); |
| primitiveToString.put(float.class, lookup.findStatic(Float.class, "toString", |
| MethodType.methodType(String.class, float.class))); |
| primitiveToString.put(double.class, lookup.findStatic(Double.class, "toString", |
| MethodType.methodType(String.class, double.class))); |
| primitiveToString.put(boolean.class, lookup.findStatic(Boolean.class, "toString", |
| MethodType.methodType(String.class, boolean.class))); |
| } |
| catch (ReflectiveOperationException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| private static int hashCombiner(int x, int y) { |
| return x*31 + y; |
| } |
| |
| private static boolean eq(Object a, Object b) { return a == b; } |
| private static boolean eq(byte a, byte b) { return a == b; } |
| private static boolean eq(short a, short b) { return a == b; } |
| private static boolean eq(char a, char b) { return a == b; } |
| private static boolean eq(int a, int b) { return a == b; } |
| private static boolean eq(long a, long b) { return a == b; } |
| private static boolean eq(float a, float b) { return Float.compare(a, b) == 0; } |
| private static boolean eq(double a, double b) { return Double.compare(a, b) == 0; } |
| private static boolean eq(boolean a, boolean b) { return a == b; } |
| |
| /** Get the method handle for combining two values of a given type */ |
| private static MethodHandle equalator(Class<?> clazz) { |
| return (clazz.isPrimitive() |
| ? primitiveEquals.get(clazz) |
| : OBJECTS_EQUALS.asType(MethodType.methodType(boolean.class, clazz, clazz))); |
| } |
| |
| /** Get the hasher for a value of a given type */ |
| private static MethodHandle hasher(Class<?> clazz) { |
| return (clazz.isPrimitive() |
| ? primitiveHashers.get(clazz) |
| : OBJECTS_HASHCODE.asType(MethodType.methodType(int.class, clazz))); |
| } |
| |
| /** Get the stringifier for a value of a given type */ |
| private static MethodHandle stringifier(Class<?> clazz) { |
| return (clazz.isPrimitive() |
| ? primitiveToString.get(clazz) |
| : OBJECTS_TOSTRING.asType(MethodType.methodType(String.class, clazz))); |
| } |
| |
| /** |
| * Generates a method handle for the {@code equals} method for a given data class |
| * @param receiverClass the data class |
| * @param getters the list of getters |
| * @return the method handle |
| */ |
| private static MethodHandle makeEquals(Class<?> receiverClass, |
| List<MethodHandle> getters) { |
| MethodType rr = MethodType.methodType(boolean.class, receiverClass, receiverClass); |
| MethodType ro = MethodType.methodType(boolean.class, receiverClass, Object.class); |
| MethodHandle instanceFalse = MethodHandles.dropArguments(FALSE, 0, receiverClass, Object.class); // (RO)Z |
| MethodHandle instanceTrue = MethodHandles.dropArguments(TRUE, 0, receiverClass, Object.class); // (RO)Z |
| MethodHandle isSameObject = OBJECT_EQ.asType(ro); // (RO)Z |
| MethodHandle isInstance = MethodHandles.dropArguments(CLASS_IS_INSTANCE.bindTo(receiverClass), 0, receiverClass); // (RO)Z |
| MethodHandle accumulator = MethodHandles.dropArguments(TRUE, 0, receiverClass, receiverClass); // (RR)Z |
| |
| for (MethodHandle getter : getters) { |
| MethodHandle equalator = equalator(getter.type().returnType()); // (TT)Z |
| MethodHandle thisFieldEqual = MethodHandles.filterArguments(equalator, 0, getter, getter); // (RR)Z |
| accumulator = MethodHandles.guardWithTest(thisFieldEqual, accumulator, instanceFalse.asType(rr)); |
| } |
| |
| return MethodHandles.guardWithTest(isSameObject, |
| instanceTrue, |
| MethodHandles.guardWithTest(isInstance, accumulator.asType(ro), instanceFalse)); |
| } |
| |
| /** |
| * Generates a method handle for the {@code hashCode} method for a given data class |
| * @param receiverClass the data class |
| * @param getters the list of getters |
| * @return the method handle |
| */ |
| private static MethodHandle makeHashCode(Class<?> receiverClass, |
| List<MethodHandle> getters) { |
| MethodHandle accumulator = MethodHandles.dropArguments(ZERO, 0, receiverClass); // (R)I |
| |
| // @@@ Use loop combinator instead? |
| for (MethodHandle getter : getters) { |
| MethodHandle hasher = hasher(getter.type().returnType()); // (T)I |
| MethodHandle hashThisField = MethodHandles.filterArguments(hasher, 0, getter); // (R)I |
| MethodHandle combineHashes = MethodHandles.filterArguments(HASH_COMBINER, 0, accumulator, hashThisField); // (RR)I |
| accumulator = MethodHandles.permuteArguments(combineHashes, accumulator.type(), 0, 0); // adapt (R)I to (RR)I |
| } |
| |
| return accumulator; |
| } |
| |
| /** |
| * Generates a method handle for the {@code toString} method for a given data class |
| * @param receiverClass the data class |
| * @param getters the list of getters |
| * @param names the names |
| * @return the method handle |
| */ |
| private static MethodHandle makeToString(Class<?> receiverClass, |
| List<MethodHandle> getters, |
| List<String> names) { |
| // This is a pretty lousy algorithm; we spread the receiver over N places, |
| // apply the N getters, apply N toString operations, and concat the result with String.format |
| // Better to use String.format directly, or delegate to StringConcatFactory |
| // Also probably want some quoting around String components |
| |
| assert getters.size() == names.size(); |
| |
| int[] invArgs = new int[getters.size()]; |
| Arrays.fill(invArgs, 0); |
| MethodHandle[] filters = new MethodHandle[getters.size()]; |
| StringBuilder sb = new StringBuilder(); |
| sb.append(receiverClass.getSimpleName()).append("["); |
| for (int i=0; i<getters.size(); i++) { |
| MethodHandle getter = getters.get(i); // (R)T |
| MethodHandle stringify = stringifier(getter.type().returnType()); // (T)String |
| MethodHandle stringifyThisField = MethodHandles.filterArguments(stringify, 0, getter); // (R)String |
| filters[i] = stringifyThisField; |
| sb.append(names.get(i)).append("=%s"); |
| if (i != getters.size() - 1) |
| sb.append(", "); |
| } |
| sb.append(']'); |
| String formatString = sb.toString(); |
| MethodHandle formatter = MethodHandles.insertArguments(STRING_FORMAT, 0, formatString) |
| .asCollector(String[].class, getters.size()); // (R*)String |
| if (getters.size() == 0) { |
| // Add back extra R |
| formatter = MethodHandles.dropArguments(formatter, 0, receiverClass); |
| } |
| else { |
| MethodHandle filtered = MethodHandles.filterArguments(formatter, 0, filters); |
| formatter = MethodHandles.permuteArguments(filtered, MethodType.methodType(String.class, receiverClass), invArgs); |
| } |
| |
| return formatter; |
| } |
| |
| /** |
| * Bootstrap method to generate the {@link Object#equals(Object)}, |
| * {@link Object#hashCode()}, and {@link Object#toString()} methods, based |
| * on a description of the component names and accessor methods, for either |
| * {@code invokedynamic} call sites or dynamic constant pool entries. |
| * |
| * For more detail on the semantics of the generated methods see the specification |
| * of {@link java.lang.Record#equals(Object)}, {@link java.lang.Record#hashCode()} and |
| * {@link java.lang.Record#toString()}. |
| * |
| * |
| * @param lookup Every bootstrap method is expected to have a {@code lookup} |
| * which usually represents a lookup context with the |
| * accessibility privileges of the caller. This is because |
| * {@code invokedynamic} call sites always provide a {@code lookup} |
| * to the corresponding bootstrap method, but this method just |
| * ignores the {@code lookup} parameter |
| * @param methodName the name of the method to generate, which must be one of |
| * {@code "equals"}, {@code "hashCode"}, or {@code "toString"} |
| * @param type a {@link MethodType} corresponding the descriptor type |
| * for the method, which must correspond to the descriptor |
| * for the corresponding {@link Object} method, if linking |
| * an {@code invokedynamic} call site, or the |
| * constant {@code MethodHandle.class}, if linking a |
| * dynamic constant |
| * @param recordClass the record class hosting the record components |
| * @param names the list of component names, joined into a string |
| * separated by ";", or the empty string if there are no |
| * components. Maybe be null, if the {@code methodName} |
| * is {@code "equals"} or {@code "hashCode"}. |
| * @param getters method handles for the accessor methods for the components |
| * @return a call site if invoked by indy, or a method handle |
| * if invoked by a condy |
| * @throws IllegalArgumentException if the bootstrap arguments are invalid |
| * or inconsistent |
| * @throws Throwable if any exception is thrown during call site construction |
| */ |
| public static Object bootstrap(MethodHandles.Lookup lookup, String methodName, TypeDescriptor type, |
| Class<?> recordClass, |
| String names, |
| MethodHandle... getters) throws Throwable { |
| MethodType methodType; |
| if (type instanceof MethodType) |
| methodType = (MethodType) type; |
| else { |
| methodType = null; |
| if (!MethodHandle.class.equals(type)) |
| throw new IllegalArgumentException(type.toString()); |
| } |
| List<MethodHandle> getterList = List.of(getters); |
| MethodHandle handle; |
| switch (methodName) { |
| case "equals": |
| if (methodType != null && !methodType.equals(MethodType.methodType(boolean.class, recordClass, Object.class))) |
| throw new IllegalArgumentException("Bad method type: " + methodType); |
| handle = makeEquals(recordClass, getterList); |
| return methodType != null ? new ConstantCallSite(handle) : handle; |
| case "hashCode": |
| if (methodType != null && !methodType.equals(MethodType.methodType(int.class, recordClass))) |
| throw new IllegalArgumentException("Bad method type: " + methodType); |
| handle = makeHashCode(recordClass, getterList); |
| return methodType != null ? new ConstantCallSite(handle) : handle; |
| case "toString": |
| if (methodType != null && !methodType.equals(MethodType.methodType(String.class, recordClass))) |
| throw new IllegalArgumentException("Bad method type: " + methodType); |
| List<String> nameList = "".equals(names) ? List.of() : List.of(names.split(";")); |
| if (nameList.size() != getterList.size()) |
| throw new IllegalArgumentException("Name list and accessor list do not match"); |
| handle = makeToString(recordClass, getterList, nameList); |
| return methodType != null ? new ConstantCallSite(handle) : handle; |
| default: |
| throw new IllegalArgumentException(methodName); |
| } |
| } |
| } |
