lib/CodeGen/MachineFrameInfo.cpp

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