[GR-68990] [GR-69008] Fix graph equality when replaying libgraal compilation on jargraal and fix cache replacements

PullRequest: graal/21937

Author: pecimuth

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/replaycomp/test/ReplayCompilationTest.java

@@ -38,6 +38,8 @@
 
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.EconomicSet;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import com.oracle.truffle.api.Truffle;
@@ -46,6 +48,7 @@
 import jdk.graal.compiler.core.CompilationWrapper;
 import jdk.graal.compiler.core.GraalCompilerOptions;
 import jdk.graal.compiler.core.test.GraalCompilerTest;
+import jdk.graal.compiler.debug.DebugCloseable;
 import jdk.graal.compiler.debug.DebugOptions;
 import jdk.graal.compiler.debug.GlobalMetrics;
 import jdk.graal.compiler.debug.LogStream;
@@ -54,9 +57,11 @@
 import jdk.graal.compiler.hotspot.CompilerConfigurationFactory;
 import jdk.graal.compiler.hotspot.HotSpotGraalCompiler;
 import jdk.graal.compiler.hotspot.HotSpotGraalCompilerFactory;
+import jdk.graal.compiler.hotspot.HotSpotReplacementsImpl;
 import jdk.graal.compiler.hotspot.replaycomp.CompilerInterfaceDeclarations;
 import jdk.graal.compiler.hotspot.replaycomp.ReplayCompilationRunner;
 import jdk.graal.compiler.options.OptionValues;
+import jdk.graal.compiler.phases.util.Providers;
 import jdk.graal.compiler.runtime.RuntimeProvider;
 import jdk.vm.ci.hotspot.HotSpotCompilationRequest;
 import jdk.vm.ci.hotspot.HotSpotCompilationRequestResult;
