LLVM  13.0.0git
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"
22 #include "llvm/IR/DebugLoc.h"
23 #include "llvm/MC/LaneBitmask.h"
25 #include <cassert>
26 #include <cstdint>
27 #include <functional>
28 #include <iterator>
29 #include <string>
30 #include <vector>
31 
32 namespace llvm {
33 
34 class BasicBlock;
35 class MachineFunction;
36 class MCSymbol;
37 class ModuleSlotTracker;
38 class Pass;
39 class Printable;
40 class SlotIndexes;
41 class StringRef;
42 class raw_ostream;
43 class LiveIntervals;
44 class TargetRegisterClass;
45 class TargetRegisterInfo;
46 
47 // This structure uniquely identifies a basic block section.
48 // Possible values are
49 // {Type: Default, Number: (unsigned)} (These are regular section IDs)
50 // {Type: Exception, Number: 0} (ExceptionSectionID)
51 // {Type: Cold, Number: 0} (ColdSectionID)
52 struct MBBSectionID {
53  enum SectionType {
54  Default = 0, // Regular section (these sections are distinguished by the
55  // Number field).
56  Exception, // Special section type for exception handling blocks
57  Cold, // Special section type for cold blocks
58  } Type;
59  unsigned Number;
60 
61  MBBSectionID(unsigned N) : Type(Default), Number(N) {}
62 
63  // Special unique sections for cold and exception blocks.
66 
67  bool operator==(const MBBSectionID &Other) const {
68  return Type == Other.Type && Number == Other.Number;
69  }
70 
71  bool operator!=(const MBBSectionID &Other) const { return !(*this == Other); }
72 
73 private:
74  // This is only used to construct the special cold and exception sections.
75  MBBSectionID(SectionType T) : Type(T), Number(0) {}
76 };
77 
78 template <> struct ilist_traits<MachineInstr> {
79 private:
80  friend class MachineBasicBlock; // Set by the owning MachineBasicBlock.
81 
82  MachineBasicBlock *Parent;
83 
84  using instr_iterator =
86 
87 public:
91  instr_iterator Last);
92  void deleteNode(MachineInstr *MI);
93 };
94 
96  : public ilist_node_with_parent<MachineBasicBlock, MachineFunction> {
97 public:
98  /// Pair of physical register and lane mask.
99  /// This is not simply a std::pair typedef because the members should be named
100  /// clearly as they both have an integer type.
102  public:
105 
108  };
109 
110 private:
112 
113  Instructions Insts;
114  const BasicBlock *BB;
115  int Number;
116  MachineFunction *xParent;
117 
118  /// Keep track of the predecessor / successor basic blocks.
119  std::vector<MachineBasicBlock *> Predecessors;
120  std::vector<MachineBasicBlock *> Successors;
121 
122  /// Keep track of the probabilities to the successors. This vector has the
123  /// same order as Successors, or it is empty if we don't use it (disable
124  /// optimization).
125  std::vector<BranchProbability> Probs;
126  using probability_iterator = std::vector<BranchProbability>::iterator;
127  using const_probability_iterator =
128  std::vector<BranchProbability>::const_iterator;
129 
130  Optional<uint64_t> IrrLoopHeaderWeight;
131 
132  /// Keep track of the physical registers that are livein of the basicblock.
133  using LiveInVector = std::vector<RegisterMaskPair>;
134  LiveInVector LiveIns;
135 
136  /// Alignment of the basic block. One if the basic block does not need to be
137  /// aligned.
138  Align Alignment;
139 
140  /// Indicate that this basic block is entered via an exception handler.
141  bool IsEHPad = false;
142 
143  /// Indicate that this basic block is potentially the target of an indirect
144  /// branch.
145  bool AddressTaken = false;
146 
147  /// Indicate that this basic block needs its symbol be emitted regardless of
148  /// whether the flow just falls-through to it.
149  bool LabelMustBeEmitted = false;
150 
151  /// Indicate that this basic block is the entry block of an EH scope, i.e.,
152  /// the block that used to have a catchpad or cleanuppad instruction in the
153  /// LLVM IR.
154  bool IsEHScopeEntry = false;
155 
156  /// Indicates if this is a target block of a catchret.
157  bool IsEHCatchretTarget = false;
158 
159  /// Indicate that this basic block is the entry block of an EH funclet.
160  bool IsEHFuncletEntry = false;
161 
162  /// Indicate that this basic block is the entry block of a cleanup funclet.
163  bool IsCleanupFuncletEntry = false;
164 
165  /// With basic block sections, this stores the Section ID of the basic block.
166  MBBSectionID SectionID{0};
167 
168  // Indicate that this basic block begins a section.
169  bool IsBeginSection = false;
170 
171  // Indicate that this basic block ends a section.
172  bool IsEndSection = false;
173 
174  /// Indicate that this basic block is the indirect dest of an INLINEASM_BR.
175  bool IsInlineAsmBrIndirectTarget = false;
176 
177  /// since getSymbol is a relatively heavy-weight operation, the symbol
178  /// is only computed once and is cached.
179  mutable MCSymbol *CachedMCSymbol = nullptr;
180 
181  /// Cached MCSymbol for this block (used if IsEHCatchRetTarget).
182  mutable MCSymbol *CachedEHCatchretMCSymbol = nullptr;
183 
184  /// Marks the end of the basic block. Used during basic block sections to
185  /// calculate the size of the basic block, or the BB section ending with it.
186  mutable MCSymbol *CachedEndMCSymbol = nullptr;
187 
188  // Intrusive list support
189  MachineBasicBlock() = default;
190 
191  explicit MachineBasicBlock(MachineFunction &MF, const BasicBlock *BB);
192 
193  ~MachineBasicBlock();
194 
195  // MachineBasicBlocks are allocated and owned by MachineFunction.
196  friend class MachineFunction;
197 
198 public:
199  /// Return the LLVM basic block that this instance corresponded to originally.
200  /// Note that this may be NULL if this instance does not correspond directly
201  /// to an LLVM basic block.
202  const BasicBlock *getBasicBlock() const { return BB; }
203 
204  /// Return the name of the corresponding LLVM basic block, or an empty string.
205  StringRef getName() const;
206 
207  /// Return a formatted string to identify this block and its parent function.
208  std::string getFullName() const;
209 
210  /// Test whether this block is potentially the target of an indirect branch.
211  bool hasAddressTaken() const { return AddressTaken; }
212 
213  /// Set this block to reflect that it potentially is the target of an indirect
214  /// branch.
215  void setHasAddressTaken() { AddressTaken = true; }
216 
217  /// Test whether this block must have its label emitted.
218  bool hasLabelMustBeEmitted() const { return LabelMustBeEmitted; }
219 
220  /// Set this block to reflect that, regardless how we flow to it, we need
221  /// its label be emitted.
222  void setLabelMustBeEmitted() { LabelMustBeEmitted = true; }
223 
224  /// Return the MachineFunction containing this basic block.
225  const MachineFunction *getParent() const { return xParent; }
226  MachineFunction *getParent() { return xParent; }
227 
232 
236  using const_reverse_iterator =
238 
239  unsigned size() const { return (unsigned)Insts.size(); }
240  bool empty() const { return Insts.empty(); }
241 
242  MachineInstr &instr_front() { return Insts.front(); }
243  MachineInstr &instr_back() { return Insts.back(); }
244  const MachineInstr &instr_front() const { return Insts.front(); }
245  const MachineInstr &instr_back() const { return Insts.back(); }
246 
247  MachineInstr &front() { return Insts.front(); }
248  MachineInstr &back() { return *--end(); }
249  const MachineInstr &front() const { return Insts.front(); }
250  const MachineInstr &back() const { return *--end(); }
251 
252  instr_iterator instr_begin() { return Insts.begin(); }
253  const_instr_iterator instr_begin() const { return Insts.begin(); }
254  instr_iterator instr_end() { return Insts.end(); }
255  const_instr_iterator instr_end() const { return Insts.end(); }
256  reverse_instr_iterator instr_rbegin() { return Insts.rbegin(); }
257  const_reverse_instr_iterator instr_rbegin() const { return Insts.rbegin(); }
258  reverse_instr_iterator instr_rend () { return Insts.rend(); }
259  const_reverse_instr_iterator instr_rend () const { return Insts.rend(); }
260 
266  }
267 
268  iterator begin() { return instr_begin(); }
269  const_iterator begin() const { return instr_begin(); }
270  iterator end () { return instr_end(); }
271  const_iterator end () const { return instr_end(); }
274  }
277  }
281  }
282 
283  /// Support for MachineInstr::getNextNode().
285  return &MachineBasicBlock::Insts;
286  }
287 
289  return make_range(getFirstTerminator(), end());
290  }
292  return make_range(getFirstTerminator(), end());
293  }
294 
295  /// Returns a range that iterates over the phis in the basic block.
297  return make_range(begin(), getFirstNonPHI());
298  }
300  return const_cast<MachineBasicBlock *>(this)->phis();
301  }
302 
303  // Machine-CFG iterators
304  using pred_iterator = std::vector<MachineBasicBlock *>::iterator;
305  using const_pred_iterator = std::vector<MachineBasicBlock *>::const_iterator;
306  using succ_iterator = std::vector<MachineBasicBlock *>::iterator;
307  using const_succ_iterator = std::vector<MachineBasicBlock *>::const_iterator;
308  using pred_reverse_iterator =
309  std::vector<MachineBasicBlock *>::reverse_iterator;
311  std::vector<MachineBasicBlock *>::const_reverse_iterator;
312  using succ_reverse_iterator =
313  std::vector<MachineBasicBlock *>::reverse_iterator;
315  std::vector<MachineBasicBlock *>::const_reverse_iterator;
316  pred_iterator pred_begin() { return Predecessors.begin(); }
317  const_pred_iterator pred_begin() const { return Predecessors.begin(); }
318  pred_iterator pred_end() { return Predecessors.end(); }
319  const_pred_iterator pred_end() const { return Predecessors.end(); }
321  { return Predecessors.rbegin();}
323  { return Predecessors.rbegin();}
325  { return Predecessors.rend(); }
327  { return Predecessors.rend(); }
328  unsigned pred_size() const {
329  return (unsigned)Predecessors.size();
330  }
331  bool pred_empty() const { return Predecessors.empty(); }
332  succ_iterator succ_begin() { return Successors.begin(); }
333  const_succ_iterator succ_begin() const { return Successors.begin(); }
334  succ_iterator succ_end() { return Successors.end(); }
335  const_succ_iterator succ_end() const { return Successors.end(); }
337  { return Successors.rbegin(); }
339  { return Successors.rbegin(); }
341  { return Successors.rend(); }
343  { return Successors.rend(); }
344  unsigned succ_size() const {
345  return (unsigned)Successors.size();
346  }
347  bool succ_empty() const { return Successors.empty(); }
348 
350  return make_range(pred_begin(), pred_end());
351  }
353  return make_range(pred_begin(), pred_end());
354  }
356  return make_range(succ_begin(), succ_end());
357  }
359  return make_range(succ_begin(), succ_end());
360  }
361 
362  // LiveIn management methods.
363 
364  /// Adds the specified register as a live in. Note that it is an error to add
365  /// the same register to the same set more than once unless the intention is
366  /// to call sortUniqueLiveIns after all registers are added.
367  void addLiveIn(MCRegister PhysReg,
368  LaneBitmask LaneMask = LaneBitmask::getAll()) {
369  LiveIns.push_back(RegisterMaskPair(PhysReg, LaneMask));
370  }
371  void addLiveIn(const RegisterMaskPair &RegMaskPair) {
372  LiveIns.push_back(RegMaskPair);
373  }
374 
375  /// Sorts and uniques the LiveIns vector. It can be significantly faster to do
376  /// this than repeatedly calling isLiveIn before calling addLiveIn for every
377  /// LiveIn insertion.
378  void sortUniqueLiveIns();
379 
380  /// Clear live in list.
381  void clearLiveIns();
382 
383  /// Add PhysReg as live in to this block, and ensure that there is a copy of
384  /// PhysReg to a virtual register of class RC. Return the virtual register
385  /// that is a copy of the live in PhysReg.
386  Register addLiveIn(MCRegister PhysReg, const TargetRegisterClass *RC);
387 
388  /// Remove the specified register from the live in set.
390  LaneBitmask LaneMask = LaneBitmask::getAll());
391 
392  /// Return true if the specified register is in the live in set.
393  bool isLiveIn(MCPhysReg Reg,
394  LaneBitmask LaneMask = LaneBitmask::getAll()) const;
395 
396  // Iteration support for live in sets. These sets are kept in sorted
397  // order by their register number.
398  using livein_iterator = LiveInVector::const_iterator;
399 #ifndef NDEBUG
400  /// Unlike livein_begin, this method does not check that the liveness
401  /// information is accurate. Still for debug purposes it may be useful
402  /// to have iterators that won't assert if the liveness information
403  /// is not current.
404  livein_iterator livein_begin_dbg() const { return LiveIns.begin(); }
407  }
408 #endif
410  livein_iterator livein_end() const { return LiveIns.end(); }
411  bool livein_empty() const { return LiveIns.empty(); }
413  return make_range(livein_begin(), livein_end());
414  }
415 
416  /// Remove entry from the livein set and return iterator to the next.
418 
419  /// Get the clobber mask for the start of this basic block. Funclets use this
420  /// to prevent register allocation across funclet transitions.
421  const uint32_t *getBeginClobberMask(const TargetRegisterInfo *TRI) const;
422 
423  /// Get the clobber mask for the end of the basic block.
424  /// \see getBeginClobberMask()
425  const uint32_t *getEndClobberMask(const TargetRegisterInfo *TRI) const;
426 
427  /// Return alignment of the basic block.
428  Align getAlignment() const { return Alignment; }
429 
430  /// Set alignment of the basic block.
431  void setAlignment(Align A) { Alignment = A; }
432 
433  /// Returns true if the block is a landing pad. That is this basic block is
434  /// entered via an exception handler.
435  bool isEHPad() const { return IsEHPad; }
436 
437  /// Indicates the block is a landing pad. That is this basic block is entered
438  /// via an exception handler.
439  void setIsEHPad(bool V = true) { IsEHPad = V; }
440 
441  bool hasEHPadSuccessor() const;
442 
443  /// Returns true if this is the entry block of the function.
444  bool isEntryBlock() const;
445 
446  /// Returns true if this is the entry block of an EH scope, i.e., the block
447  /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
448  bool isEHScopeEntry() const { return IsEHScopeEntry; }
449 
450  /// Indicates if this is the entry block of an EH scope, i.e., the block that
451  /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
452  void setIsEHScopeEntry(bool V = true) { IsEHScopeEntry = V; }
453 
454  /// Returns true if this is a target block of a catchret.
455  bool isEHCatchretTarget() const { return IsEHCatchretTarget; }
456 
457  /// Indicates if this is a target block of a catchret.
458  void setIsEHCatchretTarget(bool V = true) { IsEHCatchretTarget = V; }
459 
460  /// Returns true if this is the entry block of an EH funclet.
461  bool isEHFuncletEntry() const { return IsEHFuncletEntry; }
462 
463  /// Indicates if this is the entry block of an EH funclet.
464  void setIsEHFuncletEntry(bool V = true) { IsEHFuncletEntry = V; }
465 
466  /// Returns true if this is the entry block of a cleanup funclet.
467  bool isCleanupFuncletEntry() const { return IsCleanupFuncletEntry; }
468 
469  /// Indicates if this is the entry block of a cleanup funclet.
470  void setIsCleanupFuncletEntry(bool V = true) { IsCleanupFuncletEntry = V; }
471 
472  /// Returns true if this block begins any section.
473  bool isBeginSection() const { return IsBeginSection; }
474 
475  /// Returns true if this block ends any section.
476  bool isEndSection() const { return IsEndSection; }
477 
478  void setIsBeginSection(bool V = true) { IsBeginSection = V; }
479 
480  void setIsEndSection(bool V = true) { IsEndSection = V; }
481 
482  /// Returns the section ID of this basic block.
483  MBBSectionID getSectionID() const { return SectionID; }
484 
485  /// Returns the unique section ID number of this basic block.
486  unsigned getSectionIDNum() const {
487  return ((unsigned)MBBSectionID::SectionType::Cold) -
488  ((unsigned)SectionID.Type) + SectionID.Number;
489  }
490 
491  /// Sets the section ID for this basic block.
492  void setSectionID(MBBSectionID V) { SectionID = V; }
493 
494  /// Returns the MCSymbol marking the end of this basic block.
495  MCSymbol *getEndSymbol() const;
496 
497  /// Returns true if this block may have an INLINEASM_BR (overestimate, by
498  /// checking if any of the successors are indirect targets of any inlineasm_br
499  /// in the function).
500  bool mayHaveInlineAsmBr() const;
501 
502  /// Returns true if this is the indirect dest of an INLINEASM_BR.
504  return IsInlineAsmBrIndirectTarget;
505  }
506 
507  /// Indicates if this is the indirect dest of an INLINEASM_BR.
508  void setIsInlineAsmBrIndirectTarget(bool V = true) {
509  IsInlineAsmBrIndirectTarget = V;
510  }
511 
512  /// Returns true if it is legal to hoist instructions into this block.
513  bool isLegalToHoistInto() const;
514 
515  // Code Layout methods.
516 
517  /// Move 'this' block before or after the specified block. This only moves
518  /// the block, it does not modify the CFG or adjust potential fall-throughs at
519  /// the end of the block.
520  void moveBefore(MachineBasicBlock *NewAfter);
521  void moveAfter(MachineBasicBlock *NewBefore);
522 
523  /// Returns true if this and MBB belong to the same section.
524  bool sameSection(const MachineBasicBlock *MBB) const {
525  return getSectionID() == MBB->getSectionID();
526  }
527 
528  /// Update the terminator instructions in block to account for changes to
529  /// block layout which may have been made. PreviousLayoutSuccessor should be
530  /// set to the block which may have been used as fallthrough before the block
531  /// layout was modified. If the block previously fell through to that block,
532  /// it may now need a branch. If it previously branched to another block, it
533  /// may now be able to fallthrough to the current layout successor.
534  void updateTerminator(MachineBasicBlock *PreviousLayoutSuccessor);
535 
536  // Machine-CFG mutators
537 
538  /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
539  /// of Succ is automatically updated. PROB parameter is stored in
540  /// Probabilities list. The default probability is set as unknown. Mixing
541  /// known and unknown probabilities in successor list is not allowed. When all
542  /// successors have unknown probabilities, 1 / N is returned as the
543  /// probability for each successor, where N is the number of successors.
544  ///
545  /// Note that duplicate Machine CFG edges are not allowed.
546  void addSuccessor(MachineBasicBlock *Succ,
548 
549  /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
550  /// of Succ is automatically updated. The probability is not provided because
551  /// BPI is not available (e.g. -O0 is used), in which case edge probabilities
552  /// won't be used. Using this interface can save some space.
554 
555  /// Set successor probability of a given iterator.
557 
558  /// Normalize probabilities of all successors so that the sum of them becomes
559  /// one. This is usually done when the current update on this MBB is done, and
560  /// the sum of its successors' probabilities is not guaranteed to be one. The
561  /// user is responsible for the correct use of this function.
562  /// MBB::removeSuccessor() has an option to do this automatically.
564  BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
565  }
566 
567  /// Validate successors' probabilities and check if the sum of them is
568  /// approximate one. This only works in DEBUG mode.
569  void validateSuccProbs() const;
570 
571  /// Remove successor from the successors list of this MachineBasicBlock. The
572  /// Predecessors list of Succ is automatically updated.
573  /// If NormalizeSuccProbs is true, then normalize successors' probabilities
574  /// after the successor is removed.
576  bool NormalizeSuccProbs = false);
577 
578  /// Remove specified successor from the successors list of this
579  /// MachineBasicBlock. The Predecessors list of Succ is automatically updated.
580  /// If NormalizeSuccProbs is true, then normalize successors' probabilities
581  /// after the successor is removed.
582  /// Return the iterator to the element after the one removed.
584  bool NormalizeSuccProbs = false);
585 
586  /// Replace successor OLD with NEW and update probability info.
588 
589  /// Copy a successor (and any probability info) from original block to this
590  /// block's. Uses an iterator into the original blocks successors.
591  ///
592  /// This is useful when doing a partial clone of successors. Afterward, the
593  /// probabilities may need to be normalized.
595 
596  /// Split the old successor into old plus new and updates the probability
597  /// info.
599  bool NormalizeSuccProbs = false);
600 
601  /// Transfers all the successors from MBB to this machine basic block (i.e.,
602  /// copies all the successors FromMBB and remove all the successors from
603  /// FromMBB).
604  void transferSuccessors(MachineBasicBlock *FromMBB);
605 
606  /// Transfers all the successors, as in transferSuccessors, and update PHI
607  /// operands in the successor blocks which refer to FromMBB to refer to this.
609 
610  /// move all pseudo probes in this block to the end of /c ToMBB To and tag
611  /// them dangling.
613 
614  /// Return true if any of the successors have probabilities attached to them.
615  bool hasSuccessorProbabilities() const { return !Probs.empty(); }
616 
617  /// Return true if the specified MBB is a predecessor of this block.
618  bool isPredecessor(const MachineBasicBlock *MBB) const;
619 
620  /// Return true if the specified MBB is a successor of this block.
621  bool isSuccessor(const MachineBasicBlock *MBB) const;
622 
623  /// Return true if the specified MBB will be emitted immediately after this
624  /// block, such that if this block exits by falling through, control will
625  /// transfer to the specified MBB. Note that MBB need not be a successor at
626  /// all, for example if this block ends with an unconditional branch to some
627  /// other block.
628  bool isLayoutSuccessor(const MachineBasicBlock *MBB) const;
629 
630  /// Return the fallthrough block if the block can implicitly
631  /// transfer control to the block after it by falling off the end of
632  /// it. This should return null if it can reach the block after
633  /// it, but it uses an explicit branch to do so (e.g., a table
634  /// jump). Non-null return is a conservative answer.
636 
637  /// Return true if the block can implicitly transfer control to the
638  /// block after it by falling off the end of it. This should return
639  /// false if it can reach the block after it, but it uses an
640  /// explicit branch to do so (e.g., a table jump). True is a
641  /// conservative answer.
642  bool canFallThrough();
643 
644  /// Returns a pointer to the first instruction in this block that is not a
645  /// PHINode instruction. When adding instructions to the beginning of the
646  /// basic block, they should be added before the returned value, not before
647  /// the first instruction, which might be PHI.
648  /// Returns end() is there's no non-PHI instruction.
650 
651  /// Return the first instruction in MBB after I that is not a PHI or a label.
652  /// This is the correct point to insert lowered copies at the beginning of a
653  /// basic block that must be before any debugging information.
655 
656  /// Return the first instruction in MBB after I that is not a PHI, label or
657  /// debug. This is the correct point to insert copies at the beginning of a
658  /// basic block.
659  iterator SkipPHIsLabelsAndDebug(iterator I, bool SkipPseudoOp = true);
660 
661  /// Returns an iterator to the first terminator instruction of this basic
662  /// block. If a terminator does not exist, it returns end().
665  return const_cast<MachineBasicBlock *>(this)->getFirstTerminator();
666  }
667 
668  /// Same getFirstTerminator but it ignores bundles and return an
669  /// instr_iterator instead.
671 
672  /// Returns an iterator to the first non-debug instruction in the basic block,
673  /// or end(). Skip any pseudo probe operation if \c SkipPseudoOp is true.
674  /// Pseudo probes are like debug instructions which do not turn into real
675  /// machine code. We try to use the function to skip both debug instructions
676  /// and pseudo probe operations to avoid API proliferation. This should work
677  /// most of the time when considering optimizing the rest of code in the
678  /// block, except for certain cases where pseudo probes are designed to block
679  /// the optimizations. For example, code merge like optimizations are supposed
680  /// to be blocked by pseudo probes for better AutoFDO profile quality.
681  /// Therefore, they should be considered as a valid instruction when this
682  /// function is called in a context of such optimizations. On the other hand,
683  /// \c SkipPseudoOp should be true when it's used in optimizations that
684  /// unlikely hurt profile quality, e.g., without block merging. The default
685  /// value of \c SkipPseudoOp is set to true to maximize code quality in
686  /// general, with an explict false value passed in in a few places like branch
687  /// folding and if-conversion to favor profile quality.
688  iterator getFirstNonDebugInstr(bool SkipPseudoOp = true);
689  const_iterator getFirstNonDebugInstr(bool SkipPseudoOp = true) const {
690  return const_cast<MachineBasicBlock *>(this)->getFirstNonDebugInstr(
691  SkipPseudoOp);
692  }
693 
694  /// Returns an iterator to the last non-debug instruction in the basic block,
695  /// or end(). Skip any pseudo operation if \c SkipPseudoOp is true.
696  /// Pseudo probes are like debug instructions which do not turn into real
697  /// machine code. We try to use the function to skip both debug instructions
698  /// and pseudo probe operations to avoid API proliferation. This should work
699  /// most of the time when considering optimizing the rest of code in the
700  /// block, except for certain cases where pseudo probes are designed to block
701  /// the optimizations. For example, code merge like optimizations are supposed
702  /// to be blocked by pseudo probes for better AutoFDO profile quality.
703  /// Therefore, they should be considered as a valid instruction when this
704  /// function is called in a context of such optimizations. On the other hand,
705  /// \c SkipPseudoOp should be true when it's used in optimizations that
706  /// unlikely hurt profile quality, e.g., without block merging. The default
707  /// value of \c SkipPseudoOp is set to true to maximize code quality in
708  /// general, with an explict false value passed in in a few places like branch
709  /// folding and if-conversion to favor profile quality.
710  iterator getLastNonDebugInstr(bool SkipPseudoOp = true);
711  const_iterator getLastNonDebugInstr(bool SkipPseudoOp = true) const {
712  return const_cast<MachineBasicBlock *>(this)->getLastNonDebugInstr(
713  SkipPseudoOp);
714  }
715 
716  /// Convenience function that returns true if the block ends in a return
717  /// instruction.
718  bool isReturnBlock() const {
719  return !empty() && back().isReturn();
720  }
721 
722  /// Convenience function that returns true if the bock ends in a EH scope
723  /// return instruction.
724  bool isEHScopeReturnBlock() const {
725  return !empty() && back().isEHScopeReturn();
726  }
727 
728  /// Split a basic block into 2 pieces at \p SplitPoint. A new block will be
729  /// inserted after this block, and all instructions after \p SplitInst moved
730  /// to it (\p SplitInst will be in the original block). If \p LIS is provided,
731  /// LiveIntervals will be appropriately updated. \return the newly inserted
732  /// block.
733  ///
734  /// If \p UpdateLiveIns is true, this will ensure the live ins list is
735  /// accurate, including for physreg uses/defs in the original block.
736  MachineBasicBlock *splitAt(MachineInstr &SplitInst, bool UpdateLiveIns = true,
737  LiveIntervals *LIS = nullptr);
738 
739  /// Split the critical edge from this block to the given successor block, and
740  /// return the newly created block, or null if splitting is not possible.
741  ///
742  /// This function updates LiveVariables, MachineDominatorTree, and
743  /// MachineLoopInfo, as applicable.
746  std::vector<SparseBitVector<>> *LiveInSets = nullptr);
747 
748  /// Check if the edge between this block and the given successor \p
749  /// Succ, can be split. If this returns true a subsequent call to
750  /// SplitCriticalEdge is guaranteed to return a valid basic block if
751  /// no changes occurred in the meantime.
752  bool canSplitCriticalEdge(const MachineBasicBlock *Succ) const;
753 
754  void pop_front() { Insts.pop_front(); }
755  void pop_back() { Insts.pop_back(); }
756  void push_back(MachineInstr *MI) { Insts.push_back(MI); }
757 
758  /// Insert MI into the instruction list before I, possibly inside a bundle.
759  ///
760  /// If the insertion point is inside a bundle, MI will be added to the bundle,
761  /// otherwise MI will not be added to any bundle. That means this function
762  /// alone can't be used to prepend or append instructions to bundles. See
763  /// MIBundleBuilder::insert() for a more reliable way of doing that.
765 
766  /// Insert a range of instructions into the instruction list before I.
767  template<typename IT>
768  void insert(iterator I, IT S, IT E) {
769  assert((I == end() || I->getParent() == this) &&
770  "iterator points outside of basic block");
771  Insts.insert(I.getInstrIterator(), S, E);
772  }
773 
774  /// Insert MI into the instruction list before I.
776  assert((I == end() || I->getParent() == this) &&
777  "iterator points outside of basic block");
778  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
779  "Cannot insert instruction with bundle flags");
780  return Insts.insert(I.getInstrIterator(), MI);
781  }
782 
783  /// Insert MI into the instruction list after I.
785  assert((I == end() || I->getParent() == this) &&
786  "iterator points outside of basic block");
787  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
788  "Cannot insert instruction with bundle flags");
789  return Insts.insertAfter(I.getInstrIterator(), MI);
790  }
791 
792  /// If I is bundled then insert MI into the instruction list after the end of
793  /// the bundle, otherwise insert MI immediately after I.
795  assert((I == instr_end() || I->getParent() == this) &&
796  "iterator points outside of basic block");
797  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
798  "Cannot insert instruction with bundle flags");
799  while (I->isBundledWithSucc())
800  ++I;
801  return Insts.insertAfter(I, MI);
802  }
803 
804  /// Remove an instruction from the instruction list and delete it.
805  ///
806  /// If the instruction is part of a bundle, the other instructions in the
807  /// bundle will still be bundled after removing the single instruction.
809 
810  /// Remove an instruction from the instruction list and delete it.
811  ///
812  /// If the instruction is part of a bundle, the other instructions in the
813  /// bundle will still be bundled after removing the single instruction.
815  return erase(instr_iterator(I));
816  }
817 
818  /// Remove a range of instructions from the instruction list and delete them.
820  return Insts.erase(I.getInstrIterator(), E.getInstrIterator());
821  }
822 
823  /// Remove an instruction or bundle from the instruction list and delete it.
824  ///
825  /// If I points to a bundle of instructions, they are all erased.
827  return erase(I, std::next(I));
828  }
829 
830  /// Remove an instruction from the instruction list and delete it.
831  ///
832  /// If I is the head of a bundle of instructions, the whole bundle will be
833  /// erased.
835  return erase(iterator(I));
836  }
837 
838  /// Remove the unbundled instruction from the instruction list without
839  /// deleting it.
840  ///
841  /// This function can not be used to remove bundled instructions, use
842  /// remove_instr to remove individual instructions from a bundle.
844  assert(!I->isBundled() && "Cannot remove bundled instructions");
845  return Insts.remove(instr_iterator(I));
846  }
847 
848  /// Remove the possibly bundled instruction from the instruction list
849  /// without deleting it.
850  ///
851  /// If the instruction is part of a bundle, the other instructions in the
852  /// bundle will still be bundled after removing the single instruction.
854 
855  void clear() {
856  Insts.clear();
857  }
858 
859  /// Take an instruction from MBB 'Other' at the position From, and insert it
860  /// into this MBB right before 'Where'.
861  ///
862  /// If From points to a bundle of instructions, the whole bundle is moved.
864  // The range splice() doesn't allow noop moves, but this one does.
865  if (Where != From)
866  splice(Where, Other, From, std::next(From));
867  }
868 
869  /// Take a block of instructions from MBB 'Other' in the range [From, To),
870  /// and insert them into this MBB right before 'Where'.
871  ///
872  /// The instruction at 'Where' must not be included in the range of
873  /// instructions to move.
875  iterator From, iterator To) {
876  Insts.splice(Where.getInstrIterator(), Other->Insts,
877  From.getInstrIterator(), To.getInstrIterator());
878  }
879 
880  /// This method unlinks 'this' from the containing function, and returns it,
881  /// but does not delete it.
883 
884  /// This method unlinks 'this' from the containing function and deletes it.
885  void eraseFromParent();
886 
887  /// Given a machine basic block that branched to 'Old', change the code and
888  /// CFG so that it branches to 'New' instead.
890 
891  /// Update all phi nodes in this basic block to refer to basic block \p New
892  /// instead of basic block \p Old.
894 
895  /// Find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE
896  /// and DBG_LABEL instructions. Return UnknownLoc if there is none.
899  return findDebugLoc(MBBI.getInstrIterator());
900  }
901 
902  /// Has exact same behavior as @ref findDebugLoc (it also
903  /// searches from the first to the last MI of this MBB) except
904  /// that this takes reverse iterator.
907  return rfindDebugLoc(MBBI.getInstrIterator());
908  }
909 
910  /// Find the previous valid DebugLoc preceding MBBI, skipping and DBG_VALUE
911  /// instructions. Return UnknownLoc if there is none.
914  return findPrevDebugLoc(MBBI.getInstrIterator());
915  }
916 
917  /// Has exact same behavior as @ref findPrevDebugLoc (it also
918  /// searches from the last to the first MI of this MBB) except
919  /// that this takes reverse iterator.
922  return rfindPrevDebugLoc(MBBI.getInstrIterator());
923  }
924 
925  /// Find and return the merged DebugLoc of the branch instructions of the
926  /// block. Return UnknownLoc if there is none.
928 
929  /// Possible outcome of a register liveness query to computeRegisterLiveness()
931  LQR_Live, ///< Register is known to be (at least partially) live.
932  LQR_Dead, ///< Register is known to be fully dead.
933  LQR_Unknown ///< Register liveness not decidable from local neighborhood.
934  };
935 
936  /// Return whether (physical) register \p Reg has been defined and not
937  /// killed as of just before \p Before.
938  ///
939  /// Search is localised to a neighborhood of \p Neighborhood instructions
940  /// before (searching for defs or kills) and \p Neighborhood instructions
941  /// after (searching just for defs) \p Before.
942  ///
943  /// \p Reg must be a physical register.
945  MCRegister Reg,
946  const_iterator Before,
947  unsigned Neighborhood = 10) const;
948 
949  // Debugging methods.
950  void dump() const;
951  void print(raw_ostream &OS, const SlotIndexes * = nullptr,
952  bool IsStandalone = true) const;
953  void print(raw_ostream &OS, ModuleSlotTracker &MST,
954  const SlotIndexes * = nullptr, bool IsStandalone = true) const;
955 
957  PrintNameIr = (1 << 0), ///< Add IR name where available
958  PrintNameAttributes = (1 << 1), ///< Print attributes
959  };
960 
961  void printName(raw_ostream &os, unsigned printNameFlags = PrintNameIr,
962  ModuleSlotTracker *moduleSlotTracker = nullptr) const;
963 
964  // Printing method used by LoopInfo.
965  void printAsOperand(raw_ostream &OS, bool PrintType = true) const;
966 
967  /// MachineBasicBlocks are uniquely numbered at the function level, unless
968  /// they're not in a MachineFunction yet, in which case this will return -1.
969  int getNumber() const { return Number; }
970  void setNumber(int N) { Number = N; }
971 
972  /// Return the MCSymbol for this basic block.
973  MCSymbol *getSymbol() const;
974 
975  /// Return the EHCatchret Symbol for this basic block.
976  MCSymbol *getEHCatchretSymbol() const;
977 
979  return IrrLoopHeaderWeight;
980  }
981 
982  void setIrrLoopHeaderWeight(uint64_t Weight) {
983  IrrLoopHeaderWeight = Weight;
984  }
985 
986 private:
987  /// Return probability iterator corresponding to the I successor iterator.
988  probability_iterator getProbabilityIterator(succ_iterator I);
989  const_probability_iterator
990  getProbabilityIterator(const_succ_iterator I) const;
991 
993  friend class MIPrinter;
994 
995  /// Return probability of the edge from this block to MBB. This method should
996  /// NOT be called directly, but by using getEdgeProbability method from
997  /// MachineBranchProbabilityInfo class.
998  BranchProbability getSuccProbability(const_succ_iterator Succ) const;
999 
1000  // Methods used to maintain doubly linked list of blocks...
1002 
1003  // Machine-CFG mutators
1004 
1005  /// Add Pred as a predecessor of this MachineBasicBlock. Don't do this
1006  /// unless you know what you're doing, because it doesn't update Pred's
1007  /// successors list. Use Pred->addSuccessor instead.
1008  void addPredecessor(MachineBasicBlock *Pred);
1009 
1010  /// Remove Pred as a predecessor of this MachineBasicBlock. Don't do this
1011  /// unless you know what you're doing, because it doesn't update Pred's
1012  /// successors list. Use Pred->removeSuccessor instead.
1013  void removePredecessor(MachineBasicBlock *Pred);
1014 };
1015 
1017 
1018 /// Prints a machine basic block reference.
1019 ///
1020 /// The format is:
1021 /// %bb.5 - a machine basic block with MBB.getNumber() == 5.
1022 ///
1023 /// Usage: OS << printMBBReference(MBB) << '\n';
1025 
1026 // This is useful when building IndexedMaps keyed on basic block pointers.
1029  unsigned operator()(const MachineBasicBlock *MBB) const {
1030  return MBB->getNumber();
1031  }
1032 };
1033 
1034 //===--------------------------------------------------------------------===//
1035 // GraphTraits specializations for machine basic block graphs (machine-CFGs)
1036 //===--------------------------------------------------------------------===//
1037 
1038 // Provide specializations of GraphTraits to be able to treat a
1039 // MachineFunction as a graph of MachineBasicBlocks.
1040 //
1041 
1042 template <> struct GraphTraits<MachineBasicBlock *> {
1045 
1047  static ChildIteratorType child_begin(NodeRef N) { return N->succ_begin(); }
1048  static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
1049 };
1050 
1051 template <> struct GraphTraits<const MachineBasicBlock *> {
1052  using NodeRef = const MachineBasicBlock *;
1054 
1055  static NodeRef getEntryNode(const MachineBasicBlock *BB) { return BB; }
1056  static ChildIteratorType child_begin(NodeRef N) { return N->succ_begin(); }
1057  static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
1058 };
1059 
1060 // Provide specializations of GraphTraits to be able to treat a
1061 // MachineFunction as a graph of MachineBasicBlocks and to walk it
1062 // in inverse order. Inverse order for a function is considered
1063 // to be when traversing the predecessor edges of a MBB
1064 // instead of the successor edges.
1065 //
1066 template <> struct GraphTraits<Inverse<MachineBasicBlock*>> {
1069 
1071  return G.Graph;
1072  }
1073 
1074  static ChildIteratorType child_begin(NodeRef N) { return N->pred_begin(); }
1075  static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); }
1076 };
1077 
1079  using NodeRef = const MachineBasicBlock *;
1081 
1083  return G.Graph;
1084  }
1085 
1086  static ChildIteratorType child_begin(NodeRef N) { return N->pred_begin(); }
1087  static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); }
1088 };
1089 
1090 /// MachineInstrSpan provides an interface to get an iteration range
1091 /// containing the instruction it was initialized with, along with all
1092 /// those instructions inserted prior to or following that instruction
1093 /// at some point after the MachineInstrSpan is constructed.
1095  MachineBasicBlock &MBB;
1097 
1098 public:
1100  : MBB(*BB), I(I), B(I == MBB.begin() ? MBB.end() : std::prev(I)),
1101  E(std::next(I)) {
1102  assert(I == BB->end() || I->getParent() == BB);
1103  }
1104 
1106  return B == MBB.end() ? MBB.begin() : std::next(B);
1107  }
1109  bool empty() { return begin() == end(); }
1110 
1112 };
1113 
1114 /// Increment \p It until it points to a non-debug instruction or to \p End
1115 /// and return the resulting iterator. This function should only be used
1116 /// MachineBasicBlock::{iterator, const_iterator, instr_iterator,
1117 /// const_instr_iterator} and the respective reverse iterators.
1118 template <typename IterT>
1119 inline IterT skipDebugInstructionsForward(IterT It, IterT End,
1120  bool SkipPseudoOp = true) {
1121  while (It != End &&
1122  (It->isDebugInstr() || (SkipPseudoOp && It->isPseudoProbe())))
1123  ++It;
1124  return It;
1125 }
1126 
1127 /// Decrement \p It until it points to a non-debug instruction or to \p Begin
1128 /// and return the resulting iterator. This function should only be used
1129 /// MachineBasicBlock::{iterator, const_iterator, instr_iterator,
1130 /// const_instr_iterator} and the respective reverse iterators.
1131 template <class IterT>
1132 inline IterT skipDebugInstructionsBackward(IterT It, IterT Begin,
1133  bool SkipPseudoOp = true) {
1134  while (It != Begin &&
1135  (It->isDebugInstr() || (SkipPseudoOp && It->isPseudoProbe())))
1136  --It;
1137  return It;
1138 }
1139 
1140 /// Increment \p It, then continue incrementing it while it points to a debug
1141 /// instruction. A replacement for std::next.
1142 template <typename IterT>
1143 inline IterT next_nodbg(IterT It, IterT End, bool SkipPseudoOp = true) {
1144  return skipDebugInstructionsForward(std::next(It), End, SkipPseudoOp);
1145 }
1146 
1147 /// Decrement \p It, then continue decrementing it while it points to a debug
1148 /// instruction. A replacement for std::prev.
1149 template <typename IterT>
1150 inline IterT prev_nodbg(IterT It, IterT Begin, bool SkipPseudoOp = true) {
1151  return skipDebugInstructionsBackward(std::prev(It), Begin, SkipPseudoOp);
1152 }
1153 
1154 /// Construct a range iterator which begins at \p It and moves forwards until
1155 /// \p End is reached, skipping any debug instructions.
1156 template <typename IterT>
1157 inline auto instructionsWithoutDebug(IterT It, IterT End,
1158  bool SkipPseudoOp = true) {
1159  return make_filter_range(make_range(It, End), [=](const MachineInstr &MI) {
1160  return !MI.isDebugInstr() && !(SkipPseudoOp && MI.isPseudoProbe());
1161  });
1162 }
1163 
1164 } // end namespace llvm
1165 
1166 #endif // LLVM_CODEGEN_MACHINEBASICBLOCK_H
llvm::LaneBitmask
Definition: LaneBitmask.h:39
llvm::SuccIterator
Definition: CFG.h:139
llvm::next_nodbg
IterT next_nodbg(IterT It, IterT End, bool SkipPseudoOp=true)
Increment It, then continue incrementing it while it points to a debug instruction.
Definition: MachineBasicBlock.h:1143
llvm::MachineBasicBlock::RegisterMaskPair::PhysReg
MCPhysReg PhysReg
Definition: MachineBasicBlock.h:103
llvm::MBBSectionID::operator==
bool operator==(const MBBSectionID &Other) const
Definition: MachineBasicBlock.h:67
llvm::GraphTraits< Inverse< const MachineBasicBlock * > >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: MachineBasicBlock.h:1087
llvm::GraphTraits< Inverse< const MachineBasicBlock * > >::getEntryNode
static NodeRef getEntryNode(Inverse< const MachineBasicBlock * > G)
Definition: MachineBasicBlock.h:1082
llvm::MachineBasicBlock::succ_size
unsigned succ_size() const
Definition: MachineBasicBlock.h:344
llvm::MachineBasicBlock::terminators
iterator_range< const_iterator > terminators() const
Definition: MachineBasicBlock.h:291
llvm::MachineBasicBlock::pred_begin
pred_iterator pred_begin()
Definition: MachineBasicBlock.h:316
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:100
MachineInstr.h
llvm::MachineBasicBlock::setIrrLoopHeaderWeight
void setIrrLoopHeaderWeight(uint64_t Weight)
Definition: MachineBasicBlock.h:982
llvm
Definition: AllocatorList.h:23
llvm::MachineBasicBlock::rend
const_reverse_iterator rend() const
Definition: MachineBasicBlock.h:279
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::MachineBasicBlock::splice
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 ...
Definition: MachineBasicBlock.h:874
Pass
print lazy value Lazy Value Info Printer Pass
Definition: LazyValueInfo.cpp:1939
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
llvm::MachineBasicBlock::isLiveIn
bool isLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
Definition: MachineBasicBlock.cpp:574
llvm::MachineBasicBlock::setIsCleanupFuncletEntry
void setIsCleanupFuncletEntry(bool V=true)
Indicates if this is the entry block of a cleanup funclet.
Definition: MachineBasicBlock.h:470
llvm::MachineBasicBlock::LivenessQueryResult
LivenessQueryResult
Possible outcome of a register liveness query to computeRegisterLiveness()
Definition: MachineBasicBlock.h:930
llvm::MachineBasicBlock::getBasicBlock
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
Definition: MachineBasicBlock.h:202
llvm::MBBSectionID::Exception
@ Exception
Definition: MachineBasicBlock.h:56
llvm::MachineBasicBlock::PrintNameFlag
PrintNameFlag
Definition: MachineBasicBlock.h:956
llvm::MachineBasicBlock::erase
iterator erase(iterator I)
Remove an instruction or bundle from the instruction list and delete it.
Definition: MachineBasicBlock.h:826
llvm::MachineBasicBlock::ReplaceUsesOfBlockWith
void ReplaceUsesOfBlockWith(MachineBasicBlock *Old, MachineBasicBlock *New)
Given a machine basic block that branched to 'Old', change the code and CFG so that it branches to 'N...
Definition: MachineBasicBlock.cpp:1364
llvm::MachineInstrSpan
MachineInstrSpan provides an interface to get an iteration range containing the instruction it was in...
Definition: MachineBasicBlock.h:1094
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::MachineBasicBlock::instrs
instr_range instrs()
Definition: MachineBasicBlock.h:263
llvm::MachineBasicBlock::clear
void clear()
Definition: MachineBasicBlock.h:855
llvm::MachineInstr::isEHScopeReturn
bool isEHScopeReturn(QueryType Type=AnyInBundle) const
Return true if this is an instruction that marks the end of an EH scope, i.e., a catchpad or a cleanu...
Definition: MachineInstr.h:808
llvm::MachineBasicBlock::isEHFuncletEntry
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
Definition: MachineBasicBlock.h:461
ilist.h
llvm::MachineBasicBlock::erase
iterator erase(iterator I, iterator E)
Remove a range of instructions from the instruction list and delete them.
Definition: MachineBasicBlock.h:819
llvm::MachineBasicBlock::instrs
const_instr_range instrs() const
Definition: MachineBasicBlock.h:264
llvm::MachineBasicBlock::insertAfterBundle
instr_iterator insertAfterBundle(instr_iterator I, MachineInstr *MI)
If I is bundled then insert MI into the instruction list after the end of the bundle,...
Definition: MachineBasicBlock.h:794
llvm::printMBBReference
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
Definition: MachineBasicBlock.cpp:118
llvm::MachineBasicBlock::setIsEHCatchretTarget
void setIsEHCatchretTarget(bool V=true)
Indicates if this is a target block of a catchret.
Definition: MachineBasicBlock.h:458
llvm::ilist_node_with_parent
An ilist node that can access its parent list.
Definition: ilist_node.h:256
llvm::MachineBasicBlock::isEntryBlock
bool isEntryBlock() const
Returns true if this is the entry block of the function.
Definition: MachineBasicBlock.cpp:289
llvm::MachineBasicBlock::setSuccProbability
void setSuccProbability(succ_iterator I, BranchProbability Prob)
Set successor probability of a given iterator.
Definition: MachineBasicBlock.cpp:1476
llvm::MachineBasicBlock::getEHCatchretSymbol
MCSymbol * getEHCatchretSymbol() const
Return the EHCatchret Symbol for this basic block.
Definition: MachineBasicBlock.cpp:90
llvm::MachineBasicBlock::isReturnBlock
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction.
Definition: MachineBasicBlock.h:718
llvm::iplist_impl< simple_ilist< T, Options... >, ilist_traits< T > >::const_reverse_iterator
base_list_type::const_reverse_iterator const_reverse_iterator
Definition: ilist.h:181
llvm::MachineBasicBlock::const_pred_iterator
std::vector< MachineBasicBlock * >::const_iterator const_pred_iterator
Definition: MachineBasicBlock.h:305
llvm::ilist_callback_traits
Callbacks do nothing by default in iplist and ilist.
Definition: ilist.h:64
llvm::MachineBasicBlock::findDebugLoc
DebugLoc findDebugLoc(instr_iterator MBBI)
Find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE and DBG_LABEL instructions.
Definition: MachineBasicBlock.cpp:1398
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:231
llvm::MachineBasicBlock::livein_iterator
LiveInVector::const_iterator livein_iterator
Definition: MachineBasicBlock.h:398
llvm::MachineBasicBlock::succ_rend
const_succ_reverse_iterator succ_rend() const
Definition: MachineBasicBlock.h:342
llvm::GraphTraits< const MachineBasicBlock * >::getEntryNode
static NodeRef getEntryNode(const MachineBasicBlock *BB)
Definition: MachineBasicBlock.h:1055
llvm::MachineBasicBlock::moveBefore
void moveBefore(MachineBasicBlock *NewAfter)
Move 'this' block before or after the specified block.
Definition: MachineBasicBlock.cpp:632
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
llvm::MachineBasicBlock::liveins
iterator_range< livein_iterator > liveins() const
Definition: MachineBasicBlock.h:412
llvm::MBBSectionID::Number
unsigned Number
Definition: MachineBasicBlock.h:59
llvm::Optional< uint64_t >
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::MachineBasicBlock::getIrrLoopHeaderWeight
Optional< uint64_t > getIrrLoopHeaderWeight() const
Definition: MachineBasicBlock.h:978
llvm::GraphTraits< const MachineBasicBlock * >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: MachineBasicBlock.h:1057
llvm::MachineBasicBlock::front
const MachineInstr & front() const
Definition: MachineBasicBlock.h:249
llvm::MachineBasicBlock::back
MachineInstr & back()
Definition: MachineBasicBlock.h:248
llvm::GraphTraits< Inverse< MachineBasicBlock * > >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: MachineBasicBlock.h:1074
llvm::MachineBasicBlock::addSuccessorWithoutProb
void addSuccessorWithoutProb(MachineBasicBlock *Succ)
Add Succ as a successor of this MachineBasicBlock.
Definition: MachineBasicBlock.cpp:755
llvm::MachineBasicBlock::successors
iterator_range< const_succ_iterator > successors() const
Definition: MachineBasicBlock.h:358
llvm::MachineBasicBlock::terminators
iterator_range< iterator > terminators()
Definition: MachineBasicBlock.h:288
llvm::MBBSectionID
Definition: MachineBasicBlock.h:52
llvm::MachineBasicBlock::rfindPrevDebugLoc
DebugLoc rfindPrevDebugLoc(reverse_iterator MBBI)
Definition: MachineBasicBlock.h:921
llvm::MachineBasicBlock::copySuccessor
void copySuccessor(MachineBasicBlock *Orig, succ_iterator I)
Copy a successor (and any probability info) from original block to this block's.
Definition: MachineBasicBlock.cpp:846
llvm::MachineBasicBlock::insert
iterator insert(iterator I, MachineInstr *MI)
Insert MI into the instruction list before I.
Definition: MachineBasicBlock.h:775
llvm::MachineBasicBlock::succ_reverse_iterator
std::vector< MachineBasicBlock * >::reverse_iterator succ_reverse_iterator
Definition: MachineBasicBlock.h:313
llvm::ModuleSlotTracker
Manage lifetime of a slot tracker for printing IR.
Definition: ModuleSlotTracker.h:29
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::GraphTraits< const MachineBasicBlock * >::ChildIteratorType
MachineBasicBlock::const_succ_iterator ChildIteratorType
Definition: MachineBasicBlock.h:1053
llvm::GraphTraits< MachineBasicBlock * >::getEntryNode
static NodeRef getEntryNode(MachineBasicBlock *BB)
Definition: MachineBasicBlock.h:1046
llvm::iplist
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
Definition: ilist.h:390
llvm::MachineBasicBlock::succ_rbegin
succ_reverse_iterator succ_rbegin()
Definition: MachineBasicBlock.h:336
llvm::MachineBasicBlock::const_instr_iterator
Instructions::const_iterator const_instr_iterator
Definition: MachineBasicBlock.h:229
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::MachineBasicBlock::pop_back
void pop_back()
Definition: MachineBasicBlock.h:755
llvm::MachineBasicBlock::dump
void dump() const
Definition: MachineBasicBlock.cpp:294
llvm::MachineBasicBlock::const_instr_range
iterator_range< const_instr_iterator > const_instr_range
Definition: MachineBasicBlock.h:262
llvm::MachineBasicBlock::erase
instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
Definition: MachineBasicBlock.cpp:1324
llvm::MachineBasicBlock::isBeginSection
bool isBeginSection() const
Returns true if this block begins any section.
Definition: MachineBasicBlock.h:473
llvm::MachineBasicBlock::succ_rbegin
const_succ_reverse_iterator succ_rbegin() const
Definition: MachineBasicBlock.h:338
llvm::MachineBasicBlock::printName
void printName(raw_ostream &os, unsigned printNameFlags=PrintNameIr, ModuleSlotTracker *moduleSlotTracker=nullptr) const
Print the basic block's name as:
Definition: MachineBasicBlock.cpp:477
GraphTraits.h
SparseBitVector.h
llvm::MachineBasicBlock::setSectionID
void setSectionID(MBBSectionID V)
Sets the section ID for this basic block.
Definition: MachineBasicBlock.h:492
llvm::MachineBasicBlock::addSuccessor
void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
Definition: MachineBasicBlock.cpp:745
llvm::MachineBasicBlock::getSymbol
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
Definition: MachineBasicBlock.cpp:59
llvm::MachineBasicBlock::reverse_iterator
MachineInstrBundleIterator< MachineInstr, true > reverse_iterator
Definition: MachineBasicBlock.h:235
llvm::MachineBasicBlock::instr_end
const_instr_iterator instr_end() const
Definition: MachineBasicBlock.h:255
llvm::MachineBasicBlock::push_back
void push_back(MachineInstr *MI)
Definition: MachineBasicBlock.h:756
llvm::MachineBasicBlock::pred_size
unsigned pred_size() const
Definition: MachineBasicBlock.h:328
llvm::SparseBitVector
Definition: SparseBitVector.h:255
llvm::MachineBasicBlock::setIsInlineAsmBrIndirectTarget
void setIsInlineAsmBrIndirectTarget(bool V=true)
Indicates if this is the indirect dest of an INLINEASM_BR.
Definition: MachineBasicBlock.h:508
llvm::MachineBasicBlock::getFirstInstrTerminator
instr_iterator getFirstInstrTerminator()
Same getFirstTerminator but it ignores bundles and return an instr_iterator instead.
Definition: MachineBasicBlock.cpp:250
llvm::MachineBasicBlock::insertAfter
iterator insertAfter(iterator I, MachineInstr *MI)
Insert MI into the instruction list after I.
Definition: MachineBasicBlock.h:784
llvm::MachineBasicBlock::removeFromParent
MachineBasicBlock * removeFromParent()
This method unlinks 'this' from the containing function, and returns it, but does not delete it.
Definition: MachineBasicBlock.cpp:1350
llvm::MachineBasicBlock::remove
MachineInstr * remove(MachineInstr *I)
Remove the unbundled instruction from the instruction list without deleting it.
Definition: MachineBasicBlock.h:843
llvm::MachineBranchProbabilityInfo
Definition: MachineBranchProbabilityInfo.h:24
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineBasicBlock::succ_end
succ_iterator succ_end()
Definition: MachineBasicBlock.h:334
llvm::MBBSectionID::SectionType
SectionType
Definition: MachineBasicBlock.h:53
llvm::MachineBasicBlock::MachineFunction
friend class MachineFunction
Definition: MachineBasicBlock.h:196
llvm::GraphTraits< Inverse< MachineBasicBlock * > >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: MachineBasicBlock.h:1075
llvm::MachineBasicBlock::isSuccessor
bool isSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB is a successor of this block.
Definition: MachineBasicBlock.cpp:933
llvm::MachineBasicBlock::eraseFromParent
void eraseFromParent()
This method unlinks 'this' from the containing function and deletes it.
Definition: MachineBasicBlock.cpp:1357
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:46
llvm::MBBSectionID::Default
@ Default
Definition: MachineBasicBlock.h:54
llvm::MachineBasicBlock::pred_begin
const_pred_iterator pred_begin() const
Definition: MachineBasicBlock.h:317
First
into llvm powi allowing the code generator to produce balanced multiplication trees First
Definition: README.txt:54
llvm::MachineBasicBlock::isLegalToHoistInto
bool isLegalToHoistInto() const
Returns true if it is legal to hoist instructions into this block.
Definition: MachineBasicBlock.cpp:307
llvm::MachineBasicBlock::RegisterMaskPair
Pair of physical register and lane mask.
Definition: MachineBasicBlock.h:101
llvm::MBBSectionID::Cold
@ Cold
Definition: MachineBasicBlock.h:57
llvm::MachineBasicBlock::rend
reverse_iterator rend()
Definition: MachineBasicBlock.h:278
llvm::MachineBasicBlock::const_succ_reverse_iterator
std::vector< MachineBasicBlock * >::const_reverse_iterator const_succ_reverse_iterator
Definition: MachineBasicBlock.h:315
llvm::MachineBasicBlock::pred_rbegin
pred_reverse_iterator pred_rbegin()
Definition: MachineBasicBlock.h:320
llvm::MachineBasicBlock::splitAt
MachineBasicBlock * splitAt(MachineInstr &SplitInst, bool UpdateLiveIns=true, LiveIntervals *LIS=nullptr)
Split a basic block into 2 pieces at SplitPoint.
Definition: MachineBasicBlock.cpp:990
llvm::MachineBasicBlock::isEHCatchretTarget
bool isEHCatchretTarget() const
Returns true if this is a target block of a catchret.
Definition: MachineBasicBlock.h:455
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:50
llvm::MachineBasicBlock::instr_back
MachineInstr & instr_back()
Definition: MachineBasicBlock.h:243
llvm::operator<<
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:230
llvm::SlotIndexes
SlotIndexes pass.
Definition: SlotIndexes.h:314
llvm::MachineInstrSpan::begin
MachineBasicBlock::iterator begin()
Definition: MachineBasicBlock.h:1105
llvm::MachineBasicBlock::moveAndDanglePseudoProbes
void moveAndDanglePseudoProbes(MachineBasicBlock *ToMBB)
move all pseudo probes in this block to the end of /c ToMBB To and tag them dangling.
Definition: MachineBasicBlock.cpp:913
DebugLoc.h
llvm::MachineBasicBlock::isCleanupFuncletEntry
bool isCleanupFuncletEntry() const
Returns true if this is the entry block of a cleanup funclet.
Definition: MachineBasicBlock.h:467
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::MachineInstrSpan::end
MachineBasicBlock::iterator end()
Definition: MachineBasicBlock.h:1108
llvm::BranchProbability::getUnknown
static BranchProbability getUnknown()
Definition: BranchProbability.h:51
llvm::MachineBasicBlock::getLastNonDebugInstr
const_iterator getLastNonDebugInstr(bool SkipPseudoOp=true) const
Definition: MachineBasicBlock.h:711
llvm::iplist_impl< simple_ilist< T, Options... >, ilist_traits< T > >::reverse_iterator
base_list_type::reverse_iterator reverse_iterator
Definition: ilist.h:179
BranchProbability.h
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::MachineBasicBlock::isEHScopeReturnBlock
bool isEHScopeReturnBlock() const
Convenience function that returns true if the bock ends in a EH scope return instruction.
Definition: MachineBasicBlock.h:724
llvm::MachineBasicBlock::findPrevDebugLoc
DebugLoc findPrevDebugLoc(instr_iterator MBBI)
Find the previous valid DebugLoc preceding MBBI, skipping and DBG_VALUE instructions.
Definition: MachineBasicBlock.cpp:1416
llvm::GraphTraits< MachineBasicBlock * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: MachineBasicBlock.h:1047
llvm::GraphTraits< Inverse< MachineBasicBlock * > >::ChildIteratorType
MachineBasicBlock::pred_iterator ChildIteratorType
Definition: MachineBasicBlock.h:1068
llvm::MachineBasicBlock::getSectionIDNum
unsigned getSectionIDNum() const
Returns the unique section ID number of this basic block.
Definition: MachineBasicBlock.h:486
llvm::MachineBasicBlock::setAlignment
void setAlignment(Align A)
Set alignment of the basic block.
Definition: MachineBasicBlock.h:431
llvm::ilist_traits
Template traits for intrusive list.
Definition: ilist.h:89
llvm::MachineBasicBlock::back
const MachineInstr & back() const
Definition: MachineBasicBlock.h:250
llvm::MachineInstrBundleIterator::getInstrIterator
instr_iterator getInstrIterator() const
Definition: MachineInstrBundleIterator.h:274
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::MachineInstrSpan::getInitial
MachineBasicBlock::iterator getInitial()
Definition: MachineBasicBlock.h:1111
llvm::MachineBasicBlock::succ_iterator
std::vector< MachineBasicBlock * >::iterator succ_iterator
Definition: MachineBasicBlock.h:306
llvm::GraphTraits< Inverse< MachineBasicBlock * > >::getEntryNode
static NodeRef getEntryNode(Inverse< MachineBasicBlock * > G)
Definition: MachineBasicBlock.h:1070
llvm::MachineInstrSpan::empty
bool empty()
Definition: MachineBasicBlock.h:1109
llvm::MachineBasicBlock::hasSuccessorProbabilities
bool hasSuccessorProbabilities() const
Return true if any of the successors have probabilities attached to them.
Definition: MachineBasicBlock.h:615
llvm::MachineBasicBlock::mayHaveInlineAsmBr
bool mayHaveInlineAsmBr() const
Returns true if this block may have an INLINEASM_BR (overestimate, by checking if any of the successo...
Definition: MachineBasicBlock.cpp:299
llvm::MachineBasicBlock::printAsOperand
void printAsOperand(raw_ostream &OS, bool PrintType=true) const
Definition: MachineBasicBlock.cpp:550
llvm::MachineBasicBlock::instr_back
const MachineInstr & instr_back() const
Definition: MachineBasicBlock.h:245
llvm::MachineBasicBlock::pred_end
pred_iterator pred_end()
Definition: MachineBasicBlock.h:318
llvm::MachineBasicBlock::instr_rend
reverse_instr_iterator instr_rend()
Definition: MachineBasicBlock.h:258
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::MachineBasicBlock::hasAddressTaken
bool hasAddressTaken() const
Test whether this block is potentially the target of an indirect branch.
Definition: MachineBasicBlock.h:211
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::MachineBasicBlock::setIsEHPad
void setIsEHPad(bool V=true)
Indicates the block is a landing pad.
Definition: MachineBasicBlock.h:439
llvm::iplist_impl< simple_ilist< T, Options... >, ilist_traits< T > >::iterator
base_list_type::iterator iterator
Definition: ilist.h:177
llvm::MachineInstrBundleIterator::getAtBundleBegin
static MachineInstrBundleIterator getAtBundleBegin(instr_iterator MI)
Get the bundle iterator for the given instruction's bundle.
Definition: MachineInstrBundleIterator.h:174
llvm::MachineBasicBlock::end
const_iterator end() const
Definition: MachineBasicBlock.h:271
llvm::MachineBasicBlock::SkipPHIsAndLabels
iterator SkipPHIsAndLabels(iterator I)
Return the first instruction in MBB after I that is not a PHI or a label.
Definition: MachineBasicBlock.cpp:209
llvm::MachineBasicBlock::instr_rbegin
reverse_instr_iterator instr_rbegin()
Definition: MachineBasicBlock.h:256
llvm::MachineBasicBlock::LQR_Live
@ LQR_Live
Register is known to be (at least partially) live.
Definition: MachineBasicBlock.h:931
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::MachineBasicBlock::getFirstTerminator
const_iterator getFirstTerminator() const
Definition: MachineBasicBlock.h:664
llvm::GraphTraits< const MachineBasicBlock * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: MachineBasicBlock.h:1056
llvm::CallingConv::Cold
@ Cold
Definition: CallingConv.h:48
llvm::MachineBasicBlock::getFirstNonPHI
iterator getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: MachineBasicBlock.cpp:199
llvm::GraphTraits< Inverse< const MachineBasicBlock * > >::ChildIteratorType
MachineBasicBlock::const_pred_iterator ChildIteratorType
Definition: MachineBasicBlock.h:1080
llvm::prev_nodbg
IterT prev_nodbg(IterT It, IterT Begin, bool SkipPseudoOp=true)
Decrement It, then continue decrementing it while it points to a debug instruction.
Definition: MachineBasicBlock.h:1150
llvm::MachineBasicBlock::succ_end
const_succ_iterator succ_end() const
Definition: MachineBasicBlock.h:335
llvm::MachineBasicBlock::getLastNonDebugInstr
iterator getLastNonDebugInstr(bool SkipPseudoOp=true)
Returns an iterator to the last non-debug instruction in the basic block, or end().
Definition: MachineBasicBlock.cpp:266
llvm::MachineBasicBlock::getAlignment
Align getAlignment() const
Return alignment of the basic block.
Definition: MachineBasicBlock.h:428
llvm::MachineBasicBlock::pred_iterator
std::vector< MachineBasicBlock * >::iterator pred_iterator
Definition: MachineBasicBlock.h:304
llvm::MachineBasicBlock::setIsEndSection
void setIsEndSection(bool V=true)
Definition: MachineBasicBlock.h:480
llvm::MBBSectionID::ExceptionSectionID
const static MBBSectionID ExceptionSectionID
Definition: MachineBasicBlock.h:65
llvm::MIPrinter
This class prints out the machine instructions using the MIR serialization format.
Definition: MIRPrinter.cpp:145
llvm::MachineBasicBlock::instr_front
const MachineInstr & instr_front() const
Definition: MachineBasicBlock.h:244
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MachineBasicBlock::canFallThrough
bool canFallThrough()
Return true if the block can implicitly transfer control to the block after it by falling off the end...
Definition: MachineBasicBlock.cpp:986
llvm::MachineBasicBlock::size
unsigned size() const
Definition: MachineBasicBlock.h:239
llvm::MachineBasicBlock::succ_rend
succ_reverse_iterator succ_rend()
Definition: MachineBasicBlock.h:340
llvm::MachineBasicBlock::succ_begin
succ_iterator succ_begin()
Definition: MachineBasicBlock.h:332
llvm::MachineBasicBlock::setHasAddressTaken
void setHasAddressTaken()
Set this block to reflect that it potentially is the target of an indirect branch.
Definition: MachineBasicBlock.h:215
llvm::MachineBasicBlock::getParent
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
Definition: MachineBasicBlock.h:225
llvm::MBBSectionID::MBBSectionID
MBBSectionID(unsigned N)
Definition: MachineBasicBlock.h:61
iterator_range.h
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:64
llvm::MBB2NumberFunctor::operator()
unsigned operator()(const MachineBasicBlock *MBB) const
Definition: MachineBasicBlock.h:1029
llvm::MachineBasicBlock::instr_rend
const_reverse_instr_iterator instr_rend() const
Definition: MachineBasicBlock.h:259
B
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional ldr LCPI1_0 ldr ldr tst movne lsr ldr LCPI1_1 and r0 bx lr it saves an instruction and a register It might be profitable to cse MOVi16 if there are lots of bit immediates with the same bottom half Robert Muth started working on an alternate jump table implementation that does not put the tables in line in the text This is more like the llvm default jump table implementation This might be useful sometime Several revisions of patches are on the mailing beginning while CMP sets them like a subtract Therefore to be able to use CMN for comparisons other than the Z we ll need additional logic to reverse the conditionals associated with the comparison Perhaps a pseudo instruction for the with a post codegen pass to clean up and handle the condition codes See PR5694 for testcase Given the following on int B
Definition: README.txt:592
llvm::MachineBasicBlock::livein_end
livein_iterator livein_end() const
Definition: MachineBasicBlock.h:410
llvm::MachineBasicBlock::pred_rbegin
const_pred_reverse_iterator pred_rbegin() const
Definition: MachineBasicBlock.h:322
llvm::MachineBasicBlock::predecessors
iterator_range< pred_iterator > predecessors()
Definition: MachineBasicBlock.h:349
llvm::MachineBasicBlock::reverse_instr_iterator
Instructions::reverse_iterator reverse_instr_iterator
Definition: MachineBasicBlock.h:230
llvm::MachineBasicBlock::LQR_Dead
@ LQR_Dead
Register is known to be fully dead.
Definition: MachineBasicBlock.h:932
llvm::MachineInstr::isReturn
bool isReturn(QueryType Type=AnyInBundle) const
Definition: MachineInstr.h:802
llvm::MachineBasicBlock::instr_begin
instr_iterator instr_begin()
Definition: MachineBasicBlock.h:252
llvm::MachineBasicBlock::pred_empty
bool pred_empty() const
Definition: MachineBasicBlock.h:331
llvm::GraphTraits< MachineBasicBlock * >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: MachineBasicBlock.h:1048
llvm::MachineBasicBlock::setIsEHFuncletEntry
void setIsEHFuncletEntry(bool V=true)
Indicates if this is the entry block of an EH funclet.
Definition: MachineBasicBlock.h:464
llvm::MachineBasicBlock::instr_end
instr_iterator instr_end()
Definition: MachineBasicBlock.h:254
llvm::MachineFunction
Definition: MachineFunction.h:227
llvm::MachineBasicBlock::moveAfter
void moveAfter(MachineBasicBlock *NewBefore)
Definition: MachineBasicBlock.cpp:636
llvm::MachineBasicBlock::succ_empty
bool succ_empty() const
Definition: MachineBasicBlock.h:347
llvm::MachineBasicBlock::PrintNameIr
@ PrintNameIr
Add IR name where available.
Definition: MachineBasicBlock.h:957
llvm::MachineBasicBlock::hasLabelMustBeEmitted
bool hasLabelMustBeEmitted() const
Test whether this block must have its label emitted.
Definition: MachineBasicBlock.h:218
llvm::MachineBasicBlock::getFirstTerminator
iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
Definition: MachineBasicBlock.cpp:241
llvm::skipDebugInstructionsForward
IterT skipDebugInstructionsForward(IterT It, IterT End, bool SkipPseudoOp=true)
Increment It until it points to a non-debug instruction or to End and return the resulting iterator.
Definition: MachineBasicBlock.h:1119
llvm::MachineBasicBlock::getBeginClobberMask
const uint32_t * getBeginClobberMask(const TargetRegisterInfo *TRI) const
Get the clobber mask for the start of this basic block.
Definition: MachineBasicBlock.cpp:1608
llvm::MachineBasicBlock::phis
iterator_range< iterator > phis()
Returns a range that iterates over the phis in the basic block.
Definition: MachineBasicBlock.h:296
llvm::MachineBasicBlock::iterator
MachineInstrBundleIterator< MachineInstr > iterator
Definition: MachineBasicBlock.h:233
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")))
llvm::MachineBasicBlock::getNumber
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
Definition: MachineBasicBlock.h:969
llvm::MachineBasicBlock::isEHScopeEntry
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 ...
Definition: MachineBasicBlock.h:448
llvm::MachineBasicBlock::PrintNameAttributes
@ PrintNameAttributes
Print attributes.
Definition: MachineBasicBlock.h:958
llvm::MachineBasicBlock::getFirstNonDebugInstr
iterator getFirstNonDebugInstr(bool SkipPseudoOp=true)
Returns an iterator to the first non-debug instruction in the basic block, or end().
Definition: MachineBasicBlock.cpp:260
llvm::MachineBasicBlock::successors
iterator_range< succ_iterator > successors()
Definition: MachineBasicBlock.h:355
llvm::MachineBasicBlock::isEHPad
bool isEHPad() const
Returns true if the block is a landing pad.
Definition: MachineBasicBlock.h:435
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::MachineBasicBlock::getFirstNonDebugInstr
const_iterator getFirstNonDebugInstr(bool SkipPseudoOp=true) const
Definition: MachineBasicBlock.h:689
llvm::MachineBasicBlock::rbegin
reverse_iterator rbegin()
Definition: MachineBasicBlock.h:272
llvm::MachineBasicBlock::splice
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 '...
Definition: MachineBasicBlock.h:863
llvm::MachineBasicBlock::hasEHPadSuccessor
bool hasEHPadSuccessor() const
Definition: MachineBasicBlock.cpp:282
MBBI
MachineBasicBlock MachineBasicBlock::iterator MBBI
Definition: AArch64SLSHardening.cpp:75
llvm::MachineBasicBlock::getFullName
std::string getFullName() const
Return a formatted string to identify this block and its parent function.
Definition: MachineBasicBlock.cpp:321
llvm::MachineBasicBlock::liveins_dbg
iterator_range< livein_iterator > liveins_dbg() const
Definition: MachineBasicBlock.h:405
llvm::MachineBasicBlock::findBranchDebugLoc
DebugLoc findBranchDebugLoc()
Find and return the merged DebugLoc of the branch instructions of the block.
Definition: MachineBasicBlock.cpp:1437
const_iterator
llvm::MachineBasicBlock::removeLiveIn
void removeLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll())
Remove the specified register from the live in set.
Definition: MachineBasicBlock.cpp:556
llvm::MBBSectionID::Type
enum llvm::MBBSectionID::SectionType Type
llvm::MachineBasicBlock::rfindDebugLoc
DebugLoc rfindDebugLoc(reverse_instr_iterator MBBI)
Has exact same behavior as findDebugLoc (it also searches from the first to the last MI of this MBB) ...
Definition: MachineBasicBlock.cpp:1406
Number
uint32_t Number
Definition: Profile.cpp:47
A
* A
Definition: README_ALTIVEC.txt:89
llvm::ilist_callback_traits::addNodeToList
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
MachineInstrBundleIterator.h
uint32_t
llvm::BranchProbability
Definition: BranchProbability.h:30
llvm::MachineBasicBlock::livein_begin_dbg
livein_iterator livein_begin_dbg() const
Unlike livein_begin, this method does not check that the liveness information is accurate.
Definition: MachineBasicBlock.h:404
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MachineInstrSpan::MachineInstrSpan
MachineInstrSpan(MachineBasicBlock::iterator I, MachineBasicBlock *BB)
Definition: MachineBasicBlock.h:1099
llvm::MachineBasicBlock::splitSuccessor
void splitSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New, bool NormalizeSuccProbs=false)
Split the old successor into old plus new and updates the probability info.
Definition: MachineBasicBlock.cpp:764
llvm::MachineBasicBlock::transferSuccessors
void transferSuccessors(MachineBasicBlock *FromMBB)
Transfers all the successors from MBB to this machine basic block (i.e., copies all the successors Fr...
Definition: MachineBasicBlock.cpp:864
llvm::make_filter_range
iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)
Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...
Definition: STLExtras.h:495
llvm::MachineBasicBlock::setLabelMustBeEmitted
void setLabelMustBeEmitted()
Set this block to reflect that, regardless how we flow to it, we need its label be emitted.
Definition: MachineBasicBlock.h:222
llvm::MachineBasicBlock::getSectionID
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
Definition: MachineBasicBlock.h:483
llvm::MachineBasicBlock::pred_end
const_pred_iterator pred_end() const
Definition: MachineBasicBlock.h:319
llvm::MachineBasicBlock::instr_front
MachineInstr & instr_front()
Definition: MachineBasicBlock.h:242
llvm::MachineBasicBlock::addLiveIn
void addLiveIn(const RegisterMaskPair &RegMaskPair)
Definition: MachineBasicBlock.h:371
llvm::MachineBasicBlock::setIsEHScopeEntry
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...
Definition: MachineBasicBlock.h:452
llvm::MachineBasicBlock::RegisterMaskPair::RegisterMaskPair
RegisterMaskPair(MCPhysReg PhysReg, LaneBitmask LaneMask)
Definition: MachineBasicBlock.h:106
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::MachineBasicBlock::addLiveIn
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
Definition: MachineBasicBlock.h:367
llvm::MachineBasicBlock::isPredecessor
bool isPredecessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB is a predecessor of this block.
Definition: MachineBasicBlock.cpp:929
llvm::MachineBasicBlock::phis
iterator_range< const_iterator > phis() const
Definition: MachineBasicBlock.h:299
llvm::MachineBasicBlock::succ_begin
const_succ_iterator succ_begin() const
Definition: MachineBasicBlock.h:333
llvm::MachineBasicBlock::getEndSymbol
MCSymbol * getEndSymbol() const
Returns the MCSymbol marking the end of this basic block.
Definition: MachineBasicBlock.cpp:101
llvm::MachineBasicBlock::setNumber
void setNumber(int N)
Definition: MachineBasicBlock.h:970
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::MachineBasicBlock::RegisterMaskPair::LaneMask
LaneBitmask LaneMask
Definition: MachineBasicBlock.h:104
llvm::MachineBasicBlock::canSplitCriticalEdge
bool canSplitCriticalEdge(const MachineBasicBlock *Succ) const
Check if the edge between this block and the given successor Succ, can be split.
Definition: MachineBasicBlock.cpp:1270
llvm::MachineBasicBlock::const_reverse_iterator
MachineInstrBundleIterator< const MachineInstr, true > const_reverse_iterator
Definition: MachineBasicBlock.h:237
llvm::MachineBasicBlock::replaceSuccessor
void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New)
Replace successor OLD with NEW and update probability info.
Definition: MachineBasicBlock.cpp:806
std
Definition: BitVector.h:838
llvm::MachineBasicBlock::replacePhiUsesWith
void replacePhiUsesWith(MachineBasicBlock *Old, MachineBasicBlock *New)
Update all phi nodes in this basic block to refer to basic block New instead of basic block Old.
Definition: MachineBasicBlock.cpp:1385
llvm::MachineBasicBlock::sortUniqueLiveIns
void sortUniqueLiveIns()
Sorts and uniques the LiveIns vector.
Definition: MachineBasicBlock.cpp:580
uint16_t
llvm::MachineBasicBlock::removeSuccessor
void removeSuccessor(MachineBasicBlock *Succ, bool NormalizeSuccProbs=false)
Remove successor from the successors list of this MachineBasicBlock.
Definition: MachineBasicBlock.cpp:783
llvm::MachineBasicBlock::isEndSection
bool isEndSection() const
Returns true if this block ends any section.
Definition: MachineBasicBlock.h:476
llvm::GraphTraits< MachineBasicBlock * >::ChildIteratorType
MachineBasicBlock::succ_iterator ChildIteratorType
Definition: MachineBasicBlock.h:1044
llvm::MachineBasicBlock::erase
iterator erase(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
Definition: MachineBasicBlock.h:834
llvm::MBBSectionID::ColdSectionID
const static MBBSectionID ColdSectionID
Definition: MachineBasicBlock.h:64
llvm::MachineBasicBlock::insert
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
Definition: MachineBasicBlock.cpp:1337
llvm::ilist_iterator
Iterator for intrusive lists based on ilist_node.
Definition: ilist_iterator.h:57
llvm::MachineBasicBlock::computeRegisterLiveness
LivenessQueryResult computeRegisterLiveness(const TargetRegisterInfo *TRI, MCRegister Reg, const_iterator Before, unsigned Neighborhood=10) const
Return whether (physical) register Reg has been defined and not killed as of just before Before.
Definition: MachineBasicBlock.cpp:1510
llvm::MBBSectionID::operator!=
bool operator!=(const MBBSectionID &Other) const
Definition: MachineBasicBlock.h:71
llvm::MachineBasicBlock::instr_iterator
Instructions::iterator instr_iterator
Definition: MachineBasicBlock.h:228
llvm::MachineBasicBlock::setIsBeginSection
void setIsBeginSection(bool V=true)
Definition: MachineBasicBlock.h:478
llvm::MachineBasicBlock::pred_reverse_iterator
std::vector< MachineBasicBlock * >::reverse_iterator pred_reverse_iterator
Definition: MachineBasicBlock.h:309
llvm::ilist_callback_traits::removeNodeFromList
void removeNodeFromList(NodeTy *)
Definition: ilist.h:66
llvm::MachineBasicBlock::front
MachineInstr & front()
Definition: MachineBasicBlock.h:247
llvm::MBB2NumberFunctor
Definition: MachineBasicBlock.h:1027
llvm::MachineBasicBlock::livein_begin
livein_iterator livein_begin() const
Definition: MachineBasicBlock.cpp:1625
llvm::LiveIntervals
Definition: LiveIntervals.h:54
llvm::MachineBasicBlock::isLayoutSuccessor
bool isLayoutSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB will be emitted immediately after this block, such that if this bloc...
Definition: MachineBasicBlock.cpp:937
llvm::MachineBasicBlock::rfindPrevDebugLoc
DebugLoc rfindPrevDebugLoc(reverse_instr_iterator MBBI)
Has exact same behavior as findPrevDebugLoc (it also searches from the last to the first MI of this M...
Definition: MachineBasicBlock.cpp:1424
llvm::MachineBasicBlock::getParent
MachineFunction * getParent()
Definition: MachineBasicBlock.h:226
llvm::Inverse
Definition: GraphTraits.h:95
llvm::MachineBasicBlock::normalizeSuccProbs
void normalizeSuccProbs()
Normalize probabilities of all successors so that the sum of them becomes one.
Definition: MachineBasicBlock.h:563
llvm::MachineBasicBlock::livein_empty
bool livein_empty() const
Definition: MachineBasicBlock.h:411
llvm::MachineBasicBlock::findPrevDebugLoc
DebugLoc findPrevDebugLoc(iterator MBBI)
Definition: MachineBasicBlock.h:913
llvm::MachineBasicBlock::getFallThrough
MachineBasicBlock * getFallThrough()
Return the fallthrough block if the block can implicitly transfer control to the block after it by fa...
Definition: MachineBasicBlock.cpp:942
llvm::MachineBasicBlock::pop_front
void pop_front()
Definition: MachineBasicBlock.h:754
llvm::MachineBasicBlock::validateSuccProbs
void validateSuccProbs() const
Validate successors' probabilities and check if the sum of them is approximate one.
Definition: MachineBasicBlock.cpp:731
llvm::MachineBasicBlock::getEndClobberMask
const uint32_t * getEndClobberMask(const TargetRegisterInfo *TRI) const
Get the clobber mask for the end of the basic block.
Definition: MachineBasicBlock.cpp:1614
llvm::MachineBasicBlock::instr_begin
const_instr_iterator instr_begin() const
Definition: MachineBasicBlock.h:253
llvm::Pass
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:91
llvm::skipDebugInstructionsBackward
IterT skipDebugInstructionsBackward(IterT It, IterT Begin, bool SkipPseudoOp=true)
Decrement It until it points to a non-debug instruction or to Begin and return the resulting iterator...
Definition: MachineBasicBlock.h:1132
llvm::BranchProbability::normalizeProbabilities
static void normalizeProbabilities(ProbabilityIter Begin, ProbabilityIter End)
Definition: BranchProbability.h:205
llvm::MachineBasicBlock::begin
iterator begin()
Definition: MachineBasicBlock.h:268
llvm::MachineBasicBlock::isInlineAsmBrIndirectTarget
bool isInlineAsmBrIndirectTarget() const
Returns true if this is the indirect dest of an INLINEASM_BR.
Definition: MachineBasicBlock.h:503
llvm::ilist_alloc_traits::deleteNode
static void deleteNode(NodeTy *V)
Definition: ilist.h:41
llvm::Printable
Simple wrapper around std::function<void(raw_ostream&)>.
Definition: Printable.h:37
N
#define N
llvm::iplist_impl< simple_ilist< T, Options... >, ilist_traits< T > >::const_iterator
base_list_type::const_iterator const_iterator
Definition: ilist.h:178
llvm::MachineBasicBlock::findDebugLoc
DebugLoc findDebugLoc(iterator MBBI)
Definition: MachineBasicBlock.h:898
LaneBitmask.h
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::MachineBasicBlock::const_succ_iterator
std::vector< MachineBasicBlock * >::const_iterator const_succ_iterator
Definition: MachineBasicBlock.h:307
llvm::MachineBasicBlock::empty
bool empty() const
Definition: MachineBasicBlock.h:240
llvm::MachineBasicBlock::clearLiveIns
void clearLiveIns()
Clear live in list.
Definition: MachineBasicBlock.cpp:1621
llvm::simple_ilist
A simple intrusive list implementation.
Definition: simple_ilist.h:78
llvm::MachineBasicBlock::begin
const_iterator begin() const
Definition: MachineBasicBlock.h:269
llvm::GraphTraits< Inverse< const MachineBasicBlock * > >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: MachineBasicBlock.h:1086
llvm::MachineBasicBlock::erase_instr
instr_iterator erase_instr(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
Definition: MachineBasicBlock.h:814
llvm::MachineBasicBlock::insert
void insert(iterator I, IT S, IT E)
Insert a range of instructions into the instruction list before I.
Definition: MachineBasicBlock.h:768
llvm::MachineBasicBlock::transferSuccessorsAndUpdatePHIs
void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB)
Transfers all the successors, as in transferSuccessors, and update PHI operands in the successor bloc...
Definition: MachineBasicBlock.cpp:884
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::MachineBasicBlock::pred_rend
pred_reverse_iterator pred_rend()
Definition: MachineBasicBlock.h:324
llvm::MachineBasicBlock::const_pred_reverse_iterator
std::vector< MachineBasicBlock * >::const_reverse_iterator const_pred_reverse_iterator
Definition: MachineBasicBlock.h:311
llvm::MachineBasicBlock::LQR_Unknown
@ LQR_Unknown
Register liveness not decidable from local neighborhood.
Definition: MachineBasicBlock.h:933
llvm::GraphTraits
Definition: GraphTraits.h:35
llvm::MachineBasicBlock::SkipPHIsLabelsAndDebug
iterator SkipPHIsLabelsAndDebug(iterator I, bool SkipPseudoOp=true)
Return the first instruction in MBB after I that is not a PHI, label or debug.
Definition: MachineBasicBlock.cpp:224
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::MachineBasicBlock::print
void print(raw_ostream &OS, const SlotIndexes *=nullptr, bool IsStandalone=true) const
Definition: MachineBasicBlock.cpp:332
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::ilist_callback_traits::transferNodesFromList
void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator)
Callback before transferring nodes to this list.
Definition: ilist.h:71
llvm::MachineBasicBlock::rbegin
const_reverse_iterator rbegin() const
Definition: MachineBasicBlock.h:275
llvm::MachineBasicBlock::updateTerminator
void updateTerminator(MachineBasicBlock *PreviousLayoutSuccessor)
Update the terminator instructions in block to account for changes to block layout which may have bee...
Definition: MachineBasicBlock.cpp:640
llvm::MachineBasicBlock::instr_range
iterator_range< instr_iterator > instr_range
Definition: MachineBasicBlock.h:261
llvm::MachineBasicBlock::rfindDebugLoc
DebugLoc rfindDebugLoc(reverse_iterator MBBI)
Definition: MachineBasicBlock.h:906
llvm::MachineBasicBlock::pred_rend
const_pred_reverse_iterator pred_rend() const
Definition: MachineBasicBlock.h:326
llvm::MachineInstrBundleIterator< MachineInstr >
llvm::MachineBasicBlock::getSublistAccess
static Instructions MachineBasicBlock::* getSublistAccess(MachineInstr *)
Support for MachineInstr::getNextNode().
Definition: MachineBasicBlock.h:284
llvm::MachineBasicBlock::SplitCriticalEdge
MachineBasicBlock * SplitCriticalEdge(MachineBasicBlock *Succ, Pass &P, std::vector< SparseBitVector<>> *LiveInSets=nullptr)
Split the critical edge from this block to the given successor block, and return the newly created bl...
Definition: MachineBasicBlock.cpp:1031
llvm::MachineBasicBlock::remove_instr
MachineInstr * remove_instr(MachineInstr *I)
Remove the possibly bundled instruction from the instruction list without deleting it.
Definition: MachineBasicBlock.cpp:1329
llvm::MachineBasicBlock::getName
StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
Definition: MachineBasicBlock.cpp:313
llvm::MachineBasicBlock::end
iterator end()
Definition: MachineBasicBlock.h:270
llvm::LaneBitmask::getAll
static constexpr LaneBitmask getAll()
Definition: LaneBitmask.h:83
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:165
llvm::instructionsWithoutDebug
auto instructionsWithoutDebug(IterT It, IterT End, bool SkipPseudoOp=true)
Construct a range iterator which begins at It and moves forwards until End is reached,...
Definition: MachineBasicBlock.h:1157
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1163
llvm::MCRegister
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:22
llvm::MachineBasicBlock::sameSection
bool sameSection(const MachineBasicBlock *MBB) const
Returns true if this and MBB belong to the same section.
Definition: MachineBasicBlock.h:524
llvm::MachineBasicBlock::predecessors
iterator_range< const_pred_iterator > predecessors() const
Definition: MachineBasicBlock.h:352
llvm::MachineBasicBlock::instr_rbegin
const_reverse_instr_iterator instr_rbegin() const
Definition: MachineBasicBlock.h:257