In deopt stub, save registers again using stub calling convention.

peter-hofer · peter-hofer · commit 848b11b6653d · 2025-07-31T12:57:31.000+02:00
diff --git a/substratevm/src/com.oracle.svm.core.graal.aarch64/src/com/oracle/svm/core/graal/aarch64/SubstrateAArch64Backend.java b/substratevm/src/com.oracle.svm.core.graal.aarch64/src/com/oracle/svm/core/graal/aarch64/SubstrateAArch64Backend.java
@@ -487,27 +487,19 @@ public SubstrateLIRGenerationResult(CompilationIdentifier compilationId, LIR lir
             super(compilationId, lir, frameMapBuilder, registerAllocationConfig, callingConvention);
             this.method = method;
 
-            /*
-             * Besides for methods with callee saved registers, we reserve additional stack space
-             * for lazyDeoptStub too. This is necessary because the lazy deopt stub might read
-             * callee-saved register values in the callee of the function to be deoptimized, thus
-             * that stack space must not be overwritten by the lazy deopt stub.
-             */
-            if (method.hasCalleeSavedRegisters() || method.getDeoptStubType() == Deoptimizer.StubType.LazyEntryStub) {
+            if (method.hasCalleeSavedRegisters()) {
                 AArch64CalleeSavedRegisters calleeSavedRegisters = AArch64CalleeSavedRegisters.singleton();
                 FrameMap frameMap = ((FrameMapBuilderTool) frameMapBuilder).getFrameMap();
                 int registerSaveAreaSizeInBytes = calleeSavedRegisters.getSaveAreaSize();
                 StackSlot calleeSaveArea = frameMap.allocateStackMemory(registerSaveAreaSizeInBytes, frameMap.getTarget().wordSize);
 
-                if (method.hasCalleeSavedRegisters()) {
-                    /*
-                     * The offset of the callee save area must be fixed early during image
-                     * generation. It is accessed when compiling methods that have a call with
-                     * callee-saved calling convention. Here we verify that offset computed earlier
-                     * is the same as the offset actually reserved.
-                     */
-                    calleeSavedRegisters.verifySaveAreaOffsetInFrame(calleeSaveArea.getRawOffset());
-                }
+                /*
+                 * The offset of the callee save area must be fixed early during image generation.
+                 * It is accessed when compiling methods that have a call with callee-saved calling
+                 * convention. Here we verify that offset computed earlier is the same as the offset
+                 * actually reserved.
+                 */
+                calleeSavedRegisters.verifySaveAreaOffsetInFrame(calleeSaveArea.getRawOffset());
             }
 
             if (method.canDeoptimize() || method.isDeoptTarget()) {
@@ -1042,9 +1034,8 @@ public void returned(CompilationResultBuilder crb) {
     }
 
     /**
-     * Generates the prologue of a
-     * {@link com.oracle.svm.core.deopt.Deoptimizer.StubType#EagerEntryStub} or
-     * {@link com.oracle.svm.core.deopt.Deoptimizer.StubType#LazyEntryStub} method.
+     * Generates the prologue of a {@link com.oracle.svm.core.deopt.Deoptimizer.StubType#EntryStub}
+     * method.
      */
     protected static class DeoptEntryStubContext extends SubstrateAArch64FrameContext {
         protected final CallingConvention callingConvention;
@@ -1058,9 +1049,13 @@ protected DeoptEntryStubContext(SharedMethod method, CallingConvention callingCo
         public void enter(CompilationResultBuilder crb) {
             AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
             RegisterConfig registerConfig = crb.frameMap.getRegisterConfig();
+            Register frameRegister = registerConfig.getFrameRegister();
             Register gpReturnReg = registerConfig.getReturnRegister(JavaKind.Object);
             Register fpReturnReg = registerConfig.getReturnRegister(JavaKind.Double);
 
+            /* Create the frame. */
+            super.enter(crb);
+
             /* Pass the general purpose and floating point registers to the deopt stub. */
             Register secondParameter = ValueUtil.asRegister(callingConvention.getArgument(1));
             masm.mov(64, secondParameter, gpReturnReg);
@@ -1073,9 +1068,7 @@ public void enter(CompilationResultBuilder crb) {
              * the first argument register may overlap with the object return register.
              */
             Register firstParameter = ValueUtil.asRegister(callingConvention.getArgument(0));
-            masm.mov(64, firstParameter, registerConfig.getFrameRegister());
-
-            super.enter(crb);
+            masm.add(64, firstParameter, frameRegister, crb.frameMap.totalFrameSize());
         }
     }
 
@@ -1343,7 +1336,7 @@ public CompilationResultBuilder newCompilationResultBuilder(LIRGenerationResult
     }
 
     protected FrameContext createFrameContext(SharedMethod method, Deoptimizer.StubType stubType, CallingConvention callingConvention) {
-        if (stubType == Deoptimizer.StubType.EagerEntryStub || stubType == Deoptimizer.StubType.LazyEntryStub) {
+        if (stubType == Deoptimizer.StubType.EntryStub) {
             return new DeoptEntryStubContext(method, callingConvention);
         } else if (stubType == Deoptimizer.StubType.ExitStub) {
             return new DeoptExitStubContext(method, callingConvention);
diff --git a/substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/SubstrateAMD64Backend.java b/substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/SubstrateAMD64Backend.java
@@ -564,27 +564,19 @@ public SubstrateLIRGenerationResult(CompilationIdentifier compilationId, LIR lir
             super(compilationId, lir, frameMapBuilder, registerAllocationConfig, callingConvention);
             this.method = method;
 
-            /*
-             * Besides for methods with callee saved registers, we reserve additional stack space
-             * for lazyDeoptStub too. This is necessary because the lazy deopt stub might read
-             * callee-saved register values in the callee of the function to be deoptimized, thus
-             * that stack space must not be overwritten by the lazy deopt stub.
-             */
-            if (method.hasCalleeSavedRegisters() || method.getDeoptStubType() == Deoptimizer.StubType.LazyEntryStub) {
+            if (method.hasCalleeSavedRegisters()) {
                 AMD64CalleeSavedRegisters calleeSavedRegisters = AMD64CalleeSavedRegisters.singleton();
                 FrameMap frameMap = ((FrameMapBuilderTool) frameMapBuilder).getFrameMap();
                 int registerSaveAreaSizeInBytes = calleeSavedRegisters.getSaveAreaSize();
                 StackSlot calleeSaveArea = frameMap.allocateStackMemory(registerSaveAreaSizeInBytes, frameMap.getTarget().wordSize);
 
-                if (method.hasCalleeSavedRegisters()) {
-                    /*
-                     * The offset of the callee save area must be fixed early during image
-                     * generation. It is accessed when compiling methods that have a call with
-                     * callee-saved calling convention. Here we verify that offset computed earlier
-                     * is the same as the offset actually reserved.
-                     */
-                    calleeSavedRegisters.verifySaveAreaOffsetInFrame(calleeSaveArea.getRawOffset());
-                }
+                /*
+                 * The offset of the callee save area must be fixed early during image generation.
+                 * It is accessed when compiling methods that have a call with callee-saved calling
+                 * convention. Here we verify that offset computed earlier is the same as the offset
+                 * actually reserved.
+                 */
+                calleeSavedRegisters.verifySaveAreaOffsetInFrame(calleeSaveArea.getRawOffset());
             }
 
             if (method.canDeoptimize() || method.isDeoptTarget()) {
@@ -1344,9 +1336,8 @@ public void returned(CompilationResultBuilder crb) {
     }
 
     /**
-     * Generates the prologue of a
-     * {@link com.oracle.svm.core.deopt.Deoptimizer.StubType#EagerEntryStub} or
-     * {@link com.oracle.svm.core.deopt.Deoptimizer.StubType#LazyEntryStub} method.
+     * Generates the prologue of a {@link com.oracle.svm.core.deopt.Deoptimizer.StubType#EntryStub}
+     * method.
      */
     protected static class DeoptEntryStubContext extends SubstrateAMD64FrameContext {
         protected DeoptEntryStubContext(SharedMethod method, CallingConvention callingConvention) {
@@ -1357,24 +1348,18 @@ protected DeoptEntryStubContext(SharedMethod method, CallingConvention callingCo
         public void enter(CompilationResultBuilder tasm) {
             AMD64MacroAssembler asm = (AMD64MacroAssembler) tasm.asm;
             RegisterConfig registerConfig = tasm.frameMap.getRegisterConfig();
+            Register frameRegister = registerConfig.getFrameRegister();
             Register gpReturnReg = registerConfig.getReturnRegister(JavaKind.Long);
             Register fpReturnReg = registerConfig.getReturnRegister(JavaKind.Double);
-
             Register firstArgument = ValueUtil.asRegister(callingConvention.getArgument(0));
             assert !firstArgument.equals(gpReturnReg) : "overwriting return register";
+
             /*
              * Since this is the target for all deoptimizations we must mark the start of this
              * routine as an indirect target.
              */
             asm.maybeEmitIndirectTargetMarker();
 
-            /* Pass the address of the frame to deoptimize as first argument. */
-            asm.movq(firstArgument, registerConfig.getFrameRegister());
-
-            /* Copy the original return registers values into the argument registers. */
-            asm.movq(ValueUtil.asRegister(callingConvention.getArgument(1)), gpReturnReg);
-            asm.movdq(ValueUtil.asRegister(callingConvention.getArgument(2)), fpReturnReg);
-
             /*
              * Keep the return address slot. This keeps the stack walkable, which is crucial for the
              * interruptible phase of lazy deoptimization. (The return address points to the deopt
@@ -1383,7 +1368,15 @@ public void enter(CompilationResultBuilder tasm) {
              * This also ensures that the stack pointer is aligned properly.
              */
             asm.subq(registerConfig.getFrameRegister(), FrameAccess.returnAddressSize());
+
             super.enter(tasm);
+
+            /* Pass the address of the frame to deoptimize as first argument. */
+            asm.leaq(firstArgument, new AMD64Address(frameRegister, tasm.frameMap.totalFrameSize()));
+
+            /* Copy the original return registers values into the argument registers. */
+            asm.movq(ValueUtil.asRegister(callingConvention.getArgument(1)), gpReturnReg);
+            asm.movdq(ValueUtil.asRegister(callingConvention.getArgument(2)), fpReturnReg);
         }
     }
 
@@ -1392,7 +1385,7 @@ public void enter(CompilationResultBuilder tasm) {
      * method.
      *
      * Note no special handling is necessary for CFI as this will be a direct call from the
-     * {@link com.oracle.svm.core.deopt.Deoptimizer.StubType#EagerEntryStub}.
+     * {@link com.oracle.svm.core.deopt.Deoptimizer.StubType#EntryStub}.
      */
     protected static class DeoptExitStubContext extends SubstrateAMD64FrameContext {
         protected DeoptExitStubContext(SharedMethod method, CallingConvention callingConvention) {
@@ -1918,7 +1911,7 @@ protected AMD64MacroAssembler createAssembler(OptionValues options) {
     }
 
     protected FrameContext createFrameContext(SharedMethod method, Deoptimizer.StubType stubType, CallingConvention callingConvention) {
-        if (stubType == Deoptimizer.StubType.EagerEntryStub || stubType == Deoptimizer.StubType.LazyEntryStub) {
+        if (stubType == Deoptimizer.StubType.EntryStub) {
             return new DeoptEntryStubContext(method, callingConvention);
         } else if (stubType == Deoptimizer.StubType.ExitStub) {
             return new DeoptExitStubContext(method, callingConvention);
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/deopt/Deoptimizer.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/deopt/Deoptimizer.java
@@ -59,6 +59,7 @@
 import com.oracle.svm.core.config.ConfigurationValues;
 import com.oracle.svm.core.deopt.DeoptimizedFrame.RelockObjectData;
 import com.oracle.svm.core.deopt.DeoptimizedFrame.VirtualFrame;
+import com.oracle.svm.core.graal.code.StubCallingConvention;
 import com.oracle.svm.core.heap.GCCause;
 import com.oracle.svm.core.heap.Heap;
 import com.oracle.svm.core.heap.ReferenceAccess;
@@ -754,15 +755,7 @@ public enum StubType {
         /**
          * Custom prologue: save all of the architecture's return registers onto the stack.
          */
-        EagerEntryStub,
-
-        /**
-         * Custom prologue: same custom Prologue as the EagerEntryStub, but we also reserve some
-         * additional memory on the stack when this stub is entered, because the lazyDeoptStub might
-         * need to access callee-saved values in the frame of the callee of the method to be
-         * deoptimized.
-         */
-        LazyEntryStub,
+        EntryStub,
 
         /**
          * Custom prologue: set the stack pointer to the first method parameter.
@@ -812,7 +805,27 @@ private static boolean isNonNullValue(UnsignedWord pointer) {
         return pointer != Word.nullPointer();
     }
 
-    @DeoptStub(stubType = StubType.LazyEntryStub)
+    /**
+     * Entry point for the lazy deopt stub.
+     * <p>
+     * This method uses {@link StubCallingConvention} for when the callee (the return of which is
+     * intercepted) also uses stub calling convention. In that case, the callee (rather than the
+     * caller) has initially saved the values of registers, and these values are required for
+     * constructing the deopt frame. The values have already been restored to their registers before
+     * the return to this stub, and using stub calling convention here saves them again to the same
+     * expected locations.
+     * <p>
+     * Usually, the saved register values would still be present below the stack pointer, but could
+     * also have been overwritten by an interrupt or signal handler. The ABI might guarantee a safe
+     * zone below the stack pointer to prevent this, but such zones are typically also not large
+     * enough to fit all saved registers, especially with vector registers.
+     * <p>
+     * If the callee does not use stub calling convention, this method unnecessarily saves
+     * registers, but it avoids having additional stubs and selecting between them and should not
+     * have significant impact.
+     */
+    @StubCallingConvention
+    @DeoptStub(stubType = StubType.EntryStub)
     @Uninterruptible(reason = "Rewriting stack; gpReturnValue holds object reference.")
     public static UnsignedWord lazyDeoptStubObjectReturn(Pointer originalStackPointer, UnsignedWord gpReturnValue, UnsignedWord fpReturnValue) {
         try {
@@ -837,7 +850,9 @@ public static UnsignedWord lazyDeoptStubObjectReturn(Pointer originalStackPointe
         }
     }
 
-    @DeoptStub(stubType = StubType.LazyEntryStub)
+    /** See {@link #lazyDeoptStubObjectReturn}. */
+    @StubCallingConvention
+    @DeoptStub(stubType = StubType.EntryStub)
     @Uninterruptible(reason = "Rewriting stack.")
     public static UnsignedWord lazyDeoptStubPrimitiveReturn(Pointer originalStackPointer, UnsignedWord gpReturnValue, UnsignedWord fpReturnValue) {
         /*
@@ -987,7 +1002,7 @@ private static DeoptimizedFrame constructLazilyDeoptimizedFrameInterruptibly0(Po
      *            when the deopt stub was reached. It must be restored to the register before
      *            completion of the stub.
      */
-    @DeoptStub(stubType = StubType.EagerEntryStub)
+    @DeoptStub(stubType = StubType.EntryStub)
     @Uninterruptible(reason = "Frame holds Objects in unmanaged storage.")
     public static UnsignedWord eagerDeoptStub(Pointer originalStackPointer, UnsignedWord gpReturnValue, UnsignedWord fpReturnValue) {
         try {
