lib/Target/MSP430/MSP430FrameLowering.cpp

   1 //===-- MSP430FrameLowering.cpp - MSP430 Frame Information ----------------===//
   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 MSP430 implementation of TargetFrameLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MSP430FrameLowering.h"
  15 #include "MSP430InstrInfo.h"
  16 #include "MSP430MachineFunctionInfo.h"
  17 #include "MSP430Subtarget.h"
  18 #include "llvm/CodeGen/MachineFrameInfo.h"
  19 #include "llvm/CodeGen/MachineFunction.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/MachineModuleInfo.h"
  22 #include "llvm/CodeGen/MachineRegisterInfo.h"
  23 #include "llvm/IR/DataLayout.h"
  24 #include "llvm/IR/Function.h"
  25 #include "llvm/Support/CommandLine.h"
  26 #include "llvm/Target/TargetOptions.h"
  27
  28 using namespace llvm;
  29
  30 bool MSP430FrameLowering::hasFP(const MachineFunction &MF) const {
  31   const MachineFrameInfo *MFI = MF.getFrameInfo();
  32
  33   return (MF.getTarget().Options.DisableFramePointerElim(MF) ||
  34           MF.getFrameInfo()->hasVarSizedObjects() ||
  35           MFI->isFrameAddressTaken());
  36 }
  37
  38 bool MSP430FrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
  39   return !MF.getFrameInfo()->hasVarSizedObjects();
  40 }
  41
  42 void MSP430FrameLowering::emitPrologue(MachineFunction &MF) const {
  43   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
  44   MachineFrameInfo *MFI = MF.getFrameInfo();
  45   MSP430MachineFunctionInfo *MSP430FI = MF.getInfo<MSP430MachineFunctionInfo>();
  46   const MSP430InstrInfo &TII =
  47       *static_cast<const MSP430InstrInfo *>(MF.getSubtarget().getInstrInfo());
  48
  49   MachineBasicBlock::iterator MBBI = MBB.begin();
  50   DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
  51
  52   // Get the number of bytes to allocate from the FrameInfo.
  53   uint64_t StackSize = MFI->getStackSize();
  54
  55   uint64_t NumBytes = 0;
  56   if (hasFP(MF)) {
  57     // Calculate required stack adjustment
  58     uint64_t FrameSize = StackSize - 2;
  59     NumBytes = FrameSize - MSP430FI->getCalleeSavedFrameSize();
  60
  61     // Get the offset of the stack slot for the EBP register... which is
  62     // guaranteed to be the last slot by processFunctionBeforeFrameFinalized.
  63     // Update the frame offset adjustment.
  64     MFI->setOffsetAdjustment(-NumBytes);
  65
  66     // Save FPW into the appropriate stack slot...
  67     BuildMI(MBB, MBBI, DL, TII.get(MSP430::PUSH16r))
  68       .addReg(MSP430::FPW, RegState::Kill);
  69
  70     // Update FPW with the new base value...
  71     BuildMI(MBB, MBBI, DL, TII.get(MSP430::MOV16rr), MSP430::FPW)
  72       .addReg(MSP430::SPW);
  73
  74     // Mark the FramePtr as live-in in every block except the entry.
  75     for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
  76          I != E; ++I)
  77       I->addLiveIn(MSP430::FPW);
  78
  79   } else
  80     NumBytes = StackSize - MSP430FI->getCalleeSavedFrameSize();
  81
  82   // Skip the callee-saved push instructions.
  83   while (MBBI != MBB.end() && (MBBI->getOpcode() == MSP430::PUSH16r))
  84     ++MBBI;
  85
  86   if (MBBI != MBB.end())
  87     DL = MBBI->getDebugLoc();
  88
  89   if (NumBytes) { // adjust stack pointer: SPW -= numbytes
  90     // If there is an SUB16ri of SPW immediately before this instruction, merge
  91     // the two.
  92     //NumBytes -= mergeSPUpdates(MBB, MBBI, true);
  93     // If there is an ADD16ri or SUB16ri of SPW immediately after this
  94     // instruction, merge the two instructions.
  95     // mergeSPUpdatesDown(MBB, MBBI, &NumBytes);
  96
  97     if (NumBytes) {
  98       MachineInstr *MI =
  99         BuildMI(MBB, MBBI, DL, TII.get(MSP430::SUB16ri), MSP430::SPW)
 100         .addReg(MSP430::SPW).addImm(NumBytes);
 101       // The SRW implicit def is dead.
 102       MI->getOperand(3).setIsDead();
 103     }
 104   }
 105 }
 106
 107 void MSP430FrameLowering::emitEpilogue(MachineFunction &MF,
 108                                        MachineBasicBlock &MBB) const {
 109   const MachineFrameInfo *MFI = MF.getFrameInfo();
 110   MSP430MachineFunctionInfo *MSP430FI = MF.getInfo<MSP430MachineFunctionInfo>();
 111   const MSP430InstrInfo &TII =
 112       *static_cast<const MSP430InstrInfo *>(MF.getSubtarget().getInstrInfo());
 113
 114   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 115   unsigned RetOpcode = MBBI->getOpcode();
 116   DebugLoc DL = MBBI->getDebugLoc();
 117
 118   switch (RetOpcode) {
 119   case MSP430::RET:
 120   case MSP430::RETI: break;  // These are ok
 121   default:
 122     llvm_unreachable("Can only insert epilog into returning blocks");
 123   }
 124
 125   // Get the number of bytes to allocate from the FrameInfo
 126   uint64_t StackSize = MFI->getStackSize();
 127   unsigned CSSize = MSP430FI->getCalleeSavedFrameSize();
 128   uint64_t NumBytes = 0;
 129
 130   if (hasFP(MF)) {
 131     // Calculate required stack adjustment
 132     uint64_t FrameSize = StackSize - 2;
 133     NumBytes = FrameSize - CSSize;
 134
 135     // pop FPW.
 136     BuildMI(MBB, MBBI, DL, TII.get(MSP430::POP16r), MSP430::FPW);
 137   } else
 138     NumBytes = StackSize - CSSize;
 139
 140   // Skip the callee-saved pop instructions.
 141   while (MBBI != MBB.begin()) {
 142     MachineBasicBlock::iterator PI = std::prev(MBBI);
 143     unsigned Opc = PI->getOpcode();
 144     if (Opc != MSP430::POP16r && !PI->isTerminator())
 145       break;
 146     --MBBI;
 147   }
 148
 149   DL = MBBI->getDebugLoc();
 150
 151   // If there is an ADD16ri or SUB16ri of SPW immediately before this
 152   // instruction, merge the two instructions.
 153   //if (NumBytes || MFI->hasVarSizedObjects())
 154   //  mergeSPUpdatesUp(MBB, MBBI, StackPtr, &NumBytes);
 155
 156   if (MFI->hasVarSizedObjects()) {
 157     BuildMI(MBB, MBBI, DL,
 158             TII.get(MSP430::MOV16rr), MSP430::SPW).addReg(MSP430::FPW);
 159     if (CSSize) {
 160       MachineInstr *MI =
 161         BuildMI(MBB, MBBI, DL,
 162                 TII.get(MSP430::SUB16ri), MSP430::SPW)
 163         .addReg(MSP430::SPW).addImm(CSSize);
 164       // The SRW implicit def is dead.
 165       MI->getOperand(3).setIsDead();
 166     }
 167   } else {
 168     // adjust stack pointer back: SPW += numbytes
 169     if (NumBytes) {
 170       MachineInstr *MI =
 171         BuildMI(MBB, MBBI, DL, TII.get(MSP430::ADD16ri), MSP430::SPW)
 172         .addReg(MSP430::SPW).addImm(NumBytes);
 173       // The SRW implicit def is dead.
 174       MI->getOperand(3).setIsDead();
 175     }
 176   }
 177 }
 178
 179 // FIXME: Can we eleminate these in favour of generic code?
 180 bool
 181 MSP430FrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
 182                                            MachineBasicBlock::iterator MI,
 183                                         const std::vector<CalleeSavedInfo> &CSI,
 184                                         const TargetRegisterInfo *TRI) const {
 185   if (CSI.empty())
 186     return false;
 187
 188   DebugLoc DL;
 189   if (MI != MBB.end()) DL = MI->getDebugLoc();
 190
 191   MachineFunction &MF = *MBB.getParent();
 192   const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
 193   MSP430MachineFunctionInfo *MFI = MF.getInfo<MSP430MachineFunctionInfo>();
 194   MFI->setCalleeSavedFrameSize(CSI.size() * 2);
 195
 196   for (unsigned i = CSI.size(); i != 0; --i) {
 197     unsigned Reg = CSI[i-1].getReg();
 198     // Add the callee-saved register as live-in. It's killed at the spill.
 199     MBB.addLiveIn(Reg);
 200     BuildMI(MBB, MI, DL, TII.get(MSP430::PUSH16r))
 201       .addReg(Reg, RegState::Kill);
 202   }
 203   return true;
 204 }
 205
 206 bool
 207 MSP430FrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
 208                                                  MachineBasicBlock::iterator MI,
 209                                         const std::vector<CalleeSavedInfo> &CSI,
 210                                         const TargetRegisterInfo *TRI) const {
 211   if (CSI.empty())
 212     return false;
 213
 214   DebugLoc DL;
 215   if (MI != MBB.end()) DL = MI->getDebugLoc();
 216
 217   MachineFunction &MF = *MBB.getParent();
 218   const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
 219
 220   for (unsigned i = 0, e = CSI.size(); i != e; ++i)
 221     BuildMI(MBB, MI, DL, TII.get(MSP430::POP16r), CSI[i].getReg());
 222
 223   return true;
 224 }
 225
 226 void MSP430FrameLowering::
 227 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
 228                               MachineBasicBlock::iterator I) const {
 229   const MSP430InstrInfo &TII =
 230       *static_cast<const MSP430InstrInfo *>(MF.getSubtarget().getInstrInfo());
 231   unsigned StackAlign = getStackAlignment();
 232
 233   if (!hasReservedCallFrame(MF)) {
 234     // If the stack pointer can be changed after prologue, turn the
 235     // adjcallstackup instruction into a 'sub SPW, <amt>' and the
 236     // adjcallstackdown instruction into 'add SPW, <amt>'
 237     // TODO: consider using push / pop instead of sub + store / add
 238     MachineInstr *Old = I;
 239     uint64_t Amount = Old->getOperand(0).getImm();
 240     if (Amount != 0) {
 241       // We need to keep the stack aligned properly.  To do this, we round the
 242       // amount of space needed for the outgoing arguments up to the next
 243       // alignment boundary.
 244       Amount = (Amount+StackAlign-1)/StackAlign*StackAlign;
 245
 246       MachineInstr *New = nullptr;
 247       if (Old->getOpcode() == TII.getCallFrameSetupOpcode()) {
 248         New = BuildMI(MF, Old->getDebugLoc(),
 249                       TII.get(MSP430::SUB16ri), MSP430::SPW)
 250           .addReg(MSP430::SPW).addImm(Amount);
 251       } else {
 252         assert(Old->getOpcode() == TII.getCallFrameDestroyOpcode());
 253         // factor out the amount the callee already popped.
 254         uint64_t CalleeAmt = Old->getOperand(1).getImm();
 255         Amount -= CalleeAmt;
 256         if (Amount)
 257           New = BuildMI(MF, Old->getDebugLoc(),
 258                         TII.get(MSP430::ADD16ri), MSP430::SPW)
 259             .addReg(MSP430::SPW).addImm(Amount);
 260       }
 261
 262       if (New) {
 263         // The SRW implicit def is dead.
 264         New->getOperand(3).setIsDead();
 265
 266         // Replace the pseudo instruction with a new instruction...
 267         MBB.insert(I, New);
 268       }
 269     }
 270   } else if (I->getOpcode() == TII.getCallFrameDestroyOpcode()) {
 271     // If we are performing frame pointer elimination and if the callee pops
 272     // something off the stack pointer, add it back.
 273     if (uint64_t CalleeAmt = I->getOperand(1).getImm()) {
 274       MachineInstr *Old = I;
 275       MachineInstr *New =
 276         BuildMI(MF, Old->getDebugLoc(), TII.get(MSP430::SUB16ri),
 277                 MSP430::SPW).addReg(MSP430::SPW).addImm(CalleeAmt);
 278       // The SRW implicit def is dead.
 279       New->getOperand(3).setIsDead();
 280
 281       MBB.insert(I, New);
 282     }
 283   }
 284
 285   MBB.erase(I);
 286 }
 287
 288 void
 289 MSP430FrameLowering::processFunctionBeforeFrameFinalized(MachineFunction &MF,
 290                                                          RegScavenger *) const {
 291   // Create a frame entry for the FPW register that must be saved.
 292   if (hasFP(MF)) {
 293     int FrameIdx = MF.getFrameInfo()->CreateFixedObject(2, -4, true);
 294     (void)FrameIdx;
 295     assert(FrameIdx == MF.getFrameInfo()->getObjectIndexBegin() &&
 296            "Slot for FPW register must be last in order to be found!");
 297   }
 298 }