contrib/llvm/lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp

   1 //===-- NVPTXPrologEpilogPass.cpp - NVPTX prolog/epilog inserter ----------===//
   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 is a copy of the generic LLVM PrologEpilogInserter pass, modified
  11 // to remove unneeded functionality and to handle virtual registers. Most code
  12 // here is a copy of PrologEpilogInserter.cpp.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "NVPTX.h"
  17 #include "llvm/CodeGen/MachineFrameInfo.h"
  18 #include "llvm/CodeGen/MachineFunction.h"
  19 #include "llvm/CodeGen/MachineFunctionPass.h"
  20 #include "llvm/CodeGen/TargetFrameLowering.h"
  21 #include "llvm/CodeGen/TargetRegisterInfo.h"
  22 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  23 #include "llvm/IR/DebugInfoMetadata.h"
  24 #include "llvm/Pass.h"
  25 #include "llvm/Support/Debug.h"
  26 #include "llvm/Support/raw_ostream.h"
  27
  28 using namespace llvm;
  29
  30 #define DEBUG_TYPE "nvptx-prolog-epilog"
  31
  32 namespace {
  33 class NVPTXPrologEpilogPass : public MachineFunctionPass {
  34 public:
  35   static char ID;
  36   NVPTXPrologEpilogPass() : MachineFunctionPass(ID) {}
  37
  38   bool runOnMachineFunction(MachineFunction &MF) override;
  39
  40 private:
  41   void calculateFrameObjectOffsets(MachineFunction &Fn);
  42 };
  43 }
  44
  45 MachineFunctionPass *llvm::createNVPTXPrologEpilogPass() {
  46   return new NVPTXPrologEpilogPass();
  47 }
  48
  49 char NVPTXPrologEpilogPass::ID = 0;
  50
  51 bool NVPTXPrologEpilogPass::runOnMachineFunction(MachineFunction &MF) {
  52   const TargetSubtargetInfo &STI = MF.getSubtarget();
  53   const TargetFrameLowering &TFI = *STI.getFrameLowering();
  54   const TargetRegisterInfo &TRI = *STI.getRegisterInfo();
  55   bool Modified = false;
  56
  57   calculateFrameObjectOffsets(MF);
  58
  59   for (MachineBasicBlock &MBB : MF) {
  60     for (MachineInstr &MI : MBB) {
  61       for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
  62         if (!MI.getOperand(i).isFI())
  63           continue;
  64
  65         // Frame indices in debug values are encoded in a target independent
  66         // way with simply the frame index and offset rather than any
  67         // target-specific addressing mode.
  68         if (MI.isDebugValue()) {
  69           assert(i == 0 && "Frame indices can only appear as the first "
  70                            "operand of a DBG_VALUE machine instruction");
  71           unsigned Reg;
  72           int64_t Offset =
  73               TFI.getFrameIndexReference(MF, MI.getOperand(0).getIndex(), Reg);
  74           MI.getOperand(0).ChangeToRegister(Reg, /*isDef=*/false);
  75           MI.getOperand(0).setIsDebug();
  76           auto *DIExpr = DIExpression::prepend(MI.getDebugExpression(),
  77                                                DIExpression::NoDeref, Offset);
  78           MI.getOperand(3).setMetadata(DIExpr);
  79           continue;
  80         }
  81
  82         TRI.eliminateFrameIndex(MI, 0, i, nullptr);
  83         Modified = true;
  84       }
  85     }
  86   }
  87
  88   // Add function prolog/epilog
  89   TFI.emitPrologue(MF, MF.front());
  90
  91   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
  92     // If last instruction is a return instruction, add an epilogue
  93     if (I->isReturnBlock())
  94       TFI.emitEpilogue(MF, *I);
  95   }
  96
  97   return Modified;
  98 }
  99
 100 /// AdjustStackOffset - Helper function used to adjust the stack frame offset.
 101 static inline void
 102 AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx,
 103                   bool StackGrowsDown, int64_t &Offset,
 104                   unsigned &MaxAlign) {
 105   // If the stack grows down, add the object size to find the lowest address.
 106   if (StackGrowsDown)
 107     Offset += MFI.getObjectSize(FrameIdx);
 108
 109   unsigned Align = MFI.getObjectAlignment(FrameIdx);
 110
 111   // If the alignment of this object is greater than that of the stack, then
 112   // increase the stack alignment to match.
 113   MaxAlign = std::max(MaxAlign, Align);
 114
 115   // Adjust to alignment boundary.
 116   Offset = (Offset + Align - 1) / Align * Align;
 117
 118   if (StackGrowsDown) {
 119     LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << -Offset
 120                       << "]\n");
 121     MFI.setObjectOffset(FrameIdx, -Offset); // Set the computed offset
 122   } else {
 123     LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << Offset
 124                       << "]\n");
 125     MFI.setObjectOffset(FrameIdx, Offset);
 126     Offset += MFI.getObjectSize(FrameIdx);
 127   }
 128 }
 129
 130 void
 131 NVPTXPrologEpilogPass::calculateFrameObjectOffsets(MachineFunction &Fn) {
 132   const TargetFrameLowering &TFI = *Fn.getSubtarget().getFrameLowering();
 133   const TargetRegisterInfo *RegInfo = Fn.getSubtarget().getRegisterInfo();
 134
 135   bool StackGrowsDown =
 136     TFI.getStackGrowthDirection() == TargetFrameLowering::StackGrowsDown;
 137
 138   // Loop over all of the stack objects, assigning sequential addresses...
 139   MachineFrameInfo &MFI = Fn.getFrameInfo();
 140
 141   // Start at the beginning of the local area.
 142   // The Offset is the distance from the stack top in the direction
 143   // of stack growth -- so it's always nonnegative.
 144   int LocalAreaOffset = TFI.getOffsetOfLocalArea();
 145   if (StackGrowsDown)
 146     LocalAreaOffset = -LocalAreaOffset;
 147   assert(LocalAreaOffset >= 0
 148          && "Local area offset should be in direction of stack growth");
 149   int64_t Offset = LocalAreaOffset;
 150
 151   // If there are fixed sized objects that are preallocated in the local area,
 152   // non-fixed objects can't be allocated right at the start of local area.
 153   // We currently don't support filling in holes in between fixed sized
 154   // objects, so we adjust 'Offset' to point to the end of last fixed sized
 155   // preallocated object.
 156   for (int i = MFI.getObjectIndexBegin(); i != 0; ++i) {
 157     int64_t FixedOff;
 158     if (StackGrowsDown) {
 159       // The maximum distance from the stack pointer is at lower address of
 160       // the object -- which is given by offset. For down growing stack
 161       // the offset is negative, so we negate the offset to get the distance.
 162       FixedOff = -MFI.getObjectOffset(i);
 163     } else {
 164       // The maximum distance from the start pointer is at the upper
 165       // address of the object.
 166       FixedOff = MFI.getObjectOffset(i) + MFI.getObjectSize(i);
 167     }
 168     if (FixedOff > Offset) Offset = FixedOff;
 169   }
 170
 171   // NOTE: We do not have a call stack
 172
 173   unsigned MaxAlign = MFI.getMaxAlignment();
 174
 175   // No scavenger
 176
 177   // FIXME: Once this is working, then enable flag will change to a target
 178   // check for whether the frame is large enough to want to use virtual
 179   // frame index registers. Functions which don't want/need this optimization
 180   // will continue to use the existing code path.
 181   if (MFI.getUseLocalStackAllocationBlock()) {
 182     unsigned Align = MFI.getLocalFrameMaxAlign();
 183
 184     // Adjust to alignment boundary.
 185     Offset = (Offset + Align - 1) / Align * Align;
 186
 187     LLVM_DEBUG(dbgs() << "Local frame base offset: " << Offset << "\n");
 188
 189     // Resolve offsets for objects in the local block.
 190     for (unsigned i = 0, e = MFI.getLocalFrameObjectCount(); i != e; ++i) {
 191       std::pair<int, int64_t> Entry = MFI.getLocalFrameObjectMap(i);
 192       int64_t FIOffset = (StackGrowsDown ? -Offset : Offset) + Entry.second;
 193       LLVM_DEBUG(dbgs() << "alloc FI(" << Entry.first << ") at SP[" << FIOffset
 194                         << "]\n");
 195       MFI.setObjectOffset(Entry.first, FIOffset);
 196     }
 197     // Allocate the local block
 198     Offset += MFI.getLocalFrameSize();
 199
 200     MaxAlign = std::max(Align, MaxAlign);
 201   }
 202
 203   // No stack protector
 204
 205   // Then assign frame offsets to stack objects that are not used to spill
 206   // callee saved registers.
 207   for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
 208     if (MFI.isObjectPreAllocated(i) &&
 209         MFI.getUseLocalStackAllocationBlock())
 210       continue;
 211     if (MFI.isDeadObjectIndex(i))
 212       continue;
 213
 214     AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign);
 215   }
 216
 217   // No scavenger
 218
 219   if (!TFI.targetHandlesStackFrameRounding()) {
 220     // If we have reserved argument space for call sites in the function
 221     // immediately on entry to the current function, count it as part of the
 222     // overall stack size.
 223     if (MFI.adjustsStack() && TFI.hasReservedCallFrame(Fn))
 224       Offset += MFI.getMaxCallFrameSize();
 225
 226     // Round up the size to a multiple of the alignment.  If the function has
 227     // any calls or alloca's, align to the target's StackAlignment value to
 228     // ensure that the callee's frame or the alloca data is suitably aligned;
 229     // otherwise, for leaf functions, align to the TransientStackAlignment
 230     // value.
 231     unsigned StackAlign;
 232     if (MFI.adjustsStack() || MFI.hasVarSizedObjects() ||
 233         (RegInfo->needsStackRealignment(Fn) && MFI.getObjectIndexEnd() != 0))
 234       StackAlign = TFI.getStackAlignment();
 235     else
 236       StackAlign = TFI.getTransientStackAlignment();
 237
 238     // If the frame pointer is eliminated, all frame offsets will be relative to
 239     // SP not FP. Align to MaxAlign so this works.
 240     StackAlign = std::max(StackAlign, MaxAlign);
 241     unsigned AlignMask = StackAlign - 1;
 242     Offset = (Offset + AlignMask) & ~uint64_t(AlignMask);
 243   }
 244
 245   // Update frame info to pretend that this is part of the stack...
 246   int64_t StackSize = Offset - LocalAreaOffset;
 247   MFI.setStackSize(StackSize);
 248 }