contrib/llvm/lib/Target/SystemZ/SystemZFrameLowering.cpp

   1 //=====- SystemZFrameLowering.cpp - SystemZ Frame Information ------*- C++ -*-====//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the SystemZ implementation of TargetFrameLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "SystemZFrameLowering.h"
  15 #include "SystemZInstrBuilder.h"
  16 #include "SystemZInstrInfo.h"
  17 #include "SystemZMachineFunctionInfo.h"
  18 #include "llvm/Function.h"
  19 #include "llvm/CodeGen/MachineFrameInfo.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineInstrBuilder.h"
  22 #include "llvm/CodeGen/MachineModuleInfo.h"
  23 #include "llvm/CodeGen/MachineRegisterInfo.h"
  24 #include "llvm/Target/TargetData.h"
  25 #include "llvm/Target/TargetOptions.h"
  26 #include "llvm/Support/CommandLine.h"
  27
  28 using namespace llvm;
  29
  30 SystemZFrameLowering::SystemZFrameLowering(const SystemZSubtarget &sti)
  31   : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 8, -160), STI(sti) {
  32   // Fill the spill offsets map
  33   static const unsigned SpillOffsTab[][2] = {
  34     { SystemZ::R2D,  0x10 },
  35     { SystemZ::R3D,  0x18 },
  36     { SystemZ::R4D,  0x20 },
  37     { SystemZ::R5D,  0x28 },
  38     { SystemZ::R6D,  0x30 },
  39     { SystemZ::R7D,  0x38 },
  40     { SystemZ::R8D,  0x40 },
  41     { SystemZ::R9D,  0x48 },
  42     { SystemZ::R10D, 0x50 },
  43     { SystemZ::R11D, 0x58 },
  44     { SystemZ::R12D, 0x60 },
  45     { SystemZ::R13D, 0x68 },
  46     { SystemZ::R14D, 0x70 },
  47     { SystemZ::R15D, 0x78 }
  48   };
  49
  50   RegSpillOffsets.grow(SystemZ::NUM_TARGET_REGS);
  51
  52   for (unsigned i = 0, e = array_lengthof(SpillOffsTab); i != e; ++i)
  53     RegSpillOffsets[SpillOffsTab[i][0]] = SpillOffsTab[i][1];
  54 }
  55
  56 /// needsFP - Return true if the specified function should have a dedicated
  57 /// frame pointer register.  This is true if the function has variable sized
  58 /// allocas or if frame pointer elimination is disabled.
  59 bool SystemZFrameLowering::hasFP(const MachineFunction &MF) const {
  60   const MachineFrameInfo *MFI = MF.getFrameInfo();
  61   return DisableFramePointerElim(MF) || MFI->hasVarSizedObjects();
  62 }
  63
  64 /// emitSPUpdate - Emit a series of instructions to increment / decrement the
  65 /// stack pointer by a constant value.
  66 static
  67 void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
  68                   int64_t NumBytes, const TargetInstrInfo &TII) {
  69   unsigned Opc; uint64_t Chunk;
  70   bool isSub = NumBytes < 0;
  71   uint64_t Offset = isSub ? -NumBytes : NumBytes;
  72
  73   if (Offset >= (1LL << 15) - 1) {
  74     Opc = SystemZ::ADD64ri32;
  75     Chunk = (1LL << 31) - 1;
  76   } else {
  77     Opc = SystemZ::ADD64ri16;
  78     Chunk = (1LL << 15) - 1;
  79   }
  80
  81   DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
  82
  83   while (Offset) {
  84     uint64_t ThisVal = (Offset > Chunk) ? Chunk : Offset;
  85     MachineInstr *MI =
  86       BuildMI(MBB, MBBI, DL, TII.get(Opc), SystemZ::R15D)
  87       .addReg(SystemZ::R15D).addImm(isSub ? -ThisVal : ThisVal);
  88     // The PSW implicit def is dead.
  89     MI->getOperand(3).setIsDead();
  90     Offset -= ThisVal;
  91   }
  92 }
  93
  94 void SystemZFrameLowering::emitPrologue(MachineFunction &MF) const {
  95   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
  96   MachineFrameInfo *MFI = MF.getFrameInfo();
  97   const SystemZInstrInfo &TII =
  98     *static_cast<const SystemZInstrInfo*>(MF.getTarget().getInstrInfo());
  99   SystemZMachineFunctionInfo *SystemZMFI =
 100     MF.getInfo<SystemZMachineFunctionInfo>();
 101   MachineBasicBlock::iterator MBBI = MBB.begin();
 102   DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
 103
 104   // Get the number of bytes to allocate from the FrameInfo.
 105   // Note that area for callee-saved stuff is already allocated, thus we need to
 106   // 'undo' the stack movement.
 107   uint64_t StackSize = MFI->getStackSize();
 108   StackSize -= SystemZMFI->getCalleeSavedFrameSize();
 109
 110   uint64_t NumBytes = StackSize - getOffsetOfLocalArea();
 111
 112   // Skip the callee-saved push instructions.
 113   while (MBBI != MBB.end() &&
 114          (MBBI->getOpcode() == SystemZ::MOV64mr ||
 115           MBBI->getOpcode() == SystemZ::MOV64mrm))
 116     ++MBBI;
 117
 118   if (MBBI != MBB.end())
 119     DL = MBBI->getDebugLoc();
 120
 121   // adjust stack pointer: R15 -= numbytes
 122   if (StackSize || MFI->hasCalls()) {
 123     assert(MF.getRegInfo().isPhysRegUsed(SystemZ::R15D) &&
 124            "Invalid stack frame calculation!");
 125     emitSPUpdate(MBB, MBBI, -(int64_t)NumBytes, TII);
 126   }
 127
 128   if (hasFP(MF)) {
 129     // Update R11 with the new base value...
 130     BuildMI(MBB, MBBI, DL, TII.get(SystemZ::MOV64rr), SystemZ::R11D)
 131       .addReg(SystemZ::R15D);
 132
 133     // Mark the FramePtr as live-in in every block except the entry.
 134     for (MachineFunction::iterator I = llvm::next(MF.begin()), E = MF.end();
 135          I != E; ++I)
 136       I->addLiveIn(SystemZ::R11D);
 137
 138   }
 139 }
 140
 141 void SystemZFrameLowering::emitEpilogue(MachineFunction &MF,
 142                                     MachineBasicBlock &MBB) const {
 143   const MachineFrameInfo *MFI = MF.getFrameInfo();
 144   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 145   const SystemZInstrInfo &TII =
 146     *static_cast<const SystemZInstrInfo*>(MF.getTarget().getInstrInfo());
 147   SystemZMachineFunctionInfo *SystemZMFI =
 148     MF.getInfo<SystemZMachineFunctionInfo>();
 149   unsigned RetOpcode = MBBI->getOpcode();
 150
 151   switch (RetOpcode) {
 152   case SystemZ::RET: break;  // These are ok
 153   default:
 154     assert(0 && "Can only insert epilog into returning blocks");
 155   }
 156
 157   // Get the number of bytes to allocate from the FrameInfo
 158   // Note that area for callee-saved stuff is already allocated, thus we need to
 159   // 'undo' the stack movement.
 160   uint64_t StackSize =
 161     MFI->getStackSize() - SystemZMFI->getCalleeSavedFrameSize();
 162   uint64_t NumBytes = StackSize - getOffsetOfLocalArea();
 163
 164   // Skip the final terminator instruction.
 165   while (MBBI != MBB.begin()) {
 166     MachineBasicBlock::iterator PI = prior(MBBI);
 167     --MBBI;
 168     if (!PI->getDesc().isTerminator())
 169       break;
 170   }
 171
 172   // During callee-saved restores emission stack frame was not yet finialized
 173   // (and thus - the stack size was unknown). Tune the offset having full stack
 174   // size in hands.
 175   if (StackSize || MFI->hasCalls()) {
 176     assert((MBBI->getOpcode() == SystemZ::MOV64rmm ||
 177             MBBI->getOpcode() == SystemZ::MOV64rm) &&
 178            "Expected to see callee-save register restore code");
 179     assert(MF.getRegInfo().isPhysRegUsed(SystemZ::R15D) &&
 180            "Invalid stack frame calculation!");
 181
 182     unsigned i = 0;
 183     MachineInstr &MI = *MBBI;
 184     while (!MI.getOperand(i).isImm()) {
 185       ++i;
 186       assert(i < MI.getNumOperands() && "Unexpected restore code!");
 187     }
 188
 189     uint64_t Offset = NumBytes + MI.getOperand(i).getImm();
 190     // If Offset does not fit into 20-bit signed displacement field we need to
 191     // emit some additional code...
 192     if (Offset > 524287) {
 193       // Fold the displacement into load instruction as much as possible.
 194       NumBytes = Offset - 524287;
 195       Offset = 524287;
 196       emitSPUpdate(MBB, MBBI, NumBytes, TII);
 197     }
 198
 199     MI.getOperand(i).ChangeToImmediate(Offset);
 200   }
 201 }
 202
 203 int SystemZFrameLowering::getFrameIndexOffset(const MachineFunction &MF,
 204                                           int FI) const {
 205   const MachineFrameInfo *MFI = MF.getFrameInfo();
 206   const SystemZMachineFunctionInfo *SystemZMFI =
 207     MF.getInfo<SystemZMachineFunctionInfo>();
 208   int Offset = MFI->getObjectOffset(FI) + MFI->getOffsetAdjustment();
 209   uint64_t StackSize = MFI->getStackSize();
 210
 211   // Fixed objects are really located in the "previous" frame.
 212   if (FI < 0)
 213     StackSize -= SystemZMFI->getCalleeSavedFrameSize();
 214
 215   Offset += StackSize - getOffsetOfLocalArea();
 216
 217   // Skip the register save area if we generated the stack frame.
 218   if (StackSize || MFI->hasCalls())
 219     Offset -= getOffsetOfLocalArea();
 220
 221   return Offset;
 222 }
 223
 224 bool
 225 SystemZFrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
 226                                             MachineBasicBlock::iterator MI,
 227                                         const std::vector<CalleeSavedInfo> &CSI,
 228                                           const TargetRegisterInfo *TRI) const {
 229   if (CSI.empty())
 230     return false;
 231
 232   DebugLoc DL;
 233   if (MI != MBB.end()) DL = MI->getDebugLoc();
 234
 235   MachineFunction &MF = *MBB.getParent();
 236   const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
 237   SystemZMachineFunctionInfo *MFI = MF.getInfo<SystemZMachineFunctionInfo>();
 238   unsigned CalleeFrameSize = 0;
 239
 240   // Scan the callee-saved and find the bounds of register spill area.
 241   unsigned LowReg = 0, HighReg = 0, StartOffset = -1U, EndOffset = 0;
 242   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 243     unsigned Reg = CSI[i].getReg();
 244     if (!SystemZ::FP64RegClass.contains(Reg)) {
 245       unsigned Offset = RegSpillOffsets[Reg];
 246       CalleeFrameSize += 8;
 247       if (StartOffset > Offset) {
 248         LowReg = Reg; StartOffset = Offset;
 249       }
 250       if (EndOffset < Offset) {
 251         HighReg = Reg; EndOffset = RegSpillOffsets[Reg];
 252       }
 253     }
 254   }
 255
 256   // Save information for epilogue inserter.
 257   MFI->setCalleeSavedFrameSize(CalleeFrameSize);
 258   MFI->setLowReg(LowReg); MFI->setHighReg(HighReg);
 259
 260   // Save GPRs
 261   if (StartOffset) {
 262     // Build a store instruction. Use STORE MULTIPLE instruction if there are many
 263     // registers to store, otherwise - just STORE.
 264     MachineInstrBuilder MIB =
 265       BuildMI(MBB, MI, DL, TII.get((LowReg == HighReg ?
 266                                     SystemZ::MOV64mr : SystemZ::MOV64mrm)));
 267
 268     // Add store operands.
 269     MIB.addReg(SystemZ::R15D).addImm(StartOffset);
 270     if (LowReg == HighReg)
 271       MIB.addReg(0);
 272     MIB.addReg(LowReg, RegState::Kill);
 273     if (LowReg != HighReg)
 274       MIB.addReg(HighReg, RegState::Kill);
 275
 276     // Do a second scan adding regs as being killed by instruction
 277     for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 278       unsigned Reg = CSI[i].getReg();
 279       // Add the callee-saved register as live-in. It's killed at the spill.
 280       MBB.addLiveIn(Reg);
 281       if (Reg != LowReg && Reg != HighReg)
 282         MIB.addReg(Reg, RegState::ImplicitKill);
 283     }
 284   }
 285
 286   // Save FPRs
 287   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 288     unsigned Reg = CSI[i].getReg();
 289     if (SystemZ::FP64RegClass.contains(Reg)) {
 290       MBB.addLiveIn(Reg);
 291       TII.storeRegToStackSlot(MBB, MI, Reg, true, CSI[i].getFrameIdx(),
 292                               &SystemZ::FP64RegClass, TRI);
 293     }
 294   }
 295
 296   return true;
 297 }
 298
 299 bool
 300 SystemZFrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
 301                                               MachineBasicBlock::iterator MI,
 302                                         const std::vector<CalleeSavedInfo> &CSI,
 303                                           const TargetRegisterInfo *TRI) const {
 304   if (CSI.empty())
 305     return false;
 306
 307   DebugLoc DL;
 308   if (MI != MBB.end()) DL = MI->getDebugLoc();
 309
 310   MachineFunction &MF = *MBB.getParent();
 311   const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
 312   SystemZMachineFunctionInfo *MFI = MF.getInfo<SystemZMachineFunctionInfo>();
 313
 314   // Restore FP registers
 315   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 316     unsigned Reg = CSI[i].getReg();
 317     if (SystemZ::FP64RegClass.contains(Reg))
 318       TII.loadRegFromStackSlot(MBB, MI, Reg, CSI[i].getFrameIdx(),
 319                                &SystemZ::FP64RegClass, TRI);
 320   }
 321
 322   // Restore GP registers
 323   unsigned LowReg = MFI->getLowReg(), HighReg = MFI->getHighReg();
 324   unsigned StartOffset = RegSpillOffsets[LowReg];
 325
 326   if (StartOffset) {
 327     // Build a load instruction. Use LOAD MULTIPLE instruction if there are many
 328     // registers to load, otherwise - just LOAD.
 329     MachineInstrBuilder MIB =
 330       BuildMI(MBB, MI, DL, TII.get((LowReg == HighReg ?
 331                                     SystemZ::MOV64rm : SystemZ::MOV64rmm)));
 332     // Add store operands.
 333     MIB.addReg(LowReg, RegState::Define);
 334     if (LowReg != HighReg)
 335       MIB.addReg(HighReg, RegState::Define);
 336
 337     MIB.addReg(hasFP(MF) ? SystemZ::R11D : SystemZ::R15D);
 338     MIB.addImm(StartOffset);
 339     if (LowReg == HighReg)
 340       MIB.addReg(0);
 341
 342     // Do a second scan adding regs as being defined by instruction
 343     for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 344       unsigned Reg = CSI[i].getReg();
 345       if (Reg != LowReg && Reg != HighReg)
 346         MIB.addReg(Reg, RegState::ImplicitDefine);
 347     }
 348   }
 349
 350   return true;
 351 }
 352
 353 void
 354 SystemZFrameLowering::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
 355                                                        RegScavenger *RS) const {
 356   // Determine whether R15/R14 will ever be clobbered inside the function. And
 357   // if yes - mark it as 'callee' saved.
 358   MachineFrameInfo *FFI = MF.getFrameInfo();
 359   MachineRegisterInfo &MRI = MF.getRegInfo();
 360
 361   // Check whether high FPRs are ever used, if yes - we need to save R15 as
 362   // well.
 363   static const unsigned HighFPRs[] = {
 364     SystemZ::F8L,  SystemZ::F9L,  SystemZ::F10L, SystemZ::F11L,
 365     SystemZ::F12L, SystemZ::F13L, SystemZ::F14L, SystemZ::F15L,
 366     SystemZ::F8S,  SystemZ::F9S,  SystemZ::F10S, SystemZ::F11S,
 367     SystemZ::F12S, SystemZ::F13S, SystemZ::F14S, SystemZ::F15S,
 368   };
 369
 370   bool HighFPRsUsed = false;
 371   for (unsigned i = 0, e = array_lengthof(HighFPRs); i != e; ++i)
 372     HighFPRsUsed |= MRI.isPhysRegUsed(HighFPRs[i]);
 373
 374   if (FFI->hasCalls())
 375     /* FIXME: function is varargs */
 376     /* FIXME: function grabs RA */
 377     /* FIXME: function calls eh_return */
 378     MRI.setPhysRegUsed(SystemZ::R14D);
 379
 380   if (HighFPRsUsed ||
 381       FFI->hasCalls() ||
 382       FFI->getObjectIndexEnd() != 0 || // Contains automatic variables
 383       FFI->hasVarSizedObjects() // Function calls dynamic alloca's
 384       /* FIXME: function is varargs */)
 385     MRI.setPhysRegUsed(SystemZ::R15D);
 386 }