1 //===-- MSP430FrameLowering.cpp - MSP430 Frame Information ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains the MSP430 implementation of TargetFrameLowering class.
12 //===----------------------------------------------------------------------===//
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"
30 bool MSP430FrameLowering::hasFP(const MachineFunction &MF) const {
31 const MachineFrameInfo *MFI = MF.getFrameInfo();
33 return (MF.getTarget().Options.DisableFramePointerElim(MF) ||
34 MF.getFrameInfo()->hasVarSizedObjects() ||
35 MFI->isFrameAddressTaken());
38 bool MSP430FrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
39 return !MF.getFrameInfo()->hasVarSizedObjects();
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());
49 MachineBasicBlock::iterator MBBI = MBB.begin();
50 DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
52 // Get the number of bytes to allocate from the FrameInfo.
53 uint64_t StackSize = MFI->getStackSize();
55 uint64_t NumBytes = 0;
57 // Calculate required stack adjustment
58 uint64_t FrameSize = StackSize - 2;
59 NumBytes = FrameSize - MSP430FI->getCalleeSavedFrameSize();
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);
66 // Save FP into the appropriate stack slot...
67 BuildMI(MBB, MBBI, DL, TII.get(MSP430::PUSH16r))
68 .addReg(MSP430::FP, RegState::Kill);
70 // Update FP with the new base value...
71 BuildMI(MBB, MBBI, DL, TII.get(MSP430::MOV16rr), MSP430::FP)
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();
77 I->addLiveIn(MSP430::FP);
80 NumBytes = StackSize - MSP430FI->getCalleeSavedFrameSize();
82 // Skip the callee-saved push instructions.
83 while (MBBI != MBB.end() && (MBBI->getOpcode() == MSP430::PUSH16r))
86 if (MBBI != MBB.end())
87 DL = MBBI->getDebugLoc();
89 if (NumBytes) { // adjust stack pointer: SP -= numbytes
90 // If there is an SUB16ri of SP immediately before this instruction, merge
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);
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();
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());
114 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
115 unsigned RetOpcode = MBBI->getOpcode();
116 DebugLoc DL = MBBI->getDebugLoc();
120 case MSP430::RETI: break; // These are ok
122 llvm_unreachable("Can only insert epilog into returning blocks");
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;
131 // Calculate required stack adjustment
132 uint64_t FrameSize = StackSize - 2;
133 NumBytes = FrameSize - CSSize;
136 BuildMI(MBB, MBBI, DL, TII.get(MSP430::POP16r), MSP430::FP);
138 NumBytes = StackSize - CSSize;
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())
149 DL = MBBI->getDebugLoc();
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);
156 if (MFI->hasVarSizedObjects()) {
157 BuildMI(MBB, MBBI, DL,
158 TII.get(MSP430::MOV16rr), MSP430::SP).addReg(MSP430::FP);
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();
168 // adjust stack pointer back: SP += numbytes
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();
179 // FIXME: Can we eleminate these in favour of generic code?
181 MSP430FrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
182 MachineBasicBlock::iterator MI,
183 const std::vector<CalleeSavedInfo> &CSI,
184 const TargetRegisterInfo *TRI) const {
189 if (MI != MBB.end()) DL = MI->getDebugLoc();
191 MachineFunction &MF = *MBB.getParent();
192 const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
193 MSP430MachineFunctionInfo *MFI = MF.getInfo<MSP430MachineFunctionInfo>();
194 MFI->setCalleeSavedFrameSize(CSI.size() * 2);
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.
200 BuildMI(MBB, MI, DL, TII.get(MSP430::PUSH16r))
201 .addReg(Reg, RegState::Kill);
207 MSP430FrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
208 MachineBasicBlock::iterator MI,
209 const std::vector<CalleeSavedInfo> &CSI,
210 const TargetRegisterInfo *TRI) const {
215 if (MI != MBB.end()) DL = MI->getDebugLoc();
217 MachineFunction &MF = *MBB.getParent();
218 const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
220 for (unsigned i = 0, e = CSI.size(); i != e; ++i)
221 BuildMI(MBB, MI, DL, TII.get(MSP430::POP16r), CSI[i].getReg());
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();
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();
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;
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);
252 assert(Old->getOpcode() == TII.getCallFrameDestroyOpcode());
253 // factor out the amount the callee already popped.
254 uint64_t CalleeAmt = Old->getOperand(1).getImm();
257 New = BuildMI(MF, Old->getDebugLoc(),
258 TII.get(MSP430::ADD16ri), MSP430::SP)
259 .addReg(MSP430::SP).addImm(Amount);
263 // The SRW implicit def is dead.
264 New->getOperand(3).setIsDead();
266 // Replace the pseudo instruction with a new instruction...
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;
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();
289 MSP430FrameLowering::processFunctionBeforeFrameFinalized(MachineFunction &MF,
290 RegScavenger *) const {
291 // Create a frame entry for the FP register that must be saved.
293 int FrameIdx = MF.getFrameInfo()->CreateFixedObject(2, -4, true);
295 assert(FrameIdx == MF.getFrameInfo()->getObjectIndexBegin() &&
296 "Slot for FP register must be last in order to be found!");