[GR-64589] Use floating code base reads for virtual dispatch outside deopt targets.

PullRequest: graal/23310

Author: peter-hofer

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/ReservedRegisters.java

@@ -30,7 +30,12 @@
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
 
+import com.oracle.svm.core.graal.nodes.ReadReservedRegisterFixedNode;
+import com.oracle.svm.core.graal.nodes.ReadReservedRegisterFloatingNode;
+import com.oracle.svm.core.meta.SharedMethod;
+
 import jdk.graal.compiler.api.replacements.Fold;
+import jdk.graal.compiler.nodes.StructuredGraph;
 import jdk.vm.ci.code.Register;
 import jdk.vm.ci.code.RegisterValue;
 import jdk.vm.ci.meta.JavaValue;
@@ -102,4 +107,20 @@ public boolean isAllowedInFrameState(JavaValue value) {
     public boolean isReservedRegister(Register r) {
         return r.equals(frameRegister) || r.equals(heapBaseRegister) || r.equals(threadRegister) || r.equals(codeBaseRegister);
     }
+
+    /**
+     * Determines whether a graph must use fixed read nodes for a reserved register or can use
+     * floating reads instead.
+     *
+     * A floating node to access the register is more efficient: it allows value numbering of
+     * multiple accesses, including floating nodes that use it as an input. But for deoptimization
+     * target methods, we must not do value numbering because there is no proxying at deoptimization
+     * entry points for this node, so the value is not restored during deoptimization.
+     *
+     * @see ReadReservedRegisterFixedNode
+     * @see ReadReservedRegisterFloatingNode
+     */
+    public boolean mustUseFixedRead(StructuredGraph graph) {
+        return graph.method() instanceof SharedMethod m && m.isDeoptTarget();
+    }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/NonSnippetLowerings.java

@@ -51,6 +51,7 @@
 import com.oracle.svm.core.graal.nodes.LoadOpenTypeWorldDispatchTableStartingOffset;
 import com.oracle.svm.core.graal.nodes.LoweredDeadEndNode;
 import com.oracle.svm.core.graal.nodes.ReadReservedRegisterFixedNode;
+import com.oracle.svm.core.graal.nodes.ReadReservedRegisterFloatingNode;
 import com.oracle.svm.core.graal.nodes.ThrowBytecodeExceptionNode;
 import com.oracle.svm.core.hub.crema.CremaSupport;
 import com.oracle.svm.core.imagelayer.DynamicImageLayerInfo;
@@ -668,13 +669,14 @@ ValueNode createVirtualMethodAddressLoad(
 
             ValueNode virtualMethodAddress;
             if (relativeCodePointers) {
-                /*
-                 * GR-64589: this can be a floating read outside of deoptimization target methods,
-                 * but this code has no knowledge of deoptimization (class ReadReservedRegister).
-                 */
-                FixedWithNextNode codeBase = graph.add(new ReadReservedRegisterFixedNode(ReservedRegisters.singleton().getCodeBaseRegister()));
-                graph.addBeforeFixed(prependTo, codeBase);
-
+                ValueNode codeBase;
+                ReservedRegisters rr = ReservedRegisters.singleton();
+                if (rr.mustUseFixedRead(graph)) {
+                    codeBase = graph.add(new ReadReservedRegisterFixedNode(rr.getCodeBaseRegister()));
+                    graph.addBeforeFixed(prependTo, (FixedWithNextNode) codeBase);
+                } else {
+                    codeBase = graph.unique(new ReadReservedRegisterFloatingNode(rr.getCodeBaseRegister()));
+                }
                 virtualMethodAddress = graph.unique(new AddNode(vtableEntry, codeBase));
             } else {
                 virtualMethodAddress = vtableEntry;

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/nodes/ReadReservedRegister.java

@@ -27,7 +27,6 @@
 import com.oracle.svm.core.ReservedRegisters;
 import com.oracle.svm.core.graal.nodes.ReadReservedRegisterFixedNode;
 import com.oracle.svm.core.graal.nodes.ReadReservedRegisterFloatingNode;
-import com.oracle.svm.hosted.code.SubstrateCompilationDirectives;
 
 import jdk.graal.compiler.nodes.StructuredGraph;
 import jdk.graal.compiler.nodes.ValueNode;
@@ -36,30 +35,27 @@
 public class ReadReservedRegister {
 
     public static ValueNode createReadStackPointerNode(StructuredGraph graph) {
-        return createReadNode(graph, ReservedRegisters.singleton().getFrameRegister());
+        var rr = ReservedRegisters.singleton();
+        return createReadNode(rr.mustUseFixedRead(graph), rr.getFrameRegister());
     }
 
     public static ValueNode createReadIsolateThreadNode(StructuredGraph graph) {
-        return createReadNode(graph, ReservedRegisters.singleton().getThreadRegister());
+        var rr = ReservedRegisters.singleton();
+        return createReadNode(rr.mustUseFixedRead(graph), rr.getThreadRegister());
     }
 
     public static ValueNode createReadHeapBaseNode(StructuredGraph graph) {
-        return createReadNode(graph, ReservedRegisters.singleton().getHeapBaseRegister());
+        var rr = ReservedRegisters.singleton();
+        return createReadNode(rr.mustUseFixedRead(graph), rr.getHeapBaseRegister());
     }
 
     public static ValueNode createReadCodeBaseNode(StructuredGraph graph) {
-        return createReadNode(graph, ReservedRegisters.singleton().getCodeBaseRegister());
+        var rr = ReservedRegisters.singleton();
+        return createReadNode(rr.mustUseFixedRead(graph), rr.getCodeBaseRegister());
     }
 
-    private static ValueNode createReadNode(StructuredGraph graph, Register register) {
-        /*
-         * A floating node to access the register is more efficient: it allows value numbering of
-         * multiple accesses, including floating nodes that use it as an input. But for
-         * deoptimization target methods, we must not do value numbering because there is no
-         * proxying at deoptimization entry points for this node, so the value is not restored
-         * during deoptimization.
-         */
-        if (SubstrateCompilationDirectives.isDeoptTarget(graph.method())) {
+    private static ValueNode createReadNode(boolean useFixedRead, Register register) {
+        if (useFixedRead) {
             return new ReadReservedRegisterFixedNode(register);
         } else {
             return new ReadReservedRegisterFloatingNode(register);