Fix stable method name formatter.

Author: pecimuth

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/test/LambdaStableNameTest.java

@@ -25,22 +25,23 @@
 
 package jdk.graal.compiler.hotspot.test;
 
-import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
 
 import java.math.BigInteger;
 import java.util.function.Function;
 
+import jdk.graal.compiler.core.test.GraalCompilerTest;
+import jdk.graal.compiler.java.StableMethodNameFormatter;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+import org.junit.Assert;
 import org.junit.Test;
 
 import jdk.graal.compiler.java.LambdaUtils;
 import jdk.vm.ci.meta.ResolvedJavaType;
 import jdk.vm.ci.runtime.JVMCI;
 
-public class LambdaStableNameTest {
+public class LambdaStableNameTest extends GraalCompilerTest {
 
     @Test
     public void checkStableLamdaNameForRunnableAndAutoCloseable() {
@@ -51,15 +52,15 @@ public void checkStableLamdaNameForRunnableAndAutoCloseable() {
         Runnable r1 = s::hashCode;
         String r1Name = getLambdaName(r1.getClass());
 
-        assertEquals("The two stable lambda names should the same as they reference the same method and implement the same interface", r0Name, r1Name);
+        Assert.assertEquals("The two stable lambda names should the same as they reference the same method and implement the same interface", r0Name, r1Name);
 
         AutoCloseable ac = s::hashCode;
         String acName = getLambdaName(ac.getClass());
 
         assertNotEquals("The two stable lambda names should not be the same as they reference the same method but implement different interfaces", r0Name, acName);
 
         String myName = getClass().getName().replace('.', '/');
-        assertEquals("The name known in 24.0 version is computed", "L" + myName + "$$Lambda.0x59cf38d78b5471f8ea57f1c28b37039c;", r0Name);
+        Assert.assertEquals("The name known in 24.0 version is computed", "L" + myName + "$$Lambda.0x59cf38d78b5471f8ea57f1c28b37039c;", r0Name);
 
         Function<String, Integer> f0 = (str) -> str.hashCode();
         String f0Name = getLambdaName(f0.getClass());
@@ -95,4 +96,14 @@ private static void assertLambdaName(String name) {
         BigInteger aValue = new BigInteger(hash, 16);
         assertNotNull("Hash can be parsed as a hex number: " + hash, aValue);
     }
+
+    @Test
+    public void testStableMethodNameFormatter() {
+        Runnable runnable = "foo"::hashCode;
+        ResolvedJavaMethod method = getResolvedJavaMethod(runnable.getClass(), "run");
+        StableMethodNameFormatter formatter = new StableMethodNameFormatter();
+        String actualName = formatter.apply(method);
+        String expectedName = getClass().getName() + LambdaUtils.LAMBDA_CLASS_NAME_SUBSTRING + "/0x59cf38d78b5471f8ea57f1c28b37039c.run()";
+        Assert.assertEquals(expectedName, actualName);
+    }
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/ProfileReplaySupport.java

@@ -54,7 +54,6 @@
 import jdk.graal.compiler.debug.TTY;
 import jdk.graal.compiler.graph.Node;
 import jdk.graal.compiler.graph.NodeMap;
-import jdk.graal.compiler.java.LambdaUtils;
 import jdk.graal.compiler.java.StableMethodNameFormatter;
 import jdk.graal.compiler.nodes.ConstantNode;
 import jdk.graal.compiler.nodes.FrameState;
@@ -157,12 +156,12 @@ public static ProfileReplaySupport profileReplayPrologue(DebugContext debug, int
                     StableProfileProvider profileProvider, TypeFilter profileSaveFilter) {
         if (SaveProfiles.getValue(debug.getOptions()) || LoadProfiles.getValue(debug.getOptions()) != null) {
             LambdaNameFormatter lambdaNameFormatter = new LambdaNameFormatter() {
-                private final StableMethodNameFormatter stableFormatter = new StableMethodNameFormatter(true);
+                private final StableMethodNameFormatter stableFormatter = new StableMethodNameFormatter();
 
                 @Override
                 public boolean isLambda(ResolvedJavaMethod m) {
                     // Include method handles here as well
-                    return LambdaUtils.isLambdaType(m.getDeclaringClass()) || StableMethodNameFormatter.isMethodHandle(m.getDeclaringClass());
+                    return m.getDeclaringClass().isHidden();
                 }
 
                 @Override

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/replaycomp/CompilerInterfaceDeclarations.java

@@ -33,7 +33,6 @@
 import static jdk.graal.compiler.core.common.NativeImageSupport.inRuntimeCode;
 import static jdk.graal.compiler.hotspot.HotSpotReplacementsImpl.isGraalClass;
 import static jdk.graal.compiler.hotspot.replaycomp.proxy.CompilationProxy.wrapInvocationExceptions;
-import static jdk.graal.compiler.java.StableMethodNameFormatter.isMethodHandle;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -69,7 +68,6 @@
 import jdk.graal.compiler.hotspot.replaycomp.proxy.ProfilingInfoProxy;
 import jdk.graal.compiler.hotspot.replaycomp.proxy.SignatureProxy;
 import jdk.graal.compiler.hotspot.replaycomp.proxy.SpeculationLogProxy;
-import jdk.graal.compiler.java.LambdaUtils;
 import jdk.graal.compiler.options.ExcludeFromJacocoGeneratedReport;
 import jdk.vm.ci.code.CompiledCode;
 import jdk.vm.ci.code.InstalledCode;
@@ -78,6 +76,7 @@
 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;
 import jdk.vm.ci.hotspot.HotSpotMemoryAccessProvider;
 import jdk.vm.ci.hotspot.HotSpotMetaspaceConstant;
+import jdk.vm.ci.hotspot.HotSpotModifiers;
 import jdk.vm.ci.hotspot.HotSpotObjectConstant;
 import jdk.vm.ci.hotspot.HotSpotProfilingInfo;
 import jdk.vm.ci.hotspot.HotSpotResolvedJavaField;
@@ -792,8 +791,12 @@ public static CompilerInterfaceDeclarations build() {
                     // Record calls to be able to format stable lambda names during replay (using StableMethodNameFormatter).
                     HotSpotResolvedJavaMethod method = (HotSpotResolvedJavaMethod) receiver;
                     List<MethodCallToRecord> calls = new ArrayList<>();
-                    if (LambdaUtils.isLambdaType(method.getDeclaringClass()) || isMethodHandle(method.getDeclaringClass())) {
+                    ResolvedJavaType holder = method.getDeclaringClass();
+                    if (holder.isHidden()) {
                         ConstantPool constantPool = method.getConstantPool();
+                        calls.add(new MethodCallToRecord(holder, HotSpotResolvedObjectTypeProxy.getDeclaredConstructorsMethod, HotSpotResolvedObjectTypeProxy.getDeclaredConstructorsInvokable, null));
+                        calls.add(new MethodCallToRecord(holder, HotSpotResolvedObjectTypeProxy.getInterfacesMethod, HotSpotResolvedObjectTypeProxy.getInterfacesInvokable, null));
+                        calls.add(new MethodCallToRecord(holder, HotSpotResolvedObjectTypeProxy.getDeclaredMethodsBooleanMethod, HotSpotResolvedObjectTypeProxy.getDeclaredMethodsBooleanInvokable, new Object[]{false}));
                         calls.add(new MethodCallToRecord(method, HotSpotResolvedJavaMethodProxy.getConstantPoolMethod, HotSpotResolvedJavaMethodProxy.getConstantPoolInvokable, null));
                         for (BytecodeStream stream = new BytecodeStream(method.getCode()); stream.currentBCI() < stream.endBCI(); stream.next()) {
                             int opcode = stream.currentBC();
@@ -817,6 +820,11 @@ public static CompilerInterfaceDeclarations build() {
                     }
                     return calls;
                 })
+                .setStrategy(HotSpotResolvedJavaMethodProxy.isBridgeMethod, MethodStrategy.DefaultValue)
+                .setDefaultValueSupplier(HotSpotResolvedJavaMethodProxy.isBridgeMethod, (proxy, method, args, metaAccess) -> {
+                    ResolvedJavaMethod javaMethod = (ResolvedJavaMethod) proxy;
+                    return (javaMethod.getModifiers() & HotSpotModifiers.BRIDGE) != 0;
+                })
                 .register(declarations);
 
         new RegistrationBuilder<>(Signature.class)

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/replaycomp/RecordedOperationPersistence.java

@@ -207,6 +207,7 @@ private static Map<String, Class<?>> createKnownClasses() {
                             // Needed to deserialize array component types
                             HotSpotResolvedJavaMethod.class, HotSpotResolvedJavaField.class, HotSpotResolvedObjectType.class,
                             Object.class, ExceptionHandler.class, TriState.class, AllocatableValue.class, Value.class,
+                            ResolvedJavaMethod.class,
                             // Needed to deserialize Field objects
                             String.class,
             };

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/replaycomp/proxy/HotSpotResolvedJavaMethodProxy.java

@@ -132,7 +132,7 @@ public boolean isVarArgs() {
         return (boolean) handle(isVarArgsMethod, isVarArgsInvokable);
     }
 
-    private static final SymbolicMethod isBridgeMethod = method("isBridge");
+    public static final SymbolicMethod isBridgeMethod = method("isBridge");
     private static final InvokableMethod isBridgeInvokable = (receiver, args) -> ((HotSpotResolvedJavaMethod) receiver).isBridge();
 
     @Override

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/replaycomp/proxy/HotSpotResolvedJavaTypeProxy.java

@@ -283,8 +283,8 @@ public final HotSpotResolvedObjectType getSuperclass() {
         return (HotSpotResolvedObjectType) handle(getSuperclassMethod, getSuperclassInvokable);
     }
 
-    private static final SymbolicMethod getInterfacesMethod = method("getInterfaces");
-    private static final InvokableMethod getInterfacesInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getInterfaces();
+    public static final SymbolicMethod getInterfacesMethod = method("getInterfaces");
+    public static final InvokableMethod getInterfacesInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getInterfaces();
 
     @Override
     public final HotSpotResolvedObjectType[] getInterfaces() {
@@ -414,8 +414,8 @@ public List<? extends ResolvedJavaRecordComponent> getRecordComponents() {
         return (List<ResolvedJavaRecordComponent>) handle(getRecordComponentsMethod, getRecordComponentsInvokable);
     }
 
-    private static final SymbolicMethod getDeclaredConstructorsMethod = method("getDeclaredConstructors");
-    private static final InvokableMethod getDeclaredConstructorsInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getDeclaredConstructors();
+    public static final SymbolicMethod getDeclaredConstructorsMethod = method("getDeclaredConstructors");
+    public static final InvokableMethod getDeclaredConstructorsInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getDeclaredConstructors();
 
     @Override
     public final ResolvedJavaMethod[] getDeclaredConstructors() {
@@ -447,8 +447,8 @@ public List<ResolvedJavaMethod> getAllMethods(boolean forceLink) {
         return (List<ResolvedJavaMethod>) handle(getAllMethodsMethod, getAllMethodsInvokable, forceLink);
     }
 
-    private static final SymbolicMethod getDeclaredMethodsBooleanMethod = method("getDeclaredMethods", boolean.class);
-    private static final InvokableMethod getDeclaredMethodsBooleanInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getDeclaredMethods((boolean) args[0]);
+    public static final SymbolicMethod getDeclaredMethodsBooleanMethod = method("getDeclaredMethods", boolean.class);
+    public static final InvokableMethod getDeclaredMethodsBooleanInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getDeclaredMethods((boolean) args[0]);
 
     @Override
     public final ResolvedJavaMethod[] getDeclaredMethods(boolean forceLink) {

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/LambdaUtils.java

@@ -58,41 +58,28 @@ private LambdaUtils() {
     }
 
     /**
-     * Creates a stable name for a lambda by hashing all the invokes in the lambda. Lambda class
-     * names are typically created based on an increasing atomic counter (e.g.
-     * {@code Test$$Lambda$23}). A stable name is created by replacing the substring after
-     * {@code "$$Lambda$"} with a hash of the method descriptor for each method invoked by the
-     * lambda.
-     *
-     * Starting from JDK17, the lambda classes can have additional interfaces that lambda should
-     * implement. This further means that lambda can have more than one public method (public and
-     * not bridge).
-     *
-     * The scala lambda classes have by default one additional interface with one method. This
-     * method has the same signature as the original one but with generalized parameters (all
-     * parameters are Object types) and serves as a wrapper that casts parameters to specialized
-     * types and calls an original method.
+     * Creates a stable name for a lambda by replacing the unqualified name of the hidden class name
+     * with a stable {@link #getSignature signature}.
      *
      * @param lambdaType the lambda type to analyze
      * @return stable name for the lambda class
      */
     @SuppressWarnings("try")
     public static String findStableLambdaName(ResolvedJavaType lambdaType) {
-        ResolvedJavaMethod[] lambdaProxyMethods = Arrays.stream(lambdaType.getDeclaredMethods(false)).filter(m -> !m.isBridge() && m.isPublic()).toArray(ResolvedJavaMethod[]::new);
-        /*
-         * Take only the first method to find invoked methods, because the result would be the same
-         * for all other methods.
-         */
-        List<JavaMethod> invokedMethods = findInvokedMethods(lambdaProxyMethods[0]);
-        if (invokedMethods.isEmpty()) {
+        final String lambdaName = lambdaType.getName();
+        assert lambdaMatcher(lambdaName).find() : "Stable name should be created for lambda types: " + lambdaName;
+
+        Matcher matcher = lambdaMatcher(lambdaName);
+        String signature = getSignature(lambdaType);
+        if (signature == null) {
             StringBuilder sb = new StringBuilder();
             sb.append("Lambda without a target invoke: ").append(lambdaType.toClassName());
-            for (ResolvedJavaMethod m : lambdaType.getDeclaredMethods(false)) {
-                sb.append("\n  Method: ").append(m);
+            for (ResolvedJavaMethod method : lambdaType.getDeclaredMethods(false)) {
+                sb.append("\n  Method: ").append(method);
             }
             throw new JVMCIError(sb.toString());
         }
-        return createStableLambdaName(lambdaType, invokedMethods);
+        return matcher.replaceFirst(Matcher.quoteReplacement(LAMBDA_CLASS_NAME_SUBSTRING + ADDRESS_PREFIX + signature + ";"));
     }
 
     /**
@@ -101,7 +88,7 @@ public static String findStableLambdaName(ResolvedJavaType lambdaType) {
      * @param method the method whose bytecode is parsed
      * @return the list of invoked methods
      */
-    public static List<JavaMethod> findInvokedMethods(ResolvedJavaMethod method) {
+    private static List<JavaMethod> findInvokedMethods(ResolvedJavaMethod method) {
         ConstantPool constantPool = method.getConstantPool();
         List<JavaMethod> invokedMethods = new ArrayList<>();
         for (BytecodeStream stream = new BytecodeStream(method.getCode()); stream.currentBCI() < stream.endBCI(); stream.next()) {
@@ -142,11 +129,36 @@ public static boolean isLambdaName(String name) {
         return isLambdaClassName(name) && lambdaMatcher(name).find();
     }
 
-    private static String createStableLambdaName(ResolvedJavaType lambdaType, List<JavaMethod> invokedMethods) {
-        final String lambdaName = lambdaType.getName();
-        assert lambdaMatcher(lambdaName).find() : "Stable name should be created for lambda types: " + lambdaName;
+    /**
+     * Generates a signature for a given lambda type by hashing its composing parts. The signature
+     * is generated based on the methods invoked in the lambda's bytecode, the constructor parameter
+     * types, and the interfaces implemented by the lambda. Returns {@code null} if the lambda type
+     * does not have any invoked methods.
+     * <p>
+     * Starting from JDK17, the lambda classes can have additional interfaces that lambda should
+     * implement. This further means that lambda can have more than one public method (public and
+     * not bridge).
+     * <p>
+     * The scala lambda classes have by default one additional interface with one method. This
+     * method has the same signature as the original one but with generalized parameters (all
+     * parameters are Object types) and serves as a wrapper that casts parameters to specialized
+     * types and calls an original method.
+     *
+     * @param lambdaType the lambda type to generate a signature for
+     * @return a 32-character hexadecimal string representing the lambda's signature or {@code null}
+     *         if the lambda type does not have any invoked methods
+     */
+    public static String getSignature(ResolvedJavaType lambdaType) {
+        ResolvedJavaMethod[] lambdaProxyMethods = Arrays.stream(lambdaType.getDeclaredMethods(false)).filter(m -> !m.isBridge() && m.isPublic()).toArray(ResolvedJavaMethod[]::new);
+        /*
+         * Take only the first method to find invoked methods, because the result would be the same
+         * for all other methods.
+         */
+        List<JavaMethod> invokedMethods = findInvokedMethods(lambdaProxyMethods[0]);
+        if (invokedMethods.isEmpty()) {
+            return null;
+        }
 
-        Matcher m = lambdaMatcher(lambdaName);
         /* Generate lambda signature by hashing its composing parts. */
         StringBuilder sb = new StringBuilder();
         /* Append invoked methods. */
@@ -163,7 +175,7 @@ private static String createStableLambdaName(ResolvedJavaType lambdaType, List<J
         }
         String signature = Digest.digestAsHex(sb.toString());
         GraalError.guarantee(signature.length() == 32, "Expecting a 32 digits long hex value.");
-        return m.replaceFirst(Matcher.quoteReplacement(LAMBDA_CLASS_NAME_SUBSTRING + ADDRESS_PREFIX + signature + ";"));
+        return signature;
     }
 
     private static Matcher lambdaMatcher(String value) {