LLVM  14.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  // Only place the stack protector in the local stack area if the target
214  // allows it.
215  if (TFI.isStackIdSafeForLocalArea(MFI.getStackID(StackProtectorFI)))
216  AdjustStackOffset(MFI, StackProtectorFI, Offset, StackGrowsDown,
217  MaxAlign);
218 
219  // Assign large stack objects first.
220  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
221  if (MFI.isDeadObjectIndex(i))
222  continue;
223  if (StackProtectorFI == (int)i)
224  continue;
225  if (!TFI.isStackIdSafeForLocalArea(MFI.getStackID(i)))
226  continue;
227 
228  switch (MFI.getObjectSSPLayout(i)) {
230  continue;
232  SmallArrayObjs.insert(i);
233  continue;
235  AddrOfObjs.insert(i);
236  continue;
238  LargeArrayObjs.insert(i);
239  continue;
240  }
241  llvm_unreachable("Unexpected SSPLayoutKind.");
242  }
243 
244  AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
245  Offset, MaxAlign);
246  AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
247  Offset, MaxAlign);
248  AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
249  Offset, MaxAlign);
250  }
251 
252  // Then assign frame offsets to stack objects that are not used to spill
253  // callee saved registers.
254  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
255  if (MFI.isDeadObjectIndex(i))
256  continue;
257  if (MFI.getStackProtectorIndex() == (int)i)
258  continue;
259  if (ProtectedObjs.count(i))
260  continue;
261  if (!TFI.isStackIdSafeForLocalArea(MFI.getStackID(i)))
262  continue;
263 
264  AdjustStackOffset(MFI, i, Offset, StackGrowsDown, MaxAlign);
265  }
266 
267  // Remember how big this blob of stack space is
269  MFI.setLocalFrameMaxAlign(MaxAlign);
270 }
271 
272 static inline bool
273 lookupCandidateBaseReg(unsigned BaseReg,
274  int64_t BaseOffset,
275  int64_t FrameSizeAdjust,
276  int64_t LocalFrameOffset,
277  const MachineInstr &MI,
278  const TargetRegisterInfo *TRI) {
279  // Check if the relative offset from the where the base register references
280  // to the target address is in range for the instruction.
281  int64_t Offset = FrameSizeAdjust + LocalFrameOffset - BaseOffset;
282  return TRI->isFrameOffsetLegal(&MI, BaseReg, Offset);
283 }
284 
285 bool LocalStackSlotPass::insertFrameReferenceRegisters(MachineFunction &Fn) {
286  // Scan the function's instructions looking for frame index references.
287  // For each, ask the target if it wants a virtual base register for it
288  // based on what we can tell it about where the local will end up in the
289  // stack frame. If it wants one, re-use a suitable one we've previously
290  // allocated, or if there isn't one that fits the bill, allocate a new one
291  // and ask the target to create a defining instruction for it.
292  bool UsedBaseReg = false;
293 
294  MachineFrameInfo &MFI = Fn.getFrameInfo();
297  bool StackGrowsDown =
299 
300  // Collect all of the instructions in the block that reference
301  // a frame index. Also store the frame index referenced to ease later
302  // lookup. (For any insn that has more than one FI reference, we arbitrarily
303  // choose the first one).
304  SmallVector<FrameRef, 64> FrameReferenceInsns;
305 
306  unsigned Order = 0;
307 
308  for (MachineBasicBlock &BB : Fn) {
309  for (MachineInstr &MI : BB) {
310  // Debug value, stackmap and patchpoint instructions can't be out of
311  // range, so they don't need any updates.
312  if (MI.isDebugInstr() || MI.getOpcode() == TargetOpcode::STATEPOINT ||
313  MI.getOpcode() == TargetOpcode::STACKMAP ||
314  MI.getOpcode() == TargetOpcode::PATCHPOINT)
315  continue;
316 
317  // For now, allocate the base register(s) within the basic block
318  // where they're used, and don't try to keep them around outside
319  // of that. It may be beneficial to try sharing them more broadly
320  // than that, but the increased register pressure makes that a
321  // tricky thing to balance. Investigate if re-materializing these
322  // becomes an issue.
323  for (const MachineOperand &MO : MI.operands()) {
324  // Consider replacing all frame index operands that reference
325  // an object allocated in the local block.
326  if (MO.isFI()) {
327  // Don't try this with values not in the local block.
328  if (!MFI.isObjectPreAllocated(MO.getIndex()))
329  break;
330  int Idx = MO.getIndex();
331  int64_t LocalOffset = LocalOffsets[Idx];
332  if (!TRI->needsFrameBaseReg(&MI, LocalOffset))
333  break;
334  FrameReferenceInsns.push_back(FrameRef(&MI, LocalOffset, Idx, Order++));
335  break;
336  }
337  }
338  }
339  }
340 
341  // Sort the frame references by local offset.
342  // Use frame index as a tie-breaker in case MI's have the same offset.
343  llvm::sort(FrameReferenceInsns);
344 
345  MachineBasicBlock *Entry = &Fn.front();
346 
347  unsigned BaseReg = 0;
348  int64_t BaseOffset = 0;
349 
350  // Loop through the frame references and allocate for them as necessary.
351  for (int ref = 0, e = FrameReferenceInsns.size(); ref < e ; ++ref) {
352  FrameRef &FR = FrameReferenceInsns[ref];
353  MachineInstr &MI = *FR.getMachineInstr();
354  int64_t LocalOffset = FR.getLocalOffset();
355  int FrameIdx = FR.getFrameIndex();
356  assert(MFI.isObjectPreAllocated(FrameIdx) &&
357  "Only pre-allocated locals expected!");
358 
359  // We need to keep the references to the stack protector slot through frame
360  // index operands so that it gets resolved by PEI rather than this pass.
361  // This avoids accesses to the stack protector though virtual base
362  // registers, and forces PEI to address it using fp/sp/bp.
363  if (MFI.hasStackProtectorIndex() &&
364  FrameIdx == MFI.getStackProtectorIndex())
365  continue;
366 
367  LLVM_DEBUG(dbgs() << "Considering: " << MI);
368 
369  unsigned idx = 0;
370  for (unsigned f = MI.getNumOperands(); idx != f; ++idx) {
371  if (!MI.getOperand(idx).isFI())
372  continue;
373 
374  if (FrameIdx == MI.getOperand(idx).getIndex())
375  break;
376  }
377 
378  assert(idx < MI.getNumOperands() && "Cannot find FI operand");
379 
380  int64_t Offset = 0;
381  int64_t FrameSizeAdjust = StackGrowsDown ? MFI.getLocalFrameSize() : 0;
382 
383  LLVM_DEBUG(dbgs() << " Replacing FI in: " << MI);
384 
385  // If we have a suitable base register available, use it; otherwise
386  // create a new one. Note that any offset encoded in the
387  // instruction itself will be taken into account by the target,
388  // so we don't have to adjust for it here when reusing a base
389  // register.
390  if (UsedBaseReg &&
391  lookupCandidateBaseReg(BaseReg, BaseOffset, FrameSizeAdjust,
392  LocalOffset, MI, TRI)) {
393  LLVM_DEBUG(dbgs() << " Reusing base register " << BaseReg << "\n");
394  // We found a register to reuse.
395  Offset = FrameSizeAdjust + LocalOffset - BaseOffset;
396  } else {
397  // No previously defined register was in range, so create a new one.
398  int64_t InstrOffset = TRI->getFrameIndexInstrOffset(&MI, idx);
399 
400  int64_t PrevBaseOffset = BaseOffset;
401  BaseOffset = FrameSizeAdjust + LocalOffset + InstrOffset;
402 
403  // We'd like to avoid creating single-use virtual base registers.
404  // Because the FrameRefs are in sorted order, and we've already
405  // processed all FrameRefs before this one, just check whether or not
406  // the next FrameRef will be able to reuse this new register. If not,
407  // then don't bother creating it.
408  if (ref + 1 >= e ||
410  BaseReg, BaseOffset, FrameSizeAdjust,
411  FrameReferenceInsns[ref + 1].getLocalOffset(),
412  *FrameReferenceInsns[ref + 1].getMachineInstr(), TRI)) {
413  BaseOffset = PrevBaseOffset;
414  continue;
415  }
416 
417  const MachineFunction *MF = MI.getMF();
418  const TargetRegisterClass *RC = TRI->getPointerRegClass(*MF);
419  BaseReg = Fn.getRegInfo().createVirtualRegister(RC);
420 
421  LLVM_DEBUG(dbgs() << " Materializing base register"
422  << " at frame local offset "
423  << LocalOffset + InstrOffset);
424 
425  // Tell the target to insert the instruction to initialize
426  // the base register.
427  // MachineBasicBlock::iterator InsertionPt = Entry->begin();
428  BaseReg = TRI->materializeFrameBaseRegister(Entry, FrameIdx, InstrOffset);
429 
430  LLVM_DEBUG(dbgs() << " into " << printReg(BaseReg, TRI) << '\n');
431 
432  // The base register already includes any offset specified
433  // by the instruction, so account for that so it doesn't get
434  // applied twice.
435  Offset = -InstrOffset;
436 
437  ++NumBaseRegisters;
438  UsedBaseReg = true;
439  }
440  assert(BaseReg != 0 && "Unable to allocate virtual base register!");
441 
442  // Modify the instruction to use the new base register rather
443  // than the frame index operand.
444  TRI->resolveFrameIndex(MI, BaseReg, Offset);
445  LLVM_DEBUG(dbgs() << "Resolved: " << MI);
446 
447  ++NumReplacements;
448  }
449 
450  return UsedBaseReg;
451 }
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:105
MachineInstr.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
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:273
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:966
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:1177
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:124
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:233
llvm::MachineFrameInfo::isObjectPreAllocated
bool isObjectPreAllocated(int ObjectIdx) const
Return true if the object was pre-allocated into the local block.
Definition: MachineFrameInfo.h:446
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:80
DEBUG_TYPE
#define DEBUG_TYPE
Definition: LocalStackSlotAllocation.cpp:43
RHS
Value * RHS
Definition: X86PartialReduction.cpp:74
llvm::MachineFrameInfo::getObjectIndexEnd
int getObjectIndexEnd() const
Return one past the maximum frame object index.
Definition: MachineFrameInfo.h:393
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1559
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:101
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:163
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:425
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::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
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:908
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::MachineFrameInfo::getStackID
uint8_t getStackID(int ObjectIdx) const
Definition: MachineFrameInfo.h:699
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:609
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:713
llvm::TargetRegisterInfo::getPointerRegClass
virtual const TargetRegisterClass * getPointerRegClass(const MachineFunction &MF, unsigned Kind=0) const
Returns a TargetRegisterClass used for pointer values.
Definition: TargetRegisterInfo.h:759
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:641
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:656
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:421
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:453
llvm::MachineFrameInfo::hasStackProtectorIndex
bool hasStackProtectorIndex() const
Definition: MachineFrameInfo.h:358
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::operator<
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:338
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:467
MachineFunctionPass.h
llvm::MachineFrameInfo::mapLocalFrameObject
void mapLocalFrameObject(int ObjectIndex, int64_t Offset)
Map a frame index into the local object block.
Definition: MachineFrameInfo.h:402
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:657
llvm::TargetFrameLowering::getStackGrowthDirection
StackDirection getStackGrowthDirection() const
getStackGrowthDirection - Return the direction the stack grows
Definition: TargetFrameLowering.h:89
llvm::MachineFunction
Definition: MachineFunction.h:241
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:951
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:134
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:791
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:536
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:1590
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:942
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:957
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: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:356
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:973
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:418
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:441
SetVector.h
SmallSet.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38