[PPC] Fix two bugs in frame lowering.

[jtony]

Summary

(1) The available program storage region of the red zone to compilers is 288 bytes rather than 244 bytes (both for ABI V1.9 and ABI V2).
(2) The formula for negative number alignment calculation should be y = x & ~(n-1) rather than y = (x + (n-1)) & ~(n-1).

[inouehrs]

test/CodeGen/PowerPC/tailcall1-64.ll

2

Does this change relate to frame lowering?

[jtony]

test/CodeGen/PowerPC/tailcall1-64.ll

2

This test case is modified to make sure the changes above don't regress the TCO.

[nemanjai]

lib/Target/PowerPC/PPCFrameLowering.cpp

1877

How are we testing this change?

[stefanp]

lib/Target/PowerPC/PPCFrameLowering.cpp

1874

nit: (the stack is growning down) -> (the stack grows downward)

test/CodeGen/PowerPC/tailcall1-64.ll

12

nit: Should we be doing a CHECK-LABEL first?

[jtony]

Address the comments from Nemanja and Stefan.
Add one test case to test the alignment calculation change.

[nemanjai]

LGTM. If @hfinkel doesn't have any objections, I think this can go in.

[hfinkel]

In D34337#794950, @nemanjai wrote:

LGTM. If @hfinkel doesn't have any objections, I think this can go in.

So... I believe if we make this change as-is then we've dropped Darwin support. Darwin had a 224-byte red zone. I'm in favor of doing that, but I don't think we should just do it subtly like this. I'd add a check for Darwin for now (to keep the 224). Then we can rip it out with the rest of Darwin support when we do that.

lib/Target/PowerPC/PPCFrameLowering.cpp

1873

Please add parens here (x + (n-1)) & (n-1).

[jtony]

(1) Refactor the messy red zone guard conditions to make it more readable.
(2) Differentiate the red zone behavior for DarwinABI and Non-DarwinABI (SVR4ABI).
(3) Address comments from Hal.

[inouehrs]

lib/Target/PowerPC/PPCFrameLowering.cpp

471

How about adding a function Subtarget.getAvailableRedZoneSize(), which returns 288 only when icPPC64 && isSVR4ABI and 224 otherwise?

[jtony]

lib/Target/PowerPC/PPCFrameLowering.cpp

471

I understand why you want to add that function, but if you look at the logic (!Subtarget.isPPC64()) && (FrameSize == 0) can not nicely fit into that refactor. If everything can be fit into the getAvailableRedZoneSize() function and we just use
bool FitsInRedZone = FrameSize <= Subtarget.getAvailableRedZoneSize(), the refactoring you mentioned would be more useful.

1877

I added one new test cases to test the alignment calculation change.

[inouehrs]

lib/Target/PowerPC/PPCFrameLowering.cpp

471

isSVR4ABI && isPPC64 -> return 288
isSVR4ABI && !isPPC64 -> return 0
other -> return  224

Is this representing the above conditions? (since FrameSize is unsigned FrameSize == 0 and FrameSize <= 0 is same.)

[jtony]

Address comments from Hiroshi.

[kbarton]

LGTM. Just some minor updates in the comments.

lib/Target/PowerPC/PPCSubtarget.h

277 ↗

