Avoid unsafe subs

Author: MacDue

llvm/lib/Target/AArch64/AArch64FrameLowering.cpp

@@ -2541,13 +2541,33 @@ void AArch64FrameLowering::emitEpilogue(MachineFunction &MF,
     if (AFI->isStackRealigned() || MFI.hasVarSizedObjects()) {
       if (int64_t SVECalleeSavedSize = AFI->getSVECalleeSavedStackSize()) {
         // Set SP to start of SVE callee-save area from which they can
-        // be reloaded. The code below will deallocate the stack space
-        // space by moving FP -> SP.
-        emitFrameOffset(
-            MBB, RestoreBegin, DL, AArch64::SP, AArch64::FP,
-            StackOffset::get(-AFI->getCalleeSaveBaseToFrameRecordOffset(),
-                             -SVECalleeSavedSize),
-            TII, MachineInstr::FrameDestroy);
+        // be reloaded.
+        const AArch64RegisterInfo *RegInfo = Subtarget.getRegisterInfo();
+        if (!AFI->isStackRealigned() && RegInfo->hasBasePointer(MF)) {
+          // If the stack is not realigned we can use the base pointer to find
+          // the start of the SVE callee-saves.
+          emitFrameOffset(
+              MBB, RestoreBegin, DL, AArch64::SP, RegInfo->getBaseRegister(),
+              StackOffset::getFixed(NumBytes), TII, MachineInstr::FrameDestroy);
+        } else {
+          Register CalleeSaveBase = AArch64::FP;
+          if (int64_t CalleeSaveBaseOffset =
+                  AFI->getCalleeSaveBaseToFrameRecordOffset()) {
+            assert(RegInfo->hasBasePointer(MF) && "Expected base pointer!");
+            // NOTE: This base pointer is clobbered from this point on! The next
+            // step in eplilogue emission restoring callee-saves, so it should
+            // not be used after this point anyway.
+            CalleeSaveBase = RegInfo->getBaseRegister();
+            emitFrameOffset(MBB, RestoreBegin, DL, CalleeSaveBase, AArch64::FP,
+                            StackOffset::getFixed(-CalleeSaveBaseOffset), TII,
+                            MachineInstr::FrameDestroy);
+          }
+          // The code below will deallocate the stack space space by moving FP
+          // -> SP.
+          emitFrameOffset(MBB, RestoreBegin, DL, AArch64::SP, CalleeSaveBase,
+                          StackOffset::getScalable(-SVECalleeSavedSize), TII,
+                          MachineInstr::FrameDestroy);
+        }
       }
     } else {
       if (AFI->getSVECalleeSavedStackSize()) {

llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp

@@ -635,31 +635,33 @@ bool AArch64RegisterInfo::hasBasePointer(const MachineFunction &MF) const {
   // Furthermore, if both variable sized objects are present, and the
   // stack needs to be dynamically re-aligned, the base pointer is the only
   // reliable way to reference the locals.
-  if (MFI.hasVarSizedObjects() || MF.hasEHFunclets()) {
-    if (hasStackRealignment(MF))
-      return true;
-
-    auto &ST = MF.getSubtarget<AArch64Subtarget>();
-    const AArch64FunctionInfo *AFI = MF.getInfo<AArch64FunctionInfo>();
-    if (ST.hasSVE() || ST.isStreaming()) {
-      // Frames that have variable sized objects and scalable SVE objects,
-      // should always use a basepointer.
-      if (!AFI->hasCalculatedStackSizeSVE() || AFI->getStackSizeSVE())
-        return true;
-    }
-
+  bool CannotUseSPForSVERestore =
+      MFI.hasVarSizedObjects() || hasStackRealignment(MF);
+  if (CannotUseSPForSVERestore || MF.hasEHFunclets()) {
     // Frames with hazard padding can have a large offset between the frame
     // pointer and GPR locals, which includes the emergency spill slot. If the
     // emergency spill slot is not within range of the load/store instructions
     // (which have a signed 9-bit range), we will fail to compile if it is used.
     // Since hasBasePointer() is called before we know if we have hazard padding
     // or an emergency spill slot we need to enable the basepointer
     // conservatively.
+    auto &ST = MF.getSubtarget<AArch64Subtarget>();
+    const AArch64FunctionInfo *AFI = MF.getInfo<AArch64FunctionInfo>();
     if (ST.getStreamingHazardSize() &&
         !AFI->getSMEFnAttrs().hasNonStreamingInterfaceAndBody()) {
       return true;
     }
 
+    if (hasStackRealignment(MF))
+      return MFI.hasVarSizedObjects() || MF.hasEHFunclets();
+
+    if (ST.hasSVE() || ST.isStreaming()) {
+      // Frames that have variable sized objects and scalable SVE objects,
+      // should always use a basepointer.
+      if (!AFI->hasCalculatedStackSizeSVE() || AFI->getStackSizeSVE())
+        return true;
+    }
+
     // Conservatively estimate whether the negative offset from the frame
     // pointer will be sufficient to reach. If a function has a smallish
     // frame, it's less likely to have lots of spills and callee saved