LLVM  3.7.0
MachineBasicBlock.h
Go to the documentation of this file.
1 //===-- llvm/CodeGen/MachineBasicBlock.h ------------------------*- C++ -*-===//
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 // Collect the sequence of machine instructions for a basic block.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CODEGEN_MACHINEBASICBLOCK_H
15 #define LLVM_CODEGEN_MACHINEBASICBLOCK_H
16 
17 #include "llvm/ADT/GraphTraits.h"
19 #include "llvm/Support/DataTypes.h"
20 #include <functional>
21 
22 namespace llvm {
23 
24 class Pass;
25 class BasicBlock;
26 class MachineFunction;
27 class MCSymbol;
28 class SlotIndexes;
29 class StringRef;
30 class raw_ostream;
31 class MachineBranchProbabilityInfo;
32 
33 template <>
34 struct ilist_traits<MachineInstr> : public ilist_default_traits<MachineInstr> {
35 private:
36  mutable ilist_half_node<MachineInstr> Sentinel;
37 
38  // this is only set by the MachineBasicBlock owning the LiveList
39  friend class MachineBasicBlock;
40  MachineBasicBlock* Parent;
41 
42 public:
44  return static_cast<MachineInstr*>(&Sentinel);
45  }
46  void destroySentinel(MachineInstr *) const {}
47 
50  static void noteHead(MachineInstr*, MachineInstr*) {}
51 
54  void transferNodesFromList(ilist_traits &SrcTraits,
57  void deleteNode(MachineInstr *N);
58 private:
59  void createNode(const MachineInstr &);
60 };
61 
62 class MachineBasicBlock : public ilist_node<MachineBasicBlock> {
64  Instructions Insts;
65  const BasicBlock *BB;
66  int Number;
67  MachineFunction *xParent;
68 
69  /// Predecessors/Successors - Keep track of the predecessor / successor
70  /// basicblocks.
71  std::vector<MachineBasicBlock *> Predecessors;
72  std::vector<MachineBasicBlock *> Successors;
73 
74  /// Weights - Keep track of the weights to the successors. This vector
75  /// has the same order as Successors, or it is empty if we don't use it
76  /// (disable optimization).
77  std::vector<uint32_t> Weights;
78  typedef std::vector<uint32_t>::iterator weight_iterator;
79  typedef std::vector<uint32_t>::const_iterator const_weight_iterator;
80 
81  /// LiveIns - Keep track of the physical registers that are livein of
82  /// the basicblock.
83  std::vector<unsigned> LiveIns;
84 
85  /// Alignment - Alignment of the basic block. Zero if the basic block does
86  /// not need to be aligned.
87  /// The alignment is specified as log2(bytes).
88  unsigned Alignment;
89 
90  /// IsLandingPad - Indicate that this basic block is entered via an
91  /// exception handler.
92  bool IsLandingPad;
93 
94  /// AddressTaken - Indicate that this basic block is potentially the
95  /// target of an indirect branch.
96  bool AddressTaken;
97 
98  /// \brief since getSymbol is a relatively heavy-weight operation, the symbol
99  /// is only computed once and is cached.
100  mutable MCSymbol *CachedMCSymbol;
101 
102  // Intrusive list support
103  MachineBasicBlock() {}
104 
105  explicit MachineBasicBlock(MachineFunction &mf, const BasicBlock *bb);
106 
108 
109  // MachineBasicBlocks are allocated and owned by MachineFunction.
110  friend class MachineFunction;
111 
112 public:
113  /// getBasicBlock - Return the LLVM basic block that this instance
114  /// corresponded to originally. Note that this may be NULL if this instance
115  /// does not correspond directly to an LLVM basic block.
116  ///
117  const BasicBlock *getBasicBlock() const { return BB; }
118 
119  /// getName - Return the name of the corresponding LLVM basic block, or
120  /// "(null)".
121  StringRef getName() const;
122 
123  /// getFullName - Return a formatted string to identify this block and its
124  /// parent function.
125  std::string getFullName() const;
126 
127  /// hasAddressTaken - Test whether this block is potentially the target
128  /// of an indirect branch.
129  bool hasAddressTaken() const { return AddressTaken; }
130 
131  /// setHasAddressTaken - Set this block to reflect that it potentially
132  /// is the target of an indirect branch.
133  void setHasAddressTaken() { AddressTaken = true; }
134 
135  /// getParent - Return the MachineFunction containing this basic block.
136  ///
137  const MachineFunction *getParent() const { return xParent; }
138  MachineFunction *getParent() { return xParent; }
139 
140 
141  /// bundle_iterator - MachineBasicBlock iterator that automatically skips over
142  /// MIs that are inside bundles (i.e. walk top level MIs only).
143  template<typename Ty, typename IterTy>
145  : public std::iterator<std::bidirectional_iterator_tag, Ty, ptrdiff_t> {
146  IterTy MII;
147 
148  public:
149  bundle_iterator(IterTy mii) : MII(mii) {}
150 
151  bundle_iterator(Ty &mi) : MII(mi) {
152  assert(!mi.isBundledWithPred() &&
153  "It's not legal to initialize bundle_iterator with a bundled MI");
154  }
155  bundle_iterator(Ty *mi) : MII(mi) {
156  assert((!mi || !mi->isBundledWithPred()) &&
157  "It's not legal to initialize bundle_iterator with a bundled MI");
158  }
159  // Template allows conversion from const to nonconst.
160  template<class OtherTy, class OtherIterTy>
162  : MII(I.getInstrIterator()) {}
163  bundle_iterator() : MII(nullptr) {}
164 
165  Ty &operator*() const { return *MII; }
166  Ty *operator->() const { return &operator*(); }
167 
168  operator Ty*() const { return MII; }
169 
170  bool operator==(const bundle_iterator &x) const {
171  return MII == x.MII;
172  }
173  bool operator!=(const bundle_iterator &x) const {
174  return !operator==(x);
175  }
176 
177  // Increment and decrement operators...
178  bundle_iterator &operator--() { // predecrement - Back up
179  do --MII;
180  while (MII->isBundledWithPred());
181  return *this;
182  }
183  bundle_iterator &operator++() { // preincrement - Advance
184  while (MII->isBundledWithSucc())
185  ++MII;
186  ++MII;
187  return *this;
188  }
189  bundle_iterator operator--(int) { // postdecrement operators...
190  bundle_iterator tmp = *this;
191  --*this;
192  return tmp;
193  }
194  bundle_iterator operator++(int) { // postincrement operators...
195  bundle_iterator tmp = *this;
196  ++*this;
197  return tmp;
198  }
199 
200  IterTy getInstrIterator() const {
201  return MII;
202  }
203  };
204 
207  typedef std::reverse_iterator<instr_iterator> reverse_instr_iterator;
208  typedef
209  std::reverse_iterator<const_instr_iterator> const_reverse_instr_iterator;
210 
211  typedef
213  typedef
215  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
216  typedef std::reverse_iterator<iterator> reverse_iterator;
217 
218 
219  unsigned size() const { return (unsigned)Insts.size(); }
220  bool empty() const { return Insts.empty(); }
221 
222  MachineInstr &instr_front() { return Insts.front(); }
223  MachineInstr &instr_back() { return Insts.back(); }
224  const MachineInstr &instr_front() const { return Insts.front(); }
225  const MachineInstr &instr_back() const { return Insts.back(); }
226 
227  MachineInstr &front() { return Insts.front(); }
228  MachineInstr &back() { return *--end(); }
229  const MachineInstr &front() const { return Insts.front(); }
230  const MachineInstr &back() const { return *--end(); }
231 
232  instr_iterator instr_begin() { return Insts.begin(); }
233  const_instr_iterator instr_begin() const { return Insts.begin(); }
234  instr_iterator instr_end() { return Insts.end(); }
235  const_instr_iterator instr_end() const { return Insts.end(); }
238  reverse_instr_iterator instr_rend () { return Insts.rend(); }
239  const_reverse_instr_iterator instr_rend () const { return Insts.rend(); }
240 
241  iterator begin() { return instr_begin(); }
242  const_iterator begin() const { return instr_begin(); }
243  iterator end () { return instr_end(); }
244  const_iterator end () const { return instr_end(); }
248  const_reverse_iterator rend () const { return instr_rend(); }
249 
252  }
255  }
256 
257  // Machine-CFG iterators
258  typedef std::vector<MachineBasicBlock *>::iterator pred_iterator;
259  typedef std::vector<MachineBasicBlock *>::const_iterator const_pred_iterator;
260  typedef std::vector<MachineBasicBlock *>::iterator succ_iterator;
261  typedef std::vector<MachineBasicBlock *>::const_iterator const_succ_iterator;
262  typedef std::vector<MachineBasicBlock *>::reverse_iterator
264  typedef std::vector<MachineBasicBlock *>::const_reverse_iterator
266  typedef std::vector<MachineBasicBlock *>::reverse_iterator
268  typedef std::vector<MachineBasicBlock *>::const_reverse_iterator
270  pred_iterator pred_begin() { return Predecessors.begin(); }
271  const_pred_iterator pred_begin() const { return Predecessors.begin(); }
272  pred_iterator pred_end() { return Predecessors.end(); }
273  const_pred_iterator pred_end() const { return Predecessors.end(); }
275  { return Predecessors.rbegin();}
277  { return Predecessors.rbegin();}
279  { return Predecessors.rend(); }
281  { return Predecessors.rend(); }
282  unsigned pred_size() const {
283  return (unsigned)Predecessors.size();
284  }
285  bool pred_empty() const { return Predecessors.empty(); }
286  succ_iterator succ_begin() { return Successors.begin(); }
287  const_succ_iterator succ_begin() const { return Successors.begin(); }
288  succ_iterator succ_end() { return Successors.end(); }
289  const_succ_iterator succ_end() const { return Successors.end(); }
291  { return Successors.rbegin(); }
293  { return Successors.rbegin(); }
295  { return Successors.rend(); }
297  { return Successors.rend(); }
298  unsigned succ_size() const {
299  return (unsigned)Successors.size();
300  }
301  bool succ_empty() const { return Successors.empty(); }
302 
305  }
308  }
311  }
314  }
315 
316  // LiveIn management methods.
317 
318  /// Adds the specified register as a live in. Note that it is an error to add
319  /// the same register to the same set more than once unless the intention is
320  /// to call sortUniqueLiveIns after all registers are added.
321  void addLiveIn(unsigned Reg) { LiveIns.push_back(Reg); }
322 
323  /// Sorts and uniques the LiveIns vector. It can be significantly faster to do
324  /// this than repeatedly calling isLiveIn before calling addLiveIn for every
325  /// LiveIn insertion.
327  std::sort(LiveIns.begin(), LiveIns.end());
328  LiveIns.erase(std::unique(LiveIns.begin(), LiveIns.end()), LiveIns.end());
329  }
330 
331  /// Add PhysReg as live in to this block, and ensure that there is a copy of
332  /// PhysReg to a virtual register of class RC. Return the virtual register
333  /// that is a copy of the live in PhysReg.
334  unsigned addLiveIn(unsigned PhysReg, const TargetRegisterClass *RC);
335 
336  /// removeLiveIn - Remove the specified register from the live in set.
337  ///
338  void removeLiveIn(unsigned Reg);
339 
340  /// isLiveIn - Return true if the specified register is in the live in set.
341  ///
342  bool isLiveIn(unsigned Reg) const;
343 
344  // Iteration support for live in sets. These sets are kept in sorted
345  // order by their register number.
346  typedef std::vector<unsigned>::const_iterator livein_iterator;
347  livein_iterator livein_begin() const { return LiveIns.begin(); }
348  livein_iterator livein_end() const { return LiveIns.end(); }
349  bool livein_empty() const { return LiveIns.empty(); }
350 
351  /// getAlignment - Return alignment of the basic block.
352  /// The alignment is specified as log2(bytes).
353  ///
354  unsigned getAlignment() const { return Alignment; }
355 
356  /// setAlignment - Set alignment of the basic block.
357  /// The alignment is specified as log2(bytes).
358  ///
359  void setAlignment(unsigned Align) { Alignment = Align; }
360 
361  /// isLandingPad - Returns true if the block is a landing pad. That is
362  /// this basic block is entered via an exception handler.
363  bool isLandingPad() const { return IsLandingPad; }
364 
365  /// setIsLandingPad - Indicates the block is a landing pad. That is
366  /// this basic block is entered via an exception handler.
367  void setIsLandingPad(bool V = true) { IsLandingPad = V; }
368 
369  /// getLandingPadSuccessor - If this block has a successor that is a landing
370  /// pad, return it. Otherwise return NULL.
372 
373  // Code Layout methods.
374 
375  /// moveBefore/moveAfter - move 'this' block before or after the specified
376  /// block. This only moves the block, it does not modify the CFG or adjust
377  /// potential fall-throughs at the end of the block.
378  void moveBefore(MachineBasicBlock *NewAfter);
379  void moveAfter(MachineBasicBlock *NewBefore);
380 
381  /// updateTerminator - Update the terminator instructions in block to account
382  /// for changes to the layout. If the block previously used a fallthrough,
383  /// it may now need a branch, and if it previously used branching it may now
384  /// be able to use a fallthrough.
385  void updateTerminator();
386 
387  // Machine-CFG mutators
388 
389  /// addSuccessor - Add succ as a successor of this MachineBasicBlock.
390  /// The Predecessors list of succ is automatically updated. WEIGHT
391  /// parameter is stored in Weights list and it may be used by
392  /// MachineBranchProbabilityInfo analysis to calculate branch probability.
393  ///
394  /// Note that duplicate Machine CFG edges are not allowed.
395  ///
396  void addSuccessor(MachineBasicBlock *succ, uint32_t weight = 0);
397 
398  /// Set successor weight of a given iterator.
399  void setSuccWeight(succ_iterator I, uint32_t weight);
400 
401  /// removeSuccessor - Remove successor from the successors list of this
402  /// MachineBasicBlock. The Predecessors list of succ is automatically updated.
403  ///
405 
406  /// removeSuccessor - Remove specified successor from the successors list of
407  /// this MachineBasicBlock. The Predecessors list of succ is automatically
408  /// updated. Return the iterator to the element after the one removed.
409  ///
411 
412  /// replaceSuccessor - Replace successor OLD with NEW and update weight info.
413  ///
415 
416 
417  /// transferSuccessors - Transfers all the successors from MBB to this
418  /// machine basic block (i.e., copies all the successors fromMBB and
419  /// remove all the successors from fromMBB).
420  void transferSuccessors(MachineBasicBlock *fromMBB);
421 
422  /// transferSuccessorsAndUpdatePHIs - Transfers all the successors, as
423  /// in transferSuccessors, and update PHI operands in the successor blocks
424  /// which refer to fromMBB to refer to this.
426 
427  /// isPredecessor - Return true if the specified MBB is a predecessor of this
428  /// block.
429  bool isPredecessor(const MachineBasicBlock *MBB) const;
430 
431  /// isSuccessor - Return true if the specified MBB is a successor of this
432  /// block.
433  bool isSuccessor(const MachineBasicBlock *MBB) const;
434 
435  /// isLayoutSuccessor - Return true if the specified MBB will be emitted
436  /// immediately after this block, such that if this block exits by
437  /// falling through, control will transfer to the specified MBB. Note
438  /// that MBB need not be a successor at all, for example if this block
439  /// ends with an unconditional branch to some other block.
440  bool isLayoutSuccessor(const MachineBasicBlock *MBB) const;
441 
442  /// canFallThrough - Return true if the block can implicitly transfer
443  /// control to the block after it by falling off the end of it. This should
444  /// return false if it can reach the block after it, but it uses an explicit
445  /// branch to do so (e.g., a table jump). True is a conservative answer.
446  bool canFallThrough();
447 
448  /// Returns a pointer to the first instruction in this block that is not a
449  /// PHINode instruction. When adding instructions to the beginning of the
450  /// basic block, they should be added before the returned value, not before
451  /// the first instruction, which might be PHI.
452  /// Returns end() is there's no non-PHI instruction.
454 
455  /// SkipPHIsAndLabels - Return the first instruction in MBB after I that is
456  /// not a PHI or a label. This is the correct point to insert copies at the
457  /// beginning of a basic block.
459 
460  /// getFirstTerminator - returns an iterator to the first terminator
461  /// instruction of this basic block. If a terminator does not exist,
462  /// it returns end()
465  return const_cast<MachineBasicBlock *>(this)->getFirstTerminator();
466  }
467 
468  /// getFirstInstrTerminator - Same getFirstTerminator but it ignores bundles
469  /// and return an instr_iterator instead.
471 
472  /// getFirstNonDebugInstr - returns an iterator to the first non-debug
473  /// instruction in the basic block, or end()
476  return const_cast<MachineBasicBlock *>(this)->getFirstNonDebugInstr();
477  }
478 
479  /// getLastNonDebugInstr - returns an iterator to the last non-debug
480  /// instruction in the basic block, or end()
483  return const_cast<MachineBasicBlock *>(this)->getLastNonDebugInstr();
484  }
485 
486  /// SplitCriticalEdge - Split the critical edge from this block to the
487  /// given successor block, and return the newly created block, or null
488  /// if splitting is not possible.
489  ///
490  /// This function updates LiveVariables, MachineDominatorTree, and
491  /// MachineLoopInfo, as applicable.
493 
494  void pop_front() { Insts.pop_front(); }
495  void pop_back() { Insts.pop_back(); }
496  void push_back(MachineInstr *MI) { Insts.push_back(MI); }
497 
498  /// Insert MI into the instruction list before I, possibly inside a bundle.
499  ///
500  /// If the insertion point is inside a bundle, MI will be added to the bundle,
501  /// otherwise MI will not be added to any bundle. That means this function
502  /// alone can't be used to prepend or append instructions to bundles. See
503  /// MIBundleBuilder::insert() for a more reliable way of doing that.
505 
506  /// Insert a range of instructions into the instruction list before I.
507  template<typename IT>
508  void insert(iterator I, IT S, IT E) {
509  assert((I == end() || I->getParent() == this) &&
510  "iterator points outside of basic block");
511  Insts.insert(I.getInstrIterator(), S, E);
512  }
513 
514  /// Insert MI into the instruction list before I.
516  assert((I == end() || I->getParent() == this) &&
517  "iterator points outside of basic block");
518  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
519  "Cannot insert instruction with bundle flags");
520  return Insts.insert(I.getInstrIterator(), MI);
521  }
522 
523  /// Insert MI into the instruction list after I.
525  assert((I == end() || I->getParent() == this) &&
526  "iterator points outside of basic block");
527  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
528  "Cannot insert instruction with bundle flags");
529  return Insts.insertAfter(I.getInstrIterator(), MI);
530  }
531 
532  /// Remove an instruction from the instruction list and delete it.
533  ///
534  /// If the instruction is part of a bundle, the other instructions in the
535  /// bundle will still be bundled after removing the single instruction.
537 
538  /// Remove an instruction from the instruction list and delete it.
539  ///
540  /// If the instruction is part of a bundle, the other instructions in the
541  /// bundle will still be bundled after removing the single instruction.
543  return erase(instr_iterator(I));
544  }
545 
546  /// Remove a range of instructions from the instruction list and delete them.
548  return Insts.erase(I.getInstrIterator(), E.getInstrIterator());
549  }
550 
551  /// Remove an instruction or bundle from the instruction list and delete it.
552  ///
553  /// If I points to a bundle of instructions, they are all erased.
555  return erase(I, std::next(I));
556  }
557 
558  /// Remove an instruction from the instruction list and delete it.
559  ///
560  /// If I is the head of a bundle of instructions, the whole bundle will be
561  /// erased.
563  return erase(iterator(I));
564  }
565 
566  /// Remove the unbundled instruction from the instruction list without
567  /// deleting it.
568  ///
569  /// This function can not be used to remove bundled instructions, use
570  /// remove_instr to remove individual instructions from a bundle.
572  assert(!I->isBundled() && "Cannot remove bundled instructions");
573  return Insts.remove(I);
574  }
575 
576  /// Remove the possibly bundled instruction from the instruction list
577  /// without deleting it.
578  ///
579  /// If the instruction is part of a bundle, the other instructions in the
580  /// bundle will still be bundled after removing the single instruction.
582 
583  void clear() {
584  Insts.clear();
585  }
586 
587  /// Take an instruction from MBB 'Other' at the position From, and insert it
588  /// into this MBB right before 'Where'.
589  ///
590  /// If From points to a bundle of instructions, the whole bundle is moved.
592  // The range splice() doesn't allow noop moves, but this one does.
593  if (Where != From)
594  splice(Where, Other, From, std::next(From));
595  }
596 
597  /// Take a block of instructions from MBB 'Other' in the range [From, To),
598  /// and insert them into this MBB right before 'Where'.
599  ///
600  /// The instruction at 'Where' must not be included in the range of
601  /// instructions to move.
603  iterator From, iterator To) {
604  Insts.splice(Where.getInstrIterator(), Other->Insts,
605  From.getInstrIterator(), To.getInstrIterator());
606  }
607 
608  /// removeFromParent - This method unlinks 'this' from the containing
609  /// function, and returns it, but does not delete it.
611 
612  /// eraseFromParent - This method unlinks 'this' from the containing
613  /// function and deletes it.
614  void eraseFromParent();
615 
616  /// ReplaceUsesOfBlockWith - Given a machine basic block that branched to
617  /// 'Old', change the code and CFG so that it branches to 'New' instead.
619 
620  /// CorrectExtraCFGEdges - Various pieces of code can cause excess edges in
621  /// the CFG to be inserted. If we have proven that MBB can only branch to
622  /// DestA and DestB, remove any other MBB successors from the CFG. DestA and
623  /// DestB can be null. Besides DestA and DestB, retain other edges leading
624  /// to LandingPads (currently there can be only one; we don't check or require
625  /// that here). Note it is possible that DestA and/or DestB are LandingPads.
627  MachineBasicBlock *DestB,
628  bool isCond);
629 
630  /// findDebugLoc - find the next valid DebugLoc starting at MBBI, skipping
631  /// any DBG_VALUE instructions. Return UnknownLoc if there is none.
634  return findDebugLoc(MBBI.getInstrIterator());
635  }
636 
637  /// Possible outcome of a register liveness query to computeRegisterLiveness()
639  LQR_Live, ///< Register is known to be live.
640  LQR_OverlappingLive, ///< Register itself is not live, but some overlapping
641  ///< register is.
642  LQR_Dead, ///< Register is known to be dead.
643  LQR_Unknown ///< Register liveness not decidable from local
644  ///< neighborhood.
645  };
646 
647  /// Return whether (physical) register \p Reg has been <def>ined and not
648  /// <kill>ed as of just before \p Before.
649  ///
650  /// Search is localised to a neighborhood of \p Neighborhood instructions
651  /// before (searching for defs or kills) and \p Neighborhood instructions
652  /// after (searching just for defs) \p Before.
653  ///
654  /// \p Reg must be a physical register.
656  unsigned Reg,
657  const_iterator Before,
658  unsigned Neighborhood=10) const;
659 
660  // Debugging methods.
661  void dump() const;
662  void print(raw_ostream &OS, SlotIndexes* = nullptr) const;
663  void print(raw_ostream &OS, ModuleSlotTracker &MST,
664  SlotIndexes * = nullptr) const;
665 
666  // Printing method used by LoopInfo.
667  void printAsOperand(raw_ostream &OS, bool PrintType = true) const;
668 
669  /// getNumber - MachineBasicBlocks are uniquely numbered at the function
670  /// level, unless they're not in a MachineFunction yet, in which case this
671  /// will return -1.
672  ///
673  int getNumber() const { return Number; }
674  void setNumber(int N) { Number = N; }
675 
676  /// getSymbol - Return the MCSymbol for this basic block.
677  ///
678  MCSymbol *getSymbol() const;
679 
680 
681 private:
682  /// getWeightIterator - Return weight iterator corresponding to the I
683  /// successor iterator.
684  weight_iterator getWeightIterator(succ_iterator I);
685  const_weight_iterator getWeightIterator(const_succ_iterator I) const;
686 
688 
689  /// getSuccWeight - Return weight of the edge from this block to MBB. This
690  /// method should NOT be called directly, but by using getEdgeWeight method
691  /// from MachineBranchProbabilityInfo class.
692  uint32_t getSuccWeight(const_succ_iterator Succ) const;
693 
694 
695  // Methods used to maintain doubly linked list of blocks...
697 
698  // Machine-CFG mutators
699 
700  /// addPredecessor - Remove pred as a predecessor of this MachineBasicBlock.
701  /// Don't do this unless you know what you're doing, because it doesn't
702  /// update pred's successors list. Use pred->addSuccessor instead.
703  ///
704  void addPredecessor(MachineBasicBlock *pred);
705 
706  /// removePredecessor - Remove pred as a predecessor of this
707  /// MachineBasicBlock. Don't do this unless you know what you're
708  /// doing, because it doesn't update pred's successors list. Use
709  /// pred->removeSuccessor instead.
710  ///
711  void removePredecessor(MachineBasicBlock *pred);
712 };
713 
715 
716 // This is useful when building IndexedMaps keyed on basic block pointers.
718  public std::unary_function<const MachineBasicBlock*, unsigned> {
719  unsigned operator()(const MachineBasicBlock *MBB) const {
720  return MBB->getNumber();
721  }
722 };
723 
724 //===--------------------------------------------------------------------===//
725 // GraphTraits specializations for machine basic block graphs (machine-CFGs)
726 //===--------------------------------------------------------------------===//
727 
728 // Provide specializations of GraphTraits to be able to treat a
729 // MachineFunction as a graph of MachineBasicBlocks...
730 //
731 
732 template <> struct GraphTraits<MachineBasicBlock *> {
735 
736  static NodeType *getEntryNode(MachineBasicBlock *BB) { return BB; }
737  static inline ChildIteratorType child_begin(NodeType *N) {
738  return N->succ_begin();
739  }
740  static inline ChildIteratorType child_end(NodeType *N) {
741  return N->succ_end();
742  }
743 };
744 
745 template <> struct GraphTraits<const MachineBasicBlock *> {
748 
749  static NodeType *getEntryNode(const MachineBasicBlock *BB) { return BB; }
750  static inline ChildIteratorType child_begin(NodeType *N) {
751  return N->succ_begin();
752  }
753  static inline ChildIteratorType child_end(NodeType *N) {
754  return N->succ_end();
755  }
756 };
757 
758 // Provide specializations of GraphTraits to be able to treat a
759 // MachineFunction as a graph of MachineBasicBlocks... and to walk it
760 // in inverse order. Inverse order for a function is considered
761 // to be when traversing the predecessor edges of a MBB
762 // instead of the successor edges.
763 //
764 template <> struct GraphTraits<Inverse<MachineBasicBlock*> > {
768  return G.Graph;
769  }
770  static inline ChildIteratorType child_begin(NodeType *N) {
771  return N->pred_begin();
772  }
773  static inline ChildIteratorType child_end(NodeType *N) {
774  return N->pred_end();
775  }
776 };
777 
778 template <> struct GraphTraits<Inverse<const MachineBasicBlock*> > {
782  return G.Graph;
783  }
784  static inline ChildIteratorType child_begin(NodeType *N) {
785  return N->pred_begin();
786  }
787  static inline ChildIteratorType child_end(NodeType *N) {
788  return N->pred_end();
789  }
790 };
791 
792 
793 
794 /// MachineInstrSpan provides an interface to get an iteration range
795 /// containing the instruction it was initialized with, along with all
796 /// those instructions inserted prior to or following that instruction
797 /// at some point after the MachineInstrSpan is constructed.
799  MachineBasicBlock &MBB;
801 public:
803  : MBB(*I->getParent()),
804  I(I),
805  B(I == MBB.begin() ? MBB.end() : std::prev(I)),
806  E(std::next(I)) {}
807 
809  return B == MBB.end() ? MBB.begin() : std::next(B);
810  }
812  bool empty() { return begin() == end(); }
813 
815 };
816 
817 } // End llvm namespace
818 
819 #endif
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:82
static ChildIteratorType child_end(NodeType *N)
pred_reverse_iterator pred_rbegin()
unsigned succ_size() const
static void noteHead(MachineInstr *, MachineInstr *)
const MachineFunction * getParent() const
getParent - Return the MachineFunction containing this basic block.
const_iterator getLastNonDebugInstr() const
pred_reverse_iterator pred_rend()
const_instr_iterator instr_begin() const
instr_iterator instr_begin()
void transferNodesFromList(ilist_node_traits &, ilist_iterator< NodeTy >, ilist_iterator< NodeTy >)
Definition: ilist.h:117
void removeNodeFromList(NodeTy *)
Definition: ilist.h:116
instr_iterator instr_end()
bool operator==(const bundle_iterator &x) const
iplist< MachineInstr >::iterator iterator
Definition: ilist.h:588
void pop_back()
Definition: ilist.h:559
Various leaf nodes.
Definition: ISDOpcodes.h:60
static NodeTy * createNode(const NodeTy &V)
Definition: ilist.h:112
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
int getNumber() const
getNumber - MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a M...
void setIsLandingPad(bool V=true)
setIsLandingPad - Indicates the block is a landing pad.
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: GraphTraits.h:27
MachineInstr & instr_front()
reverse_iterator rend()
Definition: ilist.h:379
Instructions::const_iterator const_instr_iterator
const_succ_iterator succ_begin() const
instr_iterator getFirstInstrTerminator()
getFirstInstrTerminator - Same getFirstTerminator but it ignores bundles and return an instr_iterator...
iterator getFirstNonDebugInstr()
getFirstNonDebugInstr - returns an iterator to the first non-debug instruction in the basic block...
MachineBasicBlock::pred_iterator ChildIteratorType
bundle_iterator(const bundle_iterator< OtherTy, OtherIterTy > &I)
std::vector< unsigned >::const_iterator livein_iterator
iterator getFirstTerminator()
getFirstTerminator - returns an iterator to the first terminator instruction of this basic block...
MachineBasicBlock::succ_iterator ChildIteratorType
MachineInstr & instr_back()
void removeLiveIn(unsigned Reg)
removeLiveIn - Remove the specified register from the live in set.
static NodeType * getEntryNode(MachineBasicBlock *BB)
iterator_range< const_iterator > terminators() const
void addLiveIn(unsigned Reg)
Adds the specified register as a live in.
iterator insertAfter(iterator I, MachineInstr *MI)
Insert MI into the instruction list after I.
DebugLoc findDebugLoc(iterator MBBI)
void moveAfter(MachineBasicBlock *NewBefore)
A debug info location.
Definition: DebugLoc.h:34
void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *fromMBB)
transferSuccessorsAndUpdatePHIs - Transfers all the successors, as in transferSuccessors, and update PHI operands in the successor blocks which refer to fromMBB to refer to this.
Manage lifetime of a slot tracker for printing IR.
iterator begin()
Definition: ilist.h:359
iterator_range< const_succ_iterator > successors() const
std::reverse_iterator< const_instr_iterator > const_reverse_instr_iterator
MachineInstr * createSentinel() const
Instructions::iterator instr_iterator
MachineInstrSpan(MachineBasicBlock::iterator I)
iterator insert(iterator I, MachineInstr *MI)
Insert MI into the instruction list before I.
MachineBasicBlock * removeFromParent()
removeFromParent - This method unlinks 'this' from the containing function, and returns it...
void setAlignment(unsigned Align)
setAlignment - Set alignment of the basic block.
iterator_range< succ_iterator > successors()
void splice(iterator Where, MachineBasicBlock *Other, iterator From, iterator To)
Take a block of instructions from MBB 'Other' in the range [From, To), and insert them into this MBB ...
reverse_iterator rbegin()
Definition: ilist.h:377
MachineInstrSpan provides an interface to get an iteration range containing the instruction it was in...
std::vector< MachineBasicBlock * >::const_reverse_iterator const_pred_reverse_iterator
livein_iterator livein_begin() const
void ReplaceUsesOfBlockWith(MachineBasicBlock *Old, MachineBasicBlock *New)
ReplaceUsesOfBlockWith - Given a machine basic block that branched to 'Old', change the code and CFG ...
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing function and deletes it...
instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::ZeroOrMore, cl::values(clEnumValN(DefaultIT,"arm-default-it","Generate IT block based on arch"), clEnumValN(RestrictedIT,"arm-restrict-it","Disallow deprecated IT based on ARMv8"), clEnumValN(NoRestrictedIT,"arm-no-restrict-it","Allow IT blocks based on ARMv7"), clEnumValEnd))
const_iterator getFirstNonDebugInstr() const
iterator erase(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
void insert(iterator I, IT S, IT E)
Insert a range of instructions into the instruction list before I.
std::vector< MachineBasicBlock * >::iterator succ_iterator
Reg
All possible values of the reg field in the ModR/M byte.
iterator_range< iterator > terminators()
MachineBasicBlock * SplitCriticalEdge(MachineBasicBlock *Succ, Pass *P)
SplitCriticalEdge - Split the critical edge from this block to the given successor block...
ilist_default_traits - Default template traits for intrusive list.
Definition: ilist.h:127
MachineInstr * remove_instr(MachineInstr *I)
Remove the possibly bundled instruction from the instruction list without deleting it...
const MachineInstr & instr_front() const
void destroySentinel(MachineInstr *) const
MachineBasicBlock::iterator end()
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:591
#define G(x, y, z)
Definition: MD5.cpp:52
void clear()
Definition: ilist.h:550
static NodeType * getEntryNode(const MachineBasicBlock *BB)
bool isBundledWithSucc() const
Return true if this instruction is part of a bundle, and it is not the last instruction in the bundle...
Definition: MachineInstr.h:221
void transferSuccessors(MachineBasicBlock *fromMBB)
transferSuccessors - Transfers all the successors from MBB to this machine basic block (i...
SlotIndexes pass.
Definition: SlotIndexes.h:334
std::reverse_iterator< instr_iterator > reverse_instr_iterator
const_succ_iterator succ_end() const
const MachineInstr & front() const
bool canFallThrough()
canFallThrough - Return true if the block can implicitly transfer control to the block after it by fa...
iterator getLastNonDebugInstr()
getLastNonDebugInstr - returns an iterator to the last non-debug instruction in the basic block...
std::vector< MachineBasicBlock * >::iterator pred_iterator
void printAsOperand(raw_ostream &OS, bool PrintType=true) const
succ_reverse_iterator succ_rend()
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
reverse_iterator rend()
LivenessQueryResult computeRegisterLiveness(const TargetRegisterInfo *TRI, unsigned Reg, const_iterator Before, unsigned Neighborhood=10) const
Return whether (physical) register Reg has been <def>ined and not <kill>ed as of just before Before...
const_pred_iterator pred_end() const
reverse_iterator rbegin()
const BasicBlock * getBasicBlock() const
getBasicBlock - Return the LLVM basic block that this instance corresponded to originally.
static NodeType * getEntryNode(Inverse< MachineBasicBlock * > G)
static void deleteNode(NodeTy *V)
Definition: ilist.h:113
const_reverse_instr_iterator instr_rend() const
bundle_iterator< MachineInstr, instr_iterator > iterator
#define P(N)
static NodeType * getEntryNode(Inverse< const MachineBasicBlock * > G)
iterator SkipPHIsAndLabels(iterator I)
SkipPHIsAndLabels - Return the first instruction in MBB after I that is not a PHI or a label...
instr_iterator erase_instr(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
static ChildIteratorType child_end(NodeType *N)
succ_reverse_iterator succ_rbegin()
size_type LLVM_ATTRIBUTE_UNUSED_RESULT size() const
Definition: ilist.h:539
const_iterator begin() const
livein_iterator livein_end() const
DebugLoc findDebugLoc(instr_iterator MBBI)
findDebugLoc - find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE instructions...
bundle_iterator - MachineBasicBlock iterator that automatically skips over MIs that are inside bundle...
iterator insertAfter(iterator where, NodeTy *New)
Definition: ilist.h:428
iterator insert(iterator where, const NodeTy &val)
Definition: ilist.h:610
Register is known to be dead.
std::reverse_iterator< const_iterator > const_reverse_iterator
const MachineBasicBlock * getLandingPadSuccessor() const
getLandingPadSuccessor - If this block has a successor that is a landing pad, return it...
const_reverse_instr_iterator instr_rbegin() const
bool isBundledWithPred() const
Return true if this instruction is part of a bundle, and it is not the first instruction in the bundl...
Definition: MachineInstr.h:217
iterator_range< pred_iterator > predecessors()
LivenessQueryResult
Possible outcome of a register liveness query to computeRegisterLiveness()
Register is known to be live.
const_iterator getFirstTerminator() const
void removeSuccessor(MachineBasicBlock *succ)
removeSuccessor - Remove successor from the successors list of this MachineBasicBlock.
const MachineInstr & instr_back() const
bool operator!=(const bundle_iterator &x) const
void moveBefore(MachineBasicBlock *NewAfter)
moveBefore/moveAfter - move 'this' block before or after the specified block.
iterator erase(iterator I)
Remove an instruction or bundle from the instruction list and delete it.
static ChildIteratorType child_begin(NodeType *N)
aarch64 type AArch64 Type Promotion Pass
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
MCSymbol * getSymbol() const
getSymbol - Return the MCSymbol for this basic block.
iterator erase(iterator I, iterator E)
Remove a range of instructions from the instruction list and delete them.
iterator erase(iterator where)
Definition: ilist.h:465
std::vector< MachineBasicBlock * >::const_iterator const_pred_iterator
hexagon gen pred
std::string getFullName() const
getFullName - Return a formatted string to identify this block and its parent function.
MachineInstr * ensureHead(MachineInstr *) const
const_iterator end() const
const GraphType & Graph
Definition: GraphTraits.h:79
reverse_instr_iterator instr_rbegin()
const_succ_reverse_iterator succ_rbegin() const
std::vector< MachineBasicBlock * >::const_reverse_iterator const_succ_reverse_iterator
const_succ_reverse_iterator succ_rend() const
void updateTerminator()
updateTerminator - Update the terminator instructions in block to account for changes to the layout...
std::vector< MachineBasicBlock * >::reverse_iterator succ_reverse_iterator
bool isSuccessor(const MachineBasicBlock *MBB) const
isSuccessor - Return true if the specified MBB is a successor of this block.
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: ilist.h:385
void sortUniqueLiveIns()
Sorts and uniques the LiveIns vector.
MachineBasicBlock::iterator getInitial()
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))
const_reverse_iterator rbegin() const
void splice(iterator where, iplist &L2)
Definition: ilist.h:570
reverse_instr_iterator instr_rend()
A range adaptor for a pair of iterators.
StringRef getName() const
getName - Return the name of the corresponding LLVM basic block, or "(null)".
MachineBasicBlock::const_succ_iterator ChildIteratorType
void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New)
replaceSuccessor - Replace successor OLD with NEW and update weight info.
void setHasAddressTaken()
setHasAddressTaken - Set this block to reflect that it potentially is the target of an indirect branc...
MachineFunction * getParent()
MachineInstr * provideInitialHead() const
Register itself is not live, but some overlapping register is.
reference front()
Definition: ilist.h:390
Representation of each machine instruction.
Definition: MachineInstr.h:51
bundle_iterator< const MachineInstr, const_instr_iterator > const_iterator
bool hasAddressTaken() const
hasAddressTaken - Test whether this block is potentially the target of an indirect branch...
const_pred_iterator pred_begin() const
bool isLandingPad() const
isLandingPad - Returns true if the block is a landing pad.
void addNodeToList(NodeTy *)
Definition: ilist.h:115
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
bool isLiveIn(unsigned Reg) const
isLiveIn - Return true if the specified register is in the live in set.
ilist_node - Base class that provides next/prev services for nodes that use ilist_nextprev_traits or ...
Definition: ilist_node.h:43
Register liveness not decidable from local neighborhood.
const_reverse_iterator rend() const
void push_back(MachineInstr *MI)
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
const_pred_reverse_iterator pred_rbegin() const
iterator getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
void setSuccWeight(succ_iterator I, uint32_t weight)
Set successor weight of a given iterator.
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:1738
reference back()
Definition: ilist.h:398
static ChildIteratorType child_begin(NodeType *N)
MachineBasicBlock::const_pred_iterator ChildIteratorType
static NodeTy * createSentinel()
createSentinel - create the dynamic sentinel
Definition: ilist.h:78
static ChildIteratorType child_begin(NodeType *N)
iterator end()
Definition: ilist.h:367
std::vector< MachineBasicBlock * >::const_iterator const_succ_iterator
aarch64 promote const
std::reverse_iterator< iterator > reverse_iterator
void pop_front()
Definition: ilist.h:555
std::vector< MachineBasicBlock * >::reverse_iterator pred_reverse_iterator
static const Function * getParent(const Value *V)
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
const_pred_reverse_iterator pred_rend() const
bool isPredecessor(const MachineBasicBlock *MBB) const
isPredecessor - Return true if the specified MBB is a predecessor of this block.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
const MachineInstr & back() const
void print(raw_ostream &OS, SlotIndexes *=nullptr) const
bool isLayoutSuccessor(const MachineBasicBlock *MBB) const
isLayoutSuccessor - Return true if the specified MBB will be emitted immediately after this block...
const_instr_iterator instr_end() const
NodeTy * remove(iterator &IT)
Definition: ilist.h:435
void addSuccessor(MachineBasicBlock *succ, uint32_t weight=0)
addSuccessor - Add succ as a successor of this MachineBasicBlock.
unsigned pred_size() const
bool CorrectExtraCFGEdges(MachineBasicBlock *DestA, MachineBasicBlock *DestB, bool isCond)
CorrectExtraCFGEdges - Various pieces of code can cause excess edges in the CFG to be inserted...
static ChildIteratorType child_end(NodeType *N)
unsigned operator()(const MachineBasicBlock *MBB) const
void push_back(const NodeTy &val)
Definition: ilist.h:617
iterator_range< const_pred_iterator > predecessors() const
MachineBasicBlock::iterator begin()
unsigned getAlignment() const
getAlignment - Return alignment of the basic block.