lib/Target/RISCV/RISCVFrameLowering.cpp

   1 //===-- RISCVFrameLowering.cpp - RISCV 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 RISCV implementation of TargetFrameLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "RISCVFrameLowering.h"
  15 #include "RISCVMachineFunctionInfo.h"
  16 #include "RISCVSubtarget.h"
  17 #include "llvm/CodeGen/MachineFrameInfo.h"
  18 #include "llvm/CodeGen/MachineFunction.h"
  19 #include "llvm/CodeGen/MachineInstrBuilder.h"
  20 #include "llvm/CodeGen/MachineRegisterInfo.h"
  21 #include "llvm/CodeGen/RegisterScavenging.h"
  22
  23 using namespace llvm;
  24
  25 bool RISCVFrameLowering::hasFP(const MachineFunction &MF) const {
  26   const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
  27
  28   const MachineFrameInfo &MFI = MF.getFrameInfo();
  29   return MF.getTarget().Options.DisableFramePointerElim(MF) ||
  30          RegInfo->needsStackRealignment(MF) || MFI.hasVarSizedObjects() ||
  31          MFI.isFrameAddressTaken();
  32 }
  33
  34 // Determines the size of the frame and maximum call frame size.
  35 void RISCVFrameLowering::determineFrameLayout(MachineFunction &MF) const {
  36   MachineFrameInfo &MFI = MF.getFrameInfo();
  37   const RISCVRegisterInfo *RI = STI.getRegisterInfo();
  38
  39   // Get the number of bytes to allocate from the FrameInfo.
  40   uint64_t FrameSize = MFI.getStackSize();
  41
  42   // Get the alignment.
  43   uint64_t StackAlign = RI->needsStackRealignment(MF) ? MFI.getMaxAlignment()
  44                                                       : getStackAlignment();
  45
  46   // Make sure the frame is aligned.
  47   FrameSize = alignTo(FrameSize, StackAlign);
  48
  49   // Update frame info.
  50   MFI.setStackSize(FrameSize);
  51 }
  52
  53 void RISCVFrameLowering::adjustReg(MachineBasicBlock &MBB,
  54                                    MachineBasicBlock::iterator MBBI,
  55                                    const DebugLoc &DL, unsigned DestReg,
  56                                    unsigned SrcReg, int64_t Val,
  57                                    MachineInstr::MIFlag Flag) const {
  58   MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
  59   const RISCVInstrInfo *TII = STI.getInstrInfo();
  60
  61   if (DestReg == SrcReg && Val == 0)
  62     return;
  63
  64   if (isInt<12>(Val)) {
  65     BuildMI(MBB, MBBI, DL, TII->get(RISCV::ADDI), DestReg)
  66         .addReg(SrcReg)
  67         .addImm(Val)
  68         .setMIFlag(Flag);
  69   } else if (isInt<32>(Val)) {
  70     unsigned Opc = RISCV::ADD;
  71     bool isSub = Val < 0;
  72     if (isSub) {
  73       Val = -Val;
  74       Opc = RISCV::SUB;
  75     }
  76
  77     unsigned ScratchReg = MRI.createVirtualRegister(&RISCV::GPRRegClass);
  78     TII->movImm32(MBB, MBBI, DL, ScratchReg, Val, Flag);
  79     BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
  80         .addReg(SrcReg)
  81         .addReg(ScratchReg, RegState::Kill)
  82         .setMIFlag(Flag);
  83   } else {
  84     report_fatal_error("adjustReg cannot yet handle adjustments >32 bits");
  85   }
  86 }
  87
  88 // Returns the register used to hold the frame pointer.
  89 static unsigned getFPReg(const RISCVSubtarget &STI) { return RISCV::X8; }
  90
  91 // Returns the register used to hold the stack pointer.
  92 static unsigned getSPReg(const RISCVSubtarget &STI) { return RISCV::X2; }
  93
  94 void RISCVFrameLowering::emitPrologue(MachineFunction &MF,
  95                                       MachineBasicBlock &MBB) const {
  96   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
  97
  98   MachineFrameInfo &MFI = MF.getFrameInfo();
  99   auto *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
 100   MachineBasicBlock::iterator MBBI = MBB.begin();
 101
 102   unsigned FPReg = getFPReg(STI);
 103   unsigned SPReg = getSPReg(STI);
 104
 105   // Debug location must be unknown since the first debug location is used
 106   // to determine the end of the prologue.
 107   DebugLoc DL;
 108
 109   // Determine the correct frame layout
 110   determineFrameLayout(MF);
 111
 112   // FIXME (note copied from Lanai): This appears to be overallocating.  Needs
 113   // investigation. Get the number of bytes to allocate from the FrameInfo.
 114   uint64_t StackSize = MFI.getStackSize();
 115
 116   // Early exit if there is no need to allocate on the stack
 117   if (StackSize == 0 && !MFI.adjustsStack())
 118     return;
 119
 120   // Allocate space on the stack if necessary.
 121   adjustReg(MBB, MBBI, DL, SPReg, SPReg, -StackSize, MachineInstr::FrameSetup);
 122
 123   // The frame pointer is callee-saved, and code has been generated for us to
 124   // save it to the stack. We need to skip over the storing of callee-saved
 125   // registers as the frame pointer must be modified after it has been saved
 126   // to the stack, not before.
 127   // FIXME: assumes exactly one instruction is used to save each callee-saved
 128   // register.
 129   const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
 130   std::advance(MBBI, CSI.size());
 131
 132   // Generate new FP.
 133   if (hasFP(MF))
 134     adjustReg(MBB, MBBI, DL, FPReg, SPReg,
 135               StackSize - RVFI->getVarArgsSaveSize(), MachineInstr::FrameSetup);
 136 }
 137
 138 void RISCVFrameLowering::emitEpilogue(MachineFunction &MF,
 139                                       MachineBasicBlock &MBB) const {
 140   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 141   const RISCVRegisterInfo *RI = STI.getRegisterInfo();
 142   MachineFrameInfo &MFI = MF.getFrameInfo();
 143   auto *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
 144   DebugLoc DL = MBBI->getDebugLoc();
 145   unsigned FPReg = getFPReg(STI);
 146   unsigned SPReg = getSPReg(STI);
 147
 148   // Skip to before the restores of callee-saved registers
 149   // FIXME: assumes exactly one instruction is used to restore each
 150   // callee-saved register.
 151   MachineBasicBlock::iterator LastFrameDestroy = MBBI;
 152   std::advance(LastFrameDestroy, -MFI.getCalleeSavedInfo().size());
 153
 154   uint64_t StackSize = MFI.getStackSize();
 155
 156   // Restore the stack pointer using the value of the frame pointer. Only
 157   // necessary if the stack pointer was modified, meaning the stack size is
 158   // unknown.
 159   if (RI->needsStackRealignment(MF) || MFI.hasVarSizedObjects()) {
 160     assert(hasFP(MF) && "frame pointer should not have been eliminated");
 161     adjustReg(MBB, LastFrameDestroy, DL, SPReg, FPReg,
 162               -StackSize + RVFI->getVarArgsSaveSize(),
 163               MachineInstr::FrameDestroy);
 164   }
 165
 166   // Deallocate stack
 167   adjustReg(MBB, MBBI, DL, SPReg, SPReg, StackSize, MachineInstr::FrameDestroy);
 168 }
 169
 170 int RISCVFrameLowering::getFrameIndexReference(const MachineFunction &MF,
 171                                                int FI,
 172                                                unsigned &FrameReg) const {
 173   const MachineFrameInfo &MFI = MF.getFrameInfo();
 174   const TargetRegisterInfo *RI = MF.getSubtarget().getRegisterInfo();
 175   const auto *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
 176
 177   // Callee-saved registers should be referenced relative to the stack
 178   // pointer (positive offset), otherwise use the frame pointer (negative
 179   // offset).
 180   const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
 181   int MinCSFI = 0;
 182   int MaxCSFI = -1;
 183
 184   int Offset = MFI.getObjectOffset(FI) - getOffsetOfLocalArea() +
 185                MFI.getOffsetAdjustment();
 186
 187   if (CSI.size()) {
 188     MinCSFI = CSI[0].getFrameIdx();
 189     MaxCSFI = CSI[CSI.size() - 1].getFrameIdx();
 190   }
 191
 192   if (FI >= MinCSFI && FI <= MaxCSFI) {
 193     FrameReg = RISCV::X2;
 194     Offset += MF.getFrameInfo().getStackSize();
 195   } else {
 196     FrameReg = RI->getFrameRegister(MF);
 197     if (hasFP(MF))
 198       Offset += RVFI->getVarArgsSaveSize();
 199     else
 200       Offset += MF.getFrameInfo().getStackSize();
 201   }
 202   return Offset;
 203 }
 204
 205 void RISCVFrameLowering::determineCalleeSaves(MachineFunction &MF,
 206                                               BitVector &SavedRegs,
 207                                               RegScavenger *RS) const {
 208   TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
 209   // Unconditionally spill RA and FP only if the function uses a frame
 210   // pointer.
 211   if (hasFP(MF)) {
 212     SavedRegs.set(RISCV::X1);
 213     SavedRegs.set(RISCV::X8);
 214   }
 215 }
 216
 217 void RISCVFrameLowering::processFunctionBeforeFrameFinalized(
 218     MachineFunction &MF, RegScavenger *RS) const {
 219   const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
 220   MachineFrameInfo &MFI = MF.getFrameInfo();
 221   const TargetRegisterClass *RC = &RISCV::GPRRegClass;
 222   // estimateStackSize has been observed to under-estimate the final stack
 223   // size, so give ourselves wiggle-room by checking for stack size
 224   // representable an 11-bit signed field rather than 12-bits.
 225   // FIXME: It may be possible to craft a function with a small stack that
 226   // still needs an emergency spill slot for branch relaxation. This case
 227   // would currently be missed.
 228   if (!isInt<11>(MFI.estimateStackSize(MF))) {
 229     int RegScavFI = MFI.CreateStackObject(
 230         RegInfo->getSpillSize(*RC), RegInfo->getSpillAlignment(*RC), false);
 231     RS->addScavengingFrameIndex(RegScavFI);
 232   }
 233 }
 234
 235 // Not preserve stack space within prologue for outgoing variables when the
 236 // function contains variable size objects and let eliminateCallFramePseudoInstr
 237 // preserve stack space for it.
 238 bool RISCVFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
 239   return !MF.getFrameInfo().hasVarSizedObjects();
 240 }
 241
 242 // Eliminate ADJCALLSTACKDOWN, ADJCALLSTACKUP pseudo instructions.
 243 MachineBasicBlock::iterator RISCVFrameLowering::eliminateCallFramePseudoInstr(
 244     MachineFunction &MF, MachineBasicBlock &MBB,
 245     MachineBasicBlock::iterator MI) const {
 246   unsigned SPReg = RISCV::X2;
 247   DebugLoc DL = MI->getDebugLoc();
 248
 249   if (!hasReservedCallFrame(MF)) {
 250     // If space has not been reserved for a call frame, ADJCALLSTACKDOWN and
 251     // ADJCALLSTACKUP must be converted to instructions manipulating the stack
 252     // pointer. This is necessary when there is a variable length stack
 253     // allocation (e.g. alloca), which means it's not possible to allocate
 254     // space for outgoing arguments from within the function prologue.
 255     int64_t Amount = MI->getOperand(0).getImm();
 256
 257     if (Amount != 0) {
 258       // Ensure the stack remains aligned after adjustment.
 259       Amount = alignSPAdjust(Amount);
 260
 261       if (MI->getOpcode() == RISCV::ADJCALLSTACKDOWN)
 262         Amount = -Amount;
 263
 264       adjustReg(MBB, MI, DL, SPReg, SPReg, Amount, MachineInstr::NoFlags);
 265     }
 266   }
 267
 268   return MBB.erase(MI);
 269 }