LLVM  10.0.0svn
MachineFrameInfo.cpp
Go to the documentation of this file.
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 
14 
15 #include "llvm/ADT/BitVector.h"
22 #include "llvm/Config/llvm-config.h"
23 #include "llvm/Support/Debug.h"
25 #include <cassert>
26 
27 #define DEBUG_TYPE "codegen"
28 
29 using namespace llvm;
30 
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.
40 static 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 
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 
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 
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  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 
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 
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 
138  const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
139  unsigned MaxAlign = getMaxAlignment();
140  int 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.
149  continue;
150  int 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.
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 (unsigned)Offset;
187 }
188 
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 
215  if (Objects.empty()) return;
216 
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)
256  print(MF, dbgs());
257 }
258 #endif
bool isCalleeSavedInfoValid() const
Has the callee saved info been calculated yet?
This class represents lattice values for constants.
Definition: AllocatorList.h:23
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:484
void dump(const MachineFunction &MF) const
dump - Print the function to stderr.
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
void ensureMaxAlignment(Align Alignment)
Make sure the function is at least Align bytes aligned.
unsigned const TargetRegisterInfo * TRI
bool adjustsStack() const
Return true if this function adjusts the stack – e.g., when calling another function.
unsigned getCallFrameDestroyOpcode() const
static Align clampStackAlignment(bool ShouldClamp, Align Alignment, Align StackAlignment)
Clamp the alignment if requested and emit a warning.
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
const HexagonInstrInfo * TII
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
int CreateVariableSizedObject(Align Alignment, const AllocaInst *Alloca)
Notify the MachineFrameInfo object that a variable sized object has been created. ...
Align commonAlignment(Align A, Align B)
Returns the alignment that satisfies both alignments.
Definition: Alignment.h:204
int getObjectIndexBegin() const
Return the minimum frame object index.
int getObjectIndexEnd() const
Return one past the maximum frame object index.
virtual const TargetInstrInfo * getInstrInfo() const
int CreateSpillStackObject(uint64_t Size, Align Alignment)
Create a new statically sized stack object that represents a spill slot, returning a nonnegative iden...
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:86
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition: MCRegister.h:19
TargetInstrInfo - Interface to description of machine instruction set.
unsigned getObjectAlignment(int ObjectIdx) const
Return the alignment of the specified stack object.
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
unsigned const MachineRegisterInfo * MRI
void print(const MachineFunction &MF, raw_ostream &OS) const
Used by the MachineFunction printer to print information about stack objects.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
unsigned getCallFrameSetupOpcode() const
These methods return the opcode of the frame setup/destroy instructions if they exist (-1 otherwise)...
unsigned getMaxAlignment() const
Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...
constexpr double e
Definition: MathExtras.h:57
void computeMaxCallFrameSize(const MachineFunction &MF)
Computes the maximum size of a callframe and the AdjustsStack property.
static constexpr const Align None()
Returns a default constructed Align which corresponds to no alignment.
Definition: Alignment.h:93
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
MCSubRegIterator enumerates all sub-registers of Reg.
unsigned getStackAlignment() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
virtual bool hasReservedCallFrame(const MachineFunction &MF) const
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required, we reserve argument space for call sites in the function immediately on entry to the current function.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:379
unsigned getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call...
unsigned estimateStackSize(const MachineFunction &MF) const
Estimate and return the size of the stack frame.
Information about stack frame layout on the target.
int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, bool IsImmutable=false)
Create a spill slot at a fixed location on the stack.
int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable, bool isAliased=false)
Create a new object at a fixed location on the stack.
int64_t getFrameSize(const MachineInstr &I) const
Returns size of the frame associated with the given frame instruction.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
unsigned getTransientStackAlignment() const
getTransientStackAlignment - This method returns the number of bytes to which the stack pointer must ...
bool isValid() const
isValid - returns true if this iterator is not yet at the end.
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
Representation of each machine instruction.
Definition: MachineInstr.h:64
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
#define I(x, y, z)
Definition: MD5.cpp:58
virtual const TargetFrameLowering * getFrameLowering() const
uint32_t Size
Definition: Profile.cpp:46
uint8_t getStackID(int ObjectIdx) const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
int CreateStackObject(uint64_t Size, Align Alignment, bool isSpillSlot, const AllocaInst *Alloca=nullptr, uint8_t ID=0)
Create a new statically sized stack object, returning a nonnegative identifier to represent it...
bool needsStackRealignment(const MachineFunction &MF) const
True if storage within the function requires the stack pointer to be aligned more than the normal cal...
const MCPhysReg * getCalleeSavedRegs() const
Returns list of callee saved registers.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
IRTranslator LLVM IR MI
BitVector getPristineRegs(const MachineFunction &MF) const
Return a set of physical registers that are pristine.
#define LLVM_DEBUG(X)
Definition: Debug.h:122
an instruction to allocate memory on the stack
Definition: Instructions.h:59