lib/CodeGen/MachineFrameInfo.cpp

   1 //===-- MachineFrameInfo.cpp ---------------------------------------------===//
   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 /// \file Implements MachineFrameInfo that manages the stack frame.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/CodeGen/MachineFrameInfo.h"
  15
  16 #include "llvm/ADT/BitVector.h"
  17 #include "llvm/CodeGen/MachineFunction.h"
  18 #include "llvm/CodeGen/MachineRegisterInfo.h"
  19 #include "llvm/CodeGen/TargetFrameLowering.h"
  20 #include "llvm/CodeGen/TargetInstrInfo.h"
  21 #include "llvm/CodeGen/TargetRegisterInfo.h"
  22 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  23 #include "llvm/Config/llvm-config.h"
  24 #include "llvm/Support/Debug.h"
  25 #include "llvm/Support/raw_ostream.h"
  26 #include <cassert>
  27
  28 #define DEBUG_TYPE "codegen"
  29
  30 using namespace llvm;
  31
  32 void MachineFrameInfo::ensureMaxAlignment(unsigned Align) {
  33   if (!StackRealignable)
  34     assert(Align <= StackAlignment &&
  35            "For targets without stack realignment, Align is out of limit!");
  36   if (MaxAlignment < Align) MaxAlignment = Align;
  37 }
  38
  39 /// Clamp the alignment if requested and emit a warning.
  40 static inline unsigned clampStackAlignment(bool ShouldClamp, unsigned Align,
  41                                            unsigned StackAlign) {
  42   if (!ShouldClamp || Align <= StackAlign)
  43     return Align;
  44   LLVM_DEBUG(dbgs() << "Warning: requested alignment " << Align
  45                     << " exceeds the stack alignment " << StackAlign
  46                     << " when stack realignment is off" << '\n');
  47   return StackAlign;
  48 }
  49
  50 int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment,
  51                                         bool IsSpillSlot,
  52                                         const AllocaInst *Alloca,
  53                                         uint8_t StackID) {
  54   assert(Size != 0 && "Cannot allocate zero size stack objects!");
  55   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
  56   Objects.push_back(StackObject(Size, Alignment, 0, false, IsSpillSlot, Alloca,
  57                                 !IsSpillSlot, StackID));
  58   int Index = (int)Objects.size() - NumFixedObjects - 1;
  59   assert(Index >= 0 && "Bad frame index!");
  60   ensureMaxAlignment(Alignment);
  61   return Index;
  62 }
  63
  64 int MachineFrameInfo::CreateSpillStackObject(uint64_t Size,
  65                                              unsigned Alignment) {
  66   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
  67   CreateStackObject(Size, Alignment, true);
  68   int Index = (int)Objects.size() - NumFixedObjects - 1;
  69   ensureMaxAlignment(Alignment);
  70   return Index;
  71 }
  72
  73 int MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment,
  74                                                 const AllocaInst *Alloca) {
  75   HasVarSizedObjects = true;
  76   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
  77   Objects.push_back(StackObject(0, Alignment, 0, false, false, Alloca, true));
  78   ensureMaxAlignment(Alignment);
  79   return (int)Objects.size()-NumFixedObjects-1;
  80 }
  81
  82 int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset,
  83                                         bool IsImmutable, bool IsAliased) {
  84   assert(Size != 0 && "Cannot allocate zero size fixed stack objects!");
  85   // The alignment of the frame index can be determined from its offset from
  86   // the incoming frame position.  If the frame object is at offset 32 and
  87   // the stack is guaranteed to be 16-byte aligned, then we know that the
  88   // object is 16-byte aligned. Note that unlike the non-fixed case, if the
  89   // stack needs realignment, we can't assume that the stack will in fact be
  90   // aligned.
  91   unsigned Alignment = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment);
  92   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
  93   Objects.insert(Objects.begin(),
  94                  StackObject(Size, Alignment, SPOffset, IsImmutable,
  95                              /*isSpillSlot=*/false, /*Alloca=*/nullptr,
  96                              IsAliased));
  97   return -++NumFixedObjects;
  98 }
  99
 100 int MachineFrameInfo::CreateFixedSpillStackObject(uint64_t Size,
 101                                                   int64_t SPOffset,
 102                                                   bool IsImmutable) {
 103   unsigned Alignment = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment);
 104   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
 105   Objects.insert(Objects.begin(),
 106                  StackObject(Size, Alignment, SPOffset, IsImmutable,
 107                              /*IsSpillSlot=*/true, /*Alloca=*/nullptr,
 108                              /*IsAliased=*/false));
 109   return -++NumFixedObjects;
 110 }
 111
 112 BitVector MachineFrameInfo::getPristineRegs(const MachineFunction &MF) const {
 113   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
 114   BitVector BV(TRI->getNumRegs());
 115
 116   // Before CSI is calculated, no registers are considered pristine. They can be
 117   // freely used and PEI will make sure they are saved.
 118   if (!isCalleeSavedInfoValid())
 119     return BV;
 120
 121   const MachineRegisterInfo &MRI = MF.getRegInfo();
 122   for (const MCPhysReg *CSR = MRI.getCalleeSavedRegs(); CSR && *CSR;
 123        ++CSR)
 124     BV.set(*CSR);
 125
 126   // Saved CSRs are not pristine.
 127   for (auto &I : getCalleeSavedInfo())
 128     for (MCSubRegIterator S(I.getReg(), TRI, true); S.isValid(); ++S)
 129       BV.reset(*S);
 130
 131   return BV;
 132 }
 133
 134 unsigned MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const {
 135   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
 136   const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
 137   unsigned MaxAlign = getMaxAlignment();
 138   int Offset = 0;
 139
 140   // This code is very, very similar to PEI::calculateFrameObjectOffsets().
 141   // It really should be refactored to share code. Until then, changes
 142   // should keep in mind that there's tight coupling between the two.
 143
 144   for (int i = getObjectIndexBegin(); i != 0; ++i) {
 145     int FixedOff = -getObjectOffset(i);
 146     if (FixedOff > Offset) Offset = FixedOff;
 147   }
 148   for (unsigned i = 0, e = getObjectIndexEnd(); i != e; ++i) {
 149     if (isDeadObjectIndex(i))
 150       continue;
 151     Offset += getObjectSize(i);
 152     unsigned Align = getObjectAlignment(i);
 153     // Adjust to alignment boundary
 154     Offset = (Offset+Align-1)/Align*Align;
 155
 156     MaxAlign = std::max(Align, MaxAlign);
 157   }
 158
 159   if (adjustsStack() && TFI->hasReservedCallFrame(MF))
 160     Offset += getMaxCallFrameSize();
 161
 162   // Round up the size to a multiple of the alignment.  If the function has
 163   // any calls or alloca's, align to the target's StackAlignment value to
 164   // ensure that the callee's frame or the alloca data is suitably aligned;
 165   // otherwise, for leaf functions, align to the TransientStackAlignment
 166   // value.
 167   unsigned StackAlign;
 168   if (adjustsStack() || hasVarSizedObjects() ||
 169       (RegInfo->needsStackRealignment(MF) && getObjectIndexEnd() != 0))
 170     StackAlign = TFI->getStackAlignment();
 171   else
 172     StackAlign = TFI->getTransientStackAlignment();
 173
 174   // If the frame pointer is eliminated, all frame offsets will be relative to
 175   // SP not FP. Align to MaxAlign so this works.
 176   StackAlign = std::max(StackAlign, MaxAlign);
 177   unsigned AlignMask = StackAlign - 1;
 178   Offset = (Offset + AlignMask) & ~uint64_t(AlignMask);
 179
 180   return (unsigned)Offset;
 181 }
 182
 183 void MachineFrameInfo::computeMaxCallFrameSize(const MachineFunction &MF) {
 184   const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
 185   unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
 186   unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
 187   assert(FrameSetupOpcode != ~0u && FrameDestroyOpcode != ~0u &&
 188          "Can only compute MaxCallFrameSize if Setup/Destroy opcode are known");
 189
 190   MaxCallFrameSize = 0;
 191   for (const MachineBasicBlock &MBB : MF) {
 192     for (const MachineInstr &MI : MBB) {
 193       unsigned Opcode = MI.getOpcode();
 194       if (Opcode == FrameSetupOpcode || Opcode == FrameDestroyOpcode) {
 195         unsigned Size = TII.getFrameSize(MI);
 196         MaxCallFrameSize = std::max(MaxCallFrameSize, Size);
 197         AdjustsStack = true;
 198       } else if (MI.isInlineAsm()) {
 199         // Some inline asm's need a stack frame, as indicated by operand 1.
 200         unsigned ExtraInfo = MI.getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
 201         if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
 202           AdjustsStack = true;
 203       }
 204     }
 205   }
 206 }
 207
 208 void MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{
 209   if (Objects.empty()) return;
 210
 211   const TargetFrameLowering *FI = MF.getSubtarget().getFrameLowering();
 212   int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0);
 213
 214   OS << "Frame Objects:\n";
 215
 216   for (unsigned i = 0, e = Objects.size(); i != e; ++i) {
 217     const StackObject &SO = Objects[i];
 218     OS << "  fi#" << (int)(i-NumFixedObjects) << ": ";
 219
 220     if (SO.StackID != 0)
 221       OS << "id=" << static_cast<unsigned>(SO.StackID) << ' ';
 222
 223     if (SO.Size == ~0ULL) {
 224       OS << "dead\n";
 225       continue;
 226     }
 227     if (SO.Size == 0)
 228       OS << "variable sized";
 229     else
 230       OS << "size=" << SO.Size;
 231     OS << ", align=" << SO.Alignment;
 232
 233     if (i < NumFixedObjects)
 234       OS << ", fixed";
 235     if (i < NumFixedObjects || SO.SPOffset != -1) {
 236       int64_t Off = SO.SPOffset - ValOffset;
 237       OS << ", at location [SP";
 238       if (Off > 0)
 239         OS << "+" << Off;
 240       else if (Off < 0)
 241         OS << Off;
 242       OS << "]";
 243     }
 244     OS << "\n";
 245   }
 246 }
 247
 248 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 249 LLVM_DUMP_METHOD void MachineFrameInfo::dump(const MachineFunction &MF) const {
 250   print(MF, dbgs());
 251 }
 252 #endif