[GR-58055] Track fallback methods created within fallbackResolveConcreteMethod.

PullRequest: graal/19426

Author: teshull

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisType.java

@@ -161,7 +161,6 @@ public abstract class AnalysisType extends AnalysisElement implements WrappedJav
      * implement a method.
      */
     private static final Object NULL_METHOD = new Object();
-    private static final Object COMPUTING_FALLBACK_RESOLUTION = new Object();
 
     private final AnalysisType componentType;
     private final AnalysisType elementalType;
@@ -1118,7 +1117,6 @@ public AnalysisMethod resolveConcreteMethod(ResolvedJavaMethod method, ResolvedJ
         if (resolvedMethod == null) {
             ResolvedJavaMethod originalMethod = OriginalMethodProvider.getOriginalMethod(method);
             Object newResolvedMethod = null;
-            boolean computingFallback = false;
             if (originalMethod != null) {
                 /*
                  * We do not want any access checks to be performed, so we use the method's
@@ -1130,27 +1128,7 @@ public AnalysisMethod resolveConcreteMethod(ResolvedJavaMethod method, ResolvedJ
                     var concreteMethod = originalMethod instanceof BaseLayerMethod ? originalMethod : wrapped.resolveConcreteMethod(originalMethod, originalCallerType);
                     newResolvedMethod = universe.lookup(concreteMethod);
                     if (newResolvedMethod == null) {
-                        /*
-                         * Note we cannot directly use computeIfAbsent; calling
-                         * fallbackResolveConcreteMethod will potentially cause other entries to be
-                         * added to resolvedMethods, resulting in illegal recursive updates.
-                         */
-                        Object oldResolvedMethod = resolvedMethods.putIfAbsent(method, COMPUTING_FALLBACK_RESOLUTION);
-                        if (oldResolvedMethod == null) {
-                            computingFallback = true;
-                            try {
-                                newResolvedMethod = getUniverse().getBigbang().fallbackResolveConcreteMethod(this, (AnalysisMethod) method);
-                            } catch (Throwable t) {
-                                /* Finalize result if an error occurs. */
-                                resolvedMethods.compute(method, (k, v) -> {
-                                    assert v == COMPUTING_FALLBACK_RESOLUTION : v;
-                                    return NULL_METHOD;
-                                });
-                                computingFallback = false;
-
-                                throw t;
-                            }
-                        }
+                        newResolvedMethod = getUniverse().getBigbang().fallbackResolveConcreteMethod(this, (AnalysisMethod) method);
                     }
 
                 } catch (UnsupportedFeatureException e) {
@@ -1162,32 +1140,9 @@ public AnalysisMethod resolveConcreteMethod(ResolvedJavaMethod method, ResolvedJ
             if (newResolvedMethod == null) {
                 newResolvedMethod = NULL_METHOD;
             }
-
-            if (computingFallback) {
-                /*
-                 * If computingFallback is set, it is this thread's responsibility to install the
-                 * result and override the placeholder put in the map.
-                 */
-                var finalResolvedMethod = newResolvedMethod;
-                resolvedMethods.compute(method, (k, v) -> {
-                    assert v == COMPUTING_FALLBACK_RESOLUTION : v;
-                    return finalResolvedMethod;
-                });
-                resolvedMethod = newResolvedMethod;
-            } else {
-                Object oldResolvedMethod = resolvedMethods.putIfAbsent(method, newResolvedMethod);
-                resolvedMethod = oldResolvedMethod != null ? oldResolvedMethod : newResolvedMethod;
-            }
-        }
-
-        /*
-         * Wait for fallback resolution computation to complete on another thread (if needed).
-         */
-        while (resolvedMethod == COMPUTING_FALLBACK_RESOLUTION) {
-            Thread.onSpinWait();
-            resolvedMethod = resolvedMethods.get(method);
+            Object oldResolvedMethod = resolvedMethods.putIfAbsent(method, newResolvedMethod);
+            resolvedMethod = oldResolvedMethod != null ? oldResolvedMethod : newResolvedMethod;
         }
-        assert resolvedMethod != null;
         return resolvedMethod == NULL_METHOD ? null : (AnalysisMethod) resolvedMethod;
     }
 

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/analysis/NativeImagePointsToAnalysis.java

@@ -29,6 +29,7 @@
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Stream;
 
 import com.oracle.graal.pointsto.ClassInclusionPolicy;
@@ -60,6 +61,7 @@
 import jdk.vm.ci.code.BytecodePosition;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
 import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.meta.Signature;
 
 public class NativeImagePointsToAnalysis extends PointsToAnalysis implements Inflation {
 
@@ -68,6 +70,14 @@ public class NativeImagePointsToAnalysis extends PointsToAnalysis implements Inf
     private final CustomTypeFieldHandler customTypeFieldHandler;
     private final CallChecker callChecker;
 
+    /**
+     * Track the fallback methods created so that they are unique.
+     */
+    private final ConcurrentHashMap<FallbackDescriptor, IncompatibleClassChangeFallbackMethod> fallbackMethods = new ConcurrentHashMap<>();
+
+    record FallbackDescriptor(AnalysisType resolvingType, String name, Signature signature) {
+    }
+
     @SuppressWarnings("this-escape")
     public NativeImagePointsToAnalysis(OptionValues options, AnalysisUniverse universe,
                     AnalysisMetaAccess metaAccess, SnippetReflectionProvider snippetReflectionProvider,
@@ -206,7 +216,10 @@ public AnalysisMethod fallbackResolveConcreteMethod(AnalysisType resolvingType,
                  */
                 return method;
             }
-            return getUniverse().lookup(new IncompatibleClassChangeFallbackMethod(resolvingType.getWrapped(), method.getWrapped(), findResolutionError(resolvingType, method.getJavaMethod())));
+
+            var uniqueFallbackMethod = fallbackMethods.computeIfAbsent(new FallbackDescriptor(resolvingType, method.getName(), method.getSignature()),
+                            (k) -> new IncompatibleClassChangeFallbackMethod(resolvingType.getWrapped(), method.getWrapped(), findResolutionError(resolvingType, method.getJavaMethod())));
+            return getUniverse().lookup(uniqueFallbackMethod);
         }
         return super.fallbackResolveConcreteMethod(resolvingType, method);
     }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/CCLinkerInvocation.java

@@ -273,7 +273,7 @@ private static class BinutilsCCLinkerInvocation extends CCLinkerInvocation {
                 additionalPreOptions.add("-Wl,--gc-sections");
             }
 
-            if (!imageKind.isExecutable) {
+            if (imageKind.isImageLayer) {
                 /*
                  * We do not want interposition to affect the resolution of symbols we define and
                  * reference within this library.