LLVM  8.0.0svn
StackSlotColoring.cpp
Go to the documentation of this file.
1 //===- StackSlotColoring.cpp - Stack slot coloring pass. ------------------===//
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 file implements the stack slot coloring pass.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/ADT/BitVector.h"
15 #include "llvm/ADT/SmallVector.h"
16 #include "llvm/ADT/Statistic.h"
28 #include "llvm/CodeGen/Passes.h"
34 #include "llvm/Pass.h"
35 #include "llvm/Support/Casting.h"
37 #include "llvm/Support/Debug.h"
39 #include <algorithm>
40 #include <cassert>
41 #include <cstdint>
42 #include <iterator>
43 #include <vector>
44 
45 using namespace llvm;
46 
47 #define DEBUG_TYPE "stack-slot-coloring"
48 
49 static cl::opt<bool>
50 DisableSharing("no-stack-slot-sharing",
51  cl::init(false), cl::Hidden,
52  cl::desc("Suppress slot sharing during stack coloring"));
53 
54 static cl::opt<int> DCELimit("ssc-dce-limit", cl::init(-1), cl::Hidden);
55 
56 STATISTIC(NumEliminated, "Number of stack slots eliminated due to coloring");
57 STATISTIC(NumDead, "Number of trivially dead stack accesses eliminated");
58 
59 namespace {
60 
61  class StackSlotColoring : public MachineFunctionPass {
62  LiveStacks* LS;
63  MachineFrameInfo *MFI;
64  const TargetInstrInfo *TII;
65  const MachineBlockFrequencyInfo *MBFI;
66 
67  // SSIntervals - Spill slot intervals.
68  std::vector<LiveInterval*> SSIntervals;
69 
70  // SSRefs - Keep a list of MachineMemOperands for each spill slot.
71  // MachineMemOperands can be shared between instructions, so we need
72  // to be careful that renames like [FI0, FI1] -> [FI1, FI2] do not
73  // become FI0 -> FI1 -> FI2.
75 
76  // OrigAlignments - Alignments of stack objects before coloring.
77  SmallVector<unsigned, 16> OrigAlignments;
78 
79  // OrigSizes - Sizess of stack objects before coloring.
80  SmallVector<unsigned, 16> OrigSizes;
81 
82  // AllColors - If index is set, it's a spill slot, i.e. color.
83  // FIXME: This assumes PEI locate spill slot with smaller indices
84  // closest to stack pointer / frame pointer. Therefore, smaller
85  // index == better color. This is per stack ID.
86  SmallVector<BitVector, 2> AllColors;
87 
88  // NextColor - Next "color" that's not yet used. This is per stack ID.
89  SmallVector<int, 2> NextColors = { -1 };
90 
91  // UsedColors - "Colors" that have been assigned. This is per stack ID
92  SmallVector<BitVector, 2> UsedColors;
93 
94  // Assignments - Color to intervals mapping.
96 
97  public:
98  static char ID; // Pass identification
99 
100  StackSlotColoring() : MachineFunctionPass(ID) {
102  }
103 
104  void getAnalysisUsage(AnalysisUsage &AU) const override {
105  AU.setPreservesCFG();
106  AU.addRequired<SlotIndexes>();
108  AU.addRequired<LiveStacks>();
113  }
114 
115  bool runOnMachineFunction(MachineFunction &MF) override;
116 
117  private:
118  void InitializeSlots();
119  void ScanForSpillSlotRefs(MachineFunction &MF);
120  bool OverlapWithAssignments(LiveInterval *li, int Color) const;
121  int ColorSlot(LiveInterval *li);
122  bool ColorSlots(MachineFunction &MF);
123  void RewriteInstruction(MachineInstr &MI, SmallVectorImpl<int> &SlotMapping,
124  MachineFunction &MF);
125  bool RemoveDeadStores(MachineBasicBlock* MBB);
126  };
127 
128 } // end anonymous namespace
129 
130 char StackSlotColoring::ID = 0;
131 
133 
134 INITIALIZE_PASS_BEGIN(StackSlotColoring, DEBUG_TYPE,
135  "Stack Slot Coloring", false, false)
139 INITIALIZE_PASS_END(StackSlotColoring, DEBUG_TYPE,
140  "Stack Slot Coloring", false, false)
141 
142 namespace {
143 
144 // IntervalSorter - Comparison predicate that sort live intervals by
145 // their weight.
147  bool operator()(LiveInterval* LHS, LiveInterval* RHS) const {
148  return LHS->weight > RHS->weight;
149  }
150 };
151 
152 } // end anonymous namespace
153 
154 /// ScanForSpillSlotRefs - Scan all the machine instructions for spill slot
155 /// references and update spill slot weights.
156 void StackSlotColoring::ScanForSpillSlotRefs(MachineFunction &MF) {
157  SSRefs.resize(MFI->getObjectIndexEnd());
158 
159  // FIXME: Need the equivalent of MachineRegisterInfo for frameindex operands.
160  for (MachineFunction::iterator MBBI = MF.begin(), E = MF.end();
161  MBBI != E; ++MBBI) {
162  MachineBasicBlock *MBB = &*MBBI;
163  for (MachineBasicBlock::iterator MII = MBB->begin(), EE = MBB->end();
164  MII != EE; ++MII) {
165  MachineInstr &MI = *MII;
166  for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
167  MachineOperand &MO = MI.getOperand(i);
168  if (!MO.isFI())
169  continue;
170  int FI = MO.getIndex();
171  if (FI < 0)
172  continue;
173  if (!LS->hasInterval(FI))
174  continue;
175  LiveInterval &li = LS->getInterval(FI);
176  if (!MI.isDebugValue())
177  li.weight += LiveIntervals::getSpillWeight(false, true, MBFI, MI);
178  }
180  EE = MI.memoperands_end();
181  MMOI != EE; ++MMOI) {
182  MachineMemOperand *MMO = *MMOI;
183  if (const FixedStackPseudoSourceValue *FSV =
184  dyn_cast_or_null<FixedStackPseudoSourceValue>(
185  MMO->getPseudoValue())) {
186  int FI = FSV->getFrameIndex();
187  if (FI >= 0)
188  SSRefs[FI].push_back(MMO);
189  }
190  }
191  }
192  }
193 }
194 
195 /// InitializeSlots - Process all spill stack slot liveintervals and add them
196 /// to a sorted (by weight) list.
197 void StackSlotColoring::InitializeSlots() {
198  int LastFI = MFI->getObjectIndexEnd();
199 
200  // There is always at least one stack ID.
201  AllColors.resize(1);
202  UsedColors.resize(1);
203 
204  OrigAlignments.resize(LastFI);
205  OrigSizes.resize(LastFI);
206  AllColors[0].resize(LastFI);
207  UsedColors[0].resize(LastFI);
208  Assignments.resize(LastFI);
209 
210  using Pair = std::iterator_traits<LiveStacks::iterator>::value_type;
211 
212  SmallVector<Pair *, 16> Intervals;
213 
214  Intervals.reserve(LS->getNumIntervals());
215  for (auto &I : *LS)
216  Intervals.push_back(&I);
217  llvm::sort(Intervals,
218  [](Pair *LHS, Pair *RHS) { return LHS->first < RHS->first; });
219 
220  // Gather all spill slots into a list.
221  LLVM_DEBUG(dbgs() << "Spill slot intervals:\n");
222  for (auto *I : Intervals) {
223  LiveInterval &li = I->second;
224  LLVM_DEBUG(li.dump());
226  if (MFI->isDeadObjectIndex(FI))
227  continue;
228 
229  SSIntervals.push_back(&li);
230  OrigAlignments[FI] = MFI->getObjectAlignment(FI);
231  OrigSizes[FI] = MFI->getObjectSize(FI);
232 
233  auto StackID = MFI->getStackID(FI);
234  if (StackID != 0) {
235  AllColors.resize(StackID + 1);
236  UsedColors.resize(StackID + 1);
237  AllColors[StackID].resize(LastFI);
238  UsedColors[StackID].resize(LastFI);
239  }
240 
241  AllColors[StackID].set(FI);
242  }
243  LLVM_DEBUG(dbgs() << '\n');
244 
245  // Sort them by weight.
246  std::stable_sort(SSIntervals.begin(), SSIntervals.end(), IntervalSorter());
247 
248  NextColors.resize(AllColors.size());
249 
250  // Get first "color".
251  for (unsigned I = 0, E = AllColors.size(); I != E; ++I)
252  NextColors[I] = AllColors[I].find_first();
253 }
254 
255 /// OverlapWithAssignments - Return true if LiveInterval overlaps with any
256 /// LiveIntervals that have already been assigned to the specified color.
257 bool
258 StackSlotColoring::OverlapWithAssignments(LiveInterval *li, int Color) const {
259  const SmallVectorImpl<LiveInterval *> &OtherLIs = Assignments[Color];
260  for (unsigned i = 0, e = OtherLIs.size(); i != e; ++i) {
261  LiveInterval *OtherLI = OtherLIs[i];
262  if (OtherLI->overlaps(*li))
263  return true;
264  }
265  return false;
266 }
267 
268 /// ColorSlot - Assign a "color" (stack slot) to the specified stack slot.
269 int StackSlotColoring::ColorSlot(LiveInterval *li) {
270  int Color = -1;
271  bool Share = false;
273  uint8_t StackID = MFI->getStackID(FI);
274 
275  if (!DisableSharing) {
276 
277  // Check if it's possible to reuse any of the used colors.
278  Color = UsedColors[StackID].find_first();
279  while (Color != -1) {
280  if (!OverlapWithAssignments(li, Color)) {
281  Share = true;
282  ++NumEliminated;
283  break;
284  }
285  Color = UsedColors[StackID].find_next(Color);
286  }
287  }
288 
289  if (Color != -1 && MFI->getStackID(Color) != MFI->getStackID(FI)) {
290  LLVM_DEBUG(dbgs() << "cannot share FIs with different stack IDs\n");
291  Share = false;
292  }
293 
294  // Assign it to the first available color (assumed to be the best) if it's
295  // not possible to share a used color with other objects.
296  if (!Share) {
297  assert(NextColors[StackID] != -1 && "No more spill slots?");
298  Color = NextColors[StackID];
299  UsedColors[StackID].set(Color);
300  NextColors[StackID] = AllColors[StackID].find_next(NextColors[StackID]);
301  }
302 
303  assert(MFI->getStackID(Color) == MFI->getStackID(FI));
304 
305  // Record the assignment.
306  Assignments[Color].push_back(li);
307  LLVM_DEBUG(dbgs() << "Assigning fi#" << FI << " to fi#" << Color << "\n");
308 
309  // Change size and alignment of the allocated slot. If there are multiple
310  // objects sharing the same slot, then make sure the size and alignment
311  // are large enough for all.
312  unsigned Align = OrigAlignments[FI];
313  if (!Share || Align > MFI->getObjectAlignment(Color))
314  MFI->setObjectAlignment(Color, Align);
315  int64_t Size = OrigSizes[FI];
316  if (!Share || Size > MFI->getObjectSize(Color))
317  MFI->setObjectSize(Color, Size);
318  return Color;
319 }
320 
321 /// Colorslots - Color all spill stack slots and rewrite all frameindex machine
322 /// operands in the function.
323 bool StackSlotColoring::ColorSlots(MachineFunction &MF) {
324  unsigned NumObjs = MFI->getObjectIndexEnd();
325  SmallVector<int, 16> SlotMapping(NumObjs, -1);
326  SmallVector<float, 16> SlotWeights(NumObjs, 0.0);
327  SmallVector<SmallVector<int, 4>, 16> RevMap(NumObjs);
328  BitVector UsedColors(NumObjs);
329 
330  LLVM_DEBUG(dbgs() << "Color spill slot intervals:\n");
331  bool Changed = false;
332  for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i) {
333  LiveInterval *li = SSIntervals[i];
335  int NewSS = ColorSlot(li);
336  assert(NewSS >= 0 && "Stack coloring failed?");
337  SlotMapping[SS] = NewSS;
338  RevMap[NewSS].push_back(SS);
339  SlotWeights[NewSS] += li->weight;
340  UsedColors.set(NewSS);
341  Changed |= (SS != NewSS);
342  }
343 
344  LLVM_DEBUG(dbgs() << "\nSpill slots after coloring:\n");
345  for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i) {
346  LiveInterval *li = SSIntervals[i];
348  li->weight = SlotWeights[SS];
349  }
350  // Sort them by new weight.
351  std::stable_sort(SSIntervals.begin(), SSIntervals.end(), IntervalSorter());
352 
353 #ifndef NDEBUG
354  for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i)
355  LLVM_DEBUG(SSIntervals[i]->dump());
356  LLVM_DEBUG(dbgs() << '\n');
357 #endif
358 
359  if (!Changed)
360  return false;
361 
362  // Rewrite all MachineMemOperands.
363  for (unsigned SS = 0, SE = SSRefs.size(); SS != SE; ++SS) {
364  int NewFI = SlotMapping[SS];
365  if (NewFI == -1 || (NewFI == (int)SS))
366  continue;
367 
368  const PseudoSourceValue *NewSV = MF.getPSVManager().getFixedStack(NewFI);
369  SmallVectorImpl<MachineMemOperand *> &RefMMOs = SSRefs[SS];
370  for (unsigned i = 0, e = RefMMOs.size(); i != e; ++i)
371  RefMMOs[i]->setValue(NewSV);
372  }
373 
374  // Rewrite all MO_FrameIndex operands. Look for dead stores.
375  for (MachineBasicBlock &MBB : MF) {
376  for (MachineInstr &MI : MBB)
377  RewriteInstruction(MI, SlotMapping, MF);
378  RemoveDeadStores(&MBB);
379  }
380 
381  // Delete unused stack slots.
382  for (int StackID = 0, E = AllColors.size(); StackID != E; ++StackID) {
383  int NextColor = NextColors[StackID];
384  while (NextColor != -1) {
385  LLVM_DEBUG(dbgs() << "Removing unused stack object fi#" << NextColor << "\n");
386  MFI->RemoveStackObject(NextColor);
387  NextColor = AllColors[StackID].find_next(NextColor);
388  }
389  }
390 
391  return true;
392 }
393 
394 /// RewriteInstruction - Rewrite specified instruction by replacing references
395 /// to old frame index with new one.
396 void StackSlotColoring::RewriteInstruction(MachineInstr &MI,
398  MachineFunction &MF) {
399  // Update the operands.
400  for (unsigned i = 0, ee = MI.getNumOperands(); i != ee; ++i) {
401  MachineOperand &MO = MI.getOperand(i);
402  if (!MO.isFI())
403  continue;
404  int OldFI = MO.getIndex();
405  if (OldFI < 0)
406  continue;
407  int NewFI = SlotMapping[OldFI];
408  if (NewFI == -1 || NewFI == OldFI)
409  continue;
410 
411  assert(MFI->getStackID(OldFI) == MFI->getStackID(NewFI));
412  MO.setIndex(NewFI);
413  }
414 
415  // The MachineMemOperands have already been updated.
416 }
417 
418 /// RemoveDeadStores - Scan through a basic block and look for loads followed
419 /// by stores. If they're both using the same stack slot, then the store is
420 /// definitely dead. This could obviously be much more aggressive (consider
421 /// pairs with instructions between them), but such extensions might have a
422 /// considerable compile time impact.
423 bool StackSlotColoring::RemoveDeadStores(MachineBasicBlock* MBB) {
424  // FIXME: This could be much more aggressive, but we need to investigate
425  // the compile time impact of doing so.
426  bool changed = false;
427 
429 
430  for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end();
431  I != E; ++I) {
432  if (DCELimit != -1 && (int)NumDead >= DCELimit)
433  break;
434  int FirstSS, SecondSS;
435  if (TII->isStackSlotCopy(*I, FirstSS, SecondSS) && FirstSS == SecondSS &&
436  FirstSS != -1) {
437  ++NumDead;
438  changed = true;
439  toErase.push_back(&*I);
440  continue;
441  }
442 
443  MachineBasicBlock::iterator NextMI = std::next(I);
444  MachineBasicBlock::iterator ProbableLoadMI = I;
445 
446  unsigned LoadReg = 0;
447  unsigned StoreReg = 0;
448  unsigned LoadSize = 0;
449  unsigned StoreSize = 0;
450  if (!(LoadReg = TII->isLoadFromStackSlot(*I, FirstSS, LoadSize)))
451  continue;
452  // Skip the ...pseudo debugging... instructions between a load and store.
453  while ((NextMI != E) && NextMI->isDebugInstr()) {
454  ++NextMI;
455  ++I;
456  }
457  if (NextMI == E) continue;
458  if (!(StoreReg = TII->isStoreToStackSlot(*NextMI, SecondSS, StoreSize)))
459  continue;
460  if (FirstSS != SecondSS || LoadReg != StoreReg || FirstSS == -1 ||
461  LoadSize != StoreSize)
462  continue;
463 
464  ++NumDead;
465  changed = true;
466 
467  if (NextMI->findRegisterUseOperandIdx(LoadReg, true, nullptr) != -1) {
468  ++NumDead;
469  toErase.push_back(&*ProbableLoadMI);
470  }
471 
472  toErase.push_back(&*NextMI);
473  ++I;
474  }
475 
477  E = toErase.end(); I != E; ++I)
478  (*I)->eraseFromParent();
479 
480  return changed;
481 }
482 
483 bool StackSlotColoring::runOnMachineFunction(MachineFunction &MF) {
484  LLVM_DEBUG({
485  dbgs() << "********** Stack Slot Coloring **********\n"
486  << "********** Function: " << MF.getName() << '\n';
487  });
488 
489  if (skipFunction(MF.getFunction()))
490  return false;
491 
492  MFI = &MF.getFrameInfo();
493  TII = MF.getSubtarget().getInstrInfo();
494  LS = &getAnalysis<LiveStacks>();
495  MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
496 
497  bool Changed = false;
498 
499  unsigned NumSlots = LS->getNumIntervals();
500  if (NumSlots == 0)
501  // Nothing to do!
502  return false;
503 
504  // If there are calls to setjmp or sigsetjmp, don't perform stack slot
505  // coloring. The stack could be modified before the longjmp is executed,
506  // resulting in the wrong value being used afterwards. (See
507  // <rdar://problem/8007500>.)
508  if (MF.exposesReturnsTwice())
509  return false;
510 
511  // Gather spill slot references
512  ScanForSpillSlotRefs(MF);
513  InitializeSlots();
514  Changed = ColorSlots(MF);
515 
516  for (int &Next : NextColors)
517  Next = -1;
518 
519  SSIntervals.clear();
520  for (unsigned i = 0, e = SSRefs.size(); i != e; ++i)
521  SSRefs[i].clear();
522  SSRefs.clear();
523  OrigAlignments.clear();
524  OrigSizes.clear();
525  AllColors.clear();
526  UsedColors.clear();
527  for (unsigned i = 0, e = Assignments.size(); i != e; ++i)
528  Assignments[i].clear();
529  Assignments.clear();
530 
531  return Changed;
532 }
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
BitVector & set()
Definition: BitVector.h:398
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
const unsigned reg
Definition: LiveInterval.h:667
static float getSpillWeight(bool isDef, bool isUse, const MachineBlockFrequencyInfo *MBFI, const MachineInstr &MI)
Calculate the spill weight to assign to a single instruction.
This class represents lattice values for constants.
Definition: AllocatorList.h:24
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
char & MachineDominatorsID
MachineDominators - This pass is a machine dominators analysis pass.
LiveInterval - This class represents the liveness of a register, or stack slot.
Definition: LiveInterval.h:638
Stack Slot Coloring
MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...
LiveInterval & getInterval(int Slot)
Definition: LiveStacks.h:64
STATISTIC(NumFunctions, "Total number of functions")
void reserve(size_type N)
Definition: SmallVector.h:376
static int stackSlot2Index(unsigned Reg)
Compute the frame index from a register value representing a stack slot.
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:51
A description of a memory reference used in the backend.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
const HexagonInstrInfo * TII
unsigned getNumOperands() const
Retuns the total number of operands.
Definition: MachineInstr.h:412
void setIndex(int Idx)
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
SlotIndexes pass.
Definition: SlotIndexes.h:331
PseudoSourceValueManager & getPSVManager() const
bool operator()(LiveInterval *LHS, LiveInterval *RHS) const
char & StackSlotColoringID
StackSlotColoring - This pass performs stack slot coloring.
AnalysisUsage & addPreservedID(const void *ID)
virtual unsigned isStoreToStackSlot(const MachineInstr &MI, int &FrameIndex) const
If the specified machine instruction is a direct store to a stack slot, return the virtual or physica...
int getObjectIndexEnd() const
Return one past the maximum frame object index.
virtual const TargetInstrInfo * getInstrInfo() const
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
const PseudoSourceValue * getFixedStack(int FI)
Return a pseudo source value referencing a fixed stack frame entry, e.g., a spill slot...
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
TargetInstrInfo - Interface to description of machine instruction set.
void initializeStackSlotColoringPass(PassRegistry &)
unsigned getObjectAlignment(int ObjectIdx) const
Return the alignment of the specified stack object.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:419
#define DEBUG_TYPE
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
void RemoveStackObject(int ObjectIdx)
Remove or mark dead a statically sized stack object.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:129
static cl::opt< int > DCELimit("ssc-dce-limit", cl::init(-1), cl::Hidden)
Represent the analysis usage information of a pass.
const PseudoSourceValue * getPseudoValue() const
void setObjectSize(int ObjectIdx, int64_t Size)
Change the size of the specified stack object.
size_t size() const
Definition: SmallVector.h:53
static cl::opt< bool > DisableSharing("no-stack-slot-sharing", cl::init(false), cl::Hidden, cl::desc("Suppress slot sharing during stack coloring"))
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1110
virtual bool isStackSlotCopy(const MachineInstr &MI, int &DestFrameIndex, int &SrcFrameIndex) const
Return true if the specified machine instruction is a copy of one stack slot to another and has no ot...
Iterator for intrusive lists based on ilist_node.
Color
A "color", which is either even or odd.
mmo_iterator memoperands_begin() const
Access to memory operands of the instruction.
Definition: MachineInstr.h:534
INITIALIZE_PASS_BEGIN(StackSlotColoring, DEBUG_TYPE, "Stack Slot Coloring", false, false) INITIALIZE_PASS_END(StackSlotColoring
bool isDebugValue() const
Definition: MachineInstr.h:997
MachineOperand class - Representation of each machine instruction operand.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:286
const Function & getFunction() const
Return the LLVM function that this machine code represents.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
Special value supplied for machine level alias analysis.
This struct contains the mappings from the slot numbers to unnamed metadata nodes, global values and types.
Definition: SlotMapping.h:33
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:212
Representation of each machine instruction.
Definition: MachineInstr.h:64
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:133
bool overlaps(const LiveRange &other) const
overlaps - Return true if the intersection of the two live ranges is not empty.
Definition: LiveInterval.h:436
bool exposesReturnsTwice() const
exposesReturnsTwice - Returns true if the function calls setjmp or any other similar functions with a...
virtual unsigned isLoadFromStackSlot(const MachineInstr &MI, int &FrameIndex) const
If the specified machine instruction is a direct load from a stack slot, return the virtual or physic...
unsigned getNumIntervals() const
Definition: LiveStacks.h:60
#define I(x, y, z)
Definition: MD5.cpp:58
bool isFI() const
isFI - Tests if this is a MO_FrameIndex operand.
uint32_t Size
Definition: Profile.cpp:47
uint8_t getStackID(int ObjectIdx) const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool hasInterval(int Slot) const
Definition: LiveStacks.h:78
IRTranslator LLVM IR MI
A specialized PseudoSourceValue for holding FixedStack values, which must include a frame index...
#define LLVM_DEBUG(X)
Definition: Debug.h:123
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:414
void setObjectAlignment(int ObjectIdx, unsigned Align)
setObjectAlignment - Change the alignment of the specified stack object.
mmo_iterator memoperands_end() const
Access to memory operands of the instruction.
Definition: MachineInstr.h:541
void resize(size_type N)
Definition: SmallVector.h:351