LLVM  4.0.0
LocalStackSlotAllocation.cpp
Go to the documentation of this file.
1 //===- LocalStackSlotAllocation.cpp - Pre-allocate locals to stack slots --===//
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 // This pass assigns local frame indices to stack slots relative to one another
11 // and allocates additional base registers to access them when the target
12 // estimates they are likely to be out of range of stack pointer and frame
13 // pointer relative addressing.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "llvm/CodeGen/Passes.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SetVector.h"
20 #include "llvm/ADT/SmallSet.h"
21 #include "llvm/ADT/Statistic.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Intrinsics.h"
31 #include "llvm/IR/LLVMContext.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/Pass.h"
34 #include "llvm/Support/Debug.h"
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  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 
69  MachineBasicBlock::iterator getMachineInstr() const { return MI; }
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  /// StackObjSet - A set of stack object indexes
78 
79  void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx, int64_t &Offset,
80  bool StackGrowsDown, unsigned &MaxAlign);
81  void AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
82  SmallSet<int, 16> &ProtectedObjs,
83  MachineFrameInfo &MFI, bool StackGrowsDown,
84  int64_t &Offset, unsigned &MaxAlign);
85  void calculateFrameObjectOffsets(MachineFunction &Fn);
86  bool insertFrameReferenceRegisters(MachineFunction &Fn);
87  public:
88  static char ID; // Pass identification, replacement for typeid
89  explicit LocalStackSlotPass() : MachineFunctionPass(ID) {
91  }
92  bool runOnMachineFunction(MachineFunction &MF) override;
93 
94  void getAnalysisUsage(AnalysisUsage &AU) const override {
95  AU.setPreservesCFG();
98  }
99 
100  private:
101  };
102 } // end anonymous namespace
103 
104 char LocalStackSlotPass::ID = 0;
106 INITIALIZE_PASS_BEGIN(LocalStackSlotPass, "localstackalloc",
107  "Local Stack Slot Allocation", false, false)
109 INITIALIZE_PASS_END(LocalStackSlotPass, "localstackalloc",
110  "Local Stack Slot Allocation", false, false)
111 
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 (!TRI->requiresVirtualBaseRegisters(MF) || LocalObjectCount == 0)
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  int FrameIdx, int64_t &Offset,
145  bool StackGrowsDown,
146  unsigned &MaxAlign) {
147  // If the stack grows down, add the object size to find the lowest address.
148  if (StackGrowsDown)
149  Offset += MFI.getObjectSize(FrameIdx);
150 
151  unsigned Align = MFI.getObjectAlignment(FrameIdx);
152 
153  // If the alignment of this object is greater than that of the stack, then
154  // increase the stack alignment to match.
155  MaxAlign = std::max(MaxAlign, Align);
156 
157  // Adjust to alignment boundary.
158  Offset = (Offset + Align - 1) / Align * Align;
159 
160  int64_t LocalOffset = StackGrowsDown ? -Offset : Offset;
161  DEBUG(dbgs() << "Allocate FI(" << FrameIdx << ") to local offset "
162  << LocalOffset << "\n");
163  // Keep the offset available for base register allocation
164  LocalOffsets[FrameIdx] = LocalOffset;
165  // And tell MFI about it for PEI to use later
166  MFI.mapLocalFrameObject(FrameIdx, LocalOffset);
167 
168  if (!StackGrowsDown)
169  Offset += MFI.getObjectSize(FrameIdx);
170 
171  ++NumAllocations;
172 }
173 
174 /// AssignProtectedObjSet - Helper function to assign large stack objects (i.e.,
175 /// those required to be close to the Stack Protector) to stack offsets.
176 void LocalStackSlotPass::AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
177  SmallSet<int, 16> &ProtectedObjs,
178  MachineFrameInfo &MFI,
179  bool StackGrowsDown, int64_t &Offset,
180  unsigned &MaxAlign) {
181 
182  for (StackObjSet::const_iterator I = UnassignedObjs.begin(),
183  E = UnassignedObjs.end(); I != E; ++I) {
184  int i = *I;
185  AdjustStackOffset(MFI, i, Offset, StackGrowsDown, MaxAlign);
186  ProtectedObjs.insert(i);
187  }
188 }
189 
190 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
191 /// abstract stack objects.
192 ///
193 void LocalStackSlotPass::calculateFrameObjectOffsets(MachineFunction &Fn) {
194  // Loop over all of the stack objects, assigning sequential addresses...
195  MachineFrameInfo &MFI = Fn.getFrameInfo();
197  bool StackGrowsDown =
199  int64_t Offset = 0;
200  unsigned MaxAlign = 0;
201  StackProtector *SP = &getAnalysis<StackProtector>();
202 
203  // Make sure that the stack protector comes before the local variables on the
204  // stack.
205  SmallSet<int, 16> ProtectedObjs;
206  if (MFI.getStackProtectorIndex() >= 0) {
207  StackObjSet LargeArrayObjs;
208  StackObjSet SmallArrayObjs;
209  StackObjSet AddrOfObjs;
210 
212  StackGrowsDown, MaxAlign);
213 
214  // Assign large stack objects first.
215  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
216  if (MFI.isDeadObjectIndex(i))
217  continue;
218  if (MFI.getStackProtectorIndex() == (int)i)
219  continue;
220 
221  switch (SP->getSSPLayout(MFI.getObjectAllocation(i))) {
223  continue;
225  SmallArrayObjs.insert(i);
226  continue;
228  AddrOfObjs.insert(i);
229  continue;
231  LargeArrayObjs.insert(i);
232  continue;
233  }
234  llvm_unreachable("Unexpected SSPLayoutKind.");
235  }
236 
237  AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
238  Offset, MaxAlign);
239  AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
240  Offset, MaxAlign);
241  AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
242  Offset, MaxAlign);
243  }
244 
245  // Then assign frame offsets to stack objects that are not used to spill
246  // callee saved registers.
247  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
248  if (MFI.isDeadObjectIndex(i))
249  continue;
250  if (MFI.getStackProtectorIndex() == (int)i)
251  continue;
252  if (ProtectedObjs.count(i))
253  continue;
254 
255  AdjustStackOffset(MFI, i, Offset, StackGrowsDown, MaxAlign);
256  }
257 
258  // Remember how big this blob of stack space is
259  MFI.setLocalFrameSize(Offset);
260  MFI.setLocalFrameMaxAlign(MaxAlign);
261 }
262 
263 static inline bool
264 lookupCandidateBaseReg(unsigned BaseReg,
265  int64_t BaseOffset,
266  int64_t FrameSizeAdjust,
267  int64_t LocalFrameOffset,
268  const MachineInstr &MI,
269  const TargetRegisterInfo *TRI) {
270  // Check if the relative offset from the where the base register references
271  // to the target address is in range for the instruction.
272  int64_t Offset = FrameSizeAdjust + LocalFrameOffset - BaseOffset;
273  return TRI->isFrameOffsetLegal(&MI, BaseReg, Offset);
274 }
275 
276 bool LocalStackSlotPass::insertFrameReferenceRegisters(MachineFunction &Fn) {
277  // Scan the function's instructions looking for frame index references.
278  // For each, ask the target if it wants a virtual base register for it
279  // based on what we can tell it about where the local will end up in the
280  // stack frame. If it wants one, re-use a suitable one we've previously
281  // allocated, or if there isn't one that fits the bill, allocate a new one
282  // and ask the target to create a defining instruction for it.
283  bool UsedBaseReg = false;
284 
285  MachineFrameInfo &MFI = Fn.getFrameInfo();
286  const TargetRegisterInfo *TRI = Fn.getSubtarget().getRegisterInfo();
288  bool StackGrowsDown =
290 
291  // Collect all of the instructions in the block that reference
292  // a frame index. Also store the frame index referenced to ease later
293  // lookup. (For any insn that has more than one FI reference, we arbitrarily
294  // choose the first one).
295  SmallVector<FrameRef, 64> FrameReferenceInsns;
296 
297  unsigned Order = 0;
298 
299  for (MachineBasicBlock &BB : Fn) {
300  for (MachineInstr &MI : BB) {
301  // Debug value, stackmap and patchpoint instructions can't be out of
302  // range, so they don't need any updates.
303  if (MI.isDebugValue() || MI.getOpcode() == TargetOpcode::STATEPOINT ||
304  MI.getOpcode() == TargetOpcode::STACKMAP ||
305  MI.getOpcode() == TargetOpcode::PATCHPOINT)
306  continue;
307 
308  // For now, allocate the base register(s) within the basic block
309  // where they're used, and don't try to keep them around outside
310  // of that. It may be beneficial to try sharing them more broadly
311  // than that, but the increased register pressure makes that a
312  // tricky thing to balance. Investigate if re-materializing these
313  // becomes an issue.
314  for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
315  // Consider replacing all frame index operands that reference
316  // an object allocated in the local block.
317  if (MI.getOperand(i).isFI()) {
318  // Don't try this with values not in the local block.
319  if (!MFI.isObjectPreAllocated(MI.getOperand(i).getIndex()))
320  break;
321  int Idx = MI.getOperand(i).getIndex();
322  int64_t LocalOffset = LocalOffsets[Idx];
323  if (!TRI->needsFrameBaseReg(&MI, LocalOffset))
324  break;
325  FrameReferenceInsns.push_back(FrameRef(&MI, LocalOffset, Idx, Order++));
326  break;
327  }
328  }
329  }
330  }
331 
332  // Sort the frame references by local offset.
333  // Use frame index as a tie-breaker in case MI's have the same offset.
334  std::sort(FrameReferenceInsns.begin(), FrameReferenceInsns.end());
335 
336  MachineBasicBlock *Entry = &Fn.front();
337 
338  unsigned BaseReg = 0;
339  int64_t BaseOffset = 0;
340 
341  // Loop through the frame references and allocate for them as necessary.
342  for (int ref = 0, e = FrameReferenceInsns.size(); ref < e ; ++ref) {
343  FrameRef &FR = FrameReferenceInsns[ref];
344  MachineInstr &MI = *FR.getMachineInstr();
345  int64_t LocalOffset = FR.getLocalOffset();
346  int FrameIdx = FR.getFrameIndex();
347  assert(MFI.isObjectPreAllocated(FrameIdx) &&
348  "Only pre-allocated locals expected!");
349 
350  DEBUG(dbgs() << "Considering: " << MI);
351 
352  unsigned idx = 0;
353  for (unsigned f = MI.getNumOperands(); idx != f; ++idx) {
354  if (!MI.getOperand(idx).isFI())
355  continue;
356 
357  if (FrameIdx == MI.getOperand(idx).getIndex())
358  break;
359  }
360 
361  assert(idx < MI.getNumOperands() && "Cannot find FI operand");
362 
363  int64_t Offset = 0;
364  int64_t FrameSizeAdjust = StackGrowsDown ? MFI.getLocalFrameSize() : 0;
365 
366  DEBUG(dbgs() << " Replacing FI in: " << MI);
367 
368  // If we have a suitable base register available, use it; otherwise
369  // create a new one. Note that any offset encoded in the
370  // instruction itself will be taken into account by the target,
371  // so we don't have to adjust for it here when reusing a base
372  // register.
373  if (UsedBaseReg &&
374  lookupCandidateBaseReg(BaseReg, BaseOffset, FrameSizeAdjust,
375  LocalOffset, MI, TRI)) {
376  DEBUG(dbgs() << " Reusing base register " << BaseReg << "\n");
377  // We found a register to reuse.
378  Offset = FrameSizeAdjust + LocalOffset - BaseOffset;
379  } else {
380  // No previously defined register was in range, so create a new one.
381  int64_t InstrOffset = TRI->getFrameIndexInstrOffset(&MI, idx);
382 
383  int64_t PrevBaseOffset = BaseOffset;
384  BaseOffset = FrameSizeAdjust + LocalOffset + InstrOffset;
385 
386  // We'd like to avoid creating single-use virtual base registers.
387  // Because the FrameRefs are in sorted order, and we've already
388  // processed all FrameRefs before this one, just check whether or not
389  // the next FrameRef will be able to reuse this new register. If not,
390  // then don't bother creating it.
391  if (ref + 1 >= e ||
393  BaseReg, BaseOffset, FrameSizeAdjust,
394  FrameReferenceInsns[ref + 1].getLocalOffset(),
395  *FrameReferenceInsns[ref + 1].getMachineInstr(), TRI)) {
396  BaseOffset = PrevBaseOffset;
397  continue;
398  }
399 
400  const MachineFunction *MF = MI.getParent()->getParent();
401  const TargetRegisterClass *RC = TRI->getPointerRegClass(*MF);
402  BaseReg = Fn.getRegInfo().createVirtualRegister(RC);
403 
404  DEBUG(dbgs() << " Materializing base register " << BaseReg <<
405  " at frame local offset " << LocalOffset + InstrOffset << "\n");
406 
407  // Tell the target to insert the instruction to initialize
408  // the base register.
409  // MachineBasicBlock::iterator InsertionPt = Entry->begin();
410  TRI->materializeFrameBaseRegister(Entry, BaseReg, FrameIdx,
411  InstrOffset);
412 
413  // The base register already includes any offset specified
414  // by the instruction, so account for that so it doesn't get
415  // applied twice.
416  Offset = -InstrOffset;
417 
418  ++NumBaseRegisters;
419  UsedBaseReg = true;
420  }
421  assert(BaseReg != 0 && "Unable to allocate virtual base register!");
422 
423  // Modify the instruction to use the new base register rather
424  // than the frame index operand.
425  TRI->resolveFrameIndex(MI, BaseReg, Offset);
426  DEBUG(dbgs() << "Resolved: " << MI);
427 
428  ++NumReplacements;
429  }
430 
431  return UsedBaseReg;
432 }
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
static bool lookupCandidateBaseReg(unsigned BaseReg, int64_t BaseOffset, int64_t FrameSizeAdjust, int64_t LocalFrameOffset, const MachineInstr &MI, const TargetRegisterInfo *TRI)
static void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, int64_t &Offset, unsigned &MaxAlign, unsigned Skew)
AdjustStackOffset - Helper function used to adjust the stack frame offset.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
void mapLocalFrameObject(int ObjectIndex, int64_t Offset)
Map a frame index into the local object block.
STATISTIC(NumFunctions,"Total number of functions")
size_t i
INITIALIZE_PASS_BEGIN(LocalStackSlotPass,"localstackalloc","Local Stack Slot Allocation", false, false) INITIALIZE_PASS_END(LocalStackSlotPass
iterator end()
Get an iterator to the end of the SetVector.
Definition: SetVector.h:93
bool isObjectPreAllocated(int ObjectIdx) const
Return true if the object was pre-allocated into the local block.
int64_t getLocalFrameSize() const
Get the size of the local object blob.
AnalysisUsage & addRequired()
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.
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
Did not trigger a stack protector.
void setLocalFrameSize(int64_t sz)
Set the size of the local object blob.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
void setUseLocalStackAllocationBlock(bool v)
setUseLocalStackAllocationBlock - Set whether the local allocation blob should be allocated together ...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
The address of this allocation is exposed and triggered protection.
unsigned getNumOperands() const
Access to explicit operands of the instruction.
Definition: MachineInstr.h:277
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:136
bool isFI() const
isFI - Tests if this is a MO_FrameIndex operand.
iterator begin()
Get an iterator to the beginning of the SetVector.
Definition: SetVector.h:83
void setLocalFrameMaxAlign(unsigned Align)
Required alignment of the local object blob, which is the strictest alignment of any object in it...
virtual bool requiresVirtualBaseRegisters(const MachineFunction &MF) const
Returns true if the target wants the LocalStackAllocation pass to be run and virtual base registers u...
virtual void materializeFrameBaseRegister(MachineBasicBlock *MBB, unsigned BaseReg, int FrameIdx, int64_t Offset) const
Insert defining instruction(s) for BaseReg to be a pointer to FrameIdx before insertion point I...
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:131
Local Stack Slot Allocation
Local Stack Slot false
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:115
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:36
This file contains the declarations for the subclasses of Constant, which represent the different fla...
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:279
SmallSetVector< int, 8 > StackObjSet
StackObjSet - A set of stack object indexes.
Represent the analysis usage information of a pass.
uint32_t Offset
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
SSPLayoutKind getSSPLayout(const AllocaInst *AI) const
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:80
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
virtual const TargetFrameLowering * getFrameLowering() const
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:292
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
unsigned getObjectAlignment(int ObjectIdx) const
Return the alignment of the specified stack object.
Module.h This file contains the declarations for the Module class.
Information about stack frame layout on the target.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:276
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
virtual bool isFrameOffsetLegal(const MachineInstr *MI, unsigned BaseReg, int64_t Offset) const
Determine whether a given base register plus offset immediate is encodable to resolve a frame index...
int getStackProtectorIndex() const
Return the index for the stack protector object.
Representation of each machine instruction.
Definition: MachineInstr.h:52
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
StackDirection getStackGrowthDirection() const
getStackGrowthDirection - Return the direction the stack grows
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...
void initializeLocalStackSlotPassPass(PassRegistry &)
#define I(x, y, z)
Definition: MD5.cpp:54
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
virtual void resolveFrameIndex(MachineInstr &MI, unsigned BaseReg, int64_t Offset) const
Resolve a frame index operand of an instruction to reference the indicated base register plus offset ...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:326
#define DEBUG(X)
Definition: Debug.h:100
IRTranslator LLVM IR MI
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
int getObjectIndexEnd() const
Return one past the maximum frame object index.
char & LocalStackSlotAllocationID
LocalStackSlotAllocation - This pass assigns local frame indices to stack slots relative to one anoth...
const AllocaInst * getObjectAllocation(int ObjectIdx) const
Return the underlying Alloca of the specified stack object if it exists.
virtual const TargetRegisterClass * getPointerRegClass(const MachineFunction &MF, unsigned Kind=0) const
Returns a TargetRegisterClass used for pointer values.
static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs, SmallSet< int, 16 > &ProtectedObjs, MachineFrameInfo &MFI, bool StackGrowsDown, int64_t &Offset, unsigned &MaxAlign, unsigned Skew)
AssignProtectedObjSet - Helper function to assign large stack objects (i.e., those required to be clo...
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
Array or nested array >= SSP-buffer-size.
Array or nested array < SSP-buffer-size.