contrib/llvm/lib/Target/XCore/XCoreFrameLowering.cpp

   1 //===-- XCoreFrameLowering.cpp - Frame info for XCore Target --------------===//
   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 "XCoreFrameLowering.h"
  16 #include "XCore.h"
  17 #include "XCoreInstrInfo.h"
  18 #include "XCoreMachineFunctionInfo.h"
  19 #include "llvm/CodeGen/MachineFrameInfo.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineInstrBuilder.h"
  22 #include "llvm/CodeGen/MachineModuleInfo.h"
  23 #include "llvm/CodeGen/MachineRegisterInfo.h"
  24 #include "llvm/CodeGen/RegisterScavenging.h"
  25 #include "llvm/IR/DataLayout.h"
  26 #include "llvm/IR/Function.h"
  27 #include "llvm/Support/ErrorHandling.h"
  28 #include "llvm/Target/TargetLowering.h"
  29 #include "llvm/Target/TargetOptions.h"
  30 #include <algorithm>    // std::sort
  31
  32 using namespace llvm;
  33
  34 static const unsigned FramePtr = XCore::R10;
  35 static const int MaxImmU16 = (1<<16) - 1;
  36
  37 // helper functions. FIXME: Eliminate.
  38 static inline bool isImmU6(unsigned val) {
  39   return val < (1 << 6);
  40 }
  41
  42 static inline bool isImmU16(unsigned val) {
  43   return val < (1 << 16);
  44 }
  45
  46 // Helper structure with compare function for handling stack slots.
  47 namespace {
  48 struct StackSlotInfo {
  49   int FI;
  50   int Offset;
  51   unsigned Reg;
  52   StackSlotInfo(int f, int o, int r) : FI(f), Offset(o), Reg(r){};
  53 };
  54 }  // end anonymous namespace
  55
  56 static bool CompareSSIOffset(const StackSlotInfo& a, const StackSlotInfo& b) {
  57   return a.Offset < b.Offset;
  58 }
  59
  60
  61 static void EmitDefCfaRegister(MachineBasicBlock &MBB,
  62                                MachineBasicBlock::iterator MBBI, DebugLoc dl,
  63                                const TargetInstrInfo &TII,
  64                                MachineModuleInfo *MMI, unsigned DRegNum) {
  65   unsigned CFIIndex = MMI->addFrameInst(
  66       MCCFIInstruction::createDefCfaRegister(nullptr, DRegNum));
  67   BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
  68       .addCFIIndex(CFIIndex);
  69 }
  70
  71 static void EmitDefCfaOffset(MachineBasicBlock &MBB,
  72                              MachineBasicBlock::iterator MBBI, DebugLoc dl,
  73                              const TargetInstrInfo &TII,
  74                              MachineModuleInfo *MMI, int Offset) {
  75   unsigned CFIIndex =
  76       MMI->addFrameInst(MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
  77   BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
  78       .addCFIIndex(CFIIndex);
  79 }
  80
  81 static void EmitCfiOffset(MachineBasicBlock &MBB,
  82                           MachineBasicBlock::iterator MBBI, DebugLoc dl,
  83                           const TargetInstrInfo &TII, MachineModuleInfo *MMI,
  84                           unsigned DRegNum, int Offset) {
  85   unsigned CFIIndex = MMI->addFrameInst(
  86       MCCFIInstruction::createOffset(nullptr, DRegNum, Offset));
  87   BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
  88       .addCFIIndex(CFIIndex);
  89 }
  90
  91 /// The SP register is moved in steps of 'MaxImmU16' towards the bottom of the
  92 /// frame. During these steps, it may be necessary to spill registers.
  93 /// IfNeededExtSP emits the necessary EXTSP instructions to move the SP only
  94 /// as far as to make 'OffsetFromBottom' reachable using an STWSP_lru6.
  95 /// \param OffsetFromTop the spill offset from the top of the frame.
  96 /// \param [in,out] Adjusted the current SP offset from the top of the frame.
  97 static void IfNeededExtSP(MachineBasicBlock &MBB,
  98                           MachineBasicBlock::iterator MBBI, DebugLoc dl,
  99                           const TargetInstrInfo &TII, MachineModuleInfo *MMI,
 100                           int OffsetFromTop, int &Adjusted, int FrameSize,
 101                           bool emitFrameMoves) {
 102   while (OffsetFromTop > Adjusted) {
 103     assert(Adjusted < FrameSize && "OffsetFromTop is beyond FrameSize");
 104     int remaining = FrameSize - Adjusted;
 105     int OpImm = (remaining > MaxImmU16) ? MaxImmU16 : remaining;
 106     int Opcode = isImmU6(OpImm) ? XCore::EXTSP_u6 : XCore::EXTSP_lu6;
 107     BuildMI(MBB, MBBI, dl, TII.get(Opcode)).addImm(OpImm);
 108     Adjusted += OpImm;
 109     if (emitFrameMoves)
 110       EmitDefCfaOffset(MBB, MBBI, dl, TII, MMI, Adjusted*4);
 111   }
 112 }
 113
 114 /// The SP register is moved in steps of 'MaxImmU16' towards the top of the
 115 /// frame. During these steps, it may be necessary to re-load registers.
 116 /// IfNeededLDAWSP emits the necessary LDAWSP instructions to move the SP only
 117 /// as far as to make 'OffsetFromTop' reachable using an LDAWSP_lru6.
 118 /// \param OffsetFromTop the spill offset from the top of the frame.
 119 /// \param [in,out] RemainingAdj the current SP offset from the top of the
 120 /// frame.
 121 static void IfNeededLDAWSP(MachineBasicBlock &MBB,
 122                            MachineBasicBlock::iterator MBBI, DebugLoc dl,
 123                            const TargetInstrInfo &TII, int OffsetFromTop,
 124                            int &RemainingAdj) {
 125   while (OffsetFromTop < RemainingAdj - MaxImmU16) {
 126     assert(RemainingAdj && "OffsetFromTop is beyond FrameSize");
 127     int OpImm = (RemainingAdj > MaxImmU16) ? MaxImmU16 : RemainingAdj;
 128     int Opcode = isImmU6(OpImm) ? XCore::LDAWSP_ru6 : XCore::LDAWSP_lru6;
 129     BuildMI(MBB, MBBI, dl, TII.get(Opcode), XCore::SP).addImm(OpImm);
 130     RemainingAdj -= OpImm;
 131   }
 132 }
 133
 134 /// Creates an ordered list of registers that are spilled
 135 /// during the emitPrologue/emitEpilogue.
 136 /// Registers are ordered according to their frame offset.
 137 /// As offsets are negative, the largest offsets will be first.
 138 static void GetSpillList(SmallVectorImpl<StackSlotInfo> &SpillList,
 139                          MachineFrameInfo *MFI, XCoreFunctionInfo *XFI,
 140                          bool fetchLR, bool fetchFP) {
 141   if (fetchLR) {
 142     int Offset = MFI->getObjectOffset(XFI->getLRSpillSlot());
 143     SpillList.push_back(StackSlotInfo(XFI->getLRSpillSlot(),
 144                                       Offset,
 145                                       XCore::LR));
 146   }
 147   if (fetchFP) {
 148     int Offset = MFI->getObjectOffset(XFI->getFPSpillSlot());
 149     SpillList.push_back(StackSlotInfo(XFI->getFPSpillSlot(),
 150                                       Offset,
 151                                       FramePtr));
 152   }
 153   std::sort(SpillList.begin(), SpillList.end(), CompareSSIOffset);
 154 }
 155
 156 /// Creates an ordered list of EH info register 'spills'.
 157 /// These slots are only used by the unwinder and calls to llvm.eh.return().
 158 /// Registers are ordered according to their frame offset.
 159 /// As offsets are negative, the largest offsets will be first.
 160 static void GetEHSpillList(SmallVectorImpl<StackSlotInfo> &SpillList,
 161                            MachineFrameInfo *MFI, XCoreFunctionInfo *XFI,
 162                            const TargetLowering *TL) {
 163   assert(XFI->hasEHSpillSlot() && "There are no EH register spill slots");
 164   const int* EHSlot = XFI->getEHSpillSlot();
 165   SpillList.push_back(StackSlotInfo(EHSlot[0],
 166                                     MFI->getObjectOffset(EHSlot[0]),
 167                                     TL->getExceptionPointerRegister()));
 168   SpillList.push_back(StackSlotInfo(EHSlot[0],
 169                                     MFI->getObjectOffset(EHSlot[1]),
 170                                     TL->getExceptionSelectorRegister()));
 171   std::sort(SpillList.begin(), SpillList.end(), CompareSSIOffset);
 172 }
 173
 174
 175 static MachineMemOperand *
 176 getFrameIndexMMO(MachineBasicBlock &MBB, int FrameIndex, unsigned flags) {
 177   MachineFunction *MF = MBB.getParent();
 178   const MachineFrameInfo &MFI = *MF->getFrameInfo();
 179   MachineMemOperand *MMO =
 180     MF->getMachineMemOperand(MachinePointerInfo::getFixedStack(FrameIndex),
 181                              flags, MFI.getObjectSize(FrameIndex),
 182                              MFI.getObjectAlignment(FrameIndex));
 183   return MMO;
 184 }
 185
 186
 187 /// Restore clobbered registers with their spill slot value.
 188 /// The SP will be adjusted at the same time, thus the SpillList must be ordered
 189 /// with the largest (negative) offsets first.
 190 static void
 191 RestoreSpillList(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
 192                  DebugLoc dl, const TargetInstrInfo &TII, int &RemainingAdj,
 193                  SmallVectorImpl<StackSlotInfo> &SpillList) {
 194   for (unsigned i = 0, e = SpillList.size(); i != e; ++i) {
 195     assert(SpillList[i].Offset % 4 == 0 && "Misaligned stack offset");
 196     assert(SpillList[i].Offset <= 0 && "Unexpected positive stack offset");
 197     int OffsetFromTop = - SpillList[i].Offset/4;
 198     IfNeededLDAWSP(MBB, MBBI, dl, TII, OffsetFromTop, RemainingAdj);
 199     int Offset = RemainingAdj - OffsetFromTop;
 200     int Opcode = isImmU6(Offset) ? XCore::LDWSP_ru6 : XCore::LDWSP_lru6;
 201     BuildMI(MBB, MBBI, dl, TII.get(Opcode), SpillList[i].Reg)
 202       .addImm(Offset)
 203       .addMemOperand(getFrameIndexMMO(MBB, SpillList[i].FI,
 204                                       MachineMemOperand::MOLoad));
 205   }
 206 }
 207
 208 //===----------------------------------------------------------------------===//
 209 // XCoreFrameLowering:
 210 //===----------------------------------------------------------------------===//
 211
 212 XCoreFrameLowering::XCoreFrameLowering(const XCoreSubtarget &sti)
 213   : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 4, 0) {
 214   // Do nothing
 215 }
 216
 217 bool XCoreFrameLowering::hasFP(const MachineFunction &MF) const {
 218   return MF.getTarget().Options.DisableFramePointerElim(MF) ||
 219          MF.getFrameInfo()->hasVarSizedObjects();
 220 }
 221
 222 void XCoreFrameLowering::emitPrologue(MachineFunction &MF) const {
 223   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
 224   MachineBasicBlock::iterator MBBI = MBB.begin();
 225   MachineFrameInfo *MFI = MF.getFrameInfo();
 226   MachineModuleInfo *MMI = &MF.getMMI();
 227   const MCRegisterInfo *MRI = MMI->getContext().getRegisterInfo();
 228   const XCoreInstrInfo &TII =
 229     *static_cast<const XCoreInstrInfo*>(MF.getTarget().getInstrInfo());
 230   XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
 231   // Debug location must be unknown since the first debug location is used
 232   // to determine the end of the prologue.
 233   DebugLoc dl;
 234
 235   if (MFI->getMaxAlignment() > getStackAlignment())
 236     report_fatal_error("emitPrologue unsupported alignment: "
 237                        + Twine(MFI->getMaxAlignment()));
 238
 239   const AttributeSet &PAL = MF.getFunction()->getAttributes();
 240   if (PAL.hasAttrSomewhere(Attribute::Nest))
 241     BuildMI(MBB, MBBI, dl, TII.get(XCore::LDWSP_ru6), XCore::R11).addImm(0);
 242     // FIX: Needs addMemOperand() but can't use getFixedStack() or getStack().
 243
 244   // Work out frame sizes.
 245   // We will adjust the SP in stages towards the final FrameSize.
 246   assert(MFI->getStackSize()%4 == 0 && "Misaligned frame size");
 247   const int FrameSize = MFI->getStackSize() / 4;
 248   int Adjusted = 0;
 249
 250   bool saveLR = XFI->hasLRSpillSlot();
 251   bool UseENTSP = saveLR && FrameSize
 252                   && (MFI->getObjectOffset(XFI->getLRSpillSlot()) == 0);
 253   if (UseENTSP)
 254     saveLR = false;
 255   bool FP = hasFP(MF);
 256   bool emitFrameMoves = XCoreRegisterInfo::needsFrameMoves(MF);
 257
 258   if (UseENTSP) {
 259     // Allocate space on the stack at the same time as saving LR.
 260     Adjusted = (FrameSize > MaxImmU16) ? MaxImmU16 : FrameSize;
 261     int Opcode = isImmU6(Adjusted) ? XCore::ENTSP_u6 : XCore::ENTSP_lu6;
 262     MBB.addLiveIn(XCore::LR);
 263     MachineInstrBuilder MIB = BuildMI(MBB, MBBI, dl, TII.get(Opcode));
 264     MIB.addImm(Adjusted);
 265     MIB->addRegisterKilled(XCore::LR, MF.getTarget().getRegisterInfo(), true);
 266     if (emitFrameMoves) {
 267       EmitDefCfaOffset(MBB, MBBI, dl, TII, MMI, Adjusted*4);
 268       unsigned DRegNum = MRI->getDwarfRegNum(XCore::LR, true);
 269       EmitCfiOffset(MBB, MBBI, dl, TII, MMI, DRegNum, 0);
 270     }
 271   }
 272
 273   // If necessary, save LR and FP to the stack, as we EXTSP.
 274   SmallVector<StackSlotInfo,2> SpillList;
 275   GetSpillList(SpillList, MFI, XFI, saveLR, FP);
 276   // We want the nearest (negative) offsets first, so reverse list.
 277   std::reverse(SpillList.begin(), SpillList.end());
 278   for (unsigned i = 0, e = SpillList.size(); i != e; ++i) {
 279     assert(SpillList[i].Offset % 4 == 0 && "Misaligned stack offset");
 280     assert(SpillList[i].Offset <= 0 && "Unexpected positive stack offset");
 281     int OffsetFromTop = - SpillList[i].Offset/4;
 282     IfNeededExtSP(MBB, MBBI, dl, TII, MMI, OffsetFromTop, Adjusted, FrameSize,
 283                   emitFrameMoves);
 284     int Offset = Adjusted - OffsetFromTop;
 285     int Opcode = isImmU6(Offset) ? XCore::STWSP_ru6 : XCore::STWSP_lru6;
 286     MBB.addLiveIn(SpillList[i].Reg);
 287     BuildMI(MBB, MBBI, dl, TII.get(Opcode))
 288       .addReg(SpillList[i].Reg, RegState::Kill)
 289       .addImm(Offset)
 290       .addMemOperand(getFrameIndexMMO(MBB, SpillList[i].FI,
 291                                       MachineMemOperand::MOStore));
 292     if (emitFrameMoves) {
 293       unsigned DRegNum = MRI->getDwarfRegNum(SpillList[i].Reg, true);
 294       EmitCfiOffset(MBB, MBBI, dl, TII, MMI, DRegNum, SpillList[i].Offset);
 295     }
 296   }
 297
 298   // Complete any remaining Stack adjustment.
 299   IfNeededExtSP(MBB, MBBI, dl, TII, MMI, FrameSize, Adjusted, FrameSize,
 300                 emitFrameMoves);
 301   assert(Adjusted==FrameSize && "IfNeededExtSP has not completed adjustment");
 302
 303   if (FP) {
 304     // Set the FP from the SP.
 305     BuildMI(MBB, MBBI, dl, TII.get(XCore::LDAWSP_ru6), FramePtr).addImm(0);
 306     if (emitFrameMoves)
 307       EmitDefCfaRegister(MBB, MBBI, dl, TII, MMI,
 308                          MRI->getDwarfRegNum(FramePtr, true));
 309   }
 310
 311   if (emitFrameMoves) {
 312     // Frame moves for callee saved.
 313     auto SpillLabels = XFI->getSpillLabels();
 314     for (unsigned I = 0, E = SpillLabels.size(); I != E; ++I) {
 315       MachineBasicBlock::iterator Pos = SpillLabels[I].first;
 316       ++Pos;
 317       CalleeSavedInfo &CSI = SpillLabels[I].second;
 318       int Offset = MFI->getObjectOffset(CSI.getFrameIdx());
 319       unsigned DRegNum = MRI->getDwarfRegNum(CSI.getReg(), true);
 320       EmitCfiOffset(MBB, Pos, dl, TII, MMI, DRegNum, Offset);
 321     }
 322     if (XFI->hasEHSpillSlot()) {
 323       // The unwinder requires stack slot & CFI offsets for the exception info.
 324       // We do not save/spill these registers.
 325       SmallVector<StackSlotInfo,2> SpillList;
 326       GetEHSpillList(SpillList, MFI, XFI, MF.getTarget().getTargetLowering());
 327       assert(SpillList.size()==2 && "Unexpected SpillList size");
 328       EmitCfiOffset(MBB, MBBI, dl, TII, MMI,
 329                     MRI->getDwarfRegNum(SpillList[0].Reg, true),
 330                     SpillList[0].Offset);
 331       EmitCfiOffset(MBB, MBBI, dl, TII, MMI,
 332                     MRI->getDwarfRegNum(SpillList[1].Reg, true),
 333                     SpillList[1].Offset);
 334     }
 335   }
 336 }
 337
 338 void XCoreFrameLowering::emitEpilogue(MachineFunction &MF,
 339                                      MachineBasicBlock &MBB) const {
 340   MachineFrameInfo *MFI = MF.getFrameInfo();
 341   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 342   const XCoreInstrInfo &TII =
 343     *static_cast<const XCoreInstrInfo*>(MF.getTarget().getInstrInfo());
 344   XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
 345   DebugLoc dl = MBBI->getDebugLoc();
 346   unsigned RetOpcode = MBBI->getOpcode();
 347
 348   // Work out frame sizes.
 349   // We will adjust the SP in stages towards the final FrameSize.
 350   int RemainingAdj = MFI->getStackSize();
 351   assert(RemainingAdj%4 == 0 && "Misaligned frame size");
 352   RemainingAdj /= 4;
 353
 354   if (RetOpcode == XCore::EH_RETURN) {
 355     // 'Restore' the exception info the unwinder has placed into the stack
 356     // slots.
 357     SmallVector<StackSlotInfo,2> SpillList;
 358     GetEHSpillList(SpillList, MFI, XFI, MF.getTarget().getTargetLowering());
 359     RestoreSpillList(MBB, MBBI, dl, TII, RemainingAdj, SpillList);
 360
 361     // Return to the landing pad.
 362     unsigned EhStackReg = MBBI->getOperand(0).getReg();
 363     unsigned EhHandlerReg = MBBI->getOperand(1).getReg();
 364     BuildMI(MBB, MBBI, dl, TII.get(XCore::SETSP_1r)).addReg(EhStackReg);
 365     BuildMI(MBB, MBBI, dl, TII.get(XCore::BAU_1r)).addReg(EhHandlerReg);
 366     MBB.erase(MBBI);  // Erase the previous return instruction.
 367     return;
 368   }
 369
 370   bool restoreLR = XFI->hasLRSpillSlot();
 371   bool UseRETSP = restoreLR && RemainingAdj
 372                   && (MFI->getObjectOffset(XFI->getLRSpillSlot()) == 0);
 373   if (UseRETSP)
 374     restoreLR = false;
 375   bool FP = hasFP(MF);
 376
 377   if (FP) // Restore the stack pointer.
 378     BuildMI(MBB, MBBI, dl, TII.get(XCore::SETSP_1r)).addReg(FramePtr);
 379
 380   // If necessary, restore LR and FP from the stack, as we EXTSP.
 381   SmallVector<StackSlotInfo,2> SpillList;
 382   GetSpillList(SpillList, MFI, XFI, restoreLR, FP);
 383   RestoreSpillList(MBB, MBBI, dl, TII, RemainingAdj, SpillList);
 384
 385   if (RemainingAdj) {
 386     // Complete all but one of the remaining Stack adjustments.
 387     IfNeededLDAWSP(MBB, MBBI, dl, TII, 0, RemainingAdj);
 388     if (UseRETSP) {
 389       // Fold prologue into return instruction
 390       assert(RetOpcode == XCore::RETSP_u6
 391              || RetOpcode == XCore::RETSP_lu6);
 392       int Opcode = isImmU6(RemainingAdj) ? XCore::RETSP_u6 : XCore::RETSP_lu6;
 393       MachineInstrBuilder MIB = BuildMI(MBB, MBBI, dl, TII.get(Opcode))
 394                                   .addImm(RemainingAdj);
 395       for (unsigned i = 3, e = MBBI->getNumOperands(); i < e; ++i)
 396         MIB->addOperand(MBBI->getOperand(i)); // copy any variadic operands
 397       MBB.erase(MBBI);  // Erase the previous return instruction.
 398     } else {
 399       int Opcode = isImmU6(RemainingAdj) ? XCore::LDAWSP_ru6 :
 400                                            XCore::LDAWSP_lru6;
 401       BuildMI(MBB, MBBI, dl, TII.get(Opcode), XCore::SP).addImm(RemainingAdj);
 402       // Don't erase the return instruction.
 403     }
 404   } // else Don't erase the return instruction.
 405 }
 406
 407 bool XCoreFrameLowering::
 408 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
 409                           MachineBasicBlock::iterator MI,
 410                           const std::vector<CalleeSavedInfo> &CSI,
 411                           const TargetRegisterInfo *TRI) const {
 412   if (CSI.empty())
 413     return true;
 414
 415   MachineFunction *MF = MBB.getParent();
 416   const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
 417   XCoreFunctionInfo *XFI = MF->getInfo<XCoreFunctionInfo>();
 418   bool emitFrameMoves = XCoreRegisterInfo::needsFrameMoves(*MF);
 419
 420   DebugLoc DL;
 421   if (MI != MBB.end() && !MI->isDebugValue())
 422     DL = MI->getDebugLoc();
 423
 424   for (std::vector<CalleeSavedInfo>::const_iterator it = CSI.begin();
 425                                                     it != CSI.end(); ++it) {
 426     unsigned Reg = it->getReg();
 427     assert(Reg != XCore::LR && !(Reg == XCore::R10 && hasFP(*MF)) &&
 428            "LR & FP are always handled in emitPrologue");
 429
 430     // Add the callee-saved register as live-in. It's killed at the spill.
 431     MBB.addLiveIn(Reg);
 432     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
 433     TII.storeRegToStackSlot(MBB, MI, Reg, true, it->getFrameIdx(), RC, TRI);
 434     if (emitFrameMoves) {
 435       auto Store = MI;
 436       --Store;
 437       XFI->getSpillLabels().push_back(std::make_pair(Store, *it));
 438     }
 439   }
 440   return true;
 441 }
 442
 443 bool XCoreFrameLowering::
 444 restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
 445                             MachineBasicBlock::iterator MI,
 446                             const std::vector<CalleeSavedInfo> &CSI,
 447                             const TargetRegisterInfo *TRI) const{
 448   MachineFunction *MF = MBB.getParent();
 449   const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
 450   bool AtStart = MI == MBB.begin();
 451   MachineBasicBlock::iterator BeforeI = MI;
 452   if (!AtStart)
 453     --BeforeI;
 454   for (std::vector<CalleeSavedInfo>::const_iterator it = CSI.begin();
 455                                                     it != CSI.end(); ++it) {
 456     unsigned Reg = it->getReg();
 457     assert(Reg != XCore::LR && !(Reg == XCore::R10 && hasFP(*MF)) &&
 458            "LR & FP are always handled in emitEpilogue");
 459
 460     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
 461     TII.loadRegFromStackSlot(MBB, MI, Reg, it->getFrameIdx(), RC, TRI);
 462     assert(MI != MBB.begin() &&
 463            "loadRegFromStackSlot didn't insert any code!");
 464     // Insert in reverse order.  loadRegFromStackSlot can insert multiple
 465     // instructions.
 466     if (AtStart)
 467       MI = MBB.begin();
 468     else {
 469       MI = BeforeI;
 470       ++MI;
 471     }
 472   }
 473   return true;
 474 }
 475
 476 // This function eliminates ADJCALLSTACKDOWN,
 477 // ADJCALLSTACKUP pseudo instructions
 478 void XCoreFrameLowering::
 479 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
 480                               MachineBasicBlock::iterator I) const {
 481   const XCoreInstrInfo &TII =
 482     *static_cast<const XCoreInstrInfo*>(MF.getTarget().getInstrInfo());
 483   if (!hasReservedCallFrame(MF)) {
 484     // Turn the adjcallstackdown instruction into 'extsp <amt>' and the
 485     // adjcallstackup instruction into 'ldaw sp, sp[<amt>]'
 486     MachineInstr *Old = I;
 487     uint64_t Amount = Old->getOperand(0).getImm();
 488     if (Amount != 0) {
 489       // We need to keep the stack aligned properly.  To do this, we round the
 490       // amount of space needed for the outgoing arguments up to the next
 491       // alignment boundary.
 492       unsigned Align = getStackAlignment();
 493       Amount = (Amount+Align-1)/Align*Align;
 494
 495       assert(Amount%4 == 0);
 496       Amount /= 4;
 497
 498       bool isU6 = isImmU6(Amount);
 499       if (!isU6 && !isImmU16(Amount)) {
 500         // FIX could emit multiple instructions in this case.
 501 #ifndef NDEBUG
 502         errs() << "eliminateCallFramePseudoInstr size too big: "
 503                << Amount << "\n";
 504 #endif
 505         llvm_unreachable(nullptr);
 506       }
 507
 508       MachineInstr *New;
 509       if (Old->getOpcode() == XCore::ADJCALLSTACKDOWN) {
 510         int Opcode = isU6 ? XCore::EXTSP_u6 : XCore::EXTSP_lu6;
 511         New=BuildMI(MF, Old->getDebugLoc(), TII.get(Opcode))
 512           .addImm(Amount);
 513       } else {
 514         assert(Old->getOpcode() == XCore::ADJCALLSTACKUP);
 515         int Opcode = isU6 ? XCore::LDAWSP_ru6 : XCore::LDAWSP_lru6;
 516         New=BuildMI(MF, Old->getDebugLoc(), TII.get(Opcode), XCore::SP)
 517           .addImm(Amount);
 518       }
 519
 520       // Replace the pseudo instruction with a new instruction...
 521       MBB.insert(I, New);
 522     }
 523   }
 524
 525   MBB.erase(I);
 526 }
 527
 528 void XCoreFrameLowering::
 529 processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
 530                                      RegScavenger *RS) const {
 531   XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
 532
 533   bool LRUsed = MF.getRegInfo().isPhysRegUsed(XCore::LR);
 534
 535   if (!LRUsed && !MF.getFunction()->isVarArg() &&
 536       MF.getFrameInfo()->estimateStackSize(MF))
 537     // If we need to extend the stack it is more efficient to use entsp / retsp.
 538     // We force the LR to be saved so these instructions are used.
 539     LRUsed = true;
 540
 541   if (MF.getMMI().callsUnwindInit() || MF.getMMI().callsEHReturn()) {
 542     // The unwinder expects to find spill slots for the exception info regs R0
 543     // & R1. These are used during llvm.eh.return() to 'restore' the exception
 544     // info. N.B. we do not spill or restore R0, R1 during normal operation.
 545     XFI->createEHSpillSlot(MF);
 546     // As we will  have a stack, we force the LR to be saved.
 547     LRUsed = true;
 548   }
 549
 550   if (LRUsed) {
 551     // We will handle the LR in the prologue/epilogue
 552     // and allocate space on the stack ourselves.
 553     MF.getRegInfo().setPhysRegUnused(XCore::LR);
 554     XFI->createLRSpillSlot(MF);
 555   }
 556
 557   if (hasFP(MF))
 558     // A callee save register is used to hold the FP.
 559     // This needs saving / restoring in the epilogue / prologue.
 560     XFI->createFPSpillSlot(MF);
 561 }
 562
 563 void XCoreFrameLowering::
 564 processFunctionBeforeFrameFinalized(MachineFunction &MF,
 565                                     RegScavenger *RS) const {
 566   assert(RS && "requiresRegisterScavenging failed");
 567   MachineFrameInfo *MFI = MF.getFrameInfo();
 568   const TargetRegisterClass *RC = &XCore::GRRegsRegClass;
 569   XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
 570   // Reserve slots close to SP or frame pointer for Scavenging spills.
 571   // When using SP for small frames, we don't need any scratch registers.
 572   // When using SP for large frames, we may need 2 scratch registers.
 573   // When using FP, for large or small frames, we may need 1 scratch register.
 574   if (XFI->isLargeFrame(MF) || hasFP(MF))
 575     RS->addScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
 576                                                        RC->getAlignment(),
 577                                                        false));
 578   if (XFI->isLargeFrame(MF) && !hasFP(MF))
 579     RS->addScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
 580                                                        RC->getAlignment(),
 581                                                        false));
 582 }