Home | History | Annotate | Download | only in SystemZ 
      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 }
    387