LLVM  14.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 
420  public:
421  using iterator_category = std::input_iterator_tag;
422  using difference_type = std::ptrdiff_t;
424  using pointer = const RegisterMaskPair *;
425  using reference = const RegisterMaskPair &;
426 
428  MCPhysReg ExceptionSelector, bool End)
429  : ExceptionPointer(ExceptionPointer),
430  ExceptionSelector(ExceptionSelector), BlockI(MBB.succ_begin()),
431  BlockEnd(MBB.succ_end()) {
432  if (End)
433  BlockI = BlockEnd;
434  else if (BlockI != BlockEnd) {
435  LiveRegI = (*BlockI)->livein_begin();
436  if (!advanceToValidPosition())
437  return;
438  if (LiveRegI->PhysReg == ExceptionPointer ||
439  LiveRegI->PhysReg == ExceptionSelector)
440  ++(*this);
441  }
442  }
443 
445  do {
446  ++LiveRegI;
447  if (!advanceToValidPosition())
448  return *this;
449  } while ((*BlockI)->isEHPad() &&
450  (LiveRegI->PhysReg == ExceptionPointer ||
451  LiveRegI->PhysReg == ExceptionSelector));
452  return *this;
453  }
454 
456  liveout_iterator Tmp = *this;
457  ++(*this);
458  return Tmp;
459  }
460 
462  return *LiveRegI;
463  }
464 
465  pointer operator->() const {
466  return &*LiveRegI;
467  }
468 
469  bool operator==(const liveout_iterator &RHS) const {
470  if (BlockI != BlockEnd)
471  return BlockI == RHS.BlockI && LiveRegI == RHS.LiveRegI;
472  return RHS.BlockI == BlockEnd;
473  }
474 
475  bool operator!=(const liveout_iterator &RHS) const {
476  return !(*this == RHS);
477  }
478  private:
479  bool advanceToValidPosition() {
480  if (LiveRegI != (*BlockI)->livein_end())
481  return true;
482 
483  do {
484  ++BlockI;
485  } while (BlockI != BlockEnd && (*BlockI)->livein_empty());
486  if (BlockI == BlockEnd)
487  return false;
488 
489  LiveRegI = (*BlockI)->livein_begin();
490  return true;
491  }
492 
493  MCPhysReg ExceptionPointer, ExceptionSelector;
494  const_succ_iterator BlockI;
495  const_succ_iterator BlockEnd;
496  livein_iterator LiveRegI;
497  };
498 
499  /// Iterator scanning successor basic blocks' liveins to determine the
500  /// registers potentially live at the end of this block. There may be
501  /// duplicates or overlapping registers in the list returned.
502  liveout_iterator liveout_begin() const;
504  return liveout_iterator(*this, 0, 0, true);
505  }
507  return make_range(liveout_begin(), liveout_end());
508  }
509 
510  /// Get the clobber mask for the start of this basic block. Funclets use this
511  /// to prevent register allocation across funclet transitions.
512  const uint32_t *getBeginClobberMask(const TargetRegisterInfo *TRI) const;
513 
514  /// Get the clobber mask for the end of the basic block.
515  /// \see getBeginClobberMask()
516  const uint32_t *getEndClobberMask(const TargetRegisterInfo *TRI) const;
517 
518  /// Return alignment of the basic block.
519  Align getAlignment() const { return Alignment; }
520 
521  /// Set alignment of the basic block.
522  void setAlignment(Align A) { Alignment = A; }
523 
524  /// Returns true if the block is a landing pad. That is this basic block is
525  /// entered via an exception handler.
526  bool isEHPad() const { return IsEHPad; }
527 
528  /// Indicates the block is a landing pad. That is this basic block is entered
529  /// via an exception handler.
530  void setIsEHPad(bool V = true) { IsEHPad = V; }
531 
532  bool hasEHPadSuccessor() const;
533 
534  /// Returns true if this is the entry block of the function.
535  bool isEntryBlock() const;
536 
537  /// Returns true if this is the entry block of an EH scope, i.e., the block
538  /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
539  bool isEHScopeEntry() const { return IsEHScopeEntry; }
540 
541  /// Indicates if this is the entry block of an EH scope, i.e., the block that
542  /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
543  void setIsEHScopeEntry(bool V = true) { IsEHScopeEntry = V; }
544 
545  /// Returns true if this is a target block of a catchret.
546  bool isEHCatchretTarget() const { return IsEHCatchretTarget; }
547 
548  /// Indicates if this is a target block of a catchret.
549  void setIsEHCatchretTarget(bool V = true) { IsEHCatchretTarget = V; }
550 
551  /// Returns true if this is the entry block of an EH funclet.
552  bool isEHFuncletEntry() const { return IsEHFuncletEntry; }
553 
554  /// Indicates if this is the entry block of an EH funclet.
555  void setIsEHFuncletEntry(bool V = true) { IsEHFuncletEntry = V; }
556 
557  /// Returns true if this is the entry block of a cleanup funclet.
558  bool isCleanupFuncletEntry() const { return IsCleanupFuncletEntry; }
559 
560  /// Indicates if this is the entry block of a cleanup funclet.
561  void setIsCleanupFuncletEntry(bool V = true) { IsCleanupFuncletEntry = V; }
562 
563  /// Returns true if this block begins any section.
564  bool isBeginSection() const { return IsBeginSection; }
565 
566  /// Returns true if this block ends any section.
567  bool isEndSection() const { return IsEndSection; }
568 
569  void setIsBeginSection(bool V = true) { IsBeginSection = V; }
570 
571  void setIsEndSection(bool V = true) { IsEndSection = V; }
572 
573  /// Returns the section ID of this basic block.
574  MBBSectionID getSectionID() const { return SectionID; }
575 
576  /// Returns the unique section ID number of this basic block.
577  unsigned getSectionIDNum() const {
578  return ((unsigned)MBBSectionID::SectionType::Cold) -
579  ((unsigned)SectionID.Type) + SectionID.Number;
580  }
581 
582  /// Sets the section ID for this basic block.
583  void setSectionID(MBBSectionID V) { SectionID = V; }
584 
585  /// Returns the MCSymbol marking the end of this basic block.
586  MCSymbol *getEndSymbol() const;
587 
588  /// Returns true if this block may have an INLINEASM_BR (overestimate, by
589  /// checking if any of the successors are indirect targets of any inlineasm_br
590  /// in the function).
591  bool mayHaveInlineAsmBr() const;
592 
593  /// Returns true if this is the indirect dest of an INLINEASM_BR.
595  return IsInlineAsmBrIndirectTarget;
596  }
597 
598  /// Indicates if this is the indirect dest of an INLINEASM_BR.
599  void setIsInlineAsmBrIndirectTarget(bool V = true) {
600  IsInlineAsmBrIndirectTarget = V;
601  }
602 
603  /// Returns true if it is legal to hoist instructions into this block.
604  bool isLegalToHoistInto() const;
605 
606  // Code Layout methods.
607 
608  /// Move 'this' block before or after the specified block. This only moves
609  /// the block, it does not modify the CFG or adjust potential fall-throughs at
610  /// the end of the block.
611  void moveBefore(MachineBasicBlock *NewAfter);
612  void moveAfter(MachineBasicBlock *NewBefore);
613 
614  /// Returns true if this and MBB belong to the same section.
615  bool sameSection(const MachineBasicBlock *MBB) const {
616  return getSectionID() == MBB->getSectionID();
617  }
618 
619  /// Update the terminator instructions in block to account for changes to
620  /// block layout which may have been made. PreviousLayoutSuccessor should be
621  /// set to the block which may have been used as fallthrough before the block
622  /// layout was modified. If the block previously fell through to that block,
623  /// it may now need a branch. If it previously branched to another block, it
624  /// may now be able to fallthrough to the current layout successor.
625  void updateTerminator(MachineBasicBlock *PreviousLayoutSuccessor);
626 
627  // Machine-CFG mutators
628 
629  /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
630  /// of Succ is automatically updated. PROB parameter is stored in
631  /// Probabilities list. The default probability is set as unknown. Mixing
632  /// known and unknown probabilities in successor list is not allowed. When all
633  /// successors have unknown probabilities, 1 / N is returned as the
634  /// probability for each successor, where N is the number of successors.
635  ///
636  /// Note that duplicate Machine CFG edges are not allowed.
637  void addSuccessor(MachineBasicBlock *Succ,
639 
640  /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
641  /// of Succ is automatically updated. The probability is not provided because
642  /// BPI is not available (e.g. -O0 is used), in which case edge probabilities
643  /// won't be used. Using this interface can save some space.
645 
646  /// Set successor probability of a given iterator.
648 
649  /// Normalize probabilities of all successors so that the sum of them becomes
650  /// one. This is usually done when the current update on this MBB is done, and
651  /// the sum of its successors' probabilities is not guaranteed to be one. The
652  /// user is responsible for the correct use of this function.
653  /// MBB::removeSuccessor() has an option to do this automatically.
655  BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
656  }
657 
658  /// Validate successors' probabilities and check if the sum of them is
659  /// approximate one. This only works in DEBUG mode.
660  void validateSuccProbs() const;
661 
662  /// Remove successor from the successors list of this MachineBasicBlock. The
663  /// Predecessors list of Succ is automatically updated.
664  /// If NormalizeSuccProbs is true, then normalize successors' probabilities
665  /// after the successor is removed.
667  bool NormalizeSuccProbs = false);
668 
669  /// Remove specified successor from the successors list of this
670  /// MachineBasicBlock. The Predecessors list of Succ is automatically updated.
671  /// If NormalizeSuccProbs is true, then normalize successors' probabilities
672  /// after the successor is removed.
673  /// Return the iterator to the element after the one removed.
675  bool NormalizeSuccProbs = false);
676 
677  /// Replace successor OLD with NEW and update probability info.
679 
680  /// Copy a successor (and any probability info) from original block to this
681  /// block's. Uses an iterator into the original blocks successors.
682  ///
683  /// This is useful when doing a partial clone of successors. Afterward, the
684  /// probabilities may need to be normalized.
686 
687  /// Split the old successor into old plus new and updates the probability
688  /// info.
690  bool NormalizeSuccProbs = false);
691 
692  /// Transfers all the successors from MBB to this machine basic block (i.e.,
693  /// copies all the successors FromMBB and remove all the successors from
694  /// FromMBB).
695  void transferSuccessors(MachineBasicBlock *FromMBB);
696 
697  /// Transfers all the successors, as in transferSuccessors, and update PHI
698  /// operands in the successor blocks which refer to FromMBB to refer to this.
700 
701  /// Return true if any of the successors have probabilities attached to them.
702  bool hasSuccessorProbabilities() const { return !Probs.empty(); }
703 
704  /// Return true if the specified MBB is a predecessor of this block.
705  bool isPredecessor(const MachineBasicBlock *MBB) const;
706 
707  /// Return true if the specified MBB is a successor of this block.
708  bool isSuccessor(const MachineBasicBlock *MBB) const;
709 
710  /// Return true if the specified MBB will be emitted immediately after this
711  /// block, such that if this block exits by falling through, control will
712  /// transfer to the specified MBB. Note that MBB need not be a successor at
713  /// all, for example if this block ends with an unconditional branch to some
714  /// other block.
715  bool isLayoutSuccessor(const MachineBasicBlock *MBB) const;
716 
717  /// Return the fallthrough block if the block can implicitly
718  /// transfer control to the block after it by falling off the end of
719  /// it. This should return null if it can reach the block after
720  /// it, but it uses an explicit branch to do so (e.g., a table
721  /// jump). Non-null return is a conservative answer.
723 
724  /// Return true if the block can implicitly transfer control to the
725  /// block after it by falling off the end of it. This should return
726  /// false if it can reach the block after it, but it uses an
727  /// explicit branch to do so (e.g., a table jump). True is a
728  /// conservative answer.
729  bool canFallThrough();
730 
731  /// Returns a pointer to the first instruction in this block that is not a
732  /// PHINode instruction. When adding instructions to the beginning of the
733  /// basic block, they should be added before the returned value, not before
734  /// the first instruction, which might be PHI.
735  /// Returns end() is there's no non-PHI instruction.
737 
738  /// Return the first instruction in MBB after I that is not a PHI or a label.
739  /// This is the correct point to insert lowered copies at the beginning of a
740  /// basic block that must be before any debugging information.
742 
743  /// Return the first instruction in MBB after I that is not a PHI, label or
744  /// debug. This is the correct point to insert copies at the beginning of a
745  /// basic block.
746  iterator SkipPHIsLabelsAndDebug(iterator I, bool SkipPseudoOp = true);
747 
748  /// Returns an iterator to the first terminator instruction of this basic
749  /// block. If a terminator does not exist, it returns end().
752  return const_cast<MachineBasicBlock *>(this)->getFirstTerminator();
753  }
754 
755  /// Same getFirstTerminator but it ignores bundles and return an
756  /// instr_iterator instead.
758 
759  /// Returns an iterator to the first non-debug instruction in the basic block,
760  /// or end(). Skip any pseudo probe operation if \c SkipPseudoOp is true.
761  /// Pseudo probes are like debug instructions which do not turn into real
762  /// machine code. We try to use the function to skip both debug instructions
763  /// and pseudo probe operations to avoid API proliferation. This should work
764  /// most of the time when considering optimizing the rest of code in the
765  /// block, except for certain cases where pseudo probes are designed to block
766  /// the optimizations. For example, code merge like optimizations are supposed
767  /// to be blocked by pseudo probes for better AutoFDO profile quality.
768  /// Therefore, they should be considered as a valid instruction when this
769  /// function is called in a context of such optimizations. On the other hand,
770  /// \c SkipPseudoOp should be true when it's used in optimizations that
771  /// unlikely hurt profile quality, e.g., without block merging. The default
772  /// value of \c SkipPseudoOp is set to true to maximize code quality in
773  /// general, with an explict false value passed in in a few places like branch
774  /// folding and if-conversion to favor profile quality.
775  iterator getFirstNonDebugInstr(bool SkipPseudoOp = true);
776  const_iterator getFirstNonDebugInstr(bool SkipPseudoOp = true) const {
777  return const_cast<MachineBasicBlock *>(this)->getFirstNonDebugInstr(
778  SkipPseudoOp);
779  }
780 
781  /// Returns an iterator to the last non-debug instruction in the basic block,
782  /// or end(). Skip any pseudo operation if \c SkipPseudoOp is true.
783  /// Pseudo probes are like debug instructions which do not turn into real
784  /// machine code. We try to use the function to skip both debug instructions
785  /// and pseudo probe operations to avoid API proliferation. This should work
786  /// most of the time when considering optimizing the rest of code in the
787  /// block, except for certain cases where pseudo probes are designed to block
788  /// the optimizations. For example, code merge like optimizations are supposed
789  /// to be blocked by pseudo probes for better AutoFDO profile quality.
790  /// Therefore, they should be considered as a valid instruction when this
791  /// function is called in a context of such optimizations. On the other hand,
792  /// \c SkipPseudoOp should be true when it's used in optimizations that
793  /// unlikely hurt profile quality, e.g., without block merging. The default
794  /// value of \c SkipPseudoOp is set to true to maximize code quality in
795  /// general, with an explict false value passed in in a few places like branch
796  /// folding and if-conversion to favor profile quality.
797  iterator getLastNonDebugInstr(bool SkipPseudoOp = true);
798  const_iterator getLastNonDebugInstr(bool SkipPseudoOp = true) const {
799  return const_cast<MachineBasicBlock *>(this)->getLastNonDebugInstr(
800  SkipPseudoOp);
801  }
802 
803  /// Convenience function that returns true if the block ends in a return
804  /// instruction.
805  bool isReturnBlock() const {
806  return !empty() && back().isReturn();
807  }
808 
809  /// Convenience function that returns true if the bock ends in a EH scope
810  /// return instruction.
811  bool isEHScopeReturnBlock() const {
812  return !empty() && back().isEHScopeReturn();
813  }
814 
815  /// Split a basic block into 2 pieces at \p SplitPoint. A new block will be
816  /// inserted after this block, and all instructions after \p SplitInst moved
817  /// to it (\p SplitInst will be in the original block). If \p LIS is provided,
818  /// LiveIntervals will be appropriately updated. \return the newly inserted
819  /// block.
820  ///
821  /// If \p UpdateLiveIns is true, this will ensure the live ins list is
822  /// accurate, including for physreg uses/defs in the original block.
823  MachineBasicBlock *splitAt(MachineInstr &SplitInst, bool UpdateLiveIns = true,
824  LiveIntervals *LIS = nullptr);
825 
826  /// Split the critical edge from this block to the given successor block, and
827  /// return the newly created block, or null if splitting is not possible.
828  ///
829  /// This function updates LiveVariables, MachineDominatorTree, and
830  /// MachineLoopInfo, as applicable.
833  std::vector<SparseBitVector<>> *LiveInSets = nullptr);
834 
835  /// Check if the edge between this block and the given successor \p
836  /// Succ, can be split. If this returns true a subsequent call to
837  /// SplitCriticalEdge is guaranteed to return a valid basic block if
838  /// no changes occurred in the meantime.
839  bool canSplitCriticalEdge(const MachineBasicBlock *Succ) const;
840 
841  void pop_front() { Insts.pop_front(); }
842  void pop_back() { Insts.pop_back(); }
843  void push_back(MachineInstr *MI) { Insts.push_back(MI); }
844 
845  /// Insert MI into the instruction list before I, possibly inside a bundle.
846  ///
847  /// If the insertion point is inside a bundle, MI will be added to the bundle,
848  /// otherwise MI will not be added to any bundle. That means this function
849  /// alone can't be used to prepend or append instructions to bundles. See
850  /// MIBundleBuilder::insert() for a more reliable way of doing that.
852 
853  /// Insert a range of instructions into the instruction list before I.
854  template<typename IT>
855  void insert(iterator I, IT S, IT E) {
856  assert((I == end() || I->getParent() == this) &&
857  "iterator points outside of basic block");
858  Insts.insert(I.getInstrIterator(), S, E);
859  }
860 
861  /// Insert MI into the instruction list before I.
863  assert((I == end() || I->getParent() == this) &&
864  "iterator points outside of basic block");
865  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
866  "Cannot insert instruction with bundle flags");
867  return Insts.insert(I.getInstrIterator(), MI);
868  }
869 
870  /// Insert MI into the instruction list after I.
872  assert((I == end() || I->getParent() == this) &&
873  "iterator points outside of basic block");
874  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
875  "Cannot insert instruction with bundle flags");
876  return Insts.insertAfter(I.getInstrIterator(), MI);
877  }
878 
879  /// If I is bundled then insert MI into the instruction list after the end of
880  /// the bundle, otherwise insert MI immediately after I.
882  assert((I == instr_end() || I->getParent() == this) &&
883  "iterator points outside of basic block");
884  assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
885  "Cannot insert instruction with bundle flags");
886  while (I->isBundledWithSucc())
887  ++I;
888  return Insts.insertAfter(I, MI);
889  }
890 
891  /// Remove an instruction from the instruction list and delete it.
892  ///
893  /// If the instruction is part of a bundle, the other instructions in the
894  /// bundle will still be bundled after removing the single instruction.
896 
897  /// Remove an instruction from the instruction list and delete it.
898  ///
899  /// If the instruction is part of a bundle, the other instructions in the
900  /// bundle will still be bundled after removing the single instruction.
902  return erase(instr_iterator(I));
903  }
904 
905  /// Remove a range of instructions from the instruction list and delete them.
907  return Insts.erase(I.getInstrIterator(), E.getInstrIterator());
908  }
909 
910  /// Remove an instruction or bundle from the instruction list and delete it.
911  ///
912  /// If I points to a bundle of instructions, they are all erased.
914  return erase(I, std::next(I));
915  }
916 
917  /// Remove an instruction from the instruction list and delete it.
918  ///
919  /// If I is the head of a bundle of instructions, the whole bundle will be
920  /// erased.
922  return erase(iterator(I));
923  }
924 
925  /// Remove the unbundled instruction from the instruction list without
926  /// deleting it.
927  ///
928  /// This function can not be used to remove bundled instructions, use
929  /// remove_instr to remove individual instructions from a bundle.
931  assert(!I->isBundled() && "Cannot remove bundled instructions");
932  return Insts.remove(instr_iterator(I));
933  }
934 
935  /// Remove the possibly bundled instruction from the instruction list
936  /// without deleting it.
937  ///
938  /// If the instruction is part of a bundle, the other instructions in the
939  /// bundle will still be bundled after removing the single instruction.
941 
942  void clear() {
943  Insts.clear();
944  }
945 
946  /// Take an instruction from MBB 'Other' at the position From, and insert it
947  /// into this MBB right before 'Where'.
948  ///
949  /// If From points to a bundle of instructions, the whole bundle is moved.
951  // The range splice() doesn't allow noop moves, but this one does.
952  if (Where != From)
953  splice(Where, Other, From, std::next(From));
954  }
955 
956  /// Take a block of instructions from MBB 'Other' in the range [From, To),
957  /// and insert them into this MBB right before 'Where'.
958  ///
959  /// The instruction at 'Where' must not be included in the range of
960  /// instructions to move.
961  void splice(iterator Where, MachineBasicBlock *Other,
962  iterator From, iterator To) {
963  Insts.splice(Where.getInstrIterator(), Other->Insts,
964  From.getInstrIterator(), To.getInstrIterator());
965  }
966 
967  /// This method unlinks 'this' from the containing function, and returns it,
968  /// but does not delete it.
970 
971  /// This method unlinks 'this' from the containing function and deletes it.
972  void eraseFromParent();
973 
974  /// Given a machine basic block that branched to 'Old', change the code and
975  /// CFG so that it branches to 'New' instead.
977 
978  /// Update all phi nodes in this basic block to refer to basic block \p New
979  /// instead of basic block \p Old.
981 
982  /// Find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE
983  /// and DBG_LABEL instructions. Return UnknownLoc if there is none.
986  return findDebugLoc(MBBI.getInstrIterator());
987  }
988 
989  /// Has exact same behavior as @ref findDebugLoc (it also
990  /// searches from the first to the last MI of this MBB) except
991  /// that this takes reverse iterator.
994  return rfindDebugLoc(MBBI.getInstrIterator());
995  }
996 
997  /// Find the previous valid DebugLoc preceding MBBI, skipping and DBG_VALUE
998  /// instructions. Return UnknownLoc if there is none.
1001  return findPrevDebugLoc(MBBI.getInstrIterator());
1002  }
1003 
1004  /// Has exact same behavior as @ref findPrevDebugLoc (it also
1005  /// searches from the last to the first MI of this MBB) except
1006  /// that this takes reverse iterator.
1009  return rfindPrevDebugLoc(MBBI.getInstrIterator());
1010  }
1011 
1012  /// Find and return the merged DebugLoc of the branch instructions of the
1013  /// block. Return UnknownLoc if there is none.
1015 
1016  /// Possible outcome of a register liveness query to computeRegisterLiveness()
1018  LQR_Live, ///< Register is known to be (at least partially) live.
1019  LQR_Dead, ///< Register is known to be fully dead.
1020  LQR_Unknown ///< Register liveness not decidable from local neighborhood.
1021  };
1022 
1023  /// Return whether (physical) register \p Reg has been defined and not
1024  /// killed as of just before \p Before.
1025  ///
1026  /// Search is localised to a neighborhood of \p Neighborhood instructions
1027  /// before (searching for defs or kills) and \p Neighborhood instructions
1028  /// after (searching just for defs) \p Before.
1029  ///
1030  /// \p Reg must be a physical register.
1032  MCRegister Reg,
1033  const_iterator Before,
1034  unsigned Neighborhood = 10) const;
1035 
1036  // Debugging methods.
1037  void dump() const;
1038  void print(raw_ostream &OS, const SlotIndexes * = nullptr,
1039  bool IsStandalone = true) const;
1040  void print(raw_ostream &OS, ModuleSlotTracker &MST,
1041  const SlotIndexes * = nullptr, bool IsStandalone = true) const;
1042 
1044  PrintNameIr = (1 << 0), ///< Add IR name where available
1045  PrintNameAttributes = (1 << 1), ///< Print attributes
1046  };
1047 
1048  void printName(raw_ostream &os, unsigned printNameFlags = PrintNameIr,
1049  ModuleSlotTracker *moduleSlotTracker = nullptr) const;
1050 
1051  // Printing method used by LoopInfo.
1052  void printAsOperand(raw_ostream &OS, bool PrintType = true) const;
1053 
1054  /// MachineBasicBlocks are uniquely numbered at the function level, unless
1055  /// they're not in a MachineFunction yet, in which case this will return -1.
1056  int getNumber() const { return Number; }
1057  void setNumber(int N) { Number = N; }
1058 
1059  /// Return the MCSymbol for this basic block.
1060  MCSymbol *getSymbol() const;
1061 
1062  /// Return the EHCatchret Symbol for this basic block.
1063  MCSymbol *getEHCatchretSymbol() const;
1064 
1066  return IrrLoopHeaderWeight;
1067  }
1068 
1070  IrrLoopHeaderWeight = Weight;
1071  }
1072 
1073 private:
1074  /// Return probability iterator corresponding to the I successor iterator.
1075  probability_iterator getProbabilityIterator(succ_iterator I);
1076  const_probability_iterator
1077  getProbabilityIterator(const_succ_iterator I) const;
1078 
1080  friend class MIPrinter;
1081 
1082  /// Return probability of the edge from this block to MBB. This method should
1083  /// NOT be called directly, but by using getEdgeProbability method from
1084  /// MachineBranchProbabilityInfo class.
1085  BranchProbability getSuccProbability(const_succ_iterator Succ) const;
1086 
1087  // Methods used to maintain doubly linked list of blocks...
1089 
1090  // Machine-CFG mutators
1091 
1092  /// Add Pred as a predecessor of this MachineBasicBlock. Don't do this
1093  /// unless you know what you're doing, because it doesn't update Pred's
1094  /// successors list. Use Pred->addSuccessor instead.
1095  void addPredecessor(MachineBasicBlock *Pred);
1096 
1097  /// Remove Pred as a predecessor of this MachineBasicBlock. Don't do this
1098  /// unless you know what you're doing, because it doesn't update Pred's
1099  /// successors list. Use Pred->removeSuccessor instead.
1100  void removePredecessor(MachineBasicBlock *Pred);
1101 };
1102 
1104 
1105 /// Prints a machine basic block reference.
1106 ///
1107 /// The format is:
1108 /// %bb.5 - a machine basic block with MBB.getNumber() == 5.
1109 ///
1110 /// Usage: OS << printMBBReference(MBB) << '\n';
1112 
1113 // This is useful when building IndexedMaps keyed on basic block pointers.
1116  unsigned operator()(const MachineBasicBlock *MBB) const {
1117  return MBB->getNumber();
1118  }
1119 };
1120 
1121 //===--------------------------------------------------------------------===//
1122 // GraphTraits specializations for machine basic block graphs (machine-CFGs)
1123 //===--------------------------------------------------------------------===//
1124 
1125 // Provide specializations of GraphTraits to be able to treat a
1126 // MachineFunction as a graph of MachineBasicBlocks.
1127 //
1128 
1129 template <> struct GraphTraits<MachineBasicBlock *> {
1132 
1134  static ChildIteratorType child_begin(NodeRef N) { return N->succ_begin(); }
1135  static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
1136 };
1137 
1138 template <> struct GraphTraits<const MachineBasicBlock *> {
1139  using NodeRef = const MachineBasicBlock *;
1141 
1142  static NodeRef getEntryNode(const MachineBasicBlock *BB) { return BB; }
1143  static ChildIteratorType child_begin(NodeRef N) { return N->succ_begin(); }
1144  static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
1145 };
1146 
1147 // Provide specializations of GraphTraits to be able to treat a
1148 // MachineFunction as a graph of MachineBasicBlocks and to walk it
1149 // in inverse order. Inverse order for a function is considered
1150 // to be when traversing the predecessor edges of a MBB
1151 // instead of the successor edges.
1152 //
1153 template <> struct GraphTraits<Inverse<MachineBasicBlock*>> {
1156 
1158  return G.Graph;
1159  }
1160 
1161  static ChildIteratorType child_begin(NodeRef N) { return N->pred_begin(); }
1162  static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); }
1163 };
1164 
1166  using NodeRef = const MachineBasicBlock *;
1168 
1170  return G.Graph;
1171  }
1172 
1173  static ChildIteratorType child_begin(NodeRef N) { return N->pred_begin(); }
1174  static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); }
1175 };
1176 
1177 /// MachineInstrSpan provides an interface to get an iteration range
1178 /// containing the instruction it was initialized with, along with all
1179 /// those instructions inserted prior to or following that instruction
1180 /// at some point after the MachineInstrSpan is constructed.
1182  MachineBasicBlock &MBB;
1184 
1185 public:
1187  : MBB(*BB), I(I), B(I == MBB.begin() ? MBB.end() : std::prev(I)),
1188  E(std::next(I)) {
1189  assert(I == BB->end() || I->getParent() == BB);
1190  }
1191 
1193  return B == MBB.end() ? MBB.begin() : std::next(B);
1194  }
1196  bool empty() { return begin() == end(); }
1197 
1199 };
1200 
1201 /// Increment \p It until it points to a non-debug instruction or to \p End
1202 /// and return the resulting iterator. This function should only be used
1203 /// MachineBasicBlock::{iterator, const_iterator, instr_iterator,
1204 /// const_instr_iterator} and the respective reverse iterators.
1205 template <typename IterT>
1206 inline IterT skipDebugInstructionsForward(IterT It, IterT End,
1207  bool SkipPseudoOp = true) {
1208  while (It != End &&
1209  (It->isDebugInstr() || (SkipPseudoOp && It->isPseudoProbe())))
1210  ++It;
1211  return It;
1212 }
1213 
1214 /// Decrement \p It until it points to a non-debug instruction or to \p Begin
1215 /// and return the resulting iterator. This function should only be used
1216 /// MachineBasicBlock::{iterator, const_iterator, instr_iterator,
1217 /// const_instr_iterator} and the respective reverse iterators.
1218 template <class IterT>
1219 inline IterT skipDebugInstructionsBackward(IterT It, IterT Begin,
1220  bool SkipPseudoOp = true) {
1221  while (It != Begin &&
1222  (It->isDebugInstr() || (SkipPseudoOp && It->isPseudoProbe())))
1223  --It;
1224  return It;
1225 }
1226 
1227 /// Increment \p It, then continue incrementing it while it points to a debug
1228 /// instruction. A replacement for std::next.
1229 template <typename IterT>
1230 inline IterT next_nodbg(IterT It, IterT End, bool SkipPseudoOp = true) {
1231  return skipDebugInstructionsForward(std::next(It), End, SkipPseudoOp);
1232 }
1233 
1234 /// Decrement \p It, then continue decrementing it while it points to a debug
1235 /// instruction. A replacement for std::prev.
1236 template <typename IterT>
1237 inline IterT prev_nodbg(IterT It, IterT Begin, bool SkipPseudoOp = true) {
1238  return skipDebugInstructionsBackward(std::prev(It), Begin, SkipPseudoOp);
1239 }
1240 
1241 /// Construct a range iterator which begins at \p It and moves forwards until
1242 /// \p End is reached, skipping any debug instructions.
1243 template <typename IterT>
1244 inline auto instructionsWithoutDebug(IterT It, IterT End,
1245  bool SkipPseudoOp = true) {
1246  return make_filter_range(make_range(It, End), [=](const MachineInstr &MI) {
1247  return !MI.isDebugInstr() && !(SkipPseudoOp && MI.isPseudoProbe());
1248  });
1249 }
1250 
1251 } // end namespace llvm
1252 
1253 #endif // LLVM_CODEGEN_MACHINEBASICBLOCK_H
llvm::LaneBitmask
Definition: LaneBitmask.h:40
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:1230
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:1174
llvm::GraphTraits< Inverse< const MachineBasicBlock * > >::getEntryNode
static NodeRef getEntryNode(Inverse< const MachineBasicBlock * > G)
Definition: MachineBasicBlock.h:1169
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:105
MachineInstr.h
llvm::MachineBasicBlock::setIrrLoopHeaderWeight
void setIrrLoopHeaderWeight(uint64_t Weight)
Definition: MachineBasicBlock.h:1069
llvm
This file implements support for optimizing divisions by a constant.
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
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:961
Pass
print lazy value Lazy Value Info Printer Pass
Definition: LazyValueInfo.cpp:1965
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:580
llvm::MachineBasicBlock::setIsCleanupFuncletEntry
void setIsCleanupFuncletEntry(bool V=true)
Indicates if this is the entry block of a cleanup funclet.
Definition: MachineBasicBlock.h:561
llvm::MachineBasicBlock::LivenessQueryResult
LivenessQueryResult
Possible outcome of a register liveness query to computeRegisterLiveness()
Definition: MachineBasicBlock.h:1017
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:1043
llvm::MachineBasicBlock::erase
iterator erase(iterator I)
Remove an instruction or bundle from the instruction list and delete it.
Definition: MachineBasicBlock.h:913
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:1344
llvm::MachineInstrSpan
MachineInstrSpan provides an interface to get an iteration range containing the instruction it was in...
Definition: MachineBasicBlock.h:1181
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:942
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:819
llvm::MachineBasicBlock::isEHFuncletEntry
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
Definition: MachineBasicBlock.h:552
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:906
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:881
llvm::printMBBReference
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
Definition: MachineBasicBlock.cpp:119
llvm::MachineBasicBlock::setIsEHCatchretTarget
void setIsEHCatchretTarget(bool V=true)
Indicates if this is a target block of a catchret.
Definition: MachineBasicBlock.h:549
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:290
llvm::MachineBasicBlock::setSuccProbability
void setSuccProbability(succ_iterator I, BranchProbability Prob)
Set successor probability of a given iterator.
Definition: MachineBasicBlock.cpp:1456
llvm::MachineBasicBlock::getEHCatchretSymbol
MCSymbol * getEHCatchretSymbol() const
Return the EHCatchret Symbol for this basic block.
Definition: MachineBasicBlock.cpp:91
llvm::MachineBasicBlock::isReturnBlock
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction.
Definition: MachineBasicBlock.h:805
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:1378
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:233
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:1142
llvm::MachineBasicBlock::moveBefore
void moveBefore(MachineBasicBlock *NewAfter)
Move 'this' block before or after the specified block.
Definition: MachineBasicBlock.cpp:638
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::MachineBasicBlock::liveins
iterator_range< livein_iterator > liveins() const
Definition: MachineBasicBlock.h:412
llvm::MachineBasicBlock::liveout_iterator::operator*
reference operator*() const
Definition: MachineBasicBlock.h:461
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:1065
llvm::GraphTraits< const MachineBasicBlock * >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: MachineBasicBlock.h:1144
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:1161
llvm::MachineBasicBlock::addSuccessorWithoutProb
void addSuccessorWithoutProb(MachineBasicBlock *Succ)
Add Succ as a successor of this MachineBasicBlock.
Definition: MachineBasicBlock.cpp:761
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:1008
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:852
llvm::MachineBasicBlock::insert
iterator insert(iterator I, MachineInstr *MI)
Insert MI into the instruction list before I.
Definition: MachineBasicBlock.h:862
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:44
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::GraphTraits< const MachineBasicBlock * >::ChildIteratorType
MachineBasicBlock::const_succ_iterator ChildIteratorType
Definition: MachineBasicBlock.h:1140
llvm::GraphTraits< MachineBasicBlock * >::getEntryNode
static NodeRef getEntryNode(MachineBasicBlock *BB)
Definition: MachineBasicBlock.h:1133
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:842
llvm::MachineBasicBlock::dump
void dump() const
Definition: MachineBasicBlock.cpp:295
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:1304
llvm::MachineBasicBlock::isBeginSection
bool isBeginSection() const
Returns true if this block begins any section.
Definition: MachineBasicBlock.h:564
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:478
GraphTraits.h
llvm::MachineBasicBlock::liveout_iterator::operator++
liveout_iterator & operator++()
Definition: MachineBasicBlock.h:444
SparseBitVector.h
llvm::MachineBasicBlock::setSectionID
void setSectionID(MBBSectionID V)
Sets the section ID for this basic block.
Definition: MachineBasicBlock.h:583
llvm::MachineBasicBlock::addSuccessor
void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
Definition: MachineBasicBlock.cpp:751
llvm::MachineBasicBlock::getSymbol
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
Definition: MachineBasicBlock.cpp:60
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:843
llvm::MachineBasicBlock::pred_size
unsigned pred_size() const
Definition: MachineBasicBlock.h:328
llvm::MachineBasicBlock::liveouts
iterator_range< liveout_iterator > liveouts() const
Definition: MachineBasicBlock.h:506
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:599
llvm::MachineBasicBlock::getFirstInstrTerminator
instr_iterator getFirstInstrTerminator()
Same getFirstTerminator but it ignores bundles and return an instr_iterator instead.
Definition: MachineBasicBlock.cpp:251
llvm::MachineBasicBlock::insertAfter
iterator insertAfter(iterator I, MachineInstr *MI)
Insert MI into the instruction list after I.
Definition: MachineBasicBlock.h:871
llvm::MachineBasicBlock::removeFromParent
MachineBasicBlock * removeFromParent()
This method unlinks 'this' from the containing function, and returns it, but does not delete it.
Definition: MachineBasicBlock.cpp:1330
llvm::MachineBasicBlock::remove
MachineInstr * remove(MachineInstr *I)
Remove the unbundled instruction from the instruction list without deleting it.
Definition: MachineBasicBlock.h:930
llvm::MachineBranchProbabilityInfo
Definition: MachineBranchProbabilityInfo.h:24
llvm::MachineBasicBlock::liveout_iterator::operator++
liveout_iterator operator++(int)
Definition: MachineBasicBlock.h:455
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:1162
llvm::MachineBasicBlock::isSuccessor
bool isSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB is a successor of this block.
Definition: MachineBasicBlock.cpp:913
llvm::MachineBasicBlock::eraseFromParent
void eraseFromParent()
This method unlinks 'this' from the containing function and deletes it.
Definition: MachineBasicBlock.cpp:1337
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:308
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:970
llvm::MachineBasicBlock::isEHCatchretTarget
bool isEHCatchretTarget() const
Returns true if this is a target block of a catchret.
Definition: MachineBasicBlock.h:546
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
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:1192
DebugLoc.h
llvm::MachineBasicBlock::isCleanupFuncletEntry
bool isCleanupFuncletEntry() const
Returns true if this is the entry block of a cleanup funclet.
Definition: MachineBasicBlock.h:558
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:1195
llvm::BranchProbability::getUnknown
static BranchProbability getUnknown()
Definition: BranchProbability.h:51
llvm::MachineBasicBlock::getLastNonDebugInstr
const_iterator getLastNonDebugInstr(bool SkipPseudoOp=true) const
Definition: MachineBasicBlock.h:798
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:811
llvm::MachineBasicBlock::findPrevDebugLoc
DebugLoc findPrevDebugLoc(instr_iterator MBBI)
Find the previous valid DebugLoc preceding MBBI, skipping and DBG_VALUE instructions.
Definition: MachineBasicBlock.cpp:1396
llvm::GraphTraits< MachineBasicBlock * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: MachineBasicBlock.h:1134
llvm::GraphTraits< Inverse< MachineBasicBlock * > >::ChildIteratorType
MachineBasicBlock::pred_iterator ChildIteratorType
Definition: MachineBasicBlock.h:1155
llvm::MachineBasicBlock::getSectionIDNum
unsigned getSectionIDNum() const
Returns the unique section ID number of this basic block.
Definition: MachineBasicBlock.h:577
llvm::MachineBasicBlock::setAlignment
void setAlignment(Align A)
Set alignment of the basic block.
Definition: MachineBasicBlock.h:522
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:1198
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:1157
llvm::MachineInstrSpan::empty
bool empty()
Definition: MachineBasicBlock.h:1196
llvm::MachineBasicBlock::hasSuccessorProbabilities
bool hasSuccessorProbabilities() const
Return true if any of the successors have probabilities attached to them.
Definition: MachineBasicBlock.h:702
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:300
llvm::MachineBasicBlock::printAsOperand
void printAsOperand(raw_ostream &OS, bool PrintType=true) const
Definition: MachineBasicBlock.cpp:556
llvm::MachineBasicBlock::instr_back
const MachineInstr & instr_back() const
Definition: MachineBasicBlock.h:245
llvm::MachineBasicBlock::liveout_iterator::operator==
bool operator==(const liveout_iterator &RHS) const
Definition: MachineBasicBlock.h:469
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
uint64_t
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:530
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:210
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:1018
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::MCPhysReg
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition: MCRegister.h:21
llvm::MachineBasicBlock::getFirstTerminator
const_iterator getFirstTerminator() const
Definition: MachineBasicBlock.h:751
llvm::GraphTraits< const MachineBasicBlock * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: MachineBasicBlock.h:1143
llvm::MachineBasicBlock::getFirstNonPHI
iterator getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: MachineBasicBlock.cpp:200
llvm::GraphTraits< Inverse< const MachineBasicBlock * > >::ChildIteratorType
MachineBasicBlock::const_pred_iterator ChildIteratorType
Definition: MachineBasicBlock.h:1167
llvm::MachineBasicBlock::liveout_end
liveout_iterator liveout_end() const
Definition: MachineBasicBlock.h:503
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:1237
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:267
llvm::MachineBasicBlock::getAlignment
Align getAlignment() const
Return alignment of the basic block.
Definition: MachineBasicBlock.h:519
llvm::MachineBasicBlock::liveout_iterator::iterator_category
std::input_iterator_tag iterator_category
Definition: MachineBasicBlock.h:421
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:571
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:149
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:966
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
llvm::MachineBasicBlock::liveout_iterator::operator!=
bool operator!=(const liveout_iterator &RHS) const
Definition: MachineBasicBlock.h:475
iterator_range.h
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::MBB2NumberFunctor::operator()
unsigned operator()(const MachineBasicBlock *MBB) const
Definition: MachineBasicBlock.h:1116
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::CallingConv::Cold
@ Cold
Definition: CallingConv.h:48
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:1019
llvm::MachineInstr::isReturn
bool isReturn(QueryType Type=AnyInBundle) const
Definition: MachineInstr.h:813
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:1135
llvm::MachineBasicBlock::setIsEHFuncletEntry
void setIsEHFuncletEntry(bool V=true)
Indicates if this is the entry block of an EH funclet.
Definition: MachineBasicBlock.h:555
llvm::MachineBasicBlock::instr_end
instr_iterator instr_end()
Definition: MachineBasicBlock.h:254
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::MachineBasicBlock::moveAfter
void moveAfter(MachineBasicBlock *NewBefore)
Definition: MachineBasicBlock.cpp:642
llvm::MachineBasicBlock::succ_empty
bool succ_empty() const
Definition: MachineBasicBlock.h:347
llvm::MachineBasicBlock::PrintNameIr
@ PrintNameIr
Add IR name where available.
Definition: MachineBasicBlock.h:1044
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:242
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:1206
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:1588
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:1056
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:539
llvm::MachineBasicBlock::PrintNameAttributes
@ PrintNameAttributes
Print attributes.
Definition: MachineBasicBlock.h:1045
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:261
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:526
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::MachineBasicBlock::getFirstNonDebugInstr
const_iterator getFirstNonDebugInstr(bool SkipPseudoOp=true) const
Definition: MachineBasicBlock.h:776
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:950
llvm::MachineBasicBlock::hasEHPadSuccessor
bool hasEHPadSuccessor() const
Definition: MachineBasicBlock.cpp:283
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:322
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:1417
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:562
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:1386
Number
uint32_t Number
Definition: Profile.cpp:47
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:1186
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:770
llvm::MachineBasicBlock::liveout_begin
liveout_iterator liveout_begin() const
Iterator scanning successor basic blocks' liveins to determine the registers potentially live at the ...
Definition: MachineBasicBlock.cpp:1612
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:870
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:490
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:574
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:543
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:909
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:102
llvm::MachineBasicBlock::setNumber
void setNumber(int N)
Definition: MachineBasicBlock.h:1057
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:1250
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:812
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:1365
llvm::MachineBasicBlock::sortUniqueLiveIns
void sortUniqueLiveIns()
Sorts and uniques the LiveIns vector.
Definition: MachineBasicBlock.cpp:586
uint16_t
llvm::MachineBasicBlock::removeSuccessor
void removeSuccessor(MachineBasicBlock *Succ, bool NormalizeSuccProbs=false)
Remove successor from the successors list of this MachineBasicBlock.
Definition: MachineBasicBlock.cpp:789
llvm::MachineBasicBlock::isEndSection
bool isEndSection() const
Returns true if this block ends any section.
Definition: MachineBasicBlock.h:567
llvm::GraphTraits< MachineBasicBlock * >::ChildIteratorType
MachineBasicBlock::succ_iterator ChildIteratorType
Definition: MachineBasicBlock.h:1131
llvm::MachineBasicBlock::erase
iterator erase(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
Definition: MachineBasicBlock.h:921
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:1317
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:1490
llvm::MBBSectionID::operator!=
bool operator!=(const MBBSectionID &Other) const
Definition: MachineBasicBlock.h:71
llvm::MachineBasicBlock::liveout_iterator
Definition: MachineBasicBlock.h:419
llvm::MachineBasicBlock::instr_iterator
Instructions::iterator instr_iterator
Definition: MachineBasicBlock.h:228
llvm::MachineBasicBlock::setIsBeginSection
void setIsBeginSection(bool V=true)
Definition: MachineBasicBlock.h:569
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::MachineBasicBlock::liveout_iterator::operator->
pointer operator->() const
Definition: MachineBasicBlock.h:465
llvm::MBB2NumberFunctor
Definition: MachineBasicBlock.h:1114
llvm::MachineBasicBlock::livein_begin
livein_iterator livein_begin() const
Definition: MachineBasicBlock.cpp:1605
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:917
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:1404
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:654
llvm::MachineBasicBlock::livein_empty
bool livein_empty() const
Definition: MachineBasicBlock.h:411
llvm::MachineBasicBlock::findPrevDebugLoc
DebugLoc findPrevDebugLoc(iterator MBBI)
Definition: MachineBasicBlock.h:1000
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:922
llvm::MachineBasicBlock::pop_front
void pop_front()
Definition: MachineBasicBlock.h:841
llvm::MachineBasicBlock::validateSuccProbs
void validateSuccProbs() const
Validate successors' probabilities and check if the sum of them is approximate one.
Definition: MachineBasicBlock.cpp:737
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:1594
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:1219
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:594
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:38
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:985
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:1601
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:1173
llvm::MachineBasicBlock::erase_instr
instr_iterator erase_instr(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
Definition: MachineBasicBlock.h:901
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:855
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:890
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:1020
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:225
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:333
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:646
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:993
llvm::MachineBasicBlock::pred_rend
const_pred_reverse_iterator pred_rend() const
Definition: MachineBasicBlock.h:326
llvm::MachineBasicBlock::liveout_iterator::difference_type
std::ptrdiff_t difference_type
Definition: MachineBasicBlock.h:422
llvm::MachineInstrBundleIterator< MachineInstr >
llvm::MachineBasicBlock::getSublistAccess
static Instructions MachineBasicBlock::* getSublistAccess(MachineInstr *)
Support for MachineInstr::getNextNode().
Definition: MachineBasicBlock.h:284
llvm::MachineBasicBlock::liveout_iterator::liveout_iterator
liveout_iterator(const MachineBasicBlock &MBB, MCPhysReg ExceptionPointer, MCPhysReg ExceptionSelector, bool End)
Definition: MachineBasicBlock.h:427
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:1011
llvm::MachineBasicBlock::remove_instr
MachineInstr * remove_instr(MachineInstr *I)
Remove the possibly bundled instruction from the instruction list without deleting it.
Definition: MachineBasicBlock.cpp:1309
llvm::MachineBasicBlock::getName
StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
Definition: MachineBasicBlock.cpp:314
llvm::MachineBasicBlock::end
iterator end()
Definition: MachineBasicBlock.h:270
llvm::LaneBitmask::getAll
static constexpr LaneBitmask getAll()
Definition: LaneBitmask.h:84
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:172
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:1244
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1184
llvm::MCRegister
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:24
llvm::MachineBasicBlock::sameSection
bool sameSection(const MachineBasicBlock *MBB) const
Returns true if this and MBB belong to the same section.
Definition: MachineBasicBlock.h:615
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