[SystemZ][z/OS] Correct value of length/4 of params field in PPA1.

[Everybody0523]

Summary

The Length/4 of Params field in the PPA1 ought to be the length of the parameters for the current function. Currently we are storing the length of the parameter area in the current function's stack frame, which represents the length of the params of the longest callee in the current function.

[uweigand]

LGTM, thanks!

[Everybody0523]

Run clang format

llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp

void SystemZAsmPrinter::emitPPA1(MCSymbol *FnEndSym) {
   OutStreamer->emitInt16(SavedGPRMask);
 
   emitPPA1Flags(OutStreamer, MF->getFunction().isVarArg(),
                 MFFrame.hasStackProtectorIndex(), SavedFPRMask != 0,
                 TargetHasVector && SavedVRMask != 0);
 
   OutStreamer->AddComment("Length/4 of Parms");
   OutStreamer->emitInt16(
-      static_cast<uint16_t>(MFFrame.getMaxCallFrameSize() / 4)); // Parms/4.
+      static_cast<uint16_t>(ZFI->getSizeOfFnParams() / 4)); // Parms/4.
   OutStreamer->AddComment("Length of Code");
   OutStreamer->emitAbsoluteSymbolDiff(FnEndSym, CurrentFnEPMarkerSym, 4);
 
   // Emit saved FPR mask and offset to FPR save area (0x20 of flags 3).
   if (SavedFPRMask) {
     OutStreamer->AddComment("FPR mask");
     OutStreamer->emitInt16(SavedFPRMask);
     OutStreamer->AddComment("AR mask");

llvm/lib/Target/SystemZ/SystemZISelLowering.cpp

SDValue SystemZTargetLowering::LowerFormalArguments(
   // Detect unsupported vector argument types.
   if (Subtarget.hasVector())
     VerifyVectorTypes(Ins);
 
   // Assign locations to all of the incoming arguments.
   SmallVector<CCValAssign, 16> ArgLocs;
   SystemZCCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext());
   CCInfo.AnalyzeFormalArguments(Ins, CC_SystemZ);
+  FuncInfo->setSizeOfFnParams(CCInfo.getStackSize());
 
   unsigned NumFixedGPRs = 0;
   unsigned NumFixedFPRs = 0;
   for (unsigned I = 0, E = ArgLocs.size(); I != E; ++I) {
     SDValue ArgValue;
     CCValAssign &VA = ArgLocs[I];
     EVT LocVT = VA.getLocVT();
     if (VA.isRegLoc()) {

llvm/lib/Target/SystemZ/SystemZMachineFunctionInfo.h

struct GPRRegs {
   unsigned GPROffset;
   GPRRegs() : LowGPR(0), HighGPR(0), GPROffset(0) {}
   };
 }
 
 class SystemZMachineFunctionInfo : public MachineFunctionInfo {
   virtual void anchor();
 
+  /// Size of expected parameter area for current function. (Fixed args only).
+  unsigned SizeOfFnParams;
+
   SystemZ::GPRRegs SpillGPRRegs;
   SystemZ::GPRRegs RestoreGPRRegs;
   Register VarArgsFirstGPR;
   Register VarArgsFirstFPR;
   unsigned VarArgsFrameIndex;
   unsigned RegSaveFrameIndex;
   int FramePointerSaveIndex;
   unsigned NumLocalDynamics;
 
 public:
   SystemZMachineFunctionInfo(const Function &F, const TargetSubtargetInfo *STI)
-      : VarArgsFirstGPR(0), VarArgsFirstFPR(0), VarArgsFrameIndex(0),
-        RegSaveFrameIndex(0), FramePointerSaveIndex(0), NumLocalDynamics(0) {}
+      : SizeOfFnParams(0), VarArgsFirstGPR(0), VarArgsFirstFPR(0),
+        VarArgsFrameIndex(0), RegSaveFrameIndex(0), FramePointerSaveIndex(0),
+        NumLocalDynamics(0) {}
 
   MachineFunctionInfo *
   clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF,
         const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB)
       const override;
 
+  // z/OS: Get and set the size of the expected parameter area for the
+  // current function. (ie. Size of param area in caller).
+  unsigned getSizeOfFnParams() const { return SizeOfFnParams; }
+  void setSizeOfFnParams(unsigned Size) { SizeOfFnParams = Size; }
+
   // Get and set the first and last call-saved GPR that should be saved by
   // this function and the SP offset for the STMG.  These are 0 if no GPRs
   // need to be saved or restored.
   SystemZ::GPRRegs getSpillGPRRegs() const { return SpillGPRRegs; }
   void setSpillGPRRegs(Register Low, Register High, unsigned Offs) {
     SpillGPRRegs.LowGPR = Low;
     SpillGPRRegs.HighGPR = High;
     SpillGPRRegs.GPROffset = Offs;

llvm/test/CodeGen/SystemZ/zos-prologue-epilog.ll

 ; Test the generated function prologs/epilogs under XPLINK64 on z/OS
 ;
 ; RUN: llc < %s -mtriple=s390x-ibm-zos -mcpu=z13 | FileCheck --check-prefixes=CHECK64,CHECK %s
 
 ; Test prolog/epilog for non-XPLEAF.
 
 ; Small stack frame.
 ; CHECK-LABEL: func0
 ; CHECK64: stmg  6, 7, 1872(4)
 ; stmg instruction's displacement field must be 2064-dsa_size
 ; as per ABI
 ; CHECK64: aghi  4, -192
 
 ; CHECK64: lg  7, 2072(4)
 ; CHECK64: aghi  4, 192
 ; CHECK64: b 2(7)
+
+; CHECK64: @@PPA1_func0_0:
+; CHECK64: .short 0  * Length/4 of Parms
 define void @func0() {
   call i64 (i64) @fun(i64 10) 
   ret void
 }
 
 ; Spill all GPR CSRs
 ; CHECK-LABEL: func1
 ; CHECK64: stmg 6, 15, 1904(4)
 ; CHECK64: aghi  4, -160
 
 ; CHECK64: lmg 7, 15, 2072(4)
 ; CHECK64: aghi  4, 160
 ; CHECK64: b 2(7)
+
+; CHECK64: @@PPA1_func1_0:
+; CHECK64: .short 2  * Length/4 of Parms
 define void @func1(ptr %ptr) {
   %l01 = load volatile i64, ptr %ptr
   %l02 = load volatile i64, ptr %ptr
   %l03 = load volatile i64, ptr %ptr
   %l04 = load volatile i64, ptr %ptr
   %l05 = load volatile i64, ptr %ptr
   %l06 = load volatile i64, ptr %ptr
   %l07 = load volatile i64, ptr %ptr

 ; CHECK64: jhe @BB7_2
 ; CHECK64: %bb.1:
 ; CHECK64: lg  3, 72(3)
 ; CHECK64: basr  3, 3
 ; CHECK64: bcr 0, 7
 ; CHECK64: @BB7_2:
 ; CHECK64: stmg  6, 7, 2064(4)
 ; CHECK64: lgr 3, 0
+
+; CHECK64: @@PPA1_large_stack1_0:
+; CHECK64: .short 6  * Length/4 of Parms
 define void @large_stack1(i64 %n1, i64 %n2, i64 %n3) {
   %arr = alloca [131072 x i64], align 8
   call i64 (ptr, i64, i64, i64) @fun3(ptr %arr,
             i64 %n1, i64 %n2, i64 %n3)
   ret void
 }