[GR-71264] Verify that a type is linked before computing a stable signature.

PullRequest: graal/22577

Author: pecimuth

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

@@ -807,7 +807,8 @@ public static CompilerInterfaceDeclarations build() {
                     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.isLinkedMethod, HotSpotResolvedJavaTypeProxy.isLinkedInvokable, null));
+                        calls.add(new MethodCallToRecord(holder, HotSpotResolvedObjectTypeProxy.getDeclaredConstructorsBooleanMethod, HotSpotResolvedObjectTypeProxy.getDeclaredConstructorsBooleanInvokable, new Object[]{false}));
                         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));

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

@@ -224,8 +224,8 @@ public final void initialize() {
         handle(initializeMethod, initializeInvokable);
     }
 
-    private static final SymbolicMethod isLinkedMethod = method("isLinked");
-    private static final InvokableMethod isLinkedInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).isLinked();
+    public static final SymbolicMethod isLinkedMethod = method("isLinked");
+    public static final InvokableMethod isLinkedInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).isLinked();
 
     @Override
     public final boolean isLinked() {
@@ -414,16 +414,16 @@ public List<? extends ResolvedJavaRecordComponent> getRecordComponents() {
         return (List<ResolvedJavaRecordComponent>) handle(getRecordComponentsMethod, getRecordComponentsInvokable);
     }
 
-    public static final SymbolicMethod getDeclaredConstructorsMethod = method("getDeclaredConstructors");
-    public static final InvokableMethod getDeclaredConstructorsInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getDeclaredConstructors();
+    private static final SymbolicMethod getDeclaredConstructorsMethod = method("getDeclaredConstructors");
+    private static final InvokableMethod getDeclaredConstructorsInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getDeclaredConstructors();
 
     @Override
     public final ResolvedJavaMethod[] getDeclaredConstructors() {
         return (ResolvedJavaMethod[]) handle(getDeclaredConstructorsMethod, getDeclaredConstructorsInvokable);
     }
 
-    private static final SymbolicMethod getDeclaredConstructorsBooleanMethod = method("getDeclaredConstructors", boolean.class);
-    private static final InvokableMethod getDeclaredConstructorsBooleanInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getDeclaredConstructors((Boolean) args[0]);
+    public static final SymbolicMethod getDeclaredConstructorsBooleanMethod = method("getDeclaredConstructors", boolean.class);
+    public static final InvokableMethod getDeclaredConstructorsBooleanInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).getDeclaredConstructors((Boolean) args[0]);
 
     @Override
     public final ResolvedJavaMethod[] getDeclaredConstructors(boolean forceLink) {

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

@@ -73,7 +73,7 @@ public static String findStableLambdaName(ResolvedJavaType lambdaType) {
         String signature = getSignature(lambdaType);
         if (signature == null) {
             StringBuilder sb = new StringBuilder();
-            sb.append("Lambda without a target invoke: ").append(lambdaType.toClassName());
+            sb.append("Lambda without a signature: ").append(lambdaType.toClassName()).append(" (linked: ").append(lambdaType.isLinked()).append(")");
             for (ResolvedJavaMethod method : lambdaType.getDeclaredMethods(false)) {
                 sb.append("\n  Method: ").append(method);
             }
@@ -133,9 +133,9 @@ public static boolean isLambdaName(String name) {
      * Generates a signature for a given type by hashing its composing parts. The signature is
      * generated based on the methods invoked in the bytecode of a public non-bridge method, the
      * constructor parameter types, and the interfaces implemented by the type. Returns {@code null}
-     * if the selected declared method does not invoke any other method. The procedure should
-     * generate reasonable signatures for lambda proxy types, but it may fail to do so for general
-     * hidden classes.
+     * if the type is not linked or the selected declared method does not invoke any other method.
+     * The procedure should generate reasonable signatures for lambda proxy types, but it may fail
+     * to do so for general hidden classes.
      * <p>
      * Starting from JDK17, lambda classes can have additional interfaces that lambda should
      * implement. This further means that lambda can have more than one public method (public and
@@ -148,9 +148,12 @@ public static boolean isLambdaName(String name) {
      *
      * @param type the type to generate a signature for
      * @return a 32-character hexadecimal string representing the type signature or {@code null} if
-     *         the selected declared method does not have any invokes
+     *         the type is not linked or the selected declared method does not have any invokes
      */
     public static String getSignature(ResolvedJavaType type) {
+        if (!type.isLinked()) {
+            return null;
+        }
         /*
          * Take only the first method to find invoked methods, because the result would be the same
          * for all other methods (if it is a lambda type).
@@ -166,7 +169,7 @@ public static String getSignature(ResolvedJavaType type) {
             sb.append(method.format("%H.%n(%P)%R"));
         }
         /* Append constructor parameter types. */
-        for (JavaMethod ctor : type.getDeclaredConstructors()) {
+        for (JavaMethod ctor : type.getDeclaredConstructors(false)) {
             sb.append(ctor.format("%P"));
         }
         /* Append implemented interfaces. */