lib/Target/Hexagon/HexagonFrameLowering.cpp

   1 //===-- HexagonFrameLowering.cpp - Define frame lowering ------------------===//
   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
  11 #include "HexagonFrameLowering.h"
  12 #include "Hexagon.h"
  13 #include "HexagonInstrInfo.h"
  14 #include "HexagonMachineFunctionInfo.h"
  15 #include "HexagonRegisterInfo.h"
  16 #include "HexagonSubtarget.h"
  17 #include "HexagonTargetMachine.h"
  18 #include "llvm/ADT/BitVector.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/CodeGen/AsmPrinter.h"
  21 #include "llvm/CodeGen/MachineFrameInfo.h"
  22 #include "llvm/CodeGen/MachineFunction.h"
  23 #include "llvm/CodeGen/MachineFunctionPass.h"
  24 #include "llvm/CodeGen/MachineInstrBuilder.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/CodeGen/MachineRegisterInfo.h"
  27 #include "llvm/CodeGen/RegisterScavenging.h"
  28 #include "llvm/IR/Function.h"
  29 #include "llvm/IR/Type.h"
  30 #include "llvm/MC/MCAsmInfo.h"
  31 #include "llvm/MC/MachineLocation.h"
  32 #include "llvm/Support/CommandLine.h"
  33 #include "llvm/Target/TargetInstrInfo.h"
  34 #include "llvm/Target/TargetMachine.h"
  35 #include "llvm/Target/TargetOptions.h"
  36
  37 using namespace llvm;
  38
  39 static cl::opt<bool> DisableDeallocRet(
  40                        "disable-hexagon-dealloc-ret",
  41                        cl::Hidden,
  42                        cl::desc("Disable Dealloc Return for Hexagon target"));
  43
  44 /// determineFrameLayout - Determine the size of the frame and maximum call
  45 /// frame size.
  46 void HexagonFrameLowering::determineFrameLayout(MachineFunction &MF) const {
  47   MachineFrameInfo *MFI = MF.getFrameInfo();
  48
  49   // Get the number of bytes to allocate from the FrameInfo.
  50   unsigned FrameSize = MFI->getStackSize();
  51
  52   // Get the alignments provided by the target.
  53   unsigned TargetAlign = MF.getTarget().getFrameLowering()->getStackAlignment();
  54   // Get the maximum call frame size of all the calls.
  55   unsigned maxCallFrameSize = MFI->getMaxCallFrameSize();
  56
  57   // If we have dynamic alloca then maxCallFrameSize needs to be aligned so
  58   // that allocations will be aligned.
  59   if (MFI->hasVarSizedObjects())
  60     maxCallFrameSize = RoundUpToAlignment(maxCallFrameSize, TargetAlign);
  61
  62   // Update maximum call frame size.
  63   MFI->setMaxCallFrameSize(maxCallFrameSize);
  64
  65   // Include call frame size in total.
  66   FrameSize += maxCallFrameSize;
  67
  68   // Make sure the frame is aligned.
  69   FrameSize = RoundUpToAlignment(FrameSize, TargetAlign);
  70
  71   // Update frame info.
  72   MFI->setStackSize(FrameSize);
  73 }
  74
  75
  76 void HexagonFrameLowering::emitPrologue(MachineFunction &MF) const {
  77   MachineBasicBlock &MBB = MF.front();
  78   MachineFrameInfo *MFI = MF.getFrameInfo();
  79   MachineModuleInfo &MMI = MF.getMMI();
  80   MachineBasicBlock::iterator MBBI = MBB.begin();
  81   const HexagonRegisterInfo *QRI =
  82     static_cast<const HexagonRegisterInfo *>(MF.getTarget().getRegisterInfo());
  83   DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
  84   determineFrameLayout(MF);
  85
  86   // Check if frame moves are needed for EH.
  87   bool needsFrameMoves = MMI.hasDebugInfo() ||
  88     !MF.getFunction()->needsUnwindTableEntry();
  89
  90   // Get the number of bytes to allocate from the FrameInfo.
  91   int NumBytes = (int) MFI->getStackSize();
  92
  93   // LLVM expects allocframe not to be the first instruction in the
  94   // basic block.
  95   MachineBasicBlock::iterator InsertPt = MBB.begin();
  96
  97   //
  98   // ALLOCA adjust regs.  Iterate over ADJDYNALLOC nodes and change the offset.
  99   //
 100   HexagonMachineFunctionInfo *FuncInfo =
 101     MF.getInfo<HexagonMachineFunctionInfo>();
 102   const std::vector<MachineInstr*>& AdjustRegs =
 103     FuncInfo->getAllocaAdjustInsts();
 104   for (std::vector<MachineInstr*>::const_iterator i = AdjustRegs.begin(),
 105          e = AdjustRegs.end();
 106        i != e; ++i) {
 107     MachineInstr* MI = *i;
 108     assert((MI->getOpcode() == Hexagon::ADJDYNALLOC) &&
 109            "Expected adjust alloca node");
 110
 111     MachineOperand& MO = MI->getOperand(2);
 112     assert(MO.isImm() && "Expected immediate");
 113     MO.setImm(MFI->getMaxCallFrameSize());
 114   }
 115
 116  std::vector<MachineMove> &Moves = MMI.getFrameMoves();
 117
 118  if (needsFrameMoves) {
 119    // Advance CFA. DW_CFA_def_cfa
 120    unsigned FPReg = QRI->getFrameRegister();
 121    unsigned RAReg = QRI->getRARegister();
 122
 123    MachineLocation Dst(MachineLocation::VirtualFP);
 124    MachineLocation Src(FPReg, -8);
 125    Moves.push_back(MachineMove(0, Dst, Src));
 126
 127    // R31 = (R31 - #4)
 128    MachineLocation LRDst(RAReg, -4);
 129    MachineLocation LRSrc(RAReg);
 130    Moves.push_back(MachineMove(0, LRDst, LRSrc));
 131
 132    // R30 = (R30 - #8)
 133    MachineLocation SPDst(FPReg, -8);
 134    MachineLocation SPSrc(FPReg);
 135    Moves.push_back(MachineMove(0, SPDst, SPSrc));
 136  }
 137
 138   //
 139   // Only insert ALLOCFRAME if we need to.
 140   //
 141   if (hasFP(MF)) {
 142     // Check for overflow.
 143     // Hexagon_TODO: Ugh! hardcoding. Is there an API that can be used?
 144     const int ALLOCFRAME_MAX = 16384;
 145     const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
 146
 147     if (NumBytes >= ALLOCFRAME_MAX) {
 148       // Emit allocframe(#0).
 149       BuildMI(MBB, InsertPt, dl, TII.get(Hexagon::ALLOCFRAME)).addImm(0);
 150
 151       // Subtract offset from frame pointer.
 152       BuildMI(MBB, InsertPt, dl, TII.get(Hexagon::CONST32_Int_Real),
 153                                       HEXAGON_RESERVED_REG_1).addImm(NumBytes);
 154       BuildMI(MBB, InsertPt, dl, TII.get(Hexagon::SUB_rr),
 155                                       QRI->getStackRegister()).
 156                                       addReg(QRI->getStackRegister()).
 157                                       addReg(HEXAGON_RESERVED_REG_1);
 158     } else {
 159       BuildMI(MBB, InsertPt, dl, TII.get(Hexagon::ALLOCFRAME)).addImm(NumBytes);
 160     }
 161   }
 162 }
 163 // Returns true if MBB has a machine instructions that indicates a tail call
 164 // in the block.
 165 bool HexagonFrameLowering::hasTailCall(MachineBasicBlock &MBB) const {
 166   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 167   unsigned RetOpcode = MBBI->getOpcode();
 168
 169   return RetOpcode == Hexagon::TCRETURNtg || RetOpcode == Hexagon::TCRETURNtext;
 170 }
 171
 172 void HexagonFrameLowering::emitEpilogue(MachineFunction &MF,
 173                                      MachineBasicBlock &MBB) const {
 174   MachineBasicBlock::iterator MBBI = prior(MBB.end());
 175   DebugLoc dl = MBBI->getDebugLoc();
 176   //
 177   // Only insert deallocframe if we need to.  Also at -O0.  See comment
 178   // in emitPrologue above.
 179   //
 180   if (hasFP(MF) || MF.getTarget().getOptLevel() == CodeGenOpt::None) {
 181     MachineBasicBlock::iterator MBBI = prior(MBB.end());
 182     MachineBasicBlock::iterator MBBI_end = MBB.end();
 183
 184     const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
 185     // Handle EH_RETURN.
 186     if (MBBI->getOpcode() == Hexagon::EH_RETURN_JMPR) {
 187       MachineOperand &OffsetReg  = MBBI->getOperand(0);
 188       assert(OffsetReg.isReg() && "Offset should be in register!");
 189       BuildMI(MBB, MBBI, dl, TII.get(Hexagon::DEALLOCFRAME));
 190       BuildMI(MBB, MBBI, dl, TII.get(Hexagon::ADD_rr),
 191               Hexagon::R29).addReg(Hexagon::R29).addReg(Hexagon::R28);
 192       return;
 193     }
 194     // Replace 'jumpr r31' instruction with dealloc_return for V4 and higher
 195     // versions.
 196     if (STI.hasV4TOps() && MBBI->getOpcode() == Hexagon::JMPret
 197                         && !DisableDeallocRet) {
 198       // Check for RESTORE_DEALLOC_RET_JMP_V4 call. Don't emit an extra DEALLOC
 199       // instruction if we encounter it.
 200       MachineBasicBlock::iterator BeforeJMPR =
 201         MBB.begin() == MBBI ? MBBI : prior(MBBI);
 202       if (BeforeJMPR != MBBI &&
 203           BeforeJMPR->getOpcode() == Hexagon::RESTORE_DEALLOC_RET_JMP_V4) {
 204         // Remove the JMPR node.
 205         MBB.erase(MBBI);
 206         return;
 207       }
 208
 209       // Add dealloc_return.
 210       MachineInstrBuilder MIB =
 211         BuildMI(MBB, MBBI_end, dl, TII.get(Hexagon::DEALLOC_RET_V4));
 212       // Transfer the function live-out registers.
 213       MIB->copyImplicitOps(*MBB.getParent(), &*MBBI);
 214       // Remove the JUMPR node.
 215       MBB.erase(MBBI);
 216     } else { // Add deallocframe for V2 and V3, and V4 tail calls.
 217       // Check for RESTORE_DEALLOC_BEFORE_TAILCALL_V4. We don't need an extra
 218       // DEALLOCFRAME instruction after it.
 219       MachineBasicBlock::iterator Term = MBB.getFirstTerminator();
 220       MachineBasicBlock::iterator I =
 221         Term == MBB.begin() ?  MBB.end() : prior(Term);
 222       if (I != MBB.end() &&
 223           I->getOpcode() == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4)
 224         return;
 225
 226       BuildMI(MBB, MBBI, dl, TII.get(Hexagon::DEALLOCFRAME));
 227     }
 228   }
 229 }
 230
 231 bool HexagonFrameLowering::hasFP(const MachineFunction &MF) const {
 232   const MachineFrameInfo *MFI = MF.getFrameInfo();
 233   const HexagonMachineFunctionInfo *FuncInfo =
 234     MF.getInfo<HexagonMachineFunctionInfo>();
 235   return (MFI->hasCalls() || (MFI->getStackSize() > 0) ||
 236           FuncInfo->hasClobberLR() );
 237 }
 238
 239 static inline
 240 unsigned uniqueSuperReg(unsigned Reg, const TargetRegisterInfo *TRI) {
 241   MCSuperRegIterator SRI(Reg, TRI);
 242   assert(SRI.isValid() && "Expected a superreg");
 243   unsigned SuperReg = *SRI;
 244   ++SRI;
 245   assert(!SRI.isValid() && "Expected exactly one superreg");
 246   return SuperReg;
 247 }
 248
 249 bool
 250 HexagonFrameLowering::spillCalleeSavedRegisters(
 251                                         MachineBasicBlock &MBB,
 252                                         MachineBasicBlock::iterator MI,
 253                                         const std::vector<CalleeSavedInfo> &CSI,
 254                                         const TargetRegisterInfo *TRI) const {
 255   MachineFunction *MF = MBB.getParent();
 256   const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
 257
 258   if (CSI.empty()) {
 259     return false;
 260   }
 261
 262   // We can only schedule double loads if we spill contiguous callee-saved regs
 263   // For instance, we cannot scheduled double-word loads if we spill r24,
 264   // r26, and r27.
 265   // Hexagon_TODO: We can try to double-word align odd registers for -O2 and
 266   // above.
 267   bool ContiguousRegs = true;
 268
 269   for (unsigned i = 0; i < CSI.size(); ++i) {
 270     unsigned Reg = CSI[i].getReg();
 271
 272     //
 273     // Check if we can use a double-word store.
 274     //
 275     unsigned SuperReg = uniqueSuperReg(Reg, TRI);
 276     bool CanUseDblStore = false;
 277     const TargetRegisterClass* SuperRegClass = 0;
 278
 279     if (ContiguousRegs && (i < CSI.size()-1)) {
 280       unsigned SuperRegNext = uniqueSuperReg(CSI[i+1].getReg(), TRI);
 281       SuperRegClass = TRI->getMinimalPhysRegClass(SuperReg);
 282       CanUseDblStore = (SuperRegNext == SuperReg);
 283     }
 284
 285
 286     if (CanUseDblStore) {
 287       TII.storeRegToStackSlot(MBB, MI, SuperReg, true,
 288                               CSI[i+1].getFrameIdx(), SuperRegClass, TRI);
 289       MBB.addLiveIn(SuperReg);
 290       ++i;
 291     } else {
 292       // Cannot use a double-word store.
 293       ContiguousRegs = false;
 294       const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
 295       TII.storeRegToStackSlot(MBB, MI, Reg, true, CSI[i].getFrameIdx(), RC,
 296                               TRI);
 297       MBB.addLiveIn(Reg);
 298     }
 299   }
 300   return true;
 301 }
 302
 303
 304 bool HexagonFrameLowering::restoreCalleeSavedRegisters(
 305                                         MachineBasicBlock &MBB,
 306                                         MachineBasicBlock::iterator MI,
 307                                         const std::vector<CalleeSavedInfo> &CSI,
 308                                         const TargetRegisterInfo *TRI) const {
 309
 310   MachineFunction *MF = MBB.getParent();
 311   const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
 312
 313   if (CSI.empty()) {
 314     return false;
 315   }
 316
 317   // We can only schedule double loads if we spill contiguous callee-saved regs
 318   // For instance, we cannot scheduled double-word loads if we spill r24,
 319   // r26, and r27.
 320   // Hexagon_TODO: We can try to double-word align odd registers for -O2 and
 321   // above.
 322   bool ContiguousRegs = true;
 323
 324   for (unsigned i = 0; i < CSI.size(); ++i) {
 325     unsigned Reg = CSI[i].getReg();
 326
 327     //
 328     // Check if we can use a double-word load.
 329     //
 330     unsigned SuperReg = uniqueSuperReg(Reg, TRI);
 331     const TargetRegisterClass* SuperRegClass = 0;
 332     bool CanUseDblLoad = false;
 333     if (ContiguousRegs && (i < CSI.size()-1)) {
 334       unsigned SuperRegNext = uniqueSuperReg(CSI[i+1].getReg(), TRI);
 335       SuperRegClass = TRI->getMinimalPhysRegClass(SuperReg);
 336       CanUseDblLoad = (SuperRegNext == SuperReg);
 337     }
 338
 339
 340     if (CanUseDblLoad) {
 341       TII.loadRegFromStackSlot(MBB, MI, SuperReg, CSI[i+1].getFrameIdx(),
 342                                SuperRegClass, TRI);
 343       MBB.addLiveIn(SuperReg);
 344       ++i;
 345     } else {
 346       // Cannot use a double-word load.
 347       ContiguousRegs = false;
 348       const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
 349       TII.loadRegFromStackSlot(MBB, MI, Reg, CSI[i].getFrameIdx(), RC, TRI);
 350       MBB.addLiveIn(Reg);
 351     }
 352   }
 353   return true;
 354 }
 355
 356 void HexagonFrameLowering::
 357 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
 358                               MachineBasicBlock::iterator I) const {
 359   MachineInstr &MI = *I;
 360
 361   if (MI.getOpcode() == Hexagon::ADJCALLSTACKDOWN) {
 362     // Hexagon_TODO: add code
 363   } else if (MI.getOpcode() == Hexagon::ADJCALLSTACKUP) {
 364     // Hexagon_TODO: add code
 365   } else {
 366     llvm_unreachable("Cannot handle this call frame pseudo instruction");
 367   }
 368   MBB.erase(I);
 369 }
 370
 371 int HexagonFrameLowering::getFrameIndexOffset(const MachineFunction &MF,
 372                                               int FI) const {
 373   return MF.getFrameInfo()->getObjectOffset(FI);
 374 }