LLVM  7.0.0svn
MachineFrameInfo.cpp
Go to the documentation of this file.
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 
15 
16 #include "llvm/ADT/BitVector.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(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  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 
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 
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 
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 
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 
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 
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 
208  if (Objects.empty()) return;
209 
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=" << 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)
249  print(MF, dbgs());
250 }
251 #endif
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
bool isCalleeSavedInfoValid() const
Has the callee saved info been calculated yet?
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:449
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.
bool adjustsStack() const
Return true if this function adjusts the stack – e.g., when calling another function.
unsigned getCallFrameDestroyOpcode() const
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
int CreateStackObject(uint64_t Size, unsigned 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...
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 getObjectIndexBegin() const
Return the minimum frame object index.
int getObjectIndexEnd() const
Return one past the maximum frame object index.
virtual const TargetInstrInfo * getInstrInfo() const
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...
TargetInstrInfo - Interface to description of machine instruction set.
constexpr uint64_t MinAlign(uint64_t A, uint64_t B)
A and B are either alignments or offsets.
Definition: MathExtras.h:602
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...
void computeMaxCallFrameSize(const MachineFunction &MF)
Computes the maximum size of a callframe and the AdjustsStack property.
int CreateSpillStackObject(uint64_t Size, unsigned Alignment)
Create a new statically sized stack object that represents a spill slot, returning a nonnegative iden...
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
MCSubRegIterator enumerates all sub-registers of Reg.
static unsigned clampStackAlignment(bool ShouldClamp, unsigned Align, unsigned StackAlign)
Clamp the alignment if requested and emit a warning.
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.
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:60
void ensureMaxAlignment(unsigned Align)
Make sure the function is at least Align bytes aligned.
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
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool needsStackRealignment(const MachineFunction &MF) const
True if storage within the function requires the stack pointer to be aligned more than the normal cal...
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
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:44
#define DEBUG(X)
Definition: Debug.h:118
IRTranslator LLVM IR MI
BitVector getPristineRegs(const MachineFunction &MF) const
Return a set of physical registers that are pristine.
int CreateVariableSizedObject(unsigned Alignment, const AllocaInst *Alloca)
Notify the MachineFrameInfo object that a variable sized object has been created. ...
an instruction to allocate memory on the stack
Definition: Instructions.h:60