LLVM API Documentation

XCoreRegisterInfo.cpp

Go to the documentation of this file.
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