LLVM 19.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
18#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 <iterator>
28#include <string>
29#include <vector>
30
31namespace llvm {
32
33class BasicBlock;
34class MachineFunction;
35class MCSymbol;
36class ModuleSlotTracker;
37class Pass;
38class Printable;
39class SlotIndexes;
40class StringRef;
41class raw_ostream;
42class LiveIntervals;
43class TargetRegisterClass;
44class TargetRegisterInfo;
45
46// This structure uniquely identifies a basic block section.
47// Possible values are
48// {Type: Default, Number: (unsigned)} (These are regular section IDs)
49// {Type: Exception, Number: 0} (ExceptionSectionID)
50// {Type: Cold, Number: 0} (ColdSectionID)
53 Default = 0, // Regular section (these sections are distinguished by the
54 // Number field).
55 Exception, // Special section type for exception handling blocks
56 Cold, // Special section type for cold blocks
58 unsigned Number;
59
60 MBBSectionID(unsigned N) : Type(Default), Number(N) {}
61
62 // Special unique sections for cold and exception blocks.
65
66 bool operator==(const MBBSectionID &Other) const {
67 return Type == Other.Type && Number == Other.Number;
68 }
69
70 bool operator!=(const MBBSectionID &Other) const { return !(*this == Other); }
71
72private:
73 // This is only used to construct the special cold and exception sections.
75};
76
77// This structure represents the information for a basic block pertaining to
78// the basic block sections profile.
79struct UniqueBBID {
80 unsigned BaseID;
81 unsigned CloneID;
82};
83
84template <> struct ilist_traits<MachineInstr> {
85private:
86 friend class MachineBasicBlock; // Set by the owning MachineBasicBlock.
87
88 MachineBasicBlock *Parent;
89
90 using instr_iterator =
92
93public:
96 void transferNodesFromList(ilist_traits &FromList, instr_iterator First,
97 instr_iterator Last);
99};
100
102 : public ilist_node_with_parent<MachineBasicBlock, MachineFunction> {
103public:
104 /// Pair of physical register and lane mask.
105 /// This is not simply a std::pair typedef because the members should be named
106 /// clearly as they both have an integer type.
108 public:
111
114
115 bool operator==(const RegisterMaskPair &other) const {
116 return PhysReg == other.PhysReg && LaneMask == other.LaneMask;
117 }
118 };
119
120private:
122
123 const BasicBlock *BB;
124 int Number;
125
126 /// The call frame size on entry to this basic block due to call frame setup
127 /// instructions in a predecessor. This is usually zero, unless basic blocks
128 /// are split in the middle of a call sequence.
129 ///
130 /// This information is only maintained until PrologEpilogInserter eliminates
131 /// call frame pseudos.
132 unsigned CallFrameSize = 0;
133
134 MachineFunction *xParent;
135 Instructions Insts;
136
137 /// Keep track of the predecessor / successor basic blocks.
138 std::vector<MachineBasicBlock *> Predecessors;
139 std::vector<MachineBasicBlock *> Successors;
140
141 /// Keep track of the probabilities to the successors. This vector has the
142 /// same order as Successors, or it is empty if we don't use it (disable
143 /// optimization).
144 std::vector<BranchProbability> Probs;
145 using probability_iterator = std::vector<BranchProbability>::iterator;
146 using const_probability_iterator =
147 std::vector<BranchProbability>::const_iterator;
148
149 std::optional<uint64_t> IrrLoopHeaderWeight;
150
151 /// Keep track of the physical registers that are livein of the basicblock.
152 using LiveInVector = std::vector<RegisterMaskPair>;
153 LiveInVector LiveIns;
154
155 /// Alignment of the basic block. One if the basic block does not need to be
156 /// aligned.
157 Align Alignment;
158 /// Maximum amount of bytes that can be added to align the basic block. If the
159 /// alignment cannot be reached in this many bytes, no bytes are emitted.
160 /// Zero to represent no maximum.
161 unsigned MaxBytesForAlignment = 0;
162
163 /// Indicate that this basic block is entered via an exception handler.
164 bool IsEHPad = false;
165
166 /// Indicate that this MachineBasicBlock is referenced somewhere other than
167 /// as predecessor/successor, a terminator MachineInstr, or a jump table.
168 bool MachineBlockAddressTaken = false;
169
170 /// If this MachineBasicBlock corresponds to an IR-level "blockaddress"
171 /// constant, this contains a pointer to that block.
172 BasicBlock *AddressTakenIRBlock = nullptr;
173
174 /// Indicate that this basic block needs its symbol be emitted regardless of
175 /// whether the flow just falls-through to it.
176 bool LabelMustBeEmitted = false;
177
178 /// Indicate that this basic block is the entry block of an EH scope, i.e.,
179 /// the block that used to have a catchpad or cleanuppad instruction in the
180 /// LLVM IR.
181 bool IsEHScopeEntry = false;
182
183 /// Indicates if this is a target block of a catchret.
184 bool IsEHCatchretTarget = false;
185
186 /// Indicate that this basic block is the entry block of an EH funclet.
187 bool IsEHFuncletEntry = false;
188
189 /// Indicate that this basic block is the entry block of a cleanup funclet.
190 bool IsCleanupFuncletEntry = false;
191
192 /// Fixed unique ID assigned to this basic block upon creation. Used with
193 /// basic block sections and basic block labels.
194 std::optional<UniqueBBID> BBID;
195
196 /// With basic block sections, this stores the Section ID of the basic block.
197 MBBSectionID SectionID{0};
198
199 // Indicate that this basic block begins a section.
200 bool IsBeginSection = false;
201
202 // Indicate that this basic block ends a section.
203 bool IsEndSection = false;
204
205 /// Indicate that this basic block is the indirect dest of an INLINEASM_BR.
206 bool IsInlineAsmBrIndirectTarget = false;
207
208 /// since getSymbol is a relatively heavy-weight operation, the symbol
209 /// is only computed once and is cached.
210 mutable MCSymbol *CachedMCSymbol = nullptr;
211
212 /// Cached MCSymbol for this block (used if IsEHCatchRetTarget).
213 mutable MCSymbol *CachedEHCatchretMCSymbol = nullptr;
214
215 /// Marks the end of the basic block. Used during basic block sections to
216 /// calculate the size of the basic block, or the BB section ending with it.
217 mutable MCSymbol *CachedEndMCSymbol = nullptr;
218
219 // Intrusive list support
220 MachineBasicBlock() = default;
221
222 explicit MachineBasicBlock(MachineFunction &MF, const BasicBlock *BB);
223
224 ~MachineBasicBlock();
225
226 // MachineBasicBlocks are allocated and owned by MachineFunction.
227 friend class MachineFunction;
228
229public:
230 /// Return the LLVM basic block that this instance corresponded to originally.
231 /// Note that this may be NULL if this instance does not correspond directly
232 /// to an LLVM basic block.
233 const BasicBlock *getBasicBlock() const { return BB; }
234
235 /// Remove the reference to the underlying IR BasicBlock. This is for
236 /// reduction tools and should generally not be used.
238 BB = nullptr;
239 }
240
241 /// Return the name of the corresponding LLVM basic block, or an empty string.
242 StringRef getName() const;
243
244 /// Return a formatted string to identify this block and its parent function.
245 std::string getFullName() const;
246
247 /// Test whether this block is used as something other than the target
248 /// of a terminator, exception-handling target, or jump table. This is
249 /// either the result of an IR-level "blockaddress", or some form
250 /// of target-specific branch lowering.
251 bool hasAddressTaken() const {
252 return MachineBlockAddressTaken || AddressTakenIRBlock;
253 }
254
255 /// Test whether this block is used as something other than the target of a
256 /// terminator, exception-handling target, jump table, or IR blockaddress.
257 /// For example, its address might be loaded into a register, or
258 /// stored in some branch table that isn't part of MachineJumpTableInfo.
259 bool isMachineBlockAddressTaken() const { return MachineBlockAddressTaken; }
260
261 /// Test whether this block is the target of an IR BlockAddress. (There can
262 /// more than one MBB associated with an IR BB where the address is taken.)
263 bool isIRBlockAddressTaken() const { return AddressTakenIRBlock; }
264
265 /// Retrieves the BasicBlock which corresponds to this MachineBasicBlock.
266 BasicBlock *getAddressTakenIRBlock() const { return AddressTakenIRBlock; }
267
268 /// Set this block to indicate that its address is used as something other
269 /// than the target of a terminator, exception-handling target, jump table,
270 /// or IR-level "blockaddress".
271 void setMachineBlockAddressTaken() { MachineBlockAddressTaken = true; }
272
273 /// Set this block to reflect that it corresponds to an IR-level basic block
274 /// with a BlockAddress.
275 void setAddressTakenIRBlock(BasicBlock *BB) { AddressTakenIRBlock = BB; }
276
277 /// Test whether this block must have its label emitted.
278 bool hasLabelMustBeEmitted() const { return LabelMustBeEmitted; }
279
280 /// Set this block to reflect that, regardless how we flow to it, we need
281 /// its label be emitted.
282 void setLabelMustBeEmitted() { LabelMustBeEmitted = true; }
283
284 /// Return the MachineFunction containing this basic block.
285 const MachineFunction *getParent() const { return xParent; }
286 MachineFunction *getParent() { return xParent; }
287
292
298
299 unsigned size() const { return (unsigned)Insts.size(); }
300 bool sizeWithoutDebugLargerThan(unsigned Limit) const;
301 bool empty() const { return Insts.empty(); }
302
303 MachineInstr &instr_front() { return Insts.front(); }
304 MachineInstr &instr_back() { return Insts.back(); }
305 const MachineInstr &instr_front() const { return Insts.front(); }
306 const MachineInstr &instr_back() const { return Insts.back(); }
307
308 MachineInstr &front() { return Insts.front(); }
309 MachineInstr &back() { return *--end(); }
310 const MachineInstr &front() const { return Insts.front(); }
311 const MachineInstr &back() const { return *--end(); }
312
313 instr_iterator instr_begin() { return Insts.begin(); }
314 const_instr_iterator instr_begin() const { return Insts.begin(); }
315 instr_iterator instr_end() { return Insts.end(); }
316 const_instr_iterator instr_end() const { return Insts.end(); }
317 reverse_instr_iterator instr_rbegin() { return Insts.rbegin(); }
318 const_reverse_instr_iterator instr_rbegin() const { return Insts.rbegin(); }
319 reverse_instr_iterator instr_rend () { return Insts.rend(); }
320 const_reverse_instr_iterator instr_rend () const { return Insts.rend(); }
321
327 }
328
329 iterator begin() { return instr_begin(); }
330 const_iterator begin() const { return instr_begin(); }
331 iterator end () { return instr_end(); }
332 const_iterator end () const { return instr_end(); }
335 }
338 }
342 }
343
344 /// Support for MachineInstr::getNextNode().
346 return &MachineBasicBlock::Insts;
347 }
348
350 return make_range(getFirstTerminator(), end());
351 }
353 return make_range(getFirstTerminator(), end());
354 }
355
356 /// Returns a range that iterates over the phis in the basic block.
358 return make_range(begin(), getFirstNonPHI());
359 }
361 return const_cast<MachineBasicBlock *>(this)->phis();
362 }
363
364 // Machine-CFG iterators
365 using pred_iterator = std::vector<MachineBasicBlock *>::iterator;
366 using const_pred_iterator = std::vector<MachineBasicBlock *>::const_iterator;
367 using succ_iterator = std::vector<MachineBasicBlock *>::iterator;
368 using const_succ_iterator = std::vector<MachineBasicBlock *>::const_iterator;
370 std::vector<MachineBasicBlock *>::reverse_iterator;
372 std::vector<MachineBasicBlock *>::const_reverse_iterator;
374 std::vector<MachineBasicBlock *>::reverse_iterator;
376 std::vector<MachineBasicBlock *>::const_reverse_iterator;
377 pred_iterator pred_begin() { return Predecessors.begin(); }
378 const_pred_iterator pred_begin() const { return Predecessors.begin(); }
379 pred_iterator pred_end() { return Predecessors.end(); }
380 const_pred_iterator pred_end() const { return Predecessors.end(); }
382 { return Predecessors.rbegin();}
384 { return Predecessors.rbegin();}
386 { return Predecessors.rend(); }
388 { return Predecessors.rend(); }
389 unsigned pred_size() const {
390 return (unsigned)Predecessors.size();
391 }
392 bool pred_empty() const { return Predecessors.empty(); }
393 succ_iterator succ_begin() { return Successors.begin(); }
394 const_succ_iterator succ_begin() const { return Successors.begin(); }
395 succ_iterator succ_end() { return Successors.end(); }
396 const_succ_iterator succ_end() const { return Successors.end(); }
398 { return Successors.rbegin(); }
400 { return Successors.rbegin(); }
402 { return Successors.rend(); }
404 { return Successors.rend(); }
405 unsigned succ_size() const {
406 return (unsigned)Successors.size();
407 }
408 bool succ_empty() const { return Successors.empty(); }
409
411 return make_range(pred_begin(), pred_end());
412 }
414 return make_range(pred_begin(), pred_end());
415 }
417 return make_range(succ_begin(), succ_end());
418 }
420 return make_range(succ_begin(), succ_end());
421 }
422
423 // LiveIn management methods.
424
425 /// Adds the specified register as a live in. Note that it is an error to add
426 /// the same register to the same set more than once unless the intention is
427 /// to call sortUniqueLiveIns after all registers are added.
428 void addLiveIn(MCRegister PhysReg,
429 LaneBitmask LaneMask = LaneBitmask::getAll()) {
430 LiveIns.push_back(RegisterMaskPair(PhysReg, LaneMask));
431 }
432 void addLiveIn(const RegisterMaskPair &RegMaskPair) {
433 LiveIns.push_back(RegMaskPair);
434 }
435
436 /// Sorts and uniques the LiveIns vector. It can be significantly faster to do
437 /// this than repeatedly calling isLiveIn before calling addLiveIn for every
438 /// LiveIn insertion.
439 void sortUniqueLiveIns();
440
441 /// Clear live in list.
442 void clearLiveIns();
443
444 /// Add PhysReg as live in to this block, and ensure that there is a copy of
445 /// PhysReg to a virtual register of class RC. Return the virtual register
446 /// that is a copy of the live in PhysReg.
448
449 /// Remove the specified register from the live in set.
451 LaneBitmask LaneMask = LaneBitmask::getAll());
452
453 /// Return true if the specified register is in the live in set.
455 LaneBitmask LaneMask = LaneBitmask::getAll()) const;
456
457 // Iteration support for live in sets. These sets are kept in sorted
458 // order by their register number.
459 using livein_iterator = LiveInVector::const_iterator;
460
461 /// Unlike livein_begin, this method does not check that the liveness
462 /// information is accurate. Still for debug purposes it may be useful
463 /// to have iterators that won't assert if the liveness information
464 /// is not current.
465 livein_iterator livein_begin_dbg() const { return LiveIns.begin(); }
468 }
469
471 livein_iterator livein_end() const { return LiveIns.end(); }
472 bool livein_empty() const { return LiveIns.empty(); }
475 }
476
477 /// Remove entry from the livein set and return iterator to the next.
479
480 std::vector<RegisterMaskPair> getLiveIns() const { return LiveIns; }
481
483 public:
484 using iterator_category = std::input_iterator_tag;
485 using difference_type = std::ptrdiff_t;
487 using pointer = const RegisterMaskPair *;
489
491 MCPhysReg ExceptionSelector, bool End)
492 : ExceptionPointer(ExceptionPointer),
493 ExceptionSelector(ExceptionSelector), BlockI(MBB.succ_begin()),
494 BlockEnd(MBB.succ_end()) {
495 if (End)
496 BlockI = BlockEnd;
497 else if (BlockI != BlockEnd) {
498 LiveRegI = (*BlockI)->livein_begin();
499 if (!advanceToValidPosition())
500 return;
501 if (LiveRegI->PhysReg == ExceptionPointer ||
502 LiveRegI->PhysReg == ExceptionSelector)
503 ++(*this);
504 }
505 }
506
508 do {
509 ++LiveRegI;
510 if (!advanceToValidPosition())
511 return *this;
512 } while ((*BlockI)->isEHPad() &&
513 (LiveRegI->PhysReg == ExceptionPointer ||
514 LiveRegI->PhysReg == ExceptionSelector));
515 return *this;
516 }
517
519 liveout_iterator Tmp = *this;
520 ++(*this);
521 return Tmp;
522 }
523
525 return *LiveRegI;
526 }
527
529 return &*LiveRegI;
530 }
531
532 bool operator==(const liveout_iterator &RHS) const {
533 if (BlockI != BlockEnd)
534 return BlockI == RHS.BlockI && LiveRegI == RHS.LiveRegI;
535 return RHS.BlockI == BlockEnd;
536 }
537
538 bool operator!=(const liveout_iterator &RHS) const {
539 return !(*this == RHS);
540 }
541 private:
542 bool advanceToValidPosition() {
543 if (LiveRegI != (*BlockI)->livein_end())
544 return true;
545
546 do {
547 ++BlockI;
548 } while (BlockI != BlockEnd && (*BlockI)->livein_empty());
549 if (BlockI == BlockEnd)
550 return false;
551
552 LiveRegI = (*BlockI)->livein_begin();
553 return true;
554 }
555
556 MCPhysReg ExceptionPointer, ExceptionSelector;
557 const_succ_iterator BlockI;
558 const_succ_iterator BlockEnd;
559 livein_iterator LiveRegI;
560 };
561
562 /// Iterator scanning successor basic blocks' liveins to determine the
563 /// registers potentially live at the end of this block. There may be
564 /// duplicates or overlapping registers in the list returned.
565 liveout_iterator liveout_begin() const;
567 return liveout_iterator(*this, 0, 0, true);
568 }
571 }
572
573 /// Get the clobber mask for the start of this basic block. Funclets use this
574 /// to prevent register allocation across funclet transitions.
576
577 /// Get the clobber mask for the end of the basic block.
578 /// \see getBeginClobberMask()
580
581 /// Return alignment of the basic block.
582 Align getAlignment() const { return Alignment; }
583
584 /// Set alignment of the basic block.
585 void setAlignment(Align A) { Alignment = A; }
586
587 void setAlignment(Align A, unsigned MaxBytes) {
589 setMaxBytesForAlignment(MaxBytes);
590 }
591
592 /// Return the maximum amount of padding allowed for aligning the basic block.
593 unsigned getMaxBytesForAlignment() const { return MaxBytesForAlignment; }
594
595 /// Set the maximum amount of padding allowed for aligning the basic block
596 void setMaxBytesForAlignment(unsigned MaxBytes) {
597 MaxBytesForAlignment = MaxBytes;
598 }
599
600 /// Returns true if the block is a landing pad. That is this basic block is
601 /// entered via an exception handler.
602 bool isEHPad() const { return IsEHPad; }
603
604 /// Indicates the block is a landing pad. That is this basic block is entered
605 /// via an exception handler.
606 void setIsEHPad(bool V = true) { IsEHPad = V; }
607
608 bool hasEHPadSuccessor() const;
609
610 /// Returns true if this is the entry block of the function.
611 bool isEntryBlock() const;
612
613 /// Returns true if this is the entry block of an EH scope, i.e., the block
614 /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
615 bool isEHScopeEntry() const { return IsEHScopeEntry; }
616
617 /// Indicates if this is the entry block of an EH scope, i.e., the block that
618 /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
619 void setIsEHScopeEntry(bool V = true) { IsEHScopeEntry = V; }
620
621 /// Returns true if this is a target block of a catchret.
622 bool isEHCatchretTarget() const { return IsEHCatchretTarget; }
623
624 /// Indicates if this is a target block of a catchret.
625 void setIsEHCatchretTarget(bool V = true) { IsEHCatchretTarget = V; }
626
627 /// Returns true if this is the entry block of an EH funclet.
628 bool isEHFuncletEntry() const { return IsEHFuncletEntry; }
629
630 /// Indicates if this is the entry block of an EH funclet.
631 void setIsEHFuncletEntry(bool V = true) { IsEHFuncletEntry = V; }
632
633 /// Returns true if this is the entry block of a cleanup funclet.
634 bool isCleanupFuncletEntry() const { return IsCleanupFuncletEntry; }
635
636 /// Indicates if this is the entry block of a cleanup funclet.
637 void setIsCleanupFuncletEntry(bool V = true) { IsCleanupFuncletEntry = V; }
638
639 /// Returns true if this block begins any section.
640 bool isBeginSection() const { return IsBeginSection; }
641
642 /// Returns true if this block ends any section.
643 bool isEndSection() const { return IsEndSection; }
644
645 void setIsBeginSection(bool V = true) { IsBeginSection = V; }
646
647 void setIsEndSection(bool V = true) { IsEndSection = V; }
648
649 std::optional<UniqueBBID> getBBID() const { return BBID; }
650
651 /// Returns the section ID of this basic block.
652 MBBSectionID getSectionID() const { return SectionID; }
653
654 /// Returns the unique section ID number of this basic block.
655 unsigned getSectionIDNum() const {
656 return ((unsigned)MBBSectionID::SectionType::Cold) -
657 ((unsigned)SectionID.Type) + SectionID.Number;
658 }
659
660 /// Sets the fixed BBID of this basic block.
661 void setBBID(const UniqueBBID &V) {
662 assert(!BBID.has_value() && "Cannot change BBID.");
663 BBID = V;
664 }
665
666 /// Sets the section ID for this basic block.
667 void setSectionID(MBBSectionID V) { SectionID = V; }
668
669 /// Returns the MCSymbol marking the end of this basic block.
670 MCSymbol *getEndSymbol() const;
671
672 /// Returns true if this block may have an INLINEASM_BR (overestimate, by
673 /// checking if any of the successors are indirect targets of any inlineasm_br
674 /// in the function).
675 bool mayHaveInlineAsmBr() const;
676
677 /// Returns true if this is the indirect dest of an INLINEASM_BR.
679 return IsInlineAsmBrIndirectTarget;
680 }
681
682 /// Indicates if this is the indirect dest of an INLINEASM_BR.
683 void setIsInlineAsmBrIndirectTarget(bool V = true) {
684 IsInlineAsmBrIndirectTarget = V;
685 }
686
687 /// Returns true if it is legal to hoist instructions into this block.
688 bool isLegalToHoistInto() const;
689
690 // Code Layout methods.
691
692 /// Move 'this' block before or after the specified block. This only moves
693 /// the block, it does not modify the CFG or adjust potential fall-throughs at
694 /// the end of the block.
695 void moveBefore(MachineBasicBlock *NewAfter);
696 void moveAfter(MachineBasicBlock *NewBefore);
697
698 /// Returns true if this and MBB belong to the same section.
699 bool sameSection(const MachineBasicBlock *MBB) const {
700 return getSectionID() == MBB->getSectionID();
701 }
702
703 /// Update the terminator instructions in block to account for changes to
704 /// block layout which may have been made. PreviousLayoutSuccessor should be
705 /// set to the block which may have been used as fallthrough before the block
706 /// layout was modified. If the block previously fell through to that block,
707 /// it may now need a branch. If it previously branched to another block, it
708 /// may now be able to fallthrough to the current layout successor.
709 void updateTerminator(MachineBasicBlock *PreviousLayoutSuccessor);
710
711 // Machine-CFG mutators
712
713 /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
714 /// of Succ is automatically updated. PROB parameter is stored in
715 /// Probabilities list. The default probability is set as unknown. Mixing
716 /// known and unknown probabilities in successor list is not allowed. When all
717 /// successors have unknown probabilities, 1 / N is returned as the
718 /// probability for each successor, where N is the number of successors.
719 ///
720 /// Note that duplicate Machine CFG edges are not allowed.
723
724 /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
725 /// of Succ is automatically updated. The probability is not provided because
726 /// BPI is not available (e.g. -O0 is used), in which case edge probabilities
727 /// won't be used. Using this interface can save some space.
729
730 /// Set successor probability of a given iterator.
732
733 /// Normalize probabilities of all successors so that the sum of them becomes
734 /// one. This is usually done when the current update on this MBB is done, and
735 /// the sum of its successors' probabilities is not guaranteed to be one. The
736 /// user is responsible for the correct use of this function.
737 /// MBB::removeSuccessor() has an option to do this automatically.
739 BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
740 }
741
742 /// Validate successors' probabilities and check if the sum of them is
743 /// approximate one. This only works in DEBUG mode.
744 void validateSuccProbs() const;
745
746 /// Remove successor from the successors list of this MachineBasicBlock. The
747 /// Predecessors list of Succ is automatically updated.
748 /// If NormalizeSuccProbs is true, then normalize successors' probabilities
749 /// after the successor is removed.
751 bool NormalizeSuccProbs = false);
752
753 /// Remove specified successor from the successors list of this
754 /// MachineBasicBlock. The Predecessors list of Succ is automatically updated.
755 /// If NormalizeSuccProbs is true, then normalize successors' probabilities
756 /// after the successor is removed.
757 /// Return the iterator to the element after the one removed.
759 bool NormalizeSuccProbs = false);
760
761 /// Replace successor OLD with NEW and update probability info.
763
764 /// Copy a successor (and any probability info) from original block to this
765 /// block's. Uses an iterator into the original blocks successors.
766 ///
767 /// This is useful when doing a partial clone of successors. Afterward, the
768 /// probabilities may need to be normalized.
770
771 /// Split the old successor into old plus new and updates the probability
772 /// info.
774 bool NormalizeSuccProbs = false);
775
776 /// Transfers all the successors from MBB to this machine basic block (i.e.,
777 /// copies all the successors FromMBB and remove all the successors from
778 /// FromMBB).
780
781 /// Transfers all the successors, as in transferSuccessors, and update PHI
782 /// operands in the successor blocks which refer to FromMBB to refer to this.
784
785 /// Return true if any of the successors have probabilities attached to them.
786 bool hasSuccessorProbabilities() const { return !Probs.empty(); }
787
788 /// Return true if the specified MBB is a predecessor of this block.
789 bool isPredecessor(const MachineBasicBlock *MBB) const;
790
791 /// Return true if the specified MBB is a successor of this block.
792 bool isSuccessor(const MachineBasicBlock *MBB) const;
793
794 /// Return true if the specified MBB will be emitted immediately after this
795 /// block, such that if this block exits by falling through, control will
796 /// transfer to the specified MBB. Note that MBB need not be a successor at
797 /// all, for example if this block ends with an unconditional branch to some
798 /// other block.
799 bool isLayoutSuccessor(const MachineBasicBlock *MBB) const;
800
801 /// Return the successor of this block if it has a single successor.
802 /// Otherwise return a null pointer.
803 ///
806 return const_cast<MachineBasicBlock *>(
807 static_cast<const MachineBasicBlock *>(this)->getSingleSuccessor());
808 }
809
810 /// Return the predecessor of this block if it has a single predecessor.
811 /// Otherwise return a null pointer.
812 ///
815 return const_cast<MachineBasicBlock *>(
816 static_cast<const MachineBasicBlock *>(this)->getSinglePredecessor());
817 }
818
819 /// Return the fallthrough block if the block can implicitly
820 /// transfer control to the block after it by falling off the end of
821 /// it. If an explicit branch to the fallthrough block is not allowed,
822 /// set JumpToFallThrough to be false. Non-null return is a conservative
823 /// answer.
824 MachineBasicBlock *getFallThrough(bool JumpToFallThrough = true);
825
826 /// Return the fallthrough block if the block can implicitly
827 /// transfer control to it's successor, whether by a branch or
828 /// a fallthrough. Non-null return is a conservative answer.
830
831 /// Return true if the block can implicitly transfer control to the
832 /// block after it by falling off the end of it. This should return
833 /// false if it can reach the block after it, but it uses an
834 /// explicit branch to do so (e.g., a table jump). True is a
835 /// conservative answer.
836 bool canFallThrough();
837
838 /// Returns a pointer to the first instruction in this block that is not a
839 /// PHINode instruction. When adding instructions to the beginning of the
840 /// basic block, they should be added before the returned value, not before
841 /// the first instruction, which might be PHI.
842 /// Returns end() is there's no non-PHI instruction.
845 return const_cast<MachineBasicBlock *>(this)->getFirstNonPHI();
846 }
847
848 /// Return the first instruction in MBB after I that is not a PHI or a label.
849 /// This is the correct point to insert lowered copies at the beginning of a
850 /// basic block that must be before any debugging information.
852
853 /// Return the first instruction in MBB after I that is not a PHI, label or
854 /// debug. This is the correct point to insert copies at the beginning of a
855 /// basic block. \p Reg is the register being used by a spill or defined for a
856 /// restore/split during register allocation.
858 bool SkipPseudoOp = true);
859
860 /// Returns an iterator to the first terminator instruction of this basic
861 /// block. If a terminator does not exist, it returns end().
864 return const_cast<MachineBasicBlock *>(this)->getFirstTerminator();
865 }
866
867 /// Same getFirstTerminator but it ignores bundles and return an
868 /// instr_iterator instead.
870
871 /// Finds the first terminator in a block by scanning forward. This can handle
872 /// cases in GlobalISel where there may be non-terminator instructions between
873 /// terminators, for which getFirstTerminator() will not work correctly.
875
876 /// Returns an iterator to the first non-debug instruction in the basic block,
877 /// or end(). Skip any pseudo probe operation if \c SkipPseudoOp is true.
878 /// Pseudo probes are like debug instructions which do not turn into real
879 /// machine code. We try to use the function to skip both debug instructions
880 /// and pseudo probe operations to avoid API proliferation. This should work
881 /// most of the time when considering optimizing the rest of code in the
882 /// block, except for certain cases where pseudo probes are designed to block
883 /// the optimizations. For example, code merge like optimizations are supposed
884 /// to be blocked by pseudo probes for better AutoFDO profile quality.
885 /// Therefore, they should be considered as a valid instruction when this
886 /// function is called in a context of such optimizations. On the other hand,
887 /// \c SkipPseudoOp should be true when it's used in optimizations that
888 /// unlikely hurt profile quality, e.g., without block merging. The default
889 /// value of \c SkipPseudoOp is set to true to maximize code quality in
890 /// general, with an explict false value passed in in a few places like branch
891 /// folding and if-conversion to favor profile quality.
892 iterator getFirstNonDebugInstr(bool SkipPseudoOp = true);
893 const_iterator getFirstNonDebugInstr(bool SkipPseudoOp = true) const {
894 return const_cast<MachineBasicBlock *>(this)->getFirstNonDebugInstr(
895 SkipPseudoOp);
896 }
897
898 /// Returns an iterator to the last non-debug instruction in the basic block,
899 /// or end(). Skip any pseudo operation if \c SkipPseudoOp is true.
900 /// Pseudo probes are like debug instructions which do not turn into real
901 /// machine code. We try to use the function to skip both debug instructions
902 /// and pseudo probe operations to avoid API proliferation. This should work
903 /// most of the time when considering optimizing the rest of code in the
904 /// block, except for certain cases where pseudo probes are designed to block
905 /// the optimizations. For example, code merge like optimizations are supposed
906 /// to be blocked by pseudo probes for better AutoFDO profile quality.
907 /// Therefore, they should be considered as a valid instruction when this
908 /// function is called in a context of such optimizations. On the other hand,
909 /// \c SkipPseudoOp should be true when it's used in optimizations that
910 /// unlikely hurt profile quality, e.g., without block merging. The default
911 /// value of \c SkipPseudoOp is set to true to maximize code quality in
912 /// general, with an explict false value passed in in a few places like branch
913 /// folding and if-conversion to favor profile quality.
914 iterator getLastNonDebugInstr(bool SkipPseudoOp = true);
915 const_iterator getLastNonDebugInstr(bool SkipPseudoOp = true) const {
916 return const_cast<MachineBasicBlock *>(this)->getLastNonDebugInstr(
917 SkipPseudoOp);
918 }
919
920 /// Convenience function that returns true if the block ends in a return
921 /// instruction.
922 bool isReturnBlock() const {
923 return !empty() && back().isReturn();
924 }
925
926 /// Convenience function that returns true if the bock ends in a EH scope
927 /// return instruction.
928 bool isEHScopeReturnBlock() const {
929 return !empty() && back().isEHScopeReturn();
930 }
931
932 /// Split a basic block into 2 pieces at \p SplitPoint. A new block will be
933 /// inserted after this block, and all instructions after \p SplitInst moved
934 /// to it (\p SplitInst will be in the original block). If \p LIS is provided,
935 /// LiveIntervals will be appropriately updated. \return the newly inserted
936 /// block.
937 ///
938 /// If \p UpdateLiveIns is true, this will ensure the live ins list is
939 /// accurate, including for physreg uses/defs in the original block.
940 MachineBasicBlock *splitAt(MachineInstr &SplitInst, bool UpdateLiveIns = true,
941 LiveIntervals *LIS = nullptr);
942
943 /// Split the critical edge from this block to the given successor block, and
944 /// return the newly created block, or null if splitting is not possible.
945 ///
946 /// This function updates LiveVariables, MachineDominatorTree, and
947 /// MachineLoopInfo, as applicable.
950 std::vector<SparseBitVector<>> *LiveInSets = nullptr);
951
952 /// Check if the edge between this block and the given successor \p
953 /// Succ, can be split. If this returns true a subsequent call to
954 /// SplitCriticalEdge is guaranteed to return a valid basic block if
955 /// no changes occurred in the meantime.
956 bool canSplitCriticalEdge(const MachineBasicBlock *Succ) const;
957
958 void pop_front() { Insts.pop_front(); }
959 void pop_back() { Insts.pop_back(); }
960 void push_back(MachineInstr *MI) { Insts.push_back(MI); }
961
962 /// Insert MI into the instruction list before I, possibly inside a bundle.
963 ///
964 /// If the insertion point is inside a bundle, MI will be added to the bundle,
965 /// otherwise MI will not be added to any bundle. That means this function
966 /// alone can't be used to prepend or append instructions to bundles. See
967 /// MIBundleBuilder::insert() for a more reliable way of doing that.
969
970 /// Insert a range of instructions into the instruction list before I.
971 template<typename IT>
972 void insert(iterator I, IT S, IT E) {
973 assert((I == end() || I->getParent() == this) &&
974 "iterator points outside of basic block");
975 Insts.insert(I.getInstrIterator(), S, E);
976 }
977
978 /// Insert MI into the instruction list before I.
980 assert((I == end() || I->getParent() == this) &&
981 "iterator points outside of basic block");
982 assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
983 "Cannot insert instruction with bundle flags");
984 return Insts.insert(I.getInstrIterator(), MI);
985 }
986
987 /// Insert MI into the instruction list after I.
989 assert((I == end() || I->getParent() == this) &&
990 "iterator points outside of basic block");
991 assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
992 "Cannot insert instruction with bundle flags");
993 return Insts.insertAfter(I.getInstrIterator(), MI);
994 }
995
996 /// If I is bundled then insert MI into the instruction list after the end of
997 /// the bundle, otherwise insert MI immediately after I.
999 assert((I == instr_end() || I->getParent() == this) &&
1000 "iterator points outside of basic block");
1001 assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
1002 "Cannot insert instruction with bundle flags");
1003 while (I->isBundledWithSucc())
1004 ++I;
1005 return Insts.insertAfter(I, MI);
1006 }
1007
1008 /// Remove an instruction from the instruction list and delete it.
1009 ///
1010 /// If the instruction is part of a bundle, the other instructions in the
1011 /// bundle will still be bundled after removing the single instruction.
1013
1014 /// Remove an instruction from the instruction list and delete it.
1015 ///
1016 /// If the instruction is part of a bundle, the other instructions in the
1017 /// bundle will still be bundled after removing the single instruction.
1019 return erase(instr_iterator(I));
1020 }
1021
1022 /// Remove a range of instructions from the instruction list and delete them.
1024 return Insts.erase(I.getInstrIterator(), E.getInstrIterator());
1025 }
1026
1027 /// Remove an instruction or bundle from the instruction list and delete it.
1028 ///
1029 /// If I points to a bundle of instructions, they are all erased.
1031 return erase(I, std::next(I));
1032 }
1033
1034 /// Remove an instruction from the instruction list and delete it.
1035 ///
1036 /// If I is the head of a bundle of instructions, the whole bundle will be
1037 /// erased.
1039 return erase(iterator(I));
1040 }
1041
1042 /// Remove the unbundled instruction from the instruction list without
1043 /// deleting it.
1044 ///
1045 /// This function can not be used to remove bundled instructions, use
1046 /// remove_instr to remove individual instructions from a bundle.
1048 assert(!I->isBundled() && "Cannot remove bundled instructions");
1049 return Insts.remove(instr_iterator(I));
1050 }
1051
1052 /// Remove the possibly bundled instruction from the instruction list
1053 /// without deleting it.
1054 ///
1055 /// If the instruction is part of a bundle, the other instructions in the
1056 /// bundle will still be bundled after removing the single instruction.
1058
1059 void clear() {
1060 Insts.clear();
1061 }
1062
1063 /// Take an instruction from MBB 'Other' at the position From, and insert it
1064 /// into this MBB right before 'Where'.
1065 ///
1066 /// If From points to a bundle of instructions, the whole bundle is moved.
1068 // The range splice() doesn't allow noop moves, but this one does.
1069 if (Where != From)
1070 splice(Where, Other, From, std::next(From));
1071 }
1072
1073 /// Take a block of instructions from MBB 'Other' in the range [From, To),
1074 /// and insert them into this MBB right before 'Where'.
1075 ///
1076 /// The instruction at 'Where' must not be included in the range of
1077 /// instructions to move.
1079 iterator From, iterator To) {
1080 Insts.splice(Where.getInstrIterator(), Other->Insts,
1081 From.getInstrIterator(), To.getInstrIterator());
1082 }
1083
1084 /// This method unlinks 'this' from the containing function, and returns it,
1085 /// but does not delete it.
1087
1088 /// This method unlinks 'this' from the containing function and deletes it.
1089 void eraseFromParent();
1090
1091 /// Given a machine basic block that branched to 'Old', change the code and
1092 /// CFG so that it branches to 'New' instead.
1094
1095 /// Update all phi nodes in this basic block to refer to basic block \p New
1096 /// instead of basic block \p Old.
1098
1099 /// Find the next valid DebugLoc starting at MBBI, skipping any debug
1100 /// instructions. Return UnknownLoc if there is none.
1103 return findDebugLoc(MBBI.getInstrIterator());
1104 }
1105
1106 /// Has exact same behavior as @ref findDebugLoc (it also searches towards the
1107 /// end of this MBB) except that this function takes a reverse iterator to
1108 /// identify the starting MI.
1111 return rfindDebugLoc(MBBI.getInstrIterator());
1112 }
1113
1114 /// Find the previous valid DebugLoc preceding MBBI, skipping any debug
1115 /// instructions. It is possible to find the last DebugLoc in the MBB using
1116 /// findPrevDebugLoc(instr_end()). Return UnknownLoc if there is none.
1119 return findPrevDebugLoc(MBBI.getInstrIterator());
1120 }
1121
1122 /// Has exact same behavior as @ref findPrevDebugLoc (it also searches towards
1123 /// the beginning of this MBB) except that this function takes reverse
1124 /// iterator to identify the starting MI. A minor difference compared to
1125 /// findPrevDebugLoc is that we can't start scanning at "instr_end".
1128 return rfindPrevDebugLoc(MBBI.getInstrIterator());
1129 }
1130
1131 /// Find and return the merged DebugLoc of the branch instructions of the
1132 /// block. Return UnknownLoc if there is none.
1134
1135 /// Possible outcome of a register liveness query to computeRegisterLiveness()
1137 LQR_Live, ///< Register is known to be (at least partially) live.
1138 LQR_Dead, ///< Register is known to be fully dead.
1139 LQR_Unknown ///< Register liveness not decidable from local neighborhood.
1141
1142 /// Return whether (physical) register \p Reg has been defined and not
1143 /// killed as of just before \p Before.
1144 ///
1145 /// Search is localised to a neighborhood of \p Neighborhood instructions
1146 /// before (searching for defs or kills) and \p Neighborhood instructions
1147 /// after (searching just for defs) \p Before.
1148 ///
1149 /// \p Reg must be a physical register.
1153 unsigned Neighborhood = 10) const;
1154
1155 // Debugging methods.
1156 void dump() const;
1157 void print(raw_ostream &OS, const SlotIndexes * = nullptr,
1158 bool IsStandalone = true) const;
1160 const SlotIndexes * = nullptr, bool IsStandalone = true) const;
1161
1163 PrintNameIr = (1 << 0), ///< Add IR name where available
1164 PrintNameAttributes = (1 << 1), ///< Print attributes
1165 };
1166
1167 void printName(raw_ostream &os, unsigned printNameFlags = PrintNameIr,
1168 ModuleSlotTracker *moduleSlotTracker = nullptr) const;
1169
1170 // Printing method used by LoopInfo.
1171 void printAsOperand(raw_ostream &OS, bool PrintType = true) const;
1172
1173 /// MachineBasicBlocks are uniquely numbered at the function level, unless
1174 /// they're not in a MachineFunction yet, in which case this will return -1.
1175 int getNumber() const { return Number; }
1176 void setNumber(int N) { Number = N; }
1177
1178 /// Return the call frame size on entry to this basic block.
1179 unsigned getCallFrameSize() const { return CallFrameSize; }
1180 /// Set the call frame size on entry to this basic block.
1181 void setCallFrameSize(unsigned N) { CallFrameSize = N; }
1182
1183 /// Return the MCSymbol for this basic block.
1184 MCSymbol *getSymbol() const;
1185
1186 /// Return the EHCatchret Symbol for this basic block.
1188
1189 std::optional<uint64_t> getIrrLoopHeaderWeight() const {
1190 return IrrLoopHeaderWeight;
1191 }
1192
1194 IrrLoopHeaderWeight = Weight;
1195 }
1196
1197 /// Return probability of the edge from this block to MBB. This method should
1198 /// NOT be called directly, but by using getEdgeProbability method from
1199 /// MachineBranchProbabilityInfo class.
1201
1202private:
1203 /// Return probability iterator corresponding to the I successor iterator.
1204 probability_iterator getProbabilityIterator(succ_iterator I);
1205 const_probability_iterator
1206 getProbabilityIterator(const_succ_iterator I) const;
1207
1209 friend class MIPrinter;
1210
1211 // Methods used to maintain doubly linked list of blocks...
1213
1214 // Machine-CFG mutators
1215
1216 /// Add Pred as a predecessor of this MachineBasicBlock. Don't do this
1217 /// unless you know what you're doing, because it doesn't update Pred's
1218 /// successors list. Use Pred->addSuccessor instead.
1219 void addPredecessor(MachineBasicBlock *Pred);
1220
1221 /// Remove Pred as a predecessor of this MachineBasicBlock. Don't do this
1222 /// unless you know what you're doing, because it doesn't update Pred's
1223 /// successors list. Use Pred->removeSuccessor instead.
1224 void removePredecessor(MachineBasicBlock *Pred);
1225};
1226
1228
1229/// Prints a machine basic block reference.
1230///
1231/// The format is:
1232/// %bb.5 - a machine basic block with MBB.getNumber() == 5.
1233///
1234/// Usage: OS << printMBBReference(MBB) << '\n';
1236
1237// This is useful when building IndexedMaps keyed on basic block pointers.
1240 unsigned operator()(const MachineBasicBlock *MBB) const {
1241 return MBB->getNumber();
1242 }
1243};
1244
1245//===--------------------------------------------------------------------===//
1246// GraphTraits specializations for machine basic block graphs (machine-CFGs)
1247//===--------------------------------------------------------------------===//
1248
1249// Provide specializations of GraphTraits to be able to treat a
1250// MachineFunction as a graph of MachineBasicBlocks.
1251//
1252
1253template <> struct GraphTraits<MachineBasicBlock *> {
1256
1257 static NodeRef getEntryNode(MachineBasicBlock *BB) { return BB; }
1258 static ChildIteratorType child_begin(NodeRef N) { return N->succ_begin(); }
1259 static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
1260};
1261
1262template <> struct GraphTraits<const MachineBasicBlock *> {
1265
1266 static NodeRef getEntryNode(const MachineBasicBlock *BB) { return BB; }
1267 static ChildIteratorType child_begin(NodeRef N) { return N->succ_begin(); }
1268 static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
1269};
1270
1271// Provide specializations of GraphTraits to be able to treat a
1272// MachineFunction as a graph of MachineBasicBlocks and to walk it
1273// in inverse order. Inverse order for a function is considered
1274// to be when traversing the predecessor edges of a MBB
1275// instead of the successor edges.
1276//
1280
1282 return G.Graph;
1283 }
1284
1285 static ChildIteratorType child_begin(NodeRef N) { return N->pred_begin(); }
1286 static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); }
1287};
1288
1292
1294 return G.Graph;
1295 }
1296
1297 static ChildIteratorType child_begin(NodeRef N) { return N->pred_begin(); }
1298 static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); }
1299};
1300
1301// These accessors are handy for sharing templated code between IR and MIR.
1302inline auto successors(const MachineBasicBlock *BB) { return BB->successors(); }
1303inline auto predecessors(const MachineBasicBlock *BB) {
1304 return BB->predecessors();
1305}
1306
1307/// MachineInstrSpan provides an interface to get an iteration range
1308/// containing the instruction it was initialized with, along with all
1309/// those instructions inserted prior to or following that instruction
1310/// at some point after the MachineInstrSpan is constructed.
1312 MachineBasicBlock &MBB;
1314
1315public:
1317 : MBB(*BB), I(I), B(I == MBB.begin() ? MBB.end() : std::prev(I)),
1318 E(std::next(I)) {
1319 assert(I == BB->end() || I->getParent() == BB);
1320 }
1321
1323 return B == MBB.end() ? MBB.begin() : std::next(B);
1324 }
1326 bool empty() { return begin() == end(); }
1327
1329};
1330
1331/// Increment \p It until it points to a non-debug instruction or to \p End
1332/// and return the resulting iterator. This function should only be used
1333/// MachineBasicBlock::{iterator, const_iterator, instr_iterator,
1334/// const_instr_iterator} and the respective reverse iterators.
1335template <typename IterT>
1336inline IterT skipDebugInstructionsForward(IterT It, IterT End,
1337 bool SkipPseudoOp = true) {
1338 while (It != End &&
1339 (It->isDebugInstr() || (SkipPseudoOp && It->isPseudoProbe())))
1340 ++It;
1341 return It;
1342}
1343
1344/// Decrement \p It until it points to a non-debug instruction or to \p Begin
1345/// and return the resulting iterator. This function should only be used
1346/// MachineBasicBlock::{iterator, const_iterator, instr_iterator,
1347/// const_instr_iterator} and the respective reverse iterators.
1348template <class IterT>
1349inline IterT skipDebugInstructionsBackward(IterT It, IterT Begin,
1350 bool SkipPseudoOp = true) {
1351 while (It != Begin &&
1352 (It->isDebugInstr() || (SkipPseudoOp && It->isPseudoProbe())))
1353 --It;
1354 return It;
1355}
1356
1357/// Increment \p It, then continue incrementing it while it points to a debug
1358/// instruction. A replacement for std::next.
1359template <typename IterT>
1360inline IterT next_nodbg(IterT It, IterT End, bool SkipPseudoOp = true) {
1361 return skipDebugInstructionsForward(std::next(It), End, SkipPseudoOp);
1362}
1363
1364/// Decrement \p It, then continue decrementing it while it points to a debug
1365/// instruction. A replacement for std::prev.
1366template <typename IterT>
1367inline IterT prev_nodbg(IterT It, IterT Begin, bool SkipPseudoOp = true) {
1368 return skipDebugInstructionsBackward(std::prev(It), Begin, SkipPseudoOp);
1369}
1370
1371/// Construct a range iterator which begins at \p It and moves forwards until
1372/// \p End is reached, skipping any debug instructions.
1373template <typename IterT>
1374inline auto instructionsWithoutDebug(IterT It, IterT End,
1375 bool SkipPseudoOp = true) {
1376 return make_filter_range(make_range(It, End), [=](const MachineInstr &MI) {
1377 return !MI.isDebugInstr() && !(SkipPseudoOp && MI.isPseudoProbe());
1378 });
1379}
1380
1381} // end namespace llvm
1382
1383#endif // LLVM_CODEGEN_MACHINEBASICBLOCK_H
aarch64 AArch64 CCMP Pass
aarch64 promote const
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator MBBI
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
BlockVerifier::State From
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
bool End
Definition: ELF_riscv.cpp:480
This file defines the little GraphTraits<X> template class that should be specialized by classes that...
IRTranslator LLVM IR MI
A common definition of LaneBitmask for use in TableGen and CodeGen.
#define I(x, y, z)
Definition: MD5.cpp:58
#define G(x, y, z)
Definition: MD5.cpp:56
unsigned const TargetRegisterInfo * TRI
unsigned Reg
#define P(N)
uint32_t Number
Definition: Profile.cpp:47
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file defines the SparseBitVector class.
Value * RHS
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
static BranchProbability getUnknown()
static void normalizeProbabilities(ProbabilityIter Begin, ProbabilityIter End)
A debug info location.
Definition: DebugLoc.h:33
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:33
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
This class prints out the machine instructions using the MIR serialization format.
Definition: MIRPrinter.cpp:138
liveout_iterator(const MachineBasicBlock &MBB, MCPhysReg ExceptionPointer, MCPhysReg ExceptionSelector, bool End)
bool operator==(const liveout_iterator &RHS) const
bool operator!=(const liveout_iterator &RHS) const
const MachineInstr & instr_front() const
bool isInlineAsmBrIndirectTarget() const
Returns true if this is the indirect dest of an INLINEASM_BR.
DebugLoc rfindPrevDebugLoc(reverse_instr_iterator MBBI)
Has exact same behavior as findPrevDebugLoc (it also searches towards the beginning of this MBB) exce...
Instructions::const_reverse_iterator const_reverse_instr_iterator
std::vector< MachineBasicBlock * >::const_reverse_iterator const_pred_reverse_iterator
unsigned pred_size() const
void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB)
Transfers all the successors, as in transferSuccessors, and update PHI operands in the successor bloc...
std::vector< MachineBasicBlock * >::reverse_iterator succ_reverse_iterator
void setBBID(const UniqueBBID &V)
Sets the fixed BBID of this basic block.
iterator erase(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
void normalizeSuccProbs()
Normalize probabilities of all successors so that the sum of them becomes one.
void setAddressTakenIRBlock(BasicBlock *BB)
Set this block to reflect that it corresponds to an IR-level basic block with a BlockAddress.
livein_iterator livein_end() const
iterator getFirstTerminatorForward()
Finds the first terminator in a block by scanning forward.
bool isEHPad() const
Returns true if the block is a landing pad.
iterator_range< liveout_iterator > liveouts() const
const MachineInstr & back() const
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.
void setIsEHCatchretTarget(bool V=true)
Indicates if this is a target block of a catchret.
MachineInstr * remove_instr(MachineInstr *I)
Remove the possibly bundled instruction from the instruction list without deleting it.
instr_iterator instr_begin()
void setIsEndSection(bool V=true)
void setIrrLoopHeaderWeight(uint64_t Weight)
MachineBasicBlock * getLogicalFallThrough()
Return the fallthrough block if the block can implicitly transfer control to it's successor,...
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
void setIsCleanupFuncletEntry(bool V=true)
Indicates if this is the entry block of a cleanup funclet.
std::vector< MachineBasicBlock * >::reverse_iterator pred_reverse_iterator
DebugLoc rfindPrevDebugLoc(reverse_iterator MBBI)
MCSymbol * getEHCatchretSymbol() const
Return the EHCatchret Symbol for this basic block.
const_pred_iterator pred_end() const
void moveBefore(MachineBasicBlock *NewAfter)
Move 'this' block before or after the specified block.
void setLabelMustBeEmitted()
Set this block to reflect that, regardless how we flow to it, we need its label be emitted.
reverse_iterator rend()
void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New)
Replace successor OLD with NEW and update probability info.
const_pred_reverse_iterator pred_rend() const
MachineBasicBlock * getFallThrough(bool JumpToFallThrough=true)
Return the fallthrough block if the block can implicitly transfer control to the block after it by fa...
void transferSuccessors(MachineBasicBlock *FromMBB)
Transfers all the successors from MBB to this machine basic block (i.e., copies all the successors Fr...
bool hasLabelMustBeEmitted() const
Test whether this block must have its label emitted.
const_iterator getFirstNonDebugInstr(bool SkipPseudoOp=true) const
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
BranchProbability getSuccProbability(const_succ_iterator Succ) const
Return probability of the edge from this block to MBB.
const_reverse_instr_iterator instr_rend() const
iterator_range< livein_iterator > liveins() const
void setAlignment(Align A, unsigned MaxBytes)
iterator_range< iterator > phis()
Returns a range that iterates over the phis in the basic block.
reverse_instr_iterator instr_rbegin()
MachineInstrBundleIterator< const MachineInstr, true > const_reverse_iterator
instr_iterator erase_instr(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
void push_back(MachineInstr *MI)
iterator SkipPHIsAndLabels(iterator I)
Return the first instruction in MBB after I that is not a PHI or a label.
pred_reverse_iterator pred_rbegin()
std::vector< MachineBasicBlock * >::const_iterator const_succ_iterator
void addSuccessorWithoutProb(MachineBasicBlock *Succ)
Add Succ as a successor of this MachineBasicBlock.
MachineBasicBlock * getSinglePredecessor()
void setCallFrameSize(unsigned N)
Set the call frame size on entry to this basic block.
std::optional< UniqueBBID > getBBID() const
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
void splitSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New, bool NormalizeSuccProbs=false)
Split the old successor into old plus new and updates the probability info.
liveout_iterator liveout_end() const
const_instr_iterator instr_begin() const
const_succ_iterator succ_begin() const
const_succ_reverse_iterator succ_rbegin() const
pred_reverse_iterator pred_rend()
@ PrintNameIr
Add IR name where available.
@ PrintNameAttributes
Print attributes.
void updateTerminator(MachineBasicBlock *PreviousLayoutSuccessor)
Update the terminator instructions in block to account for changes to block layout which may have bee...
std::vector< MachineBasicBlock * >::const_iterator const_pred_iterator
const MachineBasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor.
iterator SkipPHIsLabelsAndDebug(iterator I, Register Reg=Register(), bool SkipPseudoOp=true)
Return the first instruction in MBB after I that is not a PHI, label or debug.
std::vector< MachineBasicBlock * >::const_reverse_iterator const_succ_reverse_iterator
bool isLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
bool canFallThrough()
Return true if the block can implicitly transfer control to the block after it by falling off the end...
void setSuccProbability(succ_iterator I, BranchProbability Prob)
Set successor probability of a given iterator.
iterator getFirstNonDebugInstr(bool SkipPseudoOp=true)
Returns an iterator to the first non-debug instruction in the basic block, or end().
DebugLoc rfindDebugLoc(reverse_iterator MBBI)
iterator erase(iterator I, iterator E)
Remove a range of instructions from the instruction list and delete them.
const MachineInstr & front() const
void printAsOperand(raw_ostream &OS, bool PrintType=true) const
MachineInstr * remove(MachineInstr *I)
Remove the unbundled instruction from the instruction list without deleting it.
const_instr_range instrs() const
const_reverse_iterator rbegin() const
void clearBasicBlock()
Remove the reference to the underlying IR BasicBlock.
unsigned getMaxBytesForAlignment() const
Return the maximum amount of padding allowed for aligning the basic block.
void setMaxBytesForAlignment(unsigned MaxBytes)
Set the maximum amount of padding allowed for aligning the basic block.
void validateSuccProbs() const
Validate successors' probabilities and check if the sum of them is approximate one.
iterator_range< const_pred_iterator > predecessors() const
const MachineInstr & instr_back() const
bool isIRBlockAddressTaken() const
Test whether this block is the target of an IR BlockAddress.
LiveInVector::const_iterator livein_iterator
MCSymbol * getEndSymbol() const
Returns the MCSymbol marking the end of this basic block.
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 ...
void clearLiveIns()
Clear live in list.
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
const_iterator getLastNonDebugInstr(bool SkipPseudoOp=true) const
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.
iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
bool sameSection(const MachineBasicBlock *MBB) const
Returns true if this and MBB belong to the same section.
iterator insert(iterator I, MachineInstr *MI)
Insert MI into the instruction list before I.
livein_iterator livein_begin() const
unsigned succ_size() const
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction.
iterator_range< livein_iterator > liveins_dbg() const
const uint32_t * getBeginClobberMask(const TargetRegisterInfo *TRI) const
Get the clobber mask for the start of this basic block.
bool hasAddressTaken() const
Test whether this block is used as something other than the target of a terminator,...
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
void setAlignment(Align A)
Set alignment of the basic block.
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 ...
std::vector< MachineBasicBlock * >::iterator succ_iterator
MachineInstr & instr_back()
bool isEntryBlock() const
Returns true if this is the entry block of the function.
iterator_range< const_instr_iterator > const_instr_range
void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
void copySuccessor(const MachineBasicBlock *Orig, succ_iterator I)
Copy a successor (and any probability info) from original block to this block's.
const_pred_reverse_iterator pred_rbegin() const
void addLiveIn(const RegisterMaskPair &RegMaskPair)
MachineBasicBlock * getSingleSuccessor()
BasicBlock * getAddressTakenIRBlock() const
Retrieves the BasicBlock which corresponds to this MachineBasicBlock.
unsigned getSectionIDNum() const
Returns the unique section ID number of this basic block.
bool isEHCatchretTarget() const
Returns true if this is a target block of a catchret.
const_iterator getFirstNonPHI() const
void sortUniqueLiveIns()
Sorts and uniques the LiveIns vector.
const MachineBasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
iterator_range< const_iterator > phis() const
const_instr_iterator instr_end() const
liveout_iterator liveout_begin() const
Iterator scanning successor basic blocks' liveins to determine the registers potentially live at the ...
DebugLoc findDebugLoc(iterator MBBI)
void removeSuccessor(MachineBasicBlock *Succ, bool NormalizeSuccProbs=false)
Remove successor from the successors list of this MachineBasicBlock.
const_succ_iterator succ_end() const
iterator getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
const_iterator begin() const
bool isPredecessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB is a predecessor of this block.
bool hasSuccessorProbabilities() const
Return true if any of the successors have probabilities attached to them.
void setSectionID(MBBSectionID V)
Sets the section ID for this basic block.
iterator_range< const_iterator > terminators() const
livein_iterator livein_begin_dbg() const
Unlike livein_begin, this method does not check that the liveness information is accurate.
DebugLoc rfindDebugLoc(reverse_instr_iterator MBBI)
Has exact same behavior as findDebugLoc (it also searches towards the end of this MBB) except that th...
const_pred_iterator pred_begin() const
void print(raw_ostream &OS, const SlotIndexes *=nullptr, bool IsStandalone=true) const
reverse_instr_iterator instr_rend()
const_reverse_iterator rend() const
DebugLoc findDebugLoc(instr_iterator MBBI)
Find the next valid DebugLoc starting at MBBI, skipping any debug instructions.
Instructions::iterator instr_iterator
iterator getLastNonDebugInstr(bool SkipPseudoOp=true)
Returns an iterator to the last non-debug instruction in the basic block, or end().
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...
MachineInstrBundleIterator< MachineInstr, true > reverse_iterator
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...
succ_reverse_iterator succ_rbegin()
bool isLayoutSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB will be emitted immediately after this block, such that if this bloc...
static Instructions MachineBasicBlock::* getSublistAccess(MachineInstr *)
Support for MachineInstr::getNextNode().
DebugLoc findPrevDebugLoc(instr_iterator MBBI)
Find the previous valid DebugLoc preceding MBBI, skipping any debug instructions.
MachineBasicBlock * splitAt(MachineInstr &SplitInst, bool UpdateLiveIns=true, LiveIntervals *LIS=nullptr)
Split a basic block into 2 pieces at SplitPoint.
MachineFunction * getParent()
void eraseFromParent()
This method unlinks 'this' from the containing function and deletes it.
void setIsInlineAsmBrIndirectTarget(bool V=true)
Indicates if this is the indirect dest of an INLINEASM_BR.
instr_iterator instr_end()
Instructions::const_iterator const_instr_iterator
iterator_range< const_succ_iterator > successors() const
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
const_iterator getFirstTerminator() const
const_succ_reverse_iterator succ_rend() const
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
std::string getFullName() const
Return a formatted string to identify this block and its parent function.
bool isBeginSection() const
Returns true if this block begins any section.
DebugLoc findPrevDebugLoc(iterator MBBI)
iterator_range< iterator > terminators()
unsigned getCallFrameSize() const
Return the call frame size on entry to this basic block.
void setIsEHFuncletEntry(bool V=true)
Indicates if this is the entry block of an EH funclet.
DebugLoc findBranchDebugLoc()
Find and return the merged DebugLoc of the branch instructions of the block.
iterator_range< succ_iterator > successors()
instr_iterator getFirstInstrTerminator()
Same getFirstTerminator but it ignores bundles and return an instr_iterator instead.
reverse_iterator rbegin()
bool isMachineBlockAddressTaken() const
Test whether this block is used as something other than the target of a terminator,...
void printName(raw_ostream &os, unsigned printNameFlags=PrintNameIr, ModuleSlotTracker *moduleSlotTracker=nullptr) const
Print the basic block's name as:
iterator insertAfter(iterator I, MachineInstr *MI)
Insert MI into the instruction list after I.
bool isSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB is a successor of this block.
iterator_range< pred_iterator > predecessors()
std::vector< RegisterMaskPair > getLiveIns() const
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
bool isEHScopeReturnBlock() const
Convenience function that returns true if the bock ends in a EH scope return instruction.
bool isEndSection() const
Returns true if this block ends any section.
Align getAlignment() const
Return alignment of the basic block.
bool canSplitCriticalEdge(const MachineBasicBlock *Succ) const
Check if the edge between this block and the given successor Succ, can be split.
MachineInstrBundleIterator< MachineInstr > iterator
bool isLegalToHoistInto() const
Returns true if it is legal to hoist instructions into this block.
MachineInstr & instr_front()
const_reverse_instr_iterator instr_rbegin() const
iterator erase(iterator I)
Remove an instruction or bundle from the instruction list and delete it.
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,...
const_iterator end() const
StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
bool mayHaveInlineAsmBr() const
Returns true if this block may have an INLINEASM_BR (overestimate, by checking if any of the successo...
void removeLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll())
Remove the specified register from the live in set.
LivenessQueryResult
Possible outcome of a register liveness query to computeRegisterLiveness()
@ LQR_Dead
Register is known to be fully dead.
@ LQR_Live
Register is known to be (at least partially) live.
@ LQR_Unknown
Register liveness not decidable from local neighborhood.
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...
void moveAfter(MachineBasicBlock *NewBefore)
succ_reverse_iterator succ_rend()
void setMachineBlockAddressTaken()
Set this block to indicate that its address is used as something other than the target of a terminato...
std::optional< uint64_t > getIrrLoopHeaderWeight() const
std::vector< MachineBasicBlock * >::iterator pred_iterator
const uint32_t * getEndClobberMask(const TargetRegisterInfo *TRI) const
Get the clobber mask for the end of the basic block.
void setIsBeginSection(bool V=true)
bool sizeWithoutDebugLargerThan(unsigned Limit) const
iterator_range< instr_iterator > instr_range
MachineBasicBlock * removeFromParent()
This method unlinks 'this' from the containing function, and returns it, but does not delete it.
void insert(iterator I, IT S, IT E)
Insert a range of instructions into the instruction list before I.
void setIsEHPad(bool V=true)
Indicates the block is a landing pad.
Instructions::reverse_iterator reverse_instr_iterator
bool isCleanupFuncletEntry() const
Returns true if this is the entry block of a cleanup funclet.
static MachineInstrBundleIterator getAtBundleBegin(instr_iterator MI)
Get the bundle iterator for the given instruction's bundle.
MachineInstrSpan provides an interface to get an iteration range containing the instruction it was in...
MachineBasicBlock::iterator getInitial()
MachineInstrSpan(MachineBasicBlock::iterator I, MachineBasicBlock *BB)
MachineBasicBlock::iterator begin()
MachineBasicBlock::iterator end()
Representation of each machine instruction.
Definition: MachineInstr.h:69
bool isReturn(QueryType Type=AnyInBundle) const
Definition: MachineInstr.h:906
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:912
Manage lifetime of a slot tracker for printing IR.
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:94
Simple wrapper around std::function<void(raw_ostream&)>.
Definition: Printable.h:38
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
SlotIndexes pass.
Definition: SlotIndexes.h:300
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
An ilist node that can access its parent list.
Definition: ilist_node.h:284
base_list_type::const_reverse_iterator const_reverse_iterator
Definition: ilist.h:125
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
Definition: ilist.h:328
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
A simple intrusive list implementation.
Definition: simple_ilist.h:81
This file defines classes to implement an intrusive doubly linked list class (i.e.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
IterT next_nodbg(IterT It, IterT End, bool SkipPseudoOp=true)
Increment It, then continue incrementing it while it points to a debug instruction.
auto successors(const MachineBasicBlock *BB)
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition: MCRegister.h:21
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
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.
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:581
auto instructionsWithoutDebug(IterT It, IterT End, bool SkipPseudoOp=true)
Construct a range iterator which begins at It and moves forwards until End is reached,...
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...
@ Other
Any other memory.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:293
auto predecessors(const MachineBasicBlock *BB)
IterT prev_nodbg(IterT It, IterT Begin, bool SkipPseudoOp=true)
Decrement It, then continue decrementing it while it points to a debug instruction.
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
#define N
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
static NodeRef getEntryNode(Inverse< MachineBasicBlock * > G)
static ChildIteratorType child_begin(NodeRef N)
static NodeRef getEntryNode(Inverse< const MachineBasicBlock * > G)
MachineBasicBlock::const_pred_iterator ChildIteratorType
MachineBasicBlock::succ_iterator ChildIteratorType
static NodeRef getEntryNode(MachineBasicBlock *BB)
static ChildIteratorType child_end(NodeRef N)
static ChildIteratorType child_begin(NodeRef N)
MachineBasicBlock::const_succ_iterator ChildIteratorType
static ChildIteratorType child_begin(NodeRef N)
static NodeRef getEntryNode(const MachineBasicBlock *BB)
static ChildIteratorType child_end(NodeRef N)
static constexpr LaneBitmask getAll()
Definition: LaneBitmask.h:82
unsigned operator()(const MachineBasicBlock *MBB) const
bool operator!=(const MBBSectionID &Other) const
static const MBBSectionID ExceptionSectionID
static const MBBSectionID ColdSectionID
MBBSectionID(unsigned N)
enum llvm::MBBSectionID::SectionType Type
bool operator==(const MBBSectionID &Other) const
Pair of physical register and lane mask.
RegisterMaskPair(MCPhysReg PhysReg, LaneBitmask LaneMask)
bool operator==(const RegisterMaskPair &other) const
Callbacks do nothing by default in iplist and ilist.
Definition: ilist.h:65
void transferNodesFromList(ilist_traits &FromList, instr_iterator First, instr_iterator Last)
void addNodeToList(MachineInstr *N)
void removeNodeFromList(MachineInstr *N)
void deleteNode(MachineInstr *MI)
Template traits for intrusive list.
Definition: ilist.h:90