(On Diff #105796)

Please change the Non-DarwinABI to SVR4ABI.

test/CodeGen/PowerPC/ppc-redzone-alignment-bug.ll

2 ↗

(On Diff #105796)

Can you please replace "this issue" with the specific Review that is being fixed?

10 ↗

(On Diff #105796)

Again, instead of "the fix" specify the review this is being done under.

lib/Target/PowerPC/PPCFrameLowering.cpp

unsigned PPCFrameLowering::determineFrameLayout(MachineFunction &MF,
 
   // Get stack alignments. The frame must be aligned to the greatest of these:
   unsigned TargetAlign = getStackAlignment(); // alignment required per the ABI
   unsigned MaxAlign = MFI.getMaxAlignment(); // algmt required by data in frame
   unsigned AlignMask = std::max(MaxAlign, TargetAlign) - 1;
 
   const PPCRegisterInfo *RegInfo = Subtarget.getRegisterInfo();
 
-  // If we are a leaf function, and use up to 224 bytes of stack space,
+  // If we are a leaf function, and use up to 288 bytes of stack space,
   // don't have a frame pointer, calls, or dynamic alloca then we do not need
   // to adjust the stack pointer (we fit in the Red Zone).
   // The 32-bit SVR4 ABI has no Red Zone. However, it can still generate
   // stackless code if all local vars are reg-allocated.
   bool DisableRedZone = MF.getFunction()->hasFnAttribute(Attribute::NoRedZone);
   unsigned LR = RegInfo->getRARegister();
   if (!DisableRedZone &&
       (Subtarget.isPPC64() ||                      // 32-bit SVR4, no stack-
        !Subtarget.isSVR4ABI() ||                   //   allocated locals.
         FrameSize == 0) &&
-      FrameSize <= 224 &&                          // Fits in red zone.
+      FrameSize <= 288 &&                          // Fits in red zone.
       !MFI.hasVarSizedObjects() &&                 // No dynamic alloca.
       !MFI.adjustsStack() &&                       // No calls.
       !MustSaveLR(MF, LR) &&
       !RegInfo->hasBasePointer(MF)) { // No special alignment.
     // No need for frame
     if (UpdateMF)
       MFI.setStackSize(0);
     return 0;
   }
 
   // Get the maximum call frame size of all the calls.
   unsigned maxCallFrameSize = MFI.getMaxCallFrameSize();
 
   // Maximum call frame needs to be at least big enough for linkage area.
   unsigned minCallFrameSize = getLinkageSize();
   maxCallFrameSize = std::max(maxCallFrameSize, minCallFrameSize);
 
   // If we have dynamic alloca then maxCallFrameSize needs to be aligned so
   // that allocations will be aligned.
   if (MFI.hasVarSizedObjects())
     maxCallFrameSize = (maxCallFrameSize + AlignMask) & ~AlignMask;
 
   // Update maximum call frame size.
   if (UpdateMF)
     MFI.setMaxCallFrameSize(maxCallFrameSize);
 
   // Include call frame size in total.
   FrameSize += maxCallFrameSize;
 
   // Make sure the frame is aligned.
for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
         MFI.setObjectOffset(FI, LowerBound + MFI.getObjectOffset(FI));
       }
     }
 
     LowerBound -= 4; // The VRSAVE save area is always 4 bytes long.
   }
 
   if (HasVRSaveArea) {
-    // Insert alignment padding, we need 16-byte alignment.
-    LowerBound = (LowerBound - 15) & ~(15);
+    // Insert alignment padding, we need 16-byte alignment. Note: for postive
+    // number the alignment formula is : y = x + (n-1) & ~(n-1). But since we
+    // are using negative number here (the stack is growning down). We should
+    // use formula : y = x & ~(n-1). Where x is the size before aligning, n is
+    // the alignment size ( n = 16 here) and y is the size after aligning.
+    LowerBound &= ~(15);
 
     for (unsigned i = 0, e = VRegs.size(); i != e; ++i) {
       int FI = VRegs[i].getFrameIdx();
 
       MFI.setObjectOffset(FI, LowerBound + MFI.getObjectOffset(FI));
     }
   }
 

test/CodeGen/PowerPC/svr4-redzone.ll

 ; PPC32: stwu 1, -16(1)
 
 ; PPC64-LABEL: smallstack:
 ; PPC64-NOT: stdu 1, -{{[0-9]+}}(1)
 ; PPC64: blr
 
 define i8* @bigstack() nounwind {
 entry:
- %0 = alloca i8, i32 230
+ %0 = alloca i8, i32 290
        ret i8* %0
 }
 ; PPC32-LABEL: bigstack:
-; PPC32: stwu 1, -240(1)
+; PPC32: stwu 1, -304(1)
 
 ; PPC64-LABEL: bigstack:
-; PPC64: stdu 1, -288(1)
+; PPC64: stdu 1, -352(1)

test/CodeGen/PowerPC/tailcall1-64.ll

 ; RUN: llc -relocation-model=static -verify-machineinstrs < %s -march=ppc64 -tailcallopt | grep TC_RETURNd8
+; RUN: llc -relocation-model=static -verify-machineinstrs -march=ppc64 < %s | FileCheck %s
 define fastcc i32 @tailcallee(i32 %a1, i32 %a2, i32 %a3, i32 %a4) {
 entry:
   ret i32 %a3
 }
 
 define fastcc i32 @tailcaller(i32 %in1, i32 %in2) {
 entry:
-  %tmp11 = tail call fastcc i32 @tailcallee( i32 %in1, i32 %in2, i32 %in1, i32 %in2 )    ; <i32> [#uses=1]
+  %tmp11 = tail call fastcc i32 @tailcallee( i32 %in1, i32 %in2, i32 %in1, i32 %in2 )
   ret i32 %tmp11
+; CHECK-NOT: stdu
+; CHECK: b tailcallee
 }