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