[X86] Improve mul w/ overflow codegen, to MUL8+SETO.
[oota-llvm.git] / 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 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
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 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?
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 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
288 void
289 MSP430FrameLowering::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 }