LLVM  13.0.0git
LocalStackSlotAllocation.cpp
Go to the documentation of this file.
1 //===- LocalStackSlotAllocation.cpp - Pre-allocate locals to stack slots --===//
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 // This pass assigns local frame indices to stack slots relative to one another
10 // and allocates additional base registers to access them when the target
11 // estimates they are likely to be out of range of stack pointer and frame
12 // pointer relative addressing.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "llvm/ADT/SetVector.h"
17 #include "llvm/ADT/SmallSet.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/Statistic.h"
31 #include "llvm/InitializePasses.h"
32 #include "llvm/Pass.h"
33 #include "llvm/Support/Debug.h"
36 #include <algorithm>
37 #include <cassert>
38 #include <cstdint>
39 #include <tuple>
40 
41 using namespace llvm;
42 
43 #define DEBUG_TYPE "localstackalloc"
44 
45 STATISTIC(NumAllocations, "Number of frame indices allocated into local block");
46 STATISTIC(NumBaseRegisters, "Number of virtual frame base registers allocated");
47 STATISTIC(NumReplacements, "Number of frame indices references replaced");
48 
49 namespace {
50 
51  class FrameRef {
52  MachineBasicBlock::iterator MI; // Instr referencing the frame
53  int64_t LocalOffset; // Local offset of the frame idx referenced
54  int FrameIdx; // The frame index
55 
56  // Order reference instruction appears in program. Used to ensure
57  // deterministic order when multiple instructions may reference the same
58  // location.
59  unsigned Order;
60 
61  public:
62  FrameRef(MachineInstr *I, int64_t Offset, int Idx, unsigned Ord) :
63  MI(I), LocalOffset(Offset), FrameIdx(Idx), Order(Ord) {}
64 
65  bool operator<(const FrameRef &RHS) const {
66  return std::tie(LocalOffset, FrameIdx, Order) <
67  std::tie(RHS.LocalOffset, RHS.FrameIdx, RHS.Order);
68  }
69 
71  int64_t getLocalOffset() const { return LocalOffset; }
72  int getFrameIndex() const { return FrameIdx; }
73  };
74 
75  class LocalStackSlotPass: public MachineFunctionPass {
76  SmallVector<int64_t, 16> LocalOffsets;
77 
78  /// StackObjSet - A set of stack object indexes
80 
81  void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx, int64_t &Offset,
82  bool StackGrowsDown, Align &MaxAlign);
83  void AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
84  SmallSet<int, 16> &ProtectedObjs,
85  MachineFrameInfo &MFI, bool StackGrowsDown,
86  int64_t &Offset, Align &MaxAlign);
87  void calculateFrameObjectOffsets(MachineFunction &Fn);
88  bool insertFrameReferenceRegisters(MachineFunction &Fn);
89 
90  public:
91  static char ID; // Pass identification, replacement for typeid
92 
93  explicit LocalStackSlotPass() : MachineFunctionPass(ID) {
95  }
96 
97  bool runOnMachineFunction(MachineFunction &MF) override;
98 
99  void getAnalysisUsage(AnalysisUsage &AU) const override {
100  AU.setPreservesCFG();
102  }
103  };
104 
105 } // end anonymous namespace
106 
107 char LocalStackSlotPass::ID = 0;
108 
110 INITIALIZE_PASS(LocalStackSlotPass, DEBUG_TYPE,
111  "Local Stack Slot Allocation", false, false)
112 
113 bool LocalStackSlotPass::runOnMachineFunction(MachineFunction &MF) {
114  MachineFrameInfo &MFI = MF.getFrameInfo();
115  const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
116  unsigned LocalObjectCount = MFI.getObjectIndexEnd();
117 
118  // If the target doesn't want/need this pass, or if there are no locals
119  // to consider, early exit.
120  if (LocalObjectCount == 0 || !TRI->requiresVirtualBaseRegisters(MF))
121  return true;
122 
123  // Make sure we have enough space to store the local offsets.
124  LocalOffsets.resize(MFI.getObjectIndexEnd());
125 
126  // Lay out the local blob.
127  calculateFrameObjectOffsets(MF);
128 
129  // Insert virtual base registers to resolve frame index references.
130  bool UsedBaseRegs = insertFrameReferenceRegisters(MF);
131 
132  // Tell MFI whether any base registers were allocated. PEI will only
133  // want to use the local block allocations from this pass if there were any.
134  // Otherwise, PEI can do a bit better job of getting the alignment right
135  // without a hole at the start since it knows the alignment of the stack
136  // at the start of local allocation, and this pass doesn't.
137  MFI.setUseLocalStackAllocationBlock(UsedBaseRegs);
138 
139  return true;
140 }
141 
142 /// AdjustStackOffset - Helper function used to adjust the stack frame offset.
144  int64_t &Offset, bool StackGrowsDown,
145  Align &MaxAlign) {
146  // If the stack grows down, add the object size to find the lowest address.
147  if (StackGrowsDown)
148  Offset += MFI.getObjectSize(FrameIdx);
149 
150  Align Alignment = MFI.getObjectAlign(FrameIdx);
151 
152  // If the alignment of this object is greater than that of the stack, then
153  // increase the stack alignment to match.
154  MaxAlign = std::max(MaxAlign, Alignment);
155 
156  // Adjust to alignment boundary.
157  Offset = alignTo(Offset, Alignment);
158 
159  int64_t LocalOffset = StackGrowsDown ? -Offset : Offset;
160  LLVM_DEBUG(dbgs() << "Allocate FI(" << FrameIdx << ") to local offset "
161  << LocalOffset << "\n");
162  // Keep the offset available for base register allocation
163  LocalOffsets[FrameIdx] = LocalOffset;
164  // And tell MFI about it for PEI to use later
165  MFI.mapLocalFrameObject(FrameIdx, LocalOffset);
166 
167  if (!StackGrowsDown)
168  Offset += MFI.getObjectSize(FrameIdx);
169 
170  ++NumAllocations;
171 }
172 
173 /// AssignProtectedObjSet - Helper function to assign large stack objects (i.e.,
174 /// those required to be close to the Stack Protector) to stack offsets.
176  const StackObjSet &UnassignedObjs, SmallSet<int, 16> &ProtectedObjs,
177  MachineFrameInfo &MFI, bool StackGrowsDown, int64_t &Offset,
178  Align &MaxAlign) {
179  for (int i : UnassignedObjs) {
180  AdjustStackOffset(MFI, i, Offset, StackGrowsDown, MaxAlign);
181  ProtectedObjs.insert(i);
182  }
183 }
184 
185 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
186 /// abstract stack objects.
187 void LocalStackSlotPass::calculateFrameObjectOffsets(MachineFunction &Fn) {
188  // Loop over all of the stack objects, assigning sequential addresses...
189  MachineFrameInfo &MFI = Fn.getFrameInfo();
191  bool StackGrowsDown =
193  int64_t Offset = 0;
194  Align MaxAlign;
195 
196  // Make sure that the stack protector comes before the local variables on the
197  // stack.
198  SmallSet<int, 16> ProtectedObjs;
199  if (MFI.hasStackProtectorIndex()) {
200  int StackProtectorFI = MFI.getStackProtectorIndex();
201 
202  // We need to make sure we didn't pre-allocate the stack protector when
203  // doing this.
204  // If we already have a stack protector, this will re-assign it to a slot
205  // that is **not** covering the protected objects.
206  assert(!MFI.isObjectPreAllocated(StackProtectorFI) &&
207  "Stack protector pre-allocated in LocalStackSlotAllocation");
208 
209  StackObjSet LargeArrayObjs;
210  StackObjSet SmallArrayObjs;
211  StackObjSet AddrOfObjs;
212 
213  AdjustStackOffset(MFI, StackProtectorFI, Offset, StackGrowsDown, MaxAlign);
214 
215  // Assign large stack objects first.
216  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
217  if (MFI.isDeadObjectIndex(i))
218  continue;
219  if (StackProtectorFI == (int)i)
220  continue;
221  if (!TFI.isStackIdSafeForLocalArea(MFI.getStackID(i)))
222  continue;
223 
224  switch (MFI.getObjectSSPLayout(i)) {
226  continue;
228  SmallArrayObjs.insert(i);
229  continue;
231  AddrOfObjs.insert(i);
232  continue;
234  LargeArrayObjs.insert(i);
235  continue;
236  }
237  llvm_unreachable("Unexpected SSPLayoutKind.");
238  }
239 
240  AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
241  Offset, MaxAlign);
242  AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
243  Offset, MaxAlign);
244  AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
245  Offset, MaxAlign);
246  }
247 
248  // Then assign frame offsets to stack objects that are not used to spill
249  // callee saved registers.
250  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
251  if (MFI.isDeadObjectIndex(i))
252  continue;
253  if (MFI.getStackProtectorIndex() == (int)i)
254  continue;
255  if (ProtectedObjs.count(i))
256  continue;
257  if (!TFI.isStackIdSafeForLocalArea(MFI.getStackID(i)))
258  continue;
259 
260  AdjustStackOffset(MFI, i, Offset, StackGrowsDown, MaxAlign);
261  }
262 
263  // Remember how big this blob of stack space is
265  MFI.setLocalFrameMaxAlign(MaxAlign);
266 }
267 
268 static inline bool
269 lookupCandidateBaseReg(unsigned BaseReg,
270  int64_t BaseOffset,
271  int64_t FrameSizeAdjust,
272  int64_t LocalFrameOffset,
273  const MachineInstr &MI,
274  const TargetRegisterInfo *TRI) {
275  // Check if the relative offset from the where the base register references
276  // to the target address is in range for the instruction.
277  int64_t Offset = FrameSizeAdjust + LocalFrameOffset - BaseOffset;
278  return TRI->isFrameOffsetLegal(&MI, BaseReg, Offset);
279 }
280 
281 bool LocalStackSlotPass::insertFrameReferenceRegisters(MachineFunction &Fn) {
282  // Scan the function's instructions looking for frame index references.
283  // For each, ask the target if it wants a virtual base register for it
284  // based on what we can tell it about where the local will end up in the
285  // stack frame. If it wants one, re-use a suitable one we've previously
286  // allocated, or if there isn't one that fits the bill, allocate a new one
287  // and ask the target to create a defining instruction for it.
288  bool UsedBaseReg = false;
289 
290  MachineFrameInfo &MFI = Fn.getFrameInfo();
293  bool StackGrowsDown =
295 
296  // Collect all of the instructions in the block that reference
297  // a frame index. Also store the frame index referenced to ease later
298  // lookup. (For any insn that has more than one FI reference, we arbitrarily
299  // choose the first one).
300  SmallVector<FrameRef, 64> FrameReferenceInsns;
301 
302  unsigned Order = 0;
303 
304  for (MachineBasicBlock &BB : Fn) {
305  for (MachineInstr &MI : BB) {
306  // Debug value, stackmap and patchpoint instructions can't be out of
307  // range, so they don't need any updates.
308  if (MI.isDebugInstr() || MI.getOpcode() == TargetOpcode::STATEPOINT ||
309  MI.getOpcode() == TargetOpcode::STACKMAP ||
310  MI.getOpcode() == TargetOpcode::PATCHPOINT)
311  continue;
312 
313  // For now, allocate the base register(s) within the basic block
314  // where they're used, and don't try to keep them around outside
315  // of that. It may be beneficial to try sharing them more broadly
316  // than that, but the increased register pressure makes that a
317  // tricky thing to balance. Investigate if re-materializing these
318  // becomes an issue.
319  for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
320  // Consider replacing all frame index operands that reference
321  // an object allocated in the local block.
322  if (MI.getOperand(i).isFI()) {
323  // Don't try this with values not in the local block.
324  if (!MFI.isObjectPreAllocated(MI.getOperand(i).getIndex()))
325  break;
326  int Idx = MI.getOperand(i).getIndex();
327  int64_t LocalOffset = LocalOffsets[Idx];
328  if (!TRI->needsFrameBaseReg(&MI, LocalOffset))
329  break;
330  FrameReferenceInsns.push_back(FrameRef(&MI, LocalOffset, Idx, Order++));
331  break;
332  }
333  }
334  }
335  }
336 
337  // Sort the frame references by local offset.
338  // Use frame index as a tie-breaker in case MI's have the same offset.
339  llvm::sort(FrameReferenceInsns);
340 
341  MachineBasicBlock *Entry = &Fn.front();
342 
343  unsigned BaseReg = 0;
344  int64_t BaseOffset = 0;
345 
346  // Loop through the frame references and allocate for them as necessary.
347  for (int ref = 0, e = FrameReferenceInsns.size(); ref < e ; ++ref) {
348  FrameRef &FR = FrameReferenceInsns[ref];
349  MachineInstr &MI = *FR.getMachineInstr();
350  int64_t LocalOffset = FR.getLocalOffset();
351  int FrameIdx = FR.getFrameIndex();
352  assert(MFI.isObjectPreAllocated(FrameIdx) &&
353  "Only pre-allocated locals expected!");
354 
355  // We need to keep the references to the stack protector slot through frame
356  // index operands so that it gets resolved by PEI rather than this pass.
357  // This avoids accesses to the stack protector though virtual base
358  // registers, and forces PEI to address it using fp/sp/bp.
359  if (MFI.hasStackProtectorIndex() &&
360  FrameIdx == MFI.getStackProtectorIndex())
361  continue;
362 
363  LLVM_DEBUG(dbgs() << "Considering: " << MI);
364 
365  unsigned idx = 0;
366  for (unsigned f = MI.getNumOperands(); idx != f; ++idx) {
367  if (!MI.getOperand(idx).isFI())
368  continue;
369 
370  if (FrameIdx == MI.getOperand(idx).getIndex())
371  break;
372  }
373 
374  assert(idx < MI.getNumOperands() && "Cannot find FI operand");
375 
376  int64_t Offset = 0;
377  int64_t FrameSizeAdjust = StackGrowsDown ? MFI.getLocalFrameSize() : 0;
378 
379  LLVM_DEBUG(dbgs() << " Replacing FI in: " << MI);
380 
381  // If we have a suitable base register available, use it; otherwise
382  // create a new one. Note that any offset encoded in the
383  // instruction itself will be taken into account by the target,
384  // so we don't have to adjust for it here when reusing a base
385  // register.
386  if (UsedBaseReg &&
387  lookupCandidateBaseReg(BaseReg, BaseOffset, FrameSizeAdjust,
388  LocalOffset, MI, TRI)) {
389  LLVM_DEBUG(dbgs() << " Reusing base register " << BaseReg << "\n");
390  // We found a register to reuse.
391  Offset = FrameSizeAdjust + LocalOffset - BaseOffset;
392  } else {
393  // No previously defined register was in range, so create a new one.
394  int64_t InstrOffset = TRI->getFrameIndexInstrOffset(&MI, idx);
395 
396  int64_t PrevBaseOffset = BaseOffset;
397  BaseOffset = FrameSizeAdjust + LocalOffset + InstrOffset;
398 
399  // We'd like to avoid creating single-use virtual base registers.
400  // Because the FrameRefs are in sorted order, and we've already
401  // processed all FrameRefs before this one, just check whether or not
402  // the next FrameRef will be able to reuse this new register. If not,
403  // then don't bother creating it.
404  if (ref + 1 >= e ||
406  BaseReg, BaseOffset, FrameSizeAdjust,
407  FrameReferenceInsns[ref + 1].getLocalOffset(),
408  *FrameReferenceInsns[ref + 1].getMachineInstr(), TRI)) {
409  BaseOffset = PrevBaseOffset;
410  continue;
411  }
412 
413  const MachineFunction *MF = MI.getMF();
414  const TargetRegisterClass *RC = TRI->getPointerRegClass(*MF);
415  BaseReg = Fn.getRegInfo().createVirtualRegister(RC);
416 
417  LLVM_DEBUG(dbgs() << " Materializing base register"
418  << " at frame local offset "
419  << LocalOffset + InstrOffset);
420 
421  // Tell the target to insert the instruction to initialize
422  // the base register.
423  // MachineBasicBlock::iterator InsertionPt = Entry->begin();
424  BaseReg = TRI->materializeFrameBaseRegister(Entry, FrameIdx, InstrOffset);
425 
426  LLVM_DEBUG(dbgs() << " into " << printReg(BaseReg, TRI) << '\n');
427 
428  // The base register already includes any offset specified
429  // by the instruction, so account for that so it doesn't get
430  // applied twice.
431  Offset = -InstrOffset;
432 
433  ++NumBaseRegisters;
434  UsedBaseReg = true;
435  }
436  assert(BaseReg != 0 && "Unable to allocate virtual base register!");
437 
438  // Modify the instruction to use the new base register rather
439  // than the frame index operand.
440  TRI->resolveFrameIndex(MI, BaseReg, Offset);
441  LLVM_DEBUG(dbgs() << "Resolved: " << MI);
442 
443  ++NumReplacements;
444  }
445 
446  return UsedBaseReg;
447 }
i
i
Definition: README.txt:29
INITIALIZE_PASS
INITIALIZE_PASS(LocalStackSlotPass, DEBUG_TYPE, "Local Stack Slot Allocation", false, false) bool LocalStackSlotPass
Definition: LocalStackSlotAllocation.cpp:110
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:148
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:100
MachineInstr.h
llvm
Definition: AllocatorList.h:23
lookupCandidateBaseReg
static bool lookupCandidateBaseReg(unsigned BaseReg, int64_t BaseOffset, int64_t FrameSizeAdjust, int64_t LocalFrameOffset, const MachineInstr &MI, const TargetRegisterInfo *TRI)
Definition: LocalStackSlotAllocation.cpp:269
TargetFrameLowering.h
llvm::TargetRegisterInfo::resolveFrameIndex
virtual void resolveFrameIndex(MachineInstr &MI, Register BaseReg, int64_t Offset) const
Resolve a frame index operand of an instruction to reference the indicated base register plus offset ...
Definition: TargetRegisterInfo.h:964
llvm::TargetFrameLowering
Information about stack frame layout on the target.
Definition: TargetFrameLowering.h:42
Pass.h
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
Statistic.h
ErrorHandling.h
llvm::TargetFrameLowering::isStackIdSafeForLocalArea
virtual bool isStackIdSafeForLocalArea(unsigned StackId) const
This method returns whether or not it is safe for an object with the given stack id to be bundled int...
Definition: TargetFrameLowering.h:132
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
MachineBasicBlock.h
llvm::TargetSubtargetInfo::getRegisterInfo
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
Definition: TargetSubtargetInfo.h:124
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:231
llvm::MachineFrameInfo::isObjectPreAllocated
bool isObjectPreAllocated(int ObjectIdx) const
Return true if the object was pre-allocated into the local block.
Definition: MachineFrameInfo.h:444
llvm::LocalStackSlotAllocationID
char & LocalStackSlotAllocationID
LocalStackSlotAllocation - This pass assigns local frame indices to stack slots relative to one anoth...
Definition: LocalStackSlotAllocation.cpp:109
llvm::MachineFrameInfo::SSPLK_LargeArray
@ SSPLK_LargeArray
Array or nested array >= SSP-buffer-size.
Definition: MachineFrameInfo.h:114
llvm::SmallSet
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:134
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
DEBUG_TYPE
#define DEBUG_TYPE
Definition: LocalStackSlotAllocation.cpp:43
llvm::MachineFrameInfo::getObjectIndexEnd
int getObjectIndexEnd() const
Return one past the maximum frame object index.
Definition: MachineFrameInfo.h:391
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::MachineFunctionPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Definition: MachineFunctionPass.cpp:102
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:122
getMachineInstr
static MachineInstr * getMachineInstr(MachineInstr *MI)
Definition: GCNIterativeScheduler.cpp:32
MachineRegisterInfo.h
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
llvm::MachineFrameInfo::setLocalFrameMaxAlign
void setLocalFrameMaxAlign(Align Alignment)
Required alignment of the local object blob, which is the strictest alignment of any object in it.
Definition: MachineFrameInfo.h:423
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:46
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::initializeLocalStackSlotPassPass
void initializeLocalStackSlotPassPass(PassRegistry &)
TargetOpcodes.h
llvm::TargetRegisterInfo::requiresVirtualBaseRegisters
virtual bool requiresVirtualBaseRegisters(const MachineFunction &MF) const
Returns true if the target wants the LocalStackAllocation pass to be run and virtual base registers u...
Definition: TargetRegisterInfo.h:906
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::MachineFrameInfo::getStackID
uint8_t getStackID(int ObjectIdx) const
Definition: MachineFrameInfo.h:697
llvm::MachineFrameInfo::SSPLK_None
@ SSPLK_None
Did not trigger a stack protector.
Definition: MachineFrameInfo.h:112
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:606
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::MachineFrameInfo::isDeadObjectIndex
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
Definition: MachineFrameInfo.h:711
llvm::TargetRegisterInfo::getPointerRegClass
virtual const TargetRegisterClass * getPointerRegClass(const MachineFunction &MF, unsigned Kind=0) const
Returns a TargetRegisterClass used for pointer values.
Definition: TargetRegisterInfo.h:757
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:558
AdjustStackOffset
static void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, int64_t &Offset, Align &MaxAlign, unsigned Skew)
AdjustStackOffset - Helper function used to adjust the stack frame offset.
Definition: PrologEpilogInserter.cpp:634
llvm::SmallSet::count
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
Definition: SmallSet.h:164
llvm::MachineFrameInfo::getLocalFrameSize
int64_t getLocalFrameSize() const
Get the size of the local object blob.
Definition: MachineFrameInfo.h:419
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::MachineFrameInfo::getObjectSize
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
Definition: MachineFrameInfo.h:451
llvm::MachineFrameInfo::hasStackProtectorIndex
bool hasStackProtectorIndex() const
Definition: MachineFrameInfo.h:356
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::operator<
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:343
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::MachineFrameInfo::getObjectAlign
Align getObjectAlign(int ObjectIdx) const
Return the alignment of the specified stack object.
Definition: MachineFrameInfo.h:465
MachineFunctionPass.h
llvm::MachineFrameInfo::mapLocalFrameObject
void mapLocalFrameObject(int ObjectIndex, int64_t Offset)
Map a frame index into the local object block.
Definition: MachineFrameInfo.h:400
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MachineFunction::getFrameInfo
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Definition: MachineFunction.h:574
llvm::TargetFrameLowering::getStackGrowthDirection
StackDirection getStackGrowthDirection() const
getStackGrowthDirection - Return the direction the stack grows
Definition: TargetFrameLowering.h:88
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::SetVector::insert
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:141
llvm::TargetRegisterInfo::needsFrameBaseReg
virtual bool needsFrameBaseReg(MachineInstr *MI, int64_t Offset) const
Returns true if the instruction's frame index reference would be better served by a base register oth...
Definition: TargetRegisterInfo.h:949
llvm::AnalysisUsage::setPreservesCFG
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:253
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
AssignProtectedObjSet
static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs, SmallSet< int, 16 > &ProtectedObjs, MachineFrameInfo &MFI, bool StackGrowsDown, int64_t &Offset, Align &MaxAlign, unsigned Skew)
AssignProtectedObjSet - Helper function to assign large stack objects (i.e., those required to be clo...
Definition: PrologEpilogInserter.cpp:767
TargetSubtargetInfo.h
llvm::SmallSet::insert
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:180
llvm::MachineFrameInfo::getObjectSSPLayout
SSPLayoutKind getObjectSSPLayout(int ObjectIdx) const
Definition: MachineFrameInfo.h:534
llvm::TargetSubtargetInfo::getFrameLowering
virtual const TargetFrameLowering * getFrameLowering() const
Definition: TargetSubtargetInfo.h:93
MachineFrameInfo.h
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1423
llvm::TargetRegisterInfo::getFrameIndexInstrOffset
virtual int64_t getFrameIndexInstrOffset(const MachineInstr *MI, int Idx) const
Get the offset from the referenced frame index in the instruction, if there is one.
Definition: TargetRegisterInfo.h:940
llvm::TargetRegisterInfo::materializeFrameBaseRegister
virtual Register materializeFrameBaseRegister(MachineBasicBlock *MBB, int FrameIdx, int64_t Offset) const
Insert defining instruction(s) for a pointer to FrameIdx before insertion point I.
Definition: TargetRegisterInfo.h:955
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:107
SmallVector.h
llvm::MachineFrameInfo::SSPLK_AddrOf
@ SSPLK_AddrOf
The address of this allocation is exposed and triggered protection.
Definition: MachineFrameInfo.h:118
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::MachineFrameInfo::SSPLK_SmallArray
@ SSPLK_SmallArray
Array or nested array < SSP-buffer-size.
Definition: MachineFrameInfo.h:116
MachineOperand.h
llvm::TargetFrameLowering::StackGrowsDown
@ StackGrowsDown
Definition: TargetFrameLowering.h:46
llvm::SmallSetVector
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:307
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::MachineFrameInfo::getStackProtectorIndex
int getStackProtectorIndex() const
Return the index for the stack protector object.
Definition: MachineFrameInfo.h:354
llvm::TargetRegisterInfo::isFrameOffsetLegal
virtual bool isFrameOffsetLegal(const MachineInstr *MI, Register BaseReg, int64_t Offset) const
Determine whether a given base register plus offset immediate is encodable to resolve a frame index.
Definition: TargetRegisterInfo.h:971
raw_ostream.h
MachineFunction.h
llvm::printReg
Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
Definition: TargetRegisterInfo.cpp:110
llvm::MachineInstrBundleIterator< MachineInstr >
InitializePasses.h
llvm::MachineFrameInfo::setLocalFrameSize
void setLocalFrameSize(int64_t sz)
Set the size of the local object blob.
Definition: MachineFrameInfo.h:416
TargetRegisterInfo.h
Debug.h
llvm::MachineFrameInfo::setUseLocalStackAllocationBlock
void setUseLocalStackAllocationBlock(bool v)
setUseLocalStackAllocationBlock - Set whether the local allocation blob should be allocated together ...
Definition: MachineFrameInfo.h:439
SetVector.h
SmallSet.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38