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 } 299
