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
28using namespace llvm;
29
30bool 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
38bool MSP430FrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
39  return !MF.getFrameInfo()->hasVarSizedObjects();
40}
41
42void 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 FP into the appropriate stack slot...
67    BuildMI(MBB, MBBI, DL, TII.get(MSP430::PUSH16r))
68      .addReg(MSP430::FP, RegState::Kill);
69
70    // Update FP with the new base value...
71    BuildMI(MBB, MBBI, DL, TII.get(MSP430::MOV16rr), MSP430::FP)
72      .addReg(MSP430::SP);
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::FP);
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: SP -= numbytes
90    // If there is an SUB16ri of SP immediately before this instruction, merge
91    // the two.
92    //NumBytes -= mergeSPUpdates(MBB, MBBI, true);
93    // If there is an ADD16ri or SUB16ri of SP 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::SP)
100        .addReg(MSP430::SP).addImm(NumBytes);
101      // The SRW implicit def is dead.
102      MI->getOperand(3).setIsDead();
103    }
104  }
105}
106
107void 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 FP.
136    BuildMI(MBB, MBBI, DL, TII.get(MSP430::POP16r), MSP430::FP);
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 SP 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::SP).addReg(MSP430::FP);
159    if (CSSize) {
160      MachineInstr *MI =
161        BuildMI(MBB, MBBI, DL,
162                TII.get(MSP430::SUB16ri), MSP430::SP)
163        .addReg(MSP430::SP).addImm(CSSize);
164      // The SRW implicit def is dead.
165      MI->getOperand(3).setIsDead();
166    }
167  } else {
168    // adjust stack pointer back: SP += numbytes
169    if (NumBytes) {
170      MachineInstr *MI =
171        BuildMI(MBB, MBBI, DL, TII.get(MSP430::ADD16ri), MSP430::SP)
172        .addReg(MSP430::SP).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?
180bool
181MSP430FrameLowering::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
206bool
207MSP430FrameLowering::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
226void MSP430FrameLowering::
227eliminateCallFramePseudoInstr(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 SP, <amt>' and the
236    // adjcallstackdown instruction into 'add SP, <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::SP)
250          .addReg(MSP430::SP).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::SP)
259            .addReg(MSP430::SP).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::SP).addReg(MSP430::SP).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
288void
289MSP430FrameLowering::processFunctionBeforeFrameFinalized(MachineFunction &MF,
290                                                         RegScavenger *) const {
291  // Create a frame entry for the FP 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 FP register must be last in order to be found!");
297  }
298}
299