LLVM  15.0.0git
SystemZFrameLowering.cpp
Go to the documentation of this file.
1 //===-- SystemZFrameLowering.cpp - Frame lowering for SystemZ -------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "SystemZFrameLowering.h"
10 #include "SystemZCallingConv.h"
11 #include "SystemZInstrBuilder.h"
12 #include "SystemZInstrInfo.h"
14 #include "SystemZRegisterInfo.h"
15 #include "SystemZSubtarget.h"
20 #include "llvm/IR/Function.h"
22 
23 using namespace llvm;
24 
25 namespace {
26 // The ABI-defined register save slots, relative to the CFA (i.e.
27 // incoming stack pointer + SystemZMC::ELFCallFrameSize).
28 static const TargetFrameLowering::SpillSlot ELFSpillOffsetTable[] = {
29  { SystemZ::R2D, 0x10 },
30  { SystemZ::R3D, 0x18 },
31  { SystemZ::R4D, 0x20 },
32  { SystemZ::R5D, 0x28 },
33  { SystemZ::R6D, 0x30 },
34  { SystemZ::R7D, 0x38 },
35  { SystemZ::R8D, 0x40 },
36  { SystemZ::R9D, 0x48 },
37  { SystemZ::R10D, 0x50 },
38  { SystemZ::R11D, 0x58 },
39  { SystemZ::R12D, 0x60 },
40  { SystemZ::R13D, 0x68 },
41  { SystemZ::R14D, 0x70 },
42  { SystemZ::R15D, 0x78 },
43  { SystemZ::F0D, 0x80 },
44  { SystemZ::F2D, 0x88 },
45  { SystemZ::F4D, 0x90 },
46  { SystemZ::F6D, 0x98 }
47 };
48 
49 static const TargetFrameLowering::SpillSlot XPLINKSpillOffsetTable[] = {
50  {SystemZ::R4D, 0x00}, {SystemZ::R5D, 0x08}, {SystemZ::R6D, 0x10},
51  {SystemZ::R7D, 0x18}, {SystemZ::R8D, 0x20}, {SystemZ::R9D, 0x28},
52  {SystemZ::R10D, 0x30}, {SystemZ::R11D, 0x38}, {SystemZ::R12D, 0x40},
53  {SystemZ::R13D, 0x48}, {SystemZ::R14D, 0x50}, {SystemZ::R15D, 0x58}};
54 } // end anonymous namespace
55 
57  int LAO, Align TransAl,
58  bool StackReal)
59  : TargetFrameLowering(D, StackAl, LAO, TransAl, StackReal) {}
60 
61 std::unique_ptr<SystemZFrameLowering>
63  if (STI.isTargetXPLINK64())
64  return std::make_unique<SystemZXPLINKFrameLowering>();
65  return std::make_unique<SystemZELFFrameLowering>();
66 }
67 
71  switch (MI->getOpcode()) {
72  case SystemZ::ADJCALLSTACKDOWN:
73  case SystemZ::ADJCALLSTACKUP:
75  "ADJSTACKDOWN and ADJSTACKUP should be no-ops");
76  return MBB.erase(MI);
77  break;
78 
79  default:
80  llvm_unreachable("Unexpected call frame instruction");
81  }
82 }
83 
84 namespace {
85 struct SZFrameSortingObj {
86  bool IsValid = false; // True if we care about this Object.
87  uint32_t ObjectIndex = 0; // Index of Object into MFI list.
88  uint64_t ObjectSize = 0; // Size of Object in bytes.
89  uint32_t D12Count = 0; // 12-bit displacement only.
90  uint32_t DPairCount = 0; // 12 or 20 bit displacement.
91 };
92 typedef std::vector<SZFrameSortingObj> SZFrameObjVec;
93 } // namespace
94 
95 // TODO: Move to base class.
97  const MachineFunction &MF, SmallVectorImpl<int> &ObjectsToAllocate) const {
98  const MachineFrameInfo &MFI = MF.getFrameInfo();
99  auto *TII = MF.getSubtarget<SystemZSubtarget>().getInstrInfo();
100 
101  // Make a vector of sorting objects to track all MFI objects and mark those
102  // to be sorted as valid.
103  if (ObjectsToAllocate.size() <= 1)
104  return;
105  SZFrameObjVec SortingObjects(MFI.getObjectIndexEnd());
106  for (auto &Obj : ObjectsToAllocate) {
107  SortingObjects[Obj].IsValid = true;
108  SortingObjects[Obj].ObjectIndex = Obj;
109  SortingObjects[Obj].ObjectSize = MFI.getObjectSize(Obj);
110  }
111 
112  // Examine uses for each object and record short (12-bit) and "pair"
113  // displacement types.
114  for (auto &MBB : MF)
115  for (auto &MI : MBB) {
116  if (MI.isDebugInstr())
117  continue;
118  for (unsigned I = 0, E = MI.getNumOperands(); I != E; ++I) {
119  const MachineOperand &MO = MI.getOperand(I);
120  if (!MO.isFI())
121  continue;
122  int Index = MO.getIndex();
123  if (Index >= 0 && Index < MFI.getObjectIndexEnd() &&
124  SortingObjects[Index].IsValid) {
125  if (TII->hasDisplacementPairInsn(MI.getOpcode()))
126  SortingObjects[Index].DPairCount++;
127  else if (!(MI.getDesc().TSFlags & SystemZII::Has20BitOffset))
128  SortingObjects[Index].D12Count++;
129  }
130  }
131  }
132 
133  // Sort all objects for short/paired displacements, which should be
134  // sufficient as it seems like all frame objects typically are within the
135  // long displacement range. Sorting works by computing the "density" as
136  // Count / ObjectSize. The comparisons of two such fractions are refactored
137  // by multiplying both sides with A.ObjectSize * B.ObjectSize, in order to
138  // eliminate the (fp) divisions. A higher density object needs to go after
139  // in the list in order for it to end up lower on the stack.
140  auto CmpD12 = [](const SZFrameSortingObj &A, const SZFrameSortingObj &B) {
141  // Put all invalid and variable sized objects at the end.
142  if (!A.IsValid || !B.IsValid)
143  return A.IsValid;
144  if (!A.ObjectSize || !B.ObjectSize)
145  return A.ObjectSize > 0;
146  uint64_t ADensityCmp = A.D12Count * B.ObjectSize;
147  uint64_t BDensityCmp = B.D12Count * A.ObjectSize;
148  if (ADensityCmp != BDensityCmp)
149  return ADensityCmp < BDensityCmp;
150  return A.DPairCount * B.ObjectSize < B.DPairCount * A.ObjectSize;
151  };
152  std::stable_sort(SortingObjects.begin(), SortingObjects.end(), CmpD12);
153 
154  // Now modify the original list to represent the final order that
155  // we want.
156  unsigned Idx = 0;
157  for (auto &Obj : SortingObjects) {
158  // All invalid items are sorted at the end, so it's safe to stop.
159  if (!Obj.IsValid)
160  break;
161  ObjectsToAllocate[Idx++] = Obj.ObjectIndex;
162  }
163 }
164 
166  const MachineFunction &MF) const {
167  // The ELF ABI requires us to allocate 160 bytes of stack space for the
168  // callee, with any outgoing stack arguments being placed above that. It
169  // seems better to make that area a permanent feature of the frame even if
170  // we're using a frame pointer. Similarly, 64-bit XPLINK requires 96 bytes
171  // of stack space for the register save area.
172  return true;
173 }
174 
177  std::vector<CalleeSavedInfo> &CSI) const {
179  MachineFrameInfo &MFFrame = MF.getFrameInfo();
180  bool IsVarArg = MF.getFunction().isVarArg();
181  if (CSI.empty())
182  return true; // Early exit if no callee saved registers are modified!
183 
184  unsigned LowGPR = 0;
185  unsigned HighGPR = SystemZ::R15D;
186  int StartSPOffset = SystemZMC::ELFCallFrameSize;
187  for (auto &CS : CSI) {
188  Register Reg = CS.getReg();
189  int Offset = getRegSpillOffset(MF, Reg);
190  if (Offset) {
191  if (SystemZ::GR64BitRegClass.contains(Reg) && StartSPOffset > Offset) {
192  LowGPR = Reg;
193  StartSPOffset = Offset;
194  }
195  Offset -= SystemZMC::ELFCallFrameSize;
196  int FrameIdx = MFFrame.CreateFixedSpillStackObject(8, Offset);
197  CS.setFrameIdx(FrameIdx);
198  } else
199  CS.setFrameIdx(INT32_MAX);
200  }
201 
202  // Save the range of call-saved registers, for use by the
203  // prologue/epilogue inserters.
204  ZFI->setRestoreGPRRegs(LowGPR, HighGPR, StartSPOffset);
205  if (IsVarArg) {
206  // Also save the GPR varargs, if any. R6D is call-saved, so would
207  // already be included, but we also need to handle the call-clobbered
208  // argument registers.
209  Register FirstGPR = ZFI->getVarArgsFirstGPR();
210  if (FirstGPR < SystemZ::ELFNumArgGPRs) {
211  unsigned Reg = SystemZ::ELFArgGPRs[FirstGPR];
212  int Offset = getRegSpillOffset(MF, Reg);
213  if (StartSPOffset > Offset) {
214  LowGPR = Reg; StartSPOffset = Offset;
215  }
216  }
217  }
218  ZFI->setSpillGPRRegs(LowGPR, HighGPR, StartSPOffset);
219 
220  // Create fixed stack objects for the remaining registers.
221  int CurrOffset = -SystemZMC::ELFCallFrameSize;
222  if (usePackedStack(MF))
223  CurrOffset += StartSPOffset;
224 
225  for (auto &CS : CSI) {
226  if (CS.getFrameIdx() != INT32_MAX)
227  continue;
228  Register Reg = CS.getReg();
230  unsigned Size = TRI->getSpillSize(*RC);
231  CurrOffset -= Size;
232  assert(CurrOffset % 8 == 0 &&
233  "8-byte alignment required for for all register save slots");
234  int FrameIdx = MFFrame.CreateFixedSpillStackObject(Size, CurrOffset);
235  CS.setFrameIdx(FrameIdx);
236  }
237 
238  return true;
239 }
240 
242  BitVector &SavedRegs,
243  RegScavenger *RS) const {
245 
246  MachineFrameInfo &MFFrame = MF.getFrameInfo();
248  bool HasFP = hasFP(MF);
250  bool IsVarArg = MF.getFunction().isVarArg();
251 
252  // va_start stores incoming FPR varargs in the normal way, but delegates
253  // the saving of incoming GPR varargs to spillCalleeSavedRegisters().
254  // Record these pending uses, which typically include the call-saved
255  // argument register R6D.
256  if (IsVarArg)
257  for (unsigned I = MFI->getVarArgsFirstGPR(); I < SystemZ::ELFNumArgGPRs; ++I)
258  SavedRegs.set(SystemZ::ELFArgGPRs[I]);
259 
260  // If there are any landing pads, entering them will modify r6/r7.
261  if (!MF.getLandingPads().empty()) {
262  SavedRegs.set(SystemZ::R6D);
263  SavedRegs.set(SystemZ::R7D);
264  }
265 
266  // If the function requires a frame pointer, record that the hard
267  // frame pointer will be clobbered.
268  if (HasFP)
269  SavedRegs.set(SystemZ::R11D);
270 
271  // If the function calls other functions, record that the return
272  // address register will be clobbered.
273  if (MFFrame.hasCalls())
274  SavedRegs.set(SystemZ::R14D);
275 
276  // If we are saving GPRs other than the stack pointer, we might as well
277  // save and restore the stack pointer at the same time, via STMG and LMG.
278  // This allows the deallocation to be done by the LMG, rather than needing
279  // a separate %r15 addition.
280  const MCPhysReg *CSRegs = TRI->getCalleeSavedRegs(&MF);
281  for (unsigned I = 0; CSRegs[I]; ++I) {
282  unsigned Reg = CSRegs[I];
283  if (SystemZ::GR64BitRegClass.contains(Reg) && SavedRegs.test(Reg)) {
284  SavedRegs.set(SystemZ::R15D);
285  break;
286  }
287  }
288 }
289 
291  : SystemZFrameLowering(TargetFrameLowering::StackGrowsDown, Align(8), 0,
292  Align(8), /* StackRealignable */ false),
293  RegSpillOffsets(0) {
294 
295  // Due to the SystemZ ABI, the DWARF CFA (Canonical Frame Address) is not
296  // equal to the incoming stack pointer, but to incoming stack pointer plus
297  // 160. Instead of using a Local Area Offset, the Register save area will
298  // be occupied by fixed frame objects, and all offsets are actually
299  // relative to CFA.
300 
301  // Create a mapping from register number to save slot offset.
302  // These offsets are relative to the start of the register save area.
303  RegSpillOffsets.grow(SystemZ::NUM_TARGET_REGS);
304  for (unsigned I = 0, E = array_lengthof(ELFSpillOffsetTable); I != E; ++I)
305  RegSpillOffsets[ELFSpillOffsetTable[I].Reg] = ELFSpillOffsetTable[I].Offset;
306 }
307 
308 // Add GPR64 to the save instruction being built by MIB, which is in basic
309 // block MBB. IsImplicit says whether this is an explicit operand to the
310 // instruction, or an implicit one that comes between the explicit start
311 // and end registers.
313  unsigned GPR64, bool IsImplicit) {
314  const TargetRegisterInfo *RI =
316  Register GPR32 = RI->getSubReg(GPR64, SystemZ::subreg_l32);
317  bool IsLive = MBB.isLiveIn(GPR64) || MBB.isLiveIn(GPR32);
318  if (!IsLive || !IsImplicit) {
319  MIB.addReg(GPR64, getImplRegState(IsImplicit) | getKillRegState(!IsLive));
320  if (!IsLive)
321  MBB.addLiveIn(GPR64);
322  }
323 }
324 
328  if (CSI.empty())
329  return false;
330 
331  MachineFunction &MF = *MBB.getParent();
334  bool IsVarArg = MF.getFunction().isVarArg();
335  DebugLoc DL;
336 
337  // Save GPRs
338  SystemZ::GPRRegs SpillGPRs = ZFI->getSpillGPRRegs();
339  if (SpillGPRs.LowGPR) {
340  assert(SpillGPRs.LowGPR != SpillGPRs.HighGPR &&
341  "Should be saving %r15 and something else");
342 
343  // Build an STMG instruction.
344  MachineInstrBuilder MIB = BuildMI(MBB, MBBI, DL, TII->get(SystemZ::STMG));
345 
346  // Add the explicit register operands.
347  addSavedGPR(MBB, MIB, SpillGPRs.LowGPR, false);
348  addSavedGPR(MBB, MIB, SpillGPRs.HighGPR, false);
349 
350  // Add the address.
351  MIB.addReg(SystemZ::R15D).addImm(SpillGPRs.GPROffset);
352 
353  // Make sure all call-saved GPRs are included as operands and are
354  // marked as live on entry.
355  for (const CalleeSavedInfo &I : CSI) {
356  Register Reg = I.getReg();
357  if (SystemZ::GR64BitRegClass.contains(Reg))
358  addSavedGPR(MBB, MIB, Reg, true);
359  }
360 
361  // ...likewise GPR varargs.
362  if (IsVarArg)
363  for (unsigned I = ZFI->getVarArgsFirstGPR(); I < SystemZ::ELFNumArgGPRs; ++I)
364  addSavedGPR(MBB, MIB, SystemZ::ELFArgGPRs[I], true);
365  }
366 
367  // Save FPRs/VRs in the normal TargetInstrInfo way.
368  for (const CalleeSavedInfo &I : CSI) {
369  Register Reg = I.getReg();
370  if (SystemZ::FP64BitRegClass.contains(Reg)) {
371  MBB.addLiveIn(Reg);
372  TII->storeRegToStackSlot(MBB, MBBI, Reg, true, I.getFrameIdx(),
373  &SystemZ::FP64BitRegClass, TRI);
374  }
375  if (SystemZ::VR128BitRegClass.contains(Reg)) {
376  MBB.addLiveIn(Reg);
377  TII->storeRegToStackSlot(MBB, MBBI, Reg, true, I.getFrameIdx(),
378  &SystemZ::VR128BitRegClass, TRI);
379  }
380  }
381 
382  return true;
383 }
384 
388  if (CSI.empty())
389  return false;
390 
391  MachineFunction &MF = *MBB.getParent();
394  bool HasFP = hasFP(MF);
395  DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
396 
397  // Restore FPRs/VRs in the normal TargetInstrInfo way.
398  for (const CalleeSavedInfo &I : CSI) {
399  Register Reg = I.getReg();
400  if (SystemZ::FP64BitRegClass.contains(Reg))
401  TII->loadRegFromStackSlot(MBB, MBBI, Reg, I.getFrameIdx(),
402  &SystemZ::FP64BitRegClass, TRI);
403  if (SystemZ::VR128BitRegClass.contains(Reg))
404  TII->loadRegFromStackSlot(MBB, MBBI, Reg, I.getFrameIdx(),
405  &SystemZ::VR128BitRegClass, TRI);
406  }
407 
408  // Restore call-saved GPRs (but not call-clobbered varargs, which at
409  // this point might hold return values).
410  SystemZ::GPRRegs RestoreGPRs = ZFI->getRestoreGPRRegs();
411  if (RestoreGPRs.LowGPR) {
412  // If we saved any of %r2-%r5 as varargs, we should also be saving
413  // and restoring %r6. If we're saving %r6 or above, we should be
414  // restoring it too.
415  assert(RestoreGPRs.LowGPR != RestoreGPRs.HighGPR &&
416  "Should be loading %r15 and something else");
417 
418  // Build an LMG instruction.
419  MachineInstrBuilder MIB = BuildMI(MBB, MBBI, DL, TII->get(SystemZ::LMG));
420 
421  // Add the explicit register operands.
422  MIB.addReg(RestoreGPRs.LowGPR, RegState::Define);
423  MIB.addReg(RestoreGPRs.HighGPR, RegState::Define);
424 
425  // Add the address.
426  MIB.addReg(HasFP ? SystemZ::R11D : SystemZ::R15D);
427  MIB.addImm(RestoreGPRs.GPROffset);
428 
429  // Do a second scan adding regs as being defined by instruction
430  for (const CalleeSavedInfo &I : CSI) {
431  Register Reg = I.getReg();
432  if (Reg != RestoreGPRs.LowGPR && Reg != RestoreGPRs.HighGPR &&
433  SystemZ::GR64BitRegClass.contains(Reg))
435  }
436  }
437 
438  return true;
439 }
440 
442  MachineFunction &MF, RegScavenger *RS) const {
443  MachineFrameInfo &MFFrame = MF.getFrameInfo();
446  bool BackChain = MF.getFunction().hasFnAttribute("backchain");
447 
448  if (!usePackedStack(MF) || BackChain)
449  // Create the incoming register save area.
451 
452  // Get the size of our stack frame to be allocated ...
453  uint64_t StackSize = (MFFrame.estimateStackSize(MF) +
455  // ... and the maximum offset we may need to reach into the
456  // caller's frame to access the save area or stack arguments.
457  int64_t MaxArgOffset = 0;
458  for (int I = MFFrame.getObjectIndexBegin(); I != 0; ++I)
459  if (MFFrame.getObjectOffset(I) >= 0) {
460  int64_t ArgOffset = MFFrame.getObjectOffset(I) +
461  MFFrame.getObjectSize(I);
462  MaxArgOffset = std::max(MaxArgOffset, ArgOffset);
463  }
464 
465  uint64_t MaxReach = StackSize + MaxArgOffset;
466  if (!isUInt<12>(MaxReach)) {
467  // We may need register scavenging slots if some parts of the frame
468  // are outside the reach of an unsigned 12-bit displacement.
469  // Create 2 for the case where both addresses in an MVC are
470  // out of range.
471  RS->addScavengingFrameIndex(MFFrame.CreateStackObject(8, Align(8), false));
472  RS->addScavengingFrameIndex(MFFrame.CreateStackObject(8, Align(8), false));
473  }
474 
475  // If R6 is used as an argument register it is still callee saved. If it in
476  // this case is not clobbered (and restored) it should never be marked as
477  // killed.
478  if (MF.front().isLiveIn(SystemZ::R6D) &&
479  ZFI->getRestoreGPRRegs().LowGPR != SystemZ::R6D)
480  for (auto &MO : MRI->use_nodbg_operands(SystemZ::R6D))
481  MO.setIsKill(false);
482 }
483 
484 // Emit instructions before MBBI (in MBB) to add NumBytes to Reg.
487  Register Reg, int64_t NumBytes,
488  const TargetInstrInfo *TII) {
489  while (NumBytes) {
490  unsigned Opcode;
491  int64_t ThisVal = NumBytes;
492  if (isInt<16>(NumBytes))
493  Opcode = SystemZ::AGHI;
494  else {
495  Opcode = SystemZ::AGFI;
496  // Make sure we maintain 8-byte stack alignment.
497  int64_t MinVal = -uint64_t(1) << 31;
498  int64_t MaxVal = (int64_t(1) << 31) - 8;
499  if (ThisVal < MinVal)
500  ThisVal = MinVal;
501  else if (ThisVal > MaxVal)
502  ThisVal = MaxVal;
503  }
504  MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII->get(Opcode), Reg)
505  .addReg(Reg).addImm(ThisVal);
506  // The CC implicit def is dead.
507  MI->getOperand(3).setIsDead();
508  NumBytes -= ThisVal;
509  }
510 }
511 
512 // Add CFI for the new CFA offset.
515  const DebugLoc &DL, int Offset,
516  const SystemZInstrInfo *ZII) {
517  unsigned CFIIndex = MBB.getParent()->addFrameInst(
518  MCCFIInstruction::cfiDefCfaOffset(nullptr, -Offset));
519  BuildMI(MBB, MBBI, DL, ZII->get(TargetOpcode::CFI_INSTRUCTION))
520  .addCFIIndex(CFIIndex);
521 }
522 
523 // Add CFI for the new frame location.
526  const DebugLoc &DL, unsigned Reg,
527  const SystemZInstrInfo *ZII) {
528  MachineFunction &MF = *MBB.getParent();
529  MachineModuleInfo &MMI = MF.getMMI();
530  const MCRegisterInfo *MRI = MMI.getContext().getRegisterInfo();
531  unsigned RegNum = MRI->getDwarfRegNum(Reg, true);
532  unsigned CFIIndex = MF.addFrameInst(
533  MCCFIInstruction::createDefCfaRegister(nullptr, RegNum));
534  BuildMI(MBB, MBBI, DL, ZII->get(TargetOpcode::CFI_INSTRUCTION))
535  .addCFIIndex(CFIIndex);
536 }
537 
539  MachineBasicBlock &MBB) const {
540  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
542  const SystemZTargetLowering &TLI = *STI.getTargetLowering();
543  MachineFrameInfo &MFFrame = MF.getFrameInfo();
544  auto *ZII = static_cast<const SystemZInstrInfo *>(STI.getInstrInfo());
547  MachineModuleInfo &MMI = MF.getMMI();
548  const MCRegisterInfo *MRI = MMI.getContext().getRegisterInfo();
549  const std::vector<CalleeSavedInfo> &CSI = MFFrame.getCalleeSavedInfo();
550  bool HasFP = hasFP(MF);
551 
552  // In GHC calling convention C stack space, including the ABI-defined
553  // 160-byte base area, is (de)allocated by GHC itself. This stack space may
554  // be used by LLVM as spill slots for the tail recursive GHC functions. Thus
555  // do not allocate stack space here, too.
557  if (MFFrame.getStackSize() > 2048 * sizeof(long)) {
559  "Pre allocated stack space for GHC function is too small");
560  }
561  if (HasFP) {
563  "In GHC calling convention a frame pointer is not supported");
564  }
566  return;
567  }
568 
569  // Debug location must be unknown since the first debug location is used
570  // to determine the end of the prologue.
571  DebugLoc DL;
572 
573  // The current offset of the stack pointer from the CFA.
574  int64_t SPOffsetFromCFA = -SystemZMC::ELFCFAOffsetFromInitialSP;
575 
576  if (ZFI->getSpillGPRRegs().LowGPR) {
577  // Skip over the GPR saves.
578  if (MBBI != MBB.end() && MBBI->getOpcode() == SystemZ::STMG)
579  ++MBBI;
580  else
581  llvm_unreachable("Couldn't skip over GPR saves");
582 
583  // Add CFI for the GPR saves.
584  for (auto &Save : CSI) {
585  Register Reg = Save.getReg();
586  if (SystemZ::GR64BitRegClass.contains(Reg)) {
587  int FI = Save.getFrameIdx();
588  int64_t Offset = MFFrame.getObjectOffset(FI);
589  unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
590  nullptr, MRI->getDwarfRegNum(Reg, true), Offset));
591  BuildMI(MBB, MBBI, DL, ZII->get(TargetOpcode::CFI_INSTRUCTION))
592  .addCFIIndex(CFIIndex);
593  }
594  }
595  }
596 
597  uint64_t StackSize = MFFrame.getStackSize();
598  // We need to allocate the ABI-defined 160-byte base area whenever
599  // we allocate stack space for our own use and whenever we call another
600  // function.
601  bool HasStackObject = false;
602  for (unsigned i = 0, e = MFFrame.getObjectIndexEnd(); i != e; ++i)
603  if (!MFFrame.isDeadObjectIndex(i)) {
604  HasStackObject = true;
605  break;
606  }
607  if (HasStackObject || MFFrame.hasCalls())
608  StackSize += SystemZMC::ELFCallFrameSize;
609  // Don't allocate the incoming reg save area.
610  StackSize = StackSize > SystemZMC::ELFCallFrameSize
611  ? StackSize - SystemZMC::ELFCallFrameSize
612  : 0;
613  MFFrame.setStackSize(StackSize);
614 
615  if (StackSize) {
616  // Allocate StackSize bytes.
617  int64_t Delta = -int64_t(StackSize);
618  const unsigned ProbeSize = TLI.getStackProbeSize(MF);
619  bool FreeProbe = (ZFI->getSpillGPRRegs().GPROffset &&
620  (ZFI->getSpillGPRRegs().GPROffset + StackSize) < ProbeSize);
621  if (!FreeProbe &&
623  // Stack probing may involve looping, but splitting the prologue block
624  // is not possible at this point since it would invalidate the
625  // SaveBlocks / RestoreBlocks sets of PEI in the single block function
626  // case. Build a pseudo to be handled later by inlineStackProbe().
627  BuildMI(MBB, MBBI, DL, ZII->get(SystemZ::PROBED_STACKALLOC))
628  .addImm(StackSize);
629  }
630  else {
631  bool StoreBackchain = MF.getFunction().hasFnAttribute("backchain");
632  // If we need backchain, save current stack pointer. R1 is free at
633  // this point.
634  if (StoreBackchain)
635  BuildMI(MBB, MBBI, DL, ZII->get(SystemZ::LGR))
636  .addReg(SystemZ::R1D, RegState::Define).addReg(SystemZ::R15D);
637  emitIncrement(MBB, MBBI, DL, SystemZ::R15D, Delta, ZII);
638  buildCFAOffs(MBB, MBBI, DL, SPOffsetFromCFA + Delta, ZII);
639  if (StoreBackchain)
640  BuildMI(MBB, MBBI, DL, ZII->get(SystemZ::STG))
641  .addReg(SystemZ::R1D, RegState::Kill).addReg(SystemZ::R15D)
643  }
644  SPOffsetFromCFA += Delta;
645  }
646 
647  if (HasFP) {
648  // Copy the base of the frame to R11.
649  BuildMI(MBB, MBBI, DL, ZII->get(SystemZ::LGR), SystemZ::R11D)
650  .addReg(SystemZ::R15D);
651 
652  // Add CFI for the new frame location.
653  buildDefCFAReg(MBB, MBBI, DL, SystemZ::R11D, ZII);
654 
655  // Mark the FramePtr as live at the beginning of every block except
656  // the entry block. (We'll have marked R11 as live on entry when
657  // saving the GPRs.)
658  for (MachineBasicBlock &MBBJ : llvm::drop_begin(MF))
659  MBBJ.addLiveIn(SystemZ::R11D);
660  }
661 
662  // Skip over the FPR/VR saves.
663  SmallVector<unsigned, 8> CFIIndexes;
664  for (auto &Save : CSI) {
665  Register Reg = Save.getReg();
666  if (SystemZ::FP64BitRegClass.contains(Reg)) {
667  if (MBBI != MBB.end() &&
668  (MBBI->getOpcode() == SystemZ::STD ||
669  MBBI->getOpcode() == SystemZ::STDY))
670  ++MBBI;
671  else
672  llvm_unreachable("Couldn't skip over FPR save");
673  } else if (SystemZ::VR128BitRegClass.contains(Reg)) {
674  if (MBBI != MBB.end() &&
675  MBBI->getOpcode() == SystemZ::VST)
676  ++MBBI;
677  else
678  llvm_unreachable("Couldn't skip over VR save");
679  } else
680  continue;
681 
682  // Add CFI for the this save.
683  unsigned DwarfReg = MRI->getDwarfRegNum(Reg, true);
684  Register IgnoredFrameReg;
685  int64_t Offset =
686  getFrameIndexReference(MF, Save.getFrameIdx(), IgnoredFrameReg)
687  .getFixed();
688 
689  unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
690  nullptr, DwarfReg, SPOffsetFromCFA + Offset));
691  CFIIndexes.push_back(CFIIndex);
692  }
693  // Complete the CFI for the FPR/VR saves, modelling them as taking effect
694  // after the last save.
695  for (auto CFIIndex : CFIIndexes) {
696  BuildMI(MBB, MBBI, DL, ZII->get(TargetOpcode::CFI_INSTRUCTION))
697  .addCFIIndex(CFIIndex);
698  }
699 }
700 
702  MachineBasicBlock &MBB) const {
704  auto *ZII =
705  static_cast<const SystemZInstrInfo *>(MF.getSubtarget().getInstrInfo());
707  MachineFrameInfo &MFFrame = MF.getFrameInfo();
708 
709  // See SystemZELFFrameLowering::emitPrologue
711  return;
712 
713  // Skip the return instruction.
714  assert(MBBI->isReturn() && "Can only insert epilogue into returning blocks");
715 
716  uint64_t StackSize = MFFrame.getStackSize();
717  if (ZFI->getRestoreGPRRegs().LowGPR) {
718  --MBBI;
719  unsigned Opcode = MBBI->getOpcode();
720  if (Opcode != SystemZ::LMG)
721  llvm_unreachable("Expected to see callee-save register restore code");
722 
723  unsigned AddrOpNo = 2;
724  DebugLoc DL = MBBI->getDebugLoc();
725  uint64_t Offset = StackSize + MBBI->getOperand(AddrOpNo + 1).getImm();
726  unsigned NewOpcode = ZII->getOpcodeForOffset(Opcode, Offset);
727 
728  // If the offset is too large, use the largest stack-aligned offset
729  // and add the rest to the base register (the stack or frame pointer).
730  if (!NewOpcode) {
731  uint64_t NumBytes = Offset - 0x7fff8;
732  emitIncrement(MBB, MBBI, DL, MBBI->getOperand(AddrOpNo).getReg(),
733  NumBytes, ZII);
734  Offset -= NumBytes;
735  NewOpcode = ZII->getOpcodeForOffset(Opcode, Offset);
736  assert(NewOpcode && "No restore instruction available");
737  }
738 
739  MBBI->setDesc(ZII->get(NewOpcode));
740  MBBI->getOperand(AddrOpNo + 1).ChangeToImmediate(Offset);
741  } else if (StackSize) {
742  DebugLoc DL = MBBI->getDebugLoc();
743  emitIncrement(MBB, MBBI, DL, SystemZ::R15D, StackSize, ZII);
744  }
745 }
746 
748  MachineFunction &MF, MachineBasicBlock &PrologMBB) const {
749  auto *ZII =
750  static_cast<const SystemZInstrInfo *>(MF.getSubtarget().getInstrInfo());
752  const SystemZTargetLowering &TLI = *STI.getTargetLowering();
753 
754  MachineInstr *StackAllocMI = nullptr;
755  for (MachineInstr &MI : PrologMBB)
756  if (MI.getOpcode() == SystemZ::PROBED_STACKALLOC) {
757  StackAllocMI = &MI;
758  break;
759  }
760  if (StackAllocMI == nullptr)
761  return;
762  uint64_t StackSize = StackAllocMI->getOperand(0).getImm();
763  const unsigned ProbeSize = TLI.getStackProbeSize(MF);
764  uint64_t NumFullBlocks = StackSize / ProbeSize;
765  uint64_t Residual = StackSize % ProbeSize;
766  int64_t SPOffsetFromCFA = -SystemZMC::ELFCFAOffsetFromInitialSP;
767  MachineBasicBlock *MBB = &PrologMBB;
768  MachineBasicBlock::iterator MBBI = StackAllocMI;
769  const DebugLoc DL = StackAllocMI->getDebugLoc();
770 
771  // Allocate a block of Size bytes on the stack and probe it.
772  auto allocateAndProbe = [&](MachineBasicBlock &InsMBB,
773  MachineBasicBlock::iterator InsPt, unsigned Size,
774  bool EmitCFI) -> void {
775  emitIncrement(InsMBB, InsPt, DL, SystemZ::R15D, -int64_t(Size), ZII);
776  if (EmitCFI) {
777  SPOffsetFromCFA -= Size;
778  buildCFAOffs(InsMBB, InsPt, DL, SPOffsetFromCFA, ZII);
779  }
780  // Probe by means of a volatile compare.
783  BuildMI(InsMBB, InsPt, DL, ZII->get(SystemZ::CG))
784  .addReg(SystemZ::R0D, RegState::Undef)
785  .addReg(SystemZ::R15D).addImm(Size - 8).addReg(0)
786  .addMemOperand(MMO);
787  };
788 
789  bool StoreBackchain = MF.getFunction().hasFnAttribute("backchain");
790  if (StoreBackchain)
791  BuildMI(*MBB, MBBI, DL, ZII->get(SystemZ::LGR))
792  .addReg(SystemZ::R1D, RegState::Define).addReg(SystemZ::R15D);
793 
794  MachineBasicBlock *DoneMBB = nullptr;
795  MachineBasicBlock *LoopMBB = nullptr;
796  if (NumFullBlocks < 3) {
797  // Emit unrolled probe statements.
798  for (unsigned int i = 0; i < NumFullBlocks; i++)
799  allocateAndProbe(*MBB, MBBI, ProbeSize, true/*EmitCFI*/);
800  } else {
801  // Emit a loop probing the pages.
802  uint64_t LoopAlloc = ProbeSize * NumFullBlocks;
803  SPOffsetFromCFA -= LoopAlloc;
804 
805  // Use R0D to hold the exit value.
806  BuildMI(*MBB, MBBI, DL, ZII->get(SystemZ::LGR), SystemZ::R0D)
807  .addReg(SystemZ::R15D);
808  buildDefCFAReg(*MBB, MBBI, DL, SystemZ::R0D, ZII);
809  emitIncrement(*MBB, MBBI, DL, SystemZ::R0D, -int64_t(LoopAlloc), ZII);
810  buildCFAOffs(*MBB, MBBI, DL, -int64_t(SystemZMC::ELFCallFrameSize + LoopAlloc),
811  ZII);
812 
813  DoneMBB = SystemZ::splitBlockBefore(MBBI, MBB);
814  LoopMBB = SystemZ::emitBlockAfter(MBB);
815  MBB->addSuccessor(LoopMBB);
816  LoopMBB->addSuccessor(LoopMBB);
817  LoopMBB->addSuccessor(DoneMBB);
818 
819  MBB = LoopMBB;
820  allocateAndProbe(*MBB, MBB->end(), ProbeSize, false/*EmitCFI*/);
821  BuildMI(*MBB, MBB->end(), DL, ZII->get(SystemZ::CLGR))
822  .addReg(SystemZ::R15D).addReg(SystemZ::R0D);
823  BuildMI(*MBB, MBB->end(), DL, ZII->get(SystemZ::BRC))
825 
826  MBB = DoneMBB;
827  MBBI = DoneMBB->begin();
828  buildDefCFAReg(*MBB, MBBI, DL, SystemZ::R15D, ZII);
829  }
830 
831  if (Residual)
832  allocateAndProbe(*MBB, MBBI, Residual, true/*EmitCFI*/);
833 
834  if (StoreBackchain)
835  BuildMI(*MBB, MBBI, DL, ZII->get(SystemZ::STG))
836  .addReg(SystemZ::R1D, RegState::Kill).addReg(SystemZ::R15D)
838 
839  StackAllocMI->eraseFromParent();
840  if (DoneMBB != nullptr) {
841  // Compute the live-in lists for the new blocks.
842  recomputeLiveIns(*DoneMBB);
843  recomputeLiveIns(*LoopMBB);
844  }
845 }
846 
848  return (MF.getTarget().Options.DisableFramePointerElim(MF) ||
850 }
851 
853  const MachineFunction &MF, int FI, Register &FrameReg) const {
854  // Our incoming SP is actually SystemZMC::ELFCallFrameSize below the CFA, so
855  // add that difference here.
856  StackOffset Offset =
859 }
860 
862  Register Reg) const {
863  bool IsVarArg = MF.getFunction().isVarArg();
864  bool BackChain = MF.getFunction().hasFnAttribute("backchain");
865  bool SoftFloat = MF.getSubtarget<SystemZSubtarget>().hasSoftFloat();
866  unsigned Offset = RegSpillOffsets[Reg];
867  if (usePackedStack(MF) && !(IsVarArg && !SoftFloat)) {
868  if (SystemZ::GR64BitRegClass.contains(Reg))
869  // Put all GPRs at the top of the Register save area with packed
870  // stack. Make room for the backchain if needed.
871  Offset += BackChain ? 24 : 32;
872  else
873  Offset = 0;
874  }
875  return Offset;
876 }
877 
879  MachineFunction &MF) const {
881  int FI = ZFI->getFramePointerSaveIndex();
882  if (!FI) {
883  MachineFrameInfo &MFFrame = MF.getFrameInfo();
885  FI = MFFrame.CreateFixedObject(8, Offset, false);
886  ZFI->setFramePointerSaveIndex(FI);
887  }
888  return FI;
889 }
890 
892  bool HasPackedStackAttr = MF.getFunction().hasFnAttribute("packed-stack");
893  bool BackChain = MF.getFunction().hasFnAttribute("backchain");
894  bool SoftFloat = MF.getSubtarget<SystemZSubtarget>().hasSoftFloat();
895  if (HasPackedStackAttr && BackChain && !SoftFloat)
896  report_fatal_error("packed-stack + backchain + hard-float is unsupported.");
897  bool CallConv = MF.getFunction().getCallingConv() != CallingConv::GHC;
898  return HasPackedStackAttr && CallConv;
899 }
900 
902  : SystemZFrameLowering(TargetFrameLowering::StackGrowsDown, Align(32), 0,
903  Align(32), /* StackRealignable */ false),
904  RegSpillOffsets(-1) {
905 
906  // Create a mapping from register number to save slot offset.
907  // These offsets are relative to the start of the local are area.
908  RegSpillOffsets.grow(SystemZ::NUM_TARGET_REGS);
909  for (unsigned I = 0, E = array_lengthof(XPLINKSpillOffsetTable); I != E; ++I)
910  RegSpillOffsets[XPLINKSpillOffsetTable[I].Reg] =
911  XPLINKSpillOffsetTable[I].Offset;
912 }
913 
916  std::vector<CalleeSavedInfo> &CSI) const {
917  MachineFrameInfo &MFFrame = MF.getFrameInfo();
919  const SystemZSubtarget &Subtarget = MF.getSubtarget<SystemZSubtarget>();
920  auto &Regs = Subtarget.getSpecialRegisters<SystemZXPLINK64Registers>();
921 
922  // Scan the call-saved GPRs and find the bounds of the register spill area.
923  unsigned LowGPR = 0;
924  int LowOffset = INT32_MAX;
925  unsigned HighGPR = LowGPR;
926  int HighOffset = -1;
927 
928  unsigned RegSP = Regs.getStackPointerRegister();
929  auto &GRRegClass = SystemZ::GR64BitRegClass;
930  const unsigned RegSize = 8;
931 
932  auto ProcessCSI = [&](std::vector<CalleeSavedInfo> &CSIList) {
933  for (auto &CS : CSIList) {
934  Register Reg = CS.getReg();
935  int Offset = RegSpillOffsets[Reg];
936  if (Offset >= 0) {
937  if (GRRegClass.contains(Reg)) {
938  if (LowOffset > Offset) {
939  LowOffset = Offset;
940  LowGPR = Reg;
941  }
942 
943  if (Offset > HighOffset) {
944  HighOffset = Offset;
945  HighGPR = Reg;
946  }
947  }
948  int FrameIdx = MFFrame.CreateFixedSpillStackObject(RegSize, Offset);
949  CS.setFrameIdx(FrameIdx);
950  } else
951  CS.setFrameIdx(INT32_MAX);
952  }
953  };
954 
955  std::vector<CalleeSavedInfo> Spills;
956 
957  // For non-leaf functions:
958  // - the address of callee (entry point) register R6 must be saved
959  Spills.push_back(CalleeSavedInfo(Regs.getAddressOfCalleeRegister()));
960 
961  // If the function needs a frame pointer, or if the backchain pointer should
962  // be stored, then save the stack pointer register R4.
963  if (hasFP(MF) || MF.getFunction().hasFnAttribute("backchain"))
964  Spills.push_back(CalleeSavedInfo(RegSP));
965 
966  // Save the range of call-saved registers, for use by the
967  // prologue/epilogue inserters.
968  ProcessCSI(CSI);
969  MFI->setRestoreGPRRegs(LowGPR, HighGPR, LowOffset);
970 
971  // Save the range of call-saved registers, for use by the epilogue inserter.
972  ProcessCSI(Spills);
973  MFI->setSpillGPRRegs(LowGPR, HighGPR, LowOffset);
974 
975  // Create spill slots for the remaining registers.
976  for (auto &CS : CSI) {
977  if (CS.getFrameIdx() != INT32_MAX)
978  continue;
979  Register Reg = CS.getReg();
981  Align Alignment = TRI->getSpillAlign(*RC);
982  unsigned Size = TRI->getSpillSize(*RC);
983  Alignment = std::min(Alignment, getStackAlign());
984  int FrameIdx = MFFrame.CreateStackObject(Size, Alignment, true);
985  CS.setFrameIdx(FrameIdx);
986  }
987 
988  return true;
989 }
990 
992  BitVector &SavedRegs,
993  RegScavenger *RS) const {
995 
996  bool HasFP = hasFP(MF);
997  const SystemZSubtarget &Subtarget = MF.getSubtarget<SystemZSubtarget>();
998  auto &Regs = Subtarget.getSpecialRegisters<SystemZXPLINK64Registers>();
999 
1000  // If the function requires a frame pointer, record that the hard
1001  // frame pointer will be clobbered.
1002  if (HasFP)
1003  SavedRegs.set(Regs.getFramePointerRegister());
1004 
1005  // If the function is not an XPLeaf function, we need to save the
1006  // return address register. We also always use that register for
1007  // the return instruction, so it needs to be restored in the
1008  // epilogue even though that register is considered to be volatile.
1009  // #TODO: Implement leaf detection.
1010  SavedRegs.set(Regs.getReturnFunctionAddressRegister());
1011 }
1012 
1015  ArrayRef<CalleeSavedInfo> CSI, const TargetRegisterInfo *TRI) const {
1016  if (CSI.empty())
1017  return true;
1018 
1019  MachineFunction &MF = *MBB.getParent();
1021  const SystemZSubtarget &Subtarget = MF.getSubtarget<SystemZSubtarget>();
1022  const TargetInstrInfo *TII = Subtarget.getInstrInfo();
1023  auto &Regs = Subtarget.getSpecialRegisters<SystemZXPLINK64Registers>();
1024  SystemZ::GPRRegs SpillGPRs = ZFI->getSpillGPRRegs();
1025  DebugLoc DL;
1026 
1027  // Save GPRs
1028  if (SpillGPRs.LowGPR) {
1029  assert(SpillGPRs.LowGPR != SpillGPRs.HighGPR &&
1030  "Should be saving multiple registers");
1031 
1032  // Build an STM/STMG instruction.
1033  MachineInstrBuilder MIB = BuildMI(MBB, MBBI, DL, TII->get(SystemZ::STMG));
1034 
1035  // Add the explicit register operands.
1036  addSavedGPR(MBB, MIB, SpillGPRs.LowGPR, false);
1037  addSavedGPR(MBB, MIB, SpillGPRs.HighGPR, false);
1038 
1039  // Add the address r4
1040  MIB.addReg(Regs.getStackPointerRegister());
1041 
1042  // Add the partial offset
1043  // We cannot add the actual offset as, at the stack is not finalized
1044  MIB.addImm(SpillGPRs.GPROffset);
1045 
1046  // Make sure all call-saved GPRs are included as operands and are
1047  // marked as live on entry.
1048  auto &GRRegClass = SystemZ::GR64BitRegClass;
1049  for (const CalleeSavedInfo &I : CSI) {
1050  Register Reg = I.getReg();
1051  if (GRRegClass.contains(Reg))
1052  addSavedGPR(MBB, MIB, Reg, true);
1053  }
1054  }
1055 
1056  // Spill FPRs to the stack in the normal TargetInstrInfo way
1057  for (const CalleeSavedInfo &I : CSI) {
1058  Register Reg = I.getReg();
1059  if (SystemZ::FP64BitRegClass.contains(Reg)) {
1060  MBB.addLiveIn(Reg);
1061  TII->storeRegToStackSlot(MBB, MBBI, Reg, true, I.getFrameIdx(),
1062  &SystemZ::FP64BitRegClass, TRI);
1063  }
1064  if (SystemZ::VR128BitRegClass.contains(Reg)) {
1065  MBB.addLiveIn(Reg);
1066  TII->storeRegToStackSlot(MBB, MBBI, Reg, true, I.getFrameIdx(),
1067  &SystemZ::VR128BitRegClass, TRI);
1068  }
1069  }
1070 
1071  return true;
1072 }
1073 
1077 
1078  if (CSI.empty())
1079  return false;
1080 
1081  MachineFunction &MF = *MBB.getParent();
1083  const SystemZSubtarget &Subtarget = MF.getSubtarget<SystemZSubtarget>();
1084  const TargetInstrInfo *TII = Subtarget.getInstrInfo();
1085  auto &Regs = Subtarget.getSpecialRegisters<SystemZXPLINK64Registers>();
1086 
1087  DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
1088 
1089  // Restore FPRs in the normal TargetInstrInfo way.
1090  for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
1091  Register Reg = CSI[I].getReg();
1092  if (SystemZ::FP64BitRegClass.contains(Reg))
1093  TII->loadRegFromStackSlot(MBB, MBBI, Reg, CSI[I].getFrameIdx(),
1094  &SystemZ::FP64BitRegClass, TRI);
1095  if (SystemZ::VR128BitRegClass.contains(Reg))
1096  TII->loadRegFromStackSlot(MBB, MBBI, Reg, CSI[I].getFrameIdx(),
1097  &SystemZ::VR128BitRegClass, TRI);
1098  }
1099 
1100  // Restore call-saved GPRs (but not call-clobbered varargs, which at
1101  // this point might hold return values).
1102  SystemZ::GPRRegs RestoreGPRs = ZFI->getRestoreGPRRegs();
1103  if (RestoreGPRs.LowGPR) {
1104  assert(isInt<20>(Regs.getStackPointerBias() + RestoreGPRs.GPROffset));
1105  if (RestoreGPRs.LowGPR == RestoreGPRs.HighGPR)
1106  // Build an LG/L instruction.
1107  BuildMI(MBB, MBBI, DL, TII->get(SystemZ::LG), RestoreGPRs.LowGPR)
1108  .addReg(Regs.getStackPointerRegister())
1109  .addImm(Regs.getStackPointerBias() + RestoreGPRs.GPROffset)
1110  .addReg(0);
1111  else {
1112  // Build an LMG/LM instruction.
1113  MachineInstrBuilder MIB = BuildMI(MBB, MBBI, DL, TII->get(SystemZ::LMG));
1114 
1115  // Add the explicit register operands.
1116  MIB.addReg(RestoreGPRs.LowGPR, RegState::Define);
1117  MIB.addReg(RestoreGPRs.HighGPR, RegState::Define);
1118 
1119  // Add the address.
1120  MIB.addReg(Regs.getStackPointerRegister());
1121  MIB.addImm(Regs.getStackPointerBias() + RestoreGPRs.GPROffset);
1122 
1123  // Do a second scan adding regs as being defined by instruction
1124  for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
1125  Register Reg = CSI[I].getReg();
1126  if (Reg > RestoreGPRs.LowGPR && Reg < RestoreGPRs.HighGPR)
1128  }
1129  }
1130  }
1131 
1132  return true;
1133 }
1134 
1136  MachineBasicBlock &MBB) const {
1137  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
1138  const SystemZSubtarget &Subtarget = MF.getSubtarget<SystemZSubtarget>();
1141  auto *ZII = static_cast<const SystemZInstrInfo *>(Subtarget.getInstrInfo());
1142  auto &Regs = Subtarget.getSpecialRegisters<SystemZXPLINK64Registers>();
1143  MachineFrameInfo &MFFrame = MF.getFrameInfo();
1144  MachineInstr *StoreInstr = nullptr;
1145  bool HasFP = hasFP(MF);
1146  // Debug location must be unknown since the first debug location is used
1147  // to determine the end of the prologue.
1148  DebugLoc DL;
1149  uint64_t Offset = 0;
1150 
1151  // TODO: Support leaf functions; only add size of save+reserved area when
1152  // function is non-leaf.
1153  MFFrame.setStackSize(MFFrame.getStackSize() + Regs.getCallFrameSize());
1154  uint64_t StackSize = MFFrame.getStackSize();
1155 
1156  if (ZFI->getSpillGPRRegs().LowGPR) {
1157  // Skip over the GPR saves.
1158  if ((MBBI != MBB.end()) && ((MBBI->getOpcode() == SystemZ::STMG))) {
1159  const int Operand = 3;
1160  // Now we can set the offset for the operation, since now the Stack
1161  // has been finalized.
1162  Offset = Regs.getStackPointerBias() + MBBI->getOperand(Operand).getImm();
1163  // Maximum displacement for STMG instruction.
1164  if (isInt<20>(Offset - StackSize))
1165  Offset -= StackSize;
1166  else
1167  StoreInstr = &*MBBI;
1168  MBBI->getOperand(Operand).setImm(Offset);
1169  ++MBBI;
1170  } else
1171  llvm_unreachable("Couldn't skip over GPR saves");
1172  }
1173 
1174  if (StackSize) {
1175  MachineBasicBlock::iterator InsertPt = StoreInstr ? StoreInstr : MBBI;
1176  // Allocate StackSize bytes.
1177  int64_t Delta = -int64_t(StackSize);
1178 
1179  // In case the STM(G) instruction also stores SP (R4), but the displacement
1180  // is too large, the SP register is manipulated first before storing,
1181  // resulting in the wrong value stored and retrieved later. In this case, we
1182  // need to temporarily save the value of SP, and store it later to memory.
1183  if (StoreInstr && HasFP) {
1184  // Insert LR r0,r4 before STMG instruction.
1185  BuildMI(MBB, InsertPt, DL, ZII->get(SystemZ::LGR))
1186  .addReg(SystemZ::R0D, RegState::Define)
1187  .addReg(SystemZ::R4D);
1188  // Insert ST r0,xxx(,r4) after STMG instruction.
1189  BuildMI(MBB, MBBI, DL, ZII->get(SystemZ::STG))
1190  .addReg(SystemZ::R0D, RegState::Kill)
1191  .addReg(SystemZ::R4D)
1192  .addImm(Offset)
1193  .addReg(0);
1194  }
1195 
1196  emitIncrement(MBB, InsertPt, DL, Regs.getStackPointerRegister(), Delta,
1197  ZII);
1198 
1199  // If the requested stack size is larger than the guard page, then we need
1200  // to check if we need to call the stack extender. This requires adding a
1201  // conditional branch, but splitting the prologue block is not possible at
1202  // this point since it would invalidate the SaveBlocks / RestoreBlocks sets
1203  // of PEI in the single block function case. Build a pseudo to be handled
1204  // later by inlineStackProbe().
1205  const uint64_t GuardPageSize = 1024 * 1024;
1206  if (StackSize > GuardPageSize) {
1207  assert(StoreInstr && "Wrong insertion point");
1208  BuildMI(MBB, InsertPt, DL, ZII->get(SystemZ::XPLINK_STACKALLOC));
1209  }
1210  }
1211 
1212  if (HasFP) {
1213  // Copy the base of the frame to Frame Pointer Register.
1214  BuildMI(MBB, MBBI, DL, ZII->get(SystemZ::LGR),
1215  Regs.getFramePointerRegister())
1216  .addReg(Regs.getStackPointerRegister());
1217 
1218  // Mark the FramePtr as live at the beginning of every block except
1219  // the entry block. (We'll have marked R8 as live on entry when
1220  // saving the GPRs.)
1221  for (auto I = std::next(MF.begin()), E = MF.end(); I != E; ++I)
1222  I->addLiveIn(Regs.getFramePointerRegister());
1223  }
1224 }
1225 
1227  MachineBasicBlock &MBB) const {
1228  const SystemZSubtarget &Subtarget = MF.getSubtarget<SystemZSubtarget>();
1231  MachineFrameInfo &MFFrame = MF.getFrameInfo();
1232  auto *ZII = static_cast<const SystemZInstrInfo *>(Subtarget.getInstrInfo());
1233  auto &Regs = Subtarget.getSpecialRegisters<SystemZXPLINK64Registers>();
1234 
1235  // Skip the return instruction.
1236  assert(MBBI->isReturn() && "Can only insert epilogue into returning blocks");
1237 
1238  uint64_t StackSize = MFFrame.getStackSize();
1239  if (StackSize) {
1240  unsigned SPReg = Regs.getStackPointerRegister();
1241  if (ZFI->getRestoreGPRRegs().LowGPR != SPReg) {
1242  DebugLoc DL = MBBI->getDebugLoc();
1243  emitIncrement(MBB, MBBI, DL, SPReg, StackSize, ZII);
1244  }
1245  }
1246 }
1247 
1248 // Emit a compare of the stack pointer against the stack floor, and a call to
1249 // the LE stack extender if needed.
1251  MachineFunction &MF, MachineBasicBlock &PrologMBB) const {
1252  auto *ZII =
1253  static_cast<const SystemZInstrInfo *>(MF.getSubtarget().getInstrInfo());
1254 
1255  MachineInstr *StackAllocMI = nullptr;
1256  for (MachineInstr &MI : PrologMBB)
1257  if (MI.getOpcode() == SystemZ::XPLINK_STACKALLOC) {
1258  StackAllocMI = &MI;
1259  break;
1260  }
1261  if (StackAllocMI == nullptr)
1262  return;
1263 
1264  MachineBasicBlock &MBB = PrologMBB;
1265  const DebugLoc DL = StackAllocMI->getDebugLoc();
1266 
1267  // The 2nd half of block MBB after split.
1268  MachineBasicBlock *NextMBB;
1269 
1270  // Add new basic block for the call to the stack overflow function.
1271  MachineBasicBlock *StackExtMBB =
1273  MF.push_back(StackExtMBB);
1274 
1275  // LG r3,72(,r3)
1276  BuildMI(StackExtMBB, DL, ZII->get(SystemZ::LG), SystemZ::R3D)
1277  .addReg(SystemZ::R3D)
1278  .addImm(72)
1279  .addReg(0);
1280  // BASR r3,r3
1281  BuildMI(StackExtMBB, DL, ZII->get(SystemZ::CallBASR_STACKEXT))
1282  .addReg(SystemZ::R3D);
1283 
1284  // LLGT r3,1208
1285  BuildMI(MBB, StackAllocMI, DL, ZII->get(SystemZ::LLGT), SystemZ::R3D)
1286  .addReg(0)
1287  .addImm(1208)
1288  .addReg(0);
1289  // CG r4,64(,r3)
1290  BuildMI(MBB, StackAllocMI, DL, ZII->get(SystemZ::CG))
1291  .addReg(SystemZ::R4D)
1292  .addReg(SystemZ::R3D)
1293  .addImm(64)
1294  .addReg(0);
1295  // JLL b'0100',F'37'
1296  BuildMI(MBB, StackAllocMI, DL, ZII->get(SystemZ::BRC))
1299  .addMBB(StackExtMBB);
1300 
1301  NextMBB = SystemZ::splitBlockBefore(StackAllocMI, &MBB);
1302  MBB.addSuccessor(NextMBB);
1303  MBB.addSuccessor(StackExtMBB);
1304 
1305  // Add jump back from stack extension BB.
1306  BuildMI(StackExtMBB, DL, ZII->get(SystemZ::J)).addMBB(NextMBB);
1307  StackExtMBB->addSuccessor(NextMBB);
1308 
1309  StackAllocMI->eraseFromParent();
1310 
1311  // Compute the live-in lists for the new blocks.
1312  recomputeLiveIns(*NextMBB);
1313  recomputeLiveIns(*StackExtMBB);
1314 }
1315 
1317  return (MF.getFrameInfo().hasVarSizedObjects());
1318 }
1319 
1321  MachineFunction &MF, RegScavenger *RS) const {
1322  MachineFrameInfo &MFFrame = MF.getFrameInfo();
1323  const SystemZSubtarget &Subtarget = MF.getSubtarget<SystemZSubtarget>();
1324  auto &Regs = Subtarget.getSpecialRegisters<SystemZXPLINK64Registers>();
1325 
1326  // Setup stack frame offset
1327  MFFrame.setOffsetAdjustment(Regs.getStackPointerBias());
1328 }
i
i
Definition: README.txt:29
llvm::MachineFrameInfo::hasVarSizedObjects
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
Definition: MachineFrameInfo.h:354
SystemZInstrBuilder.h
llvm::SystemZSubtarget::getTargetLowering
const SystemZTargetLowering * getTargetLowering() const override
Definition: SystemZSubtarget.h:115
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:104
llvm::MachineInstrBuilder::addImm
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
Definition: MachineInstrBuilder.h:131
llvm::MachineFrameInfo::estimateStackSize
uint64_t estimateStackSize(const MachineFunction &MF) const
Estimate and return the size of the stack frame.
Definition: MachineFrameInfo.cpp:137
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::drop_begin
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition: STLExtras.h:280
llvm::MachineBasicBlock::isLiveIn
bool isLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
Definition: MachineBasicBlock.cpp:576
llvm::SystemZMachineFunctionInfo::getFramePointerSaveIndex
int getFramePointerSaveIndex() const
Definition: SystemZMachineFunctionInfo.h:88
llvm::SystemZXPLINKFrameLowering::determineCalleeSaves
void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS) const override
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
Definition: SystemZFrameLowering.cpp:991
llvm::TargetFrameLowering
Information about stack frame layout on the target.
Definition: TargetFrameLowering.h:43
llvm::MachineBasicBlock::getBasicBlock
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
Definition: MachineBasicBlock.h:205
llvm::MachineModuleInfo::getContext
const MCContext & getContext() const
Definition: MachineModuleInfo.h:144
llvm::SystemZXPLINKFrameLowering::spillCalleeSavedRegisters
bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...
Definition: SystemZFrameLowering.cpp:1013
llvm::SystemZELFFrameLowering::inlineStackProbe
void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologMBB) const override
Replace a StackProbe stub (if any) with the actual probe code inline.
Definition: SystemZFrameLowering.cpp:747
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:50
RegSize
unsigned RegSize
Definition: AArch64MIPeepholeOpt.cpp:121
llvm::MCContext::getRegisterInfo
const MCRegisterInfo * getRegisterInfo() const
Definition: MCContext.h:445
llvm::BitVector::set
BitVector & set()
Definition: BitVector.h:344
llvm::TargetSubtargetInfo::getInstrInfo
virtual const TargetInstrInfo * getInstrInfo() const
Definition: TargetSubtargetInfo.h:93
llvm::MachineInstrBuilder::addCFIIndex
const MachineInstrBuilder & addCFIIndex(unsigned CFIIndex) const
Definition: MachineInstrBuilder.h:247
llvm::SystemZELFFrameLowering::processFunctionBeforeFrameFinalized
void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS) const override
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
Definition: SystemZFrameLowering.cpp:441
contains
return AArch64::GPR64RegClass contains(Reg)
llvm::SystemZTargetLowering
Definition: SystemZISelLowering.h:385
emitIncrement
static void emitIncrement(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, const DebugLoc &DL, Register Reg, int64_t NumBytes, const TargetInstrInfo *TII)
Definition: SystemZFrameLowering.cpp:485
llvm::SmallVector< unsigned, 8 >
llvm::SystemZ::emitBlockAfter
MachineBasicBlock * emitBlockAfter(MachineBasicBlock *MBB)
Definition: SystemZInstrInfo.cpp:1922
llvm::MachineFunction::end
iterator end()
Definition: MachineFunction.h:855
llvm::SystemZFrameLowering::create
static std::unique_ptr< SystemZFrameLowering > create(const SystemZSubtarget &STI)
Definition: SystemZFrameLowering.cpp:62
llvm::MachineFunction::getMachineMemOperand
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s, Align base_alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
Definition: MachineFunction.cpp:454
llvm::recomputeLiveIns
static void recomputeLiveIns(MachineBasicBlock &MBB)
Convenience function for recomputing live-in's for MBB.
Definition: LivePhysRegs.h:198
llvm::X86Disassembler::Reg
Reg
All possible values of the reg field in the ModR/M byte.
Definition: X86DisassemblerDecoder.h:462
llvm::SystemZ::CCMASK_CMP_LT
const unsigned CCMASK_CMP_LT
Definition: SystemZ.h:36
llvm::AArch64ISD::STG
@ STG
Definition: AArch64ISelLowering.h:445
llvm::TargetSubtargetInfo::getRegisterInfo
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
Definition: TargetSubtargetInfo.h:125
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:234
llvm::SystemZXPLINKFrameLowering::processFunctionBeforeFrameFinalized
void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS) const override
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
Definition: SystemZFrameLowering.cpp:1320
llvm::SystemZFrameLowering::hasReservedCallFrame
bool hasReservedCallFrame(const MachineFunction &MF) const override
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...
Definition: SystemZFrameLowering.cpp:165
llvm::StackOffset::getFixed
ScalarTy getFixed() const
Definition: TypeSize.h:149
llvm::MachineFrameInfo::setStackSize
void setStackSize(uint64_t Size)
Set the size of the stack.
Definition: MachineFrameInfo.h:580
llvm::SystemZ::splitBlockBefore
MachineBasicBlock * splitBlockBefore(MachineBasicBlock::iterator MI, MachineBasicBlock *MBB)
Definition: SystemZInstrInfo.cpp:1938
llvm::MachineMemOperand
A description of a memory reference used in the backend.
Definition: MachineMemOperand.h:127
llvm::SystemZELFFrameLowering::determineCalleeSaves
void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS) const override
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
Definition: SystemZFrameLowering.cpp:241
llvm::SystemZMachineFunctionInfo::getVarArgsFirstGPR
Register getVarArgsFirstGPR() const
Definition: SystemZMachineFunctionInfo.h:71
llvm::SystemZELFFrameLowering::emitPrologue
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
Definition: SystemZFrameLowering.cpp:538
SystemZCallingConv.h
llvm::SystemZELFFrameLowering::usePackedStack
bool usePackedStack(MachineFunction &MF) const
Definition: SystemZFrameLowering.cpp:891
llvm::max
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:337
llvm::SystemZInstrInfo
Definition: SystemZInstrInfo.h:174
llvm::RegState::ImplicitDefine
@ ImplicitDefine
Definition: MachineInstrBuilder.h:63
llvm::SystemZSubtarget::isTargetXPLINK64
bool isTargetXPLINK64() const
Definition: SystemZSubtarget.h:299
llvm::MachineFrameInfo::getObjectIndexEnd
int getObjectIndexEnd() const
Return one past the maximum frame object index.
Definition: MachineFrameInfo.h:409
llvm::SystemZXPLINKFrameLowering::restoreCalleeSavedRegisters
bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBII, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
Definition: SystemZFrameLowering.cpp:1074
llvm::MachineOperand::isFI
bool isFI() const
isFI - Tests if this is a MO_FrameIndex operand.
Definition: MachineOperand.h:330
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1628
llvm::SystemZXPLINK64Registers
XPLINK64 calling convention specific use registers Particular to z/OS when in 64 bit mode.
Definition: SystemZRegisterInfo.h:82
llvm::SystemZ::GPRRegs
Definition: SystemZMachineFunctionInfo.h:19
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:159
llvm::SystemZMachineFunctionInfo::setRestoreGPRRegs
void setRestoreGPRRegs(Register Low, Register High, unsigned Offs)
Definition: SystemZMachineFunctionInfo.h:63
llvm::MCCFIInstruction::cfiDefCfaOffset
static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int Offset)
.cfi_def_cfa_offset modifies a rule for computing CFA.
Definition: MCDwarf.h:540
MachineRegisterInfo.h
llvm::TargetFrameLowering::StackDirection
StackDirection
Definition: TargetFrameLowering.h:45
llvm::MachineBasicBlock::erase
instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
Definition: MachineBasicBlock.cpp:1299
llvm::TargetRegisterInfo::getCalleeSavedRegs
virtual const MCPhysReg * getCalleeSavedRegs(const MachineFunction *MF) const =0
Return a null-terminated list of all of the callee-saved registers on this target.
llvm::MachineBasicBlock::addSuccessor
void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
Definition: MachineBasicBlock.cpp:747
llvm::SystemZFrameLowering::SystemZFrameLowering
SystemZFrameLowering(StackDirection D, Align StackAl, int LAO, Align TransAl, bool StackReal)
Definition: SystemZFrameLowering.cpp:56
llvm::MachineFunction::front
const MachineBasicBlock & front() const
Definition: MachineFunction.h:865
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition: MachineFunction.h:666
llvm::TargetInstrInfo
TargetInstrInfo - Interface to description of machine instruction set.
Definition: TargetInstrInfo.h:97
llvm::MachineRegisterInfo::use_nodbg_operands
iterator_range< use_nodbg_iterator > use_nodbg_operands(Register Reg) const
Definition: MachineRegisterInfo.h:534
TargetMachine.h
llvm::SystemZII::Has20BitOffset
@ Has20BitOffset
Definition: SystemZInstrInfo.h:38
llvm::MachineInstrBuilder::addMBB
const MachineInstrBuilder & addMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0) const
Definition: MachineInstrBuilder.h:146
llvm::SystemZ::GPRRegs::GPROffset
unsigned GPROffset
Definition: SystemZMachineFunctionInfo.h:22
llvm::SystemZELFFrameLowering::getBackchainOffset
unsigned getBackchainOffset(MachineFunction &MF) const
Definition: SystemZFrameLowering.h:92
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:306
SystemZInstrInfo.h
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineOperand::getImm
int64_t getImm() const
Definition: MachineOperand.h:546
llvm::MachineFunction::getInfo
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Definition: MachineFunction.h:754
llvm::TargetFrameLowering::getStackAlign
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
Definition: TargetFrameLowering.h:100
llvm::MachineInstr::getOperand
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:501
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:45
llvm::RegState::Kill
@ Kill
The last use of a register.
Definition: MachineInstrBuilder.h:48
false
Definition: StackSlotColoring.cpp:141
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:125
llvm::dwarf::Index
Index
Definition: Dwarf.h:472
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:48
llvm::MachineModuleInfo
This class contains meta information specific to a module.
Definition: MachineModuleInfo.h:75
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:143
llvm::MachineFunction::begin
iterator begin()
Definition: MachineFunction.h:853
llvm::MachineFrameInfo::getStackSize
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
Definition: MachineFrameInfo.h:577
llvm::MachineFrameInfo::getObjectOffset
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
Definition: MachineFrameInfo.h:518
llvm::BitVector
Definition: BitVector.h:75
llvm::SystemZFrameLowering::eliminateCallFramePseudoInstr
MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const override
This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...
Definition: SystemZFrameLowering.cpp:68
Align
uint64_t Align
Definition: ELFObjHandler.cpp:81
llvm::SystemZMachineFunctionInfo::getRestoreGPRRegs
SystemZ::GPRRegs getRestoreGPRRegs() const
Definition: SystemZMachineFunctionInfo.h:62
llvm::SystemZMachineFunctionInfo::setSpillGPRRegs
void setSpillGPRRegs(Register Low, Register High, unsigned Offs)
Definition: SystemZMachineFunctionInfo.h:53
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::SystemZ::CCMASK_CMP_GT
const unsigned CCMASK_CMP_GT
Definition: SystemZ.h:37
llvm::MachineFrameInfo::getObjectIndexBegin
int getObjectIndexBegin() const
Return the minimum frame object index.
Definition: MachineFrameInfo.h:406
llvm::array_lengthof
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLArrayExtras.h:29
llvm::MCCFIInstruction::createDefCfaRegister
static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register)
.cfi_def_cfa_register modifies a rule for computing CFA.
Definition: MCDwarf.h:533
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:94
llvm::MachineFrameInfo::isDeadObjectIndex
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
Definition: MachineFrameInfo.h:737
llvm::SystemZ::ELFArgGPRs
const MCPhysReg ELFArgGPRs[ELFNumArgGPRs]
Definition: SystemZCallingConv.cpp:14
llvm::SystemZELFFrameLowering::orderFrameObjects
void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &ObjectsToAllocate) const override
Order the symbols in the local stack frame.
Definition: SystemZFrameLowering.cpp:96
llvm::SystemZELFFrameLowering::hasFP
bool hasFP(const MachineFunction &MF) const override
hasFP - Return true if the specified function should have a dedicated frame pointer register.
Definition: SystemZFrameLowering.cpp:847
llvm::TargetOptions::DisableFramePointerElim
bool DisableFramePointerElim(const MachineFunction &MF) const
DisableFramePointerElim - This returns true if frame pointer elimination optimization should be disab...
Definition: TargetOptionsImpl.cpp:23
llvm::MachineFunction::getMMI
MachineModuleInfo & getMMI() const
Definition: MachineFunction.h:607
buildDefCFAReg
static void buildDefCFAReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, unsigned Reg, const SystemZInstrInfo *ZII)
Definition: SystemZFrameLowering.cpp:524
llvm::TargetRegisterInfo::getSpillAlign
Align getSpillAlign(const TargetRegisterClass &RC) const
Return the minimum required alignment in bytes for a spill slot for a register of this class.
Definition: TargetRegisterInfo.h:289
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:656
llvm::Function::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:625
llvm::MachineFunction::push_back
void push_back(MachineBasicBlock *MBB)
Definition: MachineFunction.h:870
llvm::MachineInstr::getDebugLoc
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:420
llvm::TargetRegisterInfo::getSpillSize
unsigned getSpillSize(const TargetRegisterClass &RC) const
Return the size in bytes of the stack slot allocated to hold a spilled copy of a register from class ...
Definition: TargetRegisterInfo.h:283
llvm::MachineFrameInfo::CreateFixedSpillStackObject
int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, bool IsImmutable=false)
Create a spill slot at a fixed location on the stack.
Definition: MachineFrameInfo.cpp:102
llvm::SystemZMC::ELFCFAOffsetFromInitialSP
const int64_t ELFCFAOffsetFromInitialSP
Definition: SystemZMCTargetDesc.h:34
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:66
llvm::MachineInstrBuilder
Definition: MachineInstrBuilder.h:69
SystemZMachineFunctionInfo.h
uint64_t
llvm::MachineFrameInfo::getObjectSize
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
Definition: MachineFrameInfo.h:469
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::SystemZXPLINKFrameLowering::emitEpilogue
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
Definition: SystemZFrameLowering.cpp:1226
llvm::Function::getCallingConv
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:238
llvm::SystemZELFFrameLowering::assignCalleeSavedSpillSlots
bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const override
Definition: SystemZFrameLowering.cpp:175
llvm::SystemZ::CCMASK_ICMP
const unsigned CCMASK_ICMP
Definition: SystemZ.h:47
llvm::HexagonInstrInfo::storeRegToStackSlot
void storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register SrcReg, bool isKill, int FrameIndex, const TargetRegisterClass *RC, const TargetRegisterInfo *TRI) const override
Store the specified register of the given register class to the specified stack frame index.
Definition: HexagonInstrInfo.cpp:955
llvm::MachinePointerInfo
This class contains a discriminated union of information about pointers in memory operands,...
Definition: MachineMemOperand.h:39
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::RegScavenger
Definition: RegisterScavenging.h:34
addSavedGPR
static void addSavedGPR(MachineBasicBlock &MBB, MachineInstrBuilder &MIB, unsigned GPR64, bool IsImplicit)
Definition: SystemZFrameLowering.cpp:312
llvm::MachineFunction::CreateMachineBasicBlock
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *bb=nullptr)
CreateMachineBasicBlock - Allocate a new MachineBasicBlock.
Definition: MachineFunction.cpp:439
llvm::MachineBasicBlock::getLastNonDebugInstr
iterator getLastNonDebugInstr(bool SkipPseudoOp=true)
Returns an iterator to the last non-debug instruction in the basic block, or end().
Definition: MachineBasicBlock.cpp:263
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:118
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MachineFrameInfo::CreateFixedObject
int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable, bool isAliased=false)
Create a new object at a fixed location on the stack.
Definition: MachineFrameInfo.cpp:83
llvm::SystemZELFFrameLowering::getRegSpillOffset
unsigned getRegSpillOffset(MachineFunction &MF, Register Reg) const
Definition: SystemZFrameLowering.cpp:861
llvm::MachineFunction::getFrameInfo
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Definition: MachineFunction.h:672
llvm::MachineBasicBlock::getParent
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
Definition: MachineBasicBlock.h:234
llvm::RegScavenger::addScavengingFrameIndex
void addScavengingFrameIndex(int FI)
Add a scavenging frame index.
Definition: RegisterScavenging.h:143
llvm::MachineInstrBuilder::addMemOperand
const MachineInstrBuilder & addMemOperand(MachineMemOperand *MMO) const
Definition: MachineInstrBuilder.h:202
llvm::MachineFunction::getLandingPads
const std::vector< LandingPadInfo > & getLandingPads() const
Return a reference to the landing pad info for the current function.
Definition: MachineFunction.h:1109
MachineModuleInfo.h
llvm::MachineInstrBuilder::addReg
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
Definition: MachineInstrBuilder.h:97
llvm::SystemZSubtarget
Definition: SystemZSubtarget.h:33
llvm::MachineFunction
Definition: MachineFunction.h:257
SystemZSubtarget.h
llvm::MachineFrameInfo::getCalleeSavedInfo
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
Definition: MachineFrameInfo.h:779
llvm::IndexedMap::grow
void grow(IndexT n)
Definition: IndexedMap.h:68
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::MachineFrameInfo::CreateStackObject
int CreateStackObject(uint64_t Size, Align Alignment, bool isSpillSlot, const AllocaInst *Alloca=nullptr, uint8_t ID=0)
Create a new statically sized stack object, returning a nonnegative identifier to represent it.
Definition: MachineFrameInfo.cpp:51
llvm::HexagonInstrInfo::loadRegFromStackSlot
void loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register DestReg, int FrameIndex, const TargetRegisterClass *RC, const TargetRegisterInfo *TRI) const override
Load the specified register of the given register class from the specified stack frame index.
Definition: HexagonInstrInfo.cpp:1000
MBBI
MachineBasicBlock MachineBasicBlock::iterator MBBI
Definition: AArch64SLSHardening.cpp:75
llvm::SystemZ::GPRRegs::LowGPR
unsigned LowGPR
Definition: SystemZMachineFunctionInfo.h:20
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::SystemZELFFrameLowering::getFrameIndexReference
StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const override
getFrameIndexReference - This method should return the base register and offset used to reference a f...
Definition: SystemZFrameLowering.cpp:852
uint32_t
llvm::StackOffset
StackOffset is a class to represent an offset with 2 dimensions, named fixed and scalable,...
Definition: TypeSize.h:134
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::SystemZXPLINKFrameLowering::emitPrologue
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
Definition: SystemZFrameLowering.cpp:1135
llvm::MCRegisterInfo
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Definition: MCRegisterInfo.h:135
llvm::MachineMemOperand::MOVolatile
@ MOVolatile
The memory access is volatile.
Definition: MachineMemOperand.h:138
llvm::StackOffset::getFixed
static StackOffset getFixed(ScalarTy Fixed)
Definition: TypeSize.h:143
llvm::MachineMemOperand::MOLoad
@ MOLoad
The memory access reads data.
Definition: MachineMemOperand.h:134
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::SystemZELFFrameLowering::emitEpilogue
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
Definition: SystemZFrameLowering.cpp:701
llvm::MachineBasicBlock::addLiveIn
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
Definition: MachineBasicBlock.h:377
llvm::MachineFrameInfo::hasCalls
bool hasCalls() const
Return true if the current function has any function calls.
Definition: MachineFrameInfo.h:605
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::isInt< 16 >
constexpr bool isInt< 16 >(int64_t x)
Definition: MathExtras.h:370
llvm::SystemZMachineFunctionInfo
Definition: SystemZMachineFunctionInfo.h:27
llvm::BitVector::test
bool test(unsigned Idx) const
Definition: BitVector.h:454
llvm::stable_sort
void stable_sort(R &&Range)
Definition: STLExtras.h:1761
llvm::SystemZELFFrameLowering::spillCalleeSavedRegisters
bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...
Definition: SystemZFrameLowering.cpp:325
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:622
llvm::CalleeSavedInfo
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
Definition: MachineFrameInfo.h:33
uint16_t
llvm::MachineFunction::getTarget
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Definition: MachineFunction.h:652
llvm::TargetFrameLowering::getFrameIndexReference
virtual StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const
getFrameIndexReference - This method should return the base register and offset used to reference a f...
Definition: TargetFrameLoweringImpl.cpp:50
llvm::MachineOperand::getIndex
int getIndex() const
Definition: MachineOperand.h:566
llvm::TargetLoweringBase::hasInlineStackProbe
virtual bool hasInlineStackProbe(MachineFunction &MF) const
Definition: TargetLowering.h:1878
llvm::SystemZXPLINKFrameLowering::hasFP
bool hasFP(const MachineFunction &MF) const override
hasFP - Return true if the specified function should have a dedicated frame pointer register.
Definition: SystemZFrameLowering.cpp:1316
Function.h
llvm::RegState::Define
@ Define
Register definition.
Definition: MachineInstrBuilder.h:44
llvm::SystemZELFFrameLowering::restoreCalleeSavedRegisters
bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBII, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
Definition: SystemZFrameLowering.cpp:385
llvm::SystemZSubtarget::getInstrInfo
const SystemZInstrInfo * getInstrInfo() const override
Definition: SystemZSubtarget.h:111
llvm::SystemZXPLINKFrameLowering::assignCalleeSavedSpillSlots
bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const override
Definition: SystemZFrameLowering.cpp:914
llvm::SystemZMachineFunctionInfo::getSpillGPRRegs
SystemZ::GPRRegs getSpillGPRRegs() const
Definition: SystemZMachineFunctionInfo.h:52
SystemZFrameLowering.h
llvm::SystemZFrameLowering
Definition: SystemZFrameLowering.h:22
llvm::SystemZXPLINKFrameLowering::inlineStackProbe
void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologMBB) const override
Replace a StackProbe stub (if any) with the actual probe code inline.
Definition: SystemZFrameLowering.cpp:1250
llvm::SystemZELFFrameLowering::getOrCreateFramePointerSaveIndex
int getOrCreateFramePointerSaveIndex(MachineFunction &MF) const
Definition: SystemZFrameLowering.cpp:878
llvm::Function::isVarArg
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
Definition: Function.h:188
llvm::getKillRegState
unsigned getKillRegState(bool B)
Definition: MachineInstrBuilder.h:508
llvm::MachineFunction::addFrameInst
LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst)
Definition: MachineFunction.cpp:310
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:105
SystemZRegisterInfo.h
llvm::TargetSubtargetInfo::getTargetLowering
virtual const TargetLowering * getTargetLowering() const
Definition: TargetSubtargetInfo.h:97
llvm::MachineBasicBlock::begin
iterator begin()
Definition: MachineBasicBlock.h:278
buildCFAOffs
static void buildCFAOffs(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, int Offset, const SystemZInstrInfo *ZII)
Definition: SystemZFrameLowering.cpp:513
llvm::BuildMI
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
Definition: MachineInstrBuilder.h:328
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
llvm::SmallVectorImpl< int >
llvm::SystemZELFFrameLowering::SystemZELFFrameLowering
SystemZELFFrameLowering()
Definition: SystemZFrameLowering.cpp:290
llvm::TargetRegisterInfo::getSubReg
MCRegister getSubReg(MCRegister Reg, unsigned Idx) const
Returns the physical register number of sub-register "Index" for physical register RegNo.
Definition: TargetRegisterInfo.h:1113
llvm::MachineFrameInfo::setOffsetAdjustment
void setOffsetAdjustment(int Adj)
Set the correction for frame offsets.
Definition: MachineFrameInfo.h:589
llvm::MCCFIInstruction::createOffset
static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int Offset)
.cfi_offset Previous value of Register is saved at offset Offset from CFA.
Definition: MCDwarf.h:564
llvm::TargetFrameLowering::determineCalleeSaves
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
Definition: TargetFrameLoweringImpl.cpp:83
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::TargetRegisterInfo::getMinimalPhysRegClass
const TargetRegisterClass * getMinimalPhysRegClass(MCRegister Reg, MVT VT=MVT::Other) const
Returns the Register Class of a physical register of the given type, picking the most sub register cl...
Definition: TargetRegisterInfo.cpp:212
RegisterScavenging.h
llvm::SystemZXPLINKFrameLowering::SystemZXPLINKFrameLowering
SystemZXPLINKFrameLowering()
Definition: SystemZFrameLowering.cpp:901
llvm::SystemZ::GPRRegs::HighGPR
unsigned HighGPR
Definition: SystemZMachineFunctionInfo.h:21
llvm::SystemZSubtarget::getSpecialRegisters
SystemZCallingConventionRegisters * getSpecialRegisters() const
Definition: SystemZSubtarget.h:94
llvm::CallingConv::GHC
@ GHC
Definition: CallingConv.h:51
llvm::MachineInstr::eraseFromParent
void eraseFromParent()
Unlink 'this' from the containing basic block and delete it.
Definition: MachineInstr.cpp:650
llvm::MachineInstrBundleIterator< MachineInstr >
llvm::getImplRegState
unsigned getImplRegState(bool B)
Definition: MachineInstrBuilder.h:505
llvm::TargetFrameLowering::SpillSlot
Definition: TargetFrameLowering.h:51
llvm::SystemZ::ELFNumArgGPRs
const unsigned ELFNumArgGPRs
Definition: SystemZCallingConv.h:19
llvm::SystemZMachineFunctionInfo::setFramePointerSaveIndex
void setFramePointerSaveIndex(int Idx)
Definition: SystemZMachineFunctionInfo.h:89
llvm::MachineBasicBlock::end
iterator end()
Definition: MachineBasicBlock.h:280
llvm::SystemZMC::ELFCallFrameSize
const int64_t ELFCallFrameSize
Definition: SystemZMCTargetDesc.h:31
LivePhysRegs.h
llvm::RegState::Undef
@ Undef
Value of the register doesn't matter.
Definition: MachineInstrBuilder.h:52