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 =
  54       MF.getSubtarget().getFrameLowering()->getStackAlignment();
  55   // Get the maximum call frame size of all the calls.
  56   unsigned maxCallFrameSize = MFI->getMaxCallFrameSize();
  57
  58   // If we have dynamic alloca then maxCallFrameSize needs to be aligned so
  59   // that allocations will be aligned.
  60   if (MFI->hasVarSizedObjects())
  61     maxCallFrameSize = RoundUpToAlignment(maxCallFrameSize, TargetAlign);
  62
  63   // Update maximum call frame size.
  64   MFI->setMaxCallFrameSize(maxCallFrameSize);
  65
  66   // Include call frame size in total.
  67   FrameSize += maxCallFrameSize;
  68
  69   // Make sure the frame is aligned.
  70   FrameSize = RoundUpToAlignment(FrameSize, TargetAlign);
  71
  72   // Update frame info.
  73   MFI->setStackSize(FrameSize);
  74 }
  75
  76
  77 void HexagonFrameLowering::emitPrologue(MachineFunction &MF) const {
  78   MachineBasicBlock &MBB = MF.front();
  79   MachineFrameInfo *MFI = MF.getFrameInfo();
  80   MachineBasicBlock::iterator MBBI = MBB.begin();
  81   const HexagonRegisterInfo *QRI =
  82       MF.getSubtarget<HexagonSubtarget>().getRegisterInfo();
  83   DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
  84   determineFrameLayout(MF);
  85
  86   // Get the number of bytes to allocate from the FrameInfo.
  87   int NumBytes = (int) MFI->getStackSize();
  88
  89   // LLVM expects allocframe not to be the first instruction in the
  90   // basic block.
  91   MachineBasicBlock::iterator InsertPt = MBB.begin();
  92
  93   //
  94   // ALLOCA adjust regs.  Iterate over ADJDYNALLOC nodes and change the offset.
  95   //
  96   HexagonMachineFunctionInfo *FuncInfo =
  97     MF.getInfo<HexagonMachineFunctionInfo>();
  98   const std::vector<MachineInstr*>& AdjustRegs =
  99     FuncInfo->getAllocaAdjustInsts();
 100   for (std::vector<MachineInstr*>::const_iterator i = AdjustRegs.begin(),
 101          e = AdjustRegs.end();
 102        i != e; ++i) {
 103     MachineInstr* MI = *i;
 104     assert((MI->getOpcode() == Hexagon::ADJDYNALLOC) &&
 105            "Expected adjust alloca node");
 106
 107     MachineOperand& MO = MI->getOperand(2);
 108     assert(MO.isImm() && "Expected immediate");
 109     MO.setImm(MFI->getMaxCallFrameSize());
 110   }
 111
 112   //
 113   // Only insert ALLOCFRAME if we need to.
 114   //
 115   if (hasFP(MF)) {
 116     // Check for overflow.
 117     // Hexagon_TODO: Ugh! hardcoding. Is there an API that can be used?
 118     const int ALLOCFRAME_MAX = 16384;
 119     const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
 120
 121     if (NumBytes >= ALLOCFRAME_MAX) {
 122       // Emit allocframe(#0).
 123       BuildMI(MBB, InsertPt, dl, TII.get(Hexagon::S2_allocframe)).addImm(0);
 124
 125       // Subtract offset from frame pointer.
 126       BuildMI(MBB, InsertPt, dl, TII.get(Hexagon::CONST32_Int_Real),
 127                                       HEXAGON_RESERVED_REG_1).addImm(NumBytes);
 128       BuildMI(MBB, InsertPt, dl, TII.get(Hexagon::A2_sub),
 129                                       QRI->getStackRegister()).
 130                                       addReg(QRI->getStackRegister()).
 131                                       addReg(HEXAGON_RESERVED_REG_1);
 132     } else {
 133       BuildMI(MBB, InsertPt, dl, TII.get(Hexagon::S2_allocframe)).addImm(NumBytes);
 134     }
 135   }
 136 }
 137 // Returns true if MBB has a machine instructions that indicates a tail call
 138 // in the block.
 139 bool HexagonFrameLowering::hasTailCall(MachineBasicBlock &MBB) const {
 140   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 141   unsigned RetOpcode = MBBI->getOpcode();
 142
 143   return RetOpcode == Hexagon::TCRETURNtg || RetOpcode == Hexagon::TCRETURNtext;
 144 }
 145
 146 void HexagonFrameLowering::emitEpilogue(MachineFunction &MF,
 147                                      MachineBasicBlock &MBB) const {
 148   MachineBasicBlock::iterator MBBI = std::prev(MBB.end());
 149   DebugLoc dl = MBBI->getDebugLoc();
 150   //
 151   // Only insert deallocframe if we need to.  Also at -O0.  See comment
 152   // in emitPrologue above.
 153   //
 154   if (hasFP(MF) || MF.getTarget().getOptLevel() == CodeGenOpt::None) {
 155     MachineBasicBlock::iterator MBBI = std::prev(MBB.end());
 156     MachineBasicBlock::iterator MBBI_end = MBB.end();
 157
 158     const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
 159     // Handle EH_RETURN.
 160     if (MBBI->getOpcode() == Hexagon::EH_RETURN_JMPR) {
 161       assert(MBBI->getOperand(0).isReg() && "Offset should be in register!");
 162       BuildMI(MBB, MBBI, dl, TII.get(Hexagon::L2_deallocframe));
 163       BuildMI(MBB, MBBI, dl, TII.get(Hexagon::A2_add),
 164               Hexagon::R29).addReg(Hexagon::R29).addReg(Hexagon::R28);
 165       return;
 166     }
 167     // Replace 'jumpr r31' instruction with dealloc_return for V4 and higher
 168     // versions.
 169     if (MF.getSubtarget<HexagonSubtarget>().hasV4TOps() &&
 170         MBBI->getOpcode() == Hexagon::JMPret && !DisableDeallocRet) {
 171       // Check for RESTORE_DEALLOC_RET_JMP_V4 call. Don't emit an extra DEALLOC
 172       // instruction if we encounter it.
 173       MachineBasicBlock::iterator BeforeJMPR =
 174         MBB.begin() == MBBI ? MBBI : std::prev(MBBI);
 175       if (BeforeJMPR != MBBI &&
 176           BeforeJMPR->getOpcode() == Hexagon::RESTORE_DEALLOC_RET_JMP_V4) {
 177         // Remove the JMPR node.
 178         MBB.erase(MBBI);
 179         return;
 180       }
 181
 182       // Add dealloc_return.
 183       MachineInstrBuilder MIB =
 184         BuildMI(MBB, MBBI_end, dl, TII.get(Hexagon::L4_return));
 185       // Transfer the function live-out registers.
 186       MIB->copyImplicitOps(*MBB.getParent(), &*MBBI);
 187       // Remove the JUMPR node.
 188       MBB.erase(MBBI);
 189     } else { // Add deallocframe for V2 and V3, and V4 tail calls.
 190       // Check for RESTORE_DEALLOC_BEFORE_TAILCALL_V4. We don't need an extra
 191       // DEALLOCFRAME instruction after it.
 192       MachineBasicBlock::iterator Term = MBB.getFirstTerminator();
 193       MachineBasicBlock::iterator I =
 194         Term == MBB.begin() ?  MBB.end() : std::prev(Term);
 195       if (I != MBB.end() &&
 196           I->getOpcode() == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4)
 197         return;
 198
 199       BuildMI(MBB, MBBI, dl, TII.get(Hexagon::L2_deallocframe));
 200     }
 201   }
 202 }
 203
 204 bool HexagonFrameLowering::hasFP(const MachineFunction &MF) const {
 205   const MachineFrameInfo *MFI = MF.getFrameInfo();
 206   const HexagonMachineFunctionInfo *FuncInfo =
 207     MF.getInfo<HexagonMachineFunctionInfo>();
 208   return (MFI->hasCalls() || (MFI->getStackSize() > 0) ||
 209           FuncInfo->hasClobberLR() );
 210 }
 211
 212 static inline
 213 unsigned uniqueSuperReg(unsigned Reg, const TargetRegisterInfo *TRI) {
 214   MCSuperRegIterator SRI(Reg, TRI);
 215   assert(SRI.isValid() && "Expected a superreg");
 216   unsigned SuperReg = *SRI;
 217   ++SRI;
 218   assert(!SRI.isValid() && "Expected exactly one superreg");
 219   return SuperReg;
 220 }
 221
 222 bool
 223 HexagonFrameLowering::spillCalleeSavedRegisters(
 224                                         MachineBasicBlock &MBB,
 225                                         MachineBasicBlock::iterator MI,
 226                                         const std::vector<CalleeSavedInfo> &CSI,
 227                                         const TargetRegisterInfo *TRI) const {
 228   MachineFunction *MF = MBB.getParent();
 229   const TargetInstrInfo &TII = *MF->getSubtarget().getInstrInfo();
 230
 231   if (CSI.empty()) {
 232     return false;
 233   }
 234
 235   // We can only schedule double loads if we spill contiguous callee-saved regs
 236   // For instance, we cannot scheduled double-word loads if we spill r24,
 237   // r26, and r27.
 238   // Hexagon_TODO: We can try to double-word align odd registers for -O2 and
 239   // above.
 240   bool ContiguousRegs = true;
 241
 242   for (unsigned i = 0; i < CSI.size(); ++i) {
 243     unsigned Reg = CSI[i].getReg();
 244
 245     //
 246     // Check if we can use a double-word store.
 247     //
 248     unsigned SuperReg = uniqueSuperReg(Reg, TRI);
 249     bool CanUseDblStore = false;
 250     const TargetRegisterClass* SuperRegClass = nullptr;
 251
 252     if (ContiguousRegs && (i < CSI.size()-1)) {
 253       unsigned SuperRegNext = uniqueSuperReg(CSI[i+1].getReg(), TRI);
 254       SuperRegClass = TRI->getMinimalPhysRegClass(SuperReg);
 255       CanUseDblStore = (SuperRegNext == SuperReg);
 256     }
 257
 258
 259     if (CanUseDblStore) {
 260       TII.storeRegToStackSlot(MBB, MI, SuperReg, true,
 261                               CSI[i+1].getFrameIdx(), SuperRegClass, TRI);
 262       MBB.addLiveIn(SuperReg);
 263       ++i;
 264     } else {
 265       // Cannot use a double-word store.
 266       ContiguousRegs = false;
 267       const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
 268       TII.storeRegToStackSlot(MBB, MI, Reg, true, CSI[i].getFrameIdx(), RC,
 269                               TRI);
 270       MBB.addLiveIn(Reg);
 271     }
 272   }
 273   return true;
 274 }
 275
 276
 277 bool HexagonFrameLowering::restoreCalleeSavedRegisters(
 278                                         MachineBasicBlock &MBB,
 279                                         MachineBasicBlock::iterator MI,
 280                                         const std::vector<CalleeSavedInfo> &CSI,
 281                                         const TargetRegisterInfo *TRI) const {
 282
 283   MachineFunction *MF = MBB.getParent();
 284   const TargetInstrInfo &TII = *MF->getSubtarget().getInstrInfo();
 285
 286   if (CSI.empty()) {
 287     return false;
 288   }
 289
 290   // We can only schedule double loads if we spill contiguous callee-saved regs
 291   // For instance, we cannot scheduled double-word loads if we spill r24,
 292   // r26, and r27.
 293   // Hexagon_TODO: We can try to double-word align odd registers for -O2 and
 294   // above.
 295   bool ContiguousRegs = true;
 296
 297   for (unsigned i = 0; i < CSI.size(); ++i) {
 298     unsigned Reg = CSI[i].getReg();
 299
 300     //
 301     // Check if we can use a double-word load.
 302     //
 303     unsigned SuperReg = uniqueSuperReg(Reg, TRI);
 304     const TargetRegisterClass* SuperRegClass = nullptr;
 305     bool CanUseDblLoad = false;
 306     if (ContiguousRegs && (i < CSI.size()-1)) {
 307       unsigned SuperRegNext = uniqueSuperReg(CSI[i+1].getReg(), TRI);
 308       SuperRegClass = TRI->getMinimalPhysRegClass(SuperReg);
 309       CanUseDblLoad = (SuperRegNext == SuperReg);
 310     }
 311
 312
 313     if (CanUseDblLoad) {
 314       TII.loadRegFromStackSlot(MBB, MI, SuperReg, CSI[i+1].getFrameIdx(),
 315                                SuperRegClass, TRI);
 316       MBB.addLiveIn(SuperReg);
 317       ++i;
 318     } else {
 319       // Cannot use a double-word load.
 320       ContiguousRegs = false;
 321       const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
 322       TII.loadRegFromStackSlot(MBB, MI, Reg, CSI[i].getFrameIdx(), RC, TRI);
 323       MBB.addLiveIn(Reg);
 324     }
 325   }
 326   return true;
 327 }
 328
 329 void HexagonFrameLowering::
 330 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
 331                               MachineBasicBlock::iterator I) const {
 332   MachineInstr &MI = *I;
 333
 334   if (MI.getOpcode() == Hexagon::ADJCALLSTACKDOWN) {
 335     // Hexagon_TODO: add code
 336   } else if (MI.getOpcode() == Hexagon::ADJCALLSTACKUP) {
 337     // Hexagon_TODO: add code
 338   } else {
 339     llvm_unreachable("Cannot handle this call frame pseudo instruction");
 340   }
 341   MBB.erase(I);
 342 }
 343
 344 int HexagonFrameLowering::getFrameIndexOffset(const MachineFunction &MF,
 345                                               int FI) const {
 346   return MF.getFrameInfo()->getObjectOffset(FI);
 347 }