contrib/llvm/lib/Target/Mips/MipsSEFrameLowering.cpp

   1 //===-- MipsSEFrameLowering.cpp - Mips32/64 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 Mips32/64 implementation of TargetFrameLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MCTargetDesc/MipsABIInfo.h"
  15 #include "MipsMachineFunction.h"
  16 #include "MipsRegisterInfo.h"
  17 #include "MipsSEFrameLowering.h"
  18 #include "MipsSEInstrInfo.h"
  19 #include "MipsSubtarget.h"
  20 #include "llvm/ADT/BitVector.h"
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/ADT/StringSwitch.h"
  23 #include "llvm/CodeGen/MachineBasicBlock.h"
  24 #include "llvm/CodeGen/MachineFrameInfo.h"
  25 #include "llvm/CodeGen/MachineFunction.h"
  26 #include "llvm/CodeGen/MachineInstr.h"
  27 #include "llvm/CodeGen/MachineInstrBuilder.h"
  28 #include "llvm/CodeGen/MachineModuleInfo.h"
  29 #include "llvm/CodeGen/MachineOperand.h"
  30 #include "llvm/CodeGen/MachineRegisterInfo.h"
  31 #include "llvm/CodeGen/RegisterScavenging.h"
  32 #include "llvm/IR/DebugLoc.h"
  33 #include "llvm/IR/Function.h"
  34 #include "llvm/MC/MCDwarf.h"
  35 #include "llvm/MC/MCRegisterInfo.h"
  36 #include "llvm/MC/MachineLocation.h"
  37 #include "llvm/Support/CodeGen.h"
  38 #include "llvm/Support/ErrorHandling.h"
  39 #include "llvm/Support/MathExtras.h"
  40 #include "llvm/Target/TargetInstrInfo.h"
  41 #include "llvm/Target/TargetRegisterInfo.h"
  42 #include "llvm/Target/TargetSubtargetInfo.h"
  43 #include <cassert>
  44 #include <cstdint>
  45 #include <utility>
  46 #include <vector>
  47
  48 using namespace llvm;
  49
  50 static std::pair<unsigned, unsigned> getMFHiLoOpc(unsigned Src) {
  51   if (Mips::ACC64RegClass.contains(Src))
  52     return std::make_pair((unsigned)Mips::PseudoMFHI,
  53                           (unsigned)Mips::PseudoMFLO);
  54
  55   if (Mips::ACC64DSPRegClass.contains(Src))
  56     return std::make_pair((unsigned)Mips::MFHI_DSP, (unsigned)Mips::MFLO_DSP);
  57
  58   if (Mips::ACC128RegClass.contains(Src))
  59     return std::make_pair((unsigned)Mips::PseudoMFHI64,
  60                           (unsigned)Mips::PseudoMFLO64);
  61
  62   return std::make_pair(0, 0);
  63 }
  64
  65 namespace {
  66
  67 /// Helper class to expand pseudos.
  68 class ExpandPseudo {
  69 public:
  70   ExpandPseudo(MachineFunction &MF);
  71   bool expand();
  72
  73 private:
  74   typedef MachineBasicBlock::iterator Iter;
  75
  76   bool expandInstr(MachineBasicBlock &MBB, Iter I);
  77   void expandLoadCCond(MachineBasicBlock &MBB, Iter I);
  78   void expandStoreCCond(MachineBasicBlock &MBB, Iter I);
  79   void expandLoadACC(MachineBasicBlock &MBB, Iter I, unsigned RegSize);
  80   void expandStoreACC(MachineBasicBlock &MBB, Iter I, unsigned MFHiOpc,
  81                       unsigned MFLoOpc, unsigned RegSize);
  82   bool expandCopy(MachineBasicBlock &MBB, Iter I);
  83   bool expandCopyACC(MachineBasicBlock &MBB, Iter I, unsigned MFHiOpc,
  84                      unsigned MFLoOpc);
  85   bool expandBuildPairF64(MachineBasicBlock &MBB,
  86                           MachineBasicBlock::iterator I, bool FP64) const;
  87   bool expandExtractElementF64(MachineBasicBlock &MBB,
  88                                MachineBasicBlock::iterator I, bool FP64) const;
  89
  90   MachineFunction &MF;
  91   MachineRegisterInfo &MRI;
  92   const MipsSubtarget &Subtarget;
  93   const MipsSEInstrInfo &TII;
  94   const MipsRegisterInfo &RegInfo;
  95 };
  96
  97 } // end anonymous namespace
  98
  99 ExpandPseudo::ExpandPseudo(MachineFunction &MF_)
 100     : MF(MF_), MRI(MF.getRegInfo()),
 101       Subtarget(static_cast<const MipsSubtarget &>(MF.getSubtarget())),
 102       TII(*static_cast<const MipsSEInstrInfo *>(Subtarget.getInstrInfo())),
 103       RegInfo(*Subtarget.getRegisterInfo()) {}
 104
 105 bool ExpandPseudo::expand() {
 106   bool Expanded = false;
 107
 108   for (auto &MBB : MF) {
 109     for (Iter I = MBB.begin(), End = MBB.end(); I != End;)
 110       Expanded |= expandInstr(MBB, I++);
 111   }
 112
 113   return Expanded;
 114 }
 115
 116 bool ExpandPseudo::expandInstr(MachineBasicBlock &MBB, Iter I) {
 117   switch(I->getOpcode()) {
 118   case Mips::LOAD_CCOND_DSP:
 119     expandLoadCCond(MBB, I);
 120     break;
 121   case Mips::STORE_CCOND_DSP:
 122     expandStoreCCond(MBB, I);
 123     break;
 124   case Mips::LOAD_ACC64:
 125   case Mips::LOAD_ACC64DSP:
 126     expandLoadACC(MBB, I, 4);
 127     break;
 128   case Mips::LOAD_ACC128:
 129     expandLoadACC(MBB, I, 8);
 130     break;
 131   case Mips::STORE_ACC64:
 132     expandStoreACC(MBB, I, Mips::PseudoMFHI, Mips::PseudoMFLO, 4);
 133     break;
 134   case Mips::STORE_ACC64DSP:
 135     expandStoreACC(MBB, I, Mips::MFHI_DSP, Mips::MFLO_DSP, 4);
 136     break;
 137   case Mips::STORE_ACC128:
 138     expandStoreACC(MBB, I, Mips::PseudoMFHI64, Mips::PseudoMFLO64, 8);
 139     break;
 140   case Mips::BuildPairF64:
 141     if (expandBuildPairF64(MBB, I, false))
 142       MBB.erase(I);
 143     return false;
 144   case Mips::BuildPairF64_64:
 145     if (expandBuildPairF64(MBB, I, true))
 146       MBB.erase(I);
 147     return false;
 148   case Mips::ExtractElementF64:
 149     if (expandExtractElementF64(MBB, I, false))
 150       MBB.erase(I);
 151     return false;
 152   case Mips::ExtractElementF64_64:
 153     if (expandExtractElementF64(MBB, I, true))
 154       MBB.erase(I);
 155     return false;
 156   case TargetOpcode::COPY:
 157     if (!expandCopy(MBB, I))
 158       return false;
 159     break;
 160   default:
 161     return false;
 162   }
 163
 164   MBB.erase(I);
 165   return true;
 166 }
 167
 168 void ExpandPseudo::expandLoadCCond(MachineBasicBlock &MBB, Iter I) {
 169   //  load $vr, FI
 170   //  copy ccond, $vr
 171
 172   assert(I->getOperand(0).isReg() && I->getOperand(1).isFI());
 173
 174   const TargetRegisterClass *RC = RegInfo.intRegClass(4);
 175   unsigned VR = MRI.createVirtualRegister(RC);
 176   unsigned Dst = I->getOperand(0).getReg(), FI = I->getOperand(1).getIndex();
 177
 178   TII.loadRegFromStack(MBB, I, VR, FI, RC, &RegInfo, 0);
 179   BuildMI(MBB, I, I->getDebugLoc(), TII.get(TargetOpcode::COPY), Dst)
 180     .addReg(VR, RegState::Kill);
 181 }
 182
 183 void ExpandPseudo::expandStoreCCond(MachineBasicBlock &MBB, Iter I) {
 184   //  copy $vr, ccond
 185   //  store $vr, FI
 186
 187   assert(I->getOperand(0).isReg() && I->getOperand(1).isFI());
 188
 189   const TargetRegisterClass *RC = RegInfo.intRegClass(4);
 190   unsigned VR = MRI.createVirtualRegister(RC);
 191   unsigned Src = I->getOperand(0).getReg(), FI = I->getOperand(1).getIndex();
 192
 193   BuildMI(MBB, I, I->getDebugLoc(), TII.get(TargetOpcode::COPY), VR)
 194     .addReg(Src, getKillRegState(I->getOperand(0).isKill()));
 195   TII.storeRegToStack(MBB, I, VR, true, FI, RC, &RegInfo, 0);
 196 }
 197
 198 void ExpandPseudo::expandLoadACC(MachineBasicBlock &MBB, Iter I,
 199                                  unsigned RegSize) {
 200   //  load $vr0, FI
 201   //  copy lo, $vr0
 202   //  load $vr1, FI + 4
 203   //  copy hi, $vr1
 204
 205   assert(I->getOperand(0).isReg() && I->getOperand(1).isFI());
 206
 207   const TargetRegisterClass *RC = RegInfo.intRegClass(RegSize);
 208   unsigned VR0 = MRI.createVirtualRegister(RC);
 209   unsigned VR1 = MRI.createVirtualRegister(RC);
 210   unsigned Dst = I->getOperand(0).getReg(), FI = I->getOperand(1).getIndex();
 211   unsigned Lo = RegInfo.getSubReg(Dst, Mips::sub_lo);
 212   unsigned Hi = RegInfo.getSubReg(Dst, Mips::sub_hi);
 213   DebugLoc DL = I->getDebugLoc();
 214   const MCInstrDesc &Desc = TII.get(TargetOpcode::COPY);
 215
 216   TII.loadRegFromStack(MBB, I, VR0, FI, RC, &RegInfo, 0);
 217   BuildMI(MBB, I, DL, Desc, Lo).addReg(VR0, RegState::Kill);
 218   TII.loadRegFromStack(MBB, I, VR1, FI, RC, &RegInfo, RegSize);
 219   BuildMI(MBB, I, DL, Desc, Hi).addReg(VR1, RegState::Kill);
 220 }
 221
 222 void ExpandPseudo::expandStoreACC(MachineBasicBlock &MBB, Iter I,
 223                                   unsigned MFHiOpc, unsigned MFLoOpc,
 224                                   unsigned RegSize) {
 225   //  mflo $vr0, src
 226   //  store $vr0, FI
 227   //  mfhi $vr1, src
 228   //  store $vr1, FI + 4
 229
 230   assert(I->getOperand(0).isReg() && I->getOperand(1).isFI());
 231
 232   const TargetRegisterClass *RC = RegInfo.intRegClass(RegSize);
 233   unsigned VR0 = MRI.createVirtualRegister(RC);
 234   unsigned VR1 = MRI.createVirtualRegister(RC);
 235   unsigned Src = I->getOperand(0).getReg(), FI = I->getOperand(1).getIndex();
 236   unsigned SrcKill = getKillRegState(I->getOperand(0).isKill());
 237   DebugLoc DL = I->getDebugLoc();
 238
 239   BuildMI(MBB, I, DL, TII.get(MFLoOpc), VR0).addReg(Src);
 240   TII.storeRegToStack(MBB, I, VR0, true, FI, RC, &RegInfo, 0);
 241   BuildMI(MBB, I, DL, TII.get(MFHiOpc), VR1).addReg(Src, SrcKill);
 242   TII.storeRegToStack(MBB, I, VR1, true, FI, RC, &RegInfo, RegSize);
 243 }
 244
 245 bool ExpandPseudo::expandCopy(MachineBasicBlock &MBB, Iter I) {
 246   unsigned Src = I->getOperand(1).getReg();
 247   std::pair<unsigned, unsigned> Opcodes = getMFHiLoOpc(Src);
 248
 249   if (!Opcodes.first)
 250     return false;
 251
 252   return expandCopyACC(MBB, I, Opcodes.first, Opcodes.second);
 253 }
 254
 255 bool ExpandPseudo::expandCopyACC(MachineBasicBlock &MBB, Iter I,
 256                                  unsigned MFHiOpc, unsigned MFLoOpc) {
 257   //  mflo $vr0, src
 258   //  copy dst_lo, $vr0
 259   //  mfhi $vr1, src
 260   //  copy dst_hi, $vr1
 261
 262   unsigned Dst = I->getOperand(0).getReg(), Src = I->getOperand(1).getReg();
 263   const TargetRegisterClass *DstRC = RegInfo.getMinimalPhysRegClass(Dst);
 264   unsigned VRegSize = RegInfo.getRegSizeInBits(*DstRC) / 16;
 265   const TargetRegisterClass *RC = RegInfo.intRegClass(VRegSize);
 266   unsigned VR0 = MRI.createVirtualRegister(RC);
 267   unsigned VR1 = MRI.createVirtualRegister(RC);
 268   unsigned SrcKill = getKillRegState(I->getOperand(1).isKill());
 269   unsigned DstLo = RegInfo.getSubReg(Dst, Mips::sub_lo);
 270   unsigned DstHi = RegInfo.getSubReg(Dst, Mips::sub_hi);
 271   DebugLoc DL = I->getDebugLoc();
 272
 273   BuildMI(MBB, I, DL, TII.get(MFLoOpc), VR0).addReg(Src);
 274   BuildMI(MBB, I, DL, TII.get(TargetOpcode::COPY), DstLo)
 275     .addReg(VR0, RegState::Kill);
 276   BuildMI(MBB, I, DL, TII.get(MFHiOpc), VR1).addReg(Src, SrcKill);
 277   BuildMI(MBB, I, DL, TII.get(TargetOpcode::COPY), DstHi)
 278     .addReg(VR1, RegState::Kill);
 279   return true;
 280 }
 281
 282 /// This method expands the same instruction that MipsSEInstrInfo::
 283 /// expandBuildPairF64 does, for the case when ABI is fpxx and mthc1 is not
 284 /// available and the case where the ABI is FP64A. It is implemented here
 285 /// because frame indexes are eliminated before MipsSEInstrInfo::
 286 /// expandBuildPairF64 is called.
 287 bool ExpandPseudo::expandBuildPairF64(MachineBasicBlock &MBB,
 288                                       MachineBasicBlock::iterator I,
 289                                       bool FP64) const {
 290   // For fpxx and when mthc1 is not available, use:
 291   //   spill + reload via ldc1
 292   //
 293   // The case where dmtc1 is available doesn't need to be handled here
 294   // because it never creates a BuildPairF64 node.
 295   //
 296   // The FP64A ABI (fp64 with nooddspreg) must also use a spill/reload sequence
 297   // for odd-numbered double precision values (because the lower 32-bits is
 298   // transferred with mtc1 which is redirected to the upper half of the even
 299   // register). Unfortunately, we have to make this decision before register
 300   // allocation so for now we use a spill/reload sequence for all
 301   // double-precision values in regardless of being an odd/even register.
 302   if ((Subtarget.isABI_FPXX() && !Subtarget.hasMTHC1()) ||
 303       (FP64 && !Subtarget.useOddSPReg())) {
 304     unsigned DstReg = I->getOperand(0).getReg();
 305     unsigned LoReg = I->getOperand(1).getReg();
 306     unsigned HiReg = I->getOperand(2).getReg();
 307
 308     // It should be impossible to have FGR64 on MIPS-II or MIPS32r1 (which are
 309     // the cases where mthc1 is not available). 64-bit architectures and
 310     // MIPS32r2 or later can use FGR64 though.
 311     assert(Subtarget.isGP64bit() || Subtarget.hasMTHC1() ||
 312            !Subtarget.isFP64bit());
 313
 314     const TargetRegisterClass *RC = &Mips::GPR32RegClass;
 315     const TargetRegisterClass *RC2 =
 316         FP64 ? &Mips::FGR64RegClass : &Mips::AFGR64RegClass;
 317
 318     // We re-use the same spill slot each time so that the stack frame doesn't
 319     // grow too much in functions with a large number of moves.
 320     int FI = MF.getInfo<MipsFunctionInfo>()->getMoveF64ViaSpillFI(RC2);
 321     if (!Subtarget.isLittle())
 322       std::swap(LoReg, HiReg);
 323     TII.storeRegToStack(MBB, I, LoReg, I->getOperand(1).isKill(), FI, RC,
 324                         &RegInfo, 0);
 325     TII.storeRegToStack(MBB, I, HiReg, I->getOperand(2).isKill(), FI, RC,
 326                         &RegInfo, 4);
 327     TII.loadRegFromStack(MBB, I, DstReg, FI, RC2, &RegInfo, 0);
 328     return true;
 329   }
 330
 331   return false;
 332 }
 333
 334 /// This method expands the same instruction that MipsSEInstrInfo::
 335 /// expandExtractElementF64 does, for the case when ABI is fpxx and mfhc1 is not
 336 /// available and the case where the ABI is FP64A. It is implemented here
 337 /// because frame indexes are eliminated before MipsSEInstrInfo::
 338 /// expandExtractElementF64 is called.
 339 bool ExpandPseudo::expandExtractElementF64(MachineBasicBlock &MBB,
 340                                            MachineBasicBlock::iterator I,
 341                                            bool FP64) const {
 342   const MachineOperand &Op1 = I->getOperand(1);
 343   const MachineOperand &Op2 = I->getOperand(2);
 344
 345   if ((Op1.isReg() && Op1.isUndef()) || (Op2.isReg() && Op2.isUndef())) {
 346     unsigned DstReg = I->getOperand(0).getReg();
 347     BuildMI(MBB, I, I->getDebugLoc(), TII.get(Mips::IMPLICIT_DEF), DstReg);
 348     return true;
 349   }
 350
 351   // For fpxx and when mfhc1 is not available, use:
 352   //   spill + reload via ldc1
 353   //
 354   // The case where dmfc1 is available doesn't need to be handled here
 355   // because it never creates a ExtractElementF64 node.
 356   //
 357   // The FP64A ABI (fp64 with nooddspreg) must also use a spill/reload sequence
 358   // for odd-numbered double precision values (because the lower 32-bits is
 359   // transferred with mfc1 which is redirected to the upper half of the even
 360   // register). Unfortunately, we have to make this decision before register
 361   // allocation so for now we use a spill/reload sequence for all
 362   // double-precision values in regardless of being an odd/even register.
 363
 364   if ((Subtarget.isABI_FPXX() && !Subtarget.hasMTHC1()) ||
 365       (FP64 && !Subtarget.useOddSPReg())) {
 366     unsigned DstReg = I->getOperand(0).getReg();
 367     unsigned SrcReg = Op1.getReg();
 368     unsigned N = Op2.getImm();
 369     int64_t Offset = 4 * (Subtarget.isLittle() ? N : (1 - N));
 370
 371     // It should be impossible to have FGR64 on MIPS-II or MIPS32r1 (which are
 372     // the cases where mfhc1 is not available). 64-bit architectures and
 373     // MIPS32r2 or later can use FGR64 though.
 374     assert(Subtarget.isGP64bit() || Subtarget.hasMTHC1() ||
 375            !Subtarget.isFP64bit());
 376
 377     const TargetRegisterClass *RC =
 378         FP64 ? &Mips::FGR64RegClass : &Mips::AFGR64RegClass;
 379     const TargetRegisterClass *RC2 = &Mips::GPR32RegClass;
 380
 381     // We re-use the same spill slot each time so that the stack frame doesn't
 382     // grow too much in functions with a large number of moves.
 383     int FI = MF.getInfo<MipsFunctionInfo>()->getMoveF64ViaSpillFI(RC);
 384     TII.storeRegToStack(MBB, I, SrcReg, Op1.isKill(), FI, RC, &RegInfo, 0);
 385     TII.loadRegFromStack(MBB, I, DstReg, FI, RC2, &RegInfo, Offset);
 386     return true;
 387   }
 388
 389   return false;
 390 }
 391
 392 MipsSEFrameLowering::MipsSEFrameLowering(const MipsSubtarget &STI)
 393     : MipsFrameLowering(STI, STI.stackAlignment()) {}
 394
 395 void MipsSEFrameLowering::emitPrologue(MachineFunction &MF,
 396                                        MachineBasicBlock &MBB) const {
 397   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
 398   MachineFrameInfo &MFI    = MF.getFrameInfo();
 399   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
 400
 401   const MipsSEInstrInfo &TII =
 402       *static_cast<const MipsSEInstrInfo *>(STI.getInstrInfo());
 403   const MipsRegisterInfo &RegInfo =
 404       *static_cast<const MipsRegisterInfo *>(STI.getRegisterInfo());
 405
 406   MachineBasicBlock::iterator MBBI = MBB.begin();
 407   DebugLoc dl;
 408   MipsABIInfo ABI = STI.getABI();
 409   unsigned SP = ABI.GetStackPtr();
 410   unsigned FP = ABI.GetFramePtr();
 411   unsigned ZERO = ABI.GetNullPtr();
 412   unsigned MOVE = ABI.GetGPRMoveOp();
 413   unsigned ADDiu = ABI.GetPtrAddiuOp();
 414   unsigned AND = ABI.IsN64() ? Mips::AND64 : Mips::AND;
 415
 416   const TargetRegisterClass *RC = ABI.ArePtrs64bit() ?
 417         &Mips::GPR64RegClass : &Mips::GPR32RegClass;
 418
 419   // First, compute final stack size.
 420   uint64_t StackSize = MFI.getStackSize();
 421
 422   // No need to allocate space on the stack.
 423   if (StackSize == 0 && !MFI.adjustsStack()) return;
 424
 425   MachineModuleInfo &MMI = MF.getMMI();
 426   const MCRegisterInfo *MRI = MMI.getContext().getRegisterInfo();
 427   MachineLocation DstML, SrcML;
 428
 429   // Adjust stack.
 430   TII.adjustStackPtr(SP, -StackSize, MBB, MBBI);
 431
 432   // emit ".cfi_def_cfa_offset StackSize"
 433   unsigned CFIIndex = MF.addFrameInst(
 434       MCCFIInstruction::createDefCfaOffset(nullptr, -StackSize));
 435   BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 436       .addCFIIndex(CFIIndex);
 437
 438   if (MF.getFunction()->hasFnAttribute("interrupt"))
 439     emitInterruptPrologueStub(MF, MBB);
 440
 441   const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
 442
 443   if (!CSI.empty()) {
 444     // Find the instruction past the last instruction that saves a callee-saved
 445     // register to the stack.
 446     for (unsigned i = 0; i < CSI.size(); ++i)
 447       ++MBBI;
 448
 449     // Iterate over list of callee-saved registers and emit .cfi_offset
 450     // directives.
 451     for (std::vector<CalleeSavedInfo>::const_iterator I = CSI.begin(),
 452            E = CSI.end(); I != E; ++I) {
 453       int64_t Offset = MFI.getObjectOffset(I->getFrameIdx());
 454       unsigned Reg = I->getReg();
 455
 456       // If Reg is a double precision register, emit two cfa_offsets,
 457       // one for each of the paired single precision registers.
 458       if (Mips::AFGR64RegClass.contains(Reg)) {
 459         unsigned Reg0 =
 460             MRI->getDwarfRegNum(RegInfo.getSubReg(Reg, Mips::sub_lo), true);
 461         unsigned Reg1 =
 462             MRI->getDwarfRegNum(RegInfo.getSubReg(Reg, Mips::sub_hi), true);
 463
 464         if (!STI.isLittle())
 465           std::swap(Reg0, Reg1);
 466
 467         unsigned CFIIndex = MF.addFrameInst(
 468             MCCFIInstruction::createOffset(nullptr, Reg0, Offset));
 469         BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 470             .addCFIIndex(CFIIndex);
 471
 472         CFIIndex = MF.addFrameInst(
 473             MCCFIInstruction::createOffset(nullptr, Reg1, Offset + 4));
 474         BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 475             .addCFIIndex(CFIIndex);
 476       } else if (Mips::FGR64RegClass.contains(Reg)) {
 477         unsigned Reg0 = MRI->getDwarfRegNum(Reg, true);
 478         unsigned Reg1 = MRI->getDwarfRegNum(Reg, true) + 1;
 479
 480         if (!STI.isLittle())
 481           std::swap(Reg0, Reg1);
 482
 483         unsigned CFIIndex = MF.addFrameInst(
 484           MCCFIInstruction::createOffset(nullptr, Reg0, Offset));
 485         BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 486             .addCFIIndex(CFIIndex);
 487
 488         CFIIndex = MF.addFrameInst(
 489           MCCFIInstruction::createOffset(nullptr, Reg1, Offset + 4));
 490         BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 491             .addCFIIndex(CFIIndex);
 492       } else {
 493         // Reg is either in GPR32 or FGR32.
 494         unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
 495             nullptr, MRI->getDwarfRegNum(Reg, true), Offset));
 496         BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 497             .addCFIIndex(CFIIndex);
 498       }
 499     }
 500   }
 501
 502   if (MipsFI->callsEhReturn()) {
 503     // Insert instructions that spill eh data registers.
 504     for (int I = 0; I < 4; ++I) {
 505       if (!MBB.isLiveIn(ABI.GetEhDataReg(I)))
 506         MBB.addLiveIn(ABI.GetEhDataReg(I));
 507       TII.storeRegToStackSlot(MBB, MBBI, ABI.GetEhDataReg(I), false,
 508                               MipsFI->getEhDataRegFI(I), RC, &RegInfo);
 509     }
 510
 511     // Emit .cfi_offset directives for eh data registers.
 512     for (int I = 0; I < 4; ++I) {
 513       int64_t Offset = MFI.getObjectOffset(MipsFI->getEhDataRegFI(I));
 514       unsigned Reg = MRI->getDwarfRegNum(ABI.GetEhDataReg(I), true);
 515       unsigned CFIIndex = MF.addFrameInst(
 516           MCCFIInstruction::createOffset(nullptr, Reg, Offset));
 517       BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 518           .addCFIIndex(CFIIndex);
 519     }
 520   }
 521
 522   // if framepointer enabled, set it to point to the stack pointer.
 523   if (hasFP(MF)) {
 524     // Insert instruction "move $fp, $sp" at this location.
 525     BuildMI(MBB, MBBI, dl, TII.get(MOVE), FP).addReg(SP).addReg(ZERO)
 526       .setMIFlag(MachineInstr::FrameSetup);
 527
 528     // emit ".cfi_def_cfa_register $fp"
 529     unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(
 530         nullptr, MRI->getDwarfRegNum(FP, true)));
 531     BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 532         .addCFIIndex(CFIIndex);
 533
 534     if (RegInfo.needsStackRealignment(MF)) {
 535       // addiu $Reg, $zero, -MaxAlignment
 536       // andi $sp, $sp, $Reg
 537       unsigned VR = MF.getRegInfo().createVirtualRegister(RC);
 538       assert(isInt<16>(MFI.getMaxAlignment()) &&
 539              "Function's alignment size requirement is not supported.");
 540       int MaxAlign = -(int)MFI.getMaxAlignment();
 541
 542       BuildMI(MBB, MBBI, dl, TII.get(ADDiu), VR).addReg(ZERO) .addImm(MaxAlign);
 543       BuildMI(MBB, MBBI, dl, TII.get(AND), SP).addReg(SP).addReg(VR);
 544
 545       if (hasBP(MF)) {
 546         // move $s7, $sp
 547         unsigned BP = STI.isABI_N64() ? Mips::S7_64 : Mips::S7;
 548         BuildMI(MBB, MBBI, dl, TII.get(MOVE), BP)
 549           .addReg(SP)
 550           .addReg(ZERO);
 551       }
 552     }
 553   }
 554 }
 555
 556 void MipsSEFrameLowering::emitInterruptPrologueStub(
 557     MachineFunction &MF, MachineBasicBlock &MBB) const {
 558   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
 559   MachineBasicBlock::iterator MBBI = MBB.begin();
 560   DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
 561
 562   // Report an error the target doesn't support Mips32r2 or later.
 563   // The epilogue relies on the use of the "ehb" to clear execution
 564   // hazards. Pre R2 Mips relies on an implementation defined number
 565   // of "ssnop"s to clear the execution hazard. Support for ssnop hazard
 566   // clearing is not provided so reject that configuration.
 567   if (!STI.hasMips32r2())
 568     report_fatal_error(
 569         "\"interrupt\" attribute is not supported on pre-MIPS32R2 or "
 570         "MIPS16 targets.");
 571
 572   // The GP register contains the "user" value, so we cannot perform
 573   // any gp relative loads until we restore the "kernel" or "system" gp
 574   // value. Until support is written we shall only accept the static
 575   // relocation model.
 576   if ((STI.getRelocationModel() != Reloc::Static))
 577     report_fatal_error("\"interrupt\" attribute is only supported for the "
 578                        "static relocation model on MIPS at the present time.");
 579
 580   if (!STI.isABI_O32() || STI.hasMips64())
 581     report_fatal_error("\"interrupt\" attribute is only supported for the "
 582                        "O32 ABI on MIPS32R2+ at the present time.");
 583
 584   // Perform ISR handling like GCC
 585   StringRef IntKind =
 586       MF.getFunction()->getFnAttribute("interrupt").getValueAsString();
 587   const TargetRegisterClass *PtrRC = &Mips::GPR32RegClass;
 588
 589   // EIC interrupt handling needs to read the Cause register to disable
 590   // interrupts.
 591   if (IntKind == "eic") {
 592     // Coprocessor registers are always live per se.
 593     MBB.addLiveIn(Mips::COP013);
 594     BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::MFC0), Mips::K0)
 595         .addReg(Mips::COP013)
 596         .addImm(0)
 597         .setMIFlag(MachineInstr::FrameSetup);
 598
 599     BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::EXT), Mips::K0)
 600         .addReg(Mips::K0)
 601         .addImm(10)
 602         .addImm(6)
 603         .setMIFlag(MachineInstr::FrameSetup);
 604   }
 605
 606   // Fetch and spill EPC
 607   MBB.addLiveIn(Mips::COP014);
 608   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::MFC0), Mips::K1)
 609       .addReg(Mips::COP014)
 610       .addImm(0)
 611       .setMIFlag(MachineInstr::FrameSetup);
 612
 613   STI.getInstrInfo()->storeRegToStack(MBB, MBBI, Mips::K1, false,
 614                                       MipsFI->getISRRegFI(0), PtrRC,
 615                                       STI.getRegisterInfo(), 0);
 616
 617   // Fetch and Spill Status
 618   MBB.addLiveIn(Mips::COP012);
 619   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::MFC0), Mips::K1)
 620       .addReg(Mips::COP012)
 621       .addImm(0)
 622       .setMIFlag(MachineInstr::FrameSetup);
 623
 624   STI.getInstrInfo()->storeRegToStack(MBB, MBBI, Mips::K1, false,
 625                                       MipsFI->getISRRegFI(1), PtrRC,
 626                                       STI.getRegisterInfo(), 0);
 627
 628   // Build the configuration for disabling lower priority interrupts. Non EIC
 629   // interrupts need to be masked off with zero, EIC from the Cause register.
 630   unsigned InsPosition = 8;
 631   unsigned InsSize = 0;
 632   unsigned SrcReg = Mips::ZERO;
 633
 634   // If the interrupt we're tied to is the EIC, switch the source for the
 635   // masking off interrupts to the cause register.
 636   if (IntKind == "eic") {
 637     SrcReg = Mips::K0;
 638     InsPosition = 10;
 639     InsSize = 6;
 640   } else
 641     InsSize = StringSwitch<unsigned>(IntKind)
 642                   .Case("sw0", 1)
 643                   .Case("sw1", 2)
 644                   .Case("hw0", 3)
 645                   .Case("hw1", 4)
 646                   .Case("hw2", 5)
 647                   .Case("hw3", 6)
 648                   .Case("hw4", 7)
 649                   .Case("hw5", 8)
 650                   .Default(0);
 651   assert(InsSize != 0 && "Unknown interrupt type!");
 652
 653   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::INS), Mips::K1)
 654       .addReg(SrcReg)
 655       .addImm(InsPosition)
 656       .addImm(InsSize)
 657       .addReg(Mips::K1)
 658       .setMIFlag(MachineInstr::FrameSetup);
 659
 660   // Mask off KSU, ERL, EXL
 661   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::INS), Mips::K1)
 662       .addReg(Mips::ZERO)
 663       .addImm(1)
 664       .addImm(4)
 665       .addReg(Mips::K1)
 666       .setMIFlag(MachineInstr::FrameSetup);
 667
 668   // Disable the FPU as we are not spilling those register sets.
 669   if (!STI.useSoftFloat())
 670     BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::INS), Mips::K1)
 671         .addReg(Mips::ZERO)
 672         .addImm(29)
 673         .addImm(1)
 674         .addReg(Mips::K1)
 675         .setMIFlag(MachineInstr::FrameSetup);
 676
 677   // Set the new status
 678   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::MTC0), Mips::COP012)
 679       .addReg(Mips::K1)
 680       .addImm(0)
 681       .setMIFlag(MachineInstr::FrameSetup);
 682 }
 683
 684 void MipsSEFrameLowering::emitEpilogue(MachineFunction &MF,
 685                                        MachineBasicBlock &MBB) const {
 686   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 687   MachineFrameInfo &MFI            = MF.getFrameInfo();
 688   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
 689
 690   const MipsSEInstrInfo &TII =
 691       *static_cast<const MipsSEInstrInfo *>(STI.getInstrInfo());
 692   const MipsRegisterInfo &RegInfo =
 693       *static_cast<const MipsRegisterInfo *>(STI.getRegisterInfo());
 694
 695   DebugLoc DL = MBBI->getDebugLoc();
 696   MipsABIInfo ABI = STI.getABI();
 697   unsigned SP = ABI.GetStackPtr();
 698   unsigned FP = ABI.GetFramePtr();
 699   unsigned ZERO = ABI.GetNullPtr();
 700   unsigned MOVE = ABI.GetGPRMoveOp();
 701
 702   // if framepointer enabled, restore the stack pointer.
 703   if (hasFP(MF)) {
 704     // Find the first instruction that restores a callee-saved register.
 705     MachineBasicBlock::iterator I = MBBI;
 706
 707     for (unsigned i = 0; i < MFI.getCalleeSavedInfo().size(); ++i)
 708       --I;
 709
 710     // Insert instruction "move $sp, $fp" at this location.
 711     BuildMI(MBB, I, DL, TII.get(MOVE), SP).addReg(FP).addReg(ZERO);
 712   }
 713
 714   if (MipsFI->callsEhReturn()) {
 715     const TargetRegisterClass *RC =
 716         ABI.ArePtrs64bit() ? &Mips::GPR64RegClass : &Mips::GPR32RegClass;
 717
 718     // Find first instruction that restores a callee-saved register.
 719     MachineBasicBlock::iterator I = MBBI;
 720     for (unsigned i = 0; i < MFI.getCalleeSavedInfo().size(); ++i)
 721       --I;
 722
 723     // Insert instructions that restore eh data registers.
 724     for (int J = 0; J < 4; ++J) {
 725       TII.loadRegFromStackSlot(MBB, I, ABI.GetEhDataReg(J),
 726                                MipsFI->getEhDataRegFI(J), RC, &RegInfo);
 727     }
 728   }
 729
 730   if (MF.getFunction()->hasFnAttribute("interrupt"))
 731     emitInterruptEpilogueStub(MF, MBB);
 732
 733   // Get the number of bytes from FrameInfo
 734   uint64_t StackSize = MFI.getStackSize();
 735
 736   if (!StackSize)
 737     return;
 738
 739   // Adjust stack.
 740   TII.adjustStackPtr(SP, StackSize, MBB, MBBI);
 741 }
 742
 743 void MipsSEFrameLowering::emitInterruptEpilogueStub(
 744     MachineFunction &MF, MachineBasicBlock &MBB) const {
 745   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 746   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
 747   DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
 748
 749   // Perform ISR handling like GCC
 750   const TargetRegisterClass *PtrRC = &Mips::GPR32RegClass;
 751
 752   // Disable Interrupts.
 753   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::DI), Mips::ZERO);
 754   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::EHB));
 755
 756   // Restore EPC
 757   STI.getInstrInfo()->loadRegFromStackSlot(MBB, MBBI, Mips::K1,
 758                                            MipsFI->getISRRegFI(0), PtrRC,
 759                                            STI.getRegisterInfo());
 760   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::MTC0), Mips::COP014)
 761       .addReg(Mips::K1)
 762       .addImm(0);
 763
 764   // Restore Status
 765   STI.getInstrInfo()->loadRegFromStackSlot(MBB, MBBI, Mips::K1,
 766                                            MipsFI->getISRRegFI(1), PtrRC,
 767                                            STI.getRegisterInfo());
 768   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::MTC0), Mips::COP012)
 769       .addReg(Mips::K1)
 770       .addImm(0);
 771 }
 772
 773 int MipsSEFrameLowering::getFrameIndexReference(const MachineFunction &MF,
 774                                                 int FI,
 775                                                 unsigned &FrameReg) const {
 776   const MachineFrameInfo &MFI = MF.getFrameInfo();
 777   MipsABIInfo ABI = STI.getABI();
 778
 779   if (MFI.isFixedObjectIndex(FI))
 780     FrameReg = hasFP(MF) ? ABI.GetFramePtr() : ABI.GetStackPtr();
 781   else
 782     FrameReg = hasBP(MF) ? ABI.GetBasePtr() : ABI.GetStackPtr();
 783
 784   return MFI.getObjectOffset(FI) + MFI.getStackSize() -
 785          getOffsetOfLocalArea() + MFI.getOffsetAdjustment();
 786 }
 787
 788 bool MipsSEFrameLowering::
 789 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
 790                           MachineBasicBlock::iterator MI,
 791                           const std::vector<CalleeSavedInfo> &CSI,
 792                           const TargetRegisterInfo *TRI) const {
 793   MachineFunction *MF = MBB.getParent();
 794   MachineBasicBlock *EntryBlock = &MF->front();
 795   const TargetInstrInfo &TII = *STI.getInstrInfo();
 796
 797   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 798     // Add the callee-saved register as live-in. Do not add if the register is
 799     // RA and return address is taken, because it has already been added in
 800     // method MipsTargetLowering::lowerRETURNADDR.
 801     // It's killed at the spill, unless the register is RA and return address
 802     // is taken.
 803     unsigned Reg = CSI[i].getReg();
 804     bool IsRAAndRetAddrIsTaken = (Reg == Mips::RA || Reg == Mips::RA_64)
 805         && MF->getFrameInfo().isReturnAddressTaken();
 806     if (!IsRAAndRetAddrIsTaken)
 807       EntryBlock->addLiveIn(Reg);
 808
 809     // ISRs require HI/LO to be spilled into kernel registers to be then
 810     // spilled to the stack frame.
 811     bool IsLOHI = (Reg == Mips::LO0 || Reg == Mips::LO0_64 ||
 812                    Reg == Mips::HI0 || Reg == Mips::HI0_64);
 813     const Function *Func = MBB.getParent()->getFunction();
 814     if (IsLOHI && Func->hasFnAttribute("interrupt")) {
 815       DebugLoc DL = MI->getDebugLoc();
 816
 817       unsigned Op = 0;
 818       if (!STI.getABI().ArePtrs64bit()) {
 819         Op = (Reg == Mips::HI0) ? Mips::MFHI : Mips::MFLO;
 820         Reg = Mips::K0;
 821       } else {
 822         Op = (Reg == Mips::HI0) ? Mips::MFHI64 : Mips::MFLO64;
 823         Reg = Mips::K0_64;
 824       }
 825       BuildMI(MBB, MI, DL, TII.get(Op), Mips::K0)
 826           .setMIFlag(MachineInstr::FrameSetup);
 827     }
 828
 829     // Insert the spill to the stack frame.
 830     bool IsKill = !IsRAAndRetAddrIsTaken;
 831     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
 832     TII.storeRegToStackSlot(*EntryBlock, MI, Reg, IsKill,
 833                             CSI[i].getFrameIdx(), RC, TRI);
 834   }
 835
 836   return true;
 837 }
 838
 839 bool
 840 MipsSEFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
 841   const MachineFrameInfo &MFI = MF.getFrameInfo();
 842   // Reserve call frame if the size of the maximum call frame fits into 16-bit
 843   // immediate field and there are no variable sized objects on the stack.
 844   // Make sure the second register scavenger spill slot can be accessed with one
 845   // instruction.
 846   return isInt<16>(MFI.getMaxCallFrameSize() + getStackAlignment()) &&
 847     !MFI.hasVarSizedObjects();
 848 }
 849
 850 /// Mark \p Reg and all registers aliasing it in the bitset.
 851 static void setAliasRegs(MachineFunction &MF, BitVector &SavedRegs,
 852                          unsigned Reg) {
 853   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
 854   for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
 855     SavedRegs.set(*AI);
 856 }
 857
 858 void MipsSEFrameLowering::determineCalleeSaves(MachineFunction &MF,
 859                                                BitVector &SavedRegs,
 860                                                RegScavenger *RS) const {
 861   TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
 862   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
 863   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
 864   MipsABIInfo ABI = STI.getABI();
 865   unsigned FP = ABI.GetFramePtr();
 866   unsigned BP = ABI.IsN64() ? Mips::S7_64 : Mips::S7;
 867
 868   // Mark $fp as used if function has dedicated frame pointer.
 869   if (hasFP(MF))
 870     setAliasRegs(MF, SavedRegs, FP);
 871   // Mark $s7 as used if function has dedicated base pointer.
 872   if (hasBP(MF))
 873     setAliasRegs(MF, SavedRegs, BP);
 874
 875   // Create spill slots for eh data registers if function calls eh_return.
 876   if (MipsFI->callsEhReturn())
 877     MipsFI->createEhDataRegsFI();
 878
 879   // Create spill slots for Coprocessor 0 registers if function is an ISR.
 880   if (MipsFI->isISR())
 881     MipsFI->createISRRegFI();
 882
 883   // Expand pseudo instructions which load, store or copy accumulators.
 884   // Add an emergency spill slot if a pseudo was expanded.
 885   if (ExpandPseudo(MF).expand()) {
 886     // The spill slot should be half the size of the accumulator. If target is
 887     // mips64, it should be 64-bit, otherwise it should be 32-bt.
 888     const TargetRegisterClass &RC = STI.hasMips64() ?
 889       Mips::GPR64RegClass : Mips::GPR32RegClass;
 890     int FI = MF.getFrameInfo().CreateStackObject(TRI->getSpillSize(RC),
 891                                                  TRI->getSpillAlignment(RC),
 892                                                  false);
 893     RS->addScavengingFrameIndex(FI);
 894   }
 895
 896   // Set scavenging frame index if necessary.
 897   uint64_t MaxSPOffset = MF.getInfo<MipsFunctionInfo>()->getIncomingArgSize() +
 898     estimateStackSize(MF);
 899
 900   if (isInt<16>(MaxSPOffset))
 901     return;
 902
 903   const TargetRegisterClass &RC =
 904       ABI.ArePtrs64bit() ? Mips::GPR64RegClass : Mips::GPR32RegClass;
 905   int FI = MF.getFrameInfo().CreateStackObject(TRI->getSpillSize(RC),
 906                                                TRI->getSpillAlignment(RC),
 907                                                false);
 908   RS->addScavengingFrameIndex(FI);
 909 }
 910
 911 const MipsFrameLowering *
 912 llvm::createMipsSEFrameLowering(const MipsSubtarget &ST) {
 913   return new MipsSEFrameLowering(ST);
 914 }