@@ -69,6 +74,25 @@
  * Tests for compilation recording and replay.
  */
 public class ReplayCompilationTest extends GraalCompilerTest {
+    /**
+     * A separate encoded snippet scope is necessary in case the global encoded snippets have cache
+     * replacements.
+     */
+    private static DebugCloseable snippetScope;
+
+    @BeforeClass
+    public static void setup() {
+        Providers providers = Graal.getRequiredCapability(RuntimeProvider.class).getHostBackend().getProviders();
+        HotSpotReplacementsImpl replacements = (HotSpotReplacementsImpl) providers.getReplacements();
+        snippetScope = replacements.suppressEncodedSnippets();
+        replacements.encode(getInitialOptions());
+    }
+
+    @AfterClass
+    public static void teardown() {
+        snippetScope.close();
+    }
+
     private static int[] lengthsSquared(List<String> strings) {
         return strings.stream().mapToInt(String::length).map(i -> i * i).toArray();
     }

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

@@ -47,6 +47,7 @@
 import jdk.graal.compiler.core.common.type.StampPair;
 import jdk.graal.compiler.core.common.type.SymbolicJVMCIReference;
 import jdk.graal.compiler.debug.DebugContext;
+import jdk.graal.compiler.debug.DebugOptions;
 import jdk.graal.compiler.debug.GraalError;
 import jdk.graal.compiler.nodeinfo.Verbosity;
 import jdk.graal.compiler.nodes.ConstantNode;
@@ -250,12 +251,14 @@ StructuredGraph getEncodedSnippet(ResolvedJavaMethod method, ResolvedJavaMethod
             declaringClass = replacements.getProviders().getMetaAccess().lookupJavaType(Object.class);
         }
         /*
-         * If this is a recorded/replayed compilation, we must not mutate the snippet objects. This
-         * ensures we record all relevant operations during recording and no proxies are stored in
-         * the snippet objects during replay.
+         * If there is a possibility of a recorded/replayed compilation, we must not mutate the
+         * snippet objects. During recording, this ensures that we record all relevant operations
+         * and the cached objects are resolved to proxies. During replay, this ensures that no
+         * proxies are stored in the snippet objects.
          */
         boolean allowCacheReplacements = replacements.getProviders().getReplayCompilationSupport() == null &&
-                        GraalCompilerOptions.CompilationFailureAction.getValue(options) != CompilationWrapper.ExceptionAction.Diagnose;
+                        GraalCompilerOptions.CompilationFailureAction.getValue(options) != CompilationWrapper.ExceptionAction.Diagnose &&
+                        !DebugOptions.RecordForReplay.hasBeenSet(options);
         SymbolicEncodedGraph encodedGraph = new SymbolicEncodedGraph(snippetEncoding, startOffset, snippetObjects, allowCacheReplacements,
                         snippetNodeClasses, data.originalMethod, declaringClass);
         return decodeSnippetGraph(encodedGraph, method, original, replacements, args, allowAssumptions, options, true);

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/replacements/AssertionSnippets.java

@@ -90,7 +90,7 @@ public void lower(AssertionNode assertionNode, LoweringTool tool) {
             Arguments args = new Arguments(graph.start() instanceof StubStartNode ? stubAssertion : assertion, graph, tool.getLoweringStage());
             args.add("condition", assertionNode.condition());
             args.add("message",
-                            graph.unique(new ConstantNode(new CStringConstant("failed runtime assertion in snippet/stub: " + assertionNode.message() + " (" + graph.method() + ")"),
+                            graph.unique(new ConstantNode(new CStringConstant("failed runtime assertion in snippet/stub: " + assertionNode.message() + " (" + graph.method().format("%H.%n(%p)") + ")"),
                                             StampFactory.pointer())));
             args.add("l1", assertionNode.getL1());
             args.add("l2", assertionNode.getL2());

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

@@ -30,6 +30,7 @@
 import static jdk.graal.compiler.bytecode.Bytecodes.INVOKESPECIAL;
 import static jdk.graal.compiler.bytecode.Bytecodes.INVOKESTATIC;
 import static jdk.graal.compiler.bytecode.Bytecodes.INVOKEVIRTUAL;
+import static jdk.graal.compiler.hotspot.HotSpotReplacementsImpl.isGraalClass;
 import static jdk.graal.compiler.java.StableMethodNameFormatter.isMethodHandle;
 
 import java.lang.reflect.Proxy;
@@ -48,6 +49,7 @@
 import jdk.graal.compiler.core.common.CompilerProfiler;
 import jdk.graal.compiler.debug.DebugContext;
 import jdk.graal.compiler.debug.GraalError;
+import jdk.graal.compiler.hotspot.meta.HotSpotGraalConstantFieldProvider;
 import jdk.graal.compiler.hotspot.replaycomp.proxy.CompilationProxy;
 import jdk.graal.compiler.hotspot.replaycomp.proxy.CompilationProxyBase;
 import jdk.graal.compiler.hotspot.replaycomp.proxy.CompilerProfilerProxy;
@@ -66,6 +68,7 @@
 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.hotspot.HotSpotCodeCacheProvider;
 import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider;
 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;
@@ -703,6 +706,7 @@ public static CompilerInterfaceDeclarations build() {
                     }
                     return List.of();
                 })
+                .setFallbackInvocationHandler(HotSpotResolvedObjectTypeProxy.isInstanceMethod, CompilerInterfaceDeclarations::objectTypeIsInstanceFallback)
                 .register(declarations);
         // Must come after HotSpotResolvedObjectType. Needed for HotSpotResolvedPrimitiveType.
         new RegistrationBuilder<>(HotSpotResolvedJavaType.class)
@@ -921,4 +925,27 @@ private static ResolvedJavaType javaLangObjectSupplier(Object proxy, Compilation
         MetaAccessProvider metaAccess = (MetaAccessProvider) singletonObjects.get(MetaAccessProvider.class);
         return metaAccess.lookupJavaType(Object.class);
     }
+
+    /**
+     * Implements a fallback for {@link HotSpotResolvedObjectType#isInstance} calls performed by
+     * {@link HotSpotGraalConstantFieldProvider} when replaying a libgraal compilation on jargraal.
+     * <p>
+     * The provider performs checks like {@code getHotSpotVMConfigType().isInstance(receiver)},
+     * which use snippet types on libgraal and HotSpot types on jargraal. Replay on jargraal needs
+     * to answer these queries when the receiver and argument are HotSpot proxies.
+     */
+    @SuppressWarnings("unused")
+    @ExcludeFromJacocoGeneratedReport("related to replay of libgraal compilations on jargraal")
+    private static boolean objectTypeIsInstanceFallback(Object proxy, CompilationProxy.SymbolicMethod method, Object[] args, EconomicMap<Class<?>, Object> singletonObjects) {
+        HotSpotResolvedObjectType receiverType = (HotSpotResolvedObjectType) proxy;
+        if (!(args[0] instanceof HotSpotObjectConstant objectConstant)) {
+            return false;
+        }
+        HotSpotResolvedObjectType constantType = objectConstant.getType();
+        if (isGraalClass(receiverType) && !isGraalClass(constantType)) {
+            // Assumes that only a Graal class can subtype a Graal class.
+            return false;
+        }
+        return receiverType.isAssignableFrom(constantType);
+    }
 }

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

@@ -241,7 +241,7 @@ public final boolean isAssignableFrom(ResolvedJavaType other) {
         return (boolean) handle(isAssignableFromMethod, isAssignableFromInvokable, other);
     }
 
-    private static final SymbolicMethod isInstanceMethod = method("isInstance", JavaConstant.class);
+    public static final SymbolicMethod isInstanceMethod = method("isInstance", JavaConstant.class);
     private static final InvokableMethod isInstanceInvokable = (receiver, args) -> ((HotSpotResolvedJavaType) receiver).isInstance((JavaConstant) args[0]);
 
     @Override