[AArch64] Improve access to fixed-width object when stack has SVE.

[sdesmalen]

Summary

When the stack has SVE objects, fixed-width objects are often better accessed
from the SP, instead of the FP, because part/all of the fixed-width offset
can be folded into the (non-scalable) addressing mode, where otherwise an
ADDVL would be required.

[david-arm]

LGTM! Nice fix thx @sdesmalen. :)

llvm/lib/Target/AArch64/AArch64FrameLowering.cpp

StackOffset AArch64FrameLowering::resolveFrameOffsetReference(
   const StackOffset &SVEStackSize = getSVEStackSize(MF);
 
   // Use frame pointer to reference fixed objects. Use it for locals if
   // there are VLAs or a dynamically realigned SP (and thus the SP isn't
   // reliable as a base). Make sure useFPForScavengingIndex() does the
   // right thing for the emergency spill slot.
   bool UseFP = false;
   if (AFI->hasStackFrame() && !isSVE) {
-    // We shouldn't prefer using the FP when there is an SVE area
-    // in between the FP and the non-SVE locals/spills.
+    // We shouldn't prefer using the FP to access fixed-sized stack objects when
+    // there are scalable (SVE) objects in between the FP and the fixed-sized
+    // objects.
     PreferFP &= !SVEStackSize;
 
     // Note: Keeping the following as multiple 'if' statements rather than
     // merging to a single expression for readability.
     //
     // Argument access should always use the FP.
     if (isFixed) {
       UseFP = hasFP(MF);
     } else if (isCSR && RegInfo->hasStackRealignment(MF)) {
       // References to the CSR area must use FP if we're re-aligning the stack
       // since the dynamically-sized alignment padding is between the SP/BP and
       // the CSR area.
       assert(hasFP(MF) && "Re-aligned stack must have frame pointer");
       UseFP = true;
     } else if (hasFP(MF) && !RegInfo->hasStackRealignment(MF)) {
       // If the FPOffset is negative and we're producing a signed immediate, we
       // have to keep in mind that the available offset range for negative
       // offsets is smaller than for positive ones. If an offset is available
       // via the FP and the SP, use whichever is closest.
       bool FPOffsetFits = !ForSimm || FPOffset >= -256;
-      PreferFP |= Offset > -FPOffset;
+      PreferFP |= Offset > -FPOffset && !SVEStackSize;
 
       if (MFI.hasVarSizedObjects()) {
         // If we have variable sized objects, we can use either FP or BP, as the
         // SP offset is unknown. We can use the base pointer if we have one and
         // FP is not preferred. If not, we're stuck with using FP.
         bool CanUseBP = RegInfo->hasBasePointer(MF);
         if (FPOffsetFits && CanUseBP) // Both are ok. Pick the best.
           UseFP = PreferFP;

llvm/test/CodeGen/AArch64/framelayout-sve-fixed-width-access.mir

 # NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 # RUN: llc -mattr=+sve -mtriple=aarch64-none-linux-gnu -start-before=prologepilog %s -o - | FileCheck %s
 
 --- |
   define aarch64_sve_vector_pcs void @access_large_stack() nounwind { entry: unreachable }
   ; CHECK-LABEL: access_large_stack:
   ; CHECK:       // %bb.0: // %entry
   ; CHECK-NEXT:    stp x29, x30, [sp, #-16]! // 16-byte Folded Spill
   ; CHECK-NEXT:    mov x29, sp
   ; CHECK-NEXT:    addvl sp, sp, #-32
   ; CHECK-NEXT:    addvl sp, sp, #-28
   ; CHECK-NEXT:    sub sp, sp, #2064
-  ; CHECK-NEXT:    addvl x8, x29, #-32
-  ; CHECK-NEXT:    addvl x8, x8, #-28
-  ; CHECK-NEXT:    ldur x8, [x8, #-16]
+  ; CHECK-NEXT:    ldr x8, [sp, #2048]
   ; CHECK-NEXT:    addvl sp, sp, #31
   ; CHECK-NEXT:    addvl sp, sp, #29
   ; CHECK-NEXT:    add sp, sp, #2064
   ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
   ; CHECK-NEXT:    ret
 ...
 name: access_large_stack
 frameInfo:

llvm/test/CodeGen/AArch64/stack-guard-sve.ll

 ; guard but no vulnerable SVE objects, and when we do have such objects.
 
 ; CHECK-LABEL: local_stack_alloc:
 ; CHECK: mov x29, sp
 ; CHECK: addvl sp, sp, #-2
 ; CHECK: sub sp, sp, #16, lsl #12
 ; CHECK: sub sp, sp, #16
 
-; Stack guard is placed below the SVE stack area
+; Stack guard is placed below the SVE stack area (and above all fixed-width objects)
+; CHECK-DAG: add [[STACK_GUARD_SPILL_PART_LOC:x[0-9]+]], sp, #8, lsl #12
+; CHECK-DAG: add [[STACK_GUARD_SPILL_PART_LOC]], [[STACK_GUARD_SPILL_PART_LOC]], #16
 ; CHECK-DAG: ldr [[STACK_GUARD:x[0-9]+]], [{{x[0-9]+}}, :lo12:__stack_chk_guard]
-; CHECK-DAG: addvl [[STACK_GUARD_POS:x[0-9]+]], x29, #-2
-; CHECK-DAG: stur [[STACK_GUARD]], [[[STACK_GUARD_POS]], #-8]
+; CHECK-DAG: str [[STACK_GUARD]], [[[STACK_GUARD_SPILL_PART_LOC]], #32760]
 
 ; char_arr is below the stack guard
-; CHECK-DAG: sub [[CHAR_ARR_1:x[0-9]+]], x29, #16
-; CHECK-DAG: addvl [[CHAR_ARR_2:x[0-9]+]], [[CHAR_ARR_1]], #-2
-; CHECK-DAG: strb wzr, [[[CHAR_ARR_2]]]
+; CHECK-DAG: add [[CHAR_ARR_LOC:x[0-9]+]], sp, #16, lsl #12
+; CHECK-DAG: strb wzr, [[[CHAR_ARR_LOC]]]
 
 ; large1 is accessed via a virtual base register
 ; CHECK-DAG: add [[LARGE1:x[0-9]+]], sp, #8, lsl #12
 ; CHECK-DAG: stp x0, x0, [[[LARGE1]]]
 
 ; large2 is at the bottom of the stack
 ; CHECK-DAG: stp x0, x0, [sp]
 

 ; CHECK: sub sp, sp, #16
 
 ; Stack guard is placed at the top of the SVE stack area
 ; CHECK-DAG: ldr [[STACK_GUARD:x[0-9]+]], [{{x[0-9]+}}, :lo12:__stack_chk_guard]
 ; CHECK-DAG: addvl [[STACK_GUARD_POS:x[0-9]+]], x29, #-1
 ; CHECK-DAG: str [[STACK_GUARD]], [[[STACK_GUARD_POS]]]
 
 ; char_arr is below the SVE stack area
-; CHECK-DAG: addvl [[CHAR_ARR:x[0-9]+]], x29, #-3
-; CHECK-DAG: sturb wzr, [[[CHAR_ARR]], #-8]
+; CHECK-DAG: add [[CHAR_ARR:x[0-9]+]], sp, #15, lsl #12            // =61440
+; CHECK-DAG: add [[CHAR_ARR]], [[CHAR_ARR]], #9
+; CHECK-DAG: strb wzr, [[[CHAR_ARR]], #4095]
 
 ; large1 is accessed via a virtual base register
 ; CHECK-DAG: add [[LARGE1:x[0-9]+]], sp, #8, lsl #12
 ; CHECK-DAG: stp x0, x0, [[[LARGE1]], #8]
 
 ; large2 is at the bottom of the stack
 ; CHECK-DAG: stp x0, x0, [sp, #8]