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