LLVM API Documentation
00001 //===- XCoreRegisterInfo.cpp - XCore Register Information -------*- C++ -*-===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file contains the XCore implementation of the MRegisterInfo class. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #include "XCoreRegisterInfo.h" 00015 #include "XCoreMachineFunctionInfo.h" 00016 #include "XCore.h" 00017 #include "llvm/CodeGen/MachineInstrBuilder.h" 00018 #include "llvm/CodeGen/MachineFunction.h" 00019 #include "llvm/CodeGen/MachineFrameInfo.h" 00020 #include "llvm/CodeGen/MachineLocation.h" 00021 #include "llvm/CodeGen/MachineModuleInfo.h" 00022 #include "llvm/CodeGen/MachineRegisterInfo.h" 00023 #include "llvm/CodeGen/RegisterScavenging.h" 00024 #include "llvm/Target/TargetFrameInfo.h" 00025 #include "llvm/Target/TargetMachine.h" 00026 #include "llvm/Target/TargetOptions.h" 00027 #include "llvm/Target/TargetInstrInfo.h" 00028 #include "llvm/Type.h" 00029 #include "llvm/Function.h" 00030 #include "llvm/ADT/BitVector.h" 00031 #include "llvm/ADT/STLExtras.h" 00032 #include "llvm/Support/Debug.h" 00033 #include "llvm/Support/ErrorHandling.h" 00034 #include "llvm/Support/raw_ostream.h" 00035 00036 using namespace llvm; 00037 00038 XCoreRegisterInfo::XCoreRegisterInfo(const TargetInstrInfo &tii) 00039 : XCoreGenRegisterInfo(XCore::ADJCALLSTACKDOWN, XCore::ADJCALLSTACKUP), 00040 TII(tii) { 00041 } 00042 00043 // helper functions 00044 static inline bool isImmUs(unsigned val) { 00045 return val <= 11; 00046 } 00047 00048 static inline bool isImmU6(unsigned val) { 00049 return val < (1 << 6); 00050 } 00051 00052 static inline bool isImmU16(unsigned val) { 00053 return val < (1 << 16); 00054 } 00055 00056 static const unsigned XCore_ArgRegs[] = { 00057 XCore::R0, XCore::R1, XCore::R2, XCore::R3 00058 }; 00059 00060 const unsigned * XCoreRegisterInfo::getArgRegs(const MachineFunction *MF) 00061 { 00062 return XCore_ArgRegs; 00063 } 00064 00065 unsigned XCoreRegisterInfo::getNumArgRegs(const MachineFunction *MF) 00066 { 00067 return array_lengthof(XCore_ArgRegs); 00068 } 00069 00070 bool XCoreRegisterInfo::needsFrameMoves(const MachineFunction &MF) 00071 { 00072 const MachineFrameInfo *MFI = MF.getFrameInfo(); 00073 MachineModuleInfo *MMI = MFI->getMachineModuleInfo(); 00074 return (MMI && MMI->hasDebugInfo()) || 00075 !MF.getFunction()->doesNotThrow() || 00076 UnwindTablesMandatory; 00077 } 00078 00079 const unsigned* XCoreRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) 00080 const { 00081 static const unsigned CalleeSavedRegs[] = { 00082 XCore::R4, XCore::R5, XCore::R6, XCore::R7, 00083 XCore::R8, XCore::R9, XCore::R10, XCore::LR, 00084 0 00085 }; 00086 return CalleeSavedRegs; 00087 } 00088 00089 const TargetRegisterClass* const* 00090 XCoreRegisterInfo::getCalleeSavedRegClasses(const MachineFunction *MF) const { 00091 static const TargetRegisterClass * const CalleeSavedRegClasses[] = { 00092 XCore::GRRegsRegisterClass, XCore::GRRegsRegisterClass, 00093 XCore::GRRegsRegisterClass, XCore::GRRegsRegisterClass, 00094 XCore::GRRegsRegisterClass, XCore::GRRegsRegisterClass, 00095 XCore::GRRegsRegisterClass, XCore::RRegsRegisterClass, 00096 0 00097 }; 00098 return CalleeSavedRegClasses; 00099 } 00100 00101 BitVector XCoreRegisterInfo::getReservedRegs(const MachineFunction &MF) const { 00102 BitVector Reserved(getNumRegs()); 00103 Reserved.set(XCore::CP); 00104 Reserved.set(XCore::DP); 00105 Reserved.set(XCore::SP); 00106 Reserved.set(XCore::LR); 00107 if (hasFP(MF)) { 00108 Reserved.set(XCore::R10); 00109 } 00110 return Reserved; 00111 } 00112 00113 bool 00114 XCoreRegisterInfo::requiresRegisterScavenging(const MachineFunction &MF) const { 00115 // TODO can we estimate stack size? 00116 return hasFP(MF); 00117 } 00118 00119 bool XCoreRegisterInfo::hasFP(const MachineFunction &MF) const { 00120 return NoFramePointerElim || MF.getFrameInfo()->hasVarSizedObjects(); 00121 } 00122 00123 // This function eliminates ADJCALLSTACKDOWN, 00124 // ADJCALLSTACKUP pseudo instructions 00125 void XCoreRegisterInfo:: 00126 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, 00127 MachineBasicBlock::iterator I) const { 00128 if (!hasReservedCallFrame(MF)) { 00129 // Turn the adjcallstackdown instruction into 'extsp <amt>' and the 00130 // adjcallstackup instruction into 'ldaw sp, sp[<amt>]' 00131 MachineInstr *Old = I; 00132 uint64_t Amount = Old->getOperand(0).getImm(); 00133 if (Amount != 0) { 00134 // We need to keep the stack aligned properly. To do this, we round the 00135 // amount of space needed for the outgoing arguments up to the next 00136 // alignment boundary. 00137 unsigned Align = MF.getTarget().getFrameInfo()->getStackAlignment(); 00138 Amount = (Amount+Align-1)/Align*Align; 00139 00140 assert(Amount%4 == 0); 00141 Amount /= 4; 00142 00143 bool isU6 = isImmU6(Amount); 00144 00145 if (!isU6 && !isImmU16(Amount)) { 00146 // FIX could emit multiple instructions in this case. 00147 #ifndef NDEBUG 00148 cerr << "eliminateCallFramePseudoInstr size too big: " 00149 << Amount << "\n"; 00150 #endif 00151 llvm_unreachable(0); 00152 } 00153 00154 MachineInstr *New; 00155 if (Old->getOpcode() == XCore::ADJCALLSTACKDOWN) { 00156 int Opcode = isU6 ? XCore::EXTSP_u6 : XCore::EXTSP_lu6; 00157 New=BuildMI(MF, Old->getDebugLoc(), TII.get(Opcode)) 00158 .addImm(Amount); 00159 } else { 00160 assert(Old->getOpcode() == XCore::ADJCALLSTACKUP); 00161 int Opcode = isU6 ? XCore::LDAWSP_ru6_RRegs : XCore::LDAWSP_lru6_RRegs; 00162 New=BuildMI(MF, Old->getDebugLoc(), TII.get(Opcode), XCore::SP) 00163 .addImm(Amount); 00164 } 00165 00166 // Replace the pseudo instruction with a new instruction... 00167 MBB.insert(I, New); 00168 } 00169 } 00170 00171 MBB.erase(I); 00172 } 00173 00174 void XCoreRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II, 00175 int SPAdj, RegScavenger *RS) const { 00176 assert(SPAdj == 0 && "Unexpected"); 00177 MachineInstr &MI = *II; 00178 DebugLoc dl = MI.getDebugLoc(); 00179 unsigned i = 0; 00180 00181 while (!MI.getOperand(i).isFI()) { 00182 ++i; 00183 assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!"); 00184 } 00185 00186 MachineOperand &FrameOp = MI.getOperand(i); 00187 int FrameIndex = FrameOp.getIndex(); 00188 00189 MachineFunction &MF = *MI.getParent()->getParent(); 00190 int Offset = MF.getFrameInfo()->getObjectOffset(FrameIndex); 00191 int StackSize = MF.getFrameInfo()->getStackSize(); 00192 00193 #ifndef NDEBUG 00194 DEBUG(errs() << "\nFunction : " 00195 << MF.getFunction()->getName() << "\n"); 00196 DOUT << "<--------->\n"; 00197 MI.print(DOUT); 00198 DOUT << "FrameIndex : " << FrameIndex << "\n"; 00199 DOUT << "FrameOffset : " << Offset << "\n"; 00200 DOUT << "StackSize : " << StackSize << "\n"; 00201 #endif 00202 00203 Offset += StackSize; 00204 00205 // fold constant into offset. 00206 Offset += MI.getOperand(i + 1).getImm(); 00207 MI.getOperand(i + 1).ChangeToImmediate(0); 00208 00209 assert(Offset%4 == 0 && "Misaligned stack offset"); 00210 00211 #ifndef NDEBUG 00212 DOUT << "Offset : " << Offset << "\n"; 00213 DOUT << "<--------->\n"; 00214 #endif 00215 00216 Offset/=4; 00217 00218 bool FP = hasFP(MF); 00219 00220 unsigned Reg = MI.getOperand(0).getReg(); 00221 bool isKill = MI.getOpcode() == XCore::STWFI && MI.getOperand(0).isKill(); 00222 00223 assert(XCore::GRRegsRegisterClass->contains(Reg) && 00224 "Unexpected register operand"); 00225 00226 MachineBasicBlock &MBB = *MI.getParent(); 00227 00228 if (FP) { 00229 bool isUs = isImmUs(Offset); 00230 unsigned FramePtr = XCore::R10; 00231 00232 MachineInstr *New = 0; 00233 if (!isUs) { 00234 if (!RS) { 00235 std::string msg; 00236 raw_string_ostream Msg(msg); 00237 Msg << "eliminateFrameIndex Frame size too big: " << Offset; 00238 llvm_report_error(Msg.str()); 00239 } 00240 unsigned ScratchReg = RS->scavengeRegister(XCore::GRRegsRegisterClass, II, 00241 SPAdj); 00242 loadConstant(MBB, II, ScratchReg, Offset, dl); 00243 switch (MI.getOpcode()) { 00244 case XCore::LDWFI: 00245 New = BuildMI(MBB, II, dl, TII.get(XCore::LDW_3r), Reg) 00246 .addReg(FramePtr) 00247 .addReg(ScratchReg, RegState::Kill); 00248 break; 00249 case XCore::STWFI: 00250 New = BuildMI(MBB, II, dl, TII.get(XCore::STW_3r)) 00251 .addReg(Reg, getKillRegState(isKill)) 00252 .addReg(FramePtr) 00253 .addReg(ScratchReg, RegState::Kill); 00254 break; 00255 case XCore::LDAWFI: 00256 New = BuildMI(MBB, II, dl, TII.get(XCore::LDAWF_l3r), Reg) 00257 .addReg(FramePtr) 00258 .addReg(ScratchReg, RegState::Kill); 00259 break; 00260 default: 00261 llvm_unreachable("Unexpected Opcode"); 00262 } 00263 } else { 00264 switch (MI.getOpcode()) { 00265 case XCore::LDWFI: 00266 New = BuildMI(MBB, II, dl, TII.get(XCore::LDW_2rus), Reg) 00267 .addReg(FramePtr) 00268 .addImm(Offset); 00269 break; 00270 case XCore::STWFI: 00271 New = BuildMI(MBB, II, dl, TII.get(XCore::STW_2rus)) 00272 .addReg(Reg, getKillRegState(isKill)) 00273 .addReg(FramePtr) 00274 .addImm(Offset); 00275 break; 00276 case XCore::LDAWFI: 00277 New = BuildMI(MBB, II, dl, TII.get(XCore::LDAWF_l2rus), Reg) 00278 .addReg(FramePtr) 00279 .addImm(Offset); 00280 break; 00281 default: 00282 llvm_unreachable("Unexpected Opcode"); 00283 } 00284 } 00285 } else { 00286 bool isU6 = isImmU6(Offset); 00287 if (!isU6 && !isImmU16(Offset)) { 00288 std::string msg; 00289 raw_string_ostream Msg(msg); 00290 Msg << "eliminateFrameIndex Frame size too big: " << Offset; 00291 llvm_report_error(Msg.str()); 00292 } 00293 00294 switch (MI.getOpcode()) { 00295 int NewOpcode; 00296 case XCore::LDWFI: 00297 NewOpcode = (isU6) ? XCore::LDWSP_ru6 : XCore::LDWSP_lru6; 00298 BuildMI(MBB, II, dl, TII.get(NewOpcode), Reg) 00299 .addImm(Offset); 00300 break; 00301 case XCore::STWFI: 00302 NewOpcode = (isU6) ? XCore::STWSP_ru6 : XCore::STWSP_lru6; 00303 BuildMI(MBB, II, dl, TII.get(NewOpcode)) 00304 .addReg(Reg, getKillRegState(isKill)) 00305 .addImm(Offset); 00306 break; 00307 case XCore::LDAWFI: 00308 NewOpcode = (isU6) ? XCore::LDAWSP_ru6 : XCore::LDAWSP_lru6; 00309 BuildMI(MBB, II, dl, TII.get(NewOpcode), Reg) 00310 .addImm(Offset); 00311 break; 00312 default: 00313 llvm_unreachable("Unexpected Opcode"); 00314 } 00315 } 00316 // Erase old instruction. 00317 MBB.erase(II); 00318 } 00319 00320 void 00321 XCoreRegisterInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF, 00322 RegScavenger *RS) const { 00323 MachineFrameInfo *MFI = MF.getFrameInfo(); 00324 bool LRUsed = MF.getRegInfo().isPhysRegUsed(XCore::LR); 00325 const TargetRegisterClass *RC = XCore::GRRegsRegisterClass; 00326 XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>(); 00327 if (LRUsed) { 00328 MF.getRegInfo().setPhysRegUnused(XCore::LR); 00329 00330 bool isVarArg = MF.getFunction()->isVarArg(); 00331 int FrameIdx; 00332 if (! isVarArg) { 00333 // A fixed offset of 0 allows us to save / restore LR using entsp / retsp. 00334 FrameIdx = MFI->CreateFixedObject(RC->getSize(), 0); 00335 } else { 00336 FrameIdx = MFI->CreateStackObject(RC->getSize(), RC->getAlignment()); 00337 } 00338 XFI->setUsesLR(FrameIdx); 00339 XFI->setLRSpillSlot(FrameIdx); 00340 } 00341 if (requiresRegisterScavenging(MF)) { 00342 // Reserve a slot close to SP or frame pointer. 00343 RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(), 00344 RC->getAlignment())); 00345 } 00346 if (hasFP(MF)) { 00347 // A callee save register is used to hold the FP. 00348 // This needs saving / restoring in the epilogue / prologue. 00349 XFI->setFPSpillSlot(MFI->CreateStackObject(RC->getSize(), 00350 RC->getAlignment())); 00351 } 00352 } 00353 00354 void XCoreRegisterInfo:: 00355 processFunctionBeforeFrameFinalized(MachineFunction &MF) const { 00356 00357 } 00358 00359 void XCoreRegisterInfo:: 00360 loadConstant(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, 00361 unsigned DstReg, int64_t Value, DebugLoc dl) const { 00362 // TODO use mkmsk if possible. 00363 if (!isImmU16(Value)) { 00364 // TODO use constant pool. 00365 std::string msg; 00366 raw_string_ostream Msg(msg); 00367 Msg << "loadConstant value too big " << Value; 00368 llvm_report_error(Msg.str()); 00369 } 00370 int Opcode = isImmU6(Value) ? XCore::LDC_ru6 : XCore::LDC_lru6; 00371 BuildMI(MBB, I, dl, TII.get(Opcode), DstReg).addImm(Value); 00372 } 00373 00374 void XCoreRegisterInfo:: 00375 storeToStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, 00376 unsigned SrcReg, int Offset, DebugLoc dl) const { 00377 assert(Offset%4 == 0 && "Misaligned stack offset"); 00378 Offset/=4; 00379 bool isU6 = isImmU6(Offset); 00380 if (!isU6 && !isImmU16(Offset)) { 00381 std::string msg; 00382 raw_string_ostream Msg(msg); 00383 Msg << "storeToStack offset too big " << Offset; 00384 llvm_report_error(Msg.str()); 00385 } 00386 int Opcode = isU6 ? XCore::STWSP_ru6 : XCore::STWSP_lru6; 00387 BuildMI(MBB, I, dl, TII.get(Opcode)) 00388 .addReg(SrcReg) 00389 .addImm(Offset); 00390 } 00391 00392 void XCoreRegisterInfo:: 00393 loadFromStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, 00394 unsigned DstReg, int Offset, DebugLoc dl) const { 00395 assert(Offset%4 == 0 && "Misaligned stack offset"); 00396 Offset/=4; 00397 bool isU6 = isImmU6(Offset); 00398 if (!isU6 && !isImmU16(Offset)) { 00399 std::string msg; 00400 raw_string_ostream Msg(msg); 00401 Msg << "loadFromStack offset too big " << Offset; 00402 llvm_report_error(Msg.str()); 00403 } 00404 int Opcode = isU6 ? XCore::LDWSP_ru6 : XCore::LDWSP_lru6; 00405 BuildMI(MBB, I, dl, TII.get(Opcode), DstReg) 00406 .addImm(Offset); 00407 } 00408 00409 void XCoreRegisterInfo::emitPrologue(MachineFunction &MF) const { 00410 MachineBasicBlock &MBB = MF.front(); // Prolog goes in entry BB 00411 MachineBasicBlock::iterator MBBI = MBB.begin(); 00412 MachineFrameInfo *MFI = MF.getFrameInfo(); 00413 MachineModuleInfo *MMI = MFI->getMachineModuleInfo(); 00414 XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>(); 00415 DebugLoc dl = (MBBI != MBB.end() ? 00416 MBBI->getDebugLoc() : DebugLoc::getUnknownLoc()); 00417 00418 bool FP = hasFP(MF); 00419 00420 // Work out frame sizes. 00421 int FrameSize = MFI->getStackSize(); 00422 00423 assert(FrameSize%4 == 0 && "Misaligned frame size"); 00424 00425 FrameSize/=4; 00426 00427 bool isU6 = isImmU6(FrameSize); 00428 00429 if (!isU6 && !isImmU16(FrameSize)) { 00430 // FIXME could emit multiple instructions. 00431 std::string msg; 00432 raw_string_ostream Msg(msg); 00433 Msg << "emitPrologue Frame size too big: " << FrameSize; 00434 llvm_report_error(Msg.str()); 00435 } 00436 bool emitFrameMoves = needsFrameMoves(MF); 00437 00438 // Do we need to allocate space on the stack? 00439 if (FrameSize) { 00440 bool saveLR = XFI->getUsesLR(); 00441 bool LRSavedOnEntry = false; 00442 int Opcode; 00443 if (saveLR && (MFI->getObjectOffset(XFI->getLRSpillSlot()) == 0)) { 00444 Opcode = (isU6) ? XCore::ENTSP_u6 : XCore::ENTSP_lu6; 00445 MBB.addLiveIn(XCore::LR); 00446 saveLR = false; 00447 LRSavedOnEntry = true; 00448 } else { 00449 Opcode = (isU6) ? XCore::EXTSP_u6 : XCore::EXTSP_lu6; 00450 } 00451 BuildMI(MBB, MBBI, dl, TII.get(Opcode)).addImm(FrameSize); 00452 00453 if (emitFrameMoves) { 00454 std::vector<MachineMove> &Moves = MMI->getFrameMoves(); 00455 00456 // Show update of SP. 00457 unsigned FrameLabelId = MMI->NextLabelID(); 00458 BuildMI(MBB, MBBI, dl, TII.get(XCore::DBG_LABEL)).addImm(FrameLabelId); 00459 00460 MachineLocation SPDst(MachineLocation::VirtualFP); 00461 MachineLocation SPSrc(MachineLocation::VirtualFP, -FrameSize * 4); 00462 Moves.push_back(MachineMove(FrameLabelId, SPDst, SPSrc)); 00463 00464 if (LRSavedOnEntry) { 00465 MachineLocation CSDst(MachineLocation::VirtualFP, 0); 00466 MachineLocation CSSrc(XCore::LR); 00467 Moves.push_back(MachineMove(FrameLabelId, CSDst, CSSrc)); 00468 } 00469 } 00470 if (saveLR) { 00471 int LRSpillOffset = MFI->getObjectOffset(XFI->getLRSpillSlot()); 00472 storeToStack(MBB, MBBI, XCore::LR, LRSpillOffset + FrameSize*4, dl); 00473 MBB.addLiveIn(XCore::LR); 00474 00475 if (emitFrameMoves) { 00476 unsigned SaveLRLabelId = MMI->NextLabelID(); 00477 BuildMI(MBB, MBBI, dl, TII.get(XCore::DBG_LABEL)).addImm(SaveLRLabelId); 00478 MachineLocation CSDst(MachineLocation::VirtualFP, LRSpillOffset); 00479 MachineLocation CSSrc(XCore::LR); 00480 MMI->getFrameMoves().push_back(MachineMove(SaveLRLabelId, 00481 CSDst, CSSrc)); 00482 } 00483 } 00484 } 00485 00486 if (FP) { 00487 // Save R10 to the stack. 00488 int FPSpillOffset = MFI->getObjectOffset(XFI->getFPSpillSlot()); 00489 storeToStack(MBB, MBBI, XCore::R10, FPSpillOffset + FrameSize*4, dl); 00490 // R10 is live-in. It is killed at the spill. 00491 MBB.addLiveIn(XCore::R10); 00492 if (emitFrameMoves) { 00493 unsigned SaveR10LabelId = MMI->NextLabelID(); 00494 BuildMI(MBB, MBBI, dl, TII.get(XCore::DBG_LABEL)).addImm(SaveR10LabelId); 00495 MachineLocation CSDst(MachineLocation::VirtualFP, FPSpillOffset); 00496 MachineLocation CSSrc(XCore::R10); 00497 MMI->getFrameMoves().push_back(MachineMove(SaveR10LabelId, 00498 CSDst, CSSrc)); 00499 } 00500 // Set the FP from the SP. 00501 unsigned FramePtr = XCore::R10; 00502 BuildMI(MBB, MBBI, dl, TII.get(XCore::LDAWSP_ru6), FramePtr) 00503 .addImm(0); 00504 if (emitFrameMoves) { 00505 // Show FP is now valid. 00506 unsigned FrameLabelId = MMI->NextLabelID(); 00507 BuildMI(MBB, MBBI, dl, TII.get(XCore::DBG_LABEL)).addImm(FrameLabelId); 00508 MachineLocation SPDst(FramePtr); 00509 MachineLocation SPSrc(MachineLocation::VirtualFP); 00510 MMI->getFrameMoves().push_back(MachineMove(FrameLabelId, SPDst, SPSrc)); 00511 } 00512 } 00513 00514 if (emitFrameMoves) { 00515 // Frame moves for callee saved. 00516 std::vector<MachineMove> &Moves = MMI->getFrameMoves(); 00517 std::vector<std::pair<unsigned, CalleeSavedInfo> >&SpillLabels = 00518 XFI->getSpillLabels(); 00519 for (unsigned I = 0, E = SpillLabels.size(); I != E; ++I) { 00520 unsigned SpillLabel = SpillLabels[I].first; 00521 CalleeSavedInfo &CSI = SpillLabels[I].second; 00522 int Offset = MFI->getObjectOffset(CSI.getFrameIdx()); 00523 unsigned Reg = CSI.getReg(); 00524 MachineLocation CSDst(MachineLocation::VirtualFP, Offset); 00525 MachineLocation CSSrc(Reg); 00526 Moves.push_back(MachineMove(SpillLabel, CSDst, CSSrc)); 00527 } 00528 } 00529 } 00530 00531 void XCoreRegisterInfo::emitEpilogue(MachineFunction &MF, 00532 MachineBasicBlock &MBB) const { 00533 MachineFrameInfo *MFI = MF.getFrameInfo(); 00534 MachineBasicBlock::iterator MBBI = prior(MBB.end()); 00535 DebugLoc dl = MBBI->getDebugLoc(); 00536 00537 bool FP = hasFP(MF); 00538 00539 if (FP) { 00540 // Restore the stack pointer. 00541 unsigned FramePtr = XCore::R10; 00542 BuildMI(MBB, MBBI, dl, TII.get(XCore::SETSP_1r)) 00543 .addReg(FramePtr); 00544 } 00545 00546 // Work out frame sizes. 00547 int FrameSize = MFI->getStackSize(); 00548 00549 assert(FrameSize%4 == 0 && "Misaligned frame size"); 00550 00551 FrameSize/=4; 00552 00553 bool isU6 = isImmU6(FrameSize); 00554 00555 if (!isU6 && !isImmU16(FrameSize)) { 00556 // FIXME could emit multiple instructions. 00557 std::string msg; 00558 raw_string_ostream Msg(msg); 00559 Msg << "emitEpilogue Frame size too big: " << FrameSize; 00560 llvm_report_error(Msg.str()); 00561 } 00562 00563 if (FrameSize) { 00564 XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>(); 00565 00566 if (FP) { 00567 // Restore R10 00568 int FPSpillOffset = MFI->getObjectOffset(XFI->getFPSpillSlot()); 00569 FPSpillOffset += FrameSize*4; 00570 loadFromStack(MBB, MBBI, XCore::R10, FPSpillOffset, dl); 00571 } 00572 bool restoreLR = XFI->getUsesLR(); 00573 if (restoreLR && MFI->getObjectOffset(XFI->getLRSpillSlot()) != 0) { 00574 int LRSpillOffset = MFI->getObjectOffset(XFI->getLRSpillSlot()); 00575 LRSpillOffset += FrameSize*4; 00576 loadFromStack(MBB, MBBI, XCore::LR, LRSpillOffset, dl); 00577 restoreLR = false; 00578 } 00579 if (restoreLR) { 00580 // Fold prologue into return instruction 00581 assert(MBBI->getOpcode() == XCore::RETSP_u6 00582 || MBBI->getOpcode() == XCore::RETSP_lu6); 00583 int Opcode = (isU6) ? XCore::RETSP_u6 : XCore::RETSP_lu6; 00584 BuildMI(MBB, MBBI, dl, TII.get(Opcode)).addImm(FrameSize); 00585 MBB.erase(MBBI); 00586 } else { 00587 int Opcode = (isU6) ? XCore::LDAWSP_ru6_RRegs : XCore::LDAWSP_lru6_RRegs; 00588 BuildMI(MBB, MBBI, dl, TII.get(Opcode), XCore::SP).addImm(FrameSize); 00589 } 00590 } 00591 } 00592 00593 int XCoreRegisterInfo::getDwarfRegNum(unsigned RegNum, bool isEH) const { 00594 return XCoreGenRegisterInfo::getDwarfRegNumFull(RegNum, 0); 00595 } 00596 00597 unsigned XCoreRegisterInfo::getFrameRegister(MachineFunction &MF) const { 00598 bool FP = hasFP(MF); 00599 00600 return FP ? XCore::R10 : XCore::SP; 00601 } 00602 00603 unsigned XCoreRegisterInfo::getRARegister() const { 00604 return XCore::LR; 00605 } 00606 00607 void XCoreRegisterInfo::getInitialFrameState(std::vector<MachineMove> &Moves) 00608 const { 00609 // Initial state of the frame pointer is SP. 00610 MachineLocation Dst(MachineLocation::VirtualFP); 00611 MachineLocation Src(XCore::SP, 0); 00612 Moves.push_back(MachineMove(0, Dst, Src)); 00613 } 00614 00615 #include "XCoreGenRegisterInfo.inc" 00616