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