LLVM  3.7.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  public:
55  FrameRef(MachineBasicBlock::iterator I, int64_t Offset, int Idx) :
56  MI(I), LocalOffset(Offset), FrameIdx(Idx) {}
57  bool operator<(const FrameRef &RHS) const {
58  return LocalOffset < RHS.LocalOffset;
59  }
60  MachineBasicBlock::iterator getMachineInstr() const { return MI; }
61  int64_t getLocalOffset() const { return LocalOffset; }
62  int getFrameIndex() const { return FrameIdx; }
63  };
64 
65  class LocalStackSlotPass: public MachineFunctionPass {
66  SmallVector<int64_t,16> LocalOffsets;
67  /// StackObjSet - A set of stack object indexes
69 
70  void AdjustStackOffset(MachineFrameInfo *MFI, int FrameIdx, int64_t &Offset,
71  bool StackGrowsDown, unsigned &MaxAlign);
72  void AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
73  SmallSet<int, 16> &ProtectedObjs,
74  MachineFrameInfo *MFI, bool StackGrowsDown,
75  int64_t &Offset, unsigned &MaxAlign);
76  void calculateFrameObjectOffsets(MachineFunction &Fn);
77  bool insertFrameReferenceRegisters(MachineFunction &Fn);
78  public:
79  static char ID; // Pass identification, replacement for typeid
80  explicit LocalStackSlotPass() : MachineFunctionPass(ID) {
82  }
83  bool runOnMachineFunction(MachineFunction &MF) override;
84 
85  void getAnalysisUsage(AnalysisUsage &AU) const override {
86  AU.setPreservesCFG();
89  }
90 
91  private:
92  };
93 } // end anonymous namespace
94 
95 char LocalStackSlotPass::ID = 0;
97 INITIALIZE_PASS_BEGIN(LocalStackSlotPass, "localstackalloc",
98  "Local Stack Slot Allocation", false, false)
100 INITIALIZE_PASS_END(LocalStackSlotPass, "localstackalloc",
101  "Local Stack Slot Allocation", false, false)
102 
103 
104 bool LocalStackSlotPass::runOnMachineFunction(MachineFunction &MF) {
105  MachineFrameInfo *MFI = MF.getFrameInfo();
106  const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
107  unsigned LocalObjectCount = MFI->getObjectIndexEnd();
108 
109  // If the target doesn't want/need this pass, or if there are no locals
110  // to consider, early exit.
111  if (!TRI->requiresVirtualBaseRegisters(MF) || LocalObjectCount == 0)
112  return true;
113 
114  // Make sure we have enough space to store the local offsets.
115  LocalOffsets.resize(MFI->getObjectIndexEnd());
116 
117  // Lay out the local blob.
118  calculateFrameObjectOffsets(MF);
119 
120  // Insert virtual base registers to resolve frame index references.
121  bool UsedBaseRegs = insertFrameReferenceRegisters(MF);
122 
123  // Tell MFI whether any base registers were allocated. PEI will only
124  // want to use the local block allocations from this pass if there were any.
125  // Otherwise, PEI can do a bit better job of getting the alignment right
126  // without a hole at the start since it knows the alignment of the stack
127  // at the start of local allocation, and this pass doesn't.
128  MFI->setUseLocalStackAllocationBlock(UsedBaseRegs);
129 
130  return true;
131 }
132 
133 /// AdjustStackOffset - Helper function used to adjust the stack frame offset.
135  int FrameIdx, int64_t &Offset,
136  bool StackGrowsDown,
137  unsigned &MaxAlign) {
138  // If the stack grows down, add the object size to find the lowest address.
139  if (StackGrowsDown)
140  Offset += MFI->getObjectSize(FrameIdx);
141 
142  unsigned Align = MFI->getObjectAlignment(FrameIdx);
143 
144  // If the alignment of this object is greater than that of the stack, then
145  // increase the stack alignment to match.
146  MaxAlign = std::max(MaxAlign, Align);
147 
148  // Adjust to alignment boundary.
149  Offset = (Offset + Align - 1) / Align * Align;
150 
151  int64_t LocalOffset = StackGrowsDown ? -Offset : Offset;
152  DEBUG(dbgs() << "Allocate FI(" << FrameIdx << ") to local offset "
153  << LocalOffset << "\n");
154  // Keep the offset available for base register allocation
155  LocalOffsets[FrameIdx] = LocalOffset;
156  // And tell MFI about it for PEI to use later
157  MFI->mapLocalFrameObject(FrameIdx, LocalOffset);
158 
159  if (!StackGrowsDown)
160  Offset += MFI->getObjectSize(FrameIdx);
161 
162  ++NumAllocations;
163 }
164 
165 /// AssignProtectedObjSet - Helper function to assign large stack objects (i.e.,
166 /// those required to be close to the Stack Protector) to stack offsets.
167 void LocalStackSlotPass::AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
168  SmallSet<int, 16> &ProtectedObjs,
169  MachineFrameInfo *MFI,
170  bool StackGrowsDown, int64_t &Offset,
171  unsigned &MaxAlign) {
172 
173  for (StackObjSet::const_iterator I = UnassignedObjs.begin(),
174  E = UnassignedObjs.end(); I != E; ++I) {
175  int i = *I;
176  AdjustStackOffset(MFI, i, Offset, StackGrowsDown, MaxAlign);
177  ProtectedObjs.insert(i);
178  }
179 }
180 
181 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
182 /// abstract stack objects.
183 ///
184 void LocalStackSlotPass::calculateFrameObjectOffsets(MachineFunction &Fn) {
185  // Loop over all of the stack objects, assigning sequential addresses...
186  MachineFrameInfo *MFI = Fn.getFrameInfo();
188  bool StackGrowsDown =
190  int64_t Offset = 0;
191  unsigned MaxAlign = 0;
192  StackProtector *SP = &getAnalysis<StackProtector>();
193 
194  // Make sure that the stack protector comes before the local variables on the
195  // stack.
196  SmallSet<int, 16> ProtectedObjs;
197  if (MFI->getStackProtectorIndex() >= 0) {
198  StackObjSet LargeArrayObjs;
199  StackObjSet SmallArrayObjs;
200  StackObjSet AddrOfObjs;
201 
202  AdjustStackOffset(MFI, MFI->getStackProtectorIndex(), Offset,
203  StackGrowsDown, MaxAlign);
204 
205  // Assign large stack objects first.
206  for (unsigned i = 0, e = MFI->getObjectIndexEnd(); i != e; ++i) {
207  if (MFI->isDeadObjectIndex(i))
208  continue;
209  if (MFI->getStackProtectorIndex() == (int)i)
210  continue;
211 
212  switch (SP->getSSPLayout(MFI->getObjectAllocation(i))) {
214  continue;
216  SmallArrayObjs.insert(i);
217  continue;
219  AddrOfObjs.insert(i);
220  continue;
222  LargeArrayObjs.insert(i);
223  continue;
224  }
225  llvm_unreachable("Unexpected SSPLayoutKind.");
226  }
227 
228  AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
229  Offset, MaxAlign);
230  AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
231  Offset, MaxAlign);
232  AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
233  Offset, MaxAlign);
234  }
235 
236  // Then assign frame offsets to stack objects that are not used to spill
237  // callee saved registers.
238  for (unsigned i = 0, e = MFI->getObjectIndexEnd(); i != e; ++i) {
239  if (MFI->isDeadObjectIndex(i))
240  continue;
241  if (MFI->getStackProtectorIndex() == (int)i)
242  continue;
243  if (ProtectedObjs.count(i))
244  continue;
245 
246  AdjustStackOffset(MFI, i, Offset, StackGrowsDown, MaxAlign);
247  }
248 
249  // Remember how big this blob of stack space is
250  MFI->setLocalFrameSize(Offset);
251  MFI->setLocalFrameMaxAlign(MaxAlign);
252 }
253 
254 static inline bool
255 lookupCandidateBaseReg(unsigned BaseReg,
256  int64_t BaseOffset,
257  int64_t FrameSizeAdjust,
258  int64_t LocalFrameOffset,
259  const MachineInstr *MI,
260  const TargetRegisterInfo *TRI) {
261  // Check if the relative offset from the where the base register references
262  // to the target address is in range for the instruction.
263  int64_t Offset = FrameSizeAdjust + LocalFrameOffset - BaseOffset;
264  return TRI->isFrameOffsetLegal(MI, BaseReg, Offset);
265 }
266 
267 bool LocalStackSlotPass::insertFrameReferenceRegisters(MachineFunction &Fn) {
268  // Scan the function's instructions looking for frame index references.
269  // For each, ask the target if it wants a virtual base register for it
270  // based on what we can tell it about where the local will end up in the
271  // stack frame. If it wants one, re-use a suitable one we've previously
272  // allocated, or if there isn't one that fits the bill, allocate a new one
273  // and ask the target to create a defining instruction for it.
274  bool UsedBaseReg = false;
275 
276  MachineFrameInfo *MFI = Fn.getFrameInfo();
277  const TargetRegisterInfo *TRI = Fn.getSubtarget().getRegisterInfo();
279  bool StackGrowsDown =
281 
282  // Collect all of the instructions in the block that reference
283  // a frame index. Also store the frame index referenced to ease later
284  // lookup. (For any insn that has more than one FI reference, we arbitrarily
285  // choose the first one).
286  SmallVector<FrameRef, 64> FrameReferenceInsns;
287 
288  for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) {
289  for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) {
290  MachineInstr *MI = I;
291 
292  // Debug value, stackmap and patchpoint instructions can't be out of
293  // range, so they don't need any updates.
294  if (MI->isDebugValue() ||
298  continue;
299 
300  // For now, allocate the base register(s) within the basic block
301  // where they're used, and don't try to keep them around outside
302  // of that. It may be beneficial to try sharing them more broadly
303  // than that, but the increased register pressure makes that a
304  // tricky thing to balance. Investigate if re-materializing these
305  // becomes an issue.
306  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
307  // Consider replacing all frame index operands that reference
308  // an object allocated in the local block.
309  if (MI->getOperand(i).isFI()) {
310  // Don't try this with values not in the local block.
311  if (!MFI->isObjectPreAllocated(MI->getOperand(i).getIndex()))
312  break;
313  int Idx = MI->getOperand(i).getIndex();
314  int64_t LocalOffset = LocalOffsets[Idx];
315  if (!TRI->needsFrameBaseReg(MI, LocalOffset))
316  break;
317  FrameReferenceInsns.
318  push_back(FrameRef(MI, LocalOffset, Idx));
319  break;
320  }
321  }
322  }
323  }
324 
325  // Sort the frame references by local offset
326  array_pod_sort(FrameReferenceInsns.begin(), FrameReferenceInsns.end());
327 
328  MachineBasicBlock *Entry = Fn.begin();
329 
330  unsigned BaseReg = 0;
331  int64_t BaseOffset = 0;
332 
333  // Loop through the frame references and allocate for them as necessary.
334  for (int ref = 0, e = FrameReferenceInsns.size(); ref < e ; ++ref) {
335  FrameRef &FR = FrameReferenceInsns[ref];
336  MachineBasicBlock::iterator I = FR.getMachineInstr();
337  MachineInstr *MI = I;
338  int64_t LocalOffset = FR.getLocalOffset();
339  int FrameIdx = FR.getFrameIndex();
340  assert(MFI->isObjectPreAllocated(FrameIdx) &&
341  "Only pre-allocated locals expected!");
342 
343  DEBUG(dbgs() << "Considering: " << *MI);
344 
345  unsigned idx = 0;
346  for (unsigned f = MI->getNumOperands(); idx != f; ++idx) {
347  if (!MI->getOperand(idx).isFI())
348  continue;
349 
350  if (FrameIdx == I->getOperand(idx).getIndex())
351  break;
352  }
353 
354  assert(idx < MI->getNumOperands() && "Cannot find FI operand");
355 
356  int64_t Offset = 0;
357  int64_t FrameSizeAdjust = StackGrowsDown ? MFI->getLocalFrameSize() : 0;
358 
359  DEBUG(dbgs() << " Replacing FI in: " << *MI);
360 
361  // If we have a suitable base register available, use it; otherwise
362  // create a new one. Note that any offset encoded in the
363  // instruction itself will be taken into account by the target,
364  // so we don't have to adjust for it here when reusing a base
365  // register.
366  if (UsedBaseReg && lookupCandidateBaseReg(BaseReg, BaseOffset,
367  FrameSizeAdjust, LocalOffset, MI,
368  TRI)) {
369  DEBUG(dbgs() << " Reusing base register " << BaseReg << "\n");
370  // We found a register to reuse.
371  Offset = FrameSizeAdjust + LocalOffset - BaseOffset;
372  } else {
373  // No previously defined register was in range, so create a // new one.
374 
375  int64_t InstrOffset = TRI->getFrameIndexInstrOffset(MI, idx);
376 
377  int64_t PrevBaseOffset = BaseOffset;
378  BaseOffset = FrameSizeAdjust + LocalOffset + InstrOffset;
379 
380  // We'd like to avoid creating single-use virtual base registers.
381  // Because the FrameRefs are in sorted order, and we've already
382  // processed all FrameRefs before this one, just check whether or not
383  // the next FrameRef will be able to reuse this new register. If not,
384  // then don't bother creating it.
385  if (ref + 1 >= e ||
387  BaseReg, BaseOffset, FrameSizeAdjust,
388  FrameReferenceInsns[ref + 1].getLocalOffset(),
389  FrameReferenceInsns[ref + 1].getMachineInstr(), TRI)) {
390  BaseOffset = PrevBaseOffset;
391  continue;
392  }
393 
394  const MachineFunction *MF = MI->getParent()->getParent();
395  const TargetRegisterClass *RC = TRI->getPointerRegClass(*MF);
396  BaseReg = Fn.getRegInfo().createVirtualRegister(RC);
397 
398  DEBUG(dbgs() << " Materializing base register " << BaseReg <<
399  " at frame local offset " << LocalOffset + InstrOffset << "\n");
400 
401  // Tell the target to insert the instruction to initialize
402  // the base register.
403  // MachineBasicBlock::iterator InsertionPt = Entry->begin();
404  TRI->materializeFrameBaseRegister(Entry, BaseReg, FrameIdx,
405  InstrOffset);
406 
407  // The base register already includes any offset specified
408  // by the instruction, so account for that so it doesn't get
409  // applied twice.
410  Offset = -InstrOffset;
411 
412  ++NumBaseRegisters;
413  UsedBaseReg = true;
414  }
415  assert(BaseReg != 0 && "Unable to allocate virtual base register!");
416 
417  // Modify the instruction to use the new base register rather
418  // than the frame index operand.
419  TRI->resolveFrameIndex(*I, BaseReg, Offset);
420  DEBUG(dbgs() << "Resolved: " << *MI);
421 
422  ++NumReplacements;
423  }
424 
425  return UsedBaseReg;
426 }
const MachineFunction * getParent() const
getParent - Return the MachineFunction containing this basic block.
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")
unsigned createVirtualRegister(const TargetRegisterClass *RegClass)
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
INITIALIZE_PASS_BEGIN(LocalStackSlotPass,"localstackalloc","Local Stack Slot Allocation", false, false) INITIALIZE_PASS_END(LocalStackSlotPass
A Stackmap instruction captures the location of live variables at its position in the instruction str...
iterator end()
Get an iterator to the end of the SetVector.
Definition: SetVector.h:79
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
getFrameIndexInstrOffset - Get the offset from the referenced frame index in the instruction, if there is one.
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
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...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
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:271
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:102
bool isFI() const
isFI - Tests if this is a MO_FrameIndex operand.
static bool lookupCandidateBaseReg(unsigned BaseReg, int64_t BaseOffset, int64_t FrameSizeAdjust, int64_t LocalFrameOffset, const MachineInstr *MI, const TargetRegisterInfo *TRI)
iterator begin()
Get an iterator to the beginning of the SetVector.
Definition: SetVector.h:69
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
requiresVirtualBaseRegisters - Returns true if the target wants the LocalStackAllocation pass to be r...
virtual void materializeFrameBaseRegister(MachineBasicBlock *MBB, unsigned BaseReg, int FrameIdx, int64_t Offset) const
materializeFrameBaseRegister - Insert defining instruction(s) for BaseReg to be a pointer to FrameIdx...
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
Definition: MachineInstr.h:267
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:120
bool isDebugValue() const
Definition: MachineInstr.h:748
Local Stack Slot Allocation
bundle_iterator< MachineInstr, instr_iterator > iterator
Local Stack Slot false
void array_pod_sort(IteratorTy Start, IteratorTy End)
array_pod_sort - This sorts an array with the specified start and end extent.
Definition: STLExtras.h:287
Patchable call instruction - this instruction represents a call to a constant address, followed by a series of NOPs.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:32
This file contains the declarations for the subclasses of Constant, which represent the different fla...
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:273
SmallSetVector< int, 8 > StackObjSet
StackObjSet - A set of stack object indexes.
Represent the analysis usage information of a pass.
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:69
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
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:217
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
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.
MachineFrameInfo * getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:263
static cl::opt< AlignMode > Align(cl::desc("Load/store alignment support"), cl::Hidden, cl::init(NoStrictAlign), cl::values(clEnumValN(StrictAlign,"aarch64-strict-align","Disallow all unaligned memory accesses"), clEnumValN(NoStrictAlign,"aarch64-no-strict-align","Allow unaligned memory accesses"), clEnumValEnd))
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
static void AdjustStackOffset(MachineFrameInfo *MFI, int FrameIdx, bool StackGrowsDown, int64_t &Offset, unsigned &MaxAlign)
AdjustStackOffset - Helper function used to adjust the stack frame offset.
virtual bool isFrameOffsetLegal(const MachineInstr *MI, unsigned BaseReg, int64_t Offset) const
isFrameOffsetLegal - Determine whether a given base register plus offset immediate is encodable to re...
int getStackProtectorIndex() const
Return the index for the stack protector object.
Representation of each machine instruction.
Definition: MachineInstr.h:51
StackDirection getStackGrowthDirection() const
getStackGrowthDirection - Return the direction the stack grows
virtual bool needsFrameBaseReg(MachineInstr *MI, int64_t Offset) const
needsFrameBaseReg - Returns true if the instruction's frame index reference would be better served by...
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
void initializeLocalStackSlotPassPass(PassRegistry &)
Call instruction with associated vm state for deoptimization and list of live pointers for relocation...
#define I(x, y, z)
Definition: MD5.cpp:54
virtual void resolveFrameIndex(MachineInstr &MI, unsigned BaseReg, int64_t Offset) const
resolveFrameIndex - Resolve a frame index operand of an instruction to reference the indicated base r...
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:332
BasicBlockListType::iterator iterator
#define DEBUG(X)
Definition: Debug.h:92
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.
static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs, SmallSet< int, 16 > &ProtectedObjs, MachineFrameInfo *MFI, bool StackGrowsDown, int64_t &Offset, unsigned &MaxAlign)
AssignProtectedObjSet - Helper function to assign large stack objects (i.e., those required to be clo...
virtual const TargetRegisterClass * getPointerRegClass(const MachineFunction &MF, unsigned Kind=0) const
getPointerRegClass - Returns a TargetRegisterClass used for pointer values.
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.