Home | History | Annotate | Download | only in XCore 
      1 //===-- XCoreFrameLowering.cpp - Frame info for XCore Target -----*- C++ -*-==//
      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 XCore frame information that doesn't fit anywhere else
     11 // cleanly...
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "XCore.h"
     16 #include "XCoreFrameLowering.h"
     17 #include "XCoreInstrInfo.h"
     18 #include "XCoreMachineFunctionInfo.h"
     19 #include "llvm/Function.h"
     20 #include "llvm/CodeGen/MachineFrameInfo.h"
     21 #include "llvm/CodeGen/MachineFunction.h"
     22 #include "llvm/CodeGen/MachineInstrBuilder.h"
     23 #include "llvm/CodeGen/MachineModuleInfo.h"
     24 #include "llvm/CodeGen/MachineRegisterInfo.h"
     25 #include "llvm/CodeGen/RegisterScavenging.h"
     26 #include "llvm/Target/TargetData.h"
     27 #include "llvm/Target/TargetOptions.h"
     28 #include "llvm/Support/ErrorHandling.h"
     29 
     30 using namespace llvm;
     31 
     32 // helper functions. FIXME: Eliminate.
     33 static inline bool isImmUs(unsigned val) {
     34   return val <= 11;
     35 }
     36 
     37 static inline bool isImmU6(unsigned val) {
     38   return val < (1 << 6);
     39 }
     40 
     41 static inline bool isImmU16(unsigned val) {
     42   return val < (1 << 16);
     43 }
     44 
     45 static void loadFromStack(MachineBasicBlock &MBB,
     46                           MachineBasicBlock::iterator I,
     47                           unsigned DstReg, int Offset, DebugLoc dl,
     48                           const TargetInstrInfo &TII) {
     49   assert(Offset%4 == 0 && "Misaligned stack offset");
     50   Offset/=4;
     51   bool isU6 = isImmU6(Offset);
     52   if (!isU6 && !isImmU16(Offset))
     53     report_fatal_error("loadFromStack offset too big " + Twine(Offset));
     54   int Opcode = isU6 ? XCore::LDWSP_ru6 : XCore::LDWSP_lru6;
     55   BuildMI(MBB, I, dl, TII.get(Opcode), DstReg)
     56     .addImm(Offset);
     57 }
     58 
     59 
     60 static void storeToStack(MachineBasicBlock &MBB,
     61                          MachineBasicBlock::iterator I,
     62                          unsigned SrcReg, int Offset, DebugLoc dl,
     63                          const TargetInstrInfo &TII) {
     64   assert(Offset%4 == 0 && "Misaligned stack offset");
     65   Offset/=4;
     66   bool isU6 = isImmU6(Offset);
     67   if (!isU6 && !isImmU16(Offset))
     68     report_fatal_error("storeToStack offset too big " + Twine(Offset));
     69   int Opcode = isU6 ? XCore::STWSP_ru6 : XCore::STWSP_lru6;
     70   BuildMI(MBB, I, dl, TII.get(Opcode))
     71     .addReg(SrcReg)
     72     .addImm(Offset);
     73 }
     74 
     75 
     76 //===----------------------------------------------------------------------===//
     77 // XCoreFrameLowering:
     78 //===----------------------------------------------------------------------===//
     79 
     80 XCoreFrameLowering::XCoreFrameLowering(const XCoreSubtarget &sti)
     81   : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 4, 0),
     82     STI(sti) {
     83   // Do nothing
     84 }
     85 
     86 bool XCoreFrameLowering::hasFP(const MachineFunction &MF) const {
     87   return DisableFramePointerElim(MF) || MF.getFrameInfo()->hasVarSizedObjects();
     88 }
     89 
     90 void XCoreFrameLowering::emitPrologue(MachineFunction &MF) const {
     91   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
     92   MachineBasicBlock::iterator MBBI = MBB.begin();
     93   MachineFrameInfo *MFI = MF.getFrameInfo();
     94   MachineModuleInfo *MMI = &MF.getMMI();
     95   const XCoreRegisterInfo *RegInfo =
     96     static_cast<const XCoreRegisterInfo*>(MF.getTarget().getRegisterInfo());
     97   const XCoreInstrInfo &TII =
     98     *static_cast<const XCoreInstrInfo*>(MF.getTarget().getInstrInfo());
     99   XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
    100   DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
    101 
    102   bool FP = hasFP(MF);
    103   bool Nested = MF.getFunction()->
    104                 getAttributes().hasAttrSomewhere(Attribute::Nest);
    105 
    106   if (Nested) {
    107     loadFromStack(MBB, MBBI, XCore::R11, 0, dl, TII);
    108   }
    109 
    110   // Work out frame sizes.
    111   int FrameSize = MFI->getStackSize();
    112   assert(FrameSize%4 == 0 && "Misaligned frame size");
    113   FrameSize/=4;
    114 
    115   bool isU6 = isImmU6(FrameSize);
    116 
    117   if (!isU6 && !isImmU16(FrameSize)) {
    118     // FIXME could emit multiple instructions.
    119     report_fatal_error("emitPrologue Frame size too big: " + Twine(FrameSize));
    120   }
    121   bool emitFrameMoves = RegInfo->needsFrameMoves(MF);
    122 
    123   // Do we need to allocate space on the stack?
    124   if (FrameSize) {
    125     bool saveLR = XFI->getUsesLR();
    126     bool LRSavedOnEntry = false;
    127     int Opcode;
    128     if (saveLR && (MFI->getObjectOffset(XFI->getLRSpillSlot()) == 0)) {
    129       Opcode = (isU6) ? XCore::ENTSP_u6 : XCore::ENTSP_lu6;
    130       MBB.addLiveIn(XCore::LR);
    131       saveLR = false;
    132       LRSavedOnEntry = true;
    133     } else {
    134       Opcode = (isU6) ? XCore::EXTSP_u6 : XCore::EXTSP_lu6;
    135     }
    136     BuildMI(MBB, MBBI, dl, TII.get(Opcode)).addImm(FrameSize);
    137 
    138     if (emitFrameMoves) {
    139       std::vector<MachineMove> &Moves = MMI->getFrameMoves();
    140 
    141       // Show update of SP.
    142       MCSymbol *FrameLabel = MMI->getContext().CreateTempSymbol();
    143       BuildMI(MBB, MBBI, dl, TII.get(XCore::PROLOG_LABEL)).addSym(FrameLabel);
    144 
    145       MachineLocation SPDst(MachineLocation::VirtualFP);
    146       MachineLocation SPSrc(MachineLocation::VirtualFP, -FrameSize * 4);
    147       Moves.push_back(MachineMove(FrameLabel, SPDst, SPSrc));
    148 
    149       if (LRSavedOnEntry) {
    150         MachineLocation CSDst(MachineLocation::VirtualFP, 0);
    151         MachineLocation CSSrc(XCore::LR);
    152         Moves.push_back(MachineMove(FrameLabel, CSDst, CSSrc));
    153       }
    154     }
    155     if (saveLR) {
    156       int LRSpillOffset = MFI->getObjectOffset(XFI->getLRSpillSlot());
    157       storeToStack(MBB, MBBI, XCore::LR, LRSpillOffset + FrameSize*4, dl, TII);
    158       MBB.addLiveIn(XCore::LR);
    159 
    160       if (emitFrameMoves) {
    161         MCSymbol *SaveLRLabel = MMI->getContext().CreateTempSymbol();
    162         BuildMI(MBB, MBBI, dl, TII.get(XCore::PROLOG_LABEL)).addSym(SaveLRLabel);
    163         MachineLocation CSDst(MachineLocation::VirtualFP, LRSpillOffset);
    164         MachineLocation CSSrc(XCore::LR);
    165         MMI->getFrameMoves().push_back(MachineMove(SaveLRLabel, CSDst, CSSrc));
    166       }
    167     }
    168   }
    169 
    170   if (FP) {
    171     // Save R10 to the stack.
    172     int FPSpillOffset = MFI->getObjectOffset(XFI->getFPSpillSlot());
    173     storeToStack(MBB, MBBI, XCore::R10, FPSpillOffset + FrameSize*4, dl, TII);
    174     // R10 is live-in. It is killed at the spill.
    175     MBB.addLiveIn(XCore::R10);
    176     if (emitFrameMoves) {
    177       MCSymbol *SaveR10Label = MMI->getContext().CreateTempSymbol();
    178       BuildMI(MBB, MBBI, dl, TII.get(XCore::PROLOG_LABEL)).addSym(SaveR10Label);
    179       MachineLocation CSDst(MachineLocation::VirtualFP, FPSpillOffset);
    180       MachineLocation CSSrc(XCore::R10);
    181       MMI->getFrameMoves().push_back(MachineMove(SaveR10Label, CSDst, CSSrc));
    182     }
    183     // Set the FP from the SP.
    184     unsigned FramePtr = XCore::R10;
    185     BuildMI(MBB, MBBI, dl, TII.get(XCore::LDAWSP_ru6), FramePtr)
    186       .addImm(0);
    187     if (emitFrameMoves) {
    188       // Show FP is now valid.
    189       MCSymbol *FrameLabel = MMI->getContext().CreateTempSymbol();
    190       BuildMI(MBB, MBBI, dl, TII.get(XCore::PROLOG_LABEL)).addSym(FrameLabel);
    191       MachineLocation SPDst(FramePtr);
    192       MachineLocation SPSrc(MachineLocation::VirtualFP);
    193       MMI->getFrameMoves().push_back(MachineMove(FrameLabel, SPDst, SPSrc));
    194     }
    195   }
    196 
    197   if (emitFrameMoves) {
    198     // Frame moves for callee saved.
    199     std::vector<MachineMove> &Moves = MMI->getFrameMoves();
    200     std::vector<std::pair<MCSymbol*, CalleeSavedInfo> >&SpillLabels =
    201         XFI->getSpillLabels();
    202     for (unsigned I = 0, E = SpillLabels.size(); I != E; ++I) {
    203       MCSymbol *SpillLabel = SpillLabels[I].first;
    204       CalleeSavedInfo &CSI = SpillLabels[I].second;
    205       int Offset = MFI->getObjectOffset(CSI.getFrameIdx());
    206       unsigned Reg = CSI.getReg();
    207       MachineLocation CSDst(MachineLocation::VirtualFP, Offset);
    208       MachineLocation CSSrc(Reg);
    209       Moves.push_back(MachineMove(SpillLabel, CSDst, CSSrc));
    210     }
    211   }
    212 }
    213 
    214 void XCoreFrameLowering::emitEpilogue(MachineFunction &MF,
    215                                      MachineBasicBlock &MBB) const {
    216   MachineFrameInfo *MFI            = MF.getFrameInfo();
    217   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
    218   const XCoreInstrInfo &TII =
    219     *static_cast<const XCoreInstrInfo*>(MF.getTarget().getInstrInfo());
    220   DebugLoc dl = MBBI->getDebugLoc();
    221 
    222   bool FP = hasFP(MF);
    223   if (FP) {
    224     // Restore the stack pointer.
    225     unsigned FramePtr = XCore::R10;
    226     BuildMI(MBB, MBBI, dl, TII.get(XCore::SETSP_1r))
    227       .addReg(FramePtr);
    228   }
    229 
    230   // Work out frame sizes.
    231   int FrameSize = MFI->getStackSize();
    232 
    233   assert(FrameSize%4 == 0 && "Misaligned frame size");
    234 
    235   FrameSize/=4;
    236 
    237   bool isU6 = isImmU6(FrameSize);
    238 
    239   if (!isU6 && !isImmU16(FrameSize)) {
    240     // FIXME could emit multiple instructions.
    241     report_fatal_error("emitEpilogue Frame size too big: " + Twine(FrameSize));
    242   }
    243 
    244   if (FrameSize) {
    245     XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
    246 
    247     if (FP) {
    248       // Restore R10
    249       int FPSpillOffset = MFI->getObjectOffset(XFI->getFPSpillSlot());
    250       FPSpillOffset += FrameSize*4;
    251       loadFromStack(MBB, MBBI, XCore::R10, FPSpillOffset, dl, TII);
    252     }
    253     bool restoreLR = XFI->getUsesLR();
    254     if (restoreLR && MFI->getObjectOffset(XFI->getLRSpillSlot()) != 0) {
    255       int LRSpillOffset = MFI->getObjectOffset(XFI->getLRSpillSlot());
    256       LRSpillOffset += FrameSize*4;
    257       loadFromStack(MBB, MBBI, XCore::LR, LRSpillOffset, dl, TII);
    258       restoreLR = false;
    259     }
    260     if (restoreLR) {
    261       // Fold prologue into return instruction
    262       assert(MBBI->getOpcode() == XCore::RETSP_u6
    263         || MBBI->getOpcode() == XCore::RETSP_lu6);
    264       int Opcode = (isU6) ? XCore::RETSP_u6 : XCore::RETSP_lu6;
    265       BuildMI(MBB, MBBI, dl, TII.get(Opcode)).addImm(FrameSize);
    266       MBB.erase(MBBI);
    267     } else {
    268       int Opcode = (isU6) ? XCore::LDAWSP_ru6_RRegs : XCore::LDAWSP_lru6_RRegs;
    269       BuildMI(MBB, MBBI, dl, TII.get(Opcode), XCore::SP).addImm(FrameSize);
    270     }
    271   }
    272 }
    273 
    274 bool XCoreFrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
    275                                                MachineBasicBlock::iterator MI,
    276                                         const std::vector<CalleeSavedInfo> &CSI,
    277                                           const TargetRegisterInfo *TRI) const {
    278   if (CSI.empty())
    279     return true;
    280 
    281   MachineFunction *MF = MBB.getParent();
    282   const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
    283 
    284   XCoreFunctionInfo *XFI = MF->getInfo<XCoreFunctionInfo>();
    285   bool emitFrameMoves = XCoreRegisterInfo::needsFrameMoves(*MF);
    286 
    287   DebugLoc DL;
    288   if (MI != MBB.end()) DL = MI->getDebugLoc();
    289 
    290   for (std::vector<CalleeSavedInfo>::const_iterator it = CSI.begin();
    291                                                     it != CSI.end(); ++it) {
    292     // Add the callee-saved register as live-in. It's killed at the spill.
    293     MBB.addLiveIn(it->getReg());
    294 
    295     unsigned Reg = it->getReg();
    296     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
    297     TII.storeRegToStackSlot(MBB, MI, Reg, true,
    298                             it->getFrameIdx(), RC, TRI);
    299     if (emitFrameMoves) {
    300       MCSymbol *SaveLabel = MF->getContext().CreateTempSymbol();
    301       BuildMI(MBB, MI, DL, TII.get(XCore::PROLOG_LABEL)).addSym(SaveLabel);
    302       XFI->getSpillLabels().push_back(std::make_pair(SaveLabel, *it));
    303     }
    304   }
    305   return true;
    306 }
    307 
    308 bool XCoreFrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
    309                                                  MachineBasicBlock::iterator MI,
    310                                         const std::vector<CalleeSavedInfo> &CSI,
    311                                             const TargetRegisterInfo *TRI) const{
    312   MachineFunction *MF = MBB.getParent();
    313   const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
    314 
    315   bool AtStart = MI == MBB.begin();
    316   MachineBasicBlock::iterator BeforeI = MI;
    317   if (!AtStart)
    318     --BeforeI;
    319   for (std::vector<CalleeSavedInfo>::const_iterator it = CSI.begin();
    320                                                     it != CSI.end(); ++it) {
    321     unsigned Reg = it->getReg();
    322     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
    323     TII.loadRegFromStackSlot(MBB, MI, it->getReg(), it->getFrameIdx(),
    324                              RC, TRI);
    325     assert(MI != MBB.begin() &&
    326            "loadRegFromStackSlot didn't insert any code!");
    327     // Insert in reverse order.  loadRegFromStackSlot can insert multiple
    328     // instructions.
    329     if (AtStart)
    330       MI = MBB.begin();
    331     else {
    332       MI = BeforeI;
    333       ++MI;
    334     }
    335   }
    336   return true;
    337 }
    338 
    339 void
    340 XCoreFrameLowering::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
    341                                                      RegScavenger *RS) const {
    342   MachineFrameInfo *MFI = MF.getFrameInfo();
    343   const TargetRegisterInfo *RegInfo = MF.getTarget().getRegisterInfo();
    344   bool LRUsed = MF.getRegInfo().isPhysRegUsed(XCore::LR);
    345   const TargetRegisterClass *RC = XCore::GRRegsRegisterClass;
    346   XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
    347   if (LRUsed) {
    348     MF.getRegInfo().setPhysRegUnused(XCore::LR);
    349 
    350     bool isVarArg = MF.getFunction()->isVarArg();
    351     int FrameIdx;
    352     if (! isVarArg) {
    353       // A fixed offset of 0 allows us to save / restore LR using entsp / retsp.
    354       FrameIdx = MFI->CreateFixedObject(RC->getSize(), 0, true);
    355     } else {
    356       FrameIdx = MFI->CreateStackObject(RC->getSize(), RC->getAlignment(),
    357                                         false);
    358     }
    359     XFI->setUsesLR(FrameIdx);
    360     XFI->setLRSpillSlot(FrameIdx);
    361   }
    362   if (RegInfo->requiresRegisterScavenging(MF)) {
    363     // Reserve a slot close to SP or frame pointer.
    364     RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
    365                                                        RC->getAlignment(),
    366                                                        false));
    367   }
    368   if (hasFP(MF)) {
    369     // A callee save register is used to hold the FP.
    370     // This needs saving / restoring in the epilogue / prologue.
    371     XFI->setFPSpillSlot(MFI->CreateStackObject(RC->getSize(),
    372                                                RC->getAlignment(),
    373                                                false));
    374   }
    375 }
    376 
    377 void XCoreFrameLowering::
    378 processFunctionBeforeFrameFinalized(MachineFunction &MF) const {
    379 
    380 }
    381