LLVM  6.0.0svn
ShrinkWrap.cpp
Go to the documentation of this file.
1 //===- ShrinkWrap.cpp - Compute safe point for prolog/epilog insertion ----===//
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 looks for safe point where the prologue and epilogue can be
11 // inserted.
12 // The safe point for the prologue (resp. epilogue) is called Save
13 // (resp. Restore).
14 // A point is safe for prologue (resp. epilogue) if and only if
15 // it 1) dominates (resp. post-dominates) all the frame related operations and
16 // between 2) two executions of the Save (resp. Restore) point there is an
17 // execution of the Restore (resp. Save) point.
18 //
19 // For instance, the following points are safe:
20 // for (int i = 0; i < 10; ++i) {
21 // Save
22 // ...
23 // Restore
24 // }
25 // Indeed, the execution looks like Save -> Restore -> Save -> Restore ...
26 // And the following points are not:
27 // for (int i = 0; i < 10; ++i) {
28 // Save
29 // ...
30 // }
31 // for (int i = 0; i < 10; ++i) {
32 // ...
33 // Restore
34 // }
35 // Indeed, the execution looks like Save -> Save -> ... -> Restore -> Restore.
36 //
37 // This pass also ensures that the safe points are 3) cheaper than the regular
38 // entry and exits blocks.
39 //
40 // Property #1 is ensured via the use of MachineDominatorTree and
41 // MachinePostDominatorTree.
42 // Property #2 is ensured via property #1 and MachineLoopInfo, i.e., both
43 // points must be in the same loop.
44 // Property #3 is ensured via the MachineBlockFrequencyInfo.
45 //
46 // If this pass found points matching all these properties, then
47 // MachineFrameInfo is updated with this information.
48 //
49 //===----------------------------------------------------------------------===//
50 
51 #include "llvm/ADT/BitVector.h"
53 #include "llvm/ADT/SetVector.h"
54 #include "llvm/ADT/SmallVector.h"
55 #include "llvm/ADT/Statistic.h"
72 #include "llvm/IR/Attributes.h"
73 #include "llvm/IR/Function.h"
74 #include "llvm/MC/MCAsmInfo.h"
75 #include "llvm/Pass.h"
77 #include "llvm/Support/Debug.h"
81 #include <cassert>
82 #include <cstdint>
83 #include <memory>
84 
85 using namespace llvm;
86 
87 #define DEBUG_TYPE "shrink-wrap"
88 
89 STATISTIC(NumFunc, "Number of functions");
90 STATISTIC(NumCandidates, "Number of shrink-wrapping candidates");
91 STATISTIC(NumCandidatesDropped,
92  "Number of shrink-wrapping candidates dropped because of frequency");
93 
95 EnableShrinkWrapOpt("enable-shrink-wrap", cl::Hidden,
96  cl::desc("enable the shrink-wrapping pass"));
97 
98 namespace {
99 
100 /// \brief Class to determine where the safe point to insert the
101 /// prologue and epilogue are.
102 /// Unlike the paper from Fred C. Chow, PLDI'88, that introduces the
103 /// shrink-wrapping term for prologue/epilogue placement, this pass
104 /// does not rely on expensive data-flow analysis. Instead we use the
105 /// dominance properties and loop information to decide which point
106 /// are safe for such insertion.
107 class ShrinkWrap : public MachineFunctionPass {
108  /// Hold callee-saved information.
109  RegisterClassInfo RCI;
112 
113  /// Current safe point found for the prologue.
114  /// The prologue will be inserted before the first instruction
115  /// in this basic block.
116  MachineBasicBlock *Save;
117 
118  /// Current safe point found for the epilogue.
119  /// The epilogue will be inserted before the first terminator instruction
120  /// in this basic block.
121  MachineBasicBlock *Restore;
122 
123  /// Hold the information of the basic block frequency.
124  /// Use to check the profitability of the new points.
126 
127  /// Hold the loop information. Used to determine if Save and Restore
128  /// are in the same loop.
129  MachineLoopInfo *MLI;
130 
131  /// Frequency of the Entry block.
132  uint64_t EntryFreq;
133 
134  /// Current opcode for frame setup.
135  unsigned FrameSetupOpcode;
136 
137  /// Current opcode for frame destroy.
138  unsigned FrameDestroyOpcode;
139 
140  /// Entry block.
141  const MachineBasicBlock *Entry;
142 
143  using SetOfRegs = SmallSetVector<unsigned, 16>;
144 
145  /// Registers that need to be saved for the current function.
146  mutable SetOfRegs CurrentCSRs;
147 
148  /// Current MachineFunction.
149  MachineFunction *MachineFunc;
150 
151  /// \brief Check if \p MI uses or defines a callee-saved register or
152  /// a frame index. If this is the case, this means \p MI must happen
153  /// after Save and before Restore.
154  bool useOrDefCSROrFI(const MachineInstr &MI, RegScavenger *RS) const;
155 
156  const SetOfRegs &getCurrentCSRs(RegScavenger *RS) const {
157  if (CurrentCSRs.empty()) {
158  BitVector SavedRegs;
159  const TargetFrameLowering *TFI =
160  MachineFunc->getSubtarget().getFrameLowering();
161 
162  TFI->determineCalleeSaves(*MachineFunc, SavedRegs, RS);
163 
164  for (int Reg = SavedRegs.find_first(); Reg != -1;
165  Reg = SavedRegs.find_next(Reg))
166  CurrentCSRs.insert((unsigned)Reg);
167  }
168  return CurrentCSRs;
169  }
170 
171  /// \brief Update the Save and Restore points such that \p MBB is in
172  /// the region that is dominated by Save and post-dominated by Restore
173  /// and Save and Restore still match the safe point definition.
174  /// Such point may not exist and Save and/or Restore may be null after
175  /// this call.
176  void updateSaveRestorePoints(MachineBasicBlock &MBB, RegScavenger *RS);
177 
178  /// \brief Initialize the pass for \p MF.
179  void init(MachineFunction &MF) {
180  RCI.runOnMachineFunction(MF);
181  MDT = &getAnalysis<MachineDominatorTree>();
182  MPDT = &getAnalysis<MachinePostDominatorTree>();
183  Save = nullptr;
184  Restore = nullptr;
185  MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
186  MLI = &getAnalysis<MachineLoopInfo>();
187  EntryFreq = MBFI->getEntryFreq();
188  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
189  FrameSetupOpcode = TII.getCallFrameSetupOpcode();
190  FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
191  Entry = &MF.front();
192  CurrentCSRs.clear();
193  MachineFunc = &MF;
194 
195  ++NumFunc;
196  }
197 
198  /// Check whether or not Save and Restore points are still interesting for
199  /// shrink-wrapping.
200  bool ArePointsInteresting() const { return Save != Entry && Save && Restore; }
201 
202  /// \brief Check if shrink wrapping is enabled for this target and function.
203  static bool isShrinkWrapEnabled(const MachineFunction &MF);
204 
205 public:
206  static char ID;
207 
208  ShrinkWrap() : MachineFunctionPass(ID) {
210  }
211 
212  void getAnalysisUsage(AnalysisUsage &AU) const override {
213  AU.setPreservesAll();
219  }
220 
221  StringRef getPassName() const override { return "Shrink Wrapping analysis"; }
222 
223  /// \brief Perform the shrink-wrapping analysis and update
224  /// the MachineFrameInfo attached to \p MF with the results.
225  bool runOnMachineFunction(MachineFunction &MF) override;
226 };
227 
228 } // end anonymous namespace
229 
230 char ShrinkWrap::ID = 0;
231 
233 
234 INITIALIZE_PASS_BEGIN(ShrinkWrap, DEBUG_TYPE, "Shrink Wrap Pass", false, false)
239 INITIALIZE_PASS_END(ShrinkWrap, DEBUG_TYPE, "Shrink Wrap Pass", false, false)
240 
241 bool ShrinkWrap::useOrDefCSROrFI(const MachineInstr &MI,
242  RegScavenger *RS) const {
243  if (MI.getOpcode() == FrameSetupOpcode ||
244  MI.getOpcode() == FrameDestroyOpcode) {
245  DEBUG(dbgs() << "Frame instruction: " << MI << '\n');
246  return true;
247  }
248  for (const MachineOperand &MO : MI.operands()) {
249  bool UseOrDefCSR = false;
250  if (MO.isReg()) {
251  unsigned PhysReg = MO.getReg();
252  if (!PhysReg)
253  continue;
255  "Unallocated register?!");
256  UseOrDefCSR = RCI.getLastCalleeSavedAlias(PhysReg);
257  } else if (MO.isRegMask()) {
258  // Check if this regmask clobbers any of the CSRs.
259  for (unsigned Reg : getCurrentCSRs(RS)) {
260  if (MO.clobbersPhysReg(Reg)) {
261  UseOrDefCSR = true;
262  break;
263  }
264  }
265  }
266  if (UseOrDefCSR || MO.isFI()) {
267  DEBUG(dbgs() << "Use or define CSR(" << UseOrDefCSR << ") or FI("
268  << MO.isFI() << "): " << MI << '\n');
269  return true;
270  }
271  }
272  return false;
273 }
274 
275 /// \brief Helper function to find the immediate (post) dominator.
276 template <typename ListOfBBs, typename DominanceAnalysis>
277 static MachineBasicBlock *FindIDom(MachineBasicBlock &Block, ListOfBBs BBs,
278  DominanceAnalysis &Dom) {
279  MachineBasicBlock *IDom = &Block;
280  for (MachineBasicBlock *BB : BBs) {
281  IDom = Dom.findNearestCommonDominator(IDom, BB);
282  if (!IDom)
283  break;
284  }
285  if (IDom == &Block)
286  return nullptr;
287  return IDom;
288 }
289 
290 void ShrinkWrap::updateSaveRestorePoints(MachineBasicBlock &MBB,
291  RegScavenger *RS) {
292  // Get rid of the easy cases first.
293  if (!Save)
294  Save = &MBB;
295  else
296  Save = MDT->findNearestCommonDominator(Save, &MBB);
297 
298  if (!Save) {
299  DEBUG(dbgs() << "Found a block that is not reachable from Entry\n");
300  return;
301  }
302 
303  if (!Restore)
304  Restore = &MBB;
305  else if (MPDT->getNode(&MBB)) // If the block is not in the post dom tree, it
306  // means the block never returns. If that's the
307  // case, we don't want to call
308  // `findNearestCommonDominator`, which will
309  // return `Restore`.
310  Restore = MPDT->findNearestCommonDominator(Restore, &MBB);
311  else
312  Restore = nullptr; // Abort, we can't find a restore point in this case.
313 
314  // Make sure we would be able to insert the restore code before the
315  // terminator.
316  if (Restore == &MBB) {
317  for (const MachineInstr &Terminator : MBB.terminators()) {
318  if (!useOrDefCSROrFI(Terminator, RS))
319  continue;
320  // One of the terminator needs to happen before the restore point.
321  if (MBB.succ_empty()) {
322  Restore = nullptr; // Abort, we can't find a restore point in this case.
323  break;
324  }
325  // Look for a restore point that post-dominates all the successors.
326  // The immediate post-dominator is what we are looking for.
327  Restore = FindIDom<>(*Restore, Restore->successors(), *MPDT);
328  break;
329  }
330  }
331 
332  if (!Restore) {
333  DEBUG(dbgs() << "Restore point needs to be spanned on several blocks\n");
334  return;
335  }
336 
337  // Make sure Save and Restore are suitable for shrink-wrapping:
338  // 1. all path from Save needs to lead to Restore before exiting.
339  // 2. all path to Restore needs to go through Save from Entry.
340  // We achieve that by making sure that:
341  // A. Save dominates Restore.
342  // B. Restore post-dominates Save.
343  // C. Save and Restore are in the same loop.
344  bool SaveDominatesRestore = false;
345  bool RestorePostDominatesSave = false;
346  while (Save && Restore &&
347  (!(SaveDominatesRestore = MDT->dominates(Save, Restore)) ||
348  !(RestorePostDominatesSave = MPDT->dominates(Restore, Save)) ||
349  // Post-dominance is not enough in loops to ensure that all uses/defs
350  // are after the prologue and before the epilogue at runtime.
351  // E.g.,
352  // while(1) {
353  // Save
354  // Restore
355  // if (...)
356  // break;
357  // use/def CSRs
358  // }
359  // All the uses/defs of CSRs are dominated by Save and post-dominated
360  // by Restore. However, the CSRs uses are still reachable after
361  // Restore and before Save are executed.
362  //
363  // For now, just push the restore/save points outside of loops.
364  // FIXME: Refine the criteria to still find interesting cases
365  // for loops.
366  MLI->getLoopFor(Save) || MLI->getLoopFor(Restore))) {
367  // Fix (A).
368  if (!SaveDominatesRestore) {
369  Save = MDT->findNearestCommonDominator(Save, Restore);
370  continue;
371  }
372  // Fix (B).
373  if (!RestorePostDominatesSave)
374  Restore = MPDT->findNearestCommonDominator(Restore, Save);
375 
376  // Fix (C).
377  if (Save && Restore &&
378  (MLI->getLoopFor(Save) || MLI->getLoopFor(Restore))) {
379  if (MLI->getLoopDepth(Save) > MLI->getLoopDepth(Restore)) {
380  // Push Save outside of this loop if immediate dominator is different
381  // from save block. If immediate dominator is not different, bail out.
382  Save = FindIDom<>(*Save, Save->predecessors(), *MDT);
383  if (!Save)
384  break;
385  } else {
386  // If the loop does not exit, there is no point in looking
387  // for a post-dominator outside the loop.
389  MLI->getLoopFor(Restore)->getExitingBlocks(ExitBlocks);
390  // Push Restore outside of this loop.
391  // Look for the immediate post-dominator of the loop exits.
392  MachineBasicBlock *IPdom = Restore;
393  for (MachineBasicBlock *LoopExitBB: ExitBlocks) {
394  IPdom = FindIDom<>(*IPdom, LoopExitBB->successors(), *MPDT);
395  if (!IPdom)
396  break;
397  }
398  // If the immediate post-dominator is not in a less nested loop,
399  // then we are stuck in a program with an infinite loop.
400  // In that case, we will not find a safe point, hence, bail out.
401  if (IPdom && MLI->getLoopDepth(IPdom) < MLI->getLoopDepth(Restore))
402  Restore = IPdom;
403  else {
404  Restore = nullptr;
405  break;
406  }
407  }
408  }
409  }
410 }
411 
412 /// Check whether the edge (\p SrcBB, \p DestBB) is a backedge according to MLI.
413 /// I.e., check if it exists a loop that contains SrcBB and where DestBB is the
414 /// loop header.
415 static bool isProperBackedge(const MachineLoopInfo &MLI,
416  const MachineBasicBlock *SrcBB,
417  const MachineBasicBlock *DestBB) {
418  for (const MachineLoop *Loop = MLI.getLoopFor(SrcBB); Loop;
419  Loop = Loop->getParentLoop()) {
420  if (Loop->getHeader() == DestBB)
421  return true;
422  }
423  return false;
424 }
425 
426 /// Check if the CFG of \p MF is irreducible.
427 static bool isIrreducibleCFG(const MachineFunction &MF,
428  const MachineLoopInfo &MLI) {
429  const MachineBasicBlock *Entry = &*MF.begin();
431  BitVector VisitedBB(MF.getNumBlockIDs());
432  for (const MachineBasicBlock *MBB : RPOT) {
433  VisitedBB.set(MBB->getNumber());
434  for (const MachineBasicBlock *SuccBB : MBB->successors()) {
435  if (!VisitedBB.test(SuccBB->getNumber()))
436  continue;
437  // We already visited SuccBB, thus MBB->SuccBB must be a backedge.
438  // Check that the head matches what we have in the loop information.
439  // Otherwise, we have an irreducible graph.
440  if (!isProperBackedge(MLI, MBB, SuccBB))
441  return true;
442  }
443  }
444  return false;
445 }
446 
447 bool ShrinkWrap::runOnMachineFunction(MachineFunction &MF) {
448  if (skipFunction(*MF.getFunction()) || MF.empty() || !isShrinkWrapEnabled(MF))
449  return false;
450 
451  DEBUG(dbgs() << "**** Analysing " << MF.getName() << '\n');
452 
453  init(MF);
454 
455  if (isIrreducibleCFG(MF, *MLI)) {
456  // If MF is irreducible, a block may be in a loop without
457  // MachineLoopInfo reporting it. I.e., we may use the
458  // post-dominance property in loops, which lead to incorrect
459  // results. Moreover, we may miss that the prologue and
460  // epilogue are not in the same loop, leading to unbalanced
461  // construction/deconstruction of the stack frame.
462  DEBUG(dbgs() << "Irreducible CFGs are not supported yet\n");
463  return false;
464  }
465 
466  const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
467  std::unique_ptr<RegScavenger> RS(
468  TRI->requiresRegisterScavenging(MF) ? new RegScavenger() : nullptr);
469 
470  for (MachineBasicBlock &MBB : MF) {
471  DEBUG(dbgs() << "Look into: " << MBB.getNumber() << ' ' << MBB.getName()
472  << '\n');
473 
474  if (MBB.isEHFuncletEntry()) {
475  DEBUG(dbgs() << "EH Funclets are not supported yet.\n");
476  return false;
477  }
478 
479  for (const MachineInstr &MI : MBB) {
480  if (!useOrDefCSROrFI(MI, RS.get()))
481  continue;
482  // Save (resp. restore) point must dominate (resp. post dominate)
483  // MI. Look for the proper basic block for those.
484  updateSaveRestorePoints(MBB, RS.get());
485  // If we are at a point where we cannot improve the placement of
486  // save/restore instructions, just give up.
487  if (!ArePointsInteresting()) {
488  DEBUG(dbgs() << "No Shrink wrap candidate found\n");
489  return false;
490  }
491  // No need to look for other instructions, this basic block
492  // will already be part of the handled region.
493  break;
494  }
495  }
496  if (!ArePointsInteresting()) {
497  // If the points are not interesting at this point, then they must be null
498  // because it means we did not encounter any frame/CSR related code.
499  // Otherwise, we would have returned from the previous loop.
500  assert(!Save && !Restore && "We miss a shrink-wrap opportunity?!");
501  DEBUG(dbgs() << "Nothing to shrink-wrap\n");
502  return false;
503  }
504 
505  DEBUG(dbgs() << "\n ** Results **\nFrequency of the Entry: " << EntryFreq
506  << '\n');
507 
508  const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
509  do {
510  DEBUG(dbgs() << "Shrink wrap candidates (#, Name, Freq):\nSave: "
511  << Save->getNumber() << ' ' << Save->getName() << ' '
512  << MBFI->getBlockFreq(Save).getFrequency() << "\nRestore: "
513  << Restore->getNumber() << ' ' << Restore->getName() << ' '
514  << MBFI->getBlockFreq(Restore).getFrequency() << '\n');
515 
516  bool IsSaveCheap, TargetCanUseSaveAsPrologue = false;
517  if (((IsSaveCheap = EntryFreq >= MBFI->getBlockFreq(Save).getFrequency()) &&
518  EntryFreq >= MBFI->getBlockFreq(Restore).getFrequency()) &&
519  ((TargetCanUseSaveAsPrologue = TFI->canUseAsPrologue(*Save)) &&
520  TFI->canUseAsEpilogue(*Restore)))
521  break;
522  DEBUG(dbgs() << "New points are too expensive or invalid for the target\n");
523  MachineBasicBlock *NewBB;
524  if (!IsSaveCheap || !TargetCanUseSaveAsPrologue) {
525  Save = FindIDom<>(*Save, Save->predecessors(), *MDT);
526  if (!Save)
527  break;
528  NewBB = Save;
529  } else {
530  // Restore is expensive.
531  Restore = FindIDom<>(*Restore, Restore->successors(), *MPDT);
532  if (!Restore)
533  break;
534  NewBB = Restore;
535  }
536  updateSaveRestorePoints(*NewBB, RS.get());
537  } while (Save && Restore);
538 
539  if (!ArePointsInteresting()) {
540  ++NumCandidatesDropped;
541  return false;
542  }
543 
544  DEBUG(dbgs() << "Final shrink wrap candidates:\nSave: " << Save->getNumber()
545  << ' ' << Save->getName() << "\nRestore: "
546  << Restore->getNumber() << ' ' << Restore->getName() << '\n');
547 
548  MachineFrameInfo &MFI = MF.getFrameInfo();
549  MFI.setSavePoint(Save);
550  MFI.setRestorePoint(Restore);
551  ++NumCandidates;
552  return false;
553 }
554 
555 bool ShrinkWrap::isShrinkWrapEnabled(const MachineFunction &MF) {
557 
558  switch (EnableShrinkWrapOpt) {
559  case cl::BOU_UNSET:
560  return TFI->enableShrinkWrapping(MF) &&
561  // Windows with CFI has some limitations that make it impossible
562  // to use shrink-wrapping.
564  // Sanitizers look at the value of the stack at the location
565  // of the crash. Since a crash can happen anywhere, the
566  // frame must be lowered before anything else happen for the
567  // sanitizers to be able to get a correct stack frame.
568  !(MF.getFunction()->hasFnAttribute(Attribute::SanitizeAddress) ||
569  MF.getFunction()->hasFnAttribute(Attribute::SanitizeThread) ||
570  MF.getFunction()->hasFnAttribute(Attribute::SanitizeMemory));
571  // If EnableShrinkWrap is set, it takes precedence on whatever the
572  // target sets. The rational is that we assume we want to test
573  // something related to shrink-wrapping.
574  case cl::BOU_TRUE:
575  return true;
576  case cl::BOU_FALSE:
577  return false;
578  }
579  llvm_unreachable("Invalid shrink-wrapping state");
580 }
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:81
static bool isIrreducibleCFG(const MachineFunction &MF, const MachineLoopInfo &MLI)
Check if the CFG of MF is irreducible.
Definition: ShrinkWrap.cpp:427
bool usesWindowsCFI() const
Definition: MCAsmInfo.h:568
BitVector & set()
Definition: BitVector.h:398
void setSavePoint(MachineBasicBlock *NewSave)
virtual bool requiresRegisterScavenging(const MachineFunction &MF) const
Returns true if the target requires (and can make use of) the register scavenger. ...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual bool enableShrinkWrapping(const MachineFunction &MF) const
Returns true if the target will correctly handle shrink wrapping.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID&#39;s allocated.
uint64_t getFrequency() const
Returns the frequency as a fixpoint number scaled by the entry frequency.
MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:262
STATISTIC(NumFunctions, "Total number of functions")
unsigned getCallFrameDestroyOpcode() const
static bool isProperBackedge(const MachineLoopInfo &MLI, const MachineBasicBlock *SrcBB, const MachineBasicBlock *DestBB)
Check whether the edge (SrcBB, DestBB) is a backedge according to MLI.
Definition: ShrinkWrap.cpp:415
iterator_range< succ_iterator > successors()
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:51
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
const HexagonInstrInfo * TII
virtual bool canUseAsEpilogue(const MachineBasicBlock &MBB) const
Check whether or not the given MBB can be used as a epilogue for the target.
int find_first() const
find_first - Returns the index of the first set bit, -1 if none of the bits are set.
Definition: BitVector.h:332
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
int find_next(unsigned Prev) const
find_next - Returns the index of the next set bit following the "Prev" bit.
Definition: BitVector.h:340
Reg
All possible values of the reg field in the ModR/M byte.
This file contains the simple types necessary to represent the attributes associated with functions a...
iterator_range< iterator > terminators()
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
#define DEBUG_TYPE
Definition: ShrinkWrap.cpp:87
BlockT * getHeader() const
Definition: LoopInfo.h:100
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they&#39;re not in a MachineFuncti...
virtual const TargetInstrInfo * getInstrInfo() const
MachineBasicBlock * findNearestCommonDominator(MachineBasicBlock *A, MachineBasicBlock *B)
findNearestCommonDominator - Find nearest common dominator basic block for basic block A and B...
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
TargetInstrInfo - Interface to description of machine instruction set.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:406
This file declares the machine register scavenger class.
StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
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.
static cl::opt< cl::boolOrDefault > EnableShrinkWrapOpt("enable-shrink-wrap", cl::Hidden, cl::desc("enable the shrink-wrapping pass"))
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const
getblockFreq - Return block frequency.
unsigned getCallFrameSetupOpcode() const
These methods return the opcode of the frame setup/destroy instructions if they exist (-1 otherwise)...
Represent the analysis usage information of a pass.
void runOnMachineFunction(const MachineFunction &MF)
runOnFunction - Prepare to answer questions about MF.
void initializeShrinkWrapPass(PassRegistry &)
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
const MachineBasicBlock & front() const
static MachineBasicBlock * FindIDom(MachineBasicBlock &Block, ListOfBBs BBs, DominanceAnalysis &Dom)
Helper function to find the immediate (post) dominator.
Definition: ShrinkWrap.cpp:277
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:298
PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominat...
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:864
bool dominates(const MachineDomTreeNode *A, const MachineDomTreeNode *B) const
Information about stack frame layout on the target.
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:48
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
void setPreservesAll()
Set by analyses that do not transform their input at all.
LoopT * getParentLoop() const
Definition: LoopInfo.h:101
Representation of each machine instruction.
Definition: MachineInstr.h:59
static bool isPhysicalRegister(unsigned Reg)
Return true if the specified register number is in the physical register namespace.
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:439
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
virtual const TargetFrameLowering * getFrameLowering() const
virtual bool canUseAsPrologue(const MachineBasicBlock &MBB) const
Check whether or not the given MBB can be used as a prologue for the target.
unsigned getLastCalleeSavedAlias(unsigned PhysReg) const
getLastCalleeSavedAlias - Returns the last callee saved register that overlaps PhysReg, or 0 if Reg doesn&#39;t overlap a CalleeSavedAliases.
const Function * getFunction() const
getFunction - Return the LLVM function that this machine code represents
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
aarch64 promote const
MachineLoop * getLoopFor(const MachineBasicBlock *BB) const
Return the innermost loop that BB lives in.
#define DEBUG(X)
Definition: Debug.h:118
IRTranslator LLVM IR MI
char & ShrinkWrapID
ShrinkWrap pass. Look for the best place to insert save and restore.
Definition: ShrinkWrap.cpp:232
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...