LLVM  9.0.0svn
MachineBasicBlock.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/MachineBasicBlock.h -------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Collect the sequence of machine instructions for a basic block.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CODEGEN_MACHINEBASICBLOCK_H
14 #define LLVM_CODEGEN_MACHINEBASICBLOCK_H
15 
16 #include "llvm/ADT/GraphTraits.h"
17 #include "llvm/ADT/ilist.h"
18 #include "llvm/ADT/ilist_node.h"
20 #include "llvm/ADT/simple_ilist.h"
23 #include "llvm/IR/DebugLoc.h"
24 #include "llvm/MC/LaneBitmask.h"
25 #include "llvm/MC/MCRegisterInfo.h"
27 #include "llvm/Support/Printable.h"
28 #include <cassert>
29 #include <cstdint>
30 #include <functional>
31 #include <iterator>
32 #include <string>
33 #include <vector>
34 
35 namespace llvm {
36 
37 class BasicBlock;
38 class MachineFunction;
39 class MCSymbol;
40 class ModuleSlotTracker;
41 class Pass;
42 class SlotIndexes;
43 class StringRef;
44 class raw_ostream;
45 class TargetRegisterClass;
46 class TargetRegisterInfo;
47 
48 template <> struct ilist_traits<MachineInstr> {
49 private:
50  friend class MachineBasicBlock; // Set by the owning MachineBasicBlock.
51 
52  MachineBasicBlock *Parent;
53 
54  using instr_iterator =
56 
57 public:
61  instr_iterator Last);
62  void deleteNode(MachineInstr *MI);
63 };
64 
66  : public ilist_node_with_parent<MachineBasicBlock, MachineFunction> {
67 public:
68  /// Pair of physical register and lane mask.
69  /// This is not simply a std::pair typedef because the members should be named
70  /// clearly as they both have an integer type.
72  public:
75 
77  : PhysReg(PhysReg), LaneMask(LaneMask) {}
78  };
79 
80 private:
82 
83  Instructions Insts;
84  const BasicBlock *BB;
85  int Number;
86  MachineFunction *xParent;
87 
88  /// Keep track of the predecessor / successor basic blocks.
89  std::vector<MachineBasicBlock *> Predecessors;
90  std::vector<MachineBasicBlock *> Successors;
91 
92  /// Keep track of the probabilities to the successors. This vector has the
93  /// same order as Successors, or it is empty if we don't use it (disable
94  /// optimization).
95  std::vector<BranchProbability> Probs;
96  using probability_iterator = std::vector<BranchProbability>::iterator;
97  using const_probability_iterator =
98  std::vector<BranchProbability>::const_iterator;
99 
100  Optional<uint64_t> IrrLoopHeaderWeight;
101 
102  /// Keep track of the physical registers that are livein of the basicblock.
103  using LiveInVector = std::vector<RegisterMaskPair>;
104  LiveInVector LiveIns;
105 
106  /// Alignment of the basic block. Zero if the basic block does not need to be
107  /// aligned. The alignment is specified as log2(bytes).
108  unsigned Alignment = 0;
109 
110  /// Indicate that this basic block is entered via an exception handler.
111  bool IsEHPad = false;
112 
113  /// Indicate that this basic block is potentially the target of an indirect
114  /// branch.
115  bool AddressTaken = false;
116 
117  /// Indicate that this basic block is the entry block of an EH scope, i.e.,
118  /// the block that used to have a catchpad or cleanuppad instruction in the
119  /// LLVM IR.
120  bool IsEHScopeEntry = false;
121 
122  /// Indicate that this basic block is the entry block of an EH funclet.
123  bool IsEHFuncletEntry = false;
124 
125  /// Indicate that this basic block is the entry block of a cleanup funclet.
126  bool IsCleanupFuncletEntry = false;
127 
128  /// since getSymbol is a relatively heavy-weight operation, the symbol
129  /// is only computed once and is cached.
130  mutable MCSymbol *CachedMCSymbol = nullptr;
131 
132  // Intrusive list support
133  MachineBasicBlock() = default;
134 
135  explicit MachineBasicBlock(MachineFunction &MF, const BasicBlock *BB);
136 
138 
139  // MachineBasicBlocks are allocated and owned by MachineFunction.
140  friend class MachineFunction;
141 
142 public:
143  /// Return the LLVM basic block that this instance corresponded to originally.
144  /// Note that this may be NULL if this instance does not correspond directly
145  /// to an LLVM basic block.
146  const BasicBlock *getBasicBlock() const { return BB; }
147 
148  /// Return the name of the corresponding LLVM basic block, or an empty string.
149  StringRef getName() const;
150 
151  /// Return a formatted string to identify this block and its parent function.
152  std::string getFullName() const;
153 
154  /// Test whether this block is potentially the target of an indirect branch.
155  bool hasAddressTaken() const { return AddressTaken; }
156 
157  /// Set this block to reflect that it potentially is the target of an indirect
158  /// branch.
159  void setHasAddressTaken() { AddressTaken = true; }
160 
161  /// Return the MachineFunction containing this basic block.
162  const MachineFunction *getParent() const { return xParent; }
163  MachineFunction *getParent() { return xParent; }
164 
165  using instr_iterator = Instructions::iterator;
166  using const_instr_iterator = Instructions::const_iterator;
169 
173  using const_reverse_iterator =
175 
176  unsigned size() const { return (unsigned)Insts.size(); }
177  bool empty() const { return Insts.empty(); }
178 
179  MachineInstr &instr_front() { return Insts.front(); }
180  MachineInstr &instr_back() { return Insts.back(); }
181  const MachineInstr &instr_front() const { return Insts.front(); }
182  const MachineInstr &instr_back() const { return Insts.back(); }
183 
184  MachineInstr &front() { return Insts.front(); }
185  MachineInstr &back() { return *--end(); }
186  const MachineInstr &front() const { return Insts.front(); }
187  const MachineInstr &back() const { return *--end(); }
188 
189  instr_iterator instr_begin() { return Insts.begin(); }
190  const_instr_iterator instr_begin() const { return Insts.begin(); }
191  instr_iterator instr_end() { return Insts.end(); }
192  const_instr_iterator instr_end() const { return Insts.end(); }
193  reverse_instr_iterator instr_rbegin() { return Insts.rbegin(); }
194  const_reverse_instr_iterator instr_rbegin() const { return Insts.rbegin(); }
195  reverse_instr_iterator instr_rend () { return Insts.rend(); }
196  const_reverse_instr_iterator instr_rend () const { return Insts.rend(); }
197 
200  instr_range instrs() { return instr_range(instr_begin(), instr_end()); }
202  return const_instr_range(instr_begin(), instr_end());
203  }
204 
205  iterator begin() { return instr_begin(); }
206  const_iterator begin() const { return instr_begin(); }
207  iterator end () { return instr_end(); }
208  const_iterator end () const { return instr_end(); }
210  return reverse_iterator::getAtBundleBegin(instr_rbegin());
211  }
213  return const_reverse_iterator::getAtBundleBegin(instr_rbegin());
214  }
215  reverse_iterator rend() { return reverse_iterator(instr_rend()); }
217  return const_reverse_iterator(instr_rend());
218  }
219 
220  /// Support for MachineInstr::getNextNode().
222  return &MachineBasicBlock::Insts;
223  }
224 
226  return make_range(getFirstTerminator(), end());
227  }
229  return make_range(getFirstTerminator(), end());
230  }
231 
232  /// Returns a range that iterates over the phis in the basic block.
234  return make_range(begin(), getFirstNonPHI());
235  }
237  return const_cast<MachineBasicBlock *>(this)->phis();
238  }
239 
240  // Machine-CFG iterators
241  using pred_iterator = std::vector<MachineBasicBlock *>::iterator;
242  using const_pred_iterator = std::vector<MachineBasicBlock *>::const_iterator;
243  using succ_iterator = std::vector<MachineBasicBlock *>::iterator;
244  using const_succ_iterator = std::vector<MachineBasicBlock *>::const_iterator;
245  using pred_reverse_iterator =
246  std::vector<MachineBasicBlock *>::reverse_iterator;
248  std::vector<MachineBasicBlock *>::const_reverse_iterator;
249  using succ_reverse_iterator =
250  std::vector<MachineBasicBlock *>::reverse_iterator;
252  std::vector<MachineBasicBlock *>::const_reverse_iterator;
253  pred_iterator pred_begin() { return Predecessors.begin(); }
254  const_pred_iterator pred_begin() const { return Predecessors.begin(); }
255  pred_iterator pred_end() { return Predecessors.end(); }
256  const_pred_iterator pred_end() const { return Predecessors.end(); }
258  { return Predecessors.rbegin();}
260  { return Predecessors.rbegin();}
262  { return Predecessors.rend(); }
264  { return Predecessors.rend(); }
265  unsigned pred_size() const {
266  return (unsigned)Predecessors.size();
267  }
268  bool pred_empty() const { return Predecessors.empty(); }
269  succ_iterator succ_begin() { return Successors.begin(); }
270  const_succ_iterator succ_begin() const { return Successors.begin(); }
271  succ_iterator succ_end() { return Successors.end(); }
272  const_succ_iterator succ_end() const { return Successors.end(); }
274  { return Successors.rbegin(); }
276  { return Successors.rbegin(); }
278  { return Successors.rend(); }
280  { return Successors.rend(); }
281  unsigned succ_size() const {
282  return (unsigned)Successors.size();
283  }
284  bool succ_empty() const { return Successors.empty(); }
285 
287  return make_range(pred_begin(), pred_end());
288  }
290  return make_range(pred_begin(), pred_end());
291  }
293  return make_range(succ_begin(), succ_end());
294  }
296  return make_range(succ_begin(), succ_end());
297  }
298 
299  // LiveIn management methods.
300 
301  /// Adds the specified register as a live in. Note that it is an error to add
302  /// the same register to the same set more than once unless the intention is
303  /// to call sortUniqueLiveIns after all registers are added.
304  void addLiveIn(MCPhysReg PhysReg,
305  LaneBitmask LaneMask = LaneBitmask::getAll()) {
306  LiveIns.push_back(RegisterMaskPair(PhysReg, LaneMask));
307  }
308  void addLiveIn(const RegisterMaskPair &RegMaskPair) {
309  LiveIns.push_back(RegMaskPair);
310  }
311 
312  /// Sorts and uniques the LiveIns vector. It can be significantly faster to do
313  /// this than repeatedly calling isLiveIn before calling addLiveIn for every
314  /// LiveIn insertion.
315  void sortUniqueLiveIns();
316 
317  /// Clear live in list.
318  void clearLiveIns();
319 
320  /// Add PhysReg as live in to this block, and ensure that there is a copy of
321  /// PhysReg to a virtual register of class RC. Return the virtual register
322  /// that is a copy of the live in PhysReg.
323  unsigned addLiveIn(MCPhysReg PhysReg, const TargetRegisterClass *RC);
324 
325  /// Remove the specified register from the live in set.
326  void removeLiveIn(MCPhysReg Reg,
327  LaneBitmask LaneMask = LaneBitmask::getAll());
328 
329  /// Return true if the specified register is in the live in set.
330  bool isLiveIn(MCPhysReg Reg,
331  LaneBitmask LaneMask = LaneBitmask::getAll()) const;
332 
333  // Iteration support for live in sets. These sets are kept in sorted
334  // order by their register number.
335  using livein_iterator = LiveInVector::const_iterator;
336 #ifndef NDEBUG
337  /// Unlike livein_begin, this method does not check that the liveness
338  /// information is accurate. Still for debug purposes it may be useful
339  /// to have iterators that won't assert if the liveness information
340  /// is not current.
341  livein_iterator livein_begin_dbg() const { return LiveIns.begin(); }
343  return make_range(livein_begin_dbg(), livein_end());
344  }
345 #endif
346  livein_iterator livein_begin() const;
347  livein_iterator livein_end() const { return LiveIns.end(); }
348  bool livein_empty() const { return LiveIns.empty(); }
350  return make_range(livein_begin(), livein_end());
351  }
352 
353  /// Remove entry from the livein set and return iterator to the next.
354  livein_iterator removeLiveIn(livein_iterator I);
355 
356  /// Get the clobber mask for the start of this basic block. Funclets use this
357  /// to prevent register allocation across funclet transitions.
358  const uint32_t *getBeginClobberMask(const TargetRegisterInfo *TRI) const;
359 
360  /// Get the clobber mask for the end of the basic block.
361  /// \see getBeginClobberMask()
362  const uint32_t *getEndClobberMask(const TargetRegisterInfo *TRI) const;
363 
364  /// Return alignment of the basic block. The alignment is specified as
365  /// log2(bytes).
366  unsigned getAlignment() const { return Alignment; }
367 
368  /// Set alignment of the basic block. The alignment is specified as
369  /// log2(bytes).
370  void setAlignment(unsigned Align) { Alignment = Align; }
371 
372  /// Returns true if the block is a landing pad. That is this basic block is
373  /// entered via an exception handler.
374  bool isEHPad() const { return IsEHPad; }
375 
376  /// Indicates the block is a landing pad. That is this basic block is entered
377  /// via an exception handler.
378  void setIsEHPad(bool V = true) { IsEHPad = V; }
379 
380  bool hasEHPadSuccessor() const;
381 
382  /// Returns true if this is the entry block of an EH scope, i.e., the block
383  /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
384  bool isEHScopeEntry() const { return IsEHScopeEntry; }
385 
386  /// Indicates if this is the entry block of an EH scope, i.e., the block that
387  /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
388  void setIsEHScopeEntry(bool V = true) { IsEHScopeEntry = V; }
389 
390  /// Returns true if this is the entry block of an EH funclet.
391  bool isEHFuncletEntry() const { return IsEHFuncletEntry; }
392 
393  /// Indicates if this is the entry block of an EH funclet.
394  void setIsEHFuncletEntry(bool V = true) { IsEHFuncletEntry = V; }
395 
396  /// Returns true if this is the entry block of a cleanup funclet.
397  bool isCleanupFuncletEntry() const { return IsCleanupFuncletEntry; }
398 
399  /// Indicates if this is the entry block of a cleanup funclet.
400  void setIsCleanupFuncletEntry(bool V = true) { IsCleanupFuncletEntry = V; }
401 
402  /// Returns true if it is legal to hoist instructions into this block.
403  bool isLegalToHoistInto() const;
404 
405  // Code Layout methods.
406 
407  /// Move 'this' block before or after the specified block. This only moves
408  /// the block, it does not modify the CFG or adjust potential fall-throughs at
409  /// the end of the block.
410  void moveBefore(MachineBasicBlock *NewAfter);
411  void moveAfter(MachineBasicBlock *NewBefore);
412 
413  /// Update the terminator instructions in block to account for changes to the
414  /// layout. If the block previously used a fallthrough, it may now need a
415  /// branch, and if it previously used branching it may now be able to use a
416  /// fallthrough.
417  void updateTerminator();
418 
419  // Machine-CFG mutators
420 
421  /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
422  /// of Succ is automatically updated. PROB parameter is stored in
423  /// Probabilities list. The default probability is set as unknown. Mixing
424  /// known and unknown probabilities in successor list is not allowed. When all
425  /// successors have unknown probabilities, 1 / N is returned as the
426  /// probability for each successor, where N is the number of successors.
427  ///
428  /// Note that duplicate Machine CFG edges are not allowed.
429  void addSuccessor(MachineBasicBlock *Succ,
431 
432  /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
433  /// of Succ is automatically updated. The probability is not provided because
434  /// BPI is not available (e.g. -O0 is used), in which case edge probabilities
435  /// won't be used. Using this interface can save some space.
436  void addSuccessorWithoutProb(MachineBasicBlock *Succ);
437 
438  /// Set successor probability of a given iterator.
439  void setSuccProbability(succ_iterator I, BranchProbability Prob);
440 
441  /// Normalize probabilities of all successors so that the sum of them becomes
442  /// one. This is usually done when the current update on this MBB is done, and
443  /// the sum of its successors' probabilities is not guaranteed to be one. The
444  /// user is responsible for the correct use of this function.
445  /// MBB::removeSuccessor() has an option to do this automatically.
447  BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
448  }
449 
450  /// Validate successors' probabilities and check if the sum of them is
451  /// approximate one. This only works in DEBUG mode.
452  void validateSuccProbs() const;
453 
454  /// Remove successor from the successors list of this MachineBasicBlock. The
455  /// Predecessors list of Succ is automatically updated.
456  /// If NormalizeSuccProbs is true, then normalize successors' probabilities
457  /// after the successor is removed.
458  void removeSuccessor(MachineBasicBlock *Succ,
459  bool NormalizeSuccProbs = false);
460 
461  /// Remove specified successor from the successors list of this
462  /// MachineBasicBlock. The Predecessors list of Succ is automatically updated.
463  /// If NormalizeSuccProbs is true, then normalize successors' probabilities
464  /// after the successor is removed.
465  /// Return the iterator to the element after the one removed.
466  succ_iterator removeSuccessor(succ_iterator I,
467  bool NormalizeSuccProbs = false);
468 
469  /// Replace successor OLD with NEW and update probability info.
470  void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New);
471 
472  /// Copy a successor (and any probability info) from original block to this
473  /// block's. Uses an iterator into the original blocks successors.
474  ///
475  /// This is useful when doing a partial clone of successors. Afterward, the
476  /// probabilities may need to be normalized.
477  void copySuccessor(MachineBasicBlock *Orig, succ_iterator I);
478 
479  /// Split the old successor into old plus new and updates the probability
480  /// info.
481  void splitSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New,
482  bool NormalizeSuccProbs = false);
483 
484  /// Transfers all the successors from MBB to this machine basic block (i.e.,
485  /// copies all the successors FromMBB and remove all the successors from
486  /// FromMBB).
487  void transferSuccessors(MachineBasicBlock *FromMBB);
488 
489  /// Transfers all the successors, as in transferSuccessors, and update PHI
490  /// operands in the successor blocks which refer to FromMBB to refer to this.
491  void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB);
492 
493  /// Return true if any of the successors have probabilities attached to them.
494  bool hasSuccessorProbabilities() const { return !Probs.empty(); }
495 
496  /// Return true if the specified MBB is a predecessor of this block.
497  bool isPredecessor(const MachineBasicBlock *MBB) const;
498 
499  /// Return true if the specified MBB is a successor of this block.
500  bool isSuccessor(const MachineBasicBlock *MBB) const;
501 
502  /// Return true if the specified MBB will be emitted immediately after this
503  /// block, such that if this block exits by falling through, control will
504  /// transfer to the specified MBB. Note that MBB need not be a successor at
505  /// all, for example if this block ends with an unconditional branch to some
506  /// other block.
507  bool isLayoutSuccessor(const MachineBasicBlock *MBB) const;
508 
509  /// Return the fallthrough block if the block can implicitly
510  /// transfer control to the block after it by falling off the end of
511  /// it. This should return null if it can reach the block after
512  /// it, but it uses an explicit branch to do so (e.g., a table
513  /// jump). Non-null return is a conservative answer.
514  MachineBasicBlock *getFallThrough();
515 
516  /// Return true if the block can implicitly transfer control to the
517  /// block after it by falling off the end of it. This should return
518  /// false if it can reach the block after it, but it uses an
519  /// explicit branch to do so (e.g., a table jump). True is a
520  /// conservative answer.
521  bool canFallThrough();
522 
523  /// Returns a pointer to the first instruction in this block that is not a
524  /// PHINode instruction. When adding instructions to the beginning of the
525  /// basic block, they should be added before the returned value, not before
526  /// the first instruction, which might be PHI.
527  /// Returns end() is there's no non-PHI instruction.
528  iterator getFirstNonPHI();
529 
530  /// Return the first instruction in MBB after I that is not a PHI or a label.
531  /// This is the correct point to insert lowered copies at the beginning of a
532  /// basic block that must be before any debugging information.
533  iterator SkipPHIsAndLabels(iterator I);
534 
535  /// Return the first instruction in MBB after I that is not a PHI, label or
536  /// debug. This is the correct point to insert copies at the beginning of a
537  /// basic block.
538  iterator SkipPHIsLabelsAndDebug(iterator I);
539 
540  /// Returns an iterator to the first terminator instruction of this basic
541  /// block. If a terminator does not exist, it returns end().
542  iterator getFirstTerminator();
544  return const_cast<MachineBasicBlock *>(this)->getFirstTerminator();
545  }
546 
547  /// Same getFirstTerminator but it ignores bundles and return an
548  /// instr_iterator instead.
549  instr_iterator getFirstInstrTerminator();
550 
551  /// Returns an iterator to the first non-debug instruction in the basic block,
552  /// or end().
553  iterator getFirstNonDebugInstr();
555  return const_cast<MachineBasicBlock *>(this)->getFirstNonDebugInstr();
556  }
557 
558  /// Returns an iterator to the last non-debug instruction in the basic block,
559  /// or end().
560  iterator getLastNonDebugInstr();
562  return const_cast<MachineBasicBlock *>(this)->getLastNonDebugInstr();
563  }
564 
565  /// Convenience function that returns true if the block ends in a return
566  /// instruction.
567  bool isReturnBlock() const {
568  return !empty() && back().isReturn();
569  }
570 
571  /// Convenience function that returns true if the bock ends in a EH scope
572  /// return instruction.
573  bool isEHScopeReturnBlock() const {
574  return !empty() && back().isEHScopeReturn();
575  }
576 
577  /// Split the critical edge from this block to the given successor block, and
578  /// return the newly created block, or null if splitting is not possible.
579  ///
580  /// This function updates LiveVariables, MachineDominatorTree, and
581  /// MachineLoopInfo, as applicable.
583 
584  /// Check if the edge between this block and the given successor \p
585  /// Succ, can be split. If this returns true a subsequent call to
586  /// SplitCriticalEdge is guaranteed to return a valid basic block if
587  /// no changes occurred in the meantime.
588  bool canSplitCriticalEdge(const MachineBasicBlock *Succ) const;
589 
590  void pop_front() { Insts.pop_front(); }
591  void pop_back() { Insts.pop_back(); }
592  void push_back(MachineInstr *MI) { Insts.push_back(MI); }
593 
594  /// Insert MI into the instruction list before I, possibly inside a bundle.
595  ///
596  /// If the insertion point is inside a bundle, MI will be added to the bundle,
597  /// otherwise MI will not be added to any bundle. That means this function
598  /// alone can't be used to prepend or append instructions to bundles. See
599  /// MIBundleBuilder::insert() for a more reliable way of doing that.
601 
602  /// Insert a range of instructions into the instruction list before I.
603  template<typename IT>
604  void insert(iterator I, IT S, IT E) {
605  assert((I == end() || I->getParent() == this) &&
606  "iterator points outside of basic block");
607  Insts.insert(I.getInstrIterator(), S, E);
608  }
609 
610  /// Insert MI into the instruction list before I.
612  assert((I == end() || I->getParent() == this) &&
613  "iterator points outside of basic block");
614  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
615  "Cannot insert instruction with bundle flags");
616  return Insts.insert(I.getInstrIterator(), MI);
617  }
618 
619  /// Insert MI into the instruction list after I.
621  assert((I == end() || I->getParent() == this) &&
622  "iterator points outside of basic block");
623  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
624  "Cannot insert instruction with bundle flags");
625  return Insts.insertAfter(I.getInstrIterator(), MI);
626  }
627 
628  /// Remove an instruction from the instruction list and delete it.
629  ///
630  /// If the instruction is part of a bundle, the other instructions in the
631  /// bundle will still be bundled after removing the single instruction.
633 
634  /// Remove an instruction from the instruction list and delete it.
635  ///
636  /// If the instruction is part of a bundle, the other instructions in the
637  /// bundle will still be bundled after removing the single instruction.
639  return erase(instr_iterator(I));
640  }
641 
642  /// Remove a range of instructions from the instruction list and delete them.
644  return Insts.erase(I.getInstrIterator(), E.getInstrIterator());
645  }
646 
647  /// Remove an instruction or bundle from the instruction list and delete it.
648  ///
649  /// If I points to a bundle of instructions, they are all erased.
651  return erase(I, std::next(I));
652  }
653 
654  /// Remove an instruction from the instruction list and delete it.
655  ///
656  /// If I is the head of a bundle of instructions, the whole bundle will be
657  /// erased.
659  return erase(iterator(I));
660  }
661 
662  /// Remove the unbundled instruction from the instruction list without
663  /// deleting it.
664  ///
665  /// This function can not be used to remove bundled instructions, use
666  /// remove_instr to remove individual instructions from a bundle.
668  assert(!I->isBundled() && "Cannot remove bundled instructions");
669  return Insts.remove(instr_iterator(I));
670  }
671 
672  /// Remove the possibly bundled instruction from the instruction list
673  /// without deleting it.
674  ///
675  /// If the instruction is part of a bundle, the other instructions in the
676  /// bundle will still be bundled after removing the single instruction.
677  MachineInstr *remove_instr(MachineInstr *I);
678 
679  void clear() {
680  Insts.clear();
681  }
682 
683  /// Take an instruction from MBB 'Other' at the position From, and insert it
684  /// into this MBB right before 'Where'.
685  ///
686  /// If From points to a bundle of instructions, the whole bundle is moved.
688  // The range splice() doesn't allow noop moves, but this one does.
689  if (Where != From)
690  splice(Where, Other, From, std::next(From));
691  }
692 
693  /// Take a block of instructions from MBB 'Other' in the range [From, To),
694  /// and insert them into this MBB right before 'Where'.
695  ///
696  /// The instruction at 'Where' must not be included in the range of
697  /// instructions to move.
699  iterator From, iterator To) {
700  Insts.splice(Where.getInstrIterator(), Other->Insts,
701  From.getInstrIterator(), To.getInstrIterator());
702  }
703 
704  /// This method unlinks 'this' from the containing function, and returns it,
705  /// but does not delete it.
706  MachineBasicBlock *removeFromParent();
707 
708  /// This method unlinks 'this' from the containing function and deletes it.
709  void eraseFromParent();
710 
711  /// Given a machine basic block that branched to 'Old', change the code and
712  /// CFG so that it branches to 'New' instead.
713  void ReplaceUsesOfBlockWith(MachineBasicBlock *Old, MachineBasicBlock *New);
714 
715  /// Various pieces of code can cause excess edges in the CFG to be inserted.
716  /// If we have proven that MBB can only branch to DestA and DestB, remove any
717  /// other MBB successors from the CFG. DestA and DestB can be null. Besides
718  /// DestA and DestB, retain other edges leading to LandingPads (currently
719  /// there can be only one; we don't check or require that here). Note it is
720  /// possible that DestA and/or DestB are LandingPads.
721  bool CorrectExtraCFGEdges(MachineBasicBlock *DestA,
722  MachineBasicBlock *DestB,
723  bool IsCond);
724 
725  /// Find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE
726  /// and DBG_LABEL instructions. Return UnknownLoc if there is none.
727  DebugLoc findDebugLoc(instr_iterator MBBI);
729  return findDebugLoc(MBBI.getInstrIterator());
730  }
731 
732  /// Find the previous valid DebugLoc preceding MBBI, skipping and DBG_VALUE
733  /// instructions. Return UnknownLoc if there is none.
734  DebugLoc findPrevDebugLoc(instr_iterator MBBI);
736  return findPrevDebugLoc(MBBI.getInstrIterator());
737  }
738 
739  /// Find and return the merged DebugLoc of the branch instructions of the
740  /// block. Return UnknownLoc if there is none.
741  DebugLoc findBranchDebugLoc();
742 
743  /// Possible outcome of a register liveness query to computeRegisterLiveness()
745  LQR_Live, ///< Register is known to be (at least partially) live.
746  LQR_Dead, ///< Register is known to be fully dead.
747  LQR_Unknown ///< Register liveness not decidable from local neighborhood.
748  };
749 
750  /// Return whether (physical) register \p Reg has been defined and not
751  /// killed as of just before \p Before.
752  ///
753  /// Search is localised to a neighborhood of \p Neighborhood instructions
754  /// before (searching for defs or kills) and \p Neighborhood instructions
755  /// after (searching just for defs) \p Before.
756  ///
757  /// \p Reg must be a physical register.
758  LivenessQueryResult computeRegisterLiveness(const TargetRegisterInfo *TRI,
759  unsigned Reg,
760  const_iterator Before,
761  unsigned Neighborhood = 10) const;
762 
763  // Debugging methods.
764  void dump() const;
765  void print(raw_ostream &OS, const SlotIndexes * = nullptr,
766  bool IsStandalone = true) const;
767  void print(raw_ostream &OS, ModuleSlotTracker &MST,
768  const SlotIndexes * = nullptr, bool IsStandalone = true) const;
769 
770  // Printing method used by LoopInfo.
771  void printAsOperand(raw_ostream &OS, bool PrintType = true) const;
772 
773  /// MachineBasicBlocks are uniquely numbered at the function level, unless
774  /// they're not in a MachineFunction yet, in which case this will return -1.
775  int getNumber() const { return Number; }
776  void setNumber(int N) { Number = N; }
777 
778  /// Return the MCSymbol for this basic block.
779  MCSymbol *getSymbol() const;
780 
782  return IrrLoopHeaderWeight;
783  }
784 
785  void setIrrLoopHeaderWeight(uint64_t Weight) {
786  IrrLoopHeaderWeight = Weight;
787  }
788 
789 private:
790  /// Return probability iterator corresponding to the I successor iterator.
791  probability_iterator getProbabilityIterator(succ_iterator I);
792  const_probability_iterator
793  getProbabilityIterator(const_succ_iterator I) const;
794 
796  friend class MIPrinter;
797 
798  /// Return probability of the edge from this block to MBB. This method should
799  /// NOT be called directly, but by using getEdgeProbability method from
800  /// MachineBranchProbabilityInfo class.
801  BranchProbability getSuccProbability(const_succ_iterator Succ) const;
802 
803  // Methods used to maintain doubly linked list of blocks...
805 
806  // Machine-CFG mutators
807 
808  /// Add Pred as a predecessor of this MachineBasicBlock. Don't do this
809  /// unless you know what you're doing, because it doesn't update Pred's
810  /// successors list. Use Pred->addSuccessor instead.
811  void addPredecessor(MachineBasicBlock *Pred);
812 
813  /// Remove Pred as a predecessor of this MachineBasicBlock. Don't do this
814  /// unless you know what you're doing, because it doesn't update Pred's
815  /// successors list. Use Pred->removeSuccessor instead.
816  void removePredecessor(MachineBasicBlock *Pred);
817 };
818 
820 
821 /// Prints a machine basic block reference.
822 ///
823 /// The format is:
824 /// %bb.5 - a machine basic block with MBB.getNumber() == 5.
825 ///
826 /// Usage: OS << printMBBReference(MBB) << '\n';
828 
829 // This is useful when building IndexedMaps keyed on basic block pointers.
832  unsigned operator()(const MachineBasicBlock *MBB) const {
833  return MBB->getNumber();
834  }
835 };
836 
837 //===--------------------------------------------------------------------===//
838 // GraphTraits specializations for machine basic block graphs (machine-CFGs)
839 //===--------------------------------------------------------------------===//
840 
841 // Provide specializations of GraphTraits to be able to treat a
842 // MachineFunction as a graph of MachineBasicBlocks.
843 //
844 
845 template <> struct GraphTraits<MachineBasicBlock *> {
848 
849  static NodeRef getEntryNode(MachineBasicBlock *BB) { return BB; }
851  static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
852 };
853 
854 template <> struct GraphTraits<const MachineBasicBlock *> {
855  using NodeRef = const MachineBasicBlock *;
857 
858  static NodeRef getEntryNode(const MachineBasicBlock *BB) { return BB; }
860  static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
861 };
862 
863 // Provide specializations of GraphTraits to be able to treat a
864 // MachineFunction as a graph of MachineBasicBlocks and to walk it
865 // in inverse order. Inverse order for a function is considered
866 // to be when traversing the predecessor edges of a MBB
867 // instead of the successor edges.
868 //
869 template <> struct GraphTraits<Inverse<MachineBasicBlock*>> {
872 
874  return G.Graph;
875  }
876 
878  static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); }
879 };
880 
882  using NodeRef = const MachineBasicBlock *;
884 
886  return G.Graph;
887  }
888 
890  static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); }
891 };
892 
893 /// MachineInstrSpan provides an interface to get an iteration range
894 /// containing the instruction it was initialized with, along with all
895 /// those instructions inserted prior to or following that instruction
896 /// at some point after the MachineInstrSpan is constructed.
898  MachineBasicBlock &MBB;
900 
901 public:
903  : MBB(*I->getParent()),
904  I(I),
905  B(I == MBB.begin() ? MBB.end() : std::prev(I)),
906  E(std::next(I)) {}
907 
909  return B == MBB.end() ? MBB.begin() : std::next(B);
910  }
912  bool empty() { return begin() == end(); }
913 
915 };
916 
917 /// Increment \p It until it points to a non-debug instruction or to \p End
918 /// and return the resulting iterator. This function should only be used
919 /// MachineBasicBlock::{iterator, const_iterator, instr_iterator,
920 /// const_instr_iterator} and the respective reverse iterators.
921 template<typename IterT>
922 inline IterT skipDebugInstructionsForward(IterT It, IterT End) {
923  while (It != End && It->isDebugInstr())
924  It++;
925  return It;
926 }
927 
928 /// Decrement \p It until it points to a non-debug instruction or to \p Begin
929 /// and return the resulting iterator. This function should only be used
930 /// MachineBasicBlock::{iterator, const_iterator, instr_iterator,
931 /// const_instr_iterator} and the respective reverse iterators.
932 template<class IterT>
933 inline IterT skipDebugInstructionsBackward(IterT It, IterT Begin) {
934  while (It != Begin && It->isDebugInstr())
935  It--;
936  return It;
937 }
938 
939 } // end namespace llvm
940 
941 #endif // LLVM_CODEGEN_MACHINEBASICBLOCK_H
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:80
pred_reverse_iterator pred_rbegin()
const_iterator getLastNonDebugInstr() const
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:233
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
bool hasSuccessorProbabilities() const
Return true if any of the successors have probabilities attached to them.
A common definition of LaneBitmask for use in TableGen and CodeGen.
pred_reverse_iterator pred_rend()
instr_iterator instr_begin()
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:224
instr_iterator instr_end()
iterator erase(iterator where)
Definition: ilist.h:265
bool isEHScopeReturnBlock() const
Convenience function that returns true if the bock ends in a EH scope return instruction.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Various leaf nodes.
Definition: ISDOpcodes.h:59
void addNodeToList(NodeTy *)
When an MBB is added to an MF, we need to update the parent pointer of the MBB, the MBB numbering...
Definition: ilist.h:65
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
const_pred_reverse_iterator pred_rbegin() const
RegisterMaskPair(MCPhysReg PhysReg, LaneBitmask LaneMask)
void setIsEHPad(bool V=true)
Indicates the block is a landing pad.
MachineInstr & instr_front()
const_succ_iterator succ_begin() 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:361
static ChildIteratorType child_begin(NodeRef N)
const_succ_reverse_iterator succ_rbegin() const
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
bool isCleanupFuncletEntry() const
Returns true if this is the entry block of a cleanup funclet.
void setIrrLoopHeaderWeight(uint64_t Weight)
MachineBasicBlock::succ_iterator ChildIteratorType
const_reverse_instr_iterator instr_rbegin() const
unsigned Reg
MachineInstr & instr_back()
iterator_range< iterator > phis()
Returns a range that iterates over the phis in the basic block.
iterator insertAfter(iterator I, MachineInstr *MI)
Insert MI into the instruction list after I.
Template traits for intrusive list.
Definition: ilist.h:89
const_pred_iterator pred_end() const
DebugLoc findDebugLoc(iterator MBBI)
unsigned const TargetRegisterInfo * TRI
A debug info location.
Definition: DebugLoc.h:33
Manage lifetime of a slot tracker for printing IR.
std::vector< MachineBasicBlock * >::const_iterator const_pred_iterator
MachineInstrSpan(MachineBasicBlock::iterator I)
iterator insert(iterator I, MachineInstr *MI)
Insert MI into the instruction list before I.
void setAlignment(unsigned Align)
Set alignment of the basic block.
static ChildIteratorType child_begin(NodeRef N)
iterator_range< succ_iterator > successors()
void splice(iterator Where, MachineBasicBlock *Other, iterator From, iterator To)
Take a block of instructions from MBB &#39;Other&#39; in the range [From, To), and insert them into this MBB ...
const MachineInstr & back() const
MachineInstrSpan provides an interface to get an iteration range containing the instruction it was in...
Definition: BitVector.h:937
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction. ...
MachineBasicBlock::pred_iterator ChildIteratorType
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
static unsigned addLiveIn(MachineFunction &MF, unsigned PReg, const TargetRegisterClass *RC)
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:365
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.
static constexpr LaneBitmask getAll()
Definition: LaneBitmask.h:83
static StringRef getName(Value *V)
iterator_range< iterator > terminators()
LiveInVector::const_iterator livein_iterator
void setIsCleanupFuncletEntry(bool V=true)
Indicates if this is the entry block of a cleanup funclet.
MachineBasicBlock::iterator end()
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:838
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:102
A simple intrusive list implementation.
Definition: simple_ilist.h:78
static ChildIteratorType child_end(NodeRef N)
SlotIndexes pass.
Definition: SlotIndexes.h:328
const_pred_reverse_iterator pred_rend() const
static void normalizeProbabilities(ProbabilityIter Begin, ProbabilityIter End)
const_succ_reverse_iterator succ_rend() const
static Instructions MachineBasicBlock::* getSublistAccess(MachineInstr *)
Support for MachineInstr::getNextNode().
BasicBlock * SplitCriticalEdge(Instruction *TI, unsigned SuccNum, const CriticalEdgeSplittingOptions &Options=CriticalEdgeSplittingOptions())
If this edge is a critical edge, insert a new node to split the critical edge.
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they&#39;re not in a MachineFuncti...
succ_reverse_iterator succ_rend()
reverse_iterator rend()
Expected< const typename ELFT::Sym * > getSymbol(typename ELFT::SymRange Symbols, uint32_t Index)
Definition: ELF.h:336
reverse_iterator rbegin()
void normalizeSuccProbs()
Normalize probabilities of all successors so that the sum of them becomes one.
unsigned operator()(const MachineBasicBlock *MBB) const
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:105
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
void setIsEHScopeEntry(bool V=true)
Indicates if this is the entry block of an EH scope, i.e., the block that that used to have a catchpa...
#define P(N)
std::vector< MachineBasicBlock * >::const_reverse_iterator const_succ_reverse_iterator
An ilist node that can access its parent list.
Definition: ilist_node.h:256
void addLiveIn(MCPhysReg PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
instr_iterator erase_instr(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
const_reverse_iterator rbegin() const
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
static ChildIteratorType child_end(NodeRef N)
succ_reverse_iterator succ_rbegin()
bool isEHScopeEntry() const
Returns true if this is the entry block of an EH scope, i.e., the block that used to have a catchpad ...
static ChildIteratorType child_begin(NodeRef N)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
livein_iterator livein_end() const
unsigned getAlignment() const
Return alignment of the basic block.
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:112
Register is known to be fully dead.
void pop_front()
Definition: ilist.h:312
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:327
This class prints out the machine instructions using the MIR serialization format.
Definition: MIRPrinter.cpp:138
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:115
std::vector< MachineBasicBlock * >::const_iterator const_succ_iterator
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
MachineBasicBlock::const_succ_iterator ChildIteratorType
iterator_range< pred_iterator > predecessors()
std::vector< MachineBasicBlock * >::iterator pred_iterator
LivenessQueryResult
Possible outcome of a register liveness query to computeRegisterLiveness()
Register is known to be (at least partially) live.
bool hasAddressTaken() const
Test whether this block is potentially the target of an indirect branch.
iterator erase(iterator I)
Remove an instruction or bundle from the instruction list and delete it.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
iterator erase(iterator I, iterator E)
Remove a range of instructions from the instruction list and delete them.
An intrusive list with ownership and callbacks specified/controlled by ilist_traits, only with API safe for polymorphic types.
Definition: ilist.h:388
const_iterator begin() const
constexpr bool empty(const T &RangeOrContainer)
Test whether RangeOrContainer is empty. Similar to C++17 std::empty.
Definition: STLExtras.h:209
static BranchProbability getUnknown()
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
print lazy value Lazy Value Info Printer Pass
const MachineInstr & instr_back() const
Iterator for intrusive lists based on ilist_node.
const GraphType & Graph
Definition: GraphTraits.h:96
reverse_instr_iterator instr_rbegin()
iterator_range< const_iterator > phis() const
BlockVerifier::State From
void removeNodeFromList(NodeTy *)
Definition: ilist.h:66
livein_iterator livein_begin_dbg() const
Unlike livein_begin, this method does not check that the liveness information is accurate.
const_instr_iterator instr_end() const
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
iterator_range< livein_iterator > liveins_dbg() const
MachineBasicBlock::iterator getInitial()
void addLiveIn(const RegisterMaskPair &RegMaskPair)
static void deleteNode(NodeTy *V)
Definition: ilist.h:41
unsigned pred_size() const
IterT skipDebugInstructionsBackward(IterT It, IterT Begin)
Decrement It until it points to a non-debug instruction or to Begin and return the resulting iterator...
reverse_instr_iterator instr_rend()
const_iterator getFirstTerminator() const
MachineBasicBlock::const_pred_iterator ChildIteratorType
A range adaptor for a pair of iterators.
static NodeRef getEntryNode(Inverse< MachineBasicBlock *> G)
void push_back(pointer val)
Definition: ilist.h:311
DebugLoc findPrevDebugLoc(iterator MBBI)
const MachineInstr & front() const
void setHasAddressTaken()
Set this block to reflect that it potentially is the target of an indirect branch.
std::vector< MachineBasicBlock * >::const_reverse_iterator const_pred_reverse_iterator
MachineFunction * getParent()
unsigned succ_size() const
IterT skipDebugInstructionsForward(IterT It, IterT End)
Increment It until it points to a non-debug instruction or to End and return the resulting iterator...
iterator_range< const_succ_iterator > successors() const
void setIsEHFuncletEntry(bool V=true)
Indicates if this is the entry block of an EH funclet.
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")))
iterator_range< const_pred_iterator > predecessors() const
Representation of each machine instruction.
Definition: MachineInstr.h:63
pointer remove(iterator &IT)
Definition: ilist.h:249
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
iterator insert(iterator where, pointer New)
Definition: ilist.h:226
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB &#39;Other&#39; at the position From, and insert it into this MBB right before &#39;...
void clear()
Definition: ilist.h:307
std::vector< MachineBasicBlock * >::reverse_iterator pred_reverse_iterator
bool isEHPad() const
Returns true if the block is a landing pad.
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
static NodeRef getEntryNode(const MachineBasicBlock *BB)
static NodeRef getEntryNode(Inverse< const MachineBasicBlock *> G)
void push_back(MachineInstr *MI)
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
Pair of physical register and lane mask.
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
const_instr_iterator instr_begin() const
const_iterator end() const
const_succ_iterator succ_end() const
std::vector< MachineBasicBlock * >::reverse_iterator succ_reverse_iterator
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2038
iterator_range< livein_iterator > liveins() const
Instructions::iterator instr_iterator
const_iterator getFirstNonDebugInstr() const
iterator_range< const_iterator > terminators() const
Optional< uint64_t > getIrrLoopHeaderWeight() const
const_reverse_instr_iterator instr_rend() const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static ChildIteratorType child_end(NodeRef N)
aarch64 promote const
const_instr_range instrs() const
static const Function * getParent(const Value *V)
const_pred_iterator pred_begin() const
Callbacks do nothing by default in iplist and ilist.
Definition: ilist.h:64
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Simple wrapper around std::function<void(raw_ostream&)>.
Definition: Printable.h:37
void pop_back()
Definition: ilist.h:316
iterator insertAfter(iterator where, pointer New)
Definition: ilist.h:235
Instructions::const_iterator const_instr_iterator
const_reverse_iterator rend() const
std::vector< MachineBasicBlock * >::iterator succ_iterator
const MachineInstr & instr_front() const
static NodeRef getEntryNode(MachineBasicBlock *BB)
void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator)
Callback before transferring nodes to this list.
Definition: ilist.h:71
MachineBasicBlock::iterator begin()