|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/Analysis/BlockFrequencyInfoImpl.h 55 class MachineBasicBlock;
include/llvm/CodeGen/Analysis.h 29 class MachineBasicBlock;
include/llvm/CodeGen/AsmPrinter.h 50 class MachineBasicBlock;
include/llvm/CodeGen/AsmPrinterHandler.h 22 class MachineBasicBlock;
include/llvm/CodeGen/ExecutionDomainFix.h 33 class MachineBasicBlock;
include/llvm/CodeGen/GlobalISel/IRTranslator.h 43 class MachineBasicBlock;
include/llvm/CodeGen/LexicalScopes.h 30 class MachineBasicBlock;
include/llvm/CodeGen/LiveRegUnits.h 27 class MachineBasicBlock;
include/llvm/CodeGen/LiveVariables.h 42 class MachineBasicBlock;
include/llvm/CodeGen/LoopTraversal.h 25 class MachineBasicBlock;
include/llvm/CodeGen/MIRParser/MIParser.h 23 class MachineBasicBlock;
include/llvm/CodeGen/MIRPrinter.h 19 class MachineBasicBlock;
include/llvm/CodeGen/MachineBlockFrequencyInfo.h 25 class MachineBasicBlock;
include/llvm/CodeGen/MachineFrameInfo.h 25 class MachineBasicBlock;
include/llvm/CodeGen/MachineInstr.h 43 class MachineBasicBlock;
include/llvm/CodeGen/MachineJumpTableInfo.h 28 class MachineBasicBlock;
include/llvm/CodeGen/MachineLoopUtils.h 13 class MachineBasicBlock;
include/llvm/CodeGen/MachineOperand.h 30 class MachineBasicBlock;
include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h 22 class MachineBasicBlock;
include/llvm/CodeGen/MachineSSAUpdater.h 18 class MachineBasicBlock;
include/llvm/CodeGen/MachineSizeOpts.h 21 class MachineBasicBlock;
include/llvm/CodeGen/ModuloSchedule.h 72 class MachineBasicBlock;
include/llvm/CodeGen/ReachingDefAnalysis.h 31 class MachineBasicBlock;
include/llvm/CodeGen/SelectionDAG.h 70 class MachineBasicBlock;
include/llvm/CodeGen/SelectionDAGISel.h 30 class MachineBasicBlock;
include/llvm/CodeGen/SelectionDAGNodes.h 61 class MachineBasicBlock;
include/llvm/CodeGen/SwiftErrorValueTracking.h 30 class MachineBasicBlock;
include/llvm/CodeGen/SwitchLoweringUtils.h 21 class MachineBasicBlock;
include/llvm/CodeGen/TailDuplicator.h 27 class MachineBasicBlock;
include/llvm/CodeGen/TargetLowering.h 80 class MachineBasicBlock;
include/llvm/CodeGen/WinEHFuncInfo.h 32 class MachineBasicBlock;
lib/CodeGen/AggressiveAntiDepBreaker.h 29 class MachineBasicBlock;
lib/CodeGen/CriticalAntiDepBreaker.h 26 class MachineBasicBlock;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 75 class MachineBasicBlock;
lib/Target/ARM/ARM.h 32 class MachineBasicBlock;
lib/Target/ARM/ARMConstantPoolValue.h 31 class MachineBasicBlock;
lib/Target/ARM/ARMISelLowering.h 44 class MachineBasicBlock;
lib/Target/Hexagon/BitTracker.h 29 class MachineBasicBlock;
lib/Target/Hexagon/HexagonBlockRanges.h 22 class MachineBasicBlock;
lib/Target/Hexagon/RDFCopy.h 21 class MachineBasicBlock;
lib/Target/Hexagon/RDFGraph.h 248 class MachineBasicBlock;
lib/Target/Hexagon/RDFLiveness.h 25 class MachineBasicBlock;
lib/Target/Mips/MipsAsmPrinter.h 31 class MachineBasicBlock;
lib/Target/Mips/MipsISelLowering.h 47 class MachineBasicBlock;
lib/Target/Mips/MipsMCInstLower.h 18 class MachineBasicBlock;
lib/Target/Mips/MipsSEFrameLowering.h 17 class MachineBasicBlock;
lib/Target/Mips/MipsSEISelLowering.h 22 class MachineBasicBlock;
lib/Target/SystemZ/SystemZAsmPrinter.h 20 class MachineBasicBlock;
References
gen/lib/Target/AArch64/AArch64GenGICombiner.inc 101 MachineBasicBlock *MBB = MI.getParent();
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
127 ArrayRef(const std::vector<U *, A> &Vec,
129 std::is_convertible<U *const *, T const *>::value>::type* = 0)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/STLExtras.h 244 static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
250 static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
1172 bool any_of(R &&Range, UnaryPredicate P) {
include/llvm/ADT/SmallSet.h 249 class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
include/llvm/ADT/ilist.h 82 struct ilist_node_traits : ilist_alloc_traits<NodeTy>,
83 ilist_callback_traits<NodeTy> {};
89 struct ilist_traits : public ilist_node_traits<NodeTy> {};
96 template <class T> T &make();
106 static Yes &test(U *I, decltype(I->getNext(&make<NodeT>())) * = 0);
136 static Yes &test(U *I, decltype(I->createNode(make<NodeT>())) * = 0);
144 static const bool value = HasGetNext<TraitsT, NodeT>::value ||
146 HasCreateNode<TraitsT, NodeT>::value;
389 : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
389 : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
include/llvm/ADT/ilist_node.h 150 typename ilist_detail::compute_node_options<T, Options...>::type> {
256 class ilist_node_with_parent : public ilist_node<NodeTy, Options...> {
266 const ParentTy *getNodeParent() const {
274 NodeTy *getPrevNode() {
278 getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
283 const NodeTy *getPrevNode() const {
288 NodeTy *getNextNode() {
292 getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
297 const NodeTy *getNextNode() const {
include/llvm/ADT/ilist_node_options.h 108 typedef T value_type;
109 typedef T *pointer;
110 typedef T &reference;
111 typedef const T *const_pointer;
112 typedef const T &const_reference;
122 typedef node_options<T, extract_sentinel_tracking<Options...>::value,
include/llvm/ADT/simple_ilist.h 79 : ilist_detail::compute_node_options<T, Options...>::type::list_base_type,
81 typename ilist_detail::compute_node_options<T, Options...>::type> {
85 typename ilist_detail::compute_node_options<T, Options...>::type;
include/llvm/Analysis/BlockFrequencyInfoImpl.h 553 using BlockT = MachineBasicBlock;
567 template <class BlockT> std::string getBlockName(const BlockT *BB) {
844 using BlockT = typename bfi_detail::TypeMap<BT>::BlockT;
845 using FunctionT = typename bfi_detail::TypeMap<BT>::FunctionT;
847 typename bfi_detail::TypeMap<BT>::BranchProbabilityInfoT;
848 using LoopT = typename bfi_detail::TypeMap<BT>::LoopT;
849 using LoopInfoT = typename bfi_detail::TypeMap<BT>::LoopInfoT;
1260 using BlockT = BT;
1264 const BlockFrequencyInfoImpl<BT> &BFI;
1266 explicit BlockEdgesAdder(const BlockFrequencyInfoImpl<BT> &BFI)
1291 BlockEdgesAdder<BT> addBlockEdges(*this);
include/llvm/Analysis/DominanceFrontier.h 43 using DomSetType = std::set<BlockT *>; // Dom set for a bb
44 using DomSetMapType = std::map<BlockT *, DomSetType>; // Dom set map
47 using BlockTraits = GraphTraits<BlockT *>;
51 SmallVector<BlockT *, IsPostDom ? 4 : 1> Roots;
60 const SmallVectorImpl<BlockT *> &getRoots() const { return Roots; }
62 BlockT *getRoot() const {
84 iterator find(BlockT *B) { return Frontiers.find(B); }
85 const_iterator find(BlockT *B) const { return Frontiers.find(B); }
87 iterator addBasicBlock(BlockT *BB, const DomSetType &frontier) {
93 void removeBlock(BlockT *BB);
95 void addToFrontier(iterator I, BlockT *Node);
97 void removeFromFrontier(iterator I, BlockT *Node);
123 : public DominanceFrontierBase<BlockT, false> {
125 using BlockTraits = GraphTraits<BlockT *>;
128 using DomTreeT = DomTreeBase<BlockT>;
129 using DomTreeNodeT = DomTreeNodeBase<BlockT>;
130 using DomSetType = typename DominanceFrontierBase<BlockT, false>::DomSetType;
include/llvm/Analysis/DominanceFrontierImpl.h 37 using DomTreeNodeT = DomTreeNodeBase<BlockT>;
39 DFCalculateWorkObject(BlockT *B, BlockT *P, const DomTreeNodeT *N,
39 DFCalculateWorkObject(BlockT *B, BlockT *P, const DomTreeNodeT *N,
43 BlockT *currentBB;
44 BlockT *parentBB;
76 std::set<BlockT *> tmpSet;
77 for (BlockT *BB : DS2)
82 BlockT *Node = *I++;
110 BlockT *Node = I->first;
138 const std::set<BlockT *> &BBs = I->second;
140 for (const BlockT *BB : BBs) {
162 BlockT *BB = Node->getBlock();
165 std::vector<DFCalculateWorkObject<BlockT>> workList;
166 SmallPtrSet<BlockT *, 32> visited;
170 DFCalculateWorkObject<BlockT> *currentW = &workList.back();
173 BlockT *currentBB = currentW->currentBB;
174 BlockT *parentBB = currentW->parentBB;
184 for (const auto Succ : children<BlockT *>(currentBB)) {
199 BlockT *childBB = IDominee->getBlock();
include/llvm/Analysis/LoopInfo.h 80 std::vector<BlockT *> Blocks;
82 SmallPtrSet<const BlockT *, 8> DenseBlockSet;
89 LoopBase(const LoopBase<BlockT, LoopT> &) = delete;
90 const LoopBase<BlockT, LoopT> &
91 operator=(const LoopBase<BlockT, LoopT> &) = delete;
105 BlockT *getHeader() const { return getBlocks().front(); }
125 bool contains(const BlockT *BB) const {
131 template <class InstT> bool contains(const InstT *Inst) const {
154 ArrayRef<BlockT *> getBlocks() const {
158 typedef typename ArrayRef<BlockT *>::const_iterator block_iterator;
175 std::vector<BlockT *> &getBlocksVector() {
181 SmallPtrSetImpl<const BlockT *> &getBlocksSet() {
187 const SmallPtrSetImpl<const BlockT *> &getBlocksSet() const {
208 bool isLoopExiting(const BlockT *BB) const {
211 for (const auto &Succ : children<const BlockT *>(BB)) {
222 bool isLoopLatch(const BlockT *BB) const {
226 BlockT *Header = getHeader();
227 auto PredBegin = GraphTraits<Inverse<BlockT *>>::child_begin(Header);
228 auto PredEnd = GraphTraits<Inverse<BlockT *>>::child_end(Header);
236 BlockT *H = getHeader();
238 for (const auto Pred : children<Inverse<BlockT *>>(H))
256 void getExitingBlocks(SmallVectorImpl<BlockT *> &ExitingBlocks) const;
260 BlockT *getExitingBlock() const;
264 void getExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
268 BlockT *getExitBlock() const;
276 void getUniqueExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
282 void getUniqueNonLatchExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
286 BlockT *getUniqueExitBlock() const;
289 typedef std::pair<BlockT *, BlockT *> Edge;
289 typedef std::pair<BlockT *, BlockT *> Edge;
300 BlockT *getLoopPreheader() const;
306 BlockT *getLoopPredecessor() const;
310 BlockT *getLoopLatch() const;
314 void getLoopLatches(SmallVectorImpl<BlockT *> &LoopLatches) const {
316 BlockT *H = getHeader();
317 for (const auto Pred : children<Inverse<BlockT *>>(H))
365 void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase<BlockT, LoopT> &LI);
365 void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase<BlockT, LoopT> &LI);
403 void addBlockEntry(BlockT *BB) {
423 void moveToHeader(BlockT *BB) {
440 void removeBlockFromLoop(BlockT *BB) {
470 explicit LoopBase(BlockT *BB) : ParentLoop(nullptr) {
499 raw_ostream &operator<<(raw_ostream &OS, const LoopBase<BlockT, LoopT> &Loop) {
850 DenseMap<const BlockT *, LoopT *> BBMap;
928 LoopT *getLoopFor(const BlockT *BB) const { return BBMap.lookup(BB); }
931 const LoopT *operator[](const BlockT *BB) const { return getLoopFor(BB); }
935 unsigned getLoopDepth(const BlockT *BB) const {
941 bool isLoopHeader(const BlockT *BB) const {
960 void changeLoopFor(BlockT *BB, LoopT *L) {
987 void removeBlock(BlockT *BB) {
1009 void analyze(const DominatorTreeBase<BlockT, false> &DomTree);
1014 void verify(const DominatorTreeBase<BlockT, false> &DomTree) const;
include/llvm/Analysis/LoopInfoImpl.h 38 for (const auto &Succ : children<BlockT *>(BB))
51 SmallVector<BlockT *, 8> ExitingBlocks;
66 for (const auto &Succ : children<BlockT *>(BB))
77 SmallVector<BlockT *, 8> ExitBlocks;
88 SmallVector<BlockT *, 4> UniqueExitBlocks;
90 for (BlockT *EB : UniqueExitBlocks)
91 for (BlockT *Predecessor : children<Inverse<BlockT *>>(EB))
91 for (BlockT *Predecessor : children<Inverse<BlockT *>>(EB))
102 SmallVectorImpl<BlockT *> &ExitBlocks,
105 SmallPtrSet<BlockT *, 32> Visited;
107 for (BlockT *BB : Filtered)
108 for (BlockT *Successor : children<BlockT *>(BB))
108 for (BlockT *Successor : children<BlockT *>(BB))
124 const BlockT *Latch = getLoopLatch();
132 SmallVector<BlockT *, 8> UniqueExitBlocks;
145 for (const auto &Succ : children<BlockT *>(BB))
163 BlockT *Out = getLoopPredecessor();
172 typedef GraphTraits<BlockT *> BlockTraits;
191 BlockT *Out = nullptr;
194 BlockT *Header = getHeader();
195 for (const auto Pred : children<Inverse<BlockT *>>(Header)) {
211 BlockT *Header = getHeader();
212 BlockT *Latch = nullptr;
213 for (const auto Pred : children<Inverse<BlockT *>>(Header)) {
285 SmallVector<BlockT *, 8> ExitBBs;
287 df_iterator_default_set<BlockT *> VisitSet;
289 df_ext_iterator<BlockT *, df_iterator_default_set<BlockT *>>
289 df_ext_iterator<BlockT *, df_iterator_default_set<BlockT *>>
294 SmallPtrSet<BlockT *, 8> VisitedBBs;
298 BlockT *BB = *BI;
310 SmallVector<BlockT *, 2> OutsideLoopPreds;
311 std::for_each(GraphTraits<Inverse<BlockT *>>::child_begin(BB),
312 GraphTraits<Inverse<BlockT *>>::child_end(BB),
324 BlockT *EntryBB = &BB->getParent()->front();
325 for (BlockT *CB : depth_first(EntryBB))
384 BlockT *H = getHeader();
386 BlockT *BB = getBlocks()[i];
418 static void discoverAndMapSubloop(LoopT *L, ArrayRef<BlockT *> Backedges,
419 LoopInfoBase<BlockT, LoopT> *LI,
420 const DomTreeBase<BlockT> &DomTree) {
421 typedef GraphTraits<Inverse<BlockT *>> InvBlockTraits;
427 std::vector<BlockT *> ReverseCFGWorklist(Backedges.begin(), Backedges.end());
429 BlockT *PredBB = ReverseCFGWorklist.back();
464 for (const auto Pred : children<Inverse<BlockT *>>(PredBB)) {
476 typedef GraphTraits<BlockT *> BlockTraits;
479 LoopInfoBase<BlockT, LoopT> *LI;
482 PopulateLoopsDFS(LoopInfoBase<BlockT, LoopT> *li) : LI(li) {}
484 void traverse(BlockT *EntryBlock);
487 void insertIntoLoop(BlockT *Block);
493 for (BlockT *BB : post_order(EntryBlock))
540 const DomTreeNodeBase<BlockT> *DomRoot = DomTree.getRootNode();
543 BlockT *Header = DomNode->getBlock();
544 SmallVector<BlockT *, 4> Backedges;
547 for (const auto Backedge : children<Inverse<BlockT *>>(Header)) {
562 PopulateLoopsDFS<BlockT, LoopT> DFS(this);
629 void addInnerLoopsToHeadersMap(DenseMap<BlockT *, const LoopT *> &LoopHeaders,
630 const LoopInfoBase<BlockT, LoopT> &LI,
640 DenseMap<BlockT *, const LoopT *> &OtherLoopHeaders) {
641 BlockT *H = L->getHeader();
642 BlockT *OtherH = OtherL->getHeader();
657 BlockT *SubH = SubL->getHeader();
664 std::vector<BlockT *> BBs = L->getBlocks();
665 std::vector<BlockT *> OtherBBs = OtherL->getBlocks();
669 const SmallPtrSetImpl<const BlockT *> &BlocksSet = L->getBlocksSet();
670 const SmallPtrSetImpl<const BlockT *> &OtherBlocksSet = L->getBlocksSet();
692 const BlockT *BB = Entry.first;
702 LoopInfoBase<BlockT, LoopT> OtherLI;
708 DenseMap<BlockT *, const LoopT *> OtherLoopHeaders;
716 BlockT *Header = L->getHeader();
include/llvm/Analysis/RegionInfoImpl.h 504 for (const auto *BB : blocks())
include/llvm/Analysis/RegionIterator.h 42 using BlockTraits = GraphTraits<BlockT *>;
82 NodeRef getISucc(BlockT *BB) const {
90 inline BlockT* getRegionSucc() const {
96 inline bool isExit(BlockT* BB) const {
101 using Self = RNSuccIterator<NodeRef, BlockT, RegionT>;
133 BlockT *BB = isRegionMode() ? getRegionSucc() : *BItor;
169 using BlockTraits = GraphTraits<BlockT *>;
176 using Self = RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>;
include/llvm/CodeGen/Analysis.h 145 DenseMap<const MachineBasicBlock *, int>
include/llvm/CodeGen/AsmPrinter.h 407 virtual void EmitBasicBlockStart(const MachineBasicBlock &MBB);
410 virtual void EmitBasicBlockEnd(const MachineBasicBlock &MBB);
438 isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const;
681 const MachineBasicBlock *MBB, unsigned uid) const;
693 void setupCodePaddingContext(const MachineBasicBlock &MBB,
include/llvm/CodeGen/AsmPrinterHandler.h 56 virtual void beginFragment(const MachineBasicBlock *MBB,
61 virtual void beginFunclet(const MachineBasicBlock &MBB,
include/llvm/CodeGen/DFAPacketizer.h 166 void PacketizeMIs(MachineBasicBlock *MBB,
167 MachineBasicBlock::iterator BeginItr,
174 virtual MachineBasicBlock::iterator addToPacket(MachineInstr &MI) {
183 virtual void endPacket(MachineBasicBlock *MBB,
184 MachineBasicBlock::iterator MI);
192 const MachineBasicBlock *MBB) {
include/llvm/CodeGen/DebugHandlerBase.h 69 const MachineBasicBlock *PrevInstBB = nullptr;
include/llvm/CodeGen/FastISel.h 230 MachineBasicBlock::iterator LastFlushPoint;
314 void removeDeadCode(MachineBasicBlock::iterator I,
318 MachineBasicBlock::iterator InsertPt;
455 void fastEmitBranch(MachineBasicBlock *MSucc, const DebugLoc &DbgLoc);
459 void finishCondBranch(const BasicBlock *BranchBB, MachineBasicBlock *TrueMBB,
460 MachineBasicBlock *FalseMBB);
575 void initialize(MachineBasicBlock *MBB,
576 MachineBasicBlock::iterator LastFlushPoint);
585 MachineBasicBlock::iterator SavedInsertPt;
include/llvm/CodeGen/FunctionLoweringInfo.h 73 DenseMap<const BasicBlock*, MachineBasicBlock *> MBBMap;
153 MachineBasicBlock *MBB;
156 MachineBasicBlock::iterator InsertPt;
include/llvm/CodeGen/GlobalISel/CSEInfo.h 99 MachineBasicBlock *MBB, void *&InsertPos);
109 MachineBasicBlock *MBB,
187 addNodeIDMBB(const MachineBasicBlock *MBB) const;
include/llvm/CodeGen/GlobalISel/CSEMIRBuilder.h 43 bool dominates(MachineBasicBlock::const_iterator A,
include/llvm/CodeGen/GlobalISel/IRTranslator.h 150 DenseMap<const BasicBlock *, MachineBasicBlock *> BBToMBB;
158 DenseMap<CFGEdge, SmallVector<MachineBasicBlock *, 1>> MachinePreds;
297 MachineBasicBlock *HeaderBB);
298 void emitJumpTable(SwitchCG::JumpTable &JT, MachineBasicBlock *MBB);
300 void emitSwitchCase(SwitchCG::CaseBlock &CB, MachineBasicBlock *SwitchBB,
304 MachineBasicBlock *SwitchMBB,
305 MachineBasicBlock *CurMBB,
306 MachineBasicBlock *DefaultMBB,
316 MachineBasicBlock *Fallthrough,
319 MachineBasicBlock *CurMBB,
321 MachineBasicBlock *SwitchMBB);
324 MachineBasicBlock *SwitchMBB,
325 MachineBasicBlock *DefaultMBB,
534 MachineBasicBlock *Src, MachineBasicBlock *Dst,
534 MachineBasicBlock *Src, MachineBasicBlock *Dst,
587 MachineBasicBlock &getMBB(const BasicBlock &BB);
593 void addMachineCFGPred(CFGEdge Edge, MachineBasicBlock *NewPred);
599 SmallVector<MachineBasicBlock *, 1> getMachinePredBBs(CFGEdge Edge) {
608 BranchProbability getEdgeProbability(const MachineBasicBlock *Src,
609 const MachineBasicBlock *Dst) const;
611 void addSuccessorWithProb(MachineBasicBlock *Src, MachineBasicBlock *Dst,
611 void addSuccessorWithProb(MachineBasicBlock *Src, MachineBasicBlock *Dst,
include/llvm/CodeGen/GlobalISel/Localizer.h 59 MachineBasicBlock *&InsertMBB);
include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h 50 MachineBasicBlock *MBB;
51 MachineBasicBlock::iterator II;
278 const MachineBasicBlock &getMBB() const {
283 MachineBasicBlock &getMBB() {
292 MachineBasicBlock::iterator getInsertPt() { return State.II; }
297 void setInsertPt(MachineBasicBlock &MBB, MachineBasicBlock::iterator II);
297 void setInsertPt(MachineBasicBlock &MBB, MachineBasicBlock::iterator II);
309 void setMBB(MachineBasicBlock &MBB);
622 MachineInstrBuilder buildBr(MachineBasicBlock &Dest);
636 MachineInstrBuilder buildBrCond(Register Tst, MachineBasicBlock &Dest);
include/llvm/CodeGen/GlobalISel/RegBankSelect.h 129 virtual MachineBasicBlock &getInsertMBBImpl() = 0;
135 virtual MachineBasicBlock::iterator getPointImpl() = 0;
148 MachineBasicBlock::iterator getPoint() {
167 MachineBasicBlock &getInsertMBB() {
179 MachineBasicBlock::iterator insert(MachineInstr &MI) {
213 MachineBasicBlock::iterator getPointImpl() override {
220 MachineBasicBlock &getInsertMBBImpl() override {
239 MachineBasicBlock &MBB;
247 MachineBasicBlock::iterator getPointImpl() override {
251 MachineBasicBlock &getInsertMBBImpl() override { return MBB; }
254 MBBInsertPoint(MachineBasicBlock &MBB, bool Beginning = true)
275 MachineBasicBlock &Src;
280 MachineBasicBlock *DstOrSplit;
287 MachineBasicBlock::iterator getPointImpl() override {
297 MachineBasicBlock &getInsertMBBImpl() override { return *DstOrSplit; }
300 EdgeInsertPoint(MachineBasicBlock &Src, MachineBasicBlock &Dst, Pass &P)
300 EdgeInsertPoint(MachineBasicBlock &Src, MachineBasicBlock &Dst, Pass &P)
370 void addInsertPoint(MachineBasicBlock &MBB, bool Beginning);
374 void addInsertPoint(MachineBasicBlock &Src, MachineBasicBlock &Dst);
374 void addInsertPoint(MachineBasicBlock &Src, MachineBasicBlock &Dst);
include/llvm/CodeGen/LexicalScopes.h 164 SmallPtrSetImpl<const MachineBasicBlock *> &MBBs);
168 bool dominates(const DILocation *DL, MachineBasicBlock *MBB);
include/llvm/CodeGen/LiveIntervals.h 112 const MachineBasicBlock *MBB);
236 SlotIndex getMBBStartIdx(const MachineBasicBlock *mbb) const {
241 SlotIndex getMBBEndIdx(const MachineBasicBlock *mbb) const {
246 const MachineBasicBlock *mbb) const {
251 const MachineBasicBlock *mbb) const {
255 MachineBasicBlock* getMBBFromIndex(SlotIndex index) const {
259 void insertMBBInMaps(MachineBasicBlock *MBB) {
270 void InsertMachineInstrRangeInMaps(MachineBasicBlock::iterator B,
272 for (MachineBasicBlock::iterator I = B; I != E; ++I)
297 MachineBasicBlock *intervalIsInOneMBB(const LiveInterval &LI) const;
333 void repairIntervalsInRange(MachineBasicBlock *MBB,
334 MachineBasicBlock::iterator Begin,
483 void repairOldRegInRange(MachineBasicBlock::iterator Begin,
include/llvm/CodeGen/LivePhysRegs.h 134 void addLiveIns(const MachineBasicBlock &MBB);
140 void addLiveOuts(const MachineBasicBlock &MBB);
144 void addLiveOutsNoPristines(const MachineBasicBlock &MBB);
160 void addBlockLiveIns(const MachineBasicBlock &MBB);
175 void computeLiveIns(LivePhysRegs &LiveRegs, const MachineBasicBlock &MBB);
178 void recomputeLivenessFlags(MachineBasicBlock &MBB);
182 void addLiveIns(MachineBasicBlock &MBB, const LivePhysRegs &LiveRegs);
186 MachineBasicBlock &MBB);
189 static inline void recomputeLiveIns(MachineBasicBlock &MBB) {
include/llvm/CodeGen/LiveRangeCalc.h 42 using MachineDomTreeNode = DomTreeNodeBase<MachineBasicBlock>;
129 MachineBasicBlock &MBB, BitVector &DefOnEntry,
148 bool findReachingDefs(LiveRange &LR, MachineBasicBlock &UseMBB, SlotIndex Use,
255 void setLiveOutValue(MachineBasicBlock *MBB, VNInfo *VNI) {
288 static bool isJointlyDominated(const MachineBasicBlock *MBB,
include/llvm/CodeGen/LiveRangeEdit.h 219 SlotIndex rematerializeAt(MachineBasicBlock &MBB,
220 MachineBasicBlock::iterator MI, unsigned DestReg,
include/llvm/CodeGen/LiveRegUnits.h 139 void addLiveOuts(const MachineBasicBlock &MBB);
142 void addLiveIns(const MachineBasicBlock &MBB);
include/llvm/CodeGen/LiveVariables.h 102 MachineInstr *findKill(const MachineBasicBlock *MBB) const;
107 bool isLiveIn(const MachineBasicBlock &MBB,
179 void runOnBlock(MachineBasicBlock *MBB, unsigned NumRegs);
274 void MarkVirtRegAliveInBlock(VarInfo& VRInfo, MachineBasicBlock* DefBlock,
275 MachineBasicBlock *BB);
276 void MarkVirtRegAliveInBlock(VarInfo& VRInfo, MachineBasicBlock* DefBlock,
277 MachineBasicBlock *BB,
278 std::vector<MachineBasicBlock*> &WorkList);
280 void HandleVirtRegUse(unsigned reg, MachineBasicBlock *MBB, MachineInstr &MI);
282 bool isLiveIn(unsigned Reg, const MachineBasicBlock &MBB) {
289 bool isLiveOut(unsigned Reg, const MachineBasicBlock &MBB);
295 void addNewBlock(MachineBasicBlock *BB,
296 MachineBasicBlock *DomBB,
297 MachineBasicBlock *SuccBB);
include/llvm/CodeGen/LoopTraversal.h 89 MachineBasicBlock *MBB = nullptr;
97 TraversedMBBInfo(MachineBasicBlock *BB = nullptr, bool Primary = true,
110 bool isBlockDone(MachineBasicBlock *MBB);
include/llvm/CodeGen/MIRParser/MIParser.h 166 DenseMap<unsigned, MachineBasicBlock *> MBBSlots;
211 MachineBasicBlock *&MBB, StringRef Src,
include/llvm/CodeGen/MIRPrinter.h 39 void guessSuccessors(const MachineBasicBlock &MBB,
40 SmallVectorImpl<MachineBasicBlock*> &Result,
include/llvm/CodeGen/MachineBasicBlock.h 52 MachineBasicBlock *Parent;
66 : public ilist_node_with_parent<MachineBasicBlock, MachineFunction> {
89 std::vector<MachineBasicBlock *> Predecessors;
90 std::vector<MachineBasicBlock *> Successors;
233 return &MachineBasicBlock::Insts;
252 using pred_iterator = std::vector<MachineBasicBlock *>::iterator;
253 using const_pred_iterator = std::vector<MachineBasicBlock *>::const_iterator;
254 using succ_iterator = std::vector<MachineBasicBlock *>::iterator;
255 using const_succ_iterator = std::vector<MachineBasicBlock *>::const_iterator;
257 std::vector<MachineBasicBlock *>::reverse_iterator;
259 std::vector<MachineBasicBlock *>::const_reverse_iterator;
261 std::vector<MachineBasicBlock *>::reverse_iterator;
263 std::vector<MachineBasicBlock *>::const_reverse_iterator;
419 void moveBefore(MachineBasicBlock *NewAfter);
420 void moveAfter(MachineBasicBlock *NewBefore);
438 void addSuccessor(MachineBasicBlock *Succ,
445 void addSuccessorWithoutProb(MachineBasicBlock *Succ);
467 void removeSuccessor(MachineBasicBlock *Succ,
479 void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New);
479 void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New);
486 void copySuccessor(MachineBasicBlock *Orig, succ_iterator I);
490 void splitSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New,
490 void splitSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New,
496 void transferSuccessors(MachineBasicBlock *FromMBB);
500 void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB);
506 bool isPredecessor(const MachineBasicBlock *MBB) const;
509 bool isSuccessor(const MachineBasicBlock *MBB) const;
516 bool isLayoutSuccessor(const MachineBasicBlock *MBB) const;
523 MachineBasicBlock *getFallThrough();
591 MachineBasicBlock *SplitCriticalEdge(MachineBasicBlock *Succ, Pass &P);
591 MachineBasicBlock *SplitCriticalEdge(MachineBasicBlock *Succ, Pass &P);
597 bool canSplitCriticalEdge(const MachineBasicBlock *Succ) const;
708 void splice(iterator Where, MachineBasicBlock *Other, iterator From) {
719 void splice(iterator Where, MachineBasicBlock *Other,
727 MachineBasicBlock *removeFromParent();
734 void ReplaceUsesOfBlockWith(MachineBasicBlock *Old, MachineBasicBlock *New);
734 void ReplaceUsesOfBlockWith(MachineBasicBlock *Old, MachineBasicBlock *New);
738 void replacePhiUsesWith(MachineBasicBlock *Old, MachineBasicBlock *New);
738 void replacePhiUsesWith(MachineBasicBlock *Old, MachineBasicBlock *New);
746 bool CorrectExtraCFGEdges(MachineBasicBlock *DestA,
747 MachineBasicBlock *DestB,
836 void addPredecessor(MachineBasicBlock *Pred);
841 void removePredecessor(MachineBasicBlock *Pred);
844 raw_ostream& operator<<(raw_ostream &OS, const MachineBasicBlock &MBB);
852 Printable printMBBReference(const MachineBasicBlock &MBB);
856 using argument_type = const MachineBasicBlock *;
857 unsigned operator()(const MachineBasicBlock *MBB) const {
871 using NodeRef = MachineBasicBlock *;
872 using ChildIteratorType = MachineBasicBlock::succ_iterator;
874 static NodeRef getEntryNode(MachineBasicBlock *BB) { return BB; }
880 using NodeRef = const MachineBasicBlock *;
881 using ChildIteratorType = MachineBasicBlock::const_succ_iterator;
883 static NodeRef getEntryNode(const MachineBasicBlock *BB) { return BB; }
895 using NodeRef = MachineBasicBlock *;
896 using ChildIteratorType = MachineBasicBlock::pred_iterator;
898 static NodeRef getEntryNode(Inverse<MachineBasicBlock *> G) {
907 using NodeRef = const MachineBasicBlock *;
908 using ChildIteratorType = MachineBasicBlock::const_pred_iterator;
910 static NodeRef getEntryNode(Inverse<const MachineBasicBlock *> G) {
923 MachineBasicBlock &MBB;
924 MachineBasicBlock::iterator I, B, E;
927 MachineInstrSpan(MachineBasicBlock::iterator I, MachineBasicBlock *BB)
927 MachineInstrSpan(MachineBasicBlock::iterator I, MachineBasicBlock *BB)
933 MachineBasicBlock::iterator begin() {
936 MachineBasicBlock::iterator end() { return E; }
939 MachineBasicBlock::iterator getInitial() { return I; }
include/llvm/CodeGen/MachineBlockFrequencyInfo.h 34 using ImplType = BlockFrequencyInfoImpl<MachineBasicBlock>;
62 BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const;
64 Optional<uint64_t> getBlockProfileCount(const MachineBasicBlock *MBB) const;
67 bool isIrrLoopHeader(const MachineBasicBlock *MBB);
80 const MachineBasicBlock *MBB) const;
include/llvm/CodeGen/MachineBranchProbabilityInfo.h 48 BranchProbability getEdgeProbability(const MachineBasicBlock *Src,
49 const MachineBasicBlock *Dst) const;
54 getEdgeProbability(const MachineBasicBlock *Src,
55 MachineBasicBlock::const_succ_iterator Dst) const;
58 bool isEdgeHot(const MachineBasicBlock *Src,
59 const MachineBasicBlock *Dst) const;
63 MachineBasicBlock *getHotSucc(MachineBasicBlock *MBB) const;
63 MachineBasicBlock *getHotSucc(MachineBasicBlock *MBB) const;
69 const MachineBasicBlock *Src,
70 const MachineBasicBlock *Dst) const;
include/llvm/CodeGen/MachineDominanceFrontier.h 22 ForwardDominanceFrontierBase<MachineBasicBlock> Base;
25 using DomTreeT = DomTreeBase<MachineBasicBlock>;
26 using DomTreeNodeT = DomTreeNodeBase<MachineBasicBlock>;
27 using DomSetType = DominanceFrontierBase<MachineBasicBlock, false>::DomSetType;
28 using iterator = DominanceFrontierBase<MachineBasicBlock, false>::iterator;
30 DominanceFrontierBase<MachineBasicBlock, false>::const_iterator;
39 ForwardDominanceFrontierBase<MachineBasicBlock> &getBase() { return Base; }
41 const SmallVectorImpl<MachineBasicBlock *> &getRoots() const {
45 MachineBasicBlock *getRoot() const {
69 iterator find(MachineBasicBlock *B) {
73 const_iterator find(MachineBasicBlock *B) const {
77 iterator addBasicBlock(MachineBasicBlock *BB, const DomSetType &frontier) {
81 void removeBlock(MachineBasicBlock *BB) {
85 void addToFrontier(iterator I, MachineBasicBlock *Node) {
89 void removeFromFrontier(iterator I, MachineBasicBlock *Node) {
97 bool compare(DominanceFrontierBase<MachineBasicBlock, false> &Other) const {
include/llvm/CodeGen/MachineDominators.h 32 MachineBasicBlock *MBB) {
40 using MachineDomTreeNode = DomTreeNodeBase<MachineBasicBlock>;
47 using DomTreeT = DomTreeBase<MachineBasicBlock>;
52 MachineBasicBlock *FromBB;
53 MachineBasicBlock *ToBB;
54 MachineBasicBlock *NewBB;
68 mutable SmallSet<MachineBasicBlock *, 32> NewBBs;
100 const SmallVectorImpl<MachineBasicBlock*> &getRoots() const {
105 MachineBasicBlock *getRoot() const {
125 bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
125 bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
134 const MachineBasicBlock *BBA = A->getParent(), *BBB = B->getParent();
138 MachineBasicBlock::const_iterator I = BBA->begin();
151 bool properlyDominates(const MachineBasicBlock *A,
152 const MachineBasicBlock *B) const {
159 MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
159 MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
160 MachineBasicBlock *B) {
165 MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
173 MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
181 MachineDomTreeNode *addNewBlock(MachineBasicBlock *BB,
182 MachineBasicBlock *DomBB) {
190 void changeImmediateDominator(MachineBasicBlock *N,
191 MachineBasicBlock *NewIDom) {
205 void eraseNode(MachineBasicBlock *BB) {
212 void splitBlock(MachineBasicBlock* NewBB) {
219 bool isReachableFromEntry(const MachineBasicBlock *A) {
242 void recordSplitCriticalEdge(MachineBasicBlock *FromBB,
243 MachineBasicBlock *ToBB,
244 MachineBasicBlock *NewBB) {
include/llvm/CodeGen/MachineFrameInfo.h 334 MachineBasicBlock *Save = nullptr;
336 MachineBasicBlock *Restore = nullptr;
789 MachineBasicBlock *getSavePoint() const { return Save; }
790 void setSavePoint(MachineBasicBlock *NewSave) { Save = NewSave; }
791 MachineBasicBlock *getRestorePoint() const { return Restore; }
792 void setRestorePoint(MachineBasicBlock *NewRestore) { Restore = NewRestore; }
include/llvm/CodeGen/MachineFunction.h 77 void deleteNode(MachineBasicBlock *MBB);
81 void addNodeToList(MachineBasicBlock* N);
82 void removeNodeFromList(MachineBasicBlock* N);
212 MachineBasicBlock *LandingPadBlock; // Landing pad block.
219 explicit LandingPadInfo(MachineBasicBlock *MBB)
257 std::vector<MachineBasicBlock*> MBBNumbering;
269 Recycler<MachineBasicBlock> BasicBlockRecycler;
272 using BasicBlockListType = ilist<MachineBasicBlock>;
321 DenseMap<const MachineBasicBlock *, unsigned> WasmLPadToIndexMap;
586 MachineBasicBlock *getBlockNumbered(unsigned N) const {
603 void RenumberBlocks(MachineBasicBlock *MBBFrom = nullptr);
663 const MachineBasicBlock &front() const { return BasicBlocks.front(); }
664 MachineBasicBlock &front() { return BasicBlocks.front(); }
665 const MachineBasicBlock & back() const { return BasicBlocks.back(); }
666 MachineBasicBlock & back() { return BasicBlocks.back(); }
668 void push_back (MachineBasicBlock *MBB) { BasicBlocks.push_back (MBB); }
669 void push_front(MachineBasicBlock *MBB) { BasicBlocks.push_front(MBB); }
684 void remove(MachineBasicBlock *MBBI) { BasicBlocks.remove(MBBI); }
686 void erase(MachineBasicBlock *MBBI) { BasicBlocks.erase(MBBI); }
696 for (const MachineBasicBlock &MBB : BasicBlocks)
706 unsigned addToMBBNumbering(MachineBasicBlock *MBB) {
738 MachineInstr &CloneMachineInstrBundle(MachineBasicBlock &MBB,
739 MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig);
746 MachineBasicBlock *CreateMachineBasicBlock(const BasicBlock *bb = nullptr);
749 void DeleteMachineBasicBlock(MachineBasicBlock *MBB);
859 LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad);
872 void addInvoke(MachineBasicBlock *LandingPad,
878 MCSymbol *addLandingPad(MachineBasicBlock *LandingPad);
881 void addCatchTypeInfo(MachineBasicBlock *LandingPad,
885 void addFilterTypeInfo(MachineBasicBlock *LandingPad,
889 void addCleanup(MachineBasicBlock *LandingPad);
891 void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter,
894 void addSEHCleanupHandler(MachineBasicBlock *LandingPad,
907 void setWasmLandingPadIndex(const MachineBasicBlock *LPad, unsigned Index) {
912 bool hasWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
917 unsigned getWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
1024 public GraphTraits<MachineBasicBlock*> {
1041 public GraphTraits<const MachineBasicBlock*> {
1066 public GraphTraits<Inverse<MachineBasicBlock*>> {
1072 public GraphTraits<Inverse<const MachineBasicBlock*>> {
include/llvm/CodeGen/MachineInstr.h 64 : public ilist_node_with_parent<MachineInstr, MachineBasicBlock,
113 MachineBasicBlock *Parent = nullptr; // Pointer to the owning basic block.
250 void setParent(MachineBasicBlock *P) { Parent = P; }
271 const MachineBasicBlock* getParent() const { return Parent; }
272 MachineBasicBlock* getParent() { return Parent; }
include/llvm/CodeGen/MachineInstrBuilder.h 70 MachineInstrBuilder(MachineFunction &F, MachineBasicBlock::iterator I)
76 operator MachineBasicBlock::iterator() const { return MI; }
137 const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB,
332 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
333 MachineBasicBlock::iterator I,
348 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
349 MachineBasicBlock::instr_iterator I,
358 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr &I,
368 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr *I,
377 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
378 MachineBasicBlock::iterator I,
387 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
388 MachineBasicBlock::instr_iterator I,
397 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr &I,
407 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr *I,
415 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, const DebugLoc &DL,
423 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, const DebugLoc &DL,
447 MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
448 MachineBasicBlock::iterator I, const DebugLoc &DL,
455 MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
456 MachineBasicBlock::iterator I, const DebugLoc &DL,
462 MachineInstr *buildDbgValueForSpill(MachineBasicBlock &BB,
463 MachineBasicBlock::iterator I,
513 MachineBasicBlock &MBB;
514 MachineBasicBlock::instr_iterator Begin;
515 MachineBasicBlock::instr_iterator End;
520 MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator Pos)
520 MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator Pos)
524 MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator B,
524 MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator B,
525 MachineBasicBlock::iterator E)
543 MachineBasicBlock &getMBB() const { return MBB; }
550 MachineBasicBlock::instr_iterator begin() const { return Begin; }
553 MachineBasicBlock::instr_iterator end() const { return End; }
557 MIBundleBuilder &insert(MachineBasicBlock::instr_iterator I,
include/llvm/CodeGen/MachineInstrBundle.h 27 void finalizeBundle(MachineBasicBlock &MBB,
28 MachineBasicBlock::instr_iterator FirstMI,
36 MachineBasicBlock::instr_iterator finalizeBundle(MachineBasicBlock &MBB,
44 inline MachineBasicBlock::instr_iterator getBundleStart(
52 inline MachineBasicBlock::const_instr_iterator getBundleStart(
60 inline MachineBasicBlock::instr_iterator getBundleEnd(
69 inline MachineBasicBlock::const_instr_iterator getBundleEnd(
94 MachineBasicBlock::instr_iterator InstrI, InstrE;
include/llvm/CodeGen/MachineJumpTableInfo.h 36 std::vector<MachineBasicBlock*> MBBs;
38 explicit MachineJumpTableEntry(const std::vector<MachineBasicBlock*> &M)
93 unsigned createJumpTableIndex(const std::vector<MachineBasicBlock*> &DestBBs);
111 bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New);
111 bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New);
115 bool ReplaceMBBInJumpTable(unsigned Idx, MachineBasicBlock *Old,
116 MachineBasicBlock *New);
include/llvm/CodeGen/MachineLoopInfo.h 45 class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
50 MachineBasicBlock *getTopBlock();
55 MachineBasicBlock *getBottomBlock();
61 MachineBasicBlock *findLoopControlBlock();
75 explicit MachineLoop(MachineBasicBlock *MBB)
87 LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
102 LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
109 MachineBasicBlock *findLoopPreheader(MachineLoop *L,
113 using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
120 inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
125 inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
130 inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
135 inline bool isLoopHeader(const MachineBasicBlock *BB) const {
154 inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
172 void removeBlock(MachineBasicBlock *BB) {
include/llvm/CodeGen/MachineLoopUtils.h 34 MachineBasicBlock *PeelSingleBlockLoop(LoopPeelDirection Direction,
35 MachineBasicBlock *Loop,
include/llvm/CodeGen/MachineOperand.h 167 MachineBasicBlock *MBB; // For MO_MachineBasicBlock.
545 MachineBasicBlock *getMBB() const {
682 void setMBB(MachineBasicBlock *MBB) {
799 static MachineOperand CreateMBB(MachineBasicBlock *MBB,
include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h 33 const MachineBasicBlock *MBB)
49 const MachineBasicBlock *getBlock() const { return MBB; }
52 const MachineBasicBlock *MBB;
65 const MachineBasicBlock *MBB)
91 const MachineBasicBlock *MBB)
117 const MachineBasicBlock *MBB)
193 Optional<uint64_t> computeHotness(const MachineBasicBlock &MBB);
include/llvm/CodeGen/MachineOutliner.h 46 MachineBasicBlock::iterator FirstInst;
49 MachineBasicBlock::iterator LastInst;
52 MachineBasicBlock *MBB;
106 MachineBasicBlock::iterator &front() { return FirstInst; }
107 MachineBasicBlock::iterator &back() { return LastInst; }
109 MachineBasicBlock *getMBB() const { return MBB; }
121 MachineBasicBlock::iterator &FirstInst,
include/llvm/CodeGen/MachinePipeliner.h 76 MachineBasicBlock *TBB = nullptr;
77 MachineBasicBlock *FBB = nullptr;
102 void preprocessPhiNodes(MachineBasicBlock &B);
145 using MBBVectorTy = SmallVectorImpl<MachineBasicBlock *>;
include/llvm/CodeGen/MachinePostDominators.h 28 using PostDomTreeT = PostDomTreeBase<MachineBasicBlock>;
38 const SmallVectorImpl<MachineBasicBlock *> &getRoots() const {
44 MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
48 MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
57 bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
57 bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
66 bool properlyDominates(const MachineBasicBlock *A,
67 const MachineBasicBlock *B) const {
75 MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
75 MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
76 MachineBasicBlock *B) const {
82 MachineBasicBlock *
83 findNearestCommonDominator(ArrayRef<MachineBasicBlock *> Blocks) const;
include/llvm/CodeGen/MachineRegionInfo.h 32 using BlockT = MachineBasicBlock;
44 static unsigned getNumSuccessors(MachineBasicBlock *BB) {
51 inline MachineRegionNode(MachineRegion *Parent, MachineBasicBlock *Entry,
63 MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
63 MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
111 inline MachineBasicBlock *
112 RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>()
include/llvm/CodeGen/MachineRegisterInfo.h 954 void EmitLiveInCopies(MachineBasicBlock *EntryMBB,
1036 MachineBasicBlock::instr_iterator P =
1142 MachineBasicBlock::instr_iterator P =
include/llvm/CodeGen/MachineSSAUpdater.h 69 void AddAvailableValue(MachineBasicBlock *BB, unsigned V);
73 bool HasValueForBlock(MachineBasicBlock *BB) const;
77 unsigned GetValueAtEndOfBlock(MachineBasicBlock *BB);
97 unsigned GetValueInMiddleOfBlock(MachineBasicBlock *BB);
107 unsigned GetValueAtEndOfBlockInternal(MachineBasicBlock *BB);
include/llvm/CodeGen/MachineScheduler.h 204 virtual void initPolicy(MachineBasicBlock::iterator Begin,
228 virtual void enterMBB(MachineBasicBlock *MBB) {};
272 MachineBasicBlock::iterator CurrentTop;
275 MachineBasicBlock::iterator CurrentBottom;
319 MachineBasicBlock::iterator top() const { return CurrentTop; }
320 MachineBasicBlock::iterator bottom() const { return CurrentBottom; }
325 void enterRegion(MachineBasicBlock *bb,
326 MachineBasicBlock::iterator begin,
334 void startBlock(MachineBasicBlock *bb) override;
339 void moveInstruction(MachineInstr *MI, MachineBasicBlock::iterator InsertPos);
390 MachineBasicBlock::iterator LiveRegionEnd;
472 void enterRegion(MachineBasicBlock *bb,
473 MachineBasicBlock::iterator begin,
934 void initPolicy(MachineBasicBlock::iterator Begin,
1022 void initPolicy(MachineBasicBlock::iterator Begin,
include/llvm/CodeGen/MachineSizeOpts.h 31 bool shouldOptimizeForSize(const MachineBasicBlock *MBB,
include/llvm/CodeGen/MachineTraceMetrics.h 130 const FixedBlockInfo *getResources(const MachineBasicBlock*);
158 const MachineBasicBlock *Pred = nullptr;
162 const MachineBasicBlock *Succ = nullptr;
287 ArrayRef<const MachineBasicBlock *> Extrablocks = None,
329 void computeTrace(const MachineBasicBlock*);
330 void computeDepthResources(const MachineBasicBlock*);
331 void computeHeightResources(const MachineBasicBlock*);
333 void computeInstrDepths(const MachineBasicBlock*);
334 void computeInstrHeights(const MachineBasicBlock*);
336 ArrayRef<const MachineBasicBlock*> Trace);
343 virtual const MachineBasicBlock *pickTracePred(const MachineBasicBlock*) =0;
343 virtual const MachineBasicBlock *pickTracePred(const MachineBasicBlock*) =0;
344 virtual const MachineBasicBlock *pickTraceSucc(const MachineBasicBlock*) =0;
344 virtual const MachineBasicBlock *pickTraceSucc(const MachineBasicBlock*) =0;
345 const MachineLoop *getLoopFor(const MachineBasicBlock*) const;
346 const TraceBlockInfo *getDepthResources(const MachineBasicBlock*) const;
347 const TraceBlockInfo *getHeightResources(const MachineBasicBlock*) const;
356 void invalidate(const MachineBasicBlock *MBB);
361 Trace getTrace(const MachineBasicBlock *MBB);
366 void updateDepth(const MachineBasicBlock *, const MachineInstr&,
370 void updateDepths(MachineBasicBlock::iterator Start,
397 void invalidate(const MachineBasicBlock *MBB);
include/llvm/CodeGen/ModuloSchedule.h 159 using MBBVectorTy = SmallVectorImpl<MachineBasicBlock *>;
169 MachineBasicBlock *BB;
170 MachineBasicBlock *Preheader;
171 MachineBasicBlock *NewKernel = nullptr;
184 void generateProlog(unsigned LastStage, MachineBasicBlock *KernelBB,
186 void generateEpilog(unsigned LastStage, MachineBasicBlock *KernelBB,
189 void generateExistingPhis(MachineBasicBlock *NewBB, MachineBasicBlock *BB1,
189 void generateExistingPhis(MachineBasicBlock *NewBB, MachineBasicBlock *BB1,
190 MachineBasicBlock *BB2, MachineBasicBlock *KernelBB,
190 MachineBasicBlock *BB2, MachineBasicBlock *KernelBB,
194 void generatePhis(MachineBasicBlock *NewBB, MachineBasicBlock *BB1,
194 void generatePhis(MachineBasicBlock *NewBB, MachineBasicBlock *BB1,
195 MachineBasicBlock *BB2, MachineBasicBlock *KernelBB,
195 MachineBasicBlock *BB2, MachineBasicBlock *KernelBB,
198 void removeDeadInstructions(MachineBasicBlock *KernelBB,
200 void splitLifetimes(MachineBasicBlock *KernelBB, MBBVectorTy &EpilogBBs);
201 void addBranches(MachineBasicBlock &PreheaderBB, MBBVectorTy &PrologBBs,
202 MachineBasicBlock *KernelBB, MBBVectorTy &EpilogBBs,
217 MachineBasicBlock *BB);
218 void rewritePhiValues(MachineBasicBlock *NewBB, unsigned StageNum,
220 void rewriteScheduledInstr(MachineBasicBlock *BB, InstrMapTy &InstrMap,
268 MachineBasicBlock *getRewrittenKernel() { return NewKernel; }
282 MachineBasicBlock *BB;
284 MachineBasicBlock *Preheader;
286 SmallVector<MachineBasicBlock *, 4> Prologs, Epilogs;
288 DenseMap<MachineBasicBlock *, BitVector> LiveStages;
292 DenseMap<MachineBasicBlock *, BitVector> AvailableStages;
297 DenseMap<std::pair<MachineBasicBlock *, MachineInstr *>, MachineInstr *>
301 std::deque<MachineBasicBlock *> PeeledFront, PeeledBack;
323 MachineBasicBlock *peelKernel(LoopPeelDirection LPD);
329 Register getEquivalentRegisterIn(Register Reg, MachineBasicBlock *BB);
338 MachineBasicBlock *CreateLCSSAExitingBlock();
include/llvm/CodeGen/RegisterPressure.h 85 MachineBasicBlock::const_iterator TopPos;
86 MachineBasicBlock::const_iterator BottomPos;
90 void openTop(MachineBasicBlock::const_iterator PrevTop);
92 void openBottom(MachineBasicBlock::const_iterator PrevBottom);
366 const MachineBasicBlock *MBB = nullptr;
384 MachineBasicBlock::const_iterator CurrPos;
404 const LiveIntervals *lis, const MachineBasicBlock *mbb,
405 MachineBasicBlock::const_iterator pos,
414 MachineBasicBlock::const_iterator getPos() const { return CurrPos; }
420 void setPos(MachineBasicBlock::const_iterator Pos) { CurrPos = Pos; }
include/llvm/CodeGen/RegisterScavenging.h 38 MachineBasicBlock *MBB = nullptr;
39 MachineBasicBlock::iterator MBBI;
74 void enterBasicBlock(MachineBasicBlock &MBB);
80 void enterBasicBlockEnd(MachineBasicBlock &MBB);
87 void forward(MachineBasicBlock::iterator I) {
97 void unprocess(MachineBasicBlock::iterator I) {
107 void backward(MachineBasicBlock::iterator I) {
113 void skipTo(MachineBasicBlock::iterator I) {
119 MachineBasicBlock::iterator getCurrentPosition() const { return MBBI; }
164 MachineBasicBlock::iterator I, int SPAdj,
181 MachineBasicBlock::iterator To,
215 Register findSurvivorReg(MachineBasicBlock::iterator StartMI,
221 void init(MachineBasicBlock &MBB);
224 void setLiveInsUsed(const MachineBasicBlock &MBB);
229 MachineBasicBlock::iterator Before,
include/llvm/CodeGen/ScheduleDAGInstrs.h 145 MachineBasicBlock *BB;
148 MachineBasicBlock::iterator RegionBegin;
151 MachineBasicBlock::iterator RegionEnd;
272 MachineBasicBlock::iterator begin() const { return RegionBegin; }
275 MachineBasicBlock::iterator end() const { return RegionEnd; }
289 virtual void startBlock(MachineBasicBlock *BB);
298 virtual void enterRegion(MachineBasicBlock *bb,
299 MachineBasicBlock::iterator begin,
345 void fixupKills(MachineBasicBlock &MBB);
367 void startBlockForKills(MachineBasicBlock *BB);
include/llvm/CodeGen/SelectionDAG.h 674 SDValue getBasicBlock(MachineBasicBlock *MBB);
675 SDValue getBasicBlock(MachineBasicBlock *MBB, SDLoc dl);
include/llvm/CodeGen/SelectionDAGNodes.h 1907 MachineBasicBlock *MBB;
1912 explicit BasicBlockSDNode(MachineBasicBlock *mbb)
1917 MachineBasicBlock *getBasicBlock() const { return MBB; }
include/llvm/CodeGen/SlotIndexes.h 309 using IdxMBBPair = std::pair<SlotIndex, MachineBasicBlock *>;
368 void repairIndexesInRange(MachineBasicBlock *MBB,
369 MachineBasicBlock::iterator Begin,
426 const MachineBasicBlock *MBB = MI.getParent();
428 MachineBasicBlock::const_iterator I = MI, B = MBB->begin();
443 const MachineBasicBlock *MBB = MI.getParent();
445 MachineBasicBlock::const_iterator I = MI, E = MBB->end();
464 getMBBRange(const MachineBasicBlock *MBB) const {
474 SlotIndex getMBBStartIdx(const MachineBasicBlock *mbb) const {
484 SlotIndex getMBBEndIdx(const MachineBasicBlock *mbb) const {
517 MachineBasicBlock* getMBBFromIndex(SlotIndex index) const {
606 void insertMBBInMaps(MachineBasicBlock *mbb) {
include/llvm/CodeGen/SwiftErrorValueTracking.h 45 DenseMap<std::pair<const MachineBasicBlock *, const Value *>, Register>
51 DenseMap<std::pair<const MachineBasicBlock *, const Value *>, Register>
80 Register getOrCreateVReg(const MachineBasicBlock *, const Value *);
84 void setCurrentVReg(const MachineBasicBlock *MBB, const Value *, Register);
88 Register getOrCreateVRegDefAt(const Instruction *, const MachineBasicBlock *,
93 Register getOrCreateVRegUseAt(const Instruction *, const MachineBasicBlock *,
104 void preassignVRegs(MachineBasicBlock *MBB, BasicBlock::const_iterator Begin,
include/llvm/CodeGen/SwitchLoweringUtils.h 40 MachineBasicBlock *MBB;
47 MachineBasicBlock *MBB, BranchProbability Prob) {
88 MachineBasicBlock *BB = nullptr;
93 CaseBits(uint64_t mask, MachineBasicBlock *bb, unsigned bits,
124 MachineBasicBlock *TrueBB, *FalseBB;
127 MachineBasicBlock *ThisBB;
139 const Value *cmpmiddle, MachineBasicBlock *truebb,
140 MachineBasicBlock *falsebb, MachineBasicBlock *me, SDLoc dl,
140 MachineBasicBlock *falsebb, MachineBasicBlock *me, SDLoc dl,
150 MachineBasicBlock *truebb, MachineBasicBlock *falsebb,
150 MachineBasicBlock *truebb, MachineBasicBlock *falsebb,
151 MachineBasicBlock *me, DebugLoc dl,
166 MachineBasicBlock *MBB;
169 MachineBasicBlock *Default;
171 JumpTable(unsigned R, unsigned J, MachineBasicBlock *M, MachineBasicBlock *D)
171 JumpTable(unsigned R, unsigned J, MachineBasicBlock *M, MachineBasicBlock *D)
178 MachineBasicBlock *HeaderBB;
182 JumpTableHeader(APInt F, APInt L, const Value *SV, MachineBasicBlock *H,
191 MachineBasicBlock *ThisBB;
192 MachineBasicBlock *TargetBB;
195 BitTestCase(uint64_t M, MachineBasicBlock *T, MachineBasicBlock *Tr,
195 BitTestCase(uint64_t M, MachineBasicBlock *T, MachineBasicBlock *Tr,
210 MachineBasicBlock *Parent;
211 MachineBasicBlock *Default;
218 bool CR, MachineBasicBlock *P, MachineBasicBlock *D,
218 bool CR, MachineBasicBlock *P, MachineBasicBlock *D,
234 MachineBasicBlock *MBB;
267 MachineBasicBlock *DefaultMBB);
271 MachineBasicBlock *DefaultMBB, CaseCluster &JTCluster);
282 MachineBasicBlock *Src, MachineBasicBlock *Dst,
282 MachineBasicBlock *Src, MachineBasicBlock *Dst,
include/llvm/CodeGen/TailDuplicator.h 52 using AvailableValsTy = std::vector<std::pair<MachineBasicBlock *, unsigned>>;
71 static bool isSimpleBB(MachineBasicBlock *TailBB);
72 bool shouldTailDuplicate(bool IsSimple, MachineBasicBlock &TailBB);
75 bool canTailDuplicate(MachineBasicBlock *TailBB, MachineBasicBlock *PredBB);
75 bool canTailDuplicate(MachineBasicBlock *TailBB, MachineBasicBlock *PredBB);
84 bool IsSimple, MachineBasicBlock *MBB,
85 MachineBasicBlock *ForcedLayoutPred,
86 SmallVectorImpl<MachineBasicBlock*> *DuplicatedPreds = nullptr,
87 function_ref<void(MachineBasicBlock *)> *RemovalCallback = nullptr);
93 MachineBasicBlock *BB);
94 void processPHI(MachineInstr *MI, MachineBasicBlock *TailBB,
95 MachineBasicBlock *PredBB,
99 void duplicateInstruction(MachineInstr *MI, MachineBasicBlock *TailBB,
100 MachineBasicBlock *PredBB,
103 void updateSuccessorsPHIs(MachineBasicBlock *FromBB, bool isDead,
104 SmallVectorImpl<MachineBasicBlock *> &TDBBs,
105 SmallSetVector<MachineBasicBlock *, 8> &Succs);
106 bool canCompletelyDuplicateBB(MachineBasicBlock &BB);
107 bool duplicateSimpleBB(MachineBasicBlock *TailBB,
108 SmallVectorImpl<MachineBasicBlock *> &TDBBs,
112 MachineBasicBlock *TailBB,
113 MachineBasicBlock *ForcedLayoutPred,
114 SmallVectorImpl<MachineBasicBlock *> &TDBBs,
116 void appendCopies(MachineBasicBlock *MBB,
121 MachineBasicBlock *MBB,
122 function_ref<void(MachineBasicBlock *)> *RemovalCallback = nullptr);
include/llvm/CodeGen/TargetFrameLowering.h 177 MachineBasicBlock &MBB) const = 0;
179 MachineBasicBlock &MBB) const = 0;
183 MachineBasicBlock &PrologueMBB) const {}
188 MachineBasicBlock &PrologueMBB) const {}
193 MachineBasicBlock &PrologueMBB) const {}
199 virtual bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
200 MachineBasicBlock::iterator MI,
212 virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
213 MachineBasicBlock::iterator MI,
322 virtual MachineBasicBlock::iterator
350 virtual bool canUseAsPrologue(const MachineBasicBlock &MBB) const {
362 virtual bool canUseAsEpilogue(const MachineBasicBlock &MBB) const {
include/llvm/CodeGen/TargetInstrInfo.h 352 virtual void reMaterialize(MachineBasicBlock &MBB,
353 MachineBasicBlock::iterator MI, unsigned DestReg,
362 virtual MachineInstr &duplicate(MachineBasicBlock &MBB,
363 MachineBasicBlock::iterator InsertBefore,
536 virtual MachineBasicBlock *getBranchDestBlock(const MachineInstr &MI) const {
545 virtual unsigned insertIndirectBranch(MachineBasicBlock &MBB,
546 MachineBasicBlock &NewDestBB,
580 virtual bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
580 virtual bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
581 MachineBasicBlock *&FBB,
603 MachineBasicBlock *TrueDest = nullptr;
604 MachineBasicBlock *FalseDest = nullptr;
622 virtual bool analyzeBranchPredicate(MachineBasicBlock &MBB,
633 virtual unsigned removeBranch(MachineBasicBlock &MBB,
651 virtual unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
651 virtual unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
652 MachineBasicBlock *FBB,
659 unsigned insertUnconditionalBranch(MachineBasicBlock &MBB,
660 MachineBasicBlock *DestBB,
686 createTripCountGreaterCondition(int TC, MachineBasicBlock &MBB,
694 virtual void setPreheader(MachineBasicBlock *NewPreheader) = 0;
707 analyzeLoopForPipelining(MachineBasicBlock *LoopBB) const {
723 virtual unsigned reduceLoopCount(MachineBasicBlock &MBB,
724 MachineBasicBlock &PreHeader,
734 virtual void ReplaceTailWithBranchTo(MachineBasicBlock::iterator Tail,
740 virtual bool isLegalToSplitMBBAt(MachineBasicBlock &MBB,
741 MachineBasicBlock::iterator MBBI) const {
750 virtual bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
762 virtual bool isProfitableToIfCvt(MachineBasicBlock &TMBB, unsigned NumTCycles,
764 MachineBasicBlock &FMBB, unsigned NumFCycles,
776 virtual bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB,
806 virtual bool isProfitableToUnpredicate(MachineBasicBlock &TMBB,
807 MachineBasicBlock &FMBB) const {
828 virtual bool canInsertSelect(const MachineBasicBlock &MBB,
850 virtual void insertSelect(MachineBasicBlock &MBB,
851 MachineBasicBlock::iterator I, const DebugLoc &DL,
913 virtual void copyPhysReg(MachineBasicBlock &MBB,
914 MachineBasicBlock::iterator MI, const DebugLoc &DL,
951 virtual void storeRegToStackSlot(MachineBasicBlock &MBB,
952 MachineBasicBlock::iterator MI,
963 virtual void loadRegFromStackSlot(MachineBasicBlock &MBB,
964 MachineBasicBlock::iterator MI,
1043 const MachineBasicBlock *MBB) const;
1094 MachineBasicBlock::iterator InsertPt, int FrameIndex,
1107 MachineBasicBlock::iterator InsertPt, MachineInstr &LoadMI,
1257 virtual void insertNoop(MachineBasicBlock &MBB,
1258 MachineBasicBlock::iterator MI) const;
1285 virtual void replaceBranchWithTailCall(MachineBasicBlock &MBB,
1327 const MachineBasicBlock *MBB,
1704 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsPt,
1704 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsPt,
1713 virtual MachineInstr *createPHISourceCopy(MachineBasicBlock &MBB,
1714 MachineBasicBlock::iterator InsPt,
1732 getOutliningType(MachineBasicBlock::iterator &MIT, unsigned Flags) const {
1739 virtual bool isMBBSafeToOutlineFrom(MachineBasicBlock &MBB,
1745 virtual void buildOutlinedFrame(MachineBasicBlock &MBB, MachineFunction &MF,
1754 virtual MachineBasicBlock::iterator
include/llvm/CodeGen/TargetLowering.h 2924 MachineBasicBlock *emitPatchPoint(MachineInstr &MI,
2925 MachineBasicBlock *MBB) const;
2929 MachineBasicBlock *emitXRayCustomEvent(MachineInstr &MI,
2930 MachineBasicBlock *MBB) const;
2934 MachineBasicBlock *emitXRayTypedEvent(MachineInstr &MI,
2935 MachineBasicBlock *MBB) const;
3001 const MachineBasicBlock * /*MBB*/, unsigned /*uid*/,
3388 virtual void initializeSplitCSR(MachineBasicBlock *Entry) const {
3397 MachineBasicBlock *Entry,
3398 const SmallVectorImpl<MachineBasicBlock *> &Exits) const {
4203 virtual MachineBasicBlock *
4204 EmitInstrWithCustomInserter(MachineInstr &MI, MachineBasicBlock *MBB) const;
include/llvm/CodeGen/TargetRegisterInfo.h 887 virtual void materializeFrameBaseRegister(MachineBasicBlock *MBB,
912 virtual bool saveScavengerRegister(MachineBasicBlock &MBB,
913 MachineBasicBlock::iterator I,
914 MachineBasicBlock::iterator &UseMI,
927 virtual void eliminateFrameIndex(MachineBasicBlock::iterator MI,
include/llvm/CodeGen/WasmEHFuncInfo.h 25 using BBOrMBB = PointerUnion<const BasicBlock *, MachineBasicBlock *>;
43 MachineBasicBlock *getEHPadUnwindDest(MachineBasicBlock *MBB) const {
43 MachineBasicBlock *getEHPadUnwindDest(MachineBasicBlock *MBB) const {
44 return EHPadUnwindMap.lookup(MBB).get<MachineBasicBlock *>();
46 void setEHPadUnwindDest(MachineBasicBlock *MBB, MachineBasicBlock *Dest) {
46 void setEHPadUnwindDest(MachineBasicBlock *MBB, MachineBasicBlock *Dest) {
49 bool hasEHPadUnwindDest(MachineBasicBlock *MBB) const {
include/llvm/CodeGen/WinEHFuncInfo.h 38 using MBBOrBasicBlock = PointerUnion<const BasicBlock *, MachineBasicBlock *>;
include/llvm/Support/GenericDomTree.h 61 NodeT *TheBB;
69 DomTreeNodeBase(NodeT *BB, DomTreeNodeBase *iDom)
81 NodeT *getBlock() const { return TheBB; }
103 SmallPtrSet<const NodeT *, 4> OtherChildren;
105 const NodeT *Nd = I->getBlock();
110 const NodeT *N = I->getBlock();
167 raw_ostream &operator<<(raw_ostream &O, const DomTreeNodeBase<NodeT> *Node) {
180 void PrintDomTree(const DomTreeNodeBase<NodeT> *N, raw_ostream &O,
183 for (typename DomTreeNodeBase<NodeT>::const_iterator I = N->begin(),
186 PrintDomTree<NodeT>(*I, O, Lev + 1);
221 static_assert(std::is_pointer<typename GraphTraits<NodeT *>::NodeRef>::value,
223 using NodeType = NodeT;
224 using NodePtr = NodeT *;
225 using ParentPtr = decltype(std::declval<NodeT *>()->getParent());
240 SmallVector<NodeT *, IsPostDom ? 4 : 1> Roots;
243 DenseMap<NodeT *, std::unique_ptr<DomTreeNodeBase<NodeT>>>;
243 DenseMap<NodeT *, std::unique_ptr<DomTreeNodeBase<NodeT>>>;
245 DomTreeNodeBase<NodeT> *RootNode = nullptr;
284 const SmallVectorImpl<NodeT *> &getRoots() const { return Roots; }
306 NodeT *BB = DomTreeNode.first;
312 DomTreeNodeBase<NodeT> &MyNd = *DomTreeNode.second;
313 DomTreeNodeBase<NodeT> &OtherNd = *OI->second;
328 DomTreeNodeBase<NodeT> *getNode(const NodeT *BB) const {
328 DomTreeNodeBase<NodeT> *getNode(const NodeT *BB) const {
336 DomTreeNodeBase<NodeT> *operator[](const NodeT *BB) const {
336 DomTreeNodeBase<NodeT> *operator[](const NodeT *BB) const {
347 DomTreeNodeBase<NodeT> *getRootNode() { return RootNode; }
348 const DomTreeNodeBase<NodeT> *getRootNode() const { return RootNode; }
351 void getDescendants(NodeT *R, SmallVectorImpl<NodeT *> &Result) const {
351 void getDescendants(NodeT *R, SmallVectorImpl<NodeT *> &Result) const {
353 const DomTreeNodeBase<NodeT> *RN = getNode(R);
356 SmallVector<const DomTreeNodeBase<NodeT> *, 8> WL;
360 const DomTreeNodeBase<NodeT> *N = WL.pop_back_val();
369 bool properlyDominates(const DomTreeNodeBase<NodeT> *A,
370 const DomTreeNodeBase<NodeT> *B) const {
378 bool properlyDominates(const NodeT *A, const NodeT *B) const;
378 bool properlyDominates(const NodeT *A, const NodeT *B) const;
382 bool isReachableFromEntry(const NodeT *A) const {
388 bool isReachableFromEntry(const DomTreeNodeBase<NodeT> *A) const { return A; }
393 bool dominates(const DomTreeNodeBase<NodeT> *A,
394 const DomTreeNodeBase<NodeT> *B) const {
436 bool dominates(const NodeT *A, const NodeT *B) const;
436 bool dominates(const NodeT *A, const NodeT *B) const;
438 NodeT *getRoot() const {
445 NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) const {
445 NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) const {
445 NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) const {
453 NodeT &Entry = A->getParent()->front();
458 DomTreeNodeBase<NodeT> *NodeA = getNode(A);
459 DomTreeNodeBase<NodeT> *NodeB = getNode(B);
474 const NodeT *findNearestCommonDominator(const NodeT *A,
474 const NodeT *findNearestCommonDominator(const NodeT *A,
475 const NodeT *B) const {
482 bool isVirtualRoot(const DomTreeNodeBase<NodeT> *A) const {
533 void insertEdge(NodeT *From, NodeT *To) {
533 void insertEdge(NodeT *From, NodeT *To) {
551 void deleteEdge(NodeT *From, NodeT *To) {
551 void deleteEdge(NodeT *From, NodeT *To) {
568 DomTreeNodeBase<NodeT> *addNewBlock(NodeT *BB, NodeT *DomBB) {
568 DomTreeNodeBase<NodeT> *addNewBlock(NodeT *BB, NodeT *DomBB) {
568 DomTreeNodeBase<NodeT> *addNewBlock(NodeT *BB, NodeT *DomBB) {
570 DomTreeNodeBase<NodeT> *IDomNode = getNode(DomBB);
574 std::make_unique<DomTreeNodeBase<NodeT>>(BB, IDomNode))).get();
582 DomTreeNodeBase<NodeT> *setNewRoot(NodeT *BB) {
582 DomTreeNodeBase<NodeT> *setNewRoot(NodeT *BB) {
587 DomTreeNodeBase<NodeT> *NewNode = (DomTreeNodes[BB] =
588 std::make_unique<DomTreeNodeBase<NodeT>>(BB, nullptr)).get();
593 NodeT *OldRoot = Roots.front();
606 void changeImmediateDominator(DomTreeNodeBase<NodeT> *N,
607 DomTreeNodeBase<NodeT> *NewIDom) {
613 void changeImmediateDominator(NodeT *BB, NodeT *NewBB) {
613 void changeImmediateDominator(NodeT *BB, NodeT *NewBB) {
620 void eraseNode(NodeT *BB) {
621 DomTreeNodeBase<NodeT> *Node = getNode(BB);
628 DomTreeNodeBase<NodeT> *IDom = Node->getIDom();
651 void splitBlock(NodeT *NewBB) {
653 Split<Inverse<NodeT *>>(NewBB);
655 Split<NodeT *>(NewBB);
671 if (getRootNode()) PrintDomTree<NodeT>(getRootNode(), O, 1);
689 SmallVector<std::pair<const DomTreeNodeBase<NodeT> *,
690 typename DomTreeNodeBase<NodeT>::const_iterator>,
693 const DomTreeNodeBase<NodeT> *ThisRoot = getRootNode();
706 const DomTreeNodeBase<NodeT> *Node = WorkStack.back().first;
716 const DomTreeNodeBase<NodeT> *Child = *ChildIt;
758 void addRoot(NodeT *BB) { this->Roots.push_back(BB); }
797 NodeT *NewBBIDom = nullptr;
816 DomTreeNodeBase<NodeT> *NewBBNode = addNewBlock(NewBB, NewBBIDom);
821 DomTreeNodeBase<NodeT> *NewBBSuccNode = getNode(NewBBSucc);
827 bool dominatedBySlowTreeWalk(const DomTreeNodeBase<NodeT> *A,
828 const DomTreeNodeBase<NodeT> *B) const {
834 const DomTreeNodeBase<NodeT> *IDom;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Support/Recycler.h 83 SubClass *Allocate(AllocatorType &Allocator) {
84 static_assert(alignof(SubClass) <= Align,
86 static_assert(sizeof(SubClass) <= Size,
93 T *Allocate(AllocatorType &Allocator) {
93 T *Allocate(AllocatorType &Allocator) {
98 void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
include/llvm/Transforms/Utils/SizeOpts.h 55 bool shouldOptimizeForSizeImpl(const BlockT *BB, ProfileSummaryInfo *PSI,
lib/CodeGen/AggressiveAntiDepBreaker.cpp 60 MachineBasicBlock *BB)
152 void AggressiveAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
161 for (MachineBasicBlock::succ_iterator SI = BB->succ_begin(),
755 MachineBasicBlock::iterator Begin,
814 for (MachineBasicBlock::iterator I = End, E = Begin;
lib/CodeGen/AggressiveAntiDepBreaker.h 80 AggressiveAntiDepState(const unsigned TargetRegs, MachineBasicBlock *BB);
138 void StartBlock(MachineBasicBlock *BB) override;
143 MachineBasicBlock::iterator Begin,
lib/CodeGen/Analysis.cpp 698 DenseMap<const MachineBasicBlock *, int> &EHScopeMembership, int EHScope,
699 const MachineBasicBlock *MBB) {
700 SmallVector<const MachineBasicBlock *, 16> Worklist = {MBB};
702 const MachineBasicBlock *Visiting = Worklist.pop_back_val();
721 for (const MachineBasicBlock *Succ : Visiting->successors())
726 DenseMap<const MachineBasicBlock *, int>
728 DenseMap<const MachineBasicBlock *, int> EHScopeMembership;
739 SmallVector<const MachineBasicBlock *, 16> EHScopeBlocks;
740 SmallVector<const MachineBasicBlock *, 16> UnreachableBlocks;
741 SmallVector<const MachineBasicBlock *, 16> SEHCatchPads;
742 SmallVector<std::pair<const MachineBasicBlock *, int>, 16> CatchRetSuccessors;
743 for (const MachineBasicBlock &MBB : MF) {
752 MachineBasicBlock::const_iterator MBBI = MBB.getFirstTerminator();
761 const MachineBasicBlock *Successor = MBBI->getOperand(0).getMBB();
762 const MachineBasicBlock *SuccessorColor = MBBI->getOperand(1).getMBB();
774 for (const MachineBasicBlock *MBB : UnreachableBlocks)
777 for (const MachineBasicBlock *MBB : EHScopeBlocks)
780 for (const MachineBasicBlock *MBB : SEHCatchPads)
783 for (std::pair<const MachineBasicBlock *, int> CatchRetPair :
lib/CodeGen/AntiDepBreaker.h 39 virtual void StartBlock(MachineBasicBlock *BB) = 0;
44 MachineBasicBlock::iterator Begin,
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 1052 for (auto &MBB : *MF) {
1816 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
1825 SmallPtrSet<const MachineBasicBlock*, 16> EmittedSets;
1829 const MachineBasicBlock *MBB = JTBBs[ii];
1863 const MachineBasicBlock *MBB,
2867 static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB,
2874 MachineBasicBlock *Header = Loop->getHeader();
2904 void AsmPrinter::setupCodePaddingContext(const MachineBasicBlock &MBB,
2920 void AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
2983 void AsmPrinter::EmitBasicBlockEnd(const MachineBasicBlock &MBB) {
3014 isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const {
3025 MachineBasicBlock *Pred = *MBB->pred_begin();
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 1407 for (const auto &MBB : *MF) {
1426 for (const auto &MBB : *MF) {
2858 for (const auto &MBB : *MF) {
lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp 240 for (const auto &MBB : *MF) {
lib/CodeGen/AsmPrinter/DwarfCFIException.cpp 128 void DwarfCFIException::beginFragment(const MachineBasicBlock *MBB,
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 708 for (const MachineBasicBlock &MBB : MF) {
1317 MachineBasicBlock::const_reverse_iterator Pred(DbgValue);
1729 for (const auto &MBB : *MF)
lib/CodeGen/AsmPrinter/DwarfException.h 67 void beginFragment(const MachineBasicBlock *MBB,
lib/CodeGen/AsmPrinter/EHStreamer.cpp 243 for (const auto &MBB : *Asm->MF) {
lib/CodeGen/AsmPrinter/WasmException.cpp 84 MachineBasicBlock *LPad = Info->LandingPadBlock;
lib/CodeGen/AsmPrinter/WinException.cpp 170 const MachineBasicBlock *MBB) {
188 void WinException::beginFunclet(const MachineBasicBlock &MBB,
443 MachineBasicBlock::const_iterator MBBI;
631 auto *Handler = UME.Handler.get<MachineBasicBlock *>();
631 auto *Handler = UME.Handler.get<MachineBasicBlock *>();
759 getMCSymbolForMBB(Asm, UME.Cleanup.dyn_cast<MachineBasicBlock *>());
847 getMCSymbolForMBB(Asm, HT.Handler.dyn_cast<MachineBasicBlock *>());
1043 auto *Handler = UME.Handler.get<MachineBasicBlock *>();
1043 auto *Handler = UME.Handler.get<MachineBasicBlock *>();
1111 DenseMap<const MachineBasicBlock *, int> HandlerStates;
1113 MachineBasicBlock *HandlerBlock =
1114 FuncInfo.ClrEHUnwindMap[State].Handler.get<MachineBasicBlock *>();
1275 MachineBasicBlock *HandlerBlock = Entry.Handler.get<MachineBasicBlock *>();
1275 MachineBasicBlock *HandlerBlock = Entry.Handler.get<MachineBasicBlock *>();
lib/CodeGen/AsmPrinter/WinException.h 44 const MachineBasicBlock *CurrentFuncletEntry = nullptr;
109 void beginFunclet(const MachineBasicBlock &MBB, MCSymbol *Sym) override;
lib/CodeGen/BranchFolding.cpp 153 void BranchFolder::RemoveDeadBlock(MachineBasicBlock *MBB) {
200 for (MachineBasicBlock &MBB : MF) {
201 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
230 for (const MachineBasicBlock &BB : MF) {
296 static unsigned HashEndOfMBB(const MachineBasicBlock &MBB) {
297 MachineBasicBlock::const_iterator I = MBB.getLastNonDebugInstr();
312 static unsigned ComputeCommonTailLength(MachineBasicBlock *MBB1,
313 MachineBasicBlock *MBB2,
314 MachineBasicBlock::iterator &I1,
416 void BranchFolder::replaceTailWithBranchTo(MachineBasicBlock::iterator OldInst,
420 MachineBasicBlock &OldMBB = *OldInst->getParent();
424 MachineBasicBlock::iterator I = OldMBB.end();
433 for (MachineBasicBlock::RegisterMaskPair P : NewDest.liveins()) {
450 MachineBasicBlock *BranchFolder::SplitMBBAt(MachineBasicBlock &CurMBB,
450 MachineBasicBlock *BranchFolder::SplitMBBAt(MachineBasicBlock &CurMBB,
451 MachineBasicBlock::iterator BBI1,
460 MachineBasicBlock *NewMBB = MF.CreateMachineBasicBlock(BB);
495 static unsigned EstimateRuntime(MachineBasicBlock::iterator I,
515 static void FixTail(MachineBasicBlock *CurMBB, MachineBasicBlock *SuccBB,
515 static void FixTail(MachineBasicBlock *CurMBB, MachineBasicBlock *SuccBB,
519 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
523 MachineBasicBlock *NextBB = &*I;
556 BranchFolder::MBFIWrapper::getBlockFreq(const MachineBasicBlock *MBB) const {
565 void BranchFolder::MBFIWrapper::setBlockFreq(const MachineBasicBlock *MBB,
572 const MachineBasicBlock *MBB) const {
594 static unsigned CountTerminators(MachineBasicBlock *MBB,
595 MachineBasicBlock::iterator &I) {
613 static bool blockEndsInUnreachable(const MachineBasicBlock *MBB) {
638 ProfitableToMerge(MachineBasicBlock *MBB1, MachineBasicBlock *MBB2,
638 ProfitableToMerge(MachineBasicBlock *MBB1, MachineBasicBlock *MBB2,
640 MachineBasicBlock::iterator &I1,
669 MachineBasicBlock::iterator I;
736 MachineBasicBlock *SuccBB,
737 MachineBasicBlock *PredBB) {
740 MachineBasicBlock::iterator TrialBBI1, TrialBBI2;
771 MachineBasicBlock *SuccBB,
772 MachineBasicBlock *PredBB) {
778 MachineBasicBlock *CurMBB = CurMPIter->getBlock();
789 bool BranchFolder::CreateCommonTailOnlyBlock(MachineBasicBlock *&PredBB,
790 MachineBasicBlock *SuccBB,
811 MachineBasicBlock::iterator BBI =
813 MachineBasicBlock *MBB = SameTails[commonTailIndex].getBlock();
823 MachineBasicBlock *newMBB = SplitMBBAt(*MBB, BBI, BB);
840 mergeOperations(MachineBasicBlock::iterator MBBIStartPos,
842 MachineBasicBlock *MBB = MBBIStartPos->getParent();
850 MachineBasicBlock::reverse_iterator MBBI = MBB->rbegin();
851 MachineBasicBlock::reverse_iterator MBBIE = MBB->rend();
852 MachineBasicBlock::reverse_iterator MBBICommon = MBBCommon.rbegin();
853 MachineBasicBlock::reverse_iterator MBBIECommon = MBBCommon.rend();
890 MachineBasicBlock *MBB = SameTails[commonTailIndex].getBlock();
892 std::vector<MachineBasicBlock::iterator> NextCommonInsts(SameTails.size());
933 for (MachineBasicBlock *Pred : MBB->predecessors()) {
936 MachineBasicBlock::iterator InsertBefore = Pred->getFirstTerminator();
960 bool BranchFolder::TryTailMergeBlocks(MachineBasicBlock *SuccBB,
961 MachineBasicBlock *PredBB,
1004 MachineBasicBlock *EntryBB =
1022 MachineBasicBlock *MBB = SameTails[i].getBlock();
1046 MachineBasicBlock *MBB = SameTails[commonTailIndex].getBlock();
1085 for (MachineBasicBlock &MBB : MF) {
1124 SmallPtrSet<MachineBasicBlock *, 8> UniquePreds;
1125 MachineBasicBlock *IBB = &*I;
1126 MachineBasicBlock *PredBB = &*std::prev(I);
1146 for (MachineBasicBlock *PBB : I->predecessors()) {
1172 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1223 void BranchFolder::setCommonTailEdgeWeights(MachineBasicBlock &TailMBB) {
1231 const MachineBasicBlock *SrcMBB = Src.getBlock();
1281 MachineBasicBlock *MBB = &*I++;
1297 static bool IsEmptyBlock(MachineBasicBlock *MBB) {
1303 static bool IsBranchOnlyBlock(MachineBasicBlock *MBB) {
1304 MachineBasicBlock::iterator I = MBB->getFirstNonDebugInstr();
1313 static bool IsBetterFallthrough(MachineBasicBlock *MBB1,
1314 MachineBasicBlock *MBB2) {
1321 MachineBasicBlock::iterator MBB1I = MBB1->getLastNonDebugInstr();
1322 MachineBasicBlock::iterator MBB2I = MBB2->getLastNonDebugInstr();
1336 static DebugLoc getBranchDebugLoc(MachineBasicBlock &MBB) {
1337 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
1344 MachineBasicBlock &MBB,
1345 MachineBasicBlock &PredMBB) {
1356 MachineBasicBlock &MBB,
1357 MachineBasicBlock &SuccMBB) {
1375 MachineBasicBlock &MBB) {
1379 for (MachineBasicBlock *SuccBB : MBB.successors())
1385 for (MachineBasicBlock *PredBB : MBB.predecessors())
1390 bool BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
1429 MachineBasicBlock *Pred = *(MBB->pred_end()-1);
1443 MachineBasicBlock &PrevBB = *std::prev(MachineFunction::iterator(MBB));
1445 MachineBasicBlock *PriorTBB = nullptr, *PriorFBB = nullptr;
1482 MachineBasicBlock::iterator PrevBBIter = PrevBB.end();
1484 MachineBasicBlock::iterator MBBIter = MBB->begin();
1589 MachineBasicBlock *Pred = *MBB->pred_begin();
1590 MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
1620 MachineBasicBlock *CurTBB = nullptr, *CurFBB = nullptr;
1694 MachineBasicBlock *PMBB = *(MBB->pred_begin() + PI);
1705 MachineBasicBlock *NewCurTBB = nullptr, *NewCurFBB = nullptr;
1748 for (MachineBasicBlock *PredBB : MBB->predecessors()) {
1750 MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
1767 MachineBasicBlock *NextBB = &*std::next(MBB->getIterator());
1780 for (MachineBasicBlock *SuccBB : MBB->successors()) {
1811 MachineBasicBlock *PrevTBB = nullptr, *PrevFBB = nullptr;
1834 MachineBasicBlock *MBB = &*I++;
1843 static MachineBasicBlock *findFalseBlock(MachineBasicBlock *BB,
1843 static MachineBasicBlock *findFalseBlock(MachineBasicBlock *BB,
1844 MachineBasicBlock *TrueBB) {
1845 for (MachineBasicBlock *SuccBB : BB->successors())
1870 MachineBasicBlock::iterator findHoistingInsertPosAndDeps(MachineBasicBlock *MBB,
1875 MachineBasicBlock::iterator Loc = MBB->getFirstTerminator();
1910 MachineBasicBlock::iterator PI =
1967 bool BranchFolder::HoistCommonCodeInSuccs(MachineBasicBlock *MBB) {
1968 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1987 MachineBasicBlock::iterator Loc =
1994 MachineBasicBlock::iterator TIB = TBB->begin();
1995 MachineBasicBlock::iterator FIB = FBB->begin();
1996 MachineBasicBlock::iterator TIE = TBB->end();
1997 MachineBasicBlock::iterator FIE = FBB->end();
lib/CodeGen/BranchFolding.h 57 MachineBasicBlock *Block;
60 MergePotentialsElt(unsigned h, MachineBasicBlock *b)
64 MachineBasicBlock *getBlock() const { return Block; }
66 void setBlock(MachineBasicBlock *MBB) {
76 SmallPtrSet<const MachineBasicBlock*, 2> TriedMerging;
77 DenseMap<const MachineBasicBlock *, int> EHScopeMembership;
81 MachineBasicBlock::iterator TailStartPos;
84 SameTailElt(MPIterator mp, MachineBasicBlock::iterator tsp)
95 MachineBasicBlock::iterator getTailStartPos() const {
103 MachineBasicBlock *getBlock() const {
111 void setBlock(MachineBasicBlock *MBB) {
115 void setTailStartPos(MachineBasicBlock::iterator Pos) {
140 BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const;
141 void setBlockFreq(const MachineBasicBlock *MBB, BlockFrequency F);
143 const MachineBasicBlock *MBB) const;
151 DenseMap<const MachineBasicBlock *, BlockFrequency> MergedBBFreq;
159 bool TryTailMergeBlocks(MachineBasicBlock* SuccBB,
160 MachineBasicBlock* PredBB,
162 void setCommonTailEdgeWeights(MachineBasicBlock &TailMBB);
166 void replaceTailWithBranchTo(MachineBasicBlock::iterator OldInst,
172 MachineBasicBlock *SplitMBBAt(MachineBasicBlock &CurMBB,
172 MachineBasicBlock *SplitMBBAt(MachineBasicBlock &CurMBB,
173 MachineBasicBlock::iterator BBI1,
186 MachineBasicBlock *SuccBB,
187 MachineBasicBlock *PredBB);
191 void RemoveBlocksWithHash(unsigned CurHash, MachineBasicBlock* SuccBB,
192 MachineBasicBlock* PredBB);
196 bool CreateCommonTailOnlyBlock(MachineBasicBlock *&PredBB,
197 MachineBasicBlock *SuccBB,
209 bool OptimizeBlock(MachineBasicBlock *MBB);
213 void RemoveDeadBlock(MachineBasicBlock *MBB);
221 bool HoistCommonCodeInSuccs(MachineBasicBlock *MBB);
lib/CodeGen/BranchRelaxation.cpp 66 unsigned postOffset(const MachineBasicBlock &MBB) const {
93 MachineBasicBlock *createNewBlockAfter(MachineBasicBlock &BB);
93 MachineBasicBlock *createNewBlockAfter(MachineBasicBlock &BB);
95 MachineBasicBlock *splitBlockBeforeInstr(MachineInstr &MI,
96 MachineBasicBlock *DestBB);
97 void adjustBlockOffsets(MachineBasicBlock &Start);
98 bool isBlockInRange(const MachineInstr &MI, const MachineBasicBlock &BB) const;
102 uint64_t computeBlockSize(const MachineBasicBlock &MBB) const;
129 for (MachineBasicBlock &MBB : *MF) {
142 for (auto &MBB : *MF) {
160 for (MachineBasicBlock &MBB : *MF)
168 uint64_t BranchRelaxation::computeBlockSize(const MachineBasicBlock &MBB) const {
179 const MachineBasicBlock *MBB = MI.getParent();
187 for (MachineBasicBlock::const_iterator I = MBB->begin(); &*I != &MI; ++I) {
195 void BranchRelaxation::adjustBlockOffsets(MachineBasicBlock &Start) {
197 for (auto &MBB : make_range(MachineFunction::iterator(Start), MF->end())) {
210 MachineBasicBlock *BranchRelaxation::createNewBlockAfter(MachineBasicBlock &BB) {
210 MachineBasicBlock *BranchRelaxation::createNewBlockAfter(MachineBasicBlock &BB) {
212 MachineBasicBlock *NewBB =
225 MachineBasicBlock *BranchRelaxation::splitBlockBeforeInstr(MachineInstr &MI,
226 MachineBasicBlock *DestBB) {
227 MachineBasicBlock *OrigBB = MI.getParent();
230 MachineBasicBlock *NewBB =
281 const MachineInstr &MI, const MachineBasicBlock &DestBB) const {
302 MachineBasicBlock *MBB = MI.getParent();
303 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
304 MachineBasicBlock *NewBB = nullptr;
384 MachineBasicBlock &NextBB = *std::next(MachineFunction::iterator(MBB));
439 MachineBasicBlock *MBB = MI.getParent();
442 MachineBasicBlock *DestBB = TII->getBranchDestBlock(MI);
451 MachineBasicBlock *BranchBB = MBB;
459 for (const MachineBasicBlock *Succ : MBB->successors()) {
460 for (const MachineBasicBlock::RegisterMaskPair &LiveIn : Succ->liveins())
484 MachineBasicBlock &MBB = *I;
487 MachineBasicBlock::iterator Last = MBB.getLastNonDebugInstr();
499 if (MachineBasicBlock *DestBB = TII->getBranchDestBlock(*Last)) {
509 MachineBasicBlock::iterator Next;
510 for (MachineBasicBlock::iterator J = MBB.getFirstTerminator();
516 MachineBasicBlock *DestBB = TII->getBranchDestBlock(MI);
lib/CodeGen/BreakFalseDeps.cpp 70 void processBasicBlock(MachineBasicBlock *MBB);
93 void processUndefReads(MachineBasicBlock *);
214 void BreakFalseDeps::processUndefReads(MachineBasicBlock *MBB) {
250 void BreakFalseDeps::processBasicBlock(MachineBasicBlock *MBB) {
276 for (MachineBasicBlock &MBB : mf) {
lib/CodeGen/CFGuardLongjmp.cpp 74 for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/CFIInstrInserter.cpp 70 MachineBasicBlock *MBB;
107 int getCorrectCFAOffset(MachineBasicBlock *MBB) {
137 for (MachineBasicBlock &MBB : MF) {
151 for (MachineBasicBlock &MBB : MF) {
224 SmallVector<MachineBasicBlock *, 4> Stack;
228 MachineBasicBlock *Current = Stack.pop_back_val();
234 for (auto *Succ : CurrentInfo.MBB->successors()) {
250 for (MachineBasicBlock &MBB : MF) {
312 for (auto *CurrMBB : depth_first(&MF)) {
314 for (MachineBasicBlock *Succ : CurrMBB->successors()) {
lib/CodeGen/CalcSpillWeights.cpp 155 MachineBasicBlock *mbb = nullptr;
173 MachineBasicBlock *localMBB = LIS.getMBBFromIndex(*end);
lib/CodeGen/CriticalAntiDepBreaker.cpp 54 void CriticalAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
71 for (MachineBasicBlock::succ_iterator SI = BB->succ_begin(),
438 MachineBasicBlock::iterator Begin,
528 for (MachineBasicBlock::iterator I = End, E = Begin; I != E; --Count) {
lib/CodeGen/CriticalAntiDepBreaker.h 78 void StartBlock(MachineBasicBlock *BB) override;
83 MachineBasicBlock::iterator Begin,
lib/CodeGen/DFAPacketizer.cpp 208 void VLIWPacketizerList::endPacket(MachineBasicBlock *MBB,
209 MachineBasicBlock::iterator MI) {
230 void VLIWPacketizerList::PacketizeMIs(MachineBasicBlock *MBB,
231 MachineBasicBlock::iterator BeginItr,
lib/CodeGen/DeadMachineInstructionElim.cpp 109 for (MachineBasicBlock &MBB : make_range(MF.rbegin(), MF.rend())) {
116 for (MachineBasicBlock::succ_iterator S = MBB.succ_begin(),
123 for (MachineBasicBlock::reverse_iterator MII = MBB.rbegin(),
lib/CodeGen/DetectDeadLanes.cpp 534 for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/EarlyIfConversion.cpp 88 MachineBasicBlock *Head;
91 MachineBasicBlock *Tail;
94 MachineBasicBlock *TBB;
97 MachineBasicBlock *FBB;
104 MachineBasicBlock *getTPred() const { return TBB == Tail ? Head : TBB; }
107 MachineBasicBlock *getFPred() const { return FBB == Tail ? Head : FBB; }
138 MachineBasicBlock::iterator InsertionPoint;
142 bool canSpeculateInstrs(MachineBasicBlock *MBB);
146 bool canPredicateInstrs(MachineBasicBlock *MBB);
154 void PredicateBlock(MachineBasicBlock *MBB, bool ReversePredicate);
181 bool canConvertIf(MachineBasicBlock *MBB, bool Predicate = false);
185 void convertIf(SmallVectorImpl<MachineBasicBlock *> &RemovedBlocks,
199 bool SSAIfConv::canSpeculateInstrs(MachineBasicBlock *MBB) {
211 for (MachineBasicBlock::iterator I = MBB->begin(),
293 bool SSAIfConv::canPredicateInstrs(MachineBasicBlock *MBB) {
305 for (MachineBasicBlock::iterator I = MBB->begin(),
337 void SSAIfConv::PredicateBlock(MachineBasicBlock *MBB, bool ReversePredicate) {
342 for (MachineBasicBlock::iterator I = MBB->begin(),
366 MachineBasicBlock::iterator FirstTerm = Head->getFirstTerminator();
367 MachineBasicBlock::iterator I = Head->end();
368 MachineBasicBlock::iterator B = Head->begin();
431 bool SSAIfConv::canConvertIf(MachineBasicBlock *MBB, bool Predicate) {
437 MachineBasicBlock *Succ0 = Head->succ_begin()[0];
438 MachineBasicBlock *Succ1 = Head->succ_begin()[1];
505 MachineBasicBlock *TPred = getTPred();
506 MachineBasicBlock *FPred = getFPred();
507 for (MachineBasicBlock::iterator I = Tail->begin(), E = Tail->end();
561 MachineBasicBlock::iterator FirstTerm = Head->getFirstTerminator();
581 MachineBasicBlock::iterator FirstTerm = Head->getFirstTerminator();
605 MachineBasicBlock *MBB = PI.PHI->getOperand(i-1).getMBB();
623 void SSAIfConv::convertIf(SmallVectorImpl<MachineBasicBlock *> &RemovedBlocks,
719 bool tryConvertIf(MachineBasicBlock*);
750 ArrayRef<MachineBasicBlock *> Removed) {
768 ArrayRef<MachineBasicBlock *> Removed) {
818 SmallVector<const MachineBasicBlock*, 1> ExtraBlocks;
884 bool EarlyIfConverter::tryConvertIf(MachineBasicBlock *MBB) {
889 SmallVector<MachineBasicBlock*, 4> RemovedBlocks;
954 bool tryConvertIf(MachineBasicBlock *);
982 MachineBasicBlock &IfBlock =
1020 bool EarlyIfPredicator::tryConvertIf(MachineBasicBlock *MBB) {
1024 SmallVector<MachineBasicBlock *, 4> RemovedBlocks;
lib/CodeGen/EdgeBundles.cpp 44 for (const auto &MBB : *MF) {
47 for (MachineBasicBlock::const_succ_iterator SI = MBB.succ_begin(),
80 for (const auto &MBB : *MF) {
87 for (MachineBasicBlock::const_succ_iterator SI = MBB.succ_begin(),
lib/CodeGen/ExecutionDomainFix.cpp 155 MachineBasicBlock *MBB = TraversedMBB.MBB;
169 for (MachineBasicBlock *pred : MBB->predecessors()) {
lib/CodeGen/ExpandPostRAPseudos.cpp 67 MachineBasicBlock::iterator CopyMI = MI;
76 MachineBasicBlock *MBB = MI->getParent();
123 MachineBasicBlock::iterator CopyMI = MI;
192 for (MachineBasicBlock::iterator mi = mbbi->begin(), me = mbbi->end();
lib/CodeGen/FEntryInserter.cpp 42 auto &FirstMBB = *MF.begin();
lib/CodeGen/FinalizeISel.cpp 53 MachineBasicBlock *MBB = &*I;
54 for (MachineBasicBlock::iterator MBBI = MBB->begin(), MBBE = MBB->end();
61 MachineBasicBlock *NewMBB = TLI->EmitInstrWithCustomInserter(MI, MBB);
lib/CodeGen/FuncletLayout.cpp 46 DenseMap<const MachineBasicBlock *, int> FuncletMembership =
lib/CodeGen/GCRootLowering.cpp 63 void VisitCallPoint(MachineBasicBlock::iterator CI);
64 MCSymbol *InsertLabel(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
64 MCSymbol *InsertLabel(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
256 MCSymbol *GCMachineCodeAnalysis::InsertLabel(MachineBasicBlock &MBB,
257 MachineBasicBlock::iterator MI,
264 void GCMachineCodeAnalysis::VisitCallPoint(MachineBasicBlock::iterator CI) {
267 MachineBasicBlock::iterator RAI = CI;
275 for (MachineBasicBlock &MBB : MF)
276 for (MachineBasicBlock::iterator MI = MBB.begin(), ME = MBB.end();
lib/CodeGen/GlobalISel/CSEInfo.cpp 102 MachineBasicBlock *MBB,
149 MachineBasicBlock *MBB,
232 for (auto &MBB : MF) {
321 GISelInstProfileBuilder::addNodeIDMBB(const MachineBasicBlock *MBB) const {
lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp 19 bool CSEMIRBuilder::dominates(MachineBasicBlock::const_iterator A,
26 const MachineBasicBlock *BBA = A->getParent();
27 MachineBasicBlock::const_iterator I = BBA->begin();
38 MachineBasicBlock *CurMBB = &getMBB();
lib/CodeGen/GlobalISel/Combiner.cpp 132 for (MachineBasicBlock *MBB : post_order(&MF)) {
lib/CodeGen/GlobalISel/CombinerHelper.cpp 322 std::function<void(MachineBasicBlock *, MachineBasicBlock::iterator,
322 std::function<void(MachineBasicBlock *, MachineBasicBlock::iterator,
327 MachineBasicBlock *InsertBB = UseMI.getParent();
338 MachineBasicBlock::iterator InsertPt = &DefMI;
430 DenseMap<MachineBasicBlock *, MachineInstr *> EmittedInsns;
539 MachineBasicBlock::const_iterator I = DefMI.getParent()->begin();
754 MachineBasicBlock *MBB = MI.getParent();
755 MachineBasicBlock::iterator BrIt(MI);
783 MachineBasicBlock *BrTarget = MI.getOperand(0).getMBB();
784 MachineBasicBlock::iterator BrIt(MI);
lib/CodeGen/GlobalISel/IRTranslator.cpp 276 MachineBasicBlock &IRTranslator::getMBB(const BasicBlock &BB) {
277 MachineBasicBlock *&MBB = BBToMBB[&BB];
282 void IRTranslator::addMachineCFGPred(CFGEdge Edge, MachineBasicBlock *NewPred) {
391 MachineBasicBlock &TrueBB = getMBB(TrueTgt);
396 MachineBasicBlock &TgtBB = getMBB(BrTgt);
397 MachineBasicBlock &CurBB = MIRBuilder.getMBB();
409 void IRTranslator::addSuccessorWithProb(MachineBasicBlock *Src,
410 MachineBasicBlock *Dst,
422 IRTranslator::getEdgeProbability(const MachineBasicBlock *Src,
423 const MachineBasicBlock *Dst) const {
443 MachineBasicBlock *Succ = &getMBB(*I.getCaseSuccessor());
452 MachineBasicBlock *DefaultMBB = &getMBB(*SI.getDefaultDest());
459 MachineBasicBlock *SwitchMBB = &getMBB(*SI.getParent());
508 MachineBasicBlock *MBB) {
524 MachineBasicBlock *HeaderBB) {
567 MachineBasicBlock *SwitchBB,
643 MachineBasicBlock *SwitchMBB,
644 MachineBasicBlock *CurMBB,
645 MachineBasicBlock *DefaultMBB,
660 MachineBasicBlock *JumpMBB = JT->MBB;
677 for (MachineBasicBlock::succ_iterator SI = JumpMBB->succ_begin(),
716 MachineBasicBlock *Fallthrough,
719 MachineBasicBlock *CurMBB,
721 MachineBasicBlock *SwitchMBB) {
750 MachineBasicBlock *SwitchMBB,
751 MachineBasicBlock *DefaultMBB,
755 MachineBasicBlock *NextMBB = nullptr;
791 MachineBasicBlock *CurMBB = W.MBB;
794 MachineBasicBlock *Fallthrough;
844 MachineBasicBlock &CurBB = MIRBuilder.getMBB();
1710 MachineBasicBlock &EHPadMBB = getMBB(*EHPadBB),
1730 MachineBasicBlock &MBB = MIRBuilder.getMBB();
2056 MachineBasicBlock *PhiMBB = ComponentPHIs[0]->getParent();
2062 SmallSet<const MachineBasicBlock *, 16> SeenPreds;
2266 MachineBasicBlock *EntryBB = MF->CreateMachineBasicBlock();
2279 auto *&MBB = BBToMBB[&BB];
2330 MachineBasicBlock &MBB = getMBB(*BB);
2382 MachineBasicBlock &NewEntryBB = **EntryBB->succ_begin();
2391 for (const MachineBasicBlock::RegisterMaskPair &LiveIn : EntryBB->liveins())
lib/CodeGen/GlobalISel/InstructionSelect.cpp 103 for (MachineBasicBlock *MBB : post_order(&MF)) {
153 for (MachineBasicBlock &MBB : MF) {
231 for (const auto &MBB : MF) {
lib/CodeGen/GlobalISel/InstructionSelector.cpp 40 MachineBasicBlock &MBB = *I.getParent();
lib/CodeGen/GlobalISel/Legalizer.cpp 164 for (auto *MBB : RPOT) {
lib/CodeGen/GlobalISel/LegalizerHelper.cpp 919 MachineBasicBlock &OpMBB = *MI.getOperand(i + 1).getMBB();
924 MachineBasicBlock &MBB = *MI.getParent();
1763 MachineBasicBlock &OpMBB = *MI.getOperand(I + 1).getMBB();
1768 MachineBasicBlock &MBB = *MI.getParent();
2723 MachineBasicBlock *MBB = MI.getParent();
2735 MachineBasicBlock &OpMBB = *MI.getOperand(I + 1).getMBB();
3247 MachineBasicBlock &OpMBB = *MI.getOperand(I + 1).getMBB();
3252 MachineBasicBlock &MBB = *MI.getParent();
lib/CodeGen/GlobalISel/LegalizerInfo.cpp 740 for (const MachineBasicBlock &MBB : MF)
lib/CodeGen/GlobalISel/Localizer.cpp 99 MachineBasicBlock *&InsertMBB) {
110 DenseMap<std::pair<MachineBasicBlock *, unsigned>, unsigned> MBBWithLocalDef;
116 auto &MBB = MF.front();
132 MachineBasicBlock *InsertMBB;
181 MachineBasicBlock &MBB = *MI->getParent();
193 MachineBasicBlock::iterator II(MI);
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp 36 void MachineIRBuilder::setMBB(MachineBasicBlock &MBB) {
51 void MachineIRBuilder::setInsertPt(MachineBasicBlock &MBB,
52 MachineBasicBlock::iterator II) {
261 MachineInstrBuilder MachineIRBuilder::buildBr(MachineBasicBlock &Dest) {
362 MachineBasicBlock &Dest) {
lib/CodeGen/GlobalISel/RegBankSelect.cpp 680 for (MachineBasicBlock *MBB : RPOT) {
684 for (MachineBasicBlock::iterator MII = MBB->begin(), End = MBB->end();
704 MachineBasicBlock *NextInstBB = MII->getParent();
750 MachineBasicBlock::iterator It = MI.getParent()->getFirstNonPHI();
758 MachineBasicBlock &Pred = *MI.getOperand(OpIdx + 1).getMBB();
762 MachineBasicBlock::iterator It = Pred.getLastNonDebugInstr();
785 MachineBasicBlock::reverse_iterator It = MI;
804 for (MachineBasicBlock::iterator It = MI, End = MI.getParent()->end();
810 MachineBasicBlock &Src = *MI.getParent();
821 void RegBankSelect::RepairingPlacement::addInsertPoint(MachineBasicBlock &MBB,
826 void RegBankSelect::RepairingPlacement::addInsertPoint(MachineBasicBlock &Src,
827 MachineBasicBlock &Dst) {
905 MachineBasicBlock *NewBB = Src.SplitCriticalEdge(DstOrSplit, P);
lib/CodeGen/GlobalISel/Utils.cpp 54 MachineBasicBlock::iterator InsertIt(&InsertPt);
55 MachineBasicBlock &MBB = *InsertPt.getParent();
117 MachineBasicBlock &MBB = *I.getParent();
lib/CodeGen/IfConversion.cpp 146 MachineBasicBlock *BB = nullptr;
147 MachineBasicBlock *TrueBB = nullptr;
148 MachineBasicBlock *FalseBB = nullptr;
232 MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB,
245 MachineBasicBlock::iterator &Begin,
249 MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB,
252 void AnalyzeBlock(MachineBasicBlock &MBB,
259 void InvalidatePreds(MachineBasicBlock &MBB);
273 MachineBasicBlock::iterator E,
281 bool MeetIfcvtSizeLimit(MachineBasicBlock &BB,
289 MachineBasicBlock &CommBB, unsigned Dups,
293 MachineBasicBlock::iterator TIB = TBBInfo.BB->begin();
294 MachineBasicBlock::iterator FIB = FBBInfo.BB->begin();
295 MachineBasicBlock::iterator TIE = TBBInfo.BB->end();
296 MachineBasicBlock::iterator FIE = FBBInfo.BB->end();
611 static MachineBasicBlock *findFalseBlock(MachineBasicBlock *BB,
611 static MachineBasicBlock *findFalseBlock(MachineBasicBlock *BB,
612 MachineBasicBlock *TrueBB) {
613 for (MachineBasicBlock *SuccBB : BB->successors()) {
635 static inline MachineBasicBlock *getNextBlock(MachineBasicBlock &MBB) {
635 static inline MachineBasicBlock *getNextBlock(MachineBasicBlock &MBB) {
691 MachineBasicBlock *FExit = FalseBranch
703 MachineBasicBlock *TExit = FalseBranch ? TrueBBI.FalseBB : TrueBBI.TrueBB;
734 MachineBasicBlock::iterator &TIB,
768 MachineBasicBlock::reverse_iterator RTIE = std::next(TIE.getReverse());
769 MachineBasicBlock::reverse_iterator RFIE = std::next(FIE.getReverse());
770 const MachineBasicBlock::reverse_iterator RTIB = std::next(TIB.getReverse());
771 const MachineBasicBlock::reverse_iterator RFIB = std::next(FIB.getReverse());
814 MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB,
832 MachineBasicBlock *MBB1,
833 MachineBasicBlock *MBB2) {
834 const MachineBasicBlock::reverse_iterator B1 = MBB1->rend();
835 const MachineBasicBlock::reverse_iterator B2 = MBB2->rend();
836 MachineBasicBlock::reverse_iterator E1 = MBB1->rbegin();
837 MachineBasicBlock::reverse_iterator E2 = MBB2->rbegin();
898 MachineBasicBlock *TT = TrueBBI.TrueBB;
899 MachineBasicBlock *TF = TrueBBI.FalseBB;
900 MachineBasicBlock *FT = FalseBBI.TrueBB;
901 MachineBasicBlock *FF = FalseBBI.FalseBB;
933 MachineBasicBlock::iterator TIB = TrueBBI.BB->begin();
934 MachineBasicBlock::iterator FIB = FalseBBI.BB->begin();
935 MachineBasicBlock::iterator TIE = TrueBBI.BB->end();
936 MachineBasicBlock::iterator FIE = FalseBBI.BB->end();
968 MachineBasicBlock *TT = TrueBBI.TrueBB;
969 MachineBasicBlock *FT = FalseBBI.TrueBB;
992 MachineBasicBlock::iterator TIB = TrueBBI.BB->begin();
993 MachineBasicBlock::iterator FIB = FalseBBI.BB->begin();
994 MachineBasicBlock::iterator TIE = TrueBBI.BB->end();
995 MachineBasicBlock::iterator FIE = FalseBBI.BB->end();
1054 MachineBasicBlock::iterator &Begin,
1205 MachineBasicBlock &MBB, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) {
1207 BBState(MachineBasicBlock &MBB) : MBB(&MBB), SuccsAnalyzed(false) {}
1208 MachineBasicBlock *MBB;
1219 MachineBasicBlock *BB = State.MBB;
1232 MachineBasicBlock::iterator Begin = BBI.BB->begin();
1233 MachineBasicBlock::iterator End = BBI.BB->end();
1427 for (MachineBasicBlock &MBB : MF)
1436 static bool canFallThroughTo(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB) {
1436 static bool canFallThroughTo(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB) {
1454 void IfConverter::InvalidatePreds(MachineBasicBlock &MBB) {
1455 for (const MachineBasicBlock *Predecessor : MBB.predecessors()) {
1465 static void InsertUncondBranch(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB,
1465 static void InsertUncondBranch(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB,
1537 MachineBasicBlock &CvtMBB = *CvtBBI->BB;
1538 MachineBasicBlock &NextMBB = *NextBBI->BB;
1623 MachineBasicBlock &CvtMBB = *CvtBBI->BB;
1624 MachineBasicBlock &NextMBB = *NextBBI->BB;
1645 for (MachineBasicBlock *PBB : CvtMBB.predecessors()) {
1813 MachineBasicBlock &MBB1 = *BBI1->BB;
1814 MachineBasicBlock &MBB2 = *BBI2->BB;
1830 MachineBasicBlock::iterator DI1 = MBB1.getFirstNonDebugInstr();
1831 MachineBasicBlock::iterator DI2 = MBB2.getFirstNonDebugInstr();
1882 MachineBasicBlock::iterator Prev = std::prev(DI1);
1914 MachineBasicBlock::iterator Prev = std::prev(DI2);
1983 MachineBasicBlock::iterator BBI1T = MBB1.getFirstTerminator();
1984 MachineBasicBlock::iterator BBI2T = MBB2.getFirstTerminator();
2011 MachineBasicBlock::iterator TIE = TrueBBI.BB->getFirstTerminator();
2043 MachineBasicBlock *TailBB = TrueBBI.TrueBB;
2076 MachineBasicBlock::const_iterator TI = BBI.BB->getFirstTerminator();
2085 MachineBasicBlock::pred_iterator PI = TailBB->pred_begin();
2129 MachineBasicBlock::iterator E,
2176 MachineBasicBlock &FromMBB = *FromBBI.BB;
2210 std::vector<MachineBasicBlock *> Succs(FromMBB.succ_begin(),
2212 MachineBasicBlock *NBB = getNextBlock(FromMBB);
2213 MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr;
2215 for (MachineBasicBlock *Succ : Succs) {
2238 MachineBasicBlock &FromMBB = *FromBBI.BB;
2244 MachineBasicBlock::iterator FromTI = FromMBB.getFirstTerminator();
2245 MachineBasicBlock::iterator ToTI = ToBBI.BB->getFirstTerminator();
2260 SmallVector<MachineBasicBlock *, 4> FromSuccs(FromMBB.succ_begin(),
2262 MachineBasicBlock *NBB = getNextBlock(FromMBB);
2263 MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr;
2274 for (MachineBasicBlock *Succ : FromSuccs) {
2332 MachineBasicBlock *Last = &*FromMBB.getParent()->rbegin();
lib/CodeGen/ImplicitNullChecks.cpp 128 MachineBasicBlock *CheckBlock;
131 MachineBasicBlock *NotNullSucc;
134 MachineBasicBlock *NullSucc;
142 MachineBasicBlock *checkBlock,
143 MachineBasicBlock *notNullSucc,
144 MachineBasicBlock *nullSucc,
154 MachineBasicBlock *getCheckBlock() const { return CheckBlock; }
156 MachineBasicBlock *getNotNullSucc() const { return NotNullSucc; }
158 MachineBasicBlock *getNullSucc() const { return NullSucc; }
168 bool analyzeBlockForNullChecks(MachineBasicBlock &MBB,
170 MachineInstr *insertFaultingInstr(MachineInstr *MI, MachineBasicBlock *MBB,
171 MachineBasicBlock *HandlerMBB);
207 MachineBasicBlock *NullSucc, MachineInstr *&Dependence);
304 for (auto &MBB : MF)
315 MachineBasicBlock *MBB, unsigned Reg) {
392 MachineBasicBlock *NullSucc,
461 MachineBasicBlock &MBB, SmallVectorImpl<NullCheck> &NullCheckList) {
487 MachineBasicBlock *NotNullSucc, *NullSucc;
616 MachineInstr *MI, MachineBasicBlock *MBB, MachineBasicBlock *HandlerMBB) {
616 MachineInstr *MI, MachineBasicBlock *MBB, MachineBasicBlock *HandlerMBB) {
688 MachineBasicBlock *MBB = NC.getMemOperation()->getParent();
lib/CodeGen/InlineSpiller.cpp 119 MachineBasicBlock &BB, unsigned &LiveReg);
127 MachineBasicBlock *Root, SmallPtrSet<MachineInstr *, 16> &Spills,
228 void insertReload(unsigned VReg, SlotIndex, MachineBasicBlock::iterator MI);
229 void insertSpill(unsigned VReg, bool isKill, MachineBasicBlock::iterator MI);
383 MachineBasicBlock *DefMBB = LIS.getMBBFromIndex(SrcVNI->def);
401 MachineBasicBlock *MBB = LIS.getMBBFromIndex(SrcVNI->def);
402 MachineBasicBlock::iterator MII;
499 MachineBasicBlock *MBB = LIS.getMBBFromIndex(VNI->def);
500 for (MachineBasicBlock *P : MBB->predecessors()) {
750 static void dumpMachineInstrRangeWithSlotIndex(MachineBasicBlock::iterator B,
765 for (MachineBasicBlock::iterator I = B; I != E; ++I) {
905 MachineBasicBlock::iterator MI) {
906 MachineBasicBlock &MBB = *MI->getParent();
935 MachineBasicBlock::iterator MI) {
936 MachineBasicBlock &MBB = *MI->getParent();
975 MachineBasicBlock *MBB = MI->getParent();
1174 MachineBasicBlock &BB, unsigned &LiveReg) {
1177 MachineBasicBlock::iterator MI = IPA.getLastInsertPointIter(OrigLI, BB);
1206 MachineBasicBlock *Block = CurrentSpill->getParent();
1231 MachineBasicBlock *Root, SmallPtrSet<MachineInstr *, 16> &Spills,
1255 MachineBasicBlock *Block = Spill->getParent();
1335 MachineBasicBlock *Root = LIS.getMBBFromIndex(OrigVNI.def);
1353 MachineBasicBlock *Block = (*RIt)->getBlock();
1486 DenseMap<MachineBasicBlock *, unsigned> SpillsToIns;
1508 MachineBasicBlock *BB = Insert.first;
1510 MachineBasicBlock::iterator MI = IPA.getLastInsertPointIter(OrigLI, *BB);
lib/CodeGen/LexicalScopes.cpp 72 for (const auto &MBB : *MF) {
280 const DILocation *DL, SmallPtrSetImpl<const MachineBasicBlock *> &MBBs) {
289 for (const auto &MBB : *MF)
301 bool LexicalScopes::dominates(const DILocation *DL, MachineBasicBlock *MBB) {
lib/CodeGen/LiveDebugValues.cpp 109 SmallPtrSet<const MachineBasicBlock *, 4> LBlocks;
116 bool dominates(MachineBasicBlock *MBB) {
330 bool dominates(MachineBasicBlock &MBB) const { return UVS.dominates(&MBB); }
375 using VarLocInMBB = SmallDenseMap<const MachineBasicBlock *, VarLocSet>;
485 bool transferTerminator(MachineBasicBlock *MBB, OpenRangesSet &OpenRanges,
495 bool join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs, VarLocInMBB &InLocs,
636 for (const MachineBasicBlock &BB : MF) {
661 const MachineBasicBlock *MBB = MI.getParent();
1034 bool LiveDebugValues::transferTerminator(MachineBasicBlock *CurMBB,
1131 MachineBasicBlock &MBB, VarLocInMBB &OutLocs, VarLocInMBB &InLocs,
1236 auto &MBB = const_cast<MachineBasicBlock &>(*Iter.first);
1277 SmallPtrSet<const MachineBasicBlock *, 16> ArtificialBlocks;
1279 DenseMap<unsigned int, MachineBasicBlock *> OrderToBB;
1280 DenseMap<MachineBasicBlock *, unsigned int> BBToOrder;
1308 MachineBasicBlock &First_MBB = *(MF.begin());
1326 for (auto &MBB : MF) {
1340 for (auto &MBB : MF)
1359 SmallPtrSet<const MachineBasicBlock *, 16> Visited;
1364 SmallPtrSet<MachineBasicBlock *, 16> OnPending;
1367 MachineBasicBlock *MBB = OrderToBB[Worklist.top()];
1406 MachineBasicBlock *MBB = TR.TransferInst->getParent();
lib/CodeGen/LiveDebugVariables.cpp 198 void insertDebugValue(MachineBasicBlock *MBB, SlotIndex StartIdx,
361 void insertDebugLabel(MachineBasicBlock *MBB, SlotIndex Idx,
685 MachineBasicBlock *MBB = &*MFI;
686 for (MachineBasicBlock::iterator MBBI = MBB->begin(), MBBE = MBB->end();
720 MachineBasicBlock *MBB = LIS.getMBBFromIndex(Start);
972 for (MachineBasicBlock &MBB : mf) {
1237 static MachineBasicBlock::iterator
1248 MachineBasicBlock::iterator I = MBB->SkipPHIsLabelsAndDebug(MBB->begin());
1261 static MachineBasicBlock::iterator
1284 void UserValue::insertDebugValue(MachineBasicBlock *MBB, SlotIndex StartIdx,
1292 MachineBasicBlock::iterator I = findInsertLocation(MBB, StartIdx, LIS);
1328 void UserLabel::insertDebugLabel(MachineBasicBlock *MBB, SlotIndex Idx,
1331 MachineBasicBlock::iterator I = findInsertLocation(MBB, Idx, LIS);
lib/CodeGen/LiveInterval.cpp 1327 const MachineBasicBlock *MBB = LIS.getMBBFromIndex(VNI->def);
1330 for (MachineBasicBlock::const_pred_iterator PI = MBB->pred_begin(),
lib/CodeGen/LiveIntervals.cpp 215 for (const MachineBasicBlock &MBB : *MF) {
319 for (const MachineBasicBlock &MBB : *MF) {
366 SmallPtrSet<const MachineBasicBlock*, 16> LiveOut;
389 const MachineBasicBlock *MBB = Indexes->getMBBFromIndex(Idx.getPrevSlot());
401 for (const MachineBasicBlock *Pred : MBB->predecessors()) {
417 for (const MachineBasicBlock *Pred : MBB->predecessors()) {
628 MachineBasicBlock *KillMBB = Indexes->getMBBFromIndex(Kill);
645 using VisitedTy = df_iterator_default_set<MachineBasicBlock*,9>;
647 for (MachineBasicBlock *Succ : KillMBB->successors()) {
648 for (df_ext_iterator<MachineBasicBlock*, VisitedTy>
651 MachineBasicBlock *MBB = *I;
813 MachineBasicBlock*
832 MachineBasicBlock *MBB1 = Indexes->getMBBFromIndex(Start);
833 MachineBasicBlock *MBB2 = Indexes->getMBBFromIndex(Stop);
842 const MachineBasicBlock *PHIMBB = getMBBFromIndex(PHI->def);
846 for (const MachineBasicBlock *Pred : PHIMBB->predecessors())
861 const MachineBasicBlock *MBB) {
893 if (MachineBasicBlock *MBB = intervalIsInOneMBB(LI)) {
1424 MachineBasicBlock *MBB = Indexes->getMBBFromIndex(Before);
1428 MachineBasicBlock::iterator MII = MBB->end();
1434 MachineBasicBlock::iterator Begin = MBB->begin();
1481 void LiveIntervals::repairOldRegInRange(const MachineBasicBlock::iterator Begin,
1498 for (MachineBasicBlock::iterator I = End; I != Begin;) {
1576 LiveIntervals::repairIntervalsInRange(MachineBasicBlock *MBB,
1577 MachineBasicBlock::iterator Begin,
1595 for (MachineBasicBlock::iterator I = End; I != Begin;) {
lib/CodeGen/LivePhysRegs.cpp 157 void LivePhysRegs::addBlockLiveIns(const MachineBasicBlock &MBB) {
211 void LivePhysRegs::addLiveOutsNoPristines(const MachineBasicBlock &MBB) {
213 for (const MachineBasicBlock *Succ : MBB.successors())
234 void LivePhysRegs::addLiveOuts(const MachineBasicBlock &MBB) {
240 void LivePhysRegs::addLiveIns(const MachineBasicBlock &MBB) {
247 const MachineBasicBlock &MBB) {
257 void llvm::addLiveIns(MachineBasicBlock &MBB, const LivePhysRegs &LiveRegs) {
279 void llvm::recomputeLivenessFlags(MachineBasicBlock &MBB) {
327 MachineBasicBlock &MBB) {
lib/CodeGen/LiveRangeCalc.cpp 221 MachineBasicBlock *MBB = I.DomNode->getBlock();
247 MachineBasicBlock *UseMBB = Indexes->getMBBFromIndex(Use.getPrevSlot());
277 MachineBasicBlock &MBB, BitVector &DefOnEntry,
286 for (MachineBasicBlock *S : B.successors())
295 for (MachineBasicBlock *P : MBB.predecessors())
301 MachineBasicBlock &B = *MF->getBlockNumbered(N);
338 for (MachineBasicBlock *P : B.predecessors())
346 bool LiveRangeCalc::findReachingDefs(LiveRange &LR, MachineBasicBlock &UseMBB,
362 MachineBasicBlock *MBB = MF->getBlockNumbered(WorkList[i]);
386 for (MachineBasicBlock *Pred : MBB->predecessors()) {
468 MachineBasicBlock *MBB = MF->getBlockNumbered(BN);
497 MachineBasicBlock *MBB = Node->getBlock();
518 for (MachineBasicBlock *Pred : MBB->predecessors()) {
587 bool LiveRangeCalc::isJointlyDominated(const MachineBasicBlock *MBB,
601 const MachineBasicBlock *B = MF.getBlockNumbered(BN);
602 for (const MachineBasicBlock *P : B->predecessors())
lib/CodeGen/LiveRangeEdit.cpp 164 SlotIndex LiveRangeEdit::rematerializeAt(MachineBasicBlock &MBB,
165 MachineBasicBlock::iterator MI,
lib/CodeGen/LiveRangeShrink.cpp 99 static void BuildInstOrderMap(MachineBasicBlock::iterator Start,
122 for (MachineBasicBlock &MBB : MF) {
129 for (MachineBasicBlock::iterator Next = MBB.begin(); Next != MBB.end();) {
218 MachineBasicBlock::iterator I = std::next(Insert->getIterator());
233 MachineBasicBlock::iterator EndIter = std::next(MI.getIterator());
lib/CodeGen/LiveRegUnits.cpp 86 const MachineBasicBlock &MBB) {
126 void LiveRegUnits::addLiveOuts(const MachineBasicBlock &MBB) {
132 for (const MachineBasicBlock *Succ : MBB.successors())
143 void LiveRegUnits::addLiveIns(const MachineBasicBlock &MBB) {
lib/CodeGen/LiveVariables.cpp 60 LiveVariables::VarInfo::findKill(const MachineBasicBlock *MBB) const {
93 MachineBasicBlock *DefBlock,
94 MachineBasicBlock *MBB,
95 std::vector<MachineBasicBlock*> &WorkList) {
119 MachineBasicBlock *DefBlock,
120 MachineBasicBlock *MBB) {
121 std::vector<MachineBasicBlock*> WorkList;
125 MachineBasicBlock *Pred = WorkList.back();
131 void LiveVariables::HandleVirtRegUse(unsigned reg, MachineBasicBlock *MBB,
177 for (MachineBasicBlock::const_pred_iterator PI = MBB->pred_begin(),
539 MachineBasicBlock *MBB = MI.getParent();
564 void LiveVariables::runOnBlock(MachineBasicBlock *MBB, const unsigned NumRegs) {
601 for (MachineBasicBlock::const_succ_iterator SI = MBB->succ_begin(),
603 MachineBasicBlock *SuccMBB = *SI;
643 MachineBasicBlock *Entry = &MF->front();
644 df_iterator_default_set<MachineBasicBlock*,16> Visited;
646 for (MachineBasicBlock *MBB : depth_first_ext(Entry, Visited)) {
709 for (const auto &MBB : Fn)
720 bool LiveVariables::VarInfo::isLiveIn(const MachineBasicBlock &MBB,
738 bool LiveVariables::isLiveOut(unsigned Reg, const MachineBasicBlock &MBB) {
741 SmallPtrSet<const MachineBasicBlock *, 8> Kills;
747 for (const MachineBasicBlock *SuccMBB : MBB.successors()) {
763 void LiveVariables::addNewBlock(MachineBasicBlock *BB,
764 MachineBasicBlock *DomBB,
765 MachineBasicBlock *SuccBB) {
770 MachineBasicBlock::iterator BBI = SuccBB->begin(), BBE = SuccBB->end();
lib/CodeGen/LocalStackSlotAllocation.cpp 51 MachineBasicBlock::iterator MI; // Instr referencing the frame
69 MachineBasicBlock::iterator getMachineInstr() const { return MI; }
303 for (MachineBasicBlock &BB : Fn) {
340 MachineBasicBlock *Entry = &Fn.front();
lib/CodeGen/LoopTraversal.cpp 15 bool LoopTraversal::isBlockDone(MachineBasicBlock *MBB) {
28 MachineBasicBlock *Entry = &*MF.begin();
29 ReversePostOrderTraversal<MachineBasicBlock *> RPOT(Entry);
30 SmallVector<MachineBasicBlock *, 4> Workqueue;
32 for (MachineBasicBlock *MBB : RPOT) {
42 MachineBasicBlock *ActiveMBB = &*Workqueue.back();
46 for (MachineBasicBlock *Succ : ActiveMBB->successors()) {
66 for (MachineBasicBlock *MBB : RPOT) {
lib/CodeGen/MIRCanonicalizerPass.cpp 86 static std::vector<MachineBasicBlock *> GetRPOList(MachineFunction &MF) {
89 ReversePostOrderTraversal<MachineBasicBlock *> RPOT(&*MF.begin());
90 std::vector<MachineBasicBlock *> RPOList;
100 MachineBasicBlock *MBB,
101 std::function<MachineBasicBlock::iterator()> getPos) {
140 MachineBasicBlock *MBB) {
245 MachineBasicBlock::iterator DefI = BBE;
246 MachineBasicBlock::iterator UseI = BBE;
306 static bool propagateLocalCopies(MachineBasicBlock *MBB) {
353 static bool doDefKillClear(MachineBasicBlock *MBB) {
375 static bool runOnBasicBlock(MachineBasicBlock *MBB,
463 std::vector<MachineBasicBlock *> RPOList = GetRPOList(MF);
lib/CodeGen/MIRNamerPass.cpp 59 ReversePostOrderTraversal<MachineBasicBlock *> RPOT(&*MF.begin());
lib/CodeGen/MIRParser/MIParser.cpp 395 parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
398 bool parseStandaloneMBB(MachineBasicBlock *&MBB);
406 parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
407 bool parseBasicBlock(MachineBasicBlock &MBB,
408 MachineBasicBlock *&AddFalthroughFrom);
409 bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
410 bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
429 bool parseMBBReference(MachineBasicBlock *&MBB);
585 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
637 auto *MBB = MF.CreateMachineBasicBlock(BB);
652 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
695 bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
728 bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
738 MachineBasicBlock *SuccMBB = nullptr;
759 bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
760 MachineBasicBlock *&AddFalthroughFrom) {
838 SmallVector<MachineBasicBlock*,4> Successors;
841 for (MachineBasicBlock *Succ : Successors)
864 MachineBasicBlock *AddFalthroughFrom = nullptr;
866 MachineBasicBlock *MBB = nullptr;
993 bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
1652 bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
1672 MachineBasicBlock *MBB;
3057 MachineBasicBlock *&MBB, StringRef Src,
lib/CodeGen/MIRParser/MIRParser.cpp 144 MachineBasicBlock *&MBB,
321 for (const MachineBasicBlock &MBB : MF) {
613 for (const MachineBasicBlock &MBB : MF) {
651 MachineBasicBlock *MBB = nullptr;
657 MachineBasicBlock *MBB = nullptr;
842 std::vector<MachineBasicBlock *> Blocks;
844 MachineBasicBlock *MBB = nullptr;
860 MachineBasicBlock *&MBB,
lib/CodeGen/MIRPrinter.cpp 150 bool canPredictBranchProbabilities(const MachineBasicBlock &MBB) const;
151 bool canPredictSuccessors(const MachineBasicBlock &MBB) const;
160 void print(const MachineBasicBlock &MBB);
230 for (const auto &MBB : MF) {
476 MachineBasicBlock::const_instr_iterator CallI = CSInfo.first->getIterator();
532 for (const auto *MBB : Table.MBBs) {
549 void llvm::guessSuccessors(const MachineBasicBlock &MBB,
550 SmallVectorImpl<MachineBasicBlock*> &Result,
552 SmallPtrSet<MachineBasicBlock*,8> Seen;
560 MachineBasicBlock *Succ = MO.getMBB();
566 MachineBasicBlock::const_iterator I = MBB.getLastNonDebugInstr();
571 MIPrinter::canPredictBranchProbabilities(const MachineBasicBlock &MBB) const {
587 bool MIPrinter::canPredictSuccessors(const MachineBasicBlock &MBB) const {
588 SmallVector<MachineBasicBlock*,8> GuessedSuccs;
595 MachineBasicBlock *Next = const_cast<MachineBasicBlock*>(&*NextI);
605 void MIPrinter::print(const MachineBasicBlock &MBB) {
lib/CodeGen/MIRVRegNamerUtils.cpp 51 std::vector<MachineInstr *> populateCandidates(MachineBasicBlock *MBB) {
84 const MachineBasicBlock *MBB) {
253 bool renameVRegs(MachineBasicBlock *MBB,
346 bool NamedVRegCursor::renameVRegs(MachineBasicBlock *MBB) {
lib/CodeGen/MIRVRegNamerUtils.h 86 bool renameVRegs(MachineBasicBlock *MBB);
lib/CodeGen/MachineBasicBlock.cpp 74 raw_ostream &llvm::operator<<(raw_ostream &OS, const MachineBasicBlock &MBB) {
79 Printable llvm::printMBBReference(const MachineBasicBlock &MBB) {
91 MachineBasicBlock *N) {
97 for (MachineBasicBlock::instr_iterator
103 MachineBasicBlock *N) {
160 MachineBasicBlock::iterator MachineBasicBlock::getFirstNonPHI() {
169 MachineBasicBlock::iterator
184 MachineBasicBlock::iterator
200 MachineBasicBlock::iterator MachineBasicBlock::getFirstTerminator() {
209 MachineBasicBlock::instr_iterator MachineBasicBlock::getFirstInstrTerminator() {
218 MachineBasicBlock::iterator MachineBasicBlock::getFirstNonDebugInstr() {
223 MachineBasicBlock::iterator MachineBasicBlock::getLastNonDebugInstr() {
459 MachineBasicBlock::livein_iterator
460 MachineBasicBlock::removeLiveIn(MachineBasicBlock::livein_iterator I) {
524 void MachineBasicBlock::moveBefore(MachineBasicBlock *NewAfter) {
528 void MachineBasicBlock::moveAfter(MachineBasicBlock *NewBefore) {
538 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
593 MachineBasicBlock *FallthroughBB = nullptr;
655 void MachineBasicBlock::addSuccessor(MachineBasicBlock *Succ,
665 void MachineBasicBlock::addSuccessorWithoutProb(MachineBasicBlock *Succ) {
674 void MachineBasicBlock::splitSuccessor(MachineBasicBlock *Old,
675 MachineBasicBlock *New,
693 void MachineBasicBlock::removeSuccessor(MachineBasicBlock *Succ,
699 MachineBasicBlock::succ_iterator
716 void MachineBasicBlock::replaceSuccessor(MachineBasicBlock *Old,
717 MachineBasicBlock *New) {
756 void MachineBasicBlock::copySuccessor(MachineBasicBlock *Orig,
764 void MachineBasicBlock::addPredecessor(MachineBasicBlock *Pred) {
768 void MachineBasicBlock::removePredecessor(MachineBasicBlock *Pred) {
774 void MachineBasicBlock::transferSuccessors(MachineBasicBlock *FromMBB) {
779 MachineBasicBlock *Succ = *FromMBB->succ_begin();
794 MachineBasicBlock::transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB) {
799 MachineBasicBlock *Succ = *FromMBB->succ_begin();
813 bool MachineBasicBlock::isPredecessor(const MachineBasicBlock *MBB) const {
817 bool MachineBasicBlock::isSuccessor(const MachineBasicBlock *MBB) const {
821 bool MachineBasicBlock::isLayoutSuccessor(const MachineBasicBlock *MBB) const {
826 MachineBasicBlock *MachineBasicBlock::getFallThrough() {
838 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
874 MachineBasicBlock *MachineBasicBlock::SplitCriticalEdge(MachineBasicBlock *Succ,
874 MachineBasicBlock *MachineBasicBlock::SplitCriticalEdge(MachineBasicBlock *Succ,
882 MachineBasicBlock *NMBB = MF->CreateMachineBasicBlock();
1026 for (MachineBasicBlock::instr_iterator
1106 const MachineBasicBlock *Succ) const {
1122 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1154 MachineBasicBlock::instr_iterator
1167 MachineBasicBlock::instr_iterator
1181 MachineBasicBlock *MachineBasicBlock::removeFromParent() {
1195 void MachineBasicBlock::ReplaceUsesOfBlockWith(MachineBasicBlock *Old,
1196 MachineBasicBlock *New) {
1199 MachineBasicBlock::instr_iterator I = instr_end();
1216 void MachineBasicBlock::replacePhiUsesWith(MachineBasicBlock *Old,
1217 MachineBasicBlock *New) {
1233 bool MachineBasicBlock::CorrectExtraCFGEdges(MachineBasicBlock *DestA,
1234 MachineBasicBlock *DestB,
1252 MachineBasicBlock *FallThru = getNextNode();
1269 SmallPtrSet<const MachineBasicBlock*, 8> SeenMBBs;
1270 MachineBasicBlock::succ_iterator SI = succ_begin();
1272 const MachineBasicBlock *MBB = *SI;
1360 MachineBasicBlock::const_probability_iterator
1362 MachineBasicBlock::const_succ_iterator I) const {
1370 MachineBasicBlock::probability_iterator
1371 MachineBasicBlock::getProbabilityIterator(MachineBasicBlock::succ_iterator I) {
1384 MachineBasicBlock::LivenessQueryResult
1412 for (MachineBasicBlock *S : successors()) {
1413 for (const MachineBasicBlock::RegisterMaskPair &LI : S->liveins()) {
1468 for (const MachineBasicBlock::RegisterMaskPair &LI : liveins())
1497 MachineBasicBlock::livein_iterator MachineBasicBlock::livein_begin() const {
lib/CodeGen/MachineBlockFrequencyInfo.cpp 88 using NodeRef = const MachineBasicBlock *;
89 using ChildIteratorType = MachineBasicBlock::const_succ_iterator;
119 DenseMap<const MachineBasicBlock *, int> LayoutOrderMap;
124 std::string getNodeLabel(const MachineBasicBlock *Node,
146 std::string getNodeAttributes(const MachineBasicBlock *Node,
152 std::string getEdgeAttributes(const MachineBasicBlock *Node, EdgeIter EI,
227 MachineBlockFrequencyInfo::getBlockFreq(const MachineBasicBlock *MBB) const {
232 const MachineBasicBlock *MBB) const {
244 MachineBlockFrequencyInfo::isIrrLoopHeader(const MachineBasicBlock *MBB) {
265 const MachineBasicBlock *MBB) const {
lib/CodeGen/MachineBlockPlacement.cpp 202 using BlockToChainMapType = DenseMap<const MachineBasicBlock *, BlockChain *>;
220 SmallVector<MachineBasicBlock *, 4> Blocks;
236 BlockChain(BlockToChainMapType &BlockToChain, MachineBasicBlock *BB)
243 using iterator = SmallVectorImpl<MachineBasicBlock *>::iterator;
244 using const_iterator = SmallVectorImpl<MachineBasicBlock *>::const_iterator;
254 bool remove(MachineBasicBlock* BB) {
270 void merge(MachineBasicBlock *BB, BlockChain *Chain) {
288 for (MachineBasicBlock *ChainBB : *Chain) {
298 for (MachineBasicBlock *MBB : *this)
317 using BlockFilterSet = SmallSetVector<const MachineBasicBlock *, 16>;
321 MachineBasicBlock *BB;
328 MachineBasicBlock *Src;
329 MachineBasicBlock *Dest;
333 SmallVector<MachineBasicBlock *, 16> BlockWorkList;
334 SmallVector<MachineBasicBlock *, 16> EHPadWorkList;
337 DenseMap<const MachineBasicBlock *, BlockAndTailDupResult> ComputedEdges;
354 MachineBasicBlock *PreferredLoopExit;
387 DenseMap<const MachineBasicBlock *, BlockChain *> BlockToChain;
394 SmallPtrSet<MachineBasicBlock *, 4> BlocksWithUnanalyzableExits;
400 const BlockChain &Chain, const MachineBasicBlock *LoopHeaderBB,
406 const BlockChain &Chain, const MachineBasicBlock *BB,
407 const MachineBasicBlock *LoopHeaderBB,
412 const MachineBasicBlock *BB, const BlockChain &Chain,
414 SmallVector<MachineBasicBlock *, 4> &Successors);
416 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
416 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
420 MachineBasicBlock *BB, MachineBasicBlock *&LPred,
420 MachineBasicBlock *BB, MachineBasicBlock *&LPred,
421 const MachineBasicBlock *LoopHeaderBB,
425 MachineBasicBlock *BB, MachineBasicBlock *LPred,
425 MachineBasicBlock *BB, MachineBasicBlock *LPred,
430 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
430 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
435 const MachineBasicBlock *BB, const BlockChain &Chain,
437 MachineBasicBlock *selectBestCandidateBlock(
438 const BlockChain &Chain, SmallVectorImpl<MachineBasicBlock *> &WorkList);
439 MachineBasicBlock *getFirstUnplacedBlock(
449 void fillWorkLists(const MachineBasicBlock *MBB,
453 void buildChain(const MachineBasicBlock *BB, BlockChain &Chain,
455 bool canMoveBottomBlockToTop(const MachineBasicBlock *BottomBlock,
456 const MachineBasicBlock *OldTop);
457 bool hasViableTopFallthrough(const MachineBasicBlock *Top,
459 BlockFrequency TopFallThroughFreq(const MachineBasicBlock *Top,
461 BlockFrequency FallThroughGains(const MachineBasicBlock *NewTop,
462 const MachineBasicBlock *OldTop,
463 const MachineBasicBlock *ExitBB,
465 MachineBasicBlock *findBestLoopTopHelper(MachineBasicBlock *OldTop,
465 MachineBasicBlock *findBestLoopTopHelper(MachineBasicBlock *OldTop,
467 MachineBasicBlock *findBestLoopTop(
469 MachineBasicBlock *findBestLoopExit(
475 BlockChain &LoopChain, const MachineBasicBlock *ExitingBB,
485 bool shouldTailDuplicate(MachineBasicBlock *BB);
489 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
489 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
494 bool isTrellis(const MachineBasicBlock *BB,
495 const SmallVectorImpl<MachineBasicBlock *> &ViableSuccs,
500 const MachineBasicBlock *BB,
501 const SmallVectorImpl<MachineBasicBlock *> &ViableSuccs,
507 const MachineBasicBlock *BB,
513 const MachineBasicBlock *BB, MachineBasicBlock *Succ,
513 const MachineBasicBlock *BB, MachineBasicBlock *Succ,
564 static std::string getBlockName(const MachineBasicBlock *BB) {
581 const BlockChain &Chain, const MachineBasicBlock *LoopHeaderBB,
585 for (MachineBasicBlock *MBB : Chain) {
597 const BlockChain &Chain, const MachineBasicBlock *MBB,
598 const MachineBasicBlock *LoopHeaderBB, const BlockFilterSet *BlockFilter) {
603 for (MachineBasicBlock *Succ : MBB->successors()) {
617 auto *NewBB = *SuccChain.begin();
630 const MachineBasicBlock *BB, const BlockChain &Chain,
632 SmallVector<MachineBasicBlock *, 4> &Successors) {
650 for (MachineBasicBlock *Succ : BB->successors()) {
691 hasSameSuccessors(MachineBasicBlock &BB,
692 SmallPtrSetImpl<const MachineBasicBlock *> &Successors) {
698 for (MachineBasicBlock *Succ : BB.successors())
707 bool MachineBlockPlacement::shouldTailDuplicate(MachineBasicBlock *BB) {
737 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
737 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
763 MachineBasicBlock *PDom = nullptr;
764 SmallVector<MachineBasicBlock *, 4> SuccSuccs;
781 for (MachineBasicBlock *SuccSucc : SuccSuccs) {
794 for (MachineBasicBlock *SuccPred : Succ->predecessors()) {
891 const MachineBasicBlock *BB,
892 const SmallVectorImpl<MachineBasicBlock *> &ViableSuccs,
899 SmallPtrSet<const MachineBasicBlock *, 2> Successors(BB->succ_begin(),
902 SmallPtrSet<const MachineBasicBlock *, 8> SeenPreds;
904 for (MachineBasicBlock *Succ : ViableSuccs) {
910 for (MachineBasicBlock *CheckSucc : SuccPred->successors())
942 const MachineBasicBlock *BB,
986 const MachineBasicBlock *BB,
987 const SmallVectorImpl<MachineBasicBlock *> &ViableSuccs,
992 SmallPtrSet<const MachineBasicBlock *, 4> Successors(BB->succ_begin(),
1005 for (MachineBasicBlock *SuccPred : Succ->predecessors()) {
1037 MachineBasicBlock *Succ1 = BestA.Dest;
1038 MachineBasicBlock *Succ2 = BestB.Dest;
1071 const MachineBasicBlock *BB, MachineBasicBlock *Succ,
1071 const MachineBasicBlock *BB, MachineBasicBlock *Succ,
1077 SmallPtrSet<const MachineBasicBlock *, 4> Successors(BB->succ_begin(),
1079 for (MachineBasicBlock *Pred : Succ->predecessors()) {
1147 std::vector<MachineBasicBlock *> Edges;
1149 TriangleChain(MachineBasicBlock *src, MachineBasicBlock *dst)
1149 TriangleChain(MachineBasicBlock *src, MachineBasicBlock *dst)
1152 void append(MachineBasicBlock *dst) {
1160 MachineBasicBlock *getKey() const {
1171 DenseMap<const MachineBasicBlock *, TriangleChain> TriangleChainMap;
1172 for (MachineBasicBlock &BB : *F) {
1176 MachineBasicBlock *PDom = nullptr;
1177 for (MachineBasicBlock *Succ : BB.successors()) {
1197 for (MachineBasicBlock* Pred : PDom->predecessors()) {
1239 MachineBasicBlock *dst = Chain.Edges.back();
1241 for (MachineBasicBlock *src : reverse(Chain.Edges)) {
1258 const MachineBasicBlock *BB) {
1262 const MachineBasicBlock *Succ1 = *BB->succ_begin();
1263 const MachineBasicBlock *Succ2 = *(BB->succ_begin() + 1);
1290 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
1290 const MachineBasicBlock *BB, const MachineBasicBlock *Succ,
1419 for (MachineBasicBlock *Pred : Succ->predecessors()) {
1470 const MachineBasicBlock *BB, const BlockChain &Chain,
1477 SmallVector<MachineBasicBlock *, 4> Successors;
1488 MachineBasicBlock *Succ = FoundEdge->second.BB;
1505 SmallVector<std::tuple<BranchProbability, MachineBasicBlock *>, 4>
1507 for (MachineBasicBlock *Succ : Successors) {
1550 MachineBasicBlock *Succ;
1581 MachineBasicBlock *MachineBlockPlacement::selectBestCandidateBlock(
1582 const BlockChain &Chain, SmallVectorImpl<MachineBasicBlock *> &WorkList) {
1598 MachineBasicBlock *BestBlock = nullptr;
1600 for (MachineBasicBlock *MBB : WorkList) {
1650 MachineBasicBlock *MachineBlockPlacement::getFirstUnplacedBlock(
1670 const MachineBasicBlock *MBB,
1680 for (MachineBasicBlock *ChainBB : Chain) {
1683 for (MachineBasicBlock *Pred : ChainBB->predecessors()) {
1695 MachineBasicBlock *BB = *Chain.begin();
1703 const MachineBasicBlock *HeadBB, BlockChain &Chain,
1709 const MachineBasicBlock *LoopHeaderBB = HeadBB;
1711 MachineBasicBlock *BB = *std::prev(Chain.end());
1721 MachineBasicBlock* BestSucc = Result.BB;
1786 const MachineBasicBlock *BottomBlock,
1787 const MachineBasicBlock *OldTop) {
1790 MachineBasicBlock *Pred = *BottomBlock->pred_begin();
1794 MachineBasicBlock *OtherBB = *Pred->succ_begin();
1806 const MachineBasicBlock *Top,
1809 for (MachineBasicBlock *Pred : Top->predecessors()) {
1817 for (MachineBasicBlock *Succ : Pred->successors()) {
1862 const MachineBasicBlock *NewTop,
1863 const MachineBasicBlock *OldTop,
1864 const MachineBasicBlock *ExitBB,
1875 MachineBasicBlock *BestPred = nullptr;
1877 for (MachineBasicBlock *Pred : NewTop->predecessors()) {
1895 for (MachineBasicBlock *Succ : BestPred->successors()) {
1951 MachineBasicBlock *
1953 MachineBasicBlock *OldTop,
1967 MachineBasicBlock *BestPred = nullptr;
1968 for (MachineBasicBlock *Pred : OldTop->predecessors()) {
1979 MachineBasicBlock *OtherBB = nullptr;
2018 MachineBasicBlock *
2031 MachineBasicBlock *OldTop = nullptr;
2032 MachineBasicBlock *NewTop = L.getHeader();
2047 MachineBasicBlock *
2065 MachineBasicBlock *ExitingBB = nullptr;
2069 SmallPtrSet<MachineBasicBlock *, 4> BlocksExitingToOuterLoop;
2073 for (MachineBasicBlock *MBB : L.getBlocks()) {
2084 MachineBasicBlock *OldExitingBB = ExitingBB;
2087 for (MachineBasicBlock *Succ : MBB->successors()) {
2171 const MachineBasicBlock *Top,
2173 for (MachineBasicBlock *Pred : Top->predecessors()) {
2181 for (MachineBasicBlock *Succ : Pred->successors()) {
2205 const MachineBasicBlock *ExitingBB,
2211 MachineBasicBlock *Top = *LoopChain.begin();
2212 MachineBasicBlock *Bottom = *std::prev(LoopChain.end());
2224 for (MachineBasicBlock *Succ : Bottom->successors()) {
2264 MachineBasicBlock *NextBlockInChain = *std::next(ExitIt);
2310 MachineBasicBlock *ChainHeaderBB = *LoopChain.begin();
2311 for (auto *Pred : ChainHeaderBB->predecessors()) {
2330 SmallVector<std::pair<MachineBasicBlock *, BlockFrequency>, 4> ExitsWithFreq;
2333 for (auto *Succ : BB->successors()) {
2446 for (MachineBasicBlock *LoopBB : L.getBlocks()) {
2487 MachineBasicBlock *LoopTop = findBestLoopTop(L, LoopBlockSet);
2510 for (const MachineBasicBlock *LoopBB : LoopBlockSet)
2563 MachineBasicBlock *BB = &*FI;
2570 MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
2575 MachineBasicBlock *NextBB = &*NextFI;
2602 for (MachineBasicBlock &MBB : *F)
2609 using FunctionBlockSetType = SmallPtrSet<MachineBasicBlock *, 16>;
2637 for (MachineBasicBlock *ChainBB : FunctionChain) {
2649 MachineBasicBlock *PrevBB = &*std::prev(MachineFunction::iterator(ChainBB));
2655 MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
2697 MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
2715 for (MachineBasicBlock *ChainBB : FunctionChain) {
2717 MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
2755 for (MachineBasicBlock *ChainBB : FunctionChain) {
2779 MachineBasicBlock *LoopHeader = L->getHeader();
2786 MachineBasicBlock *LayoutPred =
2824 MachineBasicBlock *BB, MachineBasicBlock *&LPred,
2824 MachineBasicBlock *BB, MachineBasicBlock *&LPred,
2825 const MachineBasicBlock *LoopHeaderBB,
2844 MachineBasicBlock *DupBB, *DupPred;
2886 MachineBasicBlock *BB, MachineBasicBlock *LPred,
2886 MachineBasicBlock *BB, MachineBasicBlock *LPred,
2922 SmallVectorImpl<MachineBasicBlock *> &RemoveList = BlockWorkList;
2949 SmallVector<MachineBasicBlock *, 8> DuplicatedPreds;
2956 for (MachineBasicBlock *Pred : DuplicatedPreds) {
2964 for (MachineBasicBlock *NewSucc : Pred->successors()) {
3066 for (MachineBasicBlock &MBB : MF)
3142 for (MachineBasicBlock &MBB : F) {
3148 for (MachineBasicBlock *Succ : MBB.successors()) {
lib/CodeGen/MachineBranchProbabilityInfo.cpp 43 const MachineBasicBlock *Src,
44 MachineBasicBlock::const_succ_iterator Dst) const {
49 const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const {
49 const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const {
56 const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const {
56 const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const {
61 MachineBasicBlock *
62 MachineBranchProbabilityInfo::getHotSucc(MachineBasicBlock *MBB) const {
64 MachineBasicBlock *MaxSucc = nullptr;
65 for (MachineBasicBlock::const_succ_iterator I = MBB->succ_begin(),
82 raw_ostream &OS, const MachineBasicBlock *Src,
83 const MachineBasicBlock *Dst) const {
lib/CodeGen/MachineCSE.cpp 108 DenseMap<MachineBasicBlock *, ScopeType *> ScopeMap;
109 DenseMap<MachineInstr *, MachineBasicBlock *, MachineInstrExpressionTrait>
116 MachineBasicBlock *MBB);
118 MachineBasicBlock::const_iterator I,
121 const MachineBasicBlock *MBB,
129 MachineBasicBlock *CSBB, MachineInstr *MI);
130 void EnterScope(MachineBasicBlock *MBB);
131 void ExitScope(MachineBasicBlock *MBB);
132 bool ProcessBlockCSE(MachineBasicBlock *MBB);
138 bool ProcessBlockPRE(MachineDominatorTree *MDT, MachineBasicBlock *MBB);
142 bool isProfitableToHoistInto(MachineBasicBlock *CandidateBB,
143 MachineBasicBlock *MBB,
144 MachineBasicBlock *MBB1);
165 MachineBasicBlock *MBB) {
222 MachineBasicBlock::const_iterator I,
277 const MachineBasicBlock *MBB,
299 MachineBasicBlock::const_iterator I = MI; I = std::next(I);
335 const MachineBasicBlock *MBB = MI->getParent();
336 const MachineBasicBlock *CSMBB = CSMI->getParent();
352 MachineBasicBlock::const_iterator I = CSMI; I = std::next(I);
353 MachineBasicBlock::const_iterator E = MI;
354 MachineBasicBlock::const_iterator EE = CSMBB->end();
432 MachineBasicBlock *CSBB, MachineInstr *MI) {
457 MachineBasicBlock *BB = MI->getParent();
496 void MachineCSE::EnterScope(MachineBasicBlock *MBB) {
502 void MachineCSE::ExitScope(MachineBasicBlock *MBB) {
504 DenseMap<MachineBasicBlock*, ScopeType*>::iterator SI = ScopeMap.find(MBB);
510 bool MachineCSE::ProcessBlockCSE(MachineBasicBlock *MBB) {
516 for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E; ) {
673 for (MachineBasicBlock::iterator II = CSMI, IE = MI; II != IE; ++II)
758 MachineBasicBlock *MBB = Node->getBlock();
792 MachineBasicBlock *MBB) {
794 for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E;) {
861 MachineBasicBlock *MBB = Node->getBlock();
869 bool MachineCSE::isProfitableToHoistInto(MachineBasicBlock *CandidateBB,
870 MachineBasicBlock *MBB,
871 MachineBasicBlock *MBB1) {
lib/CodeGen/MachineCombiner.cpp 86 bool combineInstructions(MachineBasicBlock *);
94 improvesCriticalPathLen(MachineBasicBlock *MBB, MachineInstr *Root,
100 bool preservesResourceLen(MachineBasicBlock *MBB,
112 void verifyPatternOrder(MachineBasicBlock *MBB, MachineInstr &Root,
299 MachineBasicBlock *MBB, MachineInstr *Root,
370 MachineBasicBlock *MBB, MachineTraceMetrics::Trace BlockTrace,
379 SmallVector <const MachineBasicBlock *, 1> MBBarr;
430 static void insertDeleteInstructions(MachineBasicBlock *MBB, MachineInstr &MI,
462 MachineBasicBlock *MBB, MachineInstr &Root,
495 bool MachineCombiner::combineInstructions(MachineBasicBlock *MBB) {
655 for (auto &MBB : MF)
lib/CodeGen/MachineCopyPropagation.cpp 213 void CopyPropagateBlock(MachineBasicBlock &MBB);
461 void MachineCopyPropagation::CopyPropagateBlock(MachineBasicBlock &MBB) {
464 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E; ) {
650 for (MachineBasicBlock &MBB : MF)
lib/CodeGen/MachineDominators.cpp 59 DT.reset(new DomTreeBase<MachineBasicBlock>());
102 MachineBasicBlock *Succ = Edge.ToBB;
105 for (MachineBasicBlock *PredBB : Succ->predecessors()) {
lib/CodeGen/MachineFrameInfo.cpp 197 for (const MachineBasicBlock &MBB : MF) {
lib/CodeGen/MachineFunction.cpp 123 void ilist_alloc_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) {
288 void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) {
341 MachineInstr &MachineFunction::CloneMachineInstrBundle(MachineBasicBlock &MBB,
342 MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig) {
344 MachineBasicBlock::const_instr_iterator I = Orig.getIterator();
386 MachineBasicBlock *
388 return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
389 MachineBasicBlock(*this, bb);
394 MachineFunction::DeleteMachineBasicBlock(MachineBasicBlock *MBB) {
514 for (const auto &BB : *this) {
533 std::string getNodeLabel(const MachineBasicBlock *Node,
633 MachineFunction::getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad) {
645 void MachineFunction::addInvoke(MachineBasicBlock *LandingPad,
652 MCSymbol *MachineFunction::addLandingPad(MachineBasicBlock *LandingPad) {
699 void MachineFunction::addCatchTypeInfo(MachineBasicBlock *LandingPad,
706 void MachineFunction::addFilterTypeInfo(MachineBasicBlock *LandingPad,
761 void MachineFunction::addCleanup(MachineBasicBlock *LandingPad) {
766 void MachineFunction::addSEHCatchHandler(MachineBasicBlock *LandingPad,
776 void MachineFunction::addSEHCleanupHandler(MachineBasicBlock *LandingPad,
905 const std::vector<MachineBasicBlock*> &DestBBs) {
913 bool MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old,
914 MachineBasicBlock *New) {
925 MachineBasicBlock *Old,
926 MachineBasicBlock *New) {
lib/CodeGen/MachineInstr.cpp 80 if (const MachineBasicBlock *MBB = MI.getParent())
153 if (MachineBasicBlock *MBB = getParent())
177 MachineBasicBlock *MBB = getParent();
570 for (MachineBasicBlock::const_instr_iterator MII = getIterator();; ++MII) {
597 MachineBasicBlock::const_instr_iterator I1 = getIterator();
598 MachineBasicBlock::const_instr_iterator I2 = Other.getIterator();
676 MachineBasicBlock *MBB = getParent();
735 MachineBasicBlock::instr_iterator Pred = getIterator();
744 MachineBasicBlock::instr_iterator Succ = getIterator();
753 MachineBasicBlock::instr_iterator Pred = getIterator();
762 MachineBasicBlock::instr_iterator Succ = getIterator();
920 MachineBasicBlock::const_instr_iterator I = getIterator();
2007 if (const MachineBasicBlock *MBB = getParent())
2048 MachineInstrBuilder llvm::BuildMI(MachineBasicBlock &BB,
2049 MachineBasicBlock::iterator I,
2059 MachineInstrBuilder llvm::BuildMI(MachineBasicBlock &BB,
2060 MachineBasicBlock::iterator I,
2085 MachineInstr *llvm::buildDbgValueForSpill(MachineBasicBlock &BB,
2086 MachineBasicBlock::iterator I,
2110 MachineBasicBlock::iterator DI = MI; ++DI;
2111 for (MachineBasicBlock::iterator DE = MI.getParent()->end();
lib/CodeGen/MachineInstrBundle.cpp 50 MachineBasicBlock *MBB = &*I;
52 for (MachineBasicBlock::instr_iterator MII = MBB->instr_begin(),
110 static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI,
124 void llvm::finalizeBundle(MachineBasicBlock &MBB,
125 MachineBasicBlock::instr_iterator FirstMI,
243 MachineBasicBlock::instr_iterator
246 MachineBasicBlock::instr_iterator E = MBB.instr_end();
247 MachineBasicBlock::instr_iterator LastMI = std::next(FirstMI);
259 MachineBasicBlock &MBB = *I;
260 MachineBasicBlock::instr_iterator MII = MBB.instr_begin();
261 MachineBasicBlock::instr_iterator MIE = MBB.instr_end();
lib/CodeGen/MachineLICM.cpp 111 MachineBasicBlock *CurPreheader; // The preheader for CurLoop.
114 SmallVector<MachineBasicBlock *, 8> ExitBlocks;
116 bool isExitBlock(const MachineBasicBlock *MBB) const {
206 bool IsGuaranteedToExecute(MachineBasicBlock *BB);
208 void EnterScope(MachineBasicBlock *MBB);
210 void ExitScope(MachineBasicBlock *MBB);
223 void InitRegPressure(MachineBasicBlock *BB);
244 bool Hoist(MachineInstr *MI, MachineBasicBlock *Preheader);
246 void InitCSEMap(MachineBasicBlock *BB);
248 MachineBasicBlock *getCurPreheader();
489 MachineBasicBlock *Preheader = getCurPreheader();
502 for (MachineBasicBlock *BB : CurLoop->getBlocks()) {
523 MachineBasicBlock::iterator TI = Preheader->getFirstTerminator();
574 for (MachineBasicBlock *BB : CurLoop->getBlocks()) {
590 MachineBasicBlock *Preheader = getCurPreheader();
599 MachineBasicBlock *MBB = MI->getParent();
613 bool MachineLICMBase::IsGuaranteedToExecute(MachineBasicBlock *BB) {
619 SmallVector<MachineBasicBlock*, 8> CurrentLoopExitingBlocks;
621 for (MachineBasicBlock *CurrentLoopExitingBlock : CurrentLoopExitingBlocks)
632 void MachineLICMBase::EnterScope(MachineBasicBlock *MBB) {
639 void MachineLICMBase::ExitScope(MachineBasicBlock *MBB) {
671 MachineBasicBlock *Preheader = getCurPreheader();
685 MachineBasicBlock *BB = Node->getBlock();
728 MachineBasicBlock *MBB = Node->getBlock();
734 for (MachineBasicBlock::iterator
736 MachineBasicBlock::iterator NextMII = MII; ++NextMII;
754 MachineBasicBlock *Preheader = getCurPreheader();
759 for (MachineBasicBlock::instr_iterator I = Preheader->instr_begin();
774 MachineBasicBlock *B = nullptr;
807 void MachineLICMBase::InitRegPressure(MachineBasicBlock *BB) {
815 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1318 MachineBasicBlock *MBB = MI->getParent();
1319 MachineBasicBlock::iterator Pos = MI;
1341 void MachineLICMBase::InitCSEMap(MachineBasicBlock *BB) {
1435 bool MachineLICMBase::Hoist(MachineInstr *MI, MachineBasicBlock *Preheader) {
1503 MachineBasicBlock *MachineLICMBase::getCurPreheader() {
1514 MachineBasicBlock *Pred = CurLoop->getLoopPredecessor();
lib/CodeGen/MachineLoopInfo.cpp 54 MachineBasicBlock *MachineLoop::getTopBlock() {
55 MachineBasicBlock *TopMBB = getHeader();
58 MachineBasicBlock *PriorMBB = &*std::prev(TopMBB->getIterator());
69 MachineBasicBlock *MachineLoop::getBottomBlock() {
70 MachineBasicBlock *BotMBB = getHeader();
73 MachineBasicBlock *NextMBB = &*std::next(BotMBB->getIterator());
84 MachineBasicBlock *MachineLoop::findLoopControlBlock() {
85 if (MachineBasicBlock *Latch = getLoopLatch()) {
96 if (MachineBasicBlock *PHeadMBB = getLoopPreheader())
103 if (MachineBasicBlock *HeadMBB = getHeader())
110 MachineBasicBlock *
113 if (MachineBasicBlock *PB = L->getLoopPreheader())
119 MachineBasicBlock *HB = L->getHeader(), *LB = L->getLoopLatch();
123 MachineBasicBlock *Preheader = nullptr;
124 for (MachineBasicBlock *P : HB->predecessors()) {
135 for (MachineBasicBlock *S : Preheader->successors()) {
lib/CodeGen/MachineLoopUtils.cpp 19 MachineBasicBlock *BB) {
20 MachineBasicBlock *PB = MI.getParent();
26 MachineBasicBlock *llvm::PeelSingleBlockLoop(LoopPeelDirection Direction,
27 MachineBasicBlock *Loop,
31 MachineBasicBlock *Preheader = *Loop->pred_begin();
34 MachineBasicBlock *Exit = *Loop->succ_begin();
38 MachineBasicBlock *NewBB = MF.CreateMachineBasicBlock(Loop->getBasicBlock());
119 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
lib/CodeGen/MachineOperand.cpp 42 if (const MachineBasicBlock *MBB = MI->getParent())
lib/CodeGen/MachineOptimizationRemarkEmitter.cpp 34 MachineOptimizationRemarkEmitter::computeHotness(const MachineBasicBlock &MBB) {
43 const MachineBasicBlock *MBB = Remark.getBlock();
lib/CodeGen/MachineOutliner.cpp 621 DenseMap<MachineBasicBlock *, unsigned> MBBFlagsMap;
628 std::vector<MachineBasicBlock::iterator> InstrList;
643 MachineBasicBlock::iterator &It, bool &CanOutlineWithPrevInstr,
696 MachineBasicBlock::iterator &It, bool &CanOutlineWithPrevInstr,
736 void convertToUnsignedVec(MachineBasicBlock &MBB,
747 MachineBasicBlock::iterator It = MBB.begin();
764 std::vector<MachineBasicBlock::iterator> InstrListForMBB;
766 for (MachineBasicBlock::iterator Et = MBB.end(); It != Et; It++) {
983 MachineBasicBlock *MBB = &*OF.MF->begin();
1051 MachineBasicBlock::iterator StartIt = Mapper.InstrList[StartIdx];
1052 MachineBasicBlock::iterator EndIt = Mapper.InstrList[EndIdx];
1053 MachineBasicBlock *MBB = StartIt->getParent();
1131 MachineBasicBlock &MBB = *MF.CreateMachineBasicBlock();
1230 MachineBasicBlock &MBB = *C.getMBB();
1231 MachineBasicBlock::iterator StartIt = C.front();
1232 MachineBasicBlock::iterator EndIt = C.back();
1330 for (MachineBasicBlock &MBB : *MF) {
lib/CodeGen/MachinePipeliner.cpp 262 MachineBasicBlock *LBLK = L.getTopBlock();
348 void MachinePipeliner::preprocessPhiNodes(MachineBasicBlock &B) {
365 MachineBasicBlock &PredB = *PI.getOperand(i+1).getMBB();
366 MachineBasicBlock::iterator At = PredB.getFirstTerminator();
388 MachineBasicBlock *MBB = L.getHeader();
396 for (MachineBasicBlock::iterator I = MBB->getFirstTerminator(),
581 static void getPhiRegs(MachineInstr &Phi, MachineBasicBlock *Loop,
597 static unsigned getLoopPhiReg(MachineInstr &Phi, MachineBasicBlock *LoopBB) {
1018 MachineBasicBlock *MBB = Loop.getHeader();
1024 for (MachineBasicBlock::iterator I = MBB->getFirstNonPHI(),
1031 for (MachineBasicBlock::iterator I = MBB->getFirstNonPHI(),
1605 MachineBasicBlock::const_iterator CurInstI = SU->getInstr();
lib/CodeGen/MachinePostDominators.cpp 50 MachineBasicBlock *MachinePostDominatorTree::findNearestCommonDominator(
51 ArrayRef<MachineBasicBlock *> Blocks) const {
54 MachineBasicBlock *NCD = Blocks.front();
55 for (MachineBasicBlock *BB : Blocks.drop_front()) {
lib/CodeGen/MachineRegionInfo.cpp 36 MachineRegion::MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
36 MachineRegion::MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
66 MachineBasicBlock *Entry = GraphTraits<MachineFunction*>::getEntryNode(&F);
lib/CodeGen/MachineRegisterInfo.cpp 470 MachineRegisterInfo::EmitLiveInCopies(MachineBasicBlock *EntryMBB,
573 const MachineBasicBlock &MBB = *MI.getParent();
lib/CodeGen/MachineSSAUpdater.cpp 37 using AvailableValsTy = DenseMap<MachineBasicBlock *, unsigned>;
66 bool MachineSSAUpdater::HasValueForBlock(MachineBasicBlock *BB) const {
72 void MachineSSAUpdater::AddAvailableValue(MachineBasicBlock *BB, unsigned V) {
78 unsigned MachineSSAUpdater::GetValueAtEndOfBlock(MachineBasicBlock *BB) {
83 unsigned LookForIdenticalPHI(MachineBasicBlock *BB,
84 SmallVectorImpl<std::pair<MachineBasicBlock *, unsigned>> &PredValues) {
88 MachineBasicBlock::iterator I = BB->begin();
99 MachineBasicBlock *SrcBB = I->getOperand(i+1).getMBB();
117 MachineBasicBlock *BB, MachineBasicBlock::iterator I,
117 MachineBasicBlock *BB, MachineBasicBlock::iterator I,
143 unsigned MachineSSAUpdater::GetValueInMiddleOfBlock(MachineBasicBlock *BB) {
160 SmallVector<std::pair<MachineBasicBlock*, unsigned>, 8> PredValues;
164 for (MachineBasicBlock::pred_iterator PI = BB->pred_begin(),
166 MachineBasicBlock *PredBB = *PI;
188 MachineBasicBlock::iterator Loc = BB->empty() ? BB->end() : BB->begin();
211 MachineBasicBlock *findCorrespondingPred(const MachineInstr *MI,
227 MachineBasicBlock *SourceBB = findCorrespondingPred(UseMI, &U);
243 using BlkT = MachineBasicBlock;
246 using BlkSucc_iterator = MachineBasicBlock::succ_iterator;
269 MachineBasicBlock *getIncomingBlock() {
282 static void FindPredecessorBlocks(MachineBasicBlock *BB,
283 SmallVectorImpl<MachineBasicBlock*> *Preds){
284 for (MachineBasicBlock::pred_iterator PI = BB->pred_begin(),
291 static unsigned GetUndefVal(MachineBasicBlock *BB,
303 static unsigned CreateEmptyPHI(MachineBasicBlock *BB, unsigned NumPreds,
305 MachineBasicBlock::iterator Loc = BB->empty() ? BB->end() : BB->begin();
315 MachineBasicBlock *Pred) {
354 unsigned MachineSSAUpdater::GetValueAtEndOfBlockInternal(MachineBasicBlock *BB){
lib/CodeGen/MachineScheduler.cpp 276 static MachineBasicBlock::const_iterator
288 static MachineBasicBlock::iterator
297 static MachineBasicBlock::const_iterator
308 static MachineBasicBlock::iterator
439 static bool isSchedBoundary(MachineBasicBlock::iterator MI,
454 MachineBasicBlock::iterator RegionBegin;
455 MachineBasicBlock::iterator RegionEnd;
458 SchedRegion(MachineBasicBlock::iterator B, MachineBasicBlock::iterator E,
467 getSchedRegions(MachineBasicBlock *MBB,
473 MachineBasicBlock::iterator I = nullptr;
474 for(MachineBasicBlock::iterator RegionEnd = MBB->end();
546 MachineBasicBlock::iterator I = R->RegionBegin;
547 MachineBasicBlock::iterator RegionEnd = R->RegionEnd;
687 void ScheduleDAGMI::startBlock(MachineBasicBlock *bb) {
701 void ScheduleDAGMI::enterRegion(MachineBasicBlock *bb,
702 MachineBasicBlock::iterator begin,
714 MachineInstr *MI, MachineBasicBlock::iterator InsertPos) {
788 MachineBasicBlock::iterator priorII =
897 MachineBasicBlock::iterator OrigPrevMI = P.second;
910 for (MachineBasicBlock::iterator MI = begin(), ME = end(); MI != ME; ++MI) {
970 void ScheduleDAGMILive::enterRegion(MachineBasicBlock *bb,
971 MachineBasicBlock::iterator begin,
1132 MachineBasicBlock::const_iterator I =
1421 MachineBasicBlock::iterator priorII =
1816 MachineBasicBlock::iterator FirstPos = nextIfDebug(DAG->begin(), DAG->end());
2745 void GenericScheduler::initPolicy(MachineBasicBlock::iterator Begin,
3254 MachineBasicBlock::iterator InsertPos = SU->getInstr();
lib/CodeGen/MachineSink.cpp 96 SmallSet<std::pair<MachineBasicBlock*, MachineBasicBlock*>, 8>
96 SmallSet<std::pair<MachineBasicBlock*, MachineBasicBlock*>, 8>
101 SetVector<std::pair<MachineBasicBlock *, MachineBasicBlock *>> ToSplit;
101 SetVector<std::pair<MachineBasicBlock *, MachineBasicBlock *>> ToSplit;
106 std::map<MachineBasicBlock *, SmallVector<MachineBasicBlock *, 4>>;
106 std::map<MachineBasicBlock *, SmallVector<MachineBasicBlock *, 4>>;
137 bool ProcessBlock(MachineBasicBlock &MBB);
140 MachineBasicBlock *From,
141 MachineBasicBlock *To);
156 MachineBasicBlock *From,
157 MachineBasicBlock *To,
167 MachineBasicBlock *TargetBlock);
168 bool AllUsesDominatedByBlock(unsigned Reg, MachineBasicBlock *MBB,
169 MachineBasicBlock *DefMBB,
171 MachineBasicBlock *FindSuccToSinkTo(MachineInstr &MI, MachineBasicBlock *MBB,
171 MachineBasicBlock *FindSuccToSinkTo(MachineInstr &MI, MachineBasicBlock *MBB,
174 MachineBasicBlock *MBB,
175 MachineBasicBlock *SuccToSinkTo,
179 MachineBasicBlock *MBB);
181 SmallVector<MachineBasicBlock *, 4> &
202 MachineBasicBlock *MBB) {
239 MachineBasicBlock *MBB,
240 MachineBasicBlock *DefMBB,
268 MachineBasicBlock *UseBlock = UseInst->getParent();
282 MachineBasicBlock *UseBlock = UseInst->getParent();
324 for (auto &MBB: MF)
353 bool MachineSinking::ProcessBlock(MachineBasicBlock &MBB) {
368 MachineBasicBlock::iterator I = MBB.end();
418 MachineBasicBlock *From,
419 MachineBasicBlock *To) {
469 MachineBasicBlock *FromBB,
470 MachineBasicBlock *ToBB,
524 for (MachineBasicBlock::pred_iterator PI = ToBB->pred_begin(),
540 MachineBasicBlock *MBB,
541 MachineBasicBlock *SuccToSinkTo,
560 MachineBasicBlock *UseBlock = UseInst.getParent();
571 if (MachineBasicBlock *MBB2 =
582 SmallVector<MachineBasicBlock *, 4> &
590 SmallVector<MachineBasicBlock *, 4> AllSuccs(MBB->succ_begin(),
625 MachineBasicBlock *
626 MachineSinking::FindSuccToSinkTo(MachineInstr &MI, MachineBasicBlock *MBB,
636 MachineBasicBlock *SuccToSinkTo = nullptr;
680 for (MachineBasicBlock *SuccBlock :
726 auto *MBB = MI.getParent();
730 auto *PredMBB = *MBB->pred_begin();
762 static void performSink(MachineInstr &MI, MachineBasicBlock &SuccToSinkTo,
763 MachineBasicBlock::iterator InsertPos,
778 MachineBasicBlock *ParentBlock = MI.getParent();
867 MachineBasicBlock *ParentBlock = MI.getParent();
868 MachineBasicBlock *SuccToSinkTo =
946 MachineBasicBlock::iterator InsertPos = SuccToSinkTo->begin();
984 MachineInstr &MI, MachineBasicBlock *TargetBlock) {
1082 bool tryToSinkCopy(MachineBasicBlock &BB, MachineFunction &MF,
1093 static bool aliasWithRegsInLiveIn(MachineBasicBlock &MBB, unsigned Reg,
1100 static MachineBasicBlock *
1101 getSingleLiveInSuccBB(MachineBasicBlock &CurBB,
1102 const SmallPtrSetImpl<MachineBasicBlock *> &SinkableBBs,
1105 MachineBasicBlock *BB = nullptr;
1106 for (auto *SI : SinkableBBs) {
1120 for (auto *SI : CurBB.successors()) {
1127 static MachineBasicBlock *
1128 getSingleLiveInSuccBB(MachineBasicBlock &CurBB,
1129 const SmallPtrSetImpl<MachineBasicBlock *> &SinkableBBs,
1132 MachineBasicBlock *SingleBB = nullptr;
1134 MachineBasicBlock *BB =
1143 static void clearKillFlags(MachineInstr *MI, MachineBasicBlock &CurBB,
1151 MachineBasicBlock::iterator NI = std::next(MI->getIterator());
1163 static void updateLiveIn(MachineInstr *MI, MachineBasicBlock *SuccBB,
1221 bool PostRAMachineSinking::tryToSinkCopy(MachineBasicBlock &CurBB,
1225 SmallPtrSet<MachineBasicBlock *, 2> SinkableBBs;
1229 for (MachineBasicBlock *SI : CurBB.successors())
1294 MachineBasicBlock *SuccBB =
1326 MachineBasicBlock::iterator InsertPos = SuccBB->getFirstNonPHI();
1346 for (auto &BB : MF)
lib/CodeGen/MachineSizeOpts.cpp 29 bool isColdBlock(const MachineBasicBlock *MBB,
38 const MachineBasicBlock *MBB,
54 for (const auto &MBB : *MF)
71 for (const auto &MBB : *MF)
93 static bool isColdBlock(const MachineBasicBlock *MBB,
99 const MachineBasicBlock *MBB,
115 bool llvm::shouldOptimizeForSize(const MachineBasicBlock *MBB,
lib/CodeGen/MachineTraceMetrics.cpp 97 MachineTraceMetrics::getResources(const MachineBasicBlock *MBB) {
168 MachineTraceMetrics::Ensemble::getLoopFor(const MachineBasicBlock *MBB) const {
175 computeDepthResources(const MachineBasicBlock *MBB) {
208 computeHeightResources(const MachineBasicBlock *MBB) {
242 getDepthResources(const MachineBasicBlock *MBB) const {
251 getHeightResources(const MachineBasicBlock *MBB) const {
313 const MachineBasicBlock *pickTracePred(const MachineBasicBlock*) override;
313 const MachineBasicBlock *pickTracePred(const MachineBasicBlock*) override;
314 const MachineBasicBlock *pickTraceSucc(const MachineBasicBlock*) override;
314 const MachineBasicBlock *pickTraceSucc(const MachineBasicBlock*) override;
324 const MachineBasicBlock*
325 MinInstrCountEnsemble::pickTracePred(const MachineBasicBlock *MBB) {
333 const MachineBasicBlock *Best = nullptr;
335 for (const MachineBasicBlock *Pred : MBB->predecessors()) {
352 const MachineBasicBlock*
353 MinInstrCountEnsemble::pickTraceSucc(const MachineBasicBlock *MBB) {
357 const MachineBasicBlock *Best = nullptr;
359 for (const MachineBasicBlock *Succ : MBB->successors()) {
396 void MachineTraceMetrics::invalidate(const MachineBasicBlock *MBB) {
428 SmallPtrSet<const MachineBasicBlock*, 8> Visited;
449 void finishPostorder(const MachineBasicBlock*) {}
451 bool insertEdge(Optional<const MachineBasicBlock *> From,
452 const MachineBasicBlock *To) {
477 void MachineTraceMetrics::Ensemble::computeTrace(const MachineBasicBlock *MBB) {
522 MachineTraceMetrics::Ensemble::invalidate(const MachineBasicBlock *BadMBB) {
523 SmallVector<const MachineBasicBlock*, 16> WorkList;
531 const MachineBasicBlock *MBB = WorkList.pop_back_val();
536 for (const MachineBasicBlock *Pred : MBB->predecessors()) {
556 const MachineBasicBlock *MBB = WorkList.pop_back_val();
561 for (const MachineBasicBlock *Succ : MBB->successors()) {
592 const MachineBasicBlock *MBB = MTM.MF->getBlockNumbered(Num);
600 const MachineBasicBlock *MBB = MTM.MF->getBlockNumbered(Num);
682 const MachineBasicBlock *Pred,
821 updateDepth(const MachineBasicBlock *MBB, const MachineInstr &UseMI,
827 updateDepths(MachineBasicBlock::iterator Start,
837 computeInstrDepths(const MachineBasicBlock *MBB) {
841 SmallVector<const MachineBasicBlock*, 8> Stack;
979 ArrayRef<const MachineBasicBlock*> Trace) {
983 const MachineBasicBlock *DefMBB = DefMI->getParent();
987 const MachineBasicBlock *MBB = Trace[i-1];
1000 computeInstrHeights(const MachineBasicBlock *MBB) {
1003 SmallVector<const MachineBasicBlock*, 8> Stack;
1064 const MachineBasicBlock *Succ = TBI.Succ;
1091 for (MachineBasicBlock::const_iterator BI = MBB->end(), BB = MBB->begin();
1159 MachineTraceMetrics::Ensemble::getTrace(const MachineBasicBlock *MBB) {
1182 const MachineBasicBlock *MBB = TE.MTM.MF->getBlockNumbered(getBlockNum());
1224 ArrayRef<const MachineBasicBlock *> Extrablocks,
1255 for (const MachineBasicBlock *MBB : Extrablocks)
1267 for (const MachineBasicBlock *MBB : Extrablocks)
lib/CodeGen/MachineVerifier.cpp 109 using BlockSet = SmallPtrSet<const MachineBasicBlock *, 8>;
213 DenseMap<const MachineBasicBlock*, BBInfo> MBBInfoMap;
231 void visitMachineBasicBlockBefore(const MachineBasicBlock *MBB);
240 void visitMachineBasicBlockAfter(const MachineBasicBlock *MBB);
244 void report(const char *msg, const MachineBasicBlock *MBB);
272 void markReachable(const MachineBasicBlock *MBB);
274 void checkPHIOps(const MachineBasicBlock &MBB);
411 for (MachineBasicBlock::const_instr_iterator MBBI = MFI->instr_begin(),
489 void MachineVerifier::report(const char *msg, const MachineBasicBlock *MBB) {
566 void MachineVerifier::markReachable(const MachineBasicBlock *MBB) {
570 for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(),
586 for (const auto &MBB : *MF) {
607 static bool matchPair(MachineBasicBlock::const_succ_iterator i,
608 const MachineBasicBlock *a, const MachineBasicBlock *b) {
608 const MachineBasicBlock *a, const MachineBasicBlock *b) {
617 MachineVerifier::visitMachineBasicBlockBefore(const MachineBasicBlock *MBB) {
635 SmallPtrSet<MachineBasicBlock*, 4> LandingPadSuccs;
636 for (MachineBasicBlock::const_succ_iterator I = MBB->succ_begin(),
650 for (MachineBasicBlock::const_pred_iterator I = MBB->pred_begin(),
672 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
2119 MachineVerifier::visitMachineBasicBlockAfter(const MachineBasicBlock *MBB) {
2140 SmallPtrSet<const MachineBasicBlock*, 8> todo;
2141 for (const auto &MBB : *MF) {
2145 for (MachineBasicBlock::const_succ_iterator SuI = MBB.succ_begin(),
2156 const MachineBasicBlock *MBB = *todo.begin();
2159 for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(),
2175 SmallPtrSet<const MachineBasicBlock*, 8> todo;
2176 for (const auto &MBB : *MF) {
2178 for (MachineBasicBlock::const_pred_iterator PrI = MBB.pred_begin(),
2189 const MachineBasicBlock *MBB = *todo.begin();
2192 for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(),
2205 void MachineVerifier::checkPHIOps(const MachineBasicBlock &MBB) {
2208 SmallPtrSet<const MachineBasicBlock*, 8> seen;
2242 const MachineBasicBlock &Pre = *MO1.getMBB();
2259 for (MachineBasicBlock *Pred : MBB.predecessors()) {
2273 for (const MachineBasicBlock &MBB : *MF)
2280 for (const auto &MBB : *MF) {
2317 for (const auto &MBB : *MF) {
2386 const MachineBasicBlock *MBB = LiveInts->getMBBFromIndex(VNI->def);
2477 const MachineBasicBlock *MBB = LiveInts->getMBBFromIndex(S.start);
2491 const MachineBasicBlock *EndMBB =
2634 for (MachineBasicBlock::const_pred_iterator PI = MFI->pred_begin(),
2757 df_iterator_default_set<const MachineBasicBlock*> Reachable;
2761 df_iterator_default_set<const MachineBasicBlock *>>
2764 const MachineBasicBlock *MBB = *DFI;
2769 const MachineBasicBlock *StackPred = DFI.getPath(DFI.getPathLength() - 2);
2806 for (MachineBasicBlock::const_pred_iterator I = MBB->pred_begin(),
2822 for (MachineBasicBlock::const_succ_iterator I = MBB->succ_begin(),
lib/CodeGen/ModuloSchedule.cpp 35 static void getPhiRegs(MachineInstr &Phi, MachineBasicBlock *Loop,
51 static unsigned getInitPhiReg(MachineInstr &Phi, MachineBasicBlock *LoopBB) {
59 static unsigned getLoopPhiReg(MachineInstr &Phi, MachineBasicBlock *LoopBB) {
113 MachineBasicBlock *KernelBB = MF.CreateMachineBasicBlock(BB->getBasicBlock());
124 SmallVector<MachineBasicBlock *, 4> PrologBBs;
144 for (MachineBasicBlock::iterator I = BB->getFirstTerminator(),
164 SmallVector<MachineBasicBlock *, 4> EpilogBBs;
191 MachineBasicBlock *KernelBB,
194 MachineBasicBlock *PredBB = Preheader;
203 MachineBasicBlock *NewBB = MF.CreateMachineBasicBlock(BB->getBasicBlock());
213 for (MachineBasicBlock::iterator BBI = BB->instr_begin(),
249 MachineBasicBlock *KernelBB,
255 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
262 MachineBasicBlock::succ_iterator LoopExitI = KernelBB->succ_begin();
266 MachineBasicBlock *LoopExitBB = *LoopExitI;
268 MachineBasicBlock *PredBB = KernelBB;
269 MachineBasicBlock *EpilogStart = LoopExitBB;
277 MachineBasicBlock *NewBB = MF.CreateMachineBasicBlock();
325 MachineBasicBlock *LastEpilogBB = EpilogBBs.back();
334 MachineBasicBlock *MBB,
351 static bool hasUseAfterLoop(unsigned Reg, MachineBasicBlock *BB,
365 MachineBasicBlock *NewBB, MachineBasicBlock *BB1, MachineBasicBlock *BB2,
365 MachineBasicBlock *NewBB, MachineBasicBlock *BB1, MachineBasicBlock *BB2,
365 MachineBasicBlock *NewBB, MachineBasicBlock *BB1, MachineBasicBlock *BB2,
366 MachineBasicBlock *KernelBB, ValueMapTy *VRMap, InstrMapTy &InstrMap,
382 for (MachineBasicBlock::iterator BBI = BB->instr_begin(),
603 MachineBasicBlock *NewBB, MachineBasicBlock *BB1, MachineBasicBlock *BB2,
603 MachineBasicBlock *NewBB, MachineBasicBlock *BB1, MachineBasicBlock *BB2,
603 MachineBasicBlock *NewBB, MachineBasicBlock *BB1, MachineBasicBlock *BB2,
604 MachineBasicBlock *KernelBB, ValueMapTy *VRMap, InstrMapTy &InstrMap,
620 for (MachineBasicBlock::iterator BBI = BB->getFirstNonPHI(),
701 void ModuloScheduleExpander::removeDeadInstructions(MachineBasicBlock *KernelBB,
708 for (MachineBasicBlock::reverse_instr_iterator MI = (*MBB)->instr_rbegin(),
762 for (MachineBasicBlock::iterator BBI = KernelBB->instr_begin(),
785 void ModuloScheduleExpander::splitLifetimes(MachineBasicBlock *KernelBB,
832 static void removePhis(MachineBasicBlock *BB, MachineBasicBlock *Incoming) {
832 static void removePhis(MachineBasicBlock *BB, MachineBasicBlock *Incoming) {
848 void ModuloScheduleExpander::addBranches(MachineBasicBlock &PreheaderBB,
850 MachineBasicBlock *KernelBB,
854 MachineBasicBlock *LastPro = KernelBB;
855 MachineBasicBlock *LastEpi = KernelBB;
864 MachineBasicBlock *Prolog = PrologBBs[j];
865 MachineBasicBlock *Epilog = EpilogBBs[i];
897 for (MachineBasicBlock::reverse_instr_iterator I = Prolog->instr_rbegin(),
1076 ValueMapTy *VRMap, MachineBasicBlock *BB) {
1106 void ModuloScheduleExpander::rewritePhiValues(MachineBasicBlock *NewBB,
1136 MachineBasicBlock *BB, InstrMapTy &InstrMap, unsigned CurStageNum,
1216 void EliminateDeadPhis(MachineBasicBlock *MBB, MachineRegisterInfo &MRI,
1247 MachineBasicBlock *BB;
1248 MachineBasicBlock *PreheaderBB, *ExitBB;
1505 auto *InsertBB = &PreheaderBB->getParent()->front();
1517 MachineBasicBlock *BB;
1568 MachineBasicBlock *
1570 MachineBasicBlock *NewBB = PeelSingleBlockLoop(LPD, BB, MRI, TII);
1606 MachineBasicBlock *ExitingBB = CreateLCSSAExitingBlock();
1636 MachineBasicBlock *Pred = *(*EI)->pred_begin();
1649 SmallVector<MachineBasicBlock *, 8> Blocks;
1655 for (MachineBasicBlock *B : reverse(Blocks)) {
1663 for (MachineBasicBlock *B : reverse(Blocks))
1668 MachineBasicBlock *PeelingModuloScheduleExpander::CreateLCSSAExitingBlock() {
1670 MachineBasicBlock *Exit = *BB->succ_begin();
1674 MachineBasicBlock *NewBB = MF.CreateMachineBasicBlock(BB->getBasicBlock());
1699 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1713 MachineBasicBlock *BB) {
1771 MachineBasicBlock *Prolog = *PI;
1772 MachineBasicBlock *Fallthrough = *Prolog->succ_begin();
1773 MachineBasicBlock *Epilog = *EI;
1844 MachineBasicBlock *ExpandedKernel = MSE.getRewrittenKernel();
1987 MachineBasicBlock *BB = L.getTopBlock();
lib/CodeGen/OptimizePHIs.cpp 61 bool OptimizeBB(MachineBasicBlock &MBB);
166 bool OptimizePHIs::OptimizeBB(MachineBasicBlock &MBB) {
168 for (MachineBasicBlock::iterator
lib/CodeGen/PHIElimination.cpp 85 bool EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB);
87 void LowerPHINode(MachineBasicBlock &MBB,
88 MachineBasicBlock::iterator LastPHIIt);
98 bool SplitPHIEdges(MachineFunction &MF, MachineBasicBlock &MBB,
103 bool isLiveIn(unsigned Reg, const MachineBasicBlock *MBB);
104 bool isLiveOutPastPHIs(unsigned Reg, const MachineBasicBlock *MBB);
160 for (auto &MBB : MF)
168 for (auto &MBB : MF)
205 MachineBasicBlock &MBB) {
210 MachineBasicBlock::iterator LastPHIIt =
240 void PHIElimination::LowerPHINode(MachineBasicBlock &MBB,
241 MachineBasicBlock::iterator LastPHIIt) {
244 MachineBasicBlock::iterator AfterPHIsIt = std::next(LastPHIIt);
374 SmallPtrSet<MachineBasicBlock*, 8> MBBsInsertedInto;
385 MachineBasicBlock &opBlock = *MPhi->getOperand(i*2+2).getMBB();
395 MachineBasicBlock::iterator InsertPos =
442 MachineBasicBlock::iterator KillInst = opBlock.end();
443 MachineBasicBlock::iterator FirstTerm = opBlock.getFirstTerminator();
444 for (MachineBasicBlock::iterator Term = FirstTerm;
489 for (MachineBasicBlock::succ_iterator SI = opBlock.succ_begin(),
502 MachineBasicBlock::iterator KillInst = opBlock.end();
503 MachineBasicBlock::iterator FirstTerm = opBlock.getFirstTerminator();
504 for (MachineBasicBlock::iterator Term = FirstTerm;
552 for (const auto &MBB : MF)
563 MachineBasicBlock &MBB,
572 for (MachineBasicBlock::iterator BBI = MBB.begin(), BBE = MBB.end();
576 MachineBasicBlock *PreMBB = BBI->getOperand(i+1).getMBB();
642 bool PHIElimination::isLiveIn(unsigned Reg, const MachineBasicBlock *MBB) {
652 const MachineBasicBlock *MBB) {
662 for (const MachineBasicBlock *SI : MBB->successors())
lib/CodeGen/PHIEliminationUtils.cpp 20 MachineBasicBlock::iterator
41 MachineBasicBlock::iterator InsertPoint;
lib/CodeGen/PHIEliminationUtils.h 19 MachineBasicBlock::iterator
lib/CodeGen/PatchableFunction.cpp 66 auto &FirstMBB = *MF.begin();
67 MachineBasicBlock::iterator FirstActualI = FirstMBB.begin();
lib/CodeGen/PeepholeOptimizer.cpp 188 bool optimizeExtInstr(MachineInstr &MI, MachineBasicBlock &MBB,
457 optimizeExtInstr(MachineInstr &MI, MachineBasicBlock &MBB,
488 SmallPtrSet<MachineBasicBlock*, 4> ReachedBBs;
533 MachineBasicBlock *UseMBB = UseMI->getParent();
561 SmallPtrSet<MachineBasicBlock*, 4> PHIBBs;
574 MachineBasicBlock *UseMBB = UseMI->getParent();
765 MachineBasicBlock *MBB = OrigPHI.getParent();
1611 for (MachineBasicBlock &MBB : MF) {
1638 for (MachineBasicBlock::iterator MII = MBB.begin(), MIE = MBB.end();
lib/CodeGen/PostRAHazardRecognizer.cpp 78 for (auto &MBB : Fn) {
lib/CodeGen/PostRASchedulerList.cpp 157 void startBlock(MachineBasicBlock *BB) override;
163 void enterRegion(MachineBasicBlock *bb,
164 MachineBasicBlock::iterator begin,
235 void SchedulePostRATDList::enterRegion(MachineBasicBlock *bb,
236 MachineBasicBlock::iterator begin,
317 for (auto &MBB : Fn) {
334 MachineBasicBlock::iterator Current = MBB.end();
336 for (MachineBasicBlock::iterator I = Current; I != MBB.begin();) {
378 void SchedulePostRATDList::startBlock(MachineBasicBlock *BB) {
697 MachineBasicBlock::iterator OrigPrivMI = P.second;
lib/CodeGen/ProcessImplicitDefs.cpp 96 MachineBasicBlock::instr_iterator UserMI = MI->getIterator();
97 MachineBasicBlock::instr_iterator UserE = MI->getParent()->instr_end();
148 for (MachineBasicBlock::instr_iterator MBBI = MFI->instr_begin(),
lib/CodeGen/PrologEpilogInserter.cpp 76 using MBBVector = SmallVector<MachineBasicBlock *, 4>;
129 void replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
173 SmallDenseMap<MachineBasicBlock *, SmallVector<MachineInstr *, 4>, 4>;
178 static void stashEntryDbgValues(MachineBasicBlock &MBB,
235 for (MachineBasicBlock *SaveBlock : SaveBlocks)
314 std::vector<MachineBasicBlock::iterator> FrameSDOps;
316 for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I)
335 for (std::vector<MachineBasicBlock::iterator>::iterator
337 MachineBasicBlock::iterator I = *i;
361 MachineBasicBlock *RestoreBlock = MFI.getRestorePoint();
372 for (MachineBasicBlock &MBB : MF) {
469 SmallPtrSet<MachineBasicBlock *, 8> Visited;
470 SmallVector<MachineBasicBlock *, 8> WorkList;
471 MachineBasicBlock *Entry = &MF.front();
472 MachineBasicBlock *Save = MFI.getSavePoint();
483 MachineBasicBlock *Restore = MFI.getRestorePoint();
491 const MachineBasicBlock *CurBB = WorkList.pop_back_val();
498 for (MachineBasicBlock *SuccBB : CurBB->successors())
507 for (MachineBasicBlock *MBB : Visited) {
520 for (MachineBasicBlock &MBB : MF) {
533 static void insertCSRSaves(MachineBasicBlock &SaveBlock,
540 MachineBasicBlock::iterator I = SaveBlock.begin();
560 static void insertCSRRestores(MachineBasicBlock &RestoreBlock,
569 MachineBasicBlock::iterator I = RestoreBlock.getFirstTerminator();
620 for (MachineBasicBlock *SaveBlock : SaveBlocks) {
626 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
1096 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1100 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
1103 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1111 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1125 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1146 df_iterator_default_set<MachineBasicBlock*> Reachable;
1154 MachineBasicBlock *StackPred = DFI.getPath(DFI.getPathLength() - 2);
1159 MachineBasicBlock *BB = *DFI;
1165 for (auto &BB : MF) {
1174 void PEI::replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
1187 for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) {
lib/CodeGen/ReachingDefAnalysis.cpp 25 MachineBasicBlock *MBB = TraversedMBB.MBB;
55 for (MachineBasicBlock *pred : MBB->predecessors()) {
lib/CodeGen/RegAllocFast.cpp 77 MachineBasicBlock *MBB;
183 void allocateBasicBlock(MachineBasicBlock &MBB);
193 void spillVirtReg(MachineBasicBlock::iterator MI, LiveReg &LR);
194 void spillVirtReg(MachineBasicBlock::iterator MI, unsigned VirtReg);
197 void definePhysReg(MachineBasicBlock::iterator MI, MCPhysReg PhysReg,
216 void spillAll(MachineBasicBlock::iterator MI, bool OnlyLiveOut);
223 void spill(MachineBasicBlock::iterator Before, unsigned VirtReg,
225 void reload(MachineBasicBlock::iterator Before, unsigned VirtReg,
314 void RegAllocFast::spill(MachineBasicBlock::iterator Before, unsigned VirtReg,
342 void RegAllocFast::reload(MachineBasicBlock::iterator Before, unsigned VirtReg,
406 void RegAllocFast::spillVirtReg(MachineBasicBlock::iterator MI,
417 void RegAllocFast::spillVirtReg(MachineBasicBlock::iterator MI, LiveReg &LR) {
435 void RegAllocFast::spillAll(MachineBasicBlock::iterator MI, bool OnlyLiveOut) {
520 void RegAllocFast::definePhysReg(MachineBasicBlock::iterator MI,
1245 void RegAllocFast::allocateBasicBlock(MachineBasicBlock &MBB) {
1252 MachineBasicBlock::iterator MII = MBB.begin();
1255 for (const MachineBasicBlock::RegisterMaskPair LI : MBB.liveins())
1314 for (MachineBasicBlock &MBB : MF)
lib/CodeGen/RegAllocGreedy.cpp 1284 MachineBasicBlock *MBB = MF->getBlockNumbered(Number);
3166 for (MachineBasicBlock *MBB : L->getBlocks())
lib/CodeGen/RegAllocPBQP.cpp 445 for (const auto &MBB : MF) {
lib/CodeGen/RegUsageInfoPropagate.cpp 115 for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/RegisterCoalescer.cpp 186 void copyCoalesceInMBB(MachineBasicBlock *MBB);
386 static bool isSplitEdge(const MachineBasicBlock *MBB) {
833 MachineBasicBlock *MBB = DefMI->getParent();
844 MachineBasicBlock::iterator Pos = DefMI;
1031 MachineBasicBlock &MBB = *CopyMI.getParent();
1057 MachineBasicBlock *CopyLeftBB = nullptr;
1058 for (MachineBasicBlock *Pred : MBB.predecessors()) {
1278 MachineBasicBlock *MBB = CopyMI->getParent();
1279 MachineBasicBlock::iterator MII =
2706 MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def);
2787 MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def);
2867 MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def);
2868 MachineBasicBlock::iterator MI = MBB->begin();
3423 MachineBasicBlock *MBB;
3427 MBBPriorityInfo(MachineBasicBlock *mbb, unsigned depth, bool issplit)
3538 const MachineBasicBlock *OrigBB = Copy.getParent();
3570 RegisterCoalescer::copyCoalesceInMBB(MachineBasicBlock *MBB) {
3583 for (MachineBasicBlock::iterator MII = MBB->begin(), E = MBB->end();
3642 MachineBasicBlock *MBB = &*I;
lib/CodeGen/RegisterPressure.cpp 202 void RegionPressure::openTop(MachineBasicBlock::const_iterator PrevTop) {
218 void RegionPressure::openBottom(MachineBasicBlock::const_iterator PrevBottom) {
266 const MachineBasicBlock *mbb,
267 MachineBasicBlock::const_iterator pos,
311 MachineBasicBlock::const_iterator IdxPos =
lib/CodeGen/RegisterScavenging.cpp 56 void RegScavenger::init(MachineBasicBlock &MBB) {
83 void RegScavenger::enterBasicBlock(MachineBasicBlock &MBB) {
88 void RegScavenger::enterBasicBlockEnd(MachineBasicBlock &MBB) {
306 Register RegScavenger::findSurvivorReg(MachineBasicBlock::iterator StartMI,
313 MachineBasicBlock::iterator ME = MBB->getFirstTerminator();
315 MachineBasicBlock::iterator RestorePointMI = StartMI;
316 MachineBasicBlock::iterator MI = StartMI;
377 static std::pair<MCPhysReg, MachineBasicBlock::iterator>
384 MachineBasicBlock::iterator Pos;
385 MachineBasicBlock &MBB = *From->getParent();
391 for (MachineBasicBlock::iterator I = From;; --I) {
461 MachineBasicBlock::iterator Before,
518 MachineBasicBlock::iterator II = std::prev(Before);
535 MachineBasicBlock::iterator I,
558 MachineBasicBlock::iterator UseMI;
580 MachineBasicBlock::iterator To,
583 const MachineBasicBlock &MBB = *To->getParent();
587 MachineBasicBlock::iterator UseMI;
589 std::pair<MCPhysReg, MachineBasicBlock::iterator> P =
593 MachineBasicBlock::iterator SpillBefore = P.second;
605 MachineBasicBlock::iterator ReloadAfter =
607 MachineBasicBlock::iterator ReloadBefore = std::next(ReloadAfter);
628 const MachineBasicBlock *CommonMBB = nullptr;
632 MachineBasicBlock *MBB = MO.getParent()->getParent();
679 MachineBasicBlock &MBB) {
685 for (MachineBasicBlock::iterator I = MBB.end(); I != MBB.begin(); ) {
692 MachineBasicBlock::iterator N = std::next(I);
763 for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/RenameIndependentSubregs.cpp 323 MachineBasicBlock &MBB = *Indexes.getMBBFromIndex(Def);
324 for (MachineBasicBlock *PredMBB : MBB.predecessors()) {
329 MachineBasicBlock::iterator InsertPos =
lib/CodeGen/ScheduleDAGInstrs.cpp 177 void ScheduleDAGInstrs::startBlock(MachineBasicBlock *bb) {
186 void ScheduleDAGInstrs::enterRegion(MachineBasicBlock *bb,
187 MachineBasicBlock::iterator begin,
218 for (const MachineBasicBlock *Succ : BB->successors()) {
793 for (MachineBasicBlock::iterator MII = RegionEnd, MIE = RegionBegin;
1103 void ScheduleDAGInstrs::fixupKills(MachineBasicBlock &MBB) {
1135 MachineBasicBlock::instr_iterator Bundle = MI.getIterator();
1142 MachineBasicBlock::instr_iterator I = std::next(Bundle);
lib/CodeGen/SelectionDAG/FastISel.cpp 193 MachineBasicBlock::reverse_iterator RE =
196 MachineBasicBlock::reverse_iterator RI(LastLocalValue);
232 MachineBasicBlock *MBB, MachineBasicBlock::iterator LastFlushPoint) {
232 MachineBasicBlock *MBB, MachineBasicBlock::iterator LastFlushPoint) {
294 MachineBasicBlock::instr_iterator SinkPos;
544 void FastISel::removeDeadCode(MachineBasicBlock::iterator I,
567 MachineBasicBlock::iterator OldInsertPt = FuncInfo.InsertPt;
1580 MachineBasicBlock::iterator FirstDeadInst(SavedLastLocalValue);
1669 void FastISel::fastEmitBranch(MachineBasicBlock *MSucc,
1690 MachineBasicBlock *TrueMBB,
1691 MachineBasicBlock *FalseMBB) {
1846 MachineBasicBlock *MSucc = FuncInfo.MBBMap[LLVMSucc];
2254 SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled;
2263 MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB];
2270 MachineBasicBlock::iterator MBBI = SuccMBB->begin();
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp 253 MachineBasicBlock *MBB = mf.CreateMachineBasicBlock(&BB);
lib/CodeGen/SelectionDAG/InstrEmitter.cpp 1159 InstrEmitter::InstrEmitter(MachineBasicBlock *mbb,
1160 MachineBasicBlock::iterator insertpos)
lib/CodeGen/SelectionDAG/InstrEmitter.h 35 MachineBasicBlock *MBB;
36 MachineBasicBlock::iterator InsertPos;
124 MachineBasicBlock *getBlock() { return MBB; }
127 MachineBasicBlock::iterator getInsertPos() { return InsertPos; }
131 InstrEmitter(MachineBasicBlock *mbb, MachineBasicBlock::iterator insertpos);
131 InstrEmitter(MachineBasicBlock *mbb, MachineBasicBlock::iterator insertpos);
lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp 649 MachineBasicBlock *
650 EmitSchedule(MachineBasicBlock::iterator &InsertPos) override;
761 MachineBasicBlock*
762 ScheduleDAGLinearize::EmitSchedule(MachineBasicBlock::iterator &InsertPos) {
769 MachineBasicBlock *BB = Emitter.getBlock();
777 MachineBasicBlock::iterator InsertPos = Emitter.getInsertPos();
lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp 54 void ScheduleDAGSDNodes::Run(SelectionDAG *dag, MachineBasicBlock *bb) {
740 MachineBasicBlock *BB = Emitter.getBlock();
741 MachineBasicBlock::iterator InsertPos = Emitter.getInsertPos();
788 MachineBasicBlock::iterator InsertPos) {
826 MachineBasicBlock *ScheduleDAGSDNodes::
827 EmitSchedule(MachineBasicBlock::iterator &InsertPos) {
848 MachineBasicBlock::iterator Before = GetPrevInsn(Emitter.getInsertPos());
850 MachineBasicBlock::iterator After = GetPrevInsn(Emitter.getInsertPos());
935 MachineBasicBlock::iterator BBBegin = BB->getFirstNonPHI();
969 MachineBasicBlock::iterator Pos = MI;
988 MachineBasicBlock *InsertBB = Emitter.getBlock();
989 MachineBasicBlock::iterator Pos = InsertBB->getFirstTerminator();
1014 MachineBasicBlock::iterator Pos = MI;
lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.h 48 MachineBasicBlock *BB;
61 void Run(SelectionDAG *dag, MachineBasicBlock *bb);
122 virtual MachineBasicBlock*
123 EmitSchedule(MachineBasicBlock::iterator &InsertPos);
188 MachineBasicBlock::iterator InsertPos);
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 1494 SDValue SelectionDAG::getBasicBlock(MachineBasicBlock *MBB) {
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 1584 MachineBasicBlock *CatchPadMBB = FuncInfo.MBB;
1598 MachineBasicBlock *TargetMBB = FuncInfo.MBBMap[I.getSuccessor()];
1624 MachineBasicBlock *SuccessorColorMBB = FuncInfo.MBBMap[SuccessorColor];
1652 SmallVectorImpl<std::pair<MachineBasicBlock *, BranchProbability>>
1686 SmallVectorImpl<std::pair<MachineBasicBlock *, BranchProbability>>
1740 SmallVector<std::pair<MachineBasicBlock *, BranchProbability>, 1> UnwindDests;
1986 SelectionDAGBuilder::getEdgeProbability(const MachineBasicBlock *Src,
1987 const MachineBasicBlock *Dst) const {
2000 void SelectionDAGBuilder::addSuccessorWithProb(MachineBasicBlock *Src,
2001 MachineBasicBlock *Dst,
2023 MachineBasicBlock *TBB,
2024 MachineBasicBlock *FBB,
2025 MachineBasicBlock *CurBB,
2026 MachineBasicBlock *SwitchBB,
2070 MachineBasicBlock *TBB,
2071 MachineBasicBlock *FBB,
2072 MachineBasicBlock *CurBB,
2073 MachineBasicBlock *SwitchBB,
2119 MachineBasicBlock *TmpBB = MF.CreateMachineBasicBlock(CurBB->getBasicBlock());
2223 MachineBasicBlock *BrMBB = FuncInfo.MBB;
2226 MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)];
2245 MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)];
2311 MachineBasicBlock *SwitchBB) {
2420 MachineBasicBlock *SwitchBB) {
2503 MachineBasicBlock *ParentBB) {
2619 MachineBasicBlock *SwitchBB) {
2652 MachineBasicBlock* MBB = B.Cases[0].ThisBB;
2681 MachineBasicBlock* NextMBB,
2685 MachineBasicBlock *SwitchBB) {
2740 MachineBasicBlock *InvokeMBB = FuncInfo.MBB;
2744 MachineBasicBlock *Return = FuncInfo.MBBMap[I.getSuccessor(0)];
2805 SmallVector<std::pair<MachineBasicBlock *, BranchProbability>, 1> UnwindDests;
2826 MachineBasicBlock *CallBrMBB = FuncInfo.MBB;
2839 MachineBasicBlock *Return = FuncInfo.MBBMap[I.getDefaultDest()];
2844 MachineBasicBlock *Target = FuncInfo.MBBMap[I.getIndirectDest(i)];
2907 void SelectionDAGBuilder::UpdateSplitBlock(MachineBasicBlock *First,
2908 MachineBasicBlock *Last) {
2921 MachineBasicBlock *IndirectBrMBB = FuncInfo.MBB;
2931 MachineBasicBlock *Succ = FuncInfo.MBBMap[BB];
9930 SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled;
9937 MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB];
9944 MachineBasicBlock::iterator MBBI = SuccMBB->begin();
10003 MachineBasicBlock *
10006 MachineBasicBlock *ParentMBB,
10008 MachineBasicBlock *SuccMBB) {
10022 MachineBasicBlock *SelectionDAGBuilder::NextBlock(MachineBasicBlock *MBB) {
10022 MachineBasicBlock *SelectionDAGBuilder::NextBlock(MachineBasicBlock *MBB) {
10043 MachineBasicBlock *SwitchMBB,
10044 MachineBasicBlock *DefaultMBB) {
10046 MachineBasicBlock *NextMBB = nullptr;
10141 MachineBasicBlock *CurMBB = W.MBB;
10144 MachineBasicBlock *Fallthrough;
10165 MachineBasicBlock *JumpMBB = JT->MBB;
10174 for (MachineBasicBlock::succ_iterator SI = JumpMBB->succ_begin(),
10293 MachineBasicBlock *SwitchMBB) {
10383 MachineBasicBlock *LeftMBB;
10400 MachineBasicBlock *RightMBB;
10442 MachineBasicBlock *SelectionDAGBuilder::peelDominantCaseCluster(
10445 MachineBasicBlock *SwitchMBB = FuncInfo.MBB;
10472 MachineBasicBlock *PeeledSwitchMBB =
10500 MachineBasicBlock *Succ = FuncInfo.MBBMap[I.getCaseSuccessor()];
10508 MachineBasicBlock *DefaultMBB = FuncInfo.MBBMap[SI.getDefaultDest()];
10517 MachineBasicBlock *PeeledSwitchMBB =
10521 MachineBasicBlock *SwitchMBB = FuncInfo.MBB;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 159 MachineBasicBlock *SwitchMBB);
163 MachineBasicBlock *SwitchMBB,
164 MachineBasicBlock *DefaultMBB);
167 MachineBasicBlock *
299 void initialize(const BasicBlock *BB, MachineBasicBlock *MBB,
339 MachineBasicBlock *getParentMBB() { return ParentMBB; }
340 MachineBasicBlock *getSuccessMBB() { return SuccessMBB; }
341 MachineBasicBlock *getFailureMBB() { return FailureMBB; }
351 MachineBasicBlock *ParentMBB = nullptr;
355 MachineBasicBlock *SuccessMBB = nullptr;
359 MachineBasicBlock *FailureMBB = nullptr;
364 MachineBasicBlock *AddSuccessorMBB(const BasicBlock *BB,
365 MachineBasicBlock *ParentMBB,
367 MachineBasicBlock *SuccMBB = nullptr);
389 MachineBasicBlock *Src, MachineBasicBlock *Dst,
389 MachineBasicBlock *Src, MachineBasicBlock *Dst,
418 DenseMap<MachineBasicBlock *, SmallVector<unsigned, 4>> LPadToCallSiteMap;
525 void FindMergedConditions(const Value *Cond, MachineBasicBlock *TBB,
526 MachineBasicBlock *FBB, MachineBasicBlock *CurBB,
526 MachineBasicBlock *FBB, MachineBasicBlock *CurBB,
527 MachineBasicBlock *SwitchBB,
530 void EmitBranchForMergedCondition(const Value *Cond, MachineBasicBlock *TBB,
531 MachineBasicBlock *FBB,
532 MachineBasicBlock *CurBB,
533 MachineBasicBlock *SwitchBB,
559 void UpdateSplitBlock(MachineBasicBlock *First, MachineBasicBlock *Last);
559 void UpdateSplitBlock(MachineBasicBlock *First, MachineBasicBlock *Last);
642 BranchProbability getEdgeProbability(const MachineBasicBlock *Src,
643 const MachineBasicBlock *Dst) const;
645 MachineBasicBlock *Src, MachineBasicBlock *Dst,
645 MachineBasicBlock *Src, MachineBasicBlock *Dst,
649 void visitSwitchCase(SwitchCG::CaseBlock &CB, MachineBasicBlock *SwitchBB);
651 MachineBasicBlock *ParentBB);
654 MachineBasicBlock *SwitchBB);
655 void visitBitTestCase(SwitchCG::BitTestBlock &BB, MachineBasicBlock *NextMBB,
657 SwitchCG::BitTestCase &B, MachineBasicBlock *SwitchBB);
661 MachineBasicBlock *SwitchBB);
787 MachineBasicBlock *NextBlock(MachineBasicBlock *MBB);
787 MachineBasicBlock *NextBlock(MachineBasicBlock *MBB);
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 286 MachineBasicBlock *
288 MachineBasicBlock *MBB) const {
496 MachineBasicBlock *EntryMBB = &MF->front();
548 SmallVector<MachineBasicBlock*, 4> Returns;
550 for (MachineBasicBlock &MBB : mf) {
554 MachineBasicBlock::iterator Term = MBB.getFirstTerminator();
580 MachineBasicBlock::iterator InsertPos = Def;
594 MachineBasicBlock::iterator InsertPos = Def;
629 MachineBasicBlock::iterator Pos = CopyUseMI;
637 for (const auto &MBB : *MF) {
994 MachineBasicBlock *FirstMBB = FuncInfo->MBB, *LastMBB;
1196 static void mapWasmLandingPadIndex(MachineBasicBlock *MBB,
1227 MachineBasicBlock *MBB = FuncInfo->MBB;
1522 MachineBasicBlock::iterator SavedInsertPt = FuncInfo->InsertPt;
1674 static MachineBasicBlock::iterator
1676 MachineBasicBlock::iterator SplitPoint = BB->getFirstTerminator();
1681 MachineBasicBlock::iterator Start = BB->begin();
1682 MachineBasicBlock::iterator Previous = SplitPoint;
1719 MachineBasicBlock *ParentMBB = SDB->SPDescriptor.getParentMBB();
1733 MachineBasicBlock *ParentMBB = SDB->SPDescriptor.getParentMBB();
1734 MachineBasicBlock *SuccessMBB = SDB->SPDescriptor.getSuccessMBB();
1742 MachineBasicBlock::iterator SplitPoint =
1759 MachineBasicBlock *FailureMBB = SDB->SPDescriptor.getFailureMBB();
1803 MachineBasicBlock *NextMBB;
1834 MachineBasicBlock *PHIBB = PHI->getParent();
1849 MachineBasicBlock* cBB = BTB.Cases[j].ThisBB;
1887 MachineBasicBlock *PHIBB = PHI->getParent();
1909 SmallVector<MachineBasicBlock *, 2> Succs;
1922 MachineBasicBlock *ThisBB = FuncInfo->MBB;
1934 for (MachineBasicBlock::iterator
lib/CodeGen/ShrinkWrap.cpp 118 MachineBasicBlock *Save;
123 MachineBasicBlock *Restore;
149 const MachineBasicBlock *Entry;
184 void updateSaveRestorePoints(MachineBasicBlock &MBB, RegScavenger *RS);
313 static MachineBasicBlock *FindIDom(MachineBasicBlock &Block, ListOfBBs BBs,
313 static MachineBasicBlock *FindIDom(MachineBasicBlock &Block, ListOfBBs BBs,
315 MachineBasicBlock *IDom = &Block;
316 for (MachineBasicBlock *BB : BBs) {
326 void ShrinkWrap::updateSaveRestorePoints(MachineBasicBlock &MBB,
425 SmallVector<MachineBasicBlock*, 4> ExitBlocks;
429 MachineBasicBlock *IPdom = Restore;
430 for (MachineBasicBlock *LoopExitBB: ExitBlocks) {
452 const MachineBasicBlock *MBB) {
470 ReversePostOrderTraversal<MachineBasicBlock *> RPOT(&*MF.begin());
471 if (containsIrreducibleCFG<MachineBasicBlock *>(RPOT, *MLI)) {
487 for (MachineBasicBlock &MBB : MF) {
558 MachineBasicBlock *NewBB;
lib/CodeGen/SlotIndexes.cpp 70 for (MachineBasicBlock &MBB : *mf) {
135 MachineBasicBlock::instr_iterator Next = std::next(MI.getIterator());
167 void SlotIndexes::repairIndexesInRange(MachineBasicBlock *MBB,
168 MachineBasicBlock::iterator Begin,
198 MachineBasicBlock::iterator MBBI = End;
229 for (MachineBasicBlock::iterator I = End; I != Begin;) {
lib/CodeGen/SpillPlacement.cpp 210 for (auto &I : mf) {
lib/CodeGen/SplitKit.cpp 77 const MachineBasicBlock &MBB) {
82 SmallVector<const MachineBasicBlock *, 1> EHPadSuccessors;
83 for (const MachineBasicBlock *SMBB : MBB.successors())
90 MachineBasicBlock::const_iterator FirstTerm = MBB.getFirstTerminator();
101 for (MachineBasicBlock::const_iterator I = MBB.end(), E = MBB.begin();
138 MachineBasicBlock::iterator
513 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
513 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
539 LaneBitmask LaneMask, MachineBasicBlock &MBB,
540 MachineBasicBlock::iterator InsertBefore, bool Late, unsigned RegIdx) {
630 MachineBasicBlock &MBB,
631 MachineBasicBlock::iterator I) {
727 SlotIndex SplitEditor::enterIntvAtEnd(MachineBasicBlock &MBB) {
747 void SplitEditor::useIntv(const MachineBasicBlock &MBB) {
808 SlotIndex SplitEditor::leaveIntvAtTop(MachineBasicBlock &MBB) {
858 MachineBasicBlock *MBB = MI->getParent();
859 MachineBasicBlock::iterator MBBI(MI);
890 MachineBasicBlock*
891 SplitEditor::findShallowDominator(MachineBasicBlock *MBB,
892 MachineBasicBlock *DefMBB) {
902 MachineBasicBlock *BestMBB = MBB;
976 MachineBasicBlock *MBB1 = LIS.getMBBFromIndex((*It1)->def);
977 MachineBasicBlock *MBB2 = LIS.getMBBFromIndex((*It2)->def);
1009 using DomPair = std::pair<MachineBasicBlock *, SlotIndex>;
1030 MachineBasicBlock *ValMBB = LIS.getMBBFromIndex(VNI->def);
1058 MachineBasicBlock *Near =
1083 MachineBasicBlock *DefMBB = LIS.getMBBFromIndex(ParentVNI->def);
1241 void SplitEditor::extendPHIRange(MachineBasicBlock &B, LiveRangeCalc &LRC,
1244 for (MachineBasicBlock *P : B.predecessors()) {
1274 MachineBasicBlock &B = *LIS.getMBBFromIndex(V->def);
1292 MachineBasicBlock &B = *LIS.getMBBFromIndex(V->def);
1459 MachineBasicBlock &MBB = *Indexes.getMBBFromIndex(VNI.def);
1460 for (const MachineBasicBlock *Pred : MBB.predecessors()) {
1616 MachineBasicBlock *MBB = VRM.getMachineFunction().getBlockNumbered(MBBNum);
lib/CodeGen/SplitKit.h 60 const MachineBasicBlock &MBB);
67 const MachineBasicBlock &MBB) {
77 MachineBasicBlock::iterator getLastInsertPointIter(const LiveInterval &CurLI,
81 SlotIndex getFirstInsertPoint(MachineBasicBlock &MBB) {
84 MachineBasicBlock::iterator MII = MBB.SkipPHIsLabelsAndDebug(MBB.begin());
121 MachineBasicBlock *MBB;
221 using BlockPtrSet = SmallPtrSet<const MachineBasicBlock *, 16>;
237 MachineBasicBlock::iterator getLastSplitPointIter(MachineBasicBlock *BB) {
387 MachineBasicBlock &MBB,
388 MachineBasicBlock::iterator I);
396 MachineBasicBlock *findShallowDominator(MachineBasicBlock *MBB,
396 MachineBasicBlock *findShallowDominator(MachineBasicBlock *MBB,
397 MachineBasicBlock *DefMBB);
417 void extendPHIRange(MachineBasicBlock &B, LiveRangeCalc &LRC,
435 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
435 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
439 MachineBasicBlock &MB, MachineBasicBlock::iterator InsertBefore,
439 MachineBasicBlock &MB, MachineBasicBlock::iterator InsertBefore,
475 SlotIndex enterIntvAtEnd(MachineBasicBlock &MBB);
478 void useIntv(const MachineBasicBlock &MBB);
494 SlotIndex leaveIntvAtTop(MachineBasicBlock &MBB);
lib/CodeGen/StackColoring.cpp 402 using LivenessMap = DenseMap<const MachineBasicBlock *, BlockLifetimeInfo>;
406 DenseMap<const MachineBasicBlock *, int> BasicBlocks;
409 SmallVector<const MachineBasicBlock *, 8> BasicBlockNumbering;
451 using BlockBitVecMap = DenseMap<const MachineBasicBlock *, BitVector>;
456 void dumpBB(MachineBasicBlock *MBB) const;
539 LLVM_DUMP_METHOD void StackColoring::dumpBB(MachineBasicBlock *MBB) const {
551 for (MachineBasicBlock *MBB : depth_first(MF)) {
638 for (MachineBasicBlock *MBB : depth_first(MF)) {
644 for (MachineBasicBlock::const_pred_iterator PI = MBB->pred_begin(),
710 for (MachineBasicBlock *MBB : depth_first(MF)) {
767 for (const MachineBasicBlock *BB : BasicBlockNumbering) {
775 for (MachineBasicBlock::const_pred_iterator PI = BB->pred_begin(),
819 for (const MachineBasicBlock &MBB : *MF) {
962 for (MachineBasicBlock &BB : *MF)
1078 for (MachineBasicBlock &BB : *MF)
lib/CodeGen/StackMapLivenessAnalysis.cpp 125 for (auto &MBB : MF) {
lib/CodeGen/StackSlotColoring.cpp 124 bool RemoveDeadStores(MachineBasicBlock* MBB);
161 MachineBasicBlock *MBB = &*MBBI;
162 for (MachineBasicBlock::iterator MII = MBB->begin(), EE = MBB->end();
374 for (MachineBasicBlock &MBB : MF) {
422 bool StackSlotColoring::RemoveDeadStores(MachineBasicBlock* MBB) {
429 for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end();
442 MachineBasicBlock::iterator NextMI = std::next(I);
443 MachineBasicBlock::iterator ProbableLoadMI = I;
lib/CodeGen/SwiftErrorValueTracking.cpp 26 Register SwiftErrorValueTracking::getOrCreateVReg(const MachineBasicBlock *MBB,
45 void SwiftErrorValueTracking::setCurrentVReg(const MachineBasicBlock *MBB,
51 const Instruction *I, const MachineBasicBlock *MBB, const Value *Val) {
66 const Instruction *I, const MachineBasicBlock *MBB, const Value *Val) {
124 MachineBasicBlock *MBB = &*MF->begin();
158 for (MachineBasicBlock *MBB : RPOT) {
181 SmallVector<std::pair<MachineBasicBlock *, Register>, 4> VRegs;
182 SmallSet<const MachineBasicBlock *, 8> Visited;
183 for (auto *Pred : MBB->predecessors()) {
260 MachineBasicBlock *MBB, BasicBlock::const_iterator Begin,
lib/CodeGen/SwitchLoweringUtils.cpp 45 MachineBasicBlock *DefaultMBB) {
188 MachineBasicBlock *DefaultMBB,
194 std::vector<MachineBasicBlock*> Table;
195 DenseMap<MachineBasicBlock*, BranchProbability> JTProbs;
232 MachineBasicBlock *JumpTableMBB =
236 SmallPtrSet<MachineBasicBlock *, 8> Done;
237 for (MachineBasicBlock *Succ : Table) {
445 MachineBasicBlock *BitTestBB =
475 MachineBasicBlock *Succ = CC.MBB;
lib/CodeGen/TailDuplicator.cpp 97 MachineBasicBlock *MBB = &*I;
98 SmallSetVector<MachineBasicBlock *, 8> Preds(MBB->pred_begin(),
100 MachineBasicBlock::iterator MI = MBB->begin();
104 for (MachineBasicBlock *PredBB : Preds) {
107 MachineBasicBlock *PHIBB = MI->getOperand(i + 1).getMBB();
123 MachineBasicBlock *PHIBB = MI->getOperand(i + 1).getMBB();
152 bool IsSimple, MachineBasicBlock *MBB,
153 MachineBasicBlock *ForcedLayoutPred,
154 SmallVectorImpl<MachineBasicBlock*> *DuplicatedPreds,
155 function_ref<void(MachineBasicBlock *)> *RemovalCallback) {
157 SmallSetVector<MachineBasicBlock *, 8> Succs(MBB->succ_begin(),
160 SmallVector<MachineBasicBlock *, 8> TDBBs;
193 MachineBasicBlock *DefBB = nullptr;
203 MachineBasicBlock *SrcBB = LI->second[j].first;
269 MachineBasicBlock *MBB = &*I++;
288 static bool isDefLiveOut(unsigned Reg, MachineBasicBlock *BB,
299 static unsigned getPHISrcRegOpIdx(MachineInstr *MI, MachineBasicBlock *SrcBB) {
309 static void getRegsUsedByPHIs(const MachineBasicBlock &BB,
323 MachineBasicBlock *BB) {
339 MachineInstr *MI, MachineBasicBlock *TailBB, MachineBasicBlock *PredBB,
339 MachineInstr *MI, MachineBasicBlock *TailBB, MachineBasicBlock *PredBB,
371 MachineInstr *MI, MachineBasicBlock *TailBB, MachineBasicBlock *PredBB,
371 MachineInstr *MI, MachineBasicBlock *TailBB, MachineBasicBlock *PredBB,
461 MachineBasicBlock *FromBB, bool isDead,
462 SmallVectorImpl<MachineBasicBlock *> &TDBBs,
463 SmallSetVector<MachineBasicBlock *, 8> &Succs) {
464 for (MachineBasicBlock *SuccBB : Succs) {
503 MachineBasicBlock *SrcBB = LI->second[j].first;
523 MachineBasicBlock *SrcBB = TDBBs[j];
543 MachineBasicBlock &TailBB) {
571 MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
662 bool TailDuplicator::isSimpleBB(MachineBasicBlock *TailBB) {
667 MachineBasicBlock::iterator I = TailBB->getFirstNonDebugInstr();
673 static bool bothUsedInPHI(const MachineBasicBlock &A,
674 const SmallPtrSet<MachineBasicBlock *, 8> &SuccsB) {
675 for (MachineBasicBlock *BB : A.successors())
682 bool TailDuplicator::canCompletelyDuplicateBB(MachineBasicBlock &BB) {
683 for (MachineBasicBlock *PredBB : BB.predecessors()) {
687 MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
699 MachineBasicBlock *TailBB, SmallVectorImpl<MachineBasicBlock *> &TDBBs,
699 MachineBasicBlock *TailBB, SmallVectorImpl<MachineBasicBlock *> &TDBBs,
702 SmallPtrSet<MachineBasicBlock *, 8> Succs(TailBB->succ_begin(),
704 SmallVector<MachineBasicBlock *, 8> Preds(TailBB->pred_begin(),
707 for (MachineBasicBlock *PredBB : Preds) {
714 MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
723 MachineBasicBlock *NewTarget = *TailBB->succ_begin();
724 MachineBasicBlock *NextBB = PredBB->getNextNode();
772 bool TailDuplicator::canTailDuplicate(MachineBasicBlock *TailBB,
773 MachineBasicBlock *PredBB) {
778 MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
797 bool TailDuplicator::tailDuplicate(bool IsSimple, MachineBasicBlock *TailBB,
798 MachineBasicBlock *ForcedLayoutPred,
799 SmallVectorImpl<MachineBasicBlock *> &TDBBs,
814 SmallSetVector<MachineBasicBlock *, 8> Preds(TailBB->pred_begin(),
816 for (MachineBasicBlock *PredBB : Preds) {
843 for (MachineBasicBlock::iterator I = TailBB->begin(), E = TailBB->end();
865 for (MachineBasicBlock *Succ : TailBB->successors())
875 MachineBasicBlock *PrevBB = ForcedLayoutPred;
878 MachineBasicBlock *PriorTBB = nullptr, *PriorFBB = nullptr;
899 MachineBasicBlock::iterator I = TailBB->begin();
952 for (MachineBasicBlock *PredBB : Preds) {
962 MachineBasicBlock::iterator I = TailBB->begin();
978 void TailDuplicator::appendCopies(MachineBasicBlock *MBB,
981 MachineBasicBlock::iterator Loc = MBB->getFirstTerminator();
993 MachineBasicBlock *MBB,
994 function_ref<void(MachineBasicBlock *)> *RemovalCallback) {
lib/CodeGen/TargetInstrInfo.cpp 65 void TargetInstrInfo::insertNoop(MachineBasicBlock &MBB,
66 MachineBasicBlock::iterator MI) const {
130 TargetInstrInfo::ReplaceTailWithBranchTo(MachineBasicBlock::iterator Tail,
132 MachineBasicBlock *MBB = Tail->getParent();
408 void TargetInstrInfo::reMaterialize(MachineBasicBlock &MBB,
409 MachineBasicBlock::iterator I,
424 MachineInstr &TargetInstrInfo::duplicate(MachineBasicBlock &MBB,
425 MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig) const {
540 MachineBasicBlock *MBB = MI.getParent();
610 MachineBasicBlock::iterator Pos = MI;
629 MachineBasicBlock &MBB = *MI.getParent();
668 const MachineInstr &Inst, const MachineBasicBlock *MBB) const {
688 const MachineBasicBlock *MBB = Inst.getParent();
987 const MachineBasicBlock *MBB,
lib/CodeGen/TargetLoweringBase.cpp 1018 MachineBasicBlock *
1020 MachineBasicBlock *MBB) const {
1099 MachineBasicBlock *
1101 MachineBasicBlock *MBB) const {
1114 MachineBasicBlock *
1116 MachineBasicBlock *MBB) const {
lib/CodeGen/TwoAddressInstructionPass.cpp 104 MachineBasicBlock *MBB;
127 MachineBasicBlock::iterator OldPos);
141 bool convertInstTo3Addr(MachineBasicBlock::iterator &mi,
147 bool rescheduleMIBelowKill(MachineBasicBlock::iterator &mi,
150 bool rescheduleKillAboveMI(MachineBasicBlock::iterator &mi,
154 bool tryInstructionTransform(MachineBasicBlock::iterator &mi,
173 void eliminateRegSequence(MachineBasicBlock::iterator&);
217 MachineBasicBlock::iterator OldPos) {
287 MachineBasicBlock::iterator KillPos = KillMI;
343 static MachineInstr *getSingleDef(unsigned Reg, MachineBasicBlock *BB,
519 MachineInstr *findOnlyInterestingUse(unsigned Reg, MachineBasicBlock *MBB,
729 TwoAddressInstructionPass::convertInstTo3Addr(MachineBasicBlock::iterator &mi,
856 rescheduleMIBelowKill(MachineBasicBlock::iterator &mi,
927 MachineBasicBlock::iterator Begin = MI;
928 MachineBasicBlock::iterator AfterMI = std::next(Begin);
929 MachineBasicBlock::iterator End = AfterMI;
941 MachineBasicBlock::iterator KillPos = KillMI;
993 MachineBasicBlock::iterator InsertPos = KillPos;
997 for (MachineBasicBlock::iterator MBBI = AfterMI; MBBI != End;) {
1046 rescheduleKillAboveMI(MachineBasicBlock::iterator &mi,
1164 MachineBasicBlock::iterator InsertPos = mi;
1167 MachineBasicBlock::iterator From = KillMI;
1168 MachineBasicBlock::iterator To = std::next(From);
1269 tryInstructionTransform(MachineBasicBlock::iterator &mi,
1388 MachineBasicBlock::iterator NewMI = NewMIs[1];
1437 MachineBasicBlock::iterator Begin(NewMIs[0]);
1438 MachineBasicBlock::iterator End(NewMIs[1]);
1572 MachineBasicBlock::iterator PrevMI = MI;
1635 MachineBasicBlock::iterator PrevMI = MI;
1703 for (MachineBasicBlock::iterator mi = MBB->begin(), me = MBB->end();
1705 MachineBasicBlock::iterator nmi = std::next(mi);
1799 eliminateRegSequence(MachineBasicBlock::iterator &MBBI) {
1858 MachineBasicBlock::iterator EndMBBI =
lib/CodeGen/UnreachableBlockElim.cpp 103 df_iterator_default_set<MachineBasicBlock*> Reachable;
112 for (MachineBasicBlock *BB : depth_first_ext(&F, Reachable))
117 std::vector<MachineBasicBlock*> DeadBlocks;
119 MachineBasicBlock *BB = &*I;
130 MachineBasicBlock* succ = *BB->succ_begin();
132 MachineBasicBlock::iterator start = succ->begin();
161 MachineBasicBlock *BB = &*I;
163 SmallPtrSet<MachineBasicBlock*, 8> preds(BB->pred_begin(),
165 MachineBasicBlock::iterator phi = BB->begin();
lib/CodeGen/VirtRegMap.cpp 305 MachineBasicBlock *MBB = MBBI->second;
335 MachineBasicBlock *MBB = I->second;
344 for (MachineBasicBlock &MBB : *MF)
410 MachineBasicBlock &MBB = *MI.getParent();
411 for (MachineBasicBlock::reverse_instr_iterator I =
502 for (MachineBasicBlock::instr_iterator
lib/CodeGen/XRayInstrumentation.cpp 93 for (auto &MBB : MF) {
126 for (auto &MBB : MF)
160 for (const auto &MBB : MF)
194 auto &FirstMBB = *MBI;
lib/Target/AArch64/AArch64A53Fix835769.cpp 105 bool runOnBasicBlock(MachineBasicBlock &MBB);
122 for (auto &MBB : F) {
130 static MachineBasicBlock *getBBFallenThrough(MachineBasicBlock *MBB,
130 static MachineBasicBlock *getBBFallenThrough(MachineBasicBlock *MBB,
139 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
142 MachineBasicBlock *PrevBB = &*std::prev(MBBI);
143 for (MachineBasicBlock *S : MBB->predecessors())
155 static MachineInstr *getLastNonPseudo(MachineBasicBlock &MBB,
157 MachineBasicBlock *FMBB = &MBB;
171 static void insertNopBeforeInstruction(MachineBasicBlock &MBB, MachineInstr* MI,
190 AArch64A53Fix835769::runOnBasicBlock(MachineBasicBlock &MBB) {
lib/Target/AArch64/AArch64A57FPLoadBalancing.cpp 137 bool runOnBasicBlock(MachineBasicBlock &MBB);
138 bool colorChainSet(std::vector<Chain*> GV, MachineBasicBlock &MBB,
140 bool colorChain(Chain *G, Color C, MachineBasicBlock &MBB);
141 int scavengeRegister(Chain *G, Color C, MachineBasicBlock &MBB);
250 MachineBasicBlock::iterator end() const {
253 MachineBasicBlock::iterator begin() const { return getStart(); }
323 for (auto &MBB : F) {
330 bool AArch64A57FPLoadBalancing::runOnBasicBlock(MachineBasicBlock &MBB) {
440 MachineBasicBlock &MBB,
497 MachineBasicBlock &MBB) {
502 MachineBasicBlock::iterator I = MBB.end();
503 MachineBasicBlock::iterator ChainEnd = G->end();
510 MachineBasicBlock::iterator ChainBegin = G->begin();
531 MachineBasicBlock &MBB) {
lib/Target/AArch64/AArch64AdvSIMDScalarPass.cpp 81 bool processMachineBasicBlock(MachineBasicBlock *MBB);
290 MachineBasicBlock *MBB = MI.getParent();
378 bool AArch64AdvSIMDScalar::processMachineBasicBlock(MachineBasicBlock *MBB) {
380 for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E;) {
lib/Target/AArch64/AArch64AsmPrinter.cpp 89 const MachineBasicBlock *MBB, unsigned JTI);
708 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
717 for (auto *JTBB : JTBBs)
723 const MachineBasicBlock *MBB,
801 const MachineBasicBlock &MBB = *MI.getParent();
802 MachineBasicBlock::const_iterator MII(MI);
lib/Target/AArch64/AArch64BranchTargets.cpp 41 void addBTI(MachineBasicBlock &MBB, bool CouldCall, bool CouldJump);
71 SmallPtrSet<MachineBasicBlock *, 8> JumpTableTargets;
74 for (auto *MBB : JTE.MBBs)
78 for (MachineBasicBlock &MBB : MF) {
103 void AArch64BranchTargets::addBTI(MachineBasicBlock &MBB, bool CouldCall,
lib/Target/AArch64/AArch64CallLowering.cpp 378 MachineBasicBlock &MBB = MIRBuilder.getMBB();
420 MachineBasicBlock &MBB = MIRBuilder.getMBB();
lib/Target/AArch64/AArch64CleanupLocalDynamicTLSPass.cpp 63 MachineBasicBlock *BB = Node->getBlock();
67 for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;
lib/Target/AArch64/AArch64CollectLOH.cpp 511 for (const MachineBasicBlock &MBB : MF) {
515 for (const MachineBasicBlock *Succ : MBB.successors()) {
lib/Target/AArch64/AArch64CompressJumpTables.cpp 39 int computeBlockSize(MachineBasicBlock &MBB);
66 int AArch64CompressJumpTables::computeBlockSize(MachineBasicBlock &MBB) {
78 for (MachineBasicBlock &MBB : *MF) {
99 MachineBasicBlock *MinBlock = nullptr;
149 for (MachineBasicBlock &MBB : *MF) {
lib/Target/AArch64/AArch64CondBrTuning.cpp 115 MachineBasicBlock *TargetMBB = TII->getBranchDestBlock(MI);
197 MachineBasicBlock::iterator I(DefMI), E(MI);
256 MachineBasicBlock::iterator I(DefMI), E(MI);
304 for (MachineBasicBlock &MBB : MF) {
306 for (MachineBasicBlock::iterator I = MBB.getFirstTerminator(),
lib/Target/AArch64/AArch64ConditionOptimizer.cpp 110 MachineInstr *findSuitableCompare(MachineBasicBlock *MBB);
146 MachineBasicBlock *MBB) {
147 MachineBasicBlock::iterator I = MBB->getFirstTerminator();
160 for (MachineBasicBlock::iterator B = MBB->begin(); I != B;) {
276 MachineBasicBlock *const MBB = CmpMI->getParent();
346 MachineBasicBlock *HBB = I->getBlock();
349 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
360 MachineBasicBlock *TBB_TBB = nullptr, *TBB_FBB = nullptr;
lib/Target/AArch64/AArch64ConditionalCompares.cpp 147 MachineBasicBlock *Head;
150 MachineBasicBlock *CmpBB;
153 MachineBasicBlock *Tail;
182 MachineInstr *findConvertibleCompare(MachineBasicBlock *MBB);
186 bool canSpeculateInstrs(MachineBasicBlock *MBB, const MachineInstr *CmpMI);
201 bool canConvert(MachineBasicBlock *MBB);
205 void convert(SmallVectorImpl<MachineBasicBlock *> &RemovedBlocks);
222 MachineBasicBlock *MBB = I.getOperand(oi + 1).getMBB();
298 MachineInstr *SSACCmpConv::findConvertibleCompare(MachineBasicBlock *MBB) {
299 MachineBasicBlock::iterator I = MBB->getFirstTerminator();
318 for (MachineBasicBlock::iterator B = MBB->begin(); I != B;) {
382 bool SSACCmpConv::canSpeculateInstrs(MachineBasicBlock *MBB,
438 bool SSACCmpConv::canConvert(MachineBasicBlock *MBB) {
444 MachineBasicBlock *Succ0 = Head->succ_begin()[0];
445 MachineBasicBlock *Succ1 = Head->succ_begin()[1];
501 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
569 void SSACCmpConv::convert(SmallVectorImpl<MachineBasicBlock *> &RemovedBlocks) {
787 bool tryConvert(MachineBasicBlock *);
788 void updateDomTree(ArrayRef<MachineBasicBlock *> Removed);
789 void updateLoops(ArrayRef<MachineBasicBlock *> Removed);
822 ArrayRef<MachineBasicBlock *> Removed) {
826 for (MachineBasicBlock *RemovedMBB : Removed) {
838 AArch64ConditionalCompares::updateLoops(ArrayRef<MachineBasicBlock *> Removed) {
841 for (MachineBasicBlock *RemovedMBB : Removed)
915 bool AArch64ConditionalCompares::tryConvert(MachineBasicBlock *MBB) {
919 SmallVector<MachineBasicBlock *, 4> RemovedBlocks;
lib/Target/AArch64/AArch64DeadRegisterDefinitionsPass.cpp 41 void processMachineBasicBlock(MachineBasicBlock &MBB);
117 MachineBasicBlock &MBB) {
196 for (auto &MBB : MF)
lib/Target/AArch64/AArch64ExpandPseudoInsts.cpp 65 bool expandMBB(MachineBasicBlock &MBB);
66 bool expandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
66 bool expandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
68 bool expandMOVImm(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
68 bool expandMOVImm(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
71 bool expandCMP_SWAP(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
71 bool expandCMP_SWAP(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
75 bool expandCMP_SWAP_128(MachineBasicBlock &MBB,
76 MachineBasicBlock::iterator MBBI,
78 bool expandSetTagLoop(MachineBasicBlock &MBB,
79 MachineBasicBlock::iterator MBBI,
108 bool AArch64ExpandPseudo::expandMOVImm(MachineBasicBlock &MBB,
109 MachineBasicBlock::iterator MBBI,
171 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned LdarOp,
171 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned LdarOp,
251 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
251 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
344 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
344 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
403 bool AArch64ExpandPseudo::expandMI(MachineBasicBlock &MBB,
404 MachineBasicBlock::iterator MBBI,
712 bool AArch64ExpandPseudo::expandMBB(MachineBasicBlock &MBB) {
715 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
717 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
729 for (auto &MBB : MF)
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp 679 for (MachineBasicBlock *MBB : L.getBlocks())
713 for (MachineBasicBlock *MBB : L.getBlocks()) {
lib/Target/AArch64/AArch64FastISel.cpp 2052 MachineBasicBlock::iterator I(std::prev(FuncInfo.InsertPt));
2075 MachineBasicBlock::iterator I(MI);
2316 MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
2317 MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
2423 MachineBasicBlock *MSucc = FuncInfo.MBBMap[BI->getSuccessor(0)];
2428 MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
2429 MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
2495 MachineBasicBlock *Target = (Imm == 0) ? FBB : TBB;
4571 MachineBasicBlock::iterator I(MI);
lib/Target/AArch64/AArch64FrameLowering.cpp 188 for (MachineBasicBlock &MBB : MF) {
273 MachineBasicBlock::iterator AArch64FrameLowering::eliminateCallFramePseudoInstr(
345 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const {
345 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const {
382 static unsigned findScratchNonCalleeSaveRegister(MachineBasicBlock *MBB) {
412 const MachineBasicBlock &MBB) const {
414 MachineBasicBlock *TmpMBB = const_cast<MachineBasicBlock *>(&MBB);
483 static MachineBasicBlock::iterator InsertSEH(MachineBasicBlock::iterator MBBI,
487 MachineBasicBlock *MBB = MBBI->getParent();
603 static void fixupSEHOpcode(MachineBasicBlock::iterator MBBI,
625 static MachineBasicBlock::iterator convertCalleeSaveRestoreToSPPrePostIncDec(
784 static void adaptForLdStOpt(MachineBasicBlock &MBB,
785 MachineBasicBlock::iterator FirstSPPopI,
838 MachineBasicBlock &MBB) const {
839 MachineBasicBlock::iterator MBBI = MBB.begin();
967 MachineBasicBlock::iterator End = MBB.end();
1282 MachineBasicBlock &MBB) {
1288 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
1322 MachineBasicBlock &MBB) const {
1323 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
1421 MachineBasicBlock::iterator Pop = std::prev(MBB.getFirstTerminator());
1443 MachineBasicBlock::iterator LastPopI = MBB.getFirstTerminator();
1444 MachineBasicBlock::iterator Begin = MBB.begin();
1946 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
1946 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
2073 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
2073 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
2362 MachineBasicBlock &MBB = MF.front();
lib/Target/AArch64/AArch64FrameLowering.h 27 void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
28 MachineBasicBlock::iterator MBBI) const;
30 MachineBasicBlock::iterator
36 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
37 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
39 bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
50 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
51 MachineBasicBlock::iterator MI,
55 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
56 MachineBasicBlock::iterator MI,
lib/Target/AArch64/AArch64ISelLowering.cpp 1321 MachineBasicBlock *
1323 MachineBasicBlock *MBB) const {
1348 MachineBasicBlock *TrueBB = MF->CreateMachineBasicBlock(LLVM_BB);
1349 MachineBasicBlock *EndBB = MF->CreateMachineBasicBlock(LLVM_BB);
1381 MachineBasicBlock *AArch64TargetLowering::EmitLoweredCatchRet(
1382 MachineInstr &MI, MachineBasicBlock *BB) const {
1389 MachineBasicBlock *AArch64TargetLowering::EmitLoweredCatchPad(
1390 MachineInstr &MI, MachineBasicBlock *BB) const {
1395 MachineBasicBlock *AArch64TargetLowering::EmitInstrWithCustomInserter(
1396 MachineInstr &MI, MachineBasicBlock *BB) const {
12368 void AArch64TargetLowering::initializeSplitCSR(MachineBasicBlock *Entry) const {
12375 MachineBasicBlock *Entry,
12376 const SmallVectorImpl<MachineBasicBlock *> &Exits) const {
12384 MachineBasicBlock::iterator MBBI = Entry->begin();
12408 for (auto *Exit : Exits)
lib/Target/AArch64/AArch64ISelLowering.h 326 MachineBasicBlock *EmitF128CSEL(MachineInstr &MI,
327 MachineBasicBlock *BB) const;
329 MachineBasicBlock *EmitLoweredCatchRet(MachineInstr &MI,
330 MachineBasicBlock *BB) const;
332 MachineBasicBlock *EmitLoweredCatchPad(MachineInstr &MI,
333 MachineBasicBlock *BB) const;
335 MachineBasicBlock *
337 MachineBasicBlock *MBB) const override;
539 void initializeSplitCSR(MachineBasicBlock *Entry) const override;
541 MachineBasicBlock *Entry,
542 const SmallVectorImpl<MachineBasicBlock *> &Exits) const override;
lib/Target/AArch64/AArch64InstrInfo.cpp 76 const MachineBasicBlock &MBB = *MI.getParent();
126 static void parseCondBranch(MachineInstr *LastInst, MachineBasicBlock *&Target,
186 MachineBasicBlock *
208 bool AArch64InstrInfo::analyzeBranch(MachineBasicBlock &MBB,
209 MachineBasicBlock *&TBB,
210 MachineBasicBlock *&FBB,
214 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
336 unsigned AArch64InstrInfo::removeBranch(MachineBasicBlock &MBB,
338 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
372 MachineBasicBlock &MBB, const DebugLoc &DL, MachineBasicBlock *TBB,
372 MachineBasicBlock &MBB, const DebugLoc &DL, MachineBasicBlock *TBB,
389 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
389 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
389 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
496 bool AArch64InstrInfo::canInsertSelect(const MachineBasicBlock &MBB,
538 void AArch64InstrInfo::insertSelect(MachineBasicBlock &MBB,
539 MachineBasicBlock::iterator I,
964 const MachineBasicBlock *MBB,
1048 MachineBasicBlock *MBB = Instr.getParent();
1141 MachineBasicBlock::iterator From, MachineBasicBlock::iterator To,
1273 static bool areCFlagsAliveInSuccessors(MachineBasicBlock *MBB) {
1274 for (auto *BB : MBB->successors())
1473 MachineBasicBlock &MBB = *MI.getParent();
1482 MachineBasicBlock *TargetMBB = MI.getOperand(0).getMBB();
1484 MachineBasicBlock::iterator FirstEpilogSEH = std::prev(MBBI);
2410 void AArch64InstrInfo::copyPhysRegTuple(MachineBasicBlock &MBB,
2411 MachineBasicBlock::iterator I,
2437 void AArch64InstrInfo::copyGPRRegTuple(MachineBasicBlock &MBB,
2438 MachineBasicBlock::iterator I,
2462 void AArch64InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
2463 MachineBasicBlock::iterator I,
2783 MachineBasicBlock &MBB,
2784 MachineBasicBlock::iterator InsertBefore,
2806 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned SrcReg,
2806 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned SrcReg,
2912 MachineBasicBlock &MBB,
2913 MachineBasicBlock::iterator InsertBefore,
2937 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned DestReg,
2937 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned DestReg,
3044 static void emitFrameOffsetAdj(MachineBasicBlock &MBB,
3045 MachineBasicBlock::iterator MBBI,
3136 void llvm::emitFrameOffset(MachineBasicBlock &MBB,
3137 MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
3179 MachineBasicBlock::iterator InsertPt, int FrameIndex,
3238 MachineBasicBlock &MBB = *MI.getParent();
3594 static bool canCombine(MachineBasicBlock &MBB, MachineOperand &MO,
3623 static bool canCombineWithMUL(MachineBasicBlock &MBB, MachineOperand &MO,
3630 static bool canCombineWithFMUL(MachineBasicBlock &MBB, MachineOperand &MO,
3667 MachineBasicBlock &MBB = *Root.getParent();
3740 MachineBasicBlock &MBB = *Root.getParent();
4103 MachineBasicBlock &MBB = *Root.getParent();
4783 MachineBasicBlock *MBB = MI.getParent();
4828 MachineBasicBlock &RefToMBB = *MBB;
4829 MachineBasicBlock *TBB = MI.getOperand(1).getMBB();
4870 MachineBasicBlock &RefToMBB = *MBB;
4871 MachineBasicBlock *TBB = MI.getOperand(TargetBBInMI).getMBB();
5305 bool AArch64InstrInfo::isMBBSafeToOutlineFrom(MachineBasicBlock &MBB,
5372 AArch64InstrInfo::getOutliningType(MachineBasicBlock::iterator &MIT,
5375 MachineBasicBlock *MBB = MI.getParent();
5502 void AArch64InstrInfo::fixupPostOutline(MachineBasicBlock &MBB) const {
5532 MachineBasicBlock &MBB, MachineFunction &MF,
5566 MachineBasicBlock::iterator It = MBB.begin();
5567 MachineBasicBlock::iterator Et = MBB.end();
5628 MachineBasicBlock::iterator AArch64InstrInfo::insertOutlinedCall(
5651 MachineBasicBlock::iterator CallPt;
lib/Target/AArch64/AArch64InstrInfo.h 133 void copyPhysRegTuple(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
133 void copyPhysRegTuple(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
137 void copyGPRRegTuple(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
137 void copyGPRRegTuple(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
141 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
141 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
145 void storeRegToStackSlot(MachineBasicBlock &MBB,
146 MachineBasicBlock::iterator MBBI, unsigned SrcReg,
151 void loadRegFromStackSlot(MachineBasicBlock &MBB,
152 MachineBasicBlock::iterator MBBI, unsigned DestReg,
164 MachineBasicBlock::iterator InsertPt, int FrameIndex,
173 MachineBasicBlock *getBranchDestBlock(const MachineInstr &MI) const override;
175 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
175 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
176 MachineBasicBlock *&FBB,
179 unsigned removeBranch(MachineBasicBlock &MBB,
181 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
181 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
182 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
187 bool canInsertSelect(const MachineBasicBlock &, ArrayRef<MachineOperand> Cond,
189 void insertSelect(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
189 void insertSelect(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
196 const MachineBasicBlock *MBB,
251 getOutliningType(MachineBasicBlock::iterator &MIT, unsigned Flags) const override;
252 bool isMBBSafeToOutlineFrom(MachineBasicBlock &MBB,
254 void buildOutlinedFrame(MachineBasicBlock &MBB, MachineFunction &MF,
256 MachineBasicBlock::iterator
283 void fixupPostOutline(MachineBasicBlock &MBB) const;
285 void instantiateCondBranch(MachineBasicBlock &MBB, const DebugLoc &DL,
286 MachineBasicBlock *TBB,
300 void emitFrameOffset(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
300 void emitFrameOffset(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
lib/Target/AArch64/AArch64InstructionSelector.cpp 956 MachineBasicBlock *DestMBB = I.getOperand(1).getMBB();
1117 MachineBasicBlock &MBB = *I.getParent();
1155 MachineBasicBlock &MBB = *I.getParent();
1279 MachineBasicBlock &MBB = *I.getParent();
1320 MachineBasicBlock &MBB = *I.getParent();
1405 MachineBasicBlock *DestMBB = I.getOperand(1).getMBB();
2974 MachineBasicBlock &MBB = *I.getParent();
3658 MachineBasicBlock &MBB = *I.getParent();
lib/Target/AArch64/AArch64LoadStoreOptimizer.cpp 111 MachineBasicBlock::iterator findMatchingInsn(MachineBasicBlock::iterator I,
118 bool findMatchingStore(MachineBasicBlock::iterator I, unsigned Limit,
122 MachineBasicBlock::iterator
128 MachineBasicBlock::iterator
134 MachineBasicBlock::iterator
141 MachineBasicBlock::iterator
148 MachineBasicBlock::iterator
157 MachineBasicBlock::iterator
162 bool tryToMergeZeroStInst(MachineBasicBlock::iterator &MBBI);
165 bool tryToPairLdStInst(MachineBasicBlock::iterator &MBBI);
168 bool tryToPromoteLoadFromStore(MachineBasicBlock::iterator &MBBI);
171 bool tryToMergeLdStUpdate(MachineBasicBlock::iterator &MBBI);
173 bool optimizeBlock(MachineBasicBlock &MBB, bool EnableNarrowZeroStOpt);
716 MachineBasicBlock::iterator
723 MachineBasicBlock::iterator NextI = I;
739 MachineBasicBlock::iterator InsertionPoint = MergeForward ? MergeMI : I;
762 MachineBasicBlock *MBB = I->getParent();
786 MachineBasicBlock::iterator
790 MachineBasicBlock::iterator NextI = I;
808 MachineBasicBlock::iterator InsertionPoint = MergeForward ? Paired : I;
858 MachineBasicBlock *MBB = I->getParent();
941 MachineBasicBlock::iterator
944 MachineBasicBlock::iterator NextI = LoadI;
1104 MachineBasicBlock::iterator I, unsigned Limit,
1106 MachineBasicBlock::iterator B = I->getParent()->begin();
1107 MachineBasicBlock::iterator MBBI = I;
1212 MachineBasicBlock::iterator
1216 MachineBasicBlock::iterator E = I->getParent()->end();
1217 MachineBasicBlock::iterator MBBI = I;
1372 MachineBasicBlock::iterator
1379 MachineBasicBlock::iterator NextI = I;
1488 MachineBasicBlock::iterator AArch64LoadStoreOpt::findMatchingUpdateInsnForward(
1490 MachineBasicBlock::iterator E = I->getParent()->end();
1492 MachineBasicBlock::iterator MBBI = I;
1547 MachineBasicBlock::iterator AArch64LoadStoreOpt::findMatchingUpdateInsnBackward(
1549 MachineBasicBlock::iterator B = I->getParent()->begin();
1550 MachineBasicBlock::iterator E = I->getParent()->end();
1552 MachineBasicBlock::iterator MBBI = I;
1603 MachineBasicBlock::iterator &MBBI) {
1615 MachineBasicBlock::iterator StoreI;
1629 MachineBasicBlock::iterator &MBBI) {
1632 MachineBasicBlock::iterator E = MI.getParent()->end();
1639 MachineBasicBlock::iterator MergeMI =
1654 bool AArch64LoadStoreOpt::tryToPairLdStInst(MachineBasicBlock::iterator &MBBI) {
1656 MachineBasicBlock::iterator E = MI.getParent()->end();
1675 MachineBasicBlock::iterator Paired =
1690 (MachineBasicBlock::iterator &MBBI) {
1692 MachineBasicBlock::iterator E = MI.getParent()->end();
1693 MachineBasicBlock::iterator Update;
1743 bool AArch64LoadStoreOpt::optimizeBlock(MachineBasicBlock &MBB,
1756 for (MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1775 for (MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1789 for (MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1803 for (MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1831 for (auto &MBB : Fn)
lib/Target/AArch64/AArch64PBQPRegAlloc.cpp 333 for (const auto &MBB: MF) {
lib/Target/AArch64/AArch64RedundantCopyElimination.cpp 93 bool knownRegValInBlock(MachineInstr &CondBr, MachineBasicBlock *MBB,
95 MachineBasicBlock::iterator &FirstUse);
96 bool optimizeBlock(MachineBasicBlock *MBB);
125 MachineInstr &CondBr, MachineBasicBlock *MBB,
126 SmallVectorImpl<RegImm> &KnownRegs, MachineBasicBlock::iterator &FirstUse) {
149 MachineBasicBlock *BrTarget = CondBr.getOperand(1).getMBB();
155 MachineBasicBlock *PredMBB = *MBB->pred_begin();
167 MachineBasicBlock::reverse_iterator RIt = CondBr.getReverseIterator();
279 bool AArch64RedundantCopyElimination::optimizeBlock(MachineBasicBlock *MBB) {
286 MachineBasicBlock *PredMBB = *MBB->pred_begin();
290 MachineBasicBlock::iterator CondBr = PredMBB->getLastNonDebugInstr();
296 MachineBasicBlock::iterator FirstUse;
306 MachineBasicBlock::iterator Itr = std::next(CondBr);
373 MachineBasicBlock::iterator LastChange = MBB->begin();
375 for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E;) {
485 for (MachineBasicBlock &MBB : MF)
lib/Target/AArch64/AArch64RegisterInfo.cpp 405 void AArch64RegisterInfo::materializeFrameBaseRegister(MachineBasicBlock *MBB,
409 MachineBasicBlock::iterator Ins = MBB->begin();
446 void AArch64RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
452 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/AArch64/AArch64RegisterInfo.h 101 void materializeFrameBaseRegister(MachineBasicBlock *MBB, unsigned BaseReg,
106 void eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
lib/Target/AArch64/AArch64SIMDInstrOpt.cpp 319 for (MachineBasicBlock::iterator MII = MI, MIE = MI.getParent()->begin();
425 MachineBasicBlock &MBB = *MI.getParent();
508 MachineBasicBlock &MBB = *MI.getParent();
710 for (MachineBasicBlock &MBB : MF) {
711 for (MachineBasicBlock::iterator MII = MBB.begin(), MIE = MBB.end();
lib/Target/AArch64/AArch64SpeculationHardening.cpp 150 bool instrumentControlFlow(MachineBasicBlock &MBB,
152 bool endsWithCondControlFlow(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
152 bool endsWithCondControlFlow(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
153 MachineBasicBlock *&FBB,
155 void insertTrackingCode(MachineBasicBlock &SplitEdgeBB,
157 void insertSPToRegTaintPropagation(MachineBasicBlock &MBB,
158 MachineBasicBlock::iterator MBBI) const;
159 void insertRegToSPTaintPropagation(MachineBasicBlock &MBB,
160 MachineBasicBlock::iterator MBBI,
162 void insertFullSpeculationBarrier(MachineBasicBlock &MBB,
163 MachineBasicBlock::iterator MBBI,
166 bool slhLoads(MachineBasicBlock &MBB);
167 bool makeGPRSpeculationSafe(MachineBasicBlock &MBB,
168 MachineBasicBlock::iterator MBBI,
170 bool lowerSpeculationSafeValuePseudos(MachineBasicBlock &MBB,
172 bool expandSpeculationSafeValue(MachineBasicBlock &MBB,
173 MachineBasicBlock::iterator MBBI,
175 bool insertCSDB(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
175 bool insertCSDB(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
187 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
187 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
187 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
218 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
218 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
226 MachineBasicBlock &SplitEdgeBB, AArch64CC::CondCode &CondCode,
241 MachineBasicBlock &MBB, bool &UsesFullSpeculationBarrier) {
245 MachineBasicBlock *TBB = nullptr;
246 MachineBasicBlock *FBB = nullptr;
258 MachineBasicBlock *SplitEdgeTBB = MBB.SplitCriticalEdge(TBB, *this);
259 MachineBasicBlock *SplitEdgeFBB = MBB.SplitCriticalEdge(FBB, *this);
291 for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); I++) {
359 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const {
359 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const {
383 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
383 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
413 for (MachineBasicBlock &MBB : MF) {
431 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, MachineInstr &MI,
431 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, MachineInstr &MI,
459 bool AArch64SpeculationHardening::slhLoads(MachineBasicBlock &MBB) {
466 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
467 MachineBasicBlock::iterator NextMBBI;
548 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
548 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
589 bool AArch64SpeculationHardening::insertCSDB(MachineBasicBlock &MBB,
590 MachineBasicBlock::iterator MBBI,
602 MachineBasicBlock &MBB, bool UsesFullSpeculationBarrier) {
617 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
622 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
671 for (auto &MBB : MF)
680 SmallVector<MachineBasicBlock *, 2> EntryBlocks;
689 for (auto &MBB : MF) {
lib/Target/AArch64/AArch64StackTaggingPreRA.cpp 190 for (auto &BB : *MF) {
lib/Target/AArch64/AArch64StorePairSuppress.cpp 49 bool shouldAddSTPToBlock(const MachineBasicBlock *BB);
76 bool AArch64StorePairSuppress::shouldAddSTPToBlock(const MachineBasicBlock *BB) {
144 for (auto &MBB : MF) {
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp 179 const MachineBasicBlock *MBB) const {
276 void AMDGPUAsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
576 for (const MachineBasicBlock &MBB : MF) {
696 for (const MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/AMDGPUAsmPrinter.h 132 void EmitBasicBlockStart(const MachineBasicBlock &MBB) override;
141 const MachineBasicBlock *MBB) const override;
lib/Target/AMDGPU/AMDGPUCallLowering.cpp 565 MachineBasicBlock &MBB = B.getMBB();
lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp 114 MachineBasicBlock *BB = I.getParent();
220 MachineBasicBlock *BB = MO.getParent()->getParent();
300 MachineBasicBlock *BB = I.getParent();
397 MachineBasicBlock *BB = I.getParent();
438 MachineBasicBlock *BB = I.getParent();
461 MachineBasicBlock *BB = MI.getParent();
500 MachineBasicBlock *BB = MI.getParent();
561 MachineBasicBlock *BB = I.getParent();
617 MachineBasicBlock *BB = I.getParent();
717 MachineBasicBlock *BB = I.getParent();
762 MachineBasicBlock &BB = *Insert->getParent();
949 MachineBasicBlock::iterator OldInsPt = B.getInsertPt();
950 MachineBasicBlock &OldMBB = B.getMBB();
1034 MachineBasicBlock *BB = I.getParent();
1093 MachineBasicBlock *BB = I.getParent();
1220 MachineBasicBlock &MBB = *I.getParent();
1369 MachineBasicBlock *MBB = I.getParent();
1399 MachineBasicBlock *BB = I.getParent();
1539 MachineBasicBlock *BB = I.getParent();
1557 MachineBasicBlock *BB = I.getParent();
1616 MachineBasicBlock *BB = I.getParent();
1921 MachineBasicBlock *MBB = MI->getParent();
2003 MachineBasicBlock *MBB = MI->getParent();
2111 MachineBasicBlock *MBB = MI->getParent();
lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp 1820 MachineBasicBlock &OrigInsBB = B.getMBB();
1823 MachineBasicBlock &EntryMBB = B.getMF().front();
lib/Target/AMDGPU/AMDGPUMCInstLower.cpp 46 const MCExpr *getLongBranchBlockExpr(const MachineBasicBlock &SrcBB,
101 const MachineBasicBlock &SrcBB,
272 const MachineBasicBlock *MBB = MI->getParent();
273 MachineBasicBlock::const_instr_iterator I = ++MI->getIterator();
287 const MachineBasicBlock *MBB = MI->getOperand(0).getMBB();
396 const MachineBasicBlock *MBB = MI->getParent();
397 MachineBasicBlock::const_instr_iterator I = ++MI->getIterator();
lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp 56 using PHISourceT = std::pair<unsigned, MachineBasicBlock *>;
72 MachineBasicBlock *SourceMBB);
75 MachineBasicBlock *SourceMBB);
78 MachineBasicBlock *SourceMBB);
81 bool findSourcesFromMBB(MachineBasicBlock *SourceMBB,
87 MachineBasicBlock *SourceMBB);
89 MachineBasicBlock *SourceMBB = nullptr);
90 bool findDest(unsigned SourceReg, MachineBasicBlock *SourceMBB,
92 bool isSource(unsigned Reg, MachineBasicBlock *SourceMBB = nullptr);
145 MachineBasicBlock *SourceMBB) {
161 MachineBasicBlock *SourceMBB) {
188 MachineBasicBlock *SourceMBB) {
200 bool PHILinearize::findSourcesFromMBB(MachineBasicBlock *SourceMBB,
235 MachineBasicBlock *SourceMBB) {
240 MachineBasicBlock *SourceMBB) {
244 bool PHILinearize::findDest(unsigned SourceReg, MachineBasicBlock *SourceMBB,
255 bool PHILinearize::isSource(unsigned Reg, MachineBasicBlock *SourceMBB) {
307 static MachineBasicBlock *getPHIPred(MachineInstr &PHI, unsigned Index) {
313 MachineBasicBlock *NewPred) {
334 MachineBasicBlock *Entry;
337 MachineBasicBlock *Exit;
339 SmallPtrSet<MachineBasicBlock *, 1> MBBs;
344 void storeLiveOutReg(MachineBasicBlock *MBB, unsigned Reg,
354 void storeMBBLiveOuts(MachineBasicBlock *MBB, const MachineRegisterInfo *MRI,
358 void storeLiveOuts(MachineBasicBlock *MBB, const MachineRegisterInfo *MRI,
367 LinearizedRegion(MachineBasicBlock *MBB, const MachineRegisterInfo *MRI,
413 void setEntry(MachineBasicBlock *NewEntry);
415 MachineBasicBlock *getEntry();
417 void setExit(MachineBasicBlock *NewExit);
419 MachineBasicBlock *getExit();
421 void addMBB(MachineBasicBlock *MBB);
425 bool contains(MachineBasicBlock *MBB);
468 static MachineBasicBlock *
487 MachineBasicBlock *MBB;
490 MBBMRT(MachineBasicBlock *BB) : MBB(BB) {
498 MachineBasicBlock *getMBB() { return MBB; }
512 MachineBasicBlock *Succ = nullptr;
570 MachineBasicBlock *getEntry() {
576 MachineBasicBlock *getExit() {
582 void setSucc(MachineBasicBlock *MBB) { Succ = MBB; }
584 MachineBasicBlock *getSucc() { return Succ; }
586 bool contains(MachineBasicBlock *MBB) {
622 MachineBasicBlock *
625 for (auto &MFI : MF) {
626 MachineBasicBlock *ExitMBB = &MFI;
646 MachineBasicBlock *Exit = initializeMRT(MF, RegionInfo, RegionMap);
654 MachineBasicBlock *MBB = &(*MBBI);
692 void LinearizedRegion::storeLiveOutReg(MachineBasicBlock *MBB, unsigned Reg,
716 for (MachineBasicBlock::instr_iterator
750 void LinearizedRegion::storeLiveOuts(MachineBasicBlock *MBB,
769 for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
793 void LinearizedRegion::storeMBBLiveOuts(MachineBasicBlock *MBB,
817 MachineBasicBlock *Exit = Region->getSucc();
985 void LinearizedRegion::setEntry(MachineBasicBlock *NewEntry) {
989 MachineBasicBlock *LinearizedRegion::getEntry() { return Entry; }
991 void LinearizedRegion::setExit(MachineBasicBlock *NewExit) { Exit = NewExit; }
993 MachineBasicBlock *LinearizedRegion::getExit() { return Exit; }
995 void LinearizedRegion::addMBB(MachineBasicBlock *MBB) { MBBs.insert(MBB); }
1003 bool LinearizedRegion::contains(MachineBasicBlock *MBB) {
1022 MachineBasicBlock *MBB = MBBI;
1068 LinearizedRegion::LinearizedRegion(MachineBasicBlock *MBB,
1095 DenseMap<MachineBasicBlock *, MachineBasicBlock *> FallthroughMap;
1095 DenseMap<MachineBasicBlock *, MachineBasicBlock *> FallthroughMap;
1112 void extractKilledPHIs(MachineBasicBlock *MBB);
1118 MachineBasicBlock *SourceMBB,
1122 MachineBasicBlock *LastMerge,
1125 MachineBasicBlock *IfMBB,
1131 void rewriteRegionExitPHI(RegionMRT *Region, MachineBasicBlock *LastMerge,
1134 void rewriteRegionExitPHIs(RegionMRT *Region, MachineBasicBlock *LastMerge,
1136 void rewriteRegionEntryPHI(LinearizedRegion *Region, MachineBasicBlock *IfMBB,
1139 MachineBasicBlock *IfMBB);
1145 void eliminateDeadBranchOperands(MachineBasicBlock::instr_iterator &II);
1147 void insertUnconditionalBranch(MachineBasicBlock *MBB,
1148 MachineBasicBlock *Dest,
1151 MachineBasicBlock *createLinearizedExitBlock(RegionMRT *Region);
1153 void insertMergePHI(MachineBasicBlock *IfBB, MachineBasicBlock *CodeBB,
1153 void insertMergePHI(MachineBasicBlock *IfBB, MachineBasicBlock *CodeBB,
1154 MachineBasicBlock *MergeBB, unsigned DestRegister,
1158 MachineBasicBlock *createIfBlock(MachineBasicBlock *MergeBB,
1158 MachineBasicBlock *createIfBlock(MachineBasicBlock *MergeBB,
1159 MachineBasicBlock *CodeBBStart,
1160 MachineBasicBlock *CodeBBEnd,
1161 MachineBasicBlock *SelectBB, unsigned IfReg,
1164 void prunePHIInfo(MachineBasicBlock *MBB);
1168 void resolvePHIInfos(MachineBasicBlock *FunctionEntry);
1172 MachineBasicBlock *createIfRegion(MachineBasicBlock *MergeBB,
1172 MachineBasicBlock *createIfRegion(MachineBasicBlock *MergeBB,
1173 MachineBasicBlock *CodeBB,
1178 MachineBasicBlock *
1179 createIfRegion(MachineBasicBlock *MergeMBB, LinearizedRegion *InnerRegion,
1180 LinearizedRegion *CurrentRegion, MachineBasicBlock *SelectBB,
1184 void rewriteCodeBBTerminator(MachineBasicBlock *CodeBB,
1185 MachineBasicBlock *MergeBB,
1189 void insertChainedPHI(MachineBasicBlock *IfBB, MachineBasicBlock *CodeBB,
1189 void insertChainedPHI(MachineBasicBlock *IfBB, MachineBasicBlock *CodeBB,
1190 MachineBasicBlock *MergeBB,
1193 bool containsDef(MachineBasicBlock *MBB, LinearizedRegion *InnerRegion,
1195 void rewriteLiveOutRegs(MachineBasicBlock *IfBB, MachineBasicBlock *CodeBB,
1195 void rewriteLiveOutRegs(MachineBasicBlock *IfBB, MachineBasicBlock *CodeBB,
1196 MachineBasicBlock *MergeBB,
1200 void splitLoopPHI(MachineInstr &PHI, MachineBasicBlock *Entry,
1201 MachineBasicBlock *EntrySucc, LinearizedRegion *LRegion);
1202 void splitLoopPHIs(MachineBasicBlock *Entry, MachineBasicBlock *EntrySucc,
1202 void splitLoopPHIs(MachineBasicBlock *Entry, MachineBasicBlock *EntrySucc,
1205 MachineBasicBlock *splitExit(LinearizedRegion *LRegion);
1207 MachineBasicBlock *splitEntry(LinearizedRegion *LRegion);
1249 MachineBasicBlock *Entry = Region->getEntry();
1250 MachineBasicBlock *Succ = Region->getSucc();
1258 for (MachineBasicBlock::const_succ_iterator SI = Entry->succ_begin(),
1261 MachineBasicBlock *Current = *SI;
1275 MachineBasicBlock *Entry = Region->getEntry();
1276 MachineBasicBlock *Exit = Region->getExit();
1280 static void fixMBBTerminator(MachineBasicBlock *MBB) {
1282 auto *Succ = *(MBB->succ_begin());
1294 MachineBasicBlock *InternalSucc = nullptr;
1295 MachineBasicBlock *ExternalSucc = nullptr;
1299 SmallPtrSet<MachineBasicBlock *, 2> Successors;
1300 for (MachineBasicBlock::const_succ_iterator SI = Exit->succ_begin(),
1303 MachineBasicBlock *Succ = *SI;
1358 MachineBasicBlock *Pred = getPHIPred(PHI, i);
1370 MachineBasicBlock *Pred = getPHIPred(PHI, i);
1382 MachineBasicBlock *Pred = getPHIPred(PHI, i);
1414 void AMDGPUMachineCFGStructurizer::extractKilledPHIs(MachineBasicBlock *MBB) {
1418 for (MachineBasicBlock::instr_iterator I = MBB->instr_begin(),
1454 MachineBasicBlock *SourceMBB,
1483 MachineBasicBlock *MBB = PHI.getParent();
1499 MachineBasicBlock *SourcePred = getPHIPred(PHI, i);
1512 MachineInstr &PHI, unsigned CombinedSourceReg, MachineBasicBlock *LastMerge,
1528 MachineBasicBlock *MBB = PHI.getParent();
1541 MachineBasicBlock *SourcePred = getPHIPred(PHI, i);
1555 MachineInstr &PHI, unsigned CombinedSourceReg, MachineBasicBlock *IfMBB,
1577 MachineBasicBlock *MBB = PHI.getParent();
1591 MachineBasicBlock *SourcePred = getPHIPred(PHI, i);
1612 MachineBasicBlock *DefMBB = getDefInstr(Reg)->getParent();
1634 MachineBasicBlock *LastMerge,
1647 MachineBasicBlock *IfMBB,
1656 static void collectPHIs(MachineBasicBlock *MBB,
1666 MachineBasicBlock *LastMerge,
1681 MachineBasicBlock *IfMBB) {
1692 void AMDGPUMachineCFGStructurizer::insertUnconditionalBranch(MachineBasicBlock *MBB,
1693 MachineBasicBlock *Dest,
1697 MachineBasicBlock::instr_iterator Terminator = MBB->getFirstInstrTerminator();
1707 static MachineBasicBlock *getSingleExitNode(MachineFunction &MF) {
1708 MachineBasicBlock *result = nullptr;
1709 for (auto &MFI : MF) {
1726 MachineBasicBlock *
1736 MachineBasicBlock *LastMerge = MF->CreateMachineBasicBlock();
1751 void AMDGPUMachineCFGStructurizer::insertMergePHI(MachineBasicBlock *IfBB,
1752 MachineBasicBlock *CodeBB,
1753 MachineBasicBlock *MergeBB,
1781 static void removeExternalCFGSuccessors(MachineBasicBlock *MBB) {
1782 for (MachineBasicBlock::succ_iterator PI = MBB->succ_begin(),
1791 static void removeExternalCFGEdges(MachineBasicBlock *StartMBB,
1792 MachineBasicBlock *EndMBB) {
1797 DenseSet<std::pair<MachineBasicBlock *, MachineBasicBlock *>> Succs;
1797 DenseSet<std::pair<MachineBasicBlock *, MachineBasicBlock *>> Succs;
1800 MachineBasicBlock *StartMBBSucc = *(StartMBB->succ_begin());
1801 for (MachineBasicBlock::succ_iterator PI = EndMBB->succ_begin(),
1814 for (MachineBasicBlock::pred_iterator PI = StartMBB->pred_begin(),
1824 std::pair<MachineBasicBlock *, MachineBasicBlock *> Edge = SI;
1824 std::pair<MachineBasicBlock *, MachineBasicBlock *> Edge = SI;
1831 MachineBasicBlock *AMDGPUMachineCFGStructurizer::createIfBlock(
1832 MachineBasicBlock *MergeBB, MachineBasicBlock *CodeBBStart,
1832 MachineBasicBlock *MergeBB, MachineBasicBlock *CodeBBStart,
1833 MachineBasicBlock *CodeBBEnd, MachineBasicBlock *SelectBB, unsigned IfReg,
1833 MachineBasicBlock *CodeBBEnd, MachineBasicBlock *SelectBB, unsigned IfReg,
1836 MachineBasicBlock *IfBB = MF->CreateMachineBasicBlock();
1839 for (MachineBasicBlock::pred_iterator PI = CodeBBStart->pred_begin(),
1843 MachineBasicBlock *Pred = (*PI);
1868 MachineBasicBlock *SinglePred =
1901 void AMDGPUMachineCFGStructurizer::rewriteCodeBBTerminator(MachineBasicBlock *CodeBB,
1902 MachineBasicBlock *MergeBB,
1904 MachineBasicBlock *TrueBB = nullptr;
1905 MachineBasicBlock *FalseBB = nullptr;
1907 MachineBasicBlock *FallthroughBB = FallthroughMap[CodeBB];
1968 void AMDGPUMachineCFGStructurizer::insertChainedPHI(MachineBasicBlock *IfBB,
1969 MachineBasicBlock *CodeBB,
1970 MachineBasicBlock *MergeBB,
2019 bool AMDGPUMachineCFGStructurizer::containsDef(MachineBasicBlock *MBB,
2026 void AMDGPUMachineCFGStructurizer::rewriteLiveOutRegs(MachineBasicBlock *IfBB,
2027 MachineBasicBlock *CodeBB,
2028 MachineBasicBlock *MergeBB,
2093 void AMDGPUMachineCFGStructurizer::prunePHIInfo(MachineBasicBlock *MBB) {
2096 SmallVector<std::tuple<unsigned, unsigned, MachineBasicBlock *>, 4>
2120 MachineBasicBlock *SourceMBB = Source.second;
2141 MachineBasicBlock *Entry = CurrentRegion->getEntry();
2142 MachineBasicBlock *Exit = CurrentRegion->getExit();
2174 MachineBasicBlock *PHIDefMBB = PHIDefInstr->getParent();
2259 void AMDGPUMachineCFGStructurizer::resolvePHIInfos(MachineBasicBlock *FunctionEntry) {
2277 static bool isFunctionEntryBlock(MachineBasicBlock *MBB) {
2281 MachineBasicBlock *AMDGPUMachineCFGStructurizer::createIfRegion(
2282 MachineBasicBlock *MergeBB, MachineBasicBlock *CodeBB,
2282 MachineBasicBlock *MergeBB, MachineBasicBlock *CodeBB,
2317 MachineBasicBlock *IfBB = createIfBlock(MergeBB, CodeBB, CodeBB, CodeBB,
2326 MachineBasicBlock *RegionExit = CurrentRegion->getExit();
2327 MachineBasicBlock *ETrueBB = nullptr;
2328 MachineBasicBlock *EFalseBB = nullptr;
2370 MachineBasicBlock *AMDGPUMachineCFGStructurizer::createIfRegion(
2371 MachineBasicBlock *MergeBB, LinearizedRegion *InnerRegion,
2372 LinearizedRegion *CurrentRegion, MachineBasicBlock *SelectBB,
2376 MachineBasicBlock *CodeEntryBB = InnerRegion->getEntry();
2377 MachineBasicBlock *CodeExitBB = InnerRegion->getExit();
2378 MachineBasicBlock *IfBB = createIfBlock(MergeBB, CodeEntryBB, CodeExitBB,
2385 MachineBasicBlock *RegionExit = CurrentRegion->getExit();
2386 MachineBasicBlock *ETrueBB = nullptr;
2387 MachineBasicBlock *EFalseBB = nullptr;
2431 MachineBasicBlock *Entry,
2432 MachineBasicBlock *EntrySucc,
2441 MachineBasicBlock *RegionSourceMBB = getPHIPred(PHI, RegionIndex);
2468 void AMDGPUMachineCFGStructurizer::splitLoopPHIs(MachineBasicBlock *Entry,
2469 MachineBasicBlock *EntrySucc,
2480 MachineBasicBlock *
2521 static MachineBasicBlock *split(MachineBasicBlock::iterator I) {
2521 static MachineBasicBlock *split(MachineBasicBlock::iterator I) {
2523 MachineBasicBlock *MBB = (*I).getParent();
2525 MachineBasicBlock *SuccMBB = MF->CreateMachineBasicBlock();
2541 MachineBasicBlock *
2543 MachineBasicBlock *Entry = LRegion->getEntry();
2544 MachineBasicBlock *EntrySucc = split(Entry->getFirstNonPHI());
2545 MachineBasicBlock *Exit = LRegion->getExit();
2578 MachineBasicBlock *Exit = Region->getSucc();
2582 for (MachineBasicBlock::pred_iterator PI = Exit->pred_begin(),
2591 static bool mbbHasBackEdge(MachineBasicBlock *MBB,
2592 SmallPtrSet<MachineBasicBlock *, 8> &MBBs) {
2602 SmallPtrSet<MachineBasicBlock *, 8> &MBBs) {
2608 MachineBasicBlock *MBB = Tree->getMBBMRT()->getMBB();
2625 SmallPtrSet<MachineBasicBlock *, 8> MBBs;
2632 MachineBasicBlock *LastMerge = createLinearizedExitBlock(Region);
2633 MachineBasicBlock *CurrentMerge = LastMerge;
2672 MachineBasicBlock *InnerEntry = InnerLRegion->getEntry();
2693 MachineBasicBlock *IfEnd = CurrentMerge;
2699 MachineBasicBlock *MBB = Child->getMBBMRT()->getMBB();
2717 MachineBasicBlock *IfEnd = CurrentMerge;
2733 MachineBasicBlock *NewSucc = splitEntry(LRegion);
2804 for (auto &MBBI : MF) {
2805 MachineBasicBlock *MBB = MBBI.getFallThrough();
2858 for (auto &MBBI : MF) {
2859 for (MachineBasicBlock::instr_iterator I = MBBI.instr_begin(),
lib/Target/AMDGPU/AMDGPUMacroFusion.cpp 44 const MachineBasicBlock &MBB = *FirstMI->getParent();
lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp 663 iterator_range<MachineBasicBlock::iterator> Range,
670 MachineBasicBlock &MBB = B.getMBB();
711 MachineBasicBlock *LoopBB = MF->CreateMachineBasicBlock();
712 MachineBasicBlock *RemainderBB = MF->CreateMachineBasicBlock();
713 MachineBasicBlock *RestoreExecBB = MF->CreateMachineBasicBlock();
759 MachineBasicBlock::iterator I = Range.begin();
986 MachineBasicBlock::iterator I = MI.getIterator();
lib/Target/AMDGPU/AMDGPURegisterBankInfo.h 55 iterator_range<MachineBasicBlock::iterator> Range,
lib/Target/AMDGPU/AMDILCFGStructurizer.cpp 118 using MBBVector = SmallVector<MachineBasicBlock *, 32>;
119 using MBBInfoMap = std::map<MachineBasicBlock *, BlockInformation *>;
120 using LoopLandInfoMap = std::map<MachineLoop *, MachineBasicBlock *>;
203 int getSCCNum(MachineBasicBlock *MBB) const;
204 MachineBasicBlock *getLoopLandInfo(MachineLoop *LoopRep) const;
205 bool hasBackEdge(MachineBasicBlock *MBB) const;
206 bool isRetiredBlock(MachineBasicBlock *MBB) const;
207 bool isActiveLoophead(MachineBasicBlock *MBB) const;
208 PathToKind singlePathTo(MachineBasicBlock *SrcMBB, MachineBasicBlock *DstMBB,
208 PathToKind singlePathTo(MachineBasicBlock *SrcMBB, MachineBasicBlock *DstMBB,
212 bool needMigrateBlock(MachineBasicBlock *MBB) const;
215 void reversePredicateSetter(MachineBasicBlock::iterator I,
221 void insertInstrEnd(MachineBasicBlock *MBB, int NewOpcode,
223 MachineInstr *insertInstrBefore(MachineBasicBlock *MBB, int NewOpcode,
225 MachineInstr *insertInstrBefore(MachineBasicBlock::iterator I, int NewOpcode);
226 void insertCondBranchBefore(MachineBasicBlock::iterator I, int NewOpcode,
228 void insertCondBranchBefore(MachineBasicBlock *MBB,
229 MachineBasicBlock::iterator I, int NewOpcode,
236 static MachineBasicBlock *getTrueBranch(MachineInstr *MI);
237 static void setTrueBranch(MachineInstr *MI, MachineBasicBlock *MBB);
238 static MachineBasicBlock *getFalseBranch(MachineBasicBlock *MBB,
238 static MachineBasicBlock *getFalseBranch(MachineBasicBlock *MBB,
242 static DebugLoc getLastDebugLocInBB(MachineBasicBlock *MBB);
243 static MachineInstr *getNormalBlockBranchInstr(MachineBasicBlock *MBB);
249 MachineInstr *getLoopendBlockBranchInstr(MachineBasicBlock *MBB);
251 static MachineInstr *getReturnInstr(MachineBasicBlock *MBB);
252 static bool isReturnBlock(MachineBasicBlock *MBB);
253 static void cloneSuccessorList(MachineBasicBlock *DstMBB,
254 MachineBasicBlock *SrcMBB);
255 static MachineBasicBlock *clone(MachineBasicBlock *MBB);
255 static MachineBasicBlock *clone(MachineBasicBlock *MBB);
260 void replaceInstrUseOfBlockWith(MachineBasicBlock *SrcMBB,
261 MachineBasicBlock *OldMBB, MachineBasicBlock *NewBlk);
261 MachineBasicBlock *OldMBB, MachineBasicBlock *NewBlk);
263 static void wrapup(MachineBasicBlock *MBB);
265 int patternMatch(MachineBasicBlock *MBB);
266 int patternMatchGroup(MachineBasicBlock *MBB);
267 int serialPatternMatch(MachineBasicBlock *MBB);
268 int ifPatternMatch(MachineBasicBlock *MBB);
275 bool isSameloopDetachedContbreak(MachineBasicBlock *Src1MBB,
276 MachineBasicBlock *Src2MBB);
277 int handleJumpintoIf(MachineBasicBlock *HeadMBB,
278 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB);
278 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB);
279 int handleJumpintoIfImp(MachineBasicBlock *HeadMBB,
280 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB);
280 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB);
281 int improveSimpleJumpintoIf(MachineBasicBlock *HeadMBB,
282 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB,
282 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB,
283 MachineBasicBlock **LandMBBPtr);
284 void showImproveSimpleJumpintoIf(MachineBasicBlock *HeadMBB,
285 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB,
285 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB,
286 MachineBasicBlock *LandMBB, bool Detail = false);
287 int cloneOnSideEntryTo(MachineBasicBlock *PreMBB,
288 MachineBasicBlock *SrcMBB, MachineBasicBlock *DstMBB);
288 MachineBasicBlock *SrcMBB, MachineBasicBlock *DstMBB);
289 void mergeSerialBlock(MachineBasicBlock *DstMBB,
290 MachineBasicBlock *SrcMBB);
293 MachineBasicBlock *MBB, MachineBasicBlock *TrueMBB,
293 MachineBasicBlock *MBB, MachineBasicBlock *TrueMBB,
294 MachineBasicBlock *FalseMBB, MachineBasicBlock *LandMBB);
294 MachineBasicBlock *FalseMBB, MachineBasicBlock *LandMBB);
295 void mergeLooplandBlock(MachineBasicBlock *DstMBB,
296 MachineBasicBlock *LandMBB);
297 void mergeLoopbreakBlock(MachineBasicBlock *ExitingMBB,
298 MachineBasicBlock *LandMBB);
299 void settleLoopcontBlock(MachineBasicBlock *ContingMBB,
300 MachineBasicBlock *ContMBB);
310 MachineBasicBlock *normalizeInfiniteLoopExit(MachineLoop *LoopRep);
311 void removeUnconditionalBranch(MachineBasicBlock *MBB);
321 void removeRedundantConditionalBranch(MachineBasicBlock *MBB);
323 void addDummyExitBlock(SmallVectorImpl<MachineBasicBlock *> &RetMBB);
324 void removeSuccessor(MachineBasicBlock *MBB);
325 MachineBasicBlock *cloneBlockForPredecessor(MachineBasicBlock *MBB,
325 MachineBasicBlock *cloneBlockForPredecessor(MachineBasicBlock *MBB,
326 MachineBasicBlock *PredMBB);
327 void migrateInstruction(MachineBasicBlock *SrcMBB,
328 MachineBasicBlock *DstMBB, MachineBasicBlock::iterator I);
328 MachineBasicBlock *DstMBB, MachineBasicBlock::iterator I);
329 void recordSccnum(MachineBasicBlock *MBB, int SCCNum);
330 void retireBlock(MachineBasicBlock *MBB);
337 SmallVector<MachineBasicBlock *, DEFAULT_VEC_SLOTS> OrderedBlks;
344 int AMDGPUCFGStructurizer::getSCCNum(MachineBasicBlock *MBB) const {
351 MachineBasicBlock *AMDGPUCFGStructurizer::getLoopLandInfo(MachineLoop *LoopRep)
359 bool AMDGPUCFGStructurizer::hasBackEdge(MachineBasicBlock *MBB) const {
363 MachineBasicBlock *LoopHeader = LoopRep->getHeader();
367 bool AMDGPUCFGStructurizer::isRetiredBlock(MachineBasicBlock *MBB) const {
374 bool AMDGPUCFGStructurizer::isActiveLoophead(MachineBasicBlock *MBB) const {
377 MachineBasicBlock *LoopLand = getLoopLandInfo(LoopRep);
388 MachineBasicBlock *SrcMBB, MachineBasicBlock *DstMBB,
388 MachineBasicBlock *SrcMBB, MachineBasicBlock *DstMBB,
416 bool AMDGPUCFGStructurizer::needMigrateBlock(MachineBasicBlock *MBB) const {
429 MachineBasicBlock::iterator I, MachineBasicBlock &MBB) {
455 void AMDGPUCFGStructurizer::insertInstrEnd(MachineBasicBlock *MBB,
464 MachineInstr *AMDGPUCFGStructurizer::insertInstrBefore(MachineBasicBlock *MBB,
478 MachineBasicBlock::iterator I, int NewOpcode) {
480 MachineBasicBlock *MBB = OldMI->getParent();
490 MachineBasicBlock::iterator I, int NewOpcode, const DebugLoc &DL) {
492 MachineBasicBlock *MBB = OldMI->getParent();
503 MachineBasicBlock *blk, MachineBasicBlock::iterator I, int NewOpcode,
503 MachineBasicBlock *blk, MachineBasicBlock::iterator I, int NewOpcode,
553 MachineBasicBlock *AMDGPUCFGStructurizer::getTrueBranch(MachineInstr *MI) {
558 MachineBasicBlock *MBB) {
562 MachineBasicBlock *
563 AMDGPUCFGStructurizer::getFalseBranch(MachineBasicBlock *MBB,
566 MachineBasicBlock *TrueBranch = getTrueBranch(MI);
567 MachineBasicBlock::succ_iterator It = MBB->succ_begin();
568 MachineBasicBlock::succ_iterator Next = It;
595 DebugLoc AMDGPUCFGStructurizer::getLastDebugLocInBB(MachineBasicBlock *MBB) {
598 for (MachineBasicBlock::iterator It = MBB->begin(); It != MBB->end();
608 MachineBasicBlock *MBB) {
609 MachineBasicBlock::reverse_iterator It = MBB->rbegin();
617 MachineBasicBlock *MBB) {
618 for (MachineBasicBlock::reverse_iterator It = MBB->rbegin(), E = MBB->rend();
632 MachineInstr *AMDGPUCFGStructurizer::getReturnInstr(MachineBasicBlock *MBB) {
633 MachineBasicBlock::reverse_iterator It = MBB->rbegin();
642 bool AMDGPUCFGStructurizer::isReturnBlock(MachineBasicBlock *MBB) {
653 void AMDGPUCFGStructurizer::cloneSuccessorList(MachineBasicBlock *DstMBB,
654 MachineBasicBlock *SrcMBB) {
655 for (MachineBasicBlock::succ_iterator It = SrcMBB->succ_begin(),
660 MachineBasicBlock *AMDGPUCFGStructurizer::clone(MachineBasicBlock *MBB) {
660 MachineBasicBlock *AMDGPUCFGStructurizer::clone(MachineBasicBlock *MBB) {
662 MachineBasicBlock *NewMBB = Func->CreateMachineBasicBlock();
670 MachineBasicBlock *SrcMBB, MachineBasicBlock *OldMBB,
670 MachineBasicBlock *SrcMBB, MachineBasicBlock *OldMBB,
671 MachineBasicBlock *NewBlk) {
678 void AMDGPUCFGStructurizer::wrapup(MachineBasicBlock *MBB) {
685 MachineBasicBlock::iterator Pre = MBB->begin();
686 MachineBasicBlock::iterator E = MBB->end();
687 MachineBasicBlock::iterator It = Pre;
715 SmallVector<MachineBasicBlock *, DEFAULT_VEC_SLOTS> RetBlks;
725 MachineBasicBlock* DummyExitBlk = normalizeInfiniteLoopExit(LoopRep);
733 for (SmallVectorImpl<MachineBasicBlock *>::const_iterator
735 MachineBasicBlock *MBB = *It;
764 MachineBasicBlock *MBB;
774 SmallVectorImpl<MachineBasicBlock *>::const_iterator It =
776 SmallVectorImpl<MachineBasicBlock *>::const_iterator E =
779 SmallVectorImpl<MachineBasicBlock *>::const_iterator SccBeginIter =
781 MachineBasicBlock *SccBeginMBB = nullptr;
833 MachineBasicBlock *EntryMBB =
878 MachineBasicBlock *MBB;
881 const std::vector<MachineBasicBlock *> &SccNext = *It;
882 for (std::vector<MachineBasicBlock *>::const_iterator
892 for (auto *MBB : nodes(MF)) {
899 int AMDGPUCFGStructurizer::patternMatch(MachineBasicBlock *MBB) {
914 int AMDGPUCFGStructurizer::patternMatchGroup(MachineBasicBlock *MBB) {
922 int AMDGPUCFGStructurizer::serialPatternMatch(MachineBasicBlock *MBB) {
926 MachineBasicBlock *childBlk = *MBB->succ_begin();
935 int AMDGPUCFGStructurizer::ifPatternMatch(MachineBasicBlock *MBB) {
948 MachineBasicBlock *TrueMBB = getTrueBranch(BranchMI);
951 MachineBasicBlock *FalseMBB = getFalseBranch(MBB, BranchMI);
954 MachineBasicBlock *LandBlk;
1039 MachineBasicBlock *LoopHeader = LoopRep->getHeader();
1048 SmallPtrSet<MachineBasicBlock *, 2> ExitBlkSet;
1052 MachineBasicBlock *ExitBlk = *ExitBlks.begin();
1055 for (auto *LB : inverse_children<MachineBasicBlock*>(LoopHeader))
1055 for (auto *LB : inverse_children<MachineBasicBlock*>(LoopHeader))
1080 MachineBasicBlock *Src1MBB, MachineBasicBlock *Src2MBB) {
1080 MachineBasicBlock *Src1MBB, MachineBasicBlock *Src2MBB) {
1084 MachineBasicBlock *&TheEntry = LLInfoMap[LoopRep];
1096 int AMDGPUCFGStructurizer::handleJumpintoIf(MachineBasicBlock *HeadMBB,
1097 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB) {
1097 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB) {
1107 int AMDGPUCFGStructurizer::handleJumpintoIfImp(MachineBasicBlock *HeadMBB,
1108 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB) {
1108 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB) {
1110 MachineBasicBlock *DownBlk;
1146 MachineBasicBlock *HeadMBB, MachineBasicBlock *TrueMBB,
1146 MachineBasicBlock *HeadMBB, MachineBasicBlock *TrueMBB,
1147 MachineBasicBlock *FalseMBB, MachineBasicBlock *LandMBB, bool Detail) {
1147 MachineBasicBlock *FalseMBB, MachineBasicBlock *LandMBB, bool Detail) {
1188 int AMDGPUCFGStructurizer::improveSimpleJumpintoIf(MachineBasicBlock *HeadMBB,
1189 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB,
1189 MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB,
1190 MachineBasicBlock **LandMBBPtr) {
1194 MachineBasicBlock *LandBlk = *LandMBBPtr;
1306 MachineBasicBlock::iterator I = insertInstrBefore(LandBlk, R600::ENDIF);
1346 for (MachineBasicBlock::pred_iterator PI = LandBlk->pred_begin(),
1348 MachineBasicBlock *MBB = *PI;
1363 void AMDGPUCFGStructurizer::mergeSerialBlock(MachineBasicBlock *DstMBB,
1364 MachineBasicBlock *SrcMBB) {
1378 MachineBasicBlock *MBB, MachineBasicBlock *TrueMBB,
1378 MachineBasicBlock *MBB, MachineBasicBlock *TrueMBB,
1379 MachineBasicBlock *FalseMBB, MachineBasicBlock *LandMBB) {
1379 MachineBasicBlock *FalseMBB, MachineBasicBlock *LandMBB) {
1402 MachineBasicBlock::iterator I = BranchMI;
1433 void AMDGPUCFGStructurizer::mergeLooplandBlock(MachineBasicBlock *DstBlk,
1434 MachineBasicBlock *LandMBB) {
1443 void AMDGPUCFGStructurizer::mergeLoopbreakBlock(MachineBasicBlock *ExitingMBB,
1444 MachineBasicBlock *LandMBB) {
1451 MachineBasicBlock *TrueBranch = getTrueBranch(BranchMI);
1452 MachineBasicBlock::iterator I = BranchMI;
1464 void AMDGPUCFGStructurizer::settleLoopcontBlock(MachineBasicBlock *ContingMBB,
1465 MachineBasicBlock *ContMBB) {
1473 MachineBasicBlock::iterator I = MI;
1474 MachineBasicBlock *TrueBranch = getTrueBranch(MI);
1507 int AMDGPUCFGStructurizer::cloneOnSideEntryTo(MachineBasicBlock *PreMBB,
1508 MachineBasicBlock *SrcMBB, MachineBasicBlock *DstMBB) {
1508 MachineBasicBlock *SrcMBB, MachineBasicBlock *DstMBB) {
1525 MachineBasicBlock *
1526 AMDGPUCFGStructurizer::cloneBlockForPredecessor(MachineBasicBlock *MBB,
1527 MachineBasicBlock *PredMBB) {
1531 MachineBasicBlock *CloneMBB = clone(MBB); //clone instructions
1551 void AMDGPUCFGStructurizer::migrateInstruction(MachineBasicBlock *SrcMBB,
1552 MachineBasicBlock *DstMBB, MachineBasicBlock::iterator I) {
1552 MachineBasicBlock *DstMBB, MachineBasicBlock::iterator I) {
1553 MachineBasicBlock::iterator SpliceEnd;
1575 MachineBasicBlock *
1577 MachineBasicBlock *LoopHeader = LoopRep->getHeader();
1578 MachineBasicBlock *LoopLatch = LoopRep->getLoopLatch();
1587 MachineBasicBlock *DummyExitBlk = FuncRep->CreateMachineBasicBlock();
1596 void AMDGPUCFGStructurizer::removeUnconditionalBranch(MachineBasicBlock *MBB) {
1609 MachineBasicBlock *MBB) {
1612 MachineBasicBlock *MBB1 = *MBB->succ_begin();
1613 MachineBasicBlock *MBB2 = *std::next(MBB->succ_begin());
1626 SmallVectorImpl<MachineBasicBlock*> &RetMBB) {
1627 MachineBasicBlock *DummyExitBlk = FuncRep->CreateMachineBasicBlock();
1631 for (SmallVectorImpl<MachineBasicBlock *>::iterator It = RetMBB.begin(),
1633 MachineBasicBlock *MBB = *It;
1644 void AMDGPUCFGStructurizer::removeSuccessor(MachineBasicBlock *MBB) {
1649 void AMDGPUCFGStructurizer::recordSccnum(MachineBasicBlock *MBB,
1657 void AMDGPUCFGStructurizer::retireBlock(MachineBasicBlock *MBB) {
lib/Target/AMDGPU/GCNDPPCombine.cpp 515 auto *BB = OrigMI.getParent();
565 for (auto &MBB : MF) {
lib/Target/AMDGPU/GCNHazardRecognizer.cpp 206 MachineBasicBlock::instr_iterator MI = std::next(CurrCycleInstr->getIterator());
207 MachineBasicBlock::instr_iterator E = CurrCycleInstr->getParent()->instr_end();
362 MachineBasicBlock *MBB,
363 MachineBasicBlock::reverse_instr_iterator I,
366 DenseSet<const MachineBasicBlock *> &Visited) {
386 for (MachineBasicBlock *Pred : MBB->predecessors()) {
412 DenseSet<const MachineBasicBlock *> Visited;
lib/Target/AMDGPU/GCNIterativeScheduler.cpp 61 MachineBasicBlock::iterator Begin,
92 MachineBasicBlock::iterator Begin,
248 GCNIterativeScheduler::getRegionPressure(MachineBasicBlock::iterator Begin,
299 void GCNIterativeScheduler::enterRegion(MachineBasicBlock *BB, // overriden
300 MachineBasicBlock::iterator Begin,
lib/Target/AMDGPU/GCNIterativeScheduler.h 43 void enterRegion(MachineBasicBlock *BB,
44 MachineBasicBlock::iterator Begin,
61 MachineBasicBlock::iterator Begin;
63 const MachineBasicBlock::iterator End;
85 GCNRegPressure getRegionPressure(MachineBasicBlock::iterator Begin,
lib/Target/AMDGPU/GCNNSAReassign.cpp 241 for (const MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/GCNRegBankReassign.cpp 406 MachineBasicBlock::const_instr_iterator Def(MI.getIterator());
407 MachineBasicBlock::const_instr_iterator B(MI.getParent()->instr_begin());
686 for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/GCNRegPressure.cpp 429 bool GCNDownwardRPTracker::advance(MachineBasicBlock::const_iterator End) {
435 bool GCNDownwardRPTracker::advance(MachineBasicBlock::const_iterator Begin,
lib/Target/AMDGPU/GCNRegPressure.h 154 MachineBasicBlock::const_iterator NextMI;
156 MachineBasicBlock::const_iterator MBBEnd;
161 const MachineBasicBlock::const_iterator getNext() const { return NextMI; }
179 bool advance(MachineBasicBlock::const_iterator End);
182 bool advance(MachineBasicBlock::const_iterator Begin,
lib/Target/AMDGPU/GCNSchedStrategy.cpp 440 void GCNScheduleDAGMILive::computeBlockPressure(const MachineBasicBlock *MBB) {
446 const MachineBasicBlock *OnlySucc = nullptr;
509 auto *BB = I->first->getParent();
533 MachineBasicBlock *MBB = nullptr;
lib/Target/AMDGPU/GCNSchedStrategy.h 84 SmallVector<std::pair<MachineBasicBlock::iterator,
94 DenseMap<const MachineBasicBlock*, GCNRPTracker::LiveRegSet> MBBLiveIns;
103 void computeBlockPressure(const MachineBasicBlock *MBB);
lib/Target/AMDGPU/R600AsmPrinter.cpp 51 for (const MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/R600ClauseMergePass.cpp 101 MachineBasicBlock::iterator I = CFAlu, E = CFAlu.getParent()->end();
191 MachineBasicBlock &MBB = *BB;
192 MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
193 MachineBasicBlock::iterator LatestCFAlu = E;
lib/Target/AMDGPU/R600ControlFlowFinalizer.cpp 332 MakeFetchClause(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I)
332 MakeFetchClause(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I)
334 MachineBasicBlock::iterator ClauseHead = I;
339 for (MachineBasicBlock::iterator E = MBB.end(); I != E; ++I) {
394 MachineBasicBlock::iterator insertLiterals(
397 MachineBasicBlock *MBB = InsertPos->getParent();
410 MakeALUClause(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I)
410 MakeALUClause(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I)
415 for (MachineBasicBlock::instr_iterator E = MBB.instr_end(); I != E;) {
425 MachineBasicBlock::instr_iterator BI = I.getInstrIterator();
468 void EmitFetchClause(MachineBasicBlock::iterator InsertPos,
472 MachineBasicBlock *BB = Clause.first->getParent();
480 void EmitALUClause(MachineBasicBlock::iterator InsertPos, const DebugLoc &DL,
484 MachineBasicBlock *BB = Clause.first->getParent();
518 MachineBasicBlock &MBB = *MB;
531 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
541 MachineBasicBlock::iterator MI = I;
lib/Target/AMDGPU/R600EmitClauseMarkers.cpp 196 MachineBasicBlock::iterator Def,
210 for (MachineBasicBlock::iterator UseI = Def; UseI != BBEnd; ++UseI) {
242 MachineBasicBlock::iterator
244 MachineBasicBlock::iterator ClauseHead = I;
248 for (MachineBasicBlock::iterator E = MBB.end(); I != E; ++I) {
322 MachineBasicBlock &MBB = *BB;
323 MachineBasicBlock::iterator I = MBB.begin();
326 for (MachineBasicBlock::iterator E = MBB.end(); I != E;) {
lib/Target/AMDGPU/R600ExpandSpecialInstrs.cpp 90 MachineBasicBlock &MBB = *BB;
91 MachineBasicBlock::iterator I = MBB.begin();
lib/Target/AMDGPU/R600FrameLowering.h 24 MachineBasicBlock &MBB) const override {}
26 MachineBasicBlock &MBB) const override {}
lib/Target/AMDGPU/R600ISelLowering.cpp 283 static inline bool isEOP(MachineBasicBlock::iterator I) {
289 MachineBasicBlock *
291 MachineBasicBlock *BB) const {
294 MachineBasicBlock::iterator I = MI;
431 for (MachineBasicBlock::iterator NextExportInst = std::next(I),
lib/Target/AMDGPU/R600ISelLowering.h 32 MachineBasicBlock *
34 MachineBasicBlock *BB) const override;
66 void lowerImplicitParameter(MachineInstr *MI, MachineBasicBlock &BB,
lib/Target/AMDGPU/R600InstrInfo.cpp 61 void R600InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
62 MachineBasicBlock::iterator MI,
96 bool R600InstrInfo::isLegalToSplitMBBAt(MachineBasicBlock &MBB,
97 MachineBasicBlock::iterator MBBI) const {
652 findFirstPredicateSetterFrom(MachineBasicBlock &MBB,
653 MachineBasicBlock::iterator I) {
674 bool R600InstrInfo::analyzeBranch(MachineBasicBlock &MBB,
675 MachineBasicBlock *&TBB,
676 MachineBasicBlock *&FBB,
682 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
696 MachineBasicBlock::iterator PriorI = std::prev(I);
746 MachineBasicBlock::iterator FindLastAluClause(MachineBasicBlock &MBB) {
747 for (MachineBasicBlock::reverse_iterator It = MBB.rbegin(), E = MBB.rend();
756 unsigned R600InstrInfo::insertBranch(MachineBasicBlock &MBB,
757 MachineBasicBlock *TBB,
758 MachineBasicBlock *FBB,
778 MachineBasicBlock::iterator CfAlu = FindLastAluClause(MBB);
794 MachineBasicBlock::iterator CfAlu = FindLastAluClause(MBB);
803 unsigned R600InstrInfo::removeBranch(MachineBasicBlock &MBB,
810 MachineBasicBlock::iterator I = MBB.end();
823 MachineBasicBlock::iterator CfAlu = FindLastAluClause(MBB);
848 MachineBasicBlock::iterator CfAlu = FindLastAluClause(MBB);
900 R600InstrInfo::isProfitableToIfCvt(MachineBasicBlock &MBB,
908 R600InstrInfo::isProfitableToIfCvt(MachineBasicBlock &TMBB,
911 MachineBasicBlock &FMBB,
919 R600InstrInfo::isProfitableToDupForIfCvt(MachineBasicBlock &MBB,
927 R600InstrInfo::isProfitableToUnpredicate(MachineBasicBlock &TMBB,
928 MachineBasicBlock &FMBB) const {
1026 MachineBasicBlock *MBB = MI.getParent();
1113 MachineInstrBuilder R600InstrInfo::buildIndirectWrite(MachineBasicBlock *MBB,
1114 MachineBasicBlock::iterator I,
1120 MachineInstrBuilder R600InstrInfo::buildIndirectWrite(MachineBasicBlock *MBB,
1121 MachineBasicBlock::iterator I,
1145 MachineInstrBuilder R600InstrInfo::buildIndirectRead(MachineBasicBlock *MBB,
1146 MachineBasicBlock::iterator I,
1152 MachineInstrBuilder R600InstrInfo::buildIndirectRead(MachineBasicBlock *MBB,
1153 MachineBasicBlock::iterator I,
1237 MachineInstrBuilder R600InstrInfo::buildDefaultInstruction(MachineBasicBlock &MBB,
1238 MachineBasicBlock::iterator I,
1317 MachineBasicBlock &MBB, MachineInstr *MI, unsigned Slot, unsigned DstReg)
1325 MachineBasicBlock::iterator I = MI;
1364 MachineInstr *R600InstrInfo::buildMovImm(MachineBasicBlock &BB,
1365 MachineBasicBlock::iterator I,
1374 MachineInstr *R600InstrInfo::buildMovInstr(MachineBasicBlock *MBB,
1375 MachineBasicBlock::iterator I,
lib/Target/AMDGPU/R600InstrInfo.h 48 MachineInstrBuilder buildIndirectRead(MachineBasicBlock *MBB,
49 MachineBasicBlock::iterator I,
54 MachineInstrBuilder buildIndirectWrite(MachineBasicBlock *MBB,
55 MachineBasicBlock::iterator I,
75 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
75 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
78 bool isLegalToSplitMBBAt(MachineBasicBlock &MBB,
79 MachineBasicBlock::iterator MBBI) const override;
167 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
167 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
168 MachineBasicBlock *&FBB,
172 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
172 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
173 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
177 unsigned removeBranch(MachineBasicBlock &MBB,
184 bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
187 bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
191 bool isProfitableToIfCvt(MachineBasicBlock &TMBB,
193 MachineBasicBlock &FMBB,
200 bool isProfitableToUnpredicate(MachineBasicBlock &TMBB,
201 MachineBasicBlock &FMBB) const override;
244 MachineInstrBuilder buildIndirectWrite(MachineBasicBlock *MBB,
245 MachineBasicBlock::iterator I,
252 MachineInstrBuilder buildIndirectRead(MachineBasicBlock *MBB,
253 MachineBasicBlock::iterator I,
266 MachineInstrBuilder buildDefaultInstruction(MachineBasicBlock &MBB,
267 MachineBasicBlock::iterator I,
273 MachineInstr *buildSlotOfVectorInstruction(MachineBasicBlock &MBB,
278 MachineInstr *buildMovImm(MachineBasicBlock &BB,
279 MachineBasicBlock::iterator I,
283 MachineInstr *buildMovInstr(MachineBasicBlock *MBB,
284 MachineBasicBlock::iterator I,
lib/Target/AMDGPU/R600OptimizeVectorRegisters.cpp 201 MachineBasicBlock::iterator Pos = RSI->Instr;
202 MachineBasicBlock &MBB = *Pos->getParent();
343 MachineBasicBlock *MB = &*MBB;
348 for (MachineBasicBlock::iterator MII = MB->begin(), MIIE = MB->end();
lib/Target/AMDGPU/R600Packetizer.cpp 68 DenseMap<unsigned, unsigned> getPreviousVector(MachineBasicBlock::iterator I)
74 MachineBasicBlock::instr_iterator BI = I.getInstrIterator();
162 const MachineBasicBlock *MBB) override {
291 MachineBasicBlock::iterator addToPacket(MachineInstr &MI) override {
292 MachineBasicBlock::iterator FirstInBundle =
312 MachineBasicBlock::iterator It = VLIWPacketizerList::addToPacket(MI);
353 MachineBasicBlock::iterator End = MBB->end();
354 MachineBasicBlock::iterator MI = MBB->begin();
358 MachineBasicBlock::iterator DeleteMI = MI;
373 for(MachineBasicBlock::iterator RegionEnd = MBB->end();
377 MachineBasicBlock::iterator I = RegionEnd;
lib/Target/AMDGPU/R600RegisterInfo.cpp 108 void R600RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator MI,
lib/Target/AMDGPU/R600RegisterInfo.h 47 void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
lib/Target/AMDGPU/SIAddIMGInit.cpp 71 MachineBasicBlock &MBB = *BI;
72 MachineBasicBlock::iterator I, Next;
lib/Target/AMDGPU/SIFixSGPRCopies.cpp 357 bool searchPredecessors(const MachineBasicBlock *MBB,
358 const MachineBasicBlock *CutOff,
363 DenseSet<const MachineBasicBlock *> Visited;
364 SmallVector<MachineBasicBlock *, 4> Worklist(MBB->pred_begin(),
368 MachineBasicBlock *MBB = Worklist.pop_back_val();
388 const MachineBasicBlock *CutOff,
395 const MachineBasicBlock *MBBFrom = From->getParent();
396 const MachineBasicBlock *MBBTo = To->getParent();
408 static MachineBasicBlock::iterator
410 MachineBasicBlock::iterator I = MBB->getFirstNonPHI();
468 const MachineBasicBlock *MBBFrom = From->getParent();
469 const MachineBasicBlock *MBBTo = To->getParent();
515 auto *MBB = MDT.findNearestCommonDominator(MI1->getParent(),
522 MachineBasicBlock::iterator I = getFirstNonPrologue(MBB, TII);
562 MachineBasicBlock::reverse_iterator B(BoundaryMI);
599 MachineBasicBlock &MBB = *BI;
600 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
lib/Target/AMDGPU/SIFixVGPRCopies.cpp 54 for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIFixupVectorISel.cpp 155 static bool fixupGlobalSaddr(MachineBasicBlock &MBB,
164 MachineBasicBlock::iterator I, Next;
229 for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIFoldOperands.cpp 242 MachineBasicBlock *MBB = MI->getParent();
244 if (Liveness != MachineBasicBlock::LQR_Dead) {
691 MachineBasicBlock &MBB = *UseMI->getParent();
1459 for (MachineBasicBlock *MBB : depth_first(&MF)) {
1460 MachineBasicBlock::iterator I, Next;
lib/Target/AMDGPU/SIFormMemoryClauses.cpp 325 for (MachineBasicBlock &MBB : MF) {
326 MachineBasicBlock::instr_iterator Next;
lib/Target/AMDGPU/SIFrameLowering.cpp 92 static void buildPrologSpill(LivePhysRegs &LiveRegs, MachineBasicBlock &MBB,
93 MachineBasicBlock::iterator I,
140 static void buildEpilogReload(LivePhysRegs &LiveRegs, MachineBasicBlock &MBB,
141 MachineBasicBlock::iterator I,
189 MachineBasicBlock &MBB) const {
207 MachineBasicBlock::iterator I = MBB.begin();
393 MachineBasicBlock &MBB) const {
461 for (MachineBasicBlock &OtherBB : MF) {
473 MachineBasicBlock::iterator I = MBB.begin();
534 MachineFunction &MF, MachineBasicBlock &MBB, SIMachineFunctionInfo *MFI,
535 MachineBasicBlock::iterator I, unsigned PreloadedPrivateBufferReg,
683 MachineBasicBlock &MBB) const {
700 MachineBasicBlock::iterator MBBI = MBB.begin();
829 MachineBasicBlock &MBB) const {
837 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
1097 MachineBasicBlock::iterator SIFrameLowering::eliminateCallFramePseudoInstr(
lib/Target/AMDGPU/SIFrameLowering.h 29 MachineBasicBlock &MBB) const;
31 MachineBasicBlock &MBB) const override;
33 MachineBasicBlock &MBB) const override;
52 MachineBasicBlock::iterator
60 MachineBasicBlock &MBB) const;
75 MachineBasicBlock &MBB, SIMachineFunctionInfo *MFI,
76 MachineBasicBlock::iterator I, unsigned PreloadedPrivateBufferReg,
lib/Target/AMDGPU/SIISelLowering.cpp 1978 void SITargetLowering::initializeSplitCSR(MachineBasicBlock *Entry) const {
1983 MachineBasicBlock *Entry,
1984 const SmallVectorImpl<MachineBasicBlock *> &Exits) const {
1993 MachineBasicBlock::iterator MBBI = Entry->begin();
2010 for (auto *Exit : Exits)
3030 MachineBasicBlock *SITargetLowering::splitKillBlock(MachineInstr &MI,
3031 MachineBasicBlock *BB) const {
3034 MachineBasicBlock::iterator SplitPoint(&MI);
3044 MachineBasicBlock *SplitBB
3062 static std::pair<MachineBasicBlock *, MachineBasicBlock *>
3062 static std::pair<MachineBasicBlock *, MachineBasicBlock *>
3063 splitBlockForLoop(MachineInstr &MI, MachineBasicBlock &MBB, bool InstInLoop) {
3065 MachineBasicBlock::iterator I(&MI);
3069 MachineBasicBlock *LoopBB = MF->CreateMachineBasicBlock();
3070 MachineBasicBlock *RemainderBB = MF->CreateMachineBasicBlock();
3102 MachineBasicBlock *MBB = MI.getParent();
3114 MachineBasicBlock *
3116 MachineBasicBlock *BB) const {
3121 MachineBasicBlock *LoopBB;
3122 MachineBasicBlock *RemainderBB;
3131 MachineBasicBlock::iterator I = LoopBB->end();
3164 static MachineBasicBlock::iterator emitLoadM0FromVGPRLoop(
3181 MachineBasicBlock::iterator I = LoopBB.begin();
3270 static MachineBasicBlock::iterator loadM0FromVGPR(const SIInstrInfo *TII,
3283 MachineBasicBlock::iterator I(&MI);
3298 MachineBasicBlock *LoopBB;
3299 MachineBasicBlock *RemainderBB;
3308 MachineBasicBlock::iterator First = RemainderBB->begin();
3338 MachineBasicBlock *MBB = MI.getParent();
3340 MachineBasicBlock::iterator I(&MI);
3389 static MachineBasicBlock *emitIndirectSrc(MachineInstr &MI,
3390 MachineBasicBlock &MBB,
3410 MachineBasicBlock::iterator I(&MI);
3434 MachineBasicBlock::iterator I(&MI);
3443 MachineBasicBlock *LoopBB = InsPt->getParent();
3480 static MachineBasicBlock *emitIndirectDst(MachineInstr &MI,
3481 MachineBasicBlock &MBB,
3505 MachineBasicBlock::iterator I(&MI);
3520 MachineBasicBlock::iterator I(&MI);
3555 MachineBasicBlock *LoopBB = InsPt->getParent();
3580 MachineBasicBlock *SITargetLowering::EmitInstrWithCustomInserter(
3581 MachineInstr &MI, MachineBasicBlock *BB) const {
10713 MachineBasicBlock &MBB = MF.front();
10714 MachineBasicBlock::iterator I = MBB.getFirstNonDebugInstr();
10717 for (auto &MBB : MF) {
10762 const MachineBasicBlock *Header = ML->getHeader();
10767 for (const MachineBasicBlock *MBB : ML->blocks()) {
10789 if (MachineBasicBlock *Exit = P->getExitBlock()) {
10796 MachineBasicBlock *Pre = ML->getLoopPreheader();
10797 MachineBasicBlock *Exit = ML->getExitBlock();
lib/Target/AMDGPU/SIISelLowering.h 285 void initializeSplitCSR(MachineBasicBlock *Entry) const override;
287 MachineBasicBlock *Entry,
288 const SmallVectorImpl<MachineBasicBlock *> &Exits) const override;
335 MachineBasicBlock *splitKillBlock(MachineInstr &MI,
336 MachineBasicBlock *BB) const;
339 MachineBasicBlock *emitGWSMemViolTestLoop(MachineInstr &MI,
340 MachineBasicBlock *BB) const;
342 MachineBasicBlock *
344 MachineBasicBlock *BB) const override;
lib/Target/AMDGPU/SIInsertSkips.cpp 56 bool shouldSkip(const MachineBasicBlock &From,
57 const MachineBasicBlock &To) const;
59 bool skipIfDead(MachineInstr &MI, MachineBasicBlock &NextBB);
63 MachineBasicBlock *insertSkipBlock(MachineBasicBlock &MBB,
63 MachineBasicBlock *insertSkipBlock(MachineBasicBlock &MBB,
64 MachineBasicBlock::iterator I) const;
66 bool skipMaskBranch(MachineInstr &MI, MachineBasicBlock &MBB);
108 bool SIInsertSkips::shouldSkip(const MachineBasicBlock &From,
109 const MachineBasicBlock &To) const {
115 const MachineBasicBlock &MBB = *MBBI;
117 for (MachineBasicBlock::const_iterator I = MBB.begin(), E = MBB.end();
149 bool SIInsertSkips::skipIfDead(MachineInstr &MI, MachineBasicBlock &NextBB) {
150 MachineBasicBlock &MBB = *MI.getParent();
157 MachineBasicBlock *SkipBB = insertSkipBlock(MBB, MI.getIterator());
165 MachineBasicBlock::iterator Insert = SkipBB->begin();
185 MachineBasicBlock &MBB = *MI.getParent();
306 MachineBasicBlock *SIInsertSkips::insertSkipBlock(
307 MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const {
307 MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const {
310 MachineBasicBlock *SkipBB = MF->CreateMachineBasicBlock();
322 MachineBasicBlock &SrcMBB) {
323 MachineBasicBlock *DestBB = MI.getOperand(0).getMBB();
329 MachineBasicBlock::iterator InsPt = std::next(MI.getIterator());
345 MachineBasicBlock &MBB = *MI.getParent();
352 MachineBasicBlock::reverse_iterator A = MI.getReverseIterator(),
439 SmallVector<MachineBasicBlock *, 16> ExecBranchStack;
443 MachineBasicBlock *EmptyMBBAtEnd = nullptr;
448 MachineBasicBlock &MBB = *BI;
462 MachineBasicBlock::iterator I, Next;
lib/Target/AMDGPU/SIInsertWaitcnts.cpp 378 MachineBasicBlock *MBB;
382 explicit BlockInfo(MachineBasicBlock *MBB) : MBB(MBB) {}
386 DenseMap<MachineBasicBlock *, unsigned> RpotIdxMap;
453 bool insertWaitcntInBlock(MachineFunction &MF, MachineBasicBlock &Block,
1362 MachineBasicBlock &Block,
1374 for (MachineBasicBlock::instr_iterator Iter = Block.instr_begin(),
1480 for (MachineBasicBlock *MBB :
1515 for (MachineBasicBlock *Succ : BI.MBB->successors()) {
1539 SmallVector<MachineBasicBlock *, 4> EndPgmBlocks;
1545 MachineBasicBlock &MBB = *BI;
1547 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E;
1566 for (MachineBasicBlock *MBB : EndPgmBlocks) {
1569 for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E;
1594 MachineBasicBlock &EntryBB = MF.front();
lib/Target/AMDGPU/SIInstrInfo.cpp 509 static void reportIllegalCopy(const SIInstrInfo *TII, MachineBasicBlock &MBB,
510 MachineBasicBlock::iterator MI,
524 void SIInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
525 MachineBasicBlock::iterator MI,
751 void SIInstrInfo::materializeImmediate(MachineBasicBlock &MBB,
752 MachineBasicBlock::iterator MI,
812 void SIInstrInfo::insertVectorSelect(MachineBasicBlock &MBB,
813 MachineBasicBlock::iterator I,
940 unsigned SIInstrInfo::insertEQ(MachineBasicBlock *MBB,
941 MachineBasicBlock::iterator I,
953 unsigned SIInstrInfo::insertNE(MachineBasicBlock *MBB,
954 MachineBasicBlock::iterator I,
1043 void SIInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
1044 MachineBasicBlock::iterator MI,
1172 void SIInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
1173 MachineBasicBlock::iterator MI,
1229 MachineBasicBlock &MBB, MachineInstr &MI, RegScavenger *RS, unsigned TmpReg,
1240 MachineBasicBlock &Entry = MBB.getParent()->front();
1241 MachineBasicBlock::iterator Insert = Entry.front();
1323 void SIInstrInfo::insertWaitStates(MachineBasicBlock &MBB,
1324 MachineBasicBlock::iterator MI,
1339 void SIInstrInfo::insertNoop(MachineBasicBlock &MBB,
1340 MachineBasicBlock::iterator MI) const {
1344 void SIInstrInfo::insertReturn(MachineBasicBlock &MBB) const {
1372 MachineBasicBlock &MBB = *MI.getParent();
1548 for (MachineBasicBlock::instr_iterator I = MI.getIterator();
1567 MachineBasicBlock &MBB = *MI.getParent();
1756 MachineBasicBlock *SIInstrInfo::getBranchDestBlock(
1767 unsigned SIInstrInfo::insertIndirectBranch(MachineBasicBlock &MBB,
1768 MachineBasicBlock &DestBB,
1901 bool SIInstrInfo::analyzeBranchImpl(MachineBasicBlock &MBB,
1902 MachineBasicBlock::iterator I,
1913 MachineBasicBlock *CondBB = nullptr;
1944 bool SIInstrInfo::analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
1944 bool SIInstrInfo::analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
1945 MachineBasicBlock *&FBB,
1948 MachineBasicBlock::iterator I = MBB.getFirstTerminator();
1995 MachineBasicBlock *MaskBrDest = I->getOperand(0).getMBB();
2013 unsigned SIInstrInfo::removeBranch(MachineBasicBlock &MBB,
2015 MachineBasicBlock::iterator I = MBB.getFirstTerminator();
2020 MachineBasicBlock::iterator Next = std::next(I);
2045 unsigned SIInstrInfo::insertBranch(MachineBasicBlock &MBB,
2046 MachineBasicBlock *TBB,
2047 MachineBasicBlock *FBB,
2117 bool SIInstrInfo::canInsertSelect(const MachineBasicBlock &MBB,
2157 void SIInstrInfo::insertSelect(MachineBasicBlock &MBB,
2158 MachineBasicBlock::iterator I, const DebugLoc &DL,
2724 const MachineBasicBlock *MBB,
3060 MachineBasicBlock *MBB = MI.getParent();;
3825 MachineBasicBlock::iterator I = MI;
3826 MachineBasicBlock *MBB = MI.getParent();
3852 unsigned SIInstrInfo::buildExtractSubReg(MachineBasicBlock::iterator MI,
3859 MachineBasicBlock *MBB = MI->getParent();
3885 MachineBasicBlock::iterator MII,
4272 void SIInstrInfo::legalizeGenericOperand(MachineBasicBlock &InsertMBB,
4273 MachineBasicBlock::iterator I,
4320 MachineBasicBlock &OrigBB, MachineBasicBlock &LoopBB,
4320 MachineBasicBlock &OrigBB, MachineBasicBlock &LoopBB,
4334 MachineBasicBlock::iterator I = LoopBB.begin();
4404 MachineBasicBlock &MBB = *MI.getParent();
4409 MachineBasicBlock::iterator I(&MI);
4430 MachineBasicBlock *LoopBB = MF.CreateMachineBasicBlock();
4431 MachineBasicBlock *RemainderBB = MF.CreateMachineBasicBlock();
4442 MachineBasicBlock::iterator J = I++;
4466 MachineBasicBlock::iterator First = RemainderBB->begin();
4473 MachineBasicBlock &MBB = *MI.getParent();
4583 MachineBasicBlock *InsertBB = MI.getOperand(I + 1).getMBB();
4584 MachineBasicBlock::iterator Insert = InsertBB->getFirstTerminator();
4596 MachineBasicBlock *MBB = MI.getParent();
4628 MachineBasicBlock *MBB = MI.getParent();
4692 MachineBasicBlock &MBB = *MI.getParent();
4823 MachineBasicBlock *MBB = Inst.getParent();
5108 MachineBasicBlock &MBB = *Inst.getParent();
5138 MachineBasicBlock &MBB = *Inst.getParent();
5140 MachineBasicBlock::iterator MII = Inst;
5165 MachineBasicBlock &MBB = *Inst.getParent();
5167 MachineBasicBlock::iterator MII = Inst;
5231 MachineBasicBlock &MBB = *Inst.getParent();
5233 MachineBasicBlock::iterator MII = Inst;
5260 MachineBasicBlock &MBB = *Inst.getParent();
5262 MachineBasicBlock::iterator MII = Inst;
5289 MachineBasicBlock &MBB = *Inst.getParent();
5296 MachineBasicBlock::iterator MII = Inst;
5345 MachineBasicBlock &MBB = *Inst.getParent();
5360 MachineBasicBlock::iterator MII = Inst;
5415 MachineBasicBlock &MBB = *Inst.getParent();
5423 MachineBasicBlock::iterator MII = Inst;
5479 MachineBasicBlock &MBB = *Inst.getParent();
5487 MachineBasicBlock::iterator MII = Inst;
5520 MachineBasicBlock &MBB = *Inst.getParent();
5523 MachineBasicBlock::iterator MII = Inst;
5557 MachineBasicBlock &MBB = *Inst.getParent();
5559 MachineBasicBlock::iterator MII = Inst;
5656 MachineBasicBlock *MBB = Inst.getParent();
5970 MachineBasicBlock::const_instr_iterator I = MI.getIterator();
5971 MachineBasicBlock::const_instr_iterator E = MI.getParent()->instr_end();
6065 void SIInstrInfo::convertNonUniformIfRegion(MachineBasicBlock *IfEntry,
6066 MachineBasicBlock *IfEnd) const {
6067 MachineBasicBlock::iterator TI = IfEntry->getFirstTerminator();
6091 MachineBasicBlock *LoopEntry, MachineBasicBlock *LoopEnd) const {
6091 MachineBasicBlock *LoopEntry, MachineBasicBlock *LoopEnd) const {
6092 MachineBasicBlock::iterator TI = LoopEnd->getFirstTerminator();
6106 for (MachineBasicBlock::pred_iterator PI = LoopEntry->pred_begin(),
6112 MachineBasicBlock *PMBB = *PI;
6189 SIInstrInfo::getAddNoCarry(MachineBasicBlock &MBB,
6190 MachineBasicBlock::iterator I,
6204 MachineInstrBuilder SIInstrInfo::getAddNoCarry(MachineBasicBlock &MBB,
6205 MachineBasicBlock::iterator I,
6243 MachineBasicBlock *MBB = MI.getParent();
6526 MachineBasicBlock &MBB, MachineBasicBlock::iterator LastPHIIt,
6526 MachineBasicBlock &MBB, MachineBasicBlock::iterator LastPHIIt,
6541 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsPt,
6541 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsPt,
lib/Target/AMDGPU/SIInstrInfo.h 67 unsigned buildExtractSubReg(MachineBasicBlock::iterator MI,
73 MachineOperand buildExtractSubRegOrImm(MachineBasicBlock::iterator MI,
194 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
194 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
198 unsigned calculateLDSSpillAddress(MachineBasicBlock &MBB, MachineInstr &MI,
202 void materializeImmediate(MachineBasicBlock &MBB,
203 MachineBasicBlock::iterator MI,
211 unsigned insertNE(MachineBasicBlock *MBB,
212 MachineBasicBlock::iterator I, const DebugLoc &DL,
215 unsigned insertEQ(MachineBasicBlock *MBB,
216 MachineBasicBlock::iterator I, const DebugLoc &DL,
219 void storeRegToStackSlot(MachineBasicBlock &MBB,
220 MachineBasicBlock::iterator MI, unsigned SrcReg,
225 void loadRegFromStackSlot(MachineBasicBlock &MBB,
226 MachineBasicBlock::iterator MI, unsigned DestReg,
262 MachineBasicBlock *getBranchDestBlock(const MachineInstr &MI) const override;
264 unsigned insertIndirectBranch(MachineBasicBlock &MBB,
265 MachineBasicBlock &NewDestBB,
270 bool analyzeBranchImpl(MachineBasicBlock &MBB,
271 MachineBasicBlock::iterator I,
277 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
277 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
278 MachineBasicBlock *&FBB,
282 unsigned removeBranch(MachineBasicBlock &MBB,
285 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
285 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
286 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
293 bool canInsertSelect(const MachineBasicBlock &MBB,
299 void insertSelect(MachineBasicBlock &MBB,
300 MachineBasicBlock::iterator I, const DebugLoc &DL,
304 void insertVectorSelect(MachineBasicBlock &MBB,
305 MachineBasicBlock::iterator I, const DebugLoc &DL,
328 const MachineBasicBlock *MBB,
876 void legalizeGenericOperand(MachineBasicBlock &InsertMBB,
877 MachineBasicBlock::iterator I,
893 void insertWaitStates(MachineBasicBlock &MBB,MachineBasicBlock::iterator MI,
893 void insertWaitStates(MachineBasicBlock &MBB,MachineBasicBlock::iterator MI,
896 void insertNoop(MachineBasicBlock &MBB,
897 MachineBasicBlock::iterator MI) const override;
899 void insertReturn(MachineBasicBlock &MBB) const;
948 void convertNonUniformIfRegion(MachineBasicBlock *IfEntry,
949 MachineBasicBlock *IfEnd) const;
951 void convertNonUniformLoopRegion(MachineBasicBlock *LoopEntry,
952 MachineBasicBlock *LoopEnd) const;
972 MachineInstr *createPHIDestinationCopy(MachineBasicBlock &MBB,
973 MachineBasicBlock::iterator InsPt,
977 MachineInstr *createPHISourceCopy(MachineBasicBlock &MBB,
978 MachineBasicBlock::iterator InsPt,
989 MachineInstrBuilder getAddNoCarry(MachineBasicBlock &MBB,
990 MachineBasicBlock::iterator I,
994 MachineInstrBuilder getAddNoCarry(MachineBasicBlock &MBB,
995 MachineBasicBlock::iterator I,
lib/Target/AMDGPU/SILoadStoreOptimizer.cpp 114 MachineBasicBlock::iterator I;
115 MachineBasicBlock::iterator Paired;
184 void setMI(MachineBasicBlock::iterator MI, const SIInstrInfo &TII,
186 void setPaired(MachineBasicBlock::iterator MI, const SIInstrInfo &TII);
223 MachineBasicBlock::iterator mergeRead2Pair(CombineInfo &CI);
227 MachineBasicBlock::iterator mergeWrite2Pair(CombineInfo &CI);
228 MachineBasicBlock::iterator mergeImagePair(CombineInfo &CI);
229 MachineBasicBlock::iterator mergeSBufferLoadImmPair(CombineInfo &CI);
230 MachineBasicBlock::iterator mergeBufferLoadPair(CombineInfo &CI);
231 MachineBasicBlock::iterator mergeBufferStorePair(CombineInfo &CI);
247 bool collectMergeableInsts(MachineBasicBlock &MBB,
423 void SILoadStoreOptimizer::CombineInfo::setMI(MachineBasicBlock::iterator MI,
507 void SILoadStoreOptimizer::CombineInfo::setPaired(MachineBasicBlock::iterator MI,
549 static void moveInstsAfter(MachineBasicBlock::iterator I,
551 MachineBasicBlock *MBB = I->getParent();
572 static bool memAccessesCanBeReordered(MachineBasicBlock::iterator A,
753 MachineBasicBlock *MBB = CI.I->getParent();
754 MachineBasicBlock::iterator E = MBB->end();
755 MachineBasicBlock::iterator MBBI = CI.I;
871 MachineBasicBlock::iterator
873 MachineBasicBlock *MBB = CI.I->getParent();
970 MachineBasicBlock::iterator
972 MachineBasicBlock *MBB = CI.I->getParent();
1037 MachineBasicBlock::iterator
1039 MachineBasicBlock *MBB = CI.I->getParent();
1091 MachineBasicBlock::iterator
1093 MachineBasicBlock *MBB = CI.I->getParent();
1141 MachineBasicBlock::iterator
1143 MachineBasicBlock *MBB = CI.I->getParent();
1295 MachineBasicBlock::iterator
1297 MachineBasicBlock *MBB = CI.I->getParent();
1373 MachineBasicBlock *MBB = MI.getParent();
1374 MachineBasicBlock::iterator MBBI = MI.getIterator();
1588 MachineBasicBlock *MBB = MI.getParent();
1589 MachineBasicBlock::iterator E = MBB->end();
1590 MachineBasicBlock::iterator MBBI = MI.getIterator();
1678 bool SILoadStoreOptimizer::collectMergeableInsts(MachineBasicBlock &MBB,
1771 MachineBasicBlock::iterator NewMI = mergeRead2Pair(CI);
1779 MachineBasicBlock::iterator NewMI = mergeWrite2Pair(CI);
1787 MachineBasicBlock::iterator NewMI = mergeSBufferLoadImmPair(CI);
1796 MachineBasicBlock::iterator NewMI = mergeBufferLoadPair(CI);
1805 MachineBasicBlock::iterator NewMI = mergeBufferStorePair(CI);
1814 MachineBasicBlock::iterator NewMI = mergeImagePair(CI);
1850 for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SILowerControlFlow.cpp 161 DenseSet<const MachineBasicBlock*> Visited;
162 SmallVector<MachineBasicBlock*, 4> Worklist(SMBB->succ_begin(),
166 MachineBasicBlock *MBB = Worklist.pop_back_val();
181 MachineBasicBlock *MBB = MI->getParent();
188 MachineBasicBlock::iterator I = (MI);
189 MachineBasicBlock::iterator J = std::next(I);
199 MachineBasicBlock &MBB = *MI.getParent();
201 MachineBasicBlock::iterator I(&MI);
282 MachineBasicBlock &MBB = *MI.getParent();
288 MachineBasicBlock::iterator Start = MBB.begin();
306 MachineBasicBlock *DestBB = MI.getOperand(2).getMBB();
308 MachineBasicBlock::iterator ElsePt(MI);
355 MachineBasicBlock &MBB = *MI.getParent();
396 MachineBasicBlock &MBB = *MI.getParent();
417 MachineBasicBlock &MBB = *MI.getParent();
423 MachineBasicBlock::iterator InsPt =
528 MachineBasicBlock &MBB = *BI;
530 MachineBasicBlock::iterator I, Next, Last;
lib/Target/AMDGPU/SILowerI1Copies.cpp 44 static unsigned insertUndefLaneMask(MachineBasicBlock &MBB);
92 void buildMergeLaneMasks(MachineBasicBlock &MBB,
93 MachineBasicBlock::iterator I, const DebugLoc &DL,
95 MachineBasicBlock::iterator
137 DenseMap<MachineBasicBlock *, bool> ReachableMap;
138 SmallVector<MachineBasicBlock *, 4> ReachableOrdered;
139 SmallVector<MachineBasicBlock *, 4> Stack;
140 SmallVector<MachineBasicBlock *, 4> Predecessors;
147 bool isSource(MachineBasicBlock &MBB) const {
151 ArrayRef<MachineBasicBlock *> predecessors() const { return Predecessors; }
153 void analyze(MachineBasicBlock &DefBlock,
154 ArrayRef<MachineBasicBlock *> IncomingBlocks) {
165 for (MachineBasicBlock *MBB : IncomingBlocks) {
188 for (MachineBasicBlock *Succ : MBB->successors())
194 MachineBasicBlock *MBB = Stack.pop_back_val();
199 for (MachineBasicBlock *Succ : MBB->successors())
203 for (MachineBasicBlock *MBB : ReachableOrdered) {
205 for (MachineBasicBlock *Pred : MBB->predecessors()) {
215 for (MachineBasicBlock *UnreachablePred : Stack) {
264 DenseMap<MachineBasicBlock *, unsigned> Visited;
268 SmallVector<MachineBasicBlock *, 4> CommonDominators;
271 MachineBasicBlock *VisitedPostDom = nullptr;
278 MachineBasicBlock *DefBlock = nullptr;
279 SmallVector<MachineBasicBlock *, 4> Stack;
280 SmallVector<MachineBasicBlock *, 4> NextLevel;
286 void initialize(MachineBasicBlock &MBB) {
301 unsigned findLoop(MachineBasicBlock *PostDom) {
324 ArrayRef<MachineBasicBlock *> Blocks = {}) {
327 MachineBasicBlock *Dom = CommonDominators[LoopLevel];
328 for (MachineBasicBlock *MBB : Blocks)
336 for (MachineBasicBlock *Pred : Dom->predecessors()) {
344 bool inLoopLevel(MachineBasicBlock &MBB, unsigned LoopLevel,
345 ArrayRef<MachineBasicBlock *> Blocks) const {
357 MachineBasicBlock *VisitedDom;
381 MachineBasicBlock *MBB = Stack.pop_back_val();
388 for (MachineBasicBlock *Succ : MBB->successors()) {
434 static unsigned insertUndefLaneMask(MachineBasicBlock &MBB) {
504 for (MachineBasicBlock &MBB : *MF) {
545 SmallVector<MachineBasicBlock *, 4> IncomingBlocks;
552 for (MachineBasicBlock &MBB : *MF) {
559 MachineBasicBlock *PrevMBB = nullptr;
561 MachineBasicBlock &MBB = *MI->getParent();
577 MachineBasicBlock *IncomingMBB = MI->getOperand(i + 1).getMBB();
600 std::vector<MachineBasicBlock *> DomBlocks = {&MBB};
604 MachineBasicBlock *PostDomBound =
620 MachineBasicBlock &IMBB = *IncomingBlocks[i];
630 for (MachineBasicBlock *MBB : PIA.predecessors())
634 MachineBasicBlock &IMBB = *IncomingBlocks[i];
648 MachineBasicBlock &IMBB = *IncomingBlocks[i];
672 for (MachineBasicBlock &MBB : *MF) {
713 std::vector<MachineBasicBlock *> DomBlocks = {&MBB};
717 MachineBasicBlock *PostDomBound =
786 MachineBasicBlock::iterator
813 void SILowerI1Copies::buildMergeLaneMasks(MachineBasicBlock &MBB,
814 MachineBasicBlock::iterator I,
lib/Target/AMDGPU/SILowerSGPRSpills.cpp 36 using MBBVector = SmallVector<MachineBasicBlock *, 4>;
87 static void insertCSRSaves(MachineBasicBlock &SaveBlock,
95 MachineBasicBlock::iterator I = SaveBlock.begin();
119 static void insertCSRRestores(MachineBasicBlock &RestoreBlock,
129 MachineBasicBlock::iterator I = RestoreBlock.getFirstTerminator();
165 MachineBasicBlock *RestoreBlock = MFI.getRestorePoint();
176 for (MachineBasicBlock &MBB : MF) {
218 for (MachineBasicBlock *SaveBlock : SaveBlocks)
221 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
269 for (MachineBasicBlock &MBB : MF) {
270 MachineBasicBlock::iterator Next;
303 for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIMachineFunctionInfo.cpp 309 for (MachineBasicBlock &BB : MF)
lib/Target/AMDGPU/SIMachineScheduler.cpp 325 void SIScheduleBlock::initRegPressure(MachineBasicBlock::iterator BeginBlock,
398 void SIScheduleBlock::schedule(MachineBasicBlock::iterator BeginBlock,
1275 static MachineBasicBlock::iterator
1350 MachineBasicBlock::iterator CurrentTopFastSched = DAG->getCurrentTop();
1351 std::vector<MachineBasicBlock::iterator> PosOld;
1352 std::vector<MachineBasicBlock::iterator> PosNew;
1363 MachineBasicBlock::iterator Pos = MI;
1397 MachineBasicBlock::iterator POld = PosOld[i-1];
1398 MachineBasicBlock::iterator PNew = PosNew[i-1];
lib/Target/AMDGPU/SIMachineScheduler.h 152 void schedule(MachineBasicBlock::iterator BeginBlock,
209 void initRegPressure(MachineBasicBlock::iterator BeginBlock,
455 MachineBasicBlock *getBB() { return BB; }
456 MachineBasicBlock::iterator getCurrentTop() { return CurrentTop; }
457 MachineBasicBlock::iterator getCurrentBottom() { return CurrentBottom; }
lib/Target/AMDGPU/SIMemoryLegalizer.cpp 104 bool enableNamedBit(const MachineBasicBlock::iterator &MI) {
207 void reportUnsupported(const MachineBasicBlock::iterator &MI,
223 const MachineBasicBlock::iterator &MI) const;
232 const MachineBasicBlock::iterator &MI) const;
236 const MachineBasicBlock::iterator &MI) const;
241 const MachineBasicBlock::iterator &MI) const;
246 const MachineBasicBlock::iterator &MI) const;
267 virtual bool enableLoadCacheBypass(const MachineBasicBlock::iterator &MI,
273 virtual bool enableNonTemporal(const MachineBasicBlock::iterator &MI)
281 virtual bool insertCacheInvalidate(MachineBasicBlock::iterator &MI,
293 virtual bool insertWait(MachineBasicBlock::iterator &MI,
310 bool enableGLCBit(const MachineBasicBlock::iterator &MI) const {
316 bool enableSLCBit(const MachineBasicBlock::iterator &MI) const {
324 bool enableLoadCacheBypass(const MachineBasicBlock::iterator &MI,
328 bool enableNonTemporal(const MachineBasicBlock::iterator &MI) const override;
330 bool insertCacheInvalidate(MachineBasicBlock::iterator &MI,
335 bool insertWait(MachineBasicBlock::iterator &MI,
348 bool insertCacheInvalidate(MachineBasicBlock::iterator &MI,
361 bool enableDLCBit(const MachineBasicBlock::iterator &MI) const {
370 bool enableLoadCacheBypass(const MachineBasicBlock::iterator &MI,
374 bool enableNonTemporal(const MachineBasicBlock::iterator &MI) const override;
376 bool insertCacheInvalidate(MachineBasicBlock::iterator &MI,
381 bool insertWait(MachineBasicBlock::iterator &MI,
396 std::list<MachineBasicBlock::iterator> AtomicPseudoMIs;
411 MachineBasicBlock::iterator &MI);
415 MachineBasicBlock::iterator &MI);
419 MachineBasicBlock::iterator &MI);
423 MachineBasicBlock::iterator &MI);
444 void SIMemOpAccess::reportUnsupported(const MachineBasicBlock::iterator &MI,
517 const MachineBasicBlock::iterator &MI) const {
576 const MachineBasicBlock::iterator &MI) const {
590 const MachineBasicBlock::iterator &MI) const {
604 const MachineBasicBlock::iterator &MI) const {
637 const MachineBasicBlock::iterator &MI) const {
666 const MachineBasicBlock::iterator &MI,
702 const MachineBasicBlock::iterator &MI) const {
713 bool SIGfx6CacheControl::insertCacheInvalidate(MachineBasicBlock::iterator &MI,
719 MachineBasicBlock &MBB = *MI->getParent();
755 bool SIGfx6CacheControl::insertWait(MachineBasicBlock::iterator &MI,
763 MachineBasicBlock &MBB = *MI->getParent();
851 bool SIGfx7CacheControl::insertCacheInvalidate(MachineBasicBlock::iterator &MI,
857 MachineBasicBlock &MBB = *MI->getParent();
900 const MachineBasicBlock::iterator &MI,
943 const MachineBasicBlock::iterator &MI) const {
953 bool SIGfx10CacheControl::insertCacheInvalidate(MachineBasicBlock::iterator &MI,
959 MachineBasicBlock &MBB = *MI->getParent();
1005 bool SIGfx10CacheControl::insertWait(MachineBasicBlock::iterator &MI,
1013 MachineBasicBlock &MBB = *MI->getParent();
1136 MachineBasicBlock::iterator &MI) {
1181 MachineBasicBlock::iterator &MI) {
1208 MachineBasicBlock::iterator &MI) {
1246 MachineBasicBlock::iterator &MI) {
1290 for (auto &MBB : MF) {
lib/Target/AMDGPU/SIModeRegister.cpp 123 std::queue<MachineBasicBlock *> Phase2List;
144 void processBlockPhase1(MachineBasicBlock &MBB, const SIInstrInfo *TII);
146 void processBlockPhase2(MachineBasicBlock &MBB, const SIInstrInfo *TII);
148 void processBlockPhase3(MachineBasicBlock &MBB, const SIInstrInfo *TII);
152 void insertSetreg(MachineBasicBlock &MBB, MachineInstr *I,
192 void SIModeRegister::insertSetreg(MachineBasicBlock &MBB, MachineInstr *MI,
227 void SIModeRegister::processBlockPhase1(MachineBasicBlock &MBB,
326 void SIModeRegister::processBlockPhase2(MachineBasicBlock &MBB,
336 MachineBasicBlock::pred_iterator P = MBB.pred_begin(), E = MBB.pred_end();
337 MachineBasicBlock &PB = *(*P);
341 MachineBasicBlock *Pred = *P;
350 for (MachineBasicBlock::succ_iterator S = MBB.succ_begin(),
353 MachineBasicBlock &B = *(*S);
362 void SIModeRegister::processBlockPhase3(MachineBasicBlock &MBB,
384 for (MachineBasicBlock &BB : MF)
390 for (MachineBasicBlock &BB : MF)
399 for (MachineBasicBlock &BB : MF)
lib/Target/AMDGPU/SIOptimizeExecMasking.cpp 222 static MachineBasicBlock::reverse_iterator fixTerminators(
224 MachineBasicBlock &MBB) {
225 MachineBasicBlock::reverse_iterator I = MBB.rbegin(), E = MBB.rend();
237 static MachineBasicBlock::reverse_iterator findExecCopy(
240 MachineBasicBlock &MBB,
241 MachineBasicBlock::reverse_iterator I,
258 static bool isLiveOut(const MachineBasicBlock &MBB, unsigned Reg) {
259 for (MachineBasicBlock *Succ : MBB.successors()) {
287 for (MachineBasicBlock &MBB : MF) {
288 MachineBasicBlock::reverse_iterator I = fixTerminators(*TII, MBB);
289 MachineBasicBlock::reverse_iterator E = MBB.rend();
329 for (MachineBasicBlock::iterator J
lib/Target/AMDGPU/SIOptimizeExecMaskingPreRA.cpp 42 MachineBasicBlock::iterator skipIgnoreExecInsts(
45 MachineBasicBlock::iterator skipIgnoreExecInstsTrivialSucc(
134 MachineBasicBlock::iterator SIOptimizeExecMaskingPreRA::skipIgnoreExecInsts(
147 MachineBasicBlock::iterator
158 MachineBasicBlock *Succ = *MBB->succ_begin();
188 static unsigned optimizeVcndVcmpPair(MachineBasicBlock &MBB,
308 for (MachineBasicBlock &MBB : MF) {
331 SmallVector<MachineBasicBlock*, 4> Blocks({&MBB});
373 for (auto *Pred : CurBB->predecessors()) {
387 MachineBasicBlock *TmpMBB = &MBB;
lib/Target/AMDGPU/SIPeepholeSDWA.cpp 90 void matchSDWAOperands(MachineBasicBlock &MBB);
852 void SIPeepholeSDWA::matchSDWAOperands(MachineBasicBlock &MBB) {
912 MachineBasicBlock &MBB = *MI.getParent();
914 if (Liveness != MachineBasicBlock::LQR_Dead)
1216 for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIPreAllocateWWMRegs.cpp 121 for (MachineBasicBlock &MBB : MF) {
187 for (MachineBasicBlock *MBB : RPOT) {
lib/Target/AMDGPU/SIRegisterInfo.cpp 342 void SIRegisterInfo::materializeFrameBaseRegister(MachineBasicBlock *MBB,
346 MachineBasicBlock::iterator Ins = MBB->begin();
396 MachineBasicBlock *MBB = MI.getParent();
544 MachineBasicBlock::iterator MI,
549 MachineBasicBlock *MBB = MI->getParent();
576 MachineBasicBlock::iterator MI,
580 MachineBasicBlock *MBB = MI->getParent();
614 void SIRegisterInfo::buildSpillLoadStore(MachineBasicBlock::iterator MI,
624 MachineBasicBlock *MBB = MI->getParent();
745 bool SIRegisterInfo::spillSGPR(MachineBasicBlock::iterator MI,
749 MachineBasicBlock *MBB = MI->getParent();
863 bool SIRegisterInfo::restoreSGPR(MachineBasicBlock::iterator MI,
868 MachineBasicBlock *MBB = MI->getParent();
956 MachineBasicBlock::iterator MI,
983 void SIRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator MI,
987 MachineBasicBlock *MBB = MI->getParent();
lib/Target/AMDGPU/SIRegisterInfo.h 89 void materializeFrameBaseRegister(MachineBasicBlock *MBB,
103 bool spillSGPR(MachineBasicBlock::iterator MI,
107 bool restoreSGPR(MachineBasicBlock::iterator MI,
111 void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
115 bool eliminateSGPRToVGPRSpillFrameIndex(MachineBasicBlock::iterator MI,
289 void buildSpillLoadStore(MachineBasicBlock::iterator MI,
lib/Target/AMDGPU/SIShrinkInstructions.cpp 563 MachineBasicBlock &MBB = *BI;
564 MachineBasicBlock::iterator I, Next;
lib/Target/AMDGPU/SIWholeQuadMode.cpp 138 MachineBasicBlock *MBB = nullptr;
142 WorkItem(MachineBasicBlock *MBB) : MBB(MBB) {}
156 DenseMap<MachineBasicBlock *, BlockInfo> Blocks;
168 void propagateBlock(MachineBasicBlock &MBB, std::vector<WorkItem> &Worklist);
173 MachineBasicBlock::iterator saveSCC(MachineBasicBlock &MBB,
175 MachineBasicBlock::iterator
179 void toExact(MachineBasicBlock &MBB, MachineBasicBlock::iterator Before,
179 void toExact(MachineBasicBlock &MBB, MachineBasicBlock::iterator Before,
181 void toWQM(MachineBasicBlock &MBB, MachineBasicBlock::iterator Before,
181 void toWQM(MachineBasicBlock &MBB, MachineBasicBlock::iterator Before,
183 void toWWM(MachineBasicBlock &MBB, MachineBasicBlock::iterator Before,
183 void toWWM(MachineBasicBlock &MBB, MachineBasicBlock::iterator Before,
185 void fromWWM(MachineBasicBlock &MBB, MachineBasicBlock::iterator Before,
185 void fromWWM(MachineBasicBlock &MBB, MachineBasicBlock::iterator Before,
187 void processBlock(MachineBasicBlock &MBB, unsigned LiveMaskReg, bool isEntry);
323 MachineBasicBlock &MBB = **BI;
428 MachineBasicBlock *MBB = MI.getParent();
473 void SIWholeQuadMode::propagateBlock(MachineBasicBlock &MBB,
488 for (MachineBasicBlock *Pred : MBB.predecessors()) {
499 for (MachineBasicBlock *Succ : MBB.successors()) {
556 MachineBasicBlock::iterator
578 MachineBasicBlock::iterator SIWholeQuadMode::prepareInsertion(
611 MachineBasicBlock::iterator MBBI;
626 void SIWholeQuadMode::toExact(MachineBasicBlock &MBB,
627 MachineBasicBlock::iterator Before,
648 void SIWholeQuadMode::toWQM(MachineBasicBlock &MBB,
649 MachineBasicBlock::iterator Before,
667 void SIWholeQuadMode::toWWM(MachineBasicBlock &MBB,
668 MachineBasicBlock::iterator Before,
678 void SIWholeQuadMode::fromWWM(MachineBasicBlock &MBB,
679 MachineBasicBlock::iterator Before,
690 void SIWholeQuadMode::processBlock(MachineBasicBlock &MBB, unsigned LiveMaskReg,
719 MachineBasicBlock::iterator FirstWQM = IE;
725 MachineBasicBlock::iterator FirstWWM = IE;
727 MachineBasicBlock::iterator Next = II;
778 MachineBasicBlock::iterator First;
787 MachineBasicBlock::iterator Before =
899 MachineBasicBlock &Entry = MF.front();
900 MachineBasicBlock::iterator EntryMI = Entry.getFirstNonPHI();
lib/Target/ARC/ARCBranchFinalize.cpp 149 std::map<MachineBasicBlock *, unsigned> BlockToPCMap;
153 for (auto &MBB : MF) {
lib/Target/ARC/ARCExpandPseudos.cpp 37 void ExpandStore(MachineFunction &, MachineBasicBlock::iterator);
60 MachineBasicBlock::iterator SII) {
80 for (auto &MBB : MF) {
81 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
83 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
lib/Target/ARC/ARCFrameLowering.cpp 44 static void generateStackAdjustment(MachineBasicBlock &MBB,
45 MachineBasicBlock::iterator MBBI,
98 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
98 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
117 MachineBasicBlock &MBB) const {
124 MachineBasicBlock::iterator MBBI = MBB.begin();
241 MachineBasicBlock &MBB) const {
245 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
403 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
403 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
421 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
421 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
452 static void emitRegUpdate(MachineBasicBlock &MBB,
453 MachineBasicBlock::iterator &MBBI, DebugLoc dl,
469 MachineBasicBlock::iterator ARCFrameLowering::eliminateCallFramePseudoInstr(
lib/Target/ARC/ARCFrameLowering.h 34 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
37 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
43 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
44 MachineBasicBlock::iterator MI,
49 restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
50 MachineBasicBlock::iterator MI,
59 MachineBasicBlock::iterator
68 void adjustStackToMatchRecords(MachineBasicBlock &MBB,
69 MachineBasicBlock::iterator MI,
lib/Target/ARC/ARCInstrInfo.cpp 170 bool ARCInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
171 MachineBasicBlock *&TBB,
172 MachineBasicBlock *&FBB,
176 MachineBasicBlock::iterator I = MBB.end();
231 MachineBasicBlock::iterator DI = std::next(I);
254 unsigned ARCInstrInfo::removeBranch(MachineBasicBlock &MBB,
257 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
281 void ARCInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
282 MachineBasicBlock::iterator I,
293 void ARCInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
294 MachineBasicBlock::iterator I,
322 void ARCInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
323 MachineBasicBlock::iterator I,
357 MachineBasicBlock::iterator
370 unsigned ARCInstrInfo::insertBranch(MachineBasicBlock &MBB,
371 MachineBasicBlock *TBB,
372 MachineBasicBlock *FBB,
lib/Target/ARC/ARCInstrInfo.h 53 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
53 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
54 MachineBasicBlock *&FBB,
58 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
58 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
59 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
63 unsigned removeBranch(MachineBasicBlock &MBB,
66 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
66 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
70 void storeRegToStackSlot(MachineBasicBlock &MBB,
71 MachineBasicBlock::iterator MI, unsigned SrcReg,
76 void loadRegFromStackSlot(MachineBasicBlock &MBB,
77 MachineBasicBlock::iterator MI, unsigned DestReg,
96 MachineBasicBlock::iterator loadImmediate(MachineBasicBlock &MBB,
lib/Target/ARC/ARCOptAddrMode.cpp 102 bool processBasicBlock(MachineBasicBlock &MBB);
149 MachineBasicBlock *MBB = User->getOperand(BBOperandIdx).getMBB();
151 const MachineBasicBlock *InstBB = MI->getParent();
391 MachineBasicBlock::const_iterator MI(To), ME(Ldst),
419 MachineBasicBlock::const_iterator MI(Ldst), ME(To),
467 bool ARCOptAddrMode::processBasicBlock(MachineBasicBlock &MBB) {
496 for (auto &MBB : MF)
lib/Target/ARC/ARCRegisterInfo.cpp 38 static void ReplaceFrameIndex(MachineBasicBlock::iterator II,
44 MachineBasicBlock &MBB = *MI.getParent();
165 void ARCRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
lib/Target/ARC/ARCRegisterInfo.h 41 void eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
lib/Target/ARM/A15SDOptimizer.cpp 66 unsigned createDupLane(MachineBasicBlock &MBB,
67 MachineBasicBlock::iterator InsertBefore,
71 unsigned createExtractSubreg(MachineBasicBlock &MBB,
72 MachineBasicBlock::iterator InsertBefore,
76 unsigned createVExt(MachineBasicBlock &MBB,
77 MachineBasicBlock::iterator InsertBefore,
80 unsigned createRegSequence(MachineBasicBlock &MBB,
81 MachineBasicBlock::iterator InsertBefore,
85 unsigned createInsertSubreg(MachineBasicBlock &MBB,
86 MachineBasicBlock::iterator InsertBefore,
90 unsigned createImplicitDef(MachineBasicBlock &MBB,
91 MachineBasicBlock::iterator InsertBefore,
417 unsigned A15SDOptimizer::createDupLane(MachineBasicBlock &MBB,
418 MachineBasicBlock::iterator InsertBefore,
434 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
434 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
449 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
449 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
465 unsigned A15SDOptimizer::createVExt(MachineBasicBlock &MBB,
466 MachineBasicBlock::iterator InsertBefore,
479 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
479 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
494 A15SDOptimizer::createImplicitDef(MachineBasicBlock &MBB,
495 MachineBasicBlock::iterator InsertBefore,
510 MachineBasicBlock::iterator InsertPt(MI);
512 MachineBasicBlock &MBB = *MI->getParent();
675 for (MachineBasicBlock &MBB : Fn) {
lib/Target/ARM/ARMAsmPrinter.cpp 901 const MachineBasicBlock *MBB = cast<ARMConstantPoolMBB>(ACPV)->getMBB();
955 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
957 for (MachineBasicBlock *MBB : JTBBs) {
998 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
1000 for (MachineBasicBlock *MBB : JTBBs) {
1026 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
lib/Target/ARM/ARMBaseInstrInfo.cpp 304 MachineBasicBlock::iterator MBBI = MI.getIterator();
311 bool ARMBaseInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
312 MachineBasicBlock *&TBB,
313 MachineBasicBlock *&FBB,
319 MachineBasicBlock::iterator I = MBB.end();
378 MachineBasicBlock::iterator DI = std::next(I);
401 unsigned ARMBaseInstrInfo::removeBranch(MachineBasicBlock &MBB,
405 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
428 unsigned ARMBaseInstrInfo::insertBranch(MachineBasicBlock &MBB,
429 MachineBasicBlock *TBB,
430 MachineBasicBlock *FBB,
484 MachineBasicBlock::const_instr_iterator I = MI.getIterator();
485 MachineBasicBlock::const_instr_iterator E = MI.getParent()->instr_end();
701 const MachineBasicBlock &MBB = *MI.getParent();
759 MachineBasicBlock::const_instr_iterator I = MI.getIterator();
760 MachineBasicBlock::const_instr_iterator E = MI.getParent()->instr_end();
768 void ARMBaseInstrInfo::copyFromCPSR(MachineBasicBlock &MBB,
769 MachineBasicBlock::iterator I,
788 void ARMBaseInstrInfo::copyToCPSR(MachineBasicBlock &MBB,
789 MachineBasicBlock::iterator I,
830 void ARMBaseInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
831 MachineBasicBlock::iterator I,
1028 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
1028 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
1269 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
1269 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
1513 void ARMBaseInstrInfo::expandMEMCPY(MachineBasicBlock::iterator MI) const {
1519 MachineBasicBlock *BB = MI->getParent();
1692 void ARMBaseInstrInfo::reMaterialize(MachineBasicBlock &MBB,
1693 MachineBasicBlock::iterator I,
1720 ARMBaseInstrInfo::duplicate(MachineBasicBlock &MBB,
1721 MachineBasicBlock::iterator InsertBefore,
1724 MachineBasicBlock::instr_iterator I = Cloned.getIterator();
1950 const MachineBasicBlock *MBB,
1971 MachineBasicBlock::const_iterator I = MI;
1993 isProfitableToIfCvt(MachineBasicBlock &MBB,
2003 MachineBasicBlock *Pred = *MBB.pred_begin();
2019 isProfitableToIfCvt(MachineBasicBlock &TBB,
2021 MachineBasicBlock &FBB,
2115 ARMBaseInstrInfo::isProfitableToUnpredicate(MachineBasicBlock &TMBB,
2116 MachineBasicBlock &FMBB) const {
2357 void llvm::emitARMRegPlusImmediate(MachineBasicBlock &MBB,
2358 MachineBasicBlock::iterator &MBBI,
2488 MachineBasicBlock::LQR_Dead) {
2931 MachineBasicBlock::iterator I = CmpInstr, E = MI,
3156 MachineBasicBlock *MBB = CmpInstr.getParent();
3157 for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
3189 MachineBasicBlock::const_iterator Next = &MI;
4025 MachineBasicBlock::const_iterator I = MI; ++I;
4026 MachineBasicBlock::const_instr_iterator II = std::prev(I.getInstrIterator());
4048 MachineBasicBlock::const_instr_iterator II = ++MI.getIterator();
4050 MachineBasicBlock::const_instr_iterator E = MI.getParent()->instr_end();
4636 MachineBasicBlock::const_instr_iterator I = MI.getIterator();
4637 MachineBasicBlock::const_instr_iterator E = MI.getParent()->instr_end();
4767 void ARMBaseInstrInfo::expandLoadStackGuardBase(MachineBasicBlock::iterator MI,
4773 MachineBasicBlock &MBB = *MI->getParent();
4914 MachineBasicBlock::LivenessQueryResult LQR =
4917 if (LQR == MachineBasicBlock::LQR_Live)
4919 else if (LQR == MachineBasicBlock::LQR_Unknown)
5354 MachineBasicBlock::iterator From,
5368 MachineBasicBlock::iterator CmpMI = Br;
lib/Target/ARM/ARMBaseInstrInfo.h 42 void expandLoadStackGuardBase(MachineBasicBlock::iterator MI,
133 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
133 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
134 MachineBasicBlock *&FBB,
137 unsigned removeBranch(MachineBasicBlock &MBB,
139 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
139 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
140 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
198 void copyToCPSR(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
198 void copyToCPSR(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
201 void copyFromCPSR(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
201 void copyFromCPSR(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
205 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
205 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
209 void storeRegToStackSlot(MachineBasicBlock &MBB,
210 MachineBasicBlock::iterator MBBI,
215 void loadRegFromStackSlot(MachineBasicBlock &MBB,
216 MachineBasicBlock::iterator MBBI,
225 void reMaterialize(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
225 void reMaterialize(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
231 duplicate(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
231 duplicate(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
262 const MachineBasicBlock *MBB,
265 bool isProfitableToIfCvt(MachineBasicBlock &MBB,
269 bool isProfitableToIfCvt(MachineBasicBlock &TMBB, unsigned NumT,
270 unsigned ExtraT, MachineBasicBlock &FMBB,
274 bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
283 bool isProfitableToUnpredicate(MachineBasicBlock &TMBB,
284 MachineBasicBlock &FMBB) const override;
401 virtual void expandLoadStackGuard(MachineBasicBlock::iterator MI) const = 0;
403 void expandMEMCPY(MachineBasicBlock::iterator) const;
568 void emitARMRegPlusImmediate(MachineBasicBlock &MBB,
569 MachineBasicBlock::iterator &MBBI,
575 void emitT2RegPlusImmediate(MachineBasicBlock &MBB,
576 MachineBasicBlock::iterator &MBBI,
581 void emitThumbRegPlusImmediate(MachineBasicBlock &MBB,
582 MachineBasicBlock::iterator &MBBI,
612 bool registerDefinedBetween(unsigned Reg, MachineBasicBlock::iterator From,
lib/Target/ARM/ARMBaseRegisterInfo.cpp 459 MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
459 MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
630 materializeFrameBaseRegister(MachineBasicBlock *MBB,
637 MachineBasicBlock::iterator Ins = MBB->begin();
657 MachineBasicBlock &MBB = *MI.getParent();
749 ARMBaseRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
753 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/ARM/ARMBaseRegisterInfo.h 168 void materializeFrameBaseRegister(MachineBasicBlock *MBB,
186 emitLoadConstPool(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
186 emitLoadConstPool(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
201 void eliminateFrameIndex(MachineBasicBlock::iterator II,
lib/Target/ARM/ARMBasicBlockInfo.cpp 47 void ARMBasicBlockUtils::computeBlockSize(MachineBasicBlock *MBB) {
76 const MachineBasicBlock *MBB = MI->getParent();
84 for (MachineBasicBlock::const_iterator I = MBB->begin(); &*I != MI; ++I) {
94 MachineBasicBlock *DestBB,
117 void ARMBasicBlockUtils::adjustBBOffsetsAfter(MachineBasicBlock *BB) {
lib/Target/ARM/ARMBasicBlockInfo.h 126 for (MachineBasicBlock &MBB : MF)
130 void computeBlockSize(MachineBasicBlock *MBB);
134 unsigned getOffsetOf(MachineBasicBlock *MBB) const {
138 void adjustBBOffsetsAfter(MachineBasicBlock *MBB);
140 void adjustBBSize(MachineBasicBlock *MBB, int Size) {
144 bool isBBInRange(MachineInstr *MI, MachineBasicBlock *DestBB,
lib/Target/ARM/ARMCallLowering.cpp 433 auto &MBB = MIRBuilder.getMBB();
lib/Target/ARM/ARMConstantIslandPass.cpp 108 std::vector<MachineBasicBlock*> WaterList;
112 SmallSet<MachineBasicBlock*, 4> NewWaterList;
114 using water_iterator = std::vector<MachineBasicBlock *>::iterator;
131 MachineBasicBlock *HighWaterMark;
248 bool BBHasFallthrough(MachineBasicBlock *MBB);
253 MachineBasicBlock *splitBlockBeforeInstr(MachineInstr *MI);
254 void updateForInsertedWaterBlock(MachineBasicBlock *NewBB);
261 MachineBasicBlock *&NewMBB);
268 bool isWaterInRange(unsigned UserOffset, MachineBasicBlock *Water,
281 MachineBasicBlock *adjustJTTargetBlockForward(MachineBasicBlock *BB,
281 MachineBasicBlock *adjustJTTargetBlockForward(MachineBasicBlock *BB,
282 MachineBasicBlock *JTBB);
493 MachineBasicBlock *BB = MF->CreateMachineBasicBlock();
511 SmallVector<MachineBasicBlock::iterator, 8> InsPoint(MaxLogAlign + 1,
529 MachineBasicBlock::iterator InsAt = InsPoint[LogAlign];
561 MachineBasicBlock *LastCorrectlyNumberedBB = nullptr;
562 for (MachineBasicBlock &MBB : *MF) {
596 MachineBasicBlock *JumpTableBB = MF->CreateMachineBasicBlock();
617 bool ARMConstantIslands::BBHasFallthrough(MachineBasicBlock *MBB) {
624 MachineBasicBlock *NextBB = &*std::next(MBBI);
630 MachineBasicBlock *TBB, *FBB;
678 for (MachineBasicBlock &MBB : *MF) {
702 for (MachineBasicBlock &MBB : *MF) {
861 static bool CompareMBBNumbers(const MachineBasicBlock *LHS,
862 const MachineBasicBlock *RHS) {
869 void ARMConstantIslands::updateForInsertedWaterBlock(MachineBasicBlock *NewBB) {
886 MachineBasicBlock *ARMConstantIslands::splitBlockBeforeInstr(MachineInstr *MI) {
887 MachineBasicBlock *OrigBB = MI->getParent();
897 MachineBasicBlock *NewBB =
944 MachineBasicBlock* WaterBB = *IP;
1021 MachineBasicBlock* Water, CPUser &U,
1087 static bool BBIsJumpedOver(MachineBasicBlock *MBB) {
1091 MachineBasicBlock *Succ = *MBB->succ_begin();
1092 MachineBasicBlock *Pred = *MBB->pred_begin();
1215 MachineBasicBlock *UserBB = U.MI->getParent();
1223 MachineBasicBlock* WaterBB = *IP;
1267 MachineBasicBlock *&NewMBB) {
1272 MachineBasicBlock *UserMBB = UserMI->getParent();
1365 MachineBasicBlock::iterator I = UserMI;
1380 MachineBasicBlock::iterator MI = UserMI;
1468 MachineBasicBlock *NewIsland = MF->CreateMachineBasicBlock();
1469 MachineBasicBlock *NewMBB;
1473 MachineBasicBlock *WaterBB = *IP;
1493 MachineBasicBlock *WaterBB = &*--NewMBB->getIterator();
1559 MachineBasicBlock *CPEBB = CPEMI->getParent();
1605 MachineBasicBlock *DestBB = MI->getOperand(0).getMBB();
1623 MachineBasicBlock *MBB = MI->getParent();
1650 MachineBasicBlock *DestBB = MI->getOperand(0).getMBB();
1666 MachineBasicBlock *MBB = MI->getParent();
1681 MachineBasicBlock *NewDest = BMI->getOperand(0).getMBB();
1709 MachineBasicBlock *NextBB = &*++MBB->getIterator();
1808 MachineBasicBlock *MBB = U.MI->getParent();
1842 MachineBasicBlock *DestBB = Br.MI->getOperand(0).getMBB();
1846 MachineBasicBlock *MBB = Br.MI->getParent();
1905 MachineBasicBlock *MBB = Br.MI->getParent();
1906 MachineBasicBlock *DestBB = Br.MI->getOperand(0).getMBB();
1935 MachineBasicBlock *DestBB = Br.MI->getOperand(0).getMBB();
1936 MachineBasicBlock *MBB = Br.MI->getParent();
1937 MachineBasicBlock *ExitBB = &MBB->back() == Br.MI ?
1959 MachineBasicBlock::iterator KillMI = Br.MI;
2053 MachineBasicBlock::iterator I(LEAMI);
2128 MachineBasicBlock::iterator I(LEAMI);
2138 MachineBasicBlock::iterator J(RemovableAdd);
2179 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
2182 MachineBasicBlock *MBB = JTBBs[j];
2199 MachineBasicBlock *MBB = MI->getParent();
2294 MachineBasicBlock::iterator MI_JT = MI;
2374 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
2376 MachineBasicBlock *MBB = JTBBs[j];
2382 MachineBasicBlock *NewBB =
2394 MachineBasicBlock *ARMConstantIslands::
2395 adjustJTTargetBlockForward(MachineBasicBlock *BB, MachineBasicBlock *JTBB) {
2395 adjustJTTargetBlockForward(MachineBasicBlock *BB, MachineBasicBlock *JTBB) {
2400 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
2424 MachineBasicBlock *NewBB =
2430 for (const MachineBasicBlock::RegisterMaskPair &RegMaskPair : BB->liveins())
lib/Target/ARM/ARMConstantPoolValue.cpp 264 const MachineBasicBlock *mbb,
273 const MachineBasicBlock *mbb,
lib/Target/ARM/ARMConstantPoolValue.h 248 const MachineBasicBlock *MBB; // Machine basic block.
250 ARMConstantPoolMBB(LLVMContext &C, const MachineBasicBlock *mbb, unsigned id,
256 const MachineBasicBlock *mbb,
259 const MachineBasicBlock *getMBB() const { return MBB; }
lib/Target/ARM/ARMExpandPseudoInsts.cpp 63 bool ExpandMI(MachineBasicBlock &MBB,
64 MachineBasicBlock::iterator MBBI,
66 bool ExpandMBB(MachineBasicBlock &MBB);
67 void ExpandVLD(MachineBasicBlock::iterator &MBBI);
68 void ExpandVST(MachineBasicBlock::iterator &MBBI);
69 void ExpandLaneOp(MachineBasicBlock::iterator &MBBI);
70 void ExpandVTBL(MachineBasicBlock::iterator &MBBI,
72 void ExpandMOV32BitImm(MachineBasicBlock &MBB,
73 MachineBasicBlock::iterator &MBBI);
74 bool ExpandCMP_SWAP(MachineBasicBlock &MBB,
75 MachineBasicBlock::iterator MBBI, unsigned LdrexOp,
79 bool ExpandCMP_SWAP_64(MachineBasicBlock &MBB,
80 MachineBasicBlock::iterator MBBI,
469 void ARMExpandPseudo::ExpandVLD(MachineBasicBlock::iterator &MBBI) {
471 MachineBasicBlock &MBB = *MI.getParent();
580 void ARMExpandPseudo::ExpandVST(MachineBasicBlock::iterator &MBBI) {
582 MachineBasicBlock &MBB = *MI.getParent();
656 void ARMExpandPseudo::ExpandLaneOp(MachineBasicBlock::iterator &MBBI) {
658 MachineBasicBlock &MBB = *MI.getParent();
746 void ARMExpandPseudo::ExpandVTBL(MachineBasicBlock::iterator &MBBI,
749 MachineBasicBlock &MBB = *MI.getParent();
826 void ARMExpandPseudo::ExpandMOV32BitImm(MachineBasicBlock &MBB,
827 MachineBasicBlock::iterator &MBBI) {
927 bool ARMExpandPseudo::ExpandCMP_SWAP(MachineBasicBlock &MBB,
928 MachineBasicBlock::iterator MBBI,
1048 bool ARMExpandPseudo::ExpandCMP_SWAP_64(MachineBasicBlock &MBB,
1049 MachineBasicBlock::iterator MBBI,
1153 bool ARMExpandPseudo::ExpandMI(MachineBasicBlock &MBB,
1154 MachineBasicBlock::iterator MBBI,
1164 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
1957 bool ARMExpandPseudo::ExpandMBB(MachineBasicBlock &MBB) {
1960 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1962 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
1980 for (MachineBasicBlock &MBB : MF)
lib/Target/ARM/ARMFastISel.cpp 1239 MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
1240 MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
1298 MachineBasicBlock *Target = (Imm == 0) ? FBB : TBB;
2943 MachineBasicBlock::iterator I(MI);
lib/Target/ARM/ARMFrameLowering.cpp 74 static MachineBasicBlock::iterator
167 bool isARM, MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
167 bool isARM, MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
179 static void emitSPUpdate(bool isARM, MachineBasicBlock &MBB,
180 MachineBasicBlock::iterator &MBBI, const DebugLoc &dl,
231 MachineBasicBlock::iterator I;
238 void addInst(MachineBasicBlock::iterator I, unsigned SPAdjust,
244 void addExtraBytes(const MachineBasicBlock::iterator I, unsigned ExtraBytes) {
251 void emitDefCFAOffsets(MachineBasicBlock &MBB, const DebugLoc &dl,
281 MachineBasicBlock &MBB,
282 MachineBasicBlock::iterator MBBI,
357 MachineBasicBlock &MBB) const {
358 MachineBasicBlock::iterator MBBI = MBB.begin();
452 MachineBasicBlock::iterator LastPush = MBB.end(), GPRCS1Push, GPRCS2Push;
595 MachineBasicBlock::iterator AfterPush = std::next(GPRCS1Push);
622 MachineBasicBlock::iterator Pos = std::next(GPRCS1Push);
656 MachineBasicBlock::iterator Pos = std::next(GPRCS2Push);
683 MachineBasicBlock::iterator Pos = std::next(LastPush);
771 MachineBasicBlock &MBB) const {
791 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
970 void ARMFrameLowering::emitPushInst(MachineBasicBlock &MBB,
971 MachineBasicBlock::iterator MI,
1048 void ARMFrameLowering::emitPopInst(MachineBasicBlock &MBB,
1049 MachineBasicBlock::iterator MI,
1162 static void emitAlignedDPRCS2Spills(MachineBasicBlock &MBB,
1163 MachineBasicBlock::iterator MI,
1304 static MachineBasicBlock::iterator
1335 static void emitAlignedDPRCS2Restores(MachineBasicBlock &MBB,
1336 MachineBasicBlock::iterator MI,
1425 bool ARMFrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
1426 MachineBasicBlock::iterator MI,
1456 bool ARMFrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
1457 MachineBasicBlock::iterator MI,
1513 for (auto &MBB : MF) {
2145 MachineBasicBlock::iterator ARMFrameLowering::eliminateCallFramePseudoInstr(
2246 MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
2288 MachineBasicBlock *PrevStackMBB = MF.CreateMachineBasicBlock();
2289 MachineBasicBlock *PostStackMBB = MF.CreateMachineBasicBlock();
2290 MachineBasicBlock *AllocMBB = MF.CreateMachineBasicBlock();
2291 MachineBasicBlock *GetMBB = MF.CreateMachineBasicBlock();
2292 MachineBasicBlock *McrMBB = MF.CreateMachineBasicBlock();
2295 SmallPtrSet<MachineBasicBlock *, 8> BeforePrologueRegion;
2296 SmallVector<MachineBasicBlock *, 2> WalkList;
2300 MachineBasicBlock *CurMBB = WalkList.pop_back_val();
2301 for (MachineBasicBlock *PredBB : CurMBB->predecessors()) {
2311 MachineBasicBlock *AddedBlocks[] = {PrevStackMBB, McrMBB, GetMBB, AllocMBB,
2314 for (MachineBasicBlock *B : AddedBlocks)
2318 for (MachineBasicBlock *PredBB : BeforePrologueRegion)
2324 for (MachineBasicBlock *B : AddedBlocks) {
2329 for (MachineBasicBlock *MBB : BeforePrologueRegion) {
lib/Target/ARM/ARMFrameLowering.h 31 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
32 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
34 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
35 MachineBasicBlock::iterator MI,
39 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
40 MachineBasicBlock::iterator MI,
62 MachineBasicBlock &MBB) const override;
75 void emitPushInst(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
75 void emitPushInst(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
80 void emitPopInst(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
80 void emitPopInst(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
86 MachineBasicBlock::iterator
lib/Target/ARM/ARMHazardRecognizer.cpp 54 MachineBasicBlock::iterator I = LastMI;
lib/Target/ARM/ARMISelLowering.cpp 9337 MachineBasicBlock *MBB,
9338 MachineBasicBlock *DispatchBB,
9465 MachineBasicBlock *MBB) const {
9478 DenseMap<unsigned, SmallVector<MachineBasicBlock*, 2>> CallSiteNumToLPad;
9486 for (MachineBasicBlock::iterator
9505 std::vector<MachineBasicBlock*> LPadList;
9506 SmallPtrSet<MachineBasicBlock*, 32> InvokeBBs;
9509 SmallVectorImpl<MachineBasicBlock*> &MBBList = CallSiteNumToLPad[I];
9510 for (SmallVectorImpl<MachineBasicBlock*>::iterator
9528 MachineBasicBlock *DispatchBB = MF->CreateMachineBasicBlock();
9531 MachineBasicBlock *TrapBB = MF->CreateMachineBasicBlock();
9541 MachineBasicBlock *DispContBB = MF->CreateMachineBasicBlock();
9803 SmallPtrSet<MachineBasicBlock*, 8> SeenMBBs;
9804 for (std::vector<MachineBasicBlock*>::iterator
9806 MachineBasicBlock *CurMBB = *I;
9813 SmallVector<MachineBasicBlock*, 64> MBBLPads;
9814 for (MachineBasicBlock *BB : InvokeBBs) {
9818 SmallVector<MachineBasicBlock*, 4> Successors(BB->succ_begin(),
9821 MachineBasicBlock *SMBB = Successors.pop_back_val();
9835 for (MachineBasicBlock::reverse_iterator
9869 for (SmallVectorImpl<MachineBasicBlock*>::iterator
9878 MachineBasicBlock *OtherSucc(MachineBasicBlock *MBB, MachineBasicBlock *Succ) {
9878 MachineBasicBlock *OtherSucc(MachineBasicBlock *MBB, MachineBasicBlock *Succ) {
9878 MachineBasicBlock *OtherSucc(MachineBasicBlock *MBB, MachineBasicBlock *Succ) {
9879 for (MachineBasicBlock::succ_iterator I = MBB->succ_begin(),
9926 static void emitPostLd(MachineBasicBlock *BB, MachineBasicBlock::iterator Pos,
9926 static void emitPostLd(MachineBasicBlock *BB, MachineBasicBlock::iterator Pos,
9967 static void emitPostSt(MachineBasicBlock *BB, MachineBasicBlock::iterator Pos,
9967 static void emitPostSt(MachineBasicBlock *BB, MachineBasicBlock::iterator Pos,
10007 MachineBasicBlock *
10009 MachineBasicBlock *BB) const {
10118 MachineBasicBlock *loopMBB = MF->CreateMachineBasicBlock(LLVM_BB);
10119 MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
10177 MachineBasicBlock *entryBB = BB;
10254 MachineBasicBlock *
10256 MachineBasicBlock *MBB) const {
10329 MachineBasicBlock *
10331 MachineBasicBlock *MBB) const {
10336 MachineBasicBlock *ContBB = MF->CreateMachineBasicBlock();
10343 MachineBasicBlock *TrapBB = MF->CreateMachineBasicBlock();
10366 static bool checkAndUpdateCPSRKill(MachineBasicBlock::iterator SelectItr,
10370 MachineBasicBlock::iterator miI(std::next(SelectItr));
10371 for (MachineBasicBlock::iterator miE = BB->end(); miI != miE; ++miI) {
10382 for (MachineBasicBlock::succ_iterator sItr = BB->succ_begin(),
10385 MachineBasicBlock* succ = *sItr;
10397 MachineBasicBlock *
10399 MachineBasicBlock *BB) const {
10490 MachineBasicBlock *thisMBB = BB;
10492 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
10493 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
10571 MachineBasicBlock *destMBB = MI.getOperand(RHSisZero ? 3 : 5).getMBB();
10572 MachineBasicBlock *exitMBB = OtherSucc(BB, destMBB);
10617 MachineBasicBlock *RSBBB = Fn->CreateMachineBasicBlock(LLVM_BB);
10618 MachineBasicBlock *SinkBB = Fn->CreateMachineBasicBlock(LLVM_BB);
17089 void ARMTargetLowering::initializeSplitCSR(MachineBasicBlock *Entry) const {
17096 MachineBasicBlock *Entry,
17097 const SmallVectorImpl<MachineBasicBlock *> &Exits) const {
17105 MachineBasicBlock::iterator MBBI = Entry->begin();
17129 for (auto *Exit : Exits)
lib/Target/ARM/ARMISelLowering.h 324 MachineBasicBlock *
326 MachineBasicBlock *MBB) const override;
766 void initializeSplitCSR(MachineBasicBlock *Entry) const override;
768 MachineBasicBlock *Entry,
769 const SmallVectorImpl<MachineBasicBlock *> &Exits) const override;
833 void SetupEntryBlockForSjLj(MachineInstr &MI, MachineBasicBlock *MBB,
834 MachineBasicBlock *DispatchBB, int FI) const;
836 void EmitSjLjDispatchBlock(MachineInstr &MI, MachineBasicBlock *MBB) const;
838 bool RemapAddSubWithFlags(MachineInstr &MI, MachineBasicBlock *BB) const;
840 MachineBasicBlock *EmitStructByval(MachineInstr &MI,
841 MachineBasicBlock *MBB) const;
843 MachineBasicBlock *EmitLowered__chkstk(MachineInstr &MI,
844 MachineBasicBlock *MBB) const;
845 MachineBasicBlock *EmitLowered__dbzchk(MachineInstr &MI,
846 MachineBasicBlock *MBB) const;
lib/Target/ARM/ARMInstrInfo.cpp 92 void ARMInstrInfo::expandLoadStackGuard(MachineBasicBlock::iterator MI) const {
118 MachineBasicBlock &MBB = *MI->getParent();
lib/Target/ARM/ARMInstrInfo.h 41 void expandLoadStackGuard(MachineBasicBlock::iterator MI) const override;
lib/Target/ARM/ARMInstructionSelector.cpp 486 MachineBasicBlock &MBB;
487 const MachineBasicBlock::instr_iterator InsertBefore;
621 auto &MBB = *MIB->getParent();
768 auto &MBB = *MIB->getParent();
840 auto &MBB = *I.getParent();
lib/Target/ARM/ARMLoadStoreOptimizer.cpp 110 MachineBasicBlock::const_iterator LiveRegPos;
165 void moveLiveRegsBefore(const MachineBasicBlock &MBB,
166 MachineBasicBlock::const_iterator Before);
168 void UpdateBaseRegUses(MachineBasicBlock &MBB,
169 MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
173 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
173 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
179 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
179 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
186 bool FixInvalidRegPairOp(MachineBasicBlock &MBB,
187 MachineBasicBlock::iterator &MBBI);
191 bool LoadStoreMultipleOpti(MachineBasicBlock &MBB);
192 bool MergeReturnIntoLDM(MachineBasicBlock &MBB);
193 bool CombineMovBx(MachineBasicBlock &MBB);
481 void ARMLoadStoreOpt::UpdateBaseRegUses(MachineBasicBlock &MBB,
482 MachineBasicBlock::iterator MBBI,
596 void ARMLoadStoreOpt::moveLiveRegsBefore(const MachineBasicBlock &MBB,
597 MachineBasicBlock::const_iterator Before) {
624 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
624 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
636 MachineBasicBlock::LQR_Dead);
826 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
826 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore,
890 using iterator = MachineBasicBlock::iterator;
894 MachineBasicBlock &MBB = *LatestMI->getParent();
1210 static MachineBasicBlock::iterator
1214 MachineBasicBlock &MBB = *MBBI->getParent();
1215 MachineBasicBlock::iterator BeginMBBI = MBB.begin();
1216 MachineBasicBlock::iterator EndMBBI = MBB.end();
1221 MachineBasicBlock::iterator PrevMBBI = std::prev(MBBI);
1230 static MachineBasicBlock::iterator
1234 MachineBasicBlock &MBB = *MBBI->getParent();
1235 MachineBasicBlock::iterator EndMBBI = MBB.end();
1236 MachineBasicBlock::iterator NextMBBI = std::next(MBBI);
1278 MachineBasicBlock &MBB = *MI->getParent();
1279 MachineBasicBlock::iterator MBBI(MI);
1281 MachineBasicBlock::iterator MergeInstr
1411 MachineBasicBlock &MBB = *MI->getParent();
1412 MachineBasicBlock::iterator MBBI(MI);
1414 MachineBasicBlock::iterator MergeInstr
1523 MachineBasicBlock::iterator MBBI(MI);
1524 MachineBasicBlock &MBB = *MI.getParent();
1526 MachineBasicBlock::iterator MergeInstr = findIncDecBefore(MBBI, Base, Pred,
1620 static void InsertLDR_STR(MachineBasicBlock &MBB,
1621 MachineBasicBlock::iterator &MBBI, int Offset,
1648 bool ARMLoadStoreOpt::FixInvalidRegPairOp(MachineBasicBlock &MBB,
1649 MachineBasicBlock::iterator &MBBI) {
1765 bool ARMLoadStoreOpt::LoadStoreMultipleOpti(MachineBasicBlock &MBB) {
1775 for (MachineBasicBlock::iterator I = MBB.end(), MBBI; I != MBB.begin();
1924 bool ARMLoadStoreOpt::MergeReturnIntoLDM(MachineBasicBlock &MBB) {
1929 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
1934 MachineBasicBlock::iterator PrevI = std::prev(MBBI);
1970 bool ARMLoadStoreOpt::CombineMovBx(MachineBasicBlock &MBB) {
1971 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
1976 MachineBasicBlock::iterator Prev = MBBI;
2014 MachineBasicBlock &MBB = *MFI;
2064 bool RescheduleOps(MachineBasicBlock *MBB,
2068 bool RescheduleLoadStoreInstrs(MachineBasicBlock *MBB);
2096 for (MachineBasicBlock &MFI : Fn)
2103 MachineBasicBlock::iterator I,
2215 bool ARMPreAllocLoadStoreOpt::RescheduleOps(MachineBasicBlock *MBB,
2300 MachineBasicBlock::iterator InsertPos = isLd ? FirstOp : LastOp;
2383 ARMPreAllocLoadStoreOpt::RescheduleLoadStoreInstrs(MachineBasicBlock *MBB) {
2396 MachineBasicBlock::iterator MBBI = MBB->begin();
2397 MachineBasicBlock::iterator E = MBB->end();
lib/Target/ARM/ARMLowOverheadLoops.cpp 132 MachineBasicBlock::iterator End,
156 MachineBasicBlock *MBB = Start->getParent();
175 MachineBasicBlock::iterator End(SuccLRDef);
182 MachineBasicBlock::reverse_iterator End(PredLRDef);
225 std::function<MachineInstr*(MachineBasicBlock*)> SearchForStart =
245 if (auto *Preheader = ML->getLoopPreheader()) {
250 MachineBasicBlock *Pred = nullptr;
251 for (auto *MBB : ML->getHeader()->predecessors()) {
266 for (auto *MBB : reverse(ML->getBlocks())) {
361 MachineBasicBlock *MBB = MI->getParent();
369 MachineBasicBlock *DestBB = MI->getOperand(1).getMBB();
383 MachineBasicBlock *MBB = MI->getParent();
417 MachineBasicBlock *MBB = MI->getParent();
428 MachineBasicBlock *DestBB = MI->getOperand(1).getMBB();
448 MachineBasicBlock *MBB = InsertPt->getParent();
469 MachineBasicBlock *MBB = End->getParent();
488 MachineBasicBlock *BB = I->getParent();
491 MachineBasicBlock *Succ = Terminator->getOperand(0).getMBB();
518 for (auto &MBB : *MF) {
lib/Target/ARM/ARMMachineFunctionInfo.h 122 DenseMap<const MachineBasicBlock*, unsigned> CoalescedWeights;
229 DenseMap<const MachineBasicBlock*, unsigned>::iterator getCoalescedWeight(
lib/Target/ARM/ARMOptimizeBarriersPass.cpp 62 for (auto &MBB : MF) {
lib/Target/ARM/MLxExpansionPass.cpp 67 void ExpandFPMLxInstruction(MachineBasicBlock &MBB, MachineInstr *MI,
70 bool ExpandFPMLxInstructions(MachineBasicBlock &MBB);
93 MachineBasicBlock *MBB = MI->getParent();
121 MachineBasicBlock *MBB = MI->getParent();
145 MachineBasicBlock *MBB = MI->getParent();
269 MLxExpansion::ExpandFPMLxInstruction(MachineBasicBlock &MBB, MachineInstr *MI,
325 bool MLxExpansion::ExpandFPMLxInstructions(MachineBasicBlock &MBB) {
332 MachineBasicBlock::reverse_iterator MII = MBB.rbegin(), E = MBB.rend();
384 for (MachineBasicBlock &MBB : Fn)
lib/Target/ARM/MVEVPTBlockPass.cpp 57 bool InsertVPTBlocks(MachineBasicBlock &MBB);
137 static MachineInstr *findVCMPToFoldIntoVPST(MachineBasicBlock::iterator MI,
143 MachineBasicBlock::iterator CmpMI = MI;
168 bool MVEVPTBlock::InsertVPTBlocks(MachineBasicBlock &Block) {
170 MachineBasicBlock::instr_iterator MBIter = Block.instr_begin();
171 MachineBasicBlock::instr_iterator EndIter = Block.instr_end();
269 for (MachineBasicBlock &MBB : Fn)
lib/Target/ARM/Thumb1FrameLowering.cpp 67 emitPrologueEpilogueSPUpdate(MachineBasicBlock &MBB,
68 MachineBasicBlock::iterator &MBBI,
102 static void emitCallSPUpdate(MachineBasicBlock &MBB,
103 MachineBasicBlock::iterator &MBBI,
112 MachineBasicBlock::iterator Thumb1FrameLowering::
146 MachineBasicBlock &MBB) const {
147 MachineBasicBlock::iterator MBBI = MBB.begin();
333 MachineBasicBlock::iterator OldMBBI = MBBI;
471 MachineBasicBlock &MBB) const {
472 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
541 MachineBasicBlock::iterator PMBBI = std::prev(MBBI);
558 bool Thumb1FrameLowering::canUseAsEpilogue(const MachineBasicBlock &MBB) const {
562 MachineBasicBlock *TmpMBB = const_cast<MachineBasicBlock *>(&MBB);
600 bool Thumb1FrameLowering::emitPopSpecialFixUp(MachineBasicBlock &MBB,
808 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
809 MachineBasicBlock::iterator MI,
931 restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
932 MachineBasicBlock::iterator MI,
lib/Target/ARM/Thumb1FrameLowering.h 25 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
26 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
28 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
29 MachineBasicBlock::iterator MI,
32 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
33 MachineBasicBlock::iterator MI,
39 MachineBasicBlock::iterator
49 bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
83 bool emitPopSpecialFixUp(MachineBasicBlock &MBB, bool DoIt) const;
lib/Target/ARM/Thumb1InstrInfo.cpp 38 void Thumb1InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
39 MachineBasicBlock::iterator I,
60 == MachineBasicBlock::LQR_Dead) {
78 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
78 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
106 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
106 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
134 MachineBasicBlock::iterator MI) const {
lib/Target/ARM/Thumb1InstrInfo.h 40 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
40 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
43 void storeRegToStackSlot(MachineBasicBlock &MBB,
44 MachineBasicBlock::iterator MBBI,
49 void loadRegFromStackSlot(MachineBasicBlock &MBB,
50 MachineBasicBlock::iterator MBBI,
57 void expandLoadStackGuard(MachineBasicBlock::iterator MI) const override;
lib/Target/ARM/Thumb2ITBlockPass.cpp 69 bool InsertITInstructions(MachineBasicBlock &Block);
178 MachineBasicBlock::iterator I = MI;
180 MachineBasicBlock::iterator E = MI->getParent()->end();
194 bool Thumb2ITBlock::InsertITInstructions(MachineBasicBlock &MBB) {
197 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
222 MachineBasicBlock::iterator InsertPos = MIB.getInstr();
299 for (auto &MBB : Fn )
lib/Target/ARM/Thumb2InstrInfo.cpp 58 Thumb2InstrInfo::ReplaceTailWithBranchTo(MachineBasicBlock::iterator Tail,
60 MachineBasicBlock *MBB = Tail->getParent();
71 MachineBasicBlock::iterator MBBI = Tail;
81 MachineBasicBlock::iterator E = MBB->begin();
109 Thumb2InstrInfo::isLegalToSplitMBBAt(MachineBasicBlock &MBB,
110 MachineBasicBlock::iterator MBBI) const {
121 void Thumb2InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
122 MachineBasicBlock::iterator I,
135 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
135 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
178 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
178 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
222 MachineBasicBlock::iterator MI) const {
230 void llvm::emitT2RegPlusImmediate(MachineBasicBlock &MBB,
231 MachineBasicBlock::iterator &MBBI,
lib/Target/ARM/Thumb2InstrInfo.h 35 void ReplaceTailWithBranchTo(MachineBasicBlock::iterator Tail,
38 bool isLegalToSplitMBBAt(MachineBasicBlock &MBB,
39 MachineBasicBlock::iterator MBBI) const override;
41 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
41 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
45 void storeRegToStackSlot(MachineBasicBlock &MBB,
46 MachineBasicBlock::iterator MBBI,
51 void loadRegFromStackSlot(MachineBasicBlock &MBB,
52 MachineBasicBlock::iterator MBBI,
64 void expandLoadStackGuard(MachineBasicBlock::iterator MI) const override;
lib/Target/ARM/Thumb2SizeReduction.cpp 189 bool ReduceLoadStore(MachineBasicBlock &MBB, MachineInstr *MI,
192 bool ReduceSpecial(MachineBasicBlock &MBB, MachineInstr *MI,
197 bool ReduceTo2Addr(MachineBasicBlock &MBB, MachineInstr *MI,
203 bool ReduceToNarrow(MachineBasicBlock &MBB, MachineInstr *MI,
208 bool ReduceMI(MachineBasicBlock &MBB, MachineInstr *MI,
212 bool ReduceMBB(MachineBasicBlock &MBB);
404 Thumb2SizeReduce::ReduceLoadStore(MachineBasicBlock &MBB, MachineInstr *MI,
622 Thumb2SizeReduce::ReduceSpecial(MachineBasicBlock &MBB, MachineInstr *MI,
735 Thumb2SizeReduce::ReduceTo2Addr(MachineBasicBlock &MBB, MachineInstr *MI,
850 Thumb2SizeReduce::ReduceToNarrow(MachineBasicBlock &MBB, MachineInstr *MI,
1004 bool Thumb2SizeReduce::ReduceMI(MachineBasicBlock &MBB, MachineInstr *MI,
1029 bool Thumb2SizeReduce::ReduceMBB(MachineBasicBlock &MBB) {
1040 for (auto *Pred : MBB.predecessors()) {
1055 MachineBasicBlock::instr_iterator MII = MBB.instr_begin(),E = MBB.instr_end();
1056 MachineBasicBlock::instr_iterator NextMII;
1075 MachineBasicBlock::instr_iterator I = std::prev(NextMII);
lib/Target/ARM/ThumbRegisterInfo.cpp 61 static void emitThumb1LoadConstPool(MachineBasicBlock &MBB,
62 MachineBasicBlock::iterator &MBBI,
81 static void emitThumb2LoadConstPool(MachineBasicBlock &MBB,
82 MachineBasicBlock::iterator &MBBI,
104 MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
104 MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
125 MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
125 MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
186 void llvm::emitThumbRegPlusImmediate(MachineBasicBlock &MBB,
187 MachineBasicBlock::iterator &MBBI,
359 bool ThumbRegisterInfo::rewriteFrameIndex(MachineBasicBlock::iterator II,
364 MachineBasicBlock &MBB = *MI.getParent();
450 void ThumbRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
454 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/ARM/ThumbRegisterInfo.h 40 emitLoadConstPool(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
40 emitLoadConstPool(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
49 bool rewriteFrameIndex(MachineBasicBlock::iterator II, unsigned FrameRegIdx,
54 void eliminateFrameIndex(MachineBasicBlock::iterator II,
lib/Target/AVR/AVRExpandPseudoInsts.cpp 47 typedef MachineBasicBlock Block;
97 bool AVRExpandPseudo::expandMBB(MachineBasicBlock &MBB) {
864 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/AVR/AVRFrameLowering.cpp 54 MachineBasicBlock &MBB) const {
55 MachineBasicBlock::iterator MBBI = MBB.begin();
145 MachineBasicBlock &MBB) const {
156 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
187 MachineBasicBlock::iterator PI = std::prev(MBBI);
236 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
236 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
277 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
277 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
305 static void fixStackStores(MachineBasicBlock &MBB,
306 MachineBasicBlock::iterator MI,
313 MachineBasicBlock::iterator NextMI = std::next(I);
361 MachineBasicBlock::iterator AVRFrameLowering::eliminateCallFramePseudoInstr(
460 for (const MachineBasicBlock &BB : MF) {
509 MachineBasicBlock &EntryMBB = MF.front();
510 MachineBasicBlock::iterator MBBI = EntryMBB.begin();
521 for (MachineBasicBlock &MBB : MF) {
lib/Target/AVR/AVRFrameLowering.h 22 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
23 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
25 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
26 MachineBasicBlock::iterator MI,
30 restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
31 MachineBasicBlock::iterator MI,
38 MachineBasicBlock::iterator
lib/Target/AVR/AVRISelLowering.cpp 1436 MachineBasicBlock *AVRTargetLowering::insertShift(MachineInstr &MI,
1437 MachineBasicBlock *BB) const {
1500 MachineBasicBlock *LoopBB = F->CreateMachineBasicBlock(LLVM_BB);
1501 MachineBasicBlock *RemBB = F->CreateMachineBasicBlock(LLVM_BB);
1569 static bool isCopyMulResult(MachineBasicBlock::iterator const &I) {
1581 MachineBasicBlock *AVRTargetLowering::insertMul(MachineInstr &MI,
1582 MachineBasicBlock *BB) const {
1584 MachineBasicBlock::iterator I(MI);
1596 MachineBasicBlock *
1598 MachineBasicBlock *MBB) const {
1637 MachineBasicBlock *FallThrough = MBB->getFallThrough();
1646 MachineBasicBlock *trueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
1647 MachineBasicBlock *falseMBB = MF->CreateMachineBasicBlock(LLVM_BB);
lib/Target/AVR/AVRISelLowering.h 108 MachineBasicBlock *
110 MachineBasicBlock *MBB) const override;
178 MachineBasicBlock *insertShift(MachineInstr &MI, MachineBasicBlock *BB) const;
178 MachineBasicBlock *insertShift(MachineInstr &MI, MachineBasicBlock *BB) const;
179 MachineBasicBlock *insertMul(MachineInstr &MI, MachineBasicBlock *BB) const;
179 MachineBasicBlock *insertMul(MachineInstr &MI, MachineBasicBlock *BB) const;
lib/Target/AVR/AVRInstrInfo.cpp 41 void AVRInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
42 MachineBasicBlock::iterator MI,
120 void AVRInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
121 MachineBasicBlock::iterator MI,
159 void AVRInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
160 MachineBasicBlock::iterator MI,
263 bool AVRInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
264 MachineBasicBlock *&TBB,
265 MachineBasicBlock *&FBB,
270 MachineBasicBlock::iterator I = MBB.end();
271 MachineBasicBlock::iterator UnCondBrIter = MBB.end();
331 MachineBasicBlock *TargetBB = I->getOperand(0).getMBB();
353 MachineBasicBlock::iterator OldInst = I;
398 unsigned AVRInstrInfo::insertBranch(MachineBasicBlock &MBB,
399 MachineBasicBlock *TBB,
400 MachineBasicBlock *FBB,
437 unsigned AVRInstrInfo::removeBranch(MachineBasicBlock &MBB,
441 MachineBasicBlock::iterator I = MBB.end();
503 MachineBasicBlock *
558 unsigned AVRInstrInfo::insertIndirectBranch(MachineBasicBlock &MBB,
559 MachineBasicBlock &NewDestBB,
lib/Target/AVR/AVRInstrInfo.h 74 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
74 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
77 void storeRegToStackSlot(MachineBasicBlock &MBB,
78 MachineBasicBlock::iterator MI, unsigned SrcReg,
82 void loadRegFromStackSlot(MachineBasicBlock &MBB,
83 MachineBasicBlock::iterator MI, unsigned DestReg,
92 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
92 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
93 MachineBasicBlock *&FBB,
96 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
96 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
97 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
100 unsigned removeBranch(MachineBasicBlock &MBB,
105 MachineBasicBlock *getBranchDestBlock(const MachineInstr &MI) const override;
110 unsigned insertIndirectBranch(MachineBasicBlock &MBB,
111 MachineBasicBlock &NewDestBB,
lib/Target/AVR/AVRRegisterInfo.cpp 98 static void foldFrameOffset(MachineBasicBlock::iterator &II, int &Offset, unsigned DstReg) {
128 void AVRRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
135 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/AVR/AVRRegisterInfo.h 40 void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
lib/Target/AVR/AVRRelaxMemOperations.cpp 43 typedef MachineBasicBlock Block;
lib/Target/BPF/BPFFrameLowering.cpp 26 MachineBasicBlock &MBB) const {}
29 MachineBasicBlock &MBB) const {}
lib/Target/BPF/BPFFrameLowering.h 26 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
27 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
33 MachineBasicBlock::iterator
lib/Target/BPF/BPFISelLowering.cpp 564 BPFTargetLowering::EmitSubregExt(MachineInstr &MI, MachineBasicBlock *BB,
585 MachineBasicBlock *
587 MachineBasicBlock *BB)
616 MachineBasicBlock *
618 MachineBasicBlock *BB) const {
660 MachineBasicBlock *ThisMBB = BB;
662 MachineBasicBlock *Copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
663 MachineBasicBlock *Copy1MBB = F->CreateMachineBasicBlock(LLVM_BB);
lib/Target/BPF/BPFISelLowering.h 53 MachineBasicBlock *
55 MachineBasicBlock *BB) const override;
113 unsigned EmitSubregExt(MachineInstr &MI, MachineBasicBlock *BB, unsigned Reg,
116 MachineBasicBlock * EmitInstrWithCustomInserterMemcpy(MachineInstr &MI,
117 MachineBasicBlock *BB)
lib/Target/BPF/BPFInstrInfo.cpp 31 void BPFInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
32 MachineBasicBlock::iterator I,
45 void BPFInstrInfo::expandMEMCPY(MachineBasicBlock::iterator MI) const {
51 MachineBasicBlock *BB = MI->getParent();
124 void BPFInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
125 MachineBasicBlock::iterator I,
147 void BPFInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
148 MachineBasicBlock::iterator I,
164 bool BPFInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
165 MachineBasicBlock *&TBB,
166 MachineBasicBlock *&FBB,
171 MachineBasicBlock::iterator I = MBB.end();
219 unsigned BPFInstrInfo::insertBranch(MachineBasicBlock &MBB,
220 MachineBasicBlock *TBB,
221 MachineBasicBlock *FBB,
240 unsigned BPFInstrInfo::removeBranch(MachineBasicBlock &MBB,
244 MachineBasicBlock::iterator I = MBB.end();
lib/Target/BPF/BPFInstrInfo.h 32 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
32 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
38 void storeRegToStackSlot(MachineBasicBlock &MBB,
39 MachineBasicBlock::iterator MBBI, unsigned SrcReg,
44 void loadRegFromStackSlot(MachineBasicBlock &MBB,
45 MachineBasicBlock::iterator MBBI, unsigned DestReg,
48 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
48 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
49 MachineBasicBlock *&FBB,
53 unsigned removeBranch(MachineBasicBlock &MBB,
55 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
55 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
56 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
60 void expandMEMCPY(MachineBasicBlock::iterator) const;
lib/Target/BPF/BPFMIChecking.cpp 157 for (MachineBasicBlock &MBB : *MF) {
lib/Target/BPF/BPFMIPeephole.cpp 123 for (MachineBasicBlock &MBB : *MF) {
240 for (MachineBasicBlock &MBB : *MF) {
361 for (MachineBasicBlock &MBB : *MF) {
lib/Target/BPF/BPFMISimplifyPatchable.cpp 80 for (MachineBasicBlock &MBB : *MF) {
lib/Target/BPF/BPFRegisterInfo.cpp 56 void BPFRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
63 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/BPF/BPFRegisterInfo.h 31 void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
lib/Target/Hexagon/BitTracker.cpp 774 const MachineBasicBlock *BA = InstA->getParent();
775 const MachineBasicBlock *BB = InstB->getParent();
786 MachineBasicBlock::const_iterator I = MI->getParent()->begin();
787 MachineBasicBlock::const_iterator E = MI->getIterator();
815 const MachineBasicBlock *PB = PI.getOperand(i + 1).getMBB();
920 const MachineBasicBlock &B = *BI.getParent();
921 MachineBasicBlock::const_iterator It = BI, End = B.end();
961 for (const MachineBasicBlock *SB : B.successors()) {
972 for (const MachineBasicBlock *SB : B.successors())
976 for (const MachineBasicBlock *TB : Targets)
1024 bool BT::reached(const MachineBasicBlock *B) const {
1063 const MachineBasicBlock &B = *MF.getBlockNumbered(Edge.second);
1064 MachineBasicBlock::const_iterator It = B.begin(), End = B.end();
1123 const MachineBasicBlock *Entry = MachineFlowGraphTraits::getEntryNode(&MF);
1126 for (const MachineBasicBlock &B : MF) {
lib/Target/Hexagon/BitTracker.h 43 using BranchTargetList = SetVector<const MachineBasicBlock *>;
56 bool reached(const MachineBasicBlock *B) const;
lib/Target/Hexagon/HexagonAsmPrinter.cpp 107 const MachineBasicBlock *MBB) const {
750 const MachineBasicBlock* MBB = MI->getParent();
751 MachineBasicBlock::const_instr_iterator MII = MI->getIterator();
lib/Target/Hexagon/HexagonAsmPrinter.h 46 bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB)
lib/Target/Hexagon/HexagonBitSimplify.cpp 233 bool visitBlock(MachineBasicBlock &B, Transformation &T, RegisterSet &AVs);
250 virtual bool processBlock(MachineBasicBlock &B, const RegisterSet &AVs) = 0;
263 bool HexagonBitSimplify::visitBlock(MachineBasicBlock &B, Transformation &T,
994 MachineBasicBlock *B = N->getBlock();
1055 bool processBlock(MachineBasicBlock &B, const RegisterSet &AVs) override;
1300 bool RedundantInstrElimination::processBlock(MachineBasicBlock &B,
1378 bool processBlock(MachineBasicBlock &B, const RegisterSet &AVs) override;
1383 MachineBasicBlock &B, MachineBasicBlock::iterator At, DebugLoc &DL);
1383 MachineBasicBlock &B, MachineBasicBlock::iterator At, DebugLoc &DL);
1411 MachineBasicBlock &B, MachineBasicBlock::iterator At, DebugLoc &DL) {
1411 MachineBasicBlock &B, MachineBasicBlock::iterator At, DebugLoc &DL) {
1456 bool ConstGeneration::processBlock(MachineBasicBlock &B, const RegisterSet&) {
1500 bool processBlock(MachineBasicBlock &B, const RegisterSet &AVs) override;
1520 bool processBlock(MachineBasicBlock &B, const RegisterSet &AVs) override;
1582 bool CopyGeneration::processBlock(MachineBasicBlock &B,
1716 bool CopyPropagation::processBlock(MachineBasicBlock &B, const RegisterSet&) {
1745 bool processBlock(MachineBasicBlock &B, const RegisterSet &AVs) override;
2024 MachineBasicBlock &B = *MI->getParent();
2047 MachineBasicBlock &B = *MI->getParent();
2095 MachineBasicBlock &B = *MI->getParent();
2136 MachineBasicBlock &B = *MI->getParent();
2266 MachineBasicBlock &B = *DefS->getParent();
2335 MachineBasicBlock &B = *MI->getParent();
2540 MachineBasicBlock &B = *MI->getParent();
2589 MachineBasicBlock &B = *MI->getParent();
2696 bool BitSimplification::processBlock(MachineBasicBlock &B,
2777 MachineBasicBlock &Entry = MF.front();
2809 for (auto &B : MF)
2905 LoopCand(MachineBasicBlock *lb, MachineBasicBlock *pb,
2905 LoopCand(MachineBasicBlock *lb, MachineBasicBlock *pb,
2906 MachineBasicBlock *eb) : LB(lb), PB(pb), EB(eb) {}
2908 MachineBasicBlock *LB, *PB, *EB;
2916 PhiInfo(MachineInstr &P, MachineBasicBlock &B);
2920 MachineBasicBlock *LB, *PB; // Loop Block, Preheader Block
2930 void moveGroup(InstrGroup &G, MachineBasicBlock &LB, MachineBasicBlock &PB,
2930 void moveGroup(InstrGroup &G, MachineBasicBlock &LB, MachineBasicBlock &PB,
2931 MachineBasicBlock::iterator At, unsigned OldPhiR, unsigned NewPredR);
2943 MachineBasicBlock &B) {
3065 void HexagonLoopRescheduling::moveGroup(InstrGroup &G, MachineBasicBlock &LB,
3066 MachineBasicBlock &PB, MachineBasicBlock::iterator At, unsigned OldPhiR,
3066 MachineBasicBlock &PB, MachineBasicBlock::iterator At, unsigned OldPhiR,
3325 for (auto &B : MF) {
3328 MachineBasicBlock *PB = nullptr;
3339 MachineBasicBlock *EB = nullptr;
lib/Target/Hexagon/HexagonBlockRanges.cpp 157 HexagonBlockRanges::InstrIndexMap::InstrIndexMap(MachineBasicBlock &B)
233 const MachineBasicBlock &B, const MachineRegisterInfo &MRI,
294 MachineBasicBlock &B = IndexMap.getBlock();
398 for (auto *SB : B.successors())
lib/Target/Hexagon/HexagonBlockRanges.h 124 InstrIndexMap(MachineBasicBlock &B);
128 MachineBasicBlock &getBlock() const { return Block; }
138 MachineBasicBlock &Block;
161 RegisterSet getLiveIns(const MachineBasicBlock &B,
lib/Target/Hexagon/HexagonBranchRelaxation.cpp 73 DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset);
75 DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset);
77 DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset);
104 DenseMap<MachineBasicBlock*, unsigned> &OffsetMap) {
107 for (auto &B : MF) {
133 DenseMap<MachineBasicBlock*, unsigned> BlockToInstOffset;
144 DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset) {
145 MachineBasicBlock &B = *MI.getParent();
161 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
194 DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset) {
197 for (auto &B : MF) {
lib/Target/Hexagon/HexagonCFGOptimizer.cpp 38 void InvertAndChangeJumpTarget(MachineInstr &, MachineBasicBlock *);
39 bool isOnFallThroughPath(MachineBasicBlock *MBB);
81 MachineInstr &MI, MachineBasicBlock *NewTarget) {
106 bool HexagonCFGOptimizer::isOnFallThroughPath(MachineBasicBlock *MBB) {
109 for (MachineBasicBlock *PB : MBB->predecessors())
122 MachineBasicBlock *MBB = &*MBBb;
125 MachineBasicBlock::iterator MII = MBB->getFirstTerminator();
158 MachineBasicBlock::succ_iterator SI = MBB->succ_begin();
159 MachineBasicBlock* FirstSucc = *SI;
160 MachineBasicBlock* SecondSucc = *(++SI);
161 MachineBasicBlock* LayoutSucc = nullptr;
162 MachineBasicBlock* JumpAroundTarget = nullptr;
176 MachineBasicBlock* CondBranchTarget = nullptr;
191 MachineBasicBlock* UncondTarget =
222 std::vector<MachineBasicBlock::RegisterMaskPair> OrigLiveIn(
224 std::vector<MachineBasicBlock::RegisterMaskPair> NewLiveIn(
lib/Target/Hexagon/HexagonConstExtenders.cpp 190 MachineBasicBlock *Block = nullptr;
191 MachineBasicBlock::iterator At;
193 Loc(MachineBasicBlock *B, MachineBasicBlock::iterator It)
193 Loc(MachineBasicBlock *B, MachineBasicBlock::iterator It)
493 const MachineBasicBlock &MBB = *ED.getOp().getParent()->getParent();
1246 for (MachineBasicBlock &MBB : MF) {
1486 DenseSet<MachineBasicBlock*> Blocks;
1489 MachineBasicBlock *DomB = ED0.UseMI->getParent();
1494 MachineBasicBlock *MBB = ED.UseMI->getParent();
1511 MachineBasicBlock::iterator It;
1514 MachineBasicBlock::iterator End = DomB->end();
1529 MachineBasicBlock &MBB = *DefL.Block;
1530 MachineBasicBlock::iterator At = DefL.At;
1585 MachineBasicBlock &MBB = *MI.getParent();
1586 MachineBasicBlock::iterator At = MI.getIterator();
1703 MachineBasicBlock &MBB = *MI.getParent();
1704 MachineBasicBlock::iterator At = MI.getIterator();
1972 const MachineBasicBlock *BA = MA->getParent();
1973 const MachineBasicBlock *BB = MB->getParent();
lib/Target/Hexagon/HexagonConstPropagation.cpp 256 bool computeBlockSuccessors(const MachineBasicBlock *MB,
257 SetVector<const MachineBasicBlock*> &Targets);
258 void removeCFGEdge(MachineBasicBlock *From, MachineBasicBlock *To);
258 void removeCFGEdge(MachineBasicBlock *From, MachineBasicBlock *To);
309 SetVector<const MachineBasicBlock*> &Targets,
620 const MachineBasicBlock *MB = PN.getParent();
644 const MachineBasicBlock *PB = PN.getOperand(i+1).getMBB();
724 const MachineBasicBlock &B = *BrI.getParent();
726 MachineBasicBlock::const_iterator It = BrI.getIterator();
727 MachineBasicBlock::const_iterator End = B.end();
729 SetVector<const MachineBasicBlock*> Targets;
751 for (const MachineBasicBlock *SB : B.successors()) {
771 for (const MachineBasicBlock *SB : B.successors())
775 for (const MachineBasicBlock *TB : Targets) {
801 bool MachineConstPropagator::computeBlockSuccessors(const MachineBasicBlock *MB,
802 SetVector<const MachineBasicBlock*> &Targets) {
803 MachineBasicBlock::const_iterator FirstBr = MB->end();
814 MachineBasicBlock::const_iterator End = MB->end();
817 for (MachineBasicBlock::const_iterator I = FirstBr; I != End; ++I) {
839 for (const MachineBasicBlock *SB : MB->successors())
846 void MachineConstPropagator::removeCFGEdge(MachineBasicBlock *From,
847 MachineBasicBlock *To) {
866 MachineBasicBlock *Entry = GraphTraits<MachineFunction*>::getEntryNode(&MF);
884 MachineBasicBlock *SB = MF.getBlockNumbered(Edge.second);
890 MachineBasicBlock::const_iterator It = SB->begin(), End = SB->end();
928 for (const MachineBasicBlock *SSB : SB->successors())
967 std::vector<MachineBasicBlock*> POT;
968 for (MachineBasicBlock *B : post_order(&MF))
972 for (MachineBasicBlock *B : POT) {
980 SetVector<const MachineBasicBlock*> Targets;
1013 SmallVector<MachineBasicBlock*,2> ToRemove;
1014 for (MachineBasicBlock *SB : B->successors()) {
1033 for (MachineBasicBlock &B : MF) {
1034 MachineBasicBlock::iterator I = B.begin(), E = B.end();
1841 SetVector<const MachineBasicBlock*> &Targets, bool &FallsThru)
2251 const CellMap &Inputs, SetVector<const MachineBasicBlock*> &Targets,
2305 const MachineBasicBlock *BranchTarget = BrI.getOperand(1).getMBB();
2842 MachineBasicBlock &B = *MI.getParent();
2858 MachineBasicBlock::iterator At = MI.getIterator();
2950 MachineBasicBlock &B = *MI.getParent();
2952 MachineBasicBlock::iterator At = MI.getIterator();
3125 MachineBasicBlock &B = *BrI.getParent();
3131 SetVector<const MachineBasicBlock*> Targets;
3144 MachineBasicBlock *TargetB = const_cast<MachineBasicBlock*>(Targets[0]);
lib/Target/Hexagon/HexagonCopyToCombine.cpp 94 void findPotentialNewifiableTFRs(MachineBasicBlock &);
97 MachineBasicBlock::iterator &MI, bool DoInsertAtI1,
104 void emitCombineRR(MachineBasicBlock::iterator &Before, unsigned DestReg,
107 void emitCombineRI(MachineBasicBlock::iterator &Before, unsigned DestReg,
110 void emitCombineIR(MachineBasicBlock::iterator &Before, unsigned DestReg,
113 void emitCombineII(MachineBasicBlock::iterator &Before, unsigned DestReg,
116 void emitConst64(MachineBasicBlock::iterator &Before, unsigned DestReg,
282 MachineBasicBlock::reverse_iterator I(I2),
331 MachineBasicBlock::iterator I(I1), End(I2);
395 HexagonCopyToCombine::findPotentialNewifiableTFRs(MachineBasicBlock &BB) {
422 MachineBasicBlock::iterator It(DefInst);
487 for(MachineBasicBlock::iterator MI = BI->begin(), End = BI->end();
527 MachineBasicBlock::iterator I2 = std::next(MachineBasicBlock::iterator(I1));
533 for (MachineBasicBlock::iterator End = I1.getParent()->end(); I2 != End;
574 MachineBasicBlock::iterator &MI,
615 MachineBasicBlock::iterator InsertPt(DoInsertAtI1 ? I1 : I2);
632 MachineBasicBlock *BB = InsertPt->getParent();
646 void HexagonCopyToCombine::emitConst64(MachineBasicBlock::iterator &InsertPt,
653 MachineBasicBlock *BB = InsertPt->getParent();
663 void HexagonCopyToCombine::emitCombineII(MachineBasicBlock::iterator &InsertPt,
668 MachineBasicBlock *BB = InsertPt->getParent();
757 void HexagonCopyToCombine::emitCombineIR(MachineBasicBlock::iterator &InsertPt,
765 MachineBasicBlock *BB = InsertPt->getParent();
805 void HexagonCopyToCombine::emitCombineRI(MachineBasicBlock::iterator &InsertPt,
813 MachineBasicBlock *BB = InsertPt->getParent();
854 void HexagonCopyToCombine::emitCombineRR(MachineBasicBlock::iterator &InsertPt,
864 MachineBasicBlock *BB = InsertPt->getParent();
lib/Target/Hexagon/HexagonEarlyIfConv.cpp 111 PrintMB(const MachineBasicBlock *B) : MB(B) {}
113 const MachineBasicBlock *MB;
123 FlowPattern(MachineBasicBlock *B, unsigned PR, MachineBasicBlock *TB,
123 FlowPattern(MachineBasicBlock *B, unsigned PR, MachineBasicBlock *TB,
124 MachineBasicBlock *FB, MachineBasicBlock *JB)
124 MachineBasicBlock *FB, MachineBasicBlock *JB)
127 MachineBasicBlock *SplitB = nullptr;
128 MachineBasicBlock *TrueB = nullptr;
129 MachineBasicBlock *FalseB = nullptr;
130 MachineBasicBlock *JoinB = nullptr;
174 using BlockSetType = DenseSet<MachineBasicBlock *>;
176 bool isPreheader(const MachineBasicBlock *B) const;
177 bool matchFlowPattern(MachineBasicBlock *B, MachineLoop *L,
179 bool visitBlock(MachineBasicBlock *B, MachineLoop *L);
182 bool hasEHLabel(const MachineBasicBlock *B) const;
183 bool hasUncondBranch(const MachineBasicBlock *B) const;
184 bool isValidCandidate(const MachineBasicBlock *B) const;
187 unsigned countPredicateDefs(const MachineBasicBlock *B) const;
188 unsigned computePhiCost(const MachineBasicBlock *B,
196 void predicateInstr(MachineBasicBlock *ToB, MachineBasicBlock::iterator At,
196 void predicateInstr(MachineBasicBlock *ToB, MachineBasicBlock::iterator At,
198 void predicateBlockNB(MachineBasicBlock *ToB,
199 MachineBasicBlock::iterator At, MachineBasicBlock *FromB,
202 unsigned buildMux(MachineBasicBlock *B, MachineBasicBlock::iterator At,
202 unsigned buildMux(MachineBasicBlock *B, MachineBasicBlock::iterator At,
205 void updatePhiNodes(MachineBasicBlock *WhereB, const FlowPattern &FP);
208 void removeBlock(MachineBasicBlock *B);
209 void eliminatePhis(MachineBasicBlock *B);
210 void mergeBlocks(MachineBasicBlock *PredB, MachineBasicBlock *SuccB);
210 void mergeBlocks(MachineBasicBlock *PredB, MachineBasicBlock *SuccB);
230 bool HexagonEarlyIfConversion::isPreheader(const MachineBasicBlock *B) const {
233 MachineBasicBlock *SB = *B->succ_begin();
238 bool HexagonEarlyIfConversion::matchFlowPattern(MachineBasicBlock *B,
246 MachineBasicBlock *TB = nullptr, *FB = nullptr;
247 MachineBasicBlock::const_iterator T1I = B->getFirstTerminator();
257 MachineBasicBlock *NextB = (NextBI != MFN->end()) ? &*NextBI : nullptr;
259 MachineBasicBlock *T1B = T1I->getOperand(1).getMBB();
260 MachineBasicBlock::const_iterator T2I = std::next(T1I);
263 MachineBasicBlock *T2B = (T2I == B->end()) ? NextB
305 MachineBasicBlock *TSB = (TNS > 0) ? *TB->succ_begin() : nullptr;
306 MachineBasicBlock *FSB = (FNS > 0) ? *FB->succ_begin() : nullptr;
307 MachineBasicBlock *JB = nullptr;
340 bool HexagonEarlyIfConversion::hasEHLabel(const MachineBasicBlock *B) const {
349 bool HexagonEarlyIfConversion::hasUncondBranch(const MachineBasicBlock *B)
351 MachineBasicBlock::const_iterator I = B->getFirstTerminator(), E = B->end();
360 bool HexagonEarlyIfConversion::isValidCandidate(const MachineBasicBlock *B)
434 const MachineBasicBlock &B = *FP.JoinB;
448 unsigned HexagonEarlyIfConversion::computePhiCost(const MachineBasicBlock *B,
463 const MachineBasicBlock *BB = MI.getOperand(i+1).getMBB();
488 const MachineBasicBlock *B) const {
528 MachineBasicBlock *TSB = *FP.TrueB->succ_begin();
529 MachineBasicBlock *FSB = *FP.FalseB->succ_begin();
573 MachineBasicBlock *SB = *FP.TrueB->succ_begin();
578 MachineBasicBlock *SB = *FP.FalseB->succ_begin();
596 bool HexagonEarlyIfConversion::visitBlock(MachineBasicBlock *B,
615 MachineBasicBlock *SB = (*I)->getBlock();
644 MachineBasicBlock *HB = L ? L->getHeader() : nullptr;
654 MachineBasicBlock *EntryB = GraphTraits<MachineFunction*>::getEntryNode(MFN);
708 void HexagonEarlyIfConversion::predicateInstr(MachineBasicBlock *ToB,
709 MachineBasicBlock::iterator At, MachineInstr *MI,
740 MachineBasicBlock *TB = MI->getOperand(0).getMBB();
759 void HexagonEarlyIfConversion::predicateBlockNB(MachineBasicBlock *ToB,
760 MachineBasicBlock::iterator At, MachineBasicBlock *FromB,
763 MachineBasicBlock::iterator End = FromB->getFirstTerminator();
764 MachineBasicBlock::iterator I, NextI;
776 unsigned HexagonEarlyIfConversion::buildMux(MachineBasicBlock *B,
777 MachineBasicBlock::iterator At, const TargetRegisterClass *DRC,
809 void HexagonEarlyIfConversion::updatePhiNodes(MachineBasicBlock *WhereB,
859 MachineBasicBlock *TSB = nullptr, *FSB = nullptr;
860 MachineBasicBlock::iterator OldTI = FP.SplitB->getFirstTerminator();
870 MachineBasicBlock::iterator At = FP.SplitB->getFirstTerminator();
877 MachineBasicBlock *SSB = nullptr;
880 MachineBasicBlock *T = *FP.SplitB->succ_begin();
953 void HexagonEarlyIfConversion::removeBlock(MachineBasicBlock *B) {
960 MachineBasicBlock *IDB = IDN->getBlock();
967 MachineBasicBlock *SB = (*I)->getBlock();
983 void HexagonEarlyIfConversion::eliminatePhis(MachineBasicBlock *B) {
985 MachineBasicBlock::iterator I, NextI, NonPHI = B->getFirstNonPHI();
1009 void HexagonEarlyIfConversion::mergeBlocks(MachineBasicBlock *PredB,
1010 MachineBasicBlock *SuccB) {
1034 MachineBasicBlock *SB = *FP.SplitB->succ_begin();
lib/Target/Hexagon/HexagonExpandCondsets.cpp 213 MachineBasicBlock::iterator At, unsigned DstR,
220 MachineBasicBlock::iterator UseIt, unsigned PredR, bool Cond);
224 MachineBasicBlock::iterator Where,
228 bool Cond, MachineBasicBlock::iterator First,
231 bool predicateInBlock(MachineBasicBlock &B,
392 for (MachineBasicBlock *D : Defs)
396 MachineBasicBlock *Entry = &Dest->getParent()->front();
397 SetVector<MachineBasicBlock*> Work(Dest->pred_begin(), Dest->pred_end());
399 MachineBasicBlock *B = Work[i];
404 for (auto *P : B->predecessors())
413 SetVector<MachineBasicBlock*> Defs;
429 MachineBasicBlock *BB = LIS->getMBBFromIndex(SI);
441 MachineBasicBlock *BB = LIS->getMBBFromIndex(SI);
623 MachineBasicBlock::iterator At,
627 MachineBasicBlock &B = *At->getParent();
676 MachineBasicBlock::iterator At = MI;
745 MachineBasicBlock::iterator UseIt, unsigned PredR, bool Cond) {
746 MachineBasicBlock &B = *UseIt->getParent();
747 MachineBasicBlock::iterator I = UseIt, S = B.begin();
829 MachineBasicBlock::iterator StartI = IsDown ? TheI : ToI;
830 MachineBasicBlock::iterator EndI = IsDown ? ToI : TheI;
834 for (MachineBasicBlock::iterator I = std::next(StartI); I != EndI; ++I) {
855 MachineBasicBlock::iterator Where,
869 MachineBasicBlock &B = *MI.getParent();
908 unsigned PredR, bool Cond, MachineBasicBlock::iterator First,
910 MachineBasicBlock::iterator End = std::next(Last);
911 for (MachineBasicBlock::iterator I = First; I != End; ++I) {
968 MachineBasicBlock::iterator DefIt = DefI, TfrIt = TfrI;
974 for (MachineBasicBlock::iterator I = std::next(DefIt); I != TfrIt; ++I) {
981 for (MachineBasicBlock::iterator I = std::next(DefIt); I != TfrIt; ++I) {
1049 MachineBasicBlock::iterator PastDefIt = std::next(DefIt);
1068 bool HexagonExpandCondsets::predicateInBlock(MachineBasicBlock &B,
1071 MachineBasicBlock::iterator I, E, NextI;
1267 for (auto &B : MF)
1312 for (auto &B : MF)
lib/Target/Hexagon/HexagonFixupHwLoops.cpp 70 MachineBasicBlock::iterator &MII);
110 DenseMap<const MachineBasicBlock *, unsigned> BlockToInstOffset;
116 for (const MachineBasicBlock &MBB : MF) {
132 for (MachineBasicBlock &MBB : MF) {
136 MachineBasicBlock::iterator MII = MBB.begin();
137 MachineBasicBlock::iterator MIE = MBB.end();
147 MachineBasicBlock *TargetBB = MII->getOperand(0).getMBB();
169 MachineBasicBlock::iterator &MII) {
171 MachineBasicBlock *MBB = MII->getParent();
lib/Target/Hexagon/HexagonFrameLowering.cpp 282 static bool needsStackFrame(const MachineBasicBlock &MBB, const BitVector &CSR,
336 static bool hasTailCall(const MachineBasicBlock &MBB) {
337 MachineBasicBlock::const_iterator I = MBB.getLastNonDebugInstr();
345 static bool hasReturn(const MachineBasicBlock &MBB) {
354 static MachineInstr *getReturn(MachineBasicBlock &MBB) {
395 MachineBasicBlock *&PrologB, MachineBasicBlock *&EpilogB) const {
395 MachineBasicBlock *&PrologB, MachineBasicBlock *&EpilogB) const {
423 for (auto &I : MF) {
434 SmallVector<MachineBasicBlock*,16> SFBlocks;
440 for (auto &I : MF)
455 MachineBasicBlock *DomB = SFBlocks[0];
461 MachineBasicBlock *PDomB = SFBlocks[0];
504 MachineBasicBlock &MBB) const {
510 MachineBasicBlock *PrologB = &MF.front(), *EpilogB = nullptr;
523 for (auto &B : MF)
527 for (auto &B : MF)
531 for (auto &B : MF) {
583 void HexagonFrameLowering::insertPrologueInBlock(MachineBasicBlock &MBB,
609 MachineBasicBlock::iterator InsertPt = MBB.begin();
612 for (auto &MBB : MF)
646 void HexagonFrameLowering::insertEpilogueInBlock(MachineBasicBlock &MBB) const {
653 MachineBasicBlock::iterator InsertPt = MBB.getFirstTerminator();
686 MachineBasicBlock::iterator It = RetI;
703 MachineBasicBlock::iterator PrevIt = std::prev(InsertPt);
733 void HexagonFrameLowering::insertAllocframe(MachineBasicBlock &MBB,
734 MachineBasicBlock::iterator InsertPt, unsigned NumBytes) const {
775 MachineBasicBlock &SaveB) const {
778 MachineBasicBlock &EntryB = MF.front();
786 MachineBasicBlock &MBB = *MF.getBlockNumbered(BN);
796 bool HexagonFrameLowering::updateExitPaths(MachineBasicBlock &MBB,
797 MachineBasicBlock &RestoreB, BitVector &DoneT, BitVector &DoneF,
840 static Optional<MachineBasicBlock::iterator>
850 MachineBasicBlock::iterator It = I.getIterator();
872 for (auto &B : MF) {
879 void HexagonFrameLowering::insertCFIInstructionsAt(MachineBasicBlock &MBB,
880 MachineBasicBlock::iterator At) const {
1210 bool HexagonFrameLowering::insertCSRSpillsInBlock(MachineBasicBlock &MBB,
1216 MachineBasicBlock::iterator MI = MBB.begin();
1278 bool HexagonFrameLowering::insertCSRRestoresInBlock(MachineBasicBlock &MBB,
1283 MachineBasicBlock::iterator MI = MBB.getFirstTerminator();
1314 MachineBasicBlock::iterator It = MBB.getFirstTerminator();
1342 MachineBasicBlock::iterator HexagonFrameLowering::eliminateCallFramePseudoInstr(
1568 bool HexagonFrameLowering::expandCopy(MachineBasicBlock &B,
1569 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1589 bool HexagonFrameLowering::expandStoreInt(MachineBasicBlock &B,
1590 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1622 bool HexagonFrameLowering::expandLoadInt(MachineBasicBlock &B,
1623 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1653 bool HexagonFrameLowering::expandStoreVecPred(MachineBasicBlock &B,
1654 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1690 bool HexagonFrameLowering::expandLoadVecPred(MachineBasicBlock &B,
1691 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1725 bool HexagonFrameLowering::expandStoreVec2(MachineBasicBlock &B,
1726 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1785 bool HexagonFrameLowering::expandLoadVec2(MachineBasicBlock &B,
1786 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1826 bool HexagonFrameLowering::expandStoreVec(MachineBasicBlock &B,
1827 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1855 bool HexagonFrameLowering::expandLoadVec(MachineBasicBlock &B,
1856 MachineBasicBlock::iterator It, MachineRegisterInfo &MRI,
1888 for (auto &B : MF) {
1890 MachineBasicBlock::iterator NextI;
2017 std::map<MachineBasicBlock *, HexagonBlockRanges::InstrIndexMap>;
2019 std::map<MachineBasicBlock *, HexagonBlockRanges::RangeList>;
2053 for (auto &B : MF) {
2189 std::map<MachineBasicBlock*,std::vector<int>> BlockFIMap;
2195 for (auto &B : MF) {
2228 for (auto &B : MF) {
2271 MachineBasicBlock::iterator StartIt = SI.getIterator(), NextIt;
2332 MachineBasicBlock &MB = *AI->getParent();
2501 for (const MachineBasicBlock &B : MF) {
lib/Target/Hexagon/HexagonFrameLowering.h 38 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const
40 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const
45 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
46 MachineBasicBlock::iterator MI, const std::vector<CalleeSavedInfo> &CSI,
51 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
52 MachineBasicBlock::iterator MI, std::vector<CalleeSavedInfo> &CSI,
68 MachineBasicBlock::iterator
112 void insertPrologueInBlock(MachineBasicBlock &MBB, bool PrologueStubs) const;
113 void insertEpilogueInBlock(MachineBasicBlock &MBB) const;
114 void insertAllocframe(MachineBasicBlock &MBB,
115 MachineBasicBlock::iterator InsertPt, unsigned NumBytes) const;
116 bool insertCSRSpillsInBlock(MachineBasicBlock &MBB, const CSIVect &CSI,
118 bool insertCSRRestoresInBlock(MachineBasicBlock &MBB, const CSIVect &CSI,
120 void updateEntryPaths(MachineFunction &MF, MachineBasicBlock &SaveB) const;
121 bool updateExitPaths(MachineBasicBlock &MBB, MachineBasicBlock &RestoreB,
121 bool updateExitPaths(MachineBasicBlock &MBB, MachineBasicBlock &RestoreB,
123 void insertCFIInstructionsAt(MachineBasicBlock &MBB,
124 MachineBasicBlock::iterator At) const;
128 bool expandCopy(MachineBasicBlock &B, MachineBasicBlock::iterator It,
128 bool expandCopy(MachineBasicBlock &B, MachineBasicBlock::iterator It,
131 bool expandStoreInt(MachineBasicBlock &B, MachineBasicBlock::iterator It,
131 bool expandStoreInt(MachineBasicBlock &B, MachineBasicBlock::iterator It,
134 bool expandLoadInt(MachineBasicBlock &B, MachineBasicBlock::iterator It,
134 bool expandLoadInt(MachineBasicBlock &B, MachineBasicBlock::iterator It,
137 bool expandStoreVecPred(MachineBasicBlock &B, MachineBasicBlock::iterator It,
137 bool expandStoreVecPred(MachineBasicBlock &B, MachineBasicBlock::iterator It,
140 bool expandLoadVecPred(MachineBasicBlock &B, MachineBasicBlock::iterator It,
140 bool expandLoadVecPred(MachineBasicBlock &B, MachineBasicBlock::iterator It,
143 bool expandStoreVec2(MachineBasicBlock &B, MachineBasicBlock::iterator It,
143 bool expandStoreVec2(MachineBasicBlock &B, MachineBasicBlock::iterator It,
146 bool expandLoadVec2(MachineBasicBlock &B, MachineBasicBlock::iterator It,
146 bool expandLoadVec2(MachineBasicBlock &B, MachineBasicBlock::iterator It,
149 bool expandStoreVec(MachineBasicBlock &B, MachineBasicBlock::iterator It,
149 bool expandStoreVec(MachineBasicBlock &B, MachineBasicBlock::iterator It,
152 bool expandLoadVec(MachineBasicBlock &B, MachineBasicBlock::iterator It,
152 bool expandLoadVec(MachineBasicBlock &B, MachineBasicBlock::iterator It,
165 void findShrunkPrologEpilog(MachineFunction &MF, MachineBasicBlock *&PrologB,
166 MachineBasicBlock *&EpilogB) const;
lib/Target/Hexagon/HexagonGenInsert.cpp 535 unsigned distance(const MachineBasicBlock *FromB,
536 const MachineBasicBlock *ToB, const UnsignedMap &RPO,
538 unsigned distance(MachineBasicBlock::const_iterator FromI,
542 void collectInBlock(MachineBasicBlock *B, OrderedRegisterList &AVs);
598 const MachineBasicBlock &B = *A;
602 using mb_iterator = MachineBasicBlock::const_iterator;
747 unsigned HexagonGenInsert::distance(const MachineBasicBlock *FromB,
748 const MachineBasicBlock *ToB, const UnsignedMap &RPO,
763 using pred_iterator = MachineBasicBlock::const_pred_iterator;
766 const MachineBasicBlock *PB = *I;
782 unsigned HexagonGenInsert::distance(MachineBasicBlock::const_iterator FromI,
785 const MachineBasicBlock *FB = FromI->getParent(), *TB = ToI->getParent();
928 void HexagonGenInsert::collectInBlock(MachineBasicBlock *B,
943 for (MachineBasicBlock::iterator I = B->begin(), E = B->end(); I != E; ++I) {
980 MachineBasicBlock *SB = DTN->getBlock();
1411 MachineBasicBlock &B = *MI->getParent();
1429 MachineBasicBlock::iterator At = MI;
1458 MachineBasicBlock *B = N->getBlock();
1547 MachineBasicBlock *RootB = MDT->getRoot();
lib/Target/Hexagon/HexagonGenMux.cpp 107 MachineBasicBlock::iterator At;
112 MuxInfo(MachineBasicBlock::iterator It, unsigned DR, unsigned PR,
131 void buildMaps(MachineBasicBlock &B, InstrIndexMap &I2X,
136 bool genMuxInBlock(MachineBasicBlock &B);
180 void HexagonGenMux::buildMaps(MachineBasicBlock &B, InstrIndexMap &I2X,
186 for (MachineBasicBlock::iterator I = B.begin(), E = B.end(); I != E; ++I) {
224 bool HexagonGenMux::genMuxInBlock(MachineBasicBlock &B) {
235 MachineBasicBlock::iterator NextI, End = B.end();
236 for (MachineBasicBlock::iterator I = B.begin(); I != End; I = NextI) {
301 MachineBasicBlock::iterator It1 = B.begin(), It2 = B.begin();
327 MachineBasicBlock::iterator At = CanDown ? Def2 : Def1;
335 MachineBasicBlock &B = *MX.At->getParent();
383 for (auto &I : MF)
lib/Target/Hexagon/HexagonGenPredicate.cpp 207 MachineBasicBlock &B = *A;
208 for (MachineBasicBlock::iterator I = B.begin(), E = B.end(); I != E; ++I) {
265 MachineBasicBlock &B = *DefI->getParent();
273 MachineBasicBlock::iterator DefIt = DefI;
384 MachineBasicBlock &B = *MI->getParent();
468 for (MachineBasicBlock &MBB : MF) {
lib/Target/Hexagon/HexagonHardwareLoops.cpp 237 bool isLoopFeeder(MachineLoop *L, MachineBasicBlock *A, MachineInstr *MI,
244 MachineBasicBlock *MBB, MachineLoop *L,
251 MachineBasicBlock *MBB, MachineLoop *L,
301 MachineBasicBlock *createPreheaderForLoop(MachineLoop *L);
406 MachineBasicBlock *Header = L->getHeader();
407 MachineBasicBlock *Preheader = MLI->findLoopPreheader(L, SpecPreheader);
408 MachineBasicBlock *Latch = L->getLoopLatch();
409 MachineBasicBlock *ExitingBlock = L->findLoopControlBlock();
425 using instr_iterator = MachineBasicBlock::instr_iterator;
456 MachineBasicBlock *TB = nullptr, *FB = nullptr;
567 MachineBasicBlock *TopMBB = L->getTopBlock();
568 MachineBasicBlock::pred_iterator PI = TopMBB->pred_begin();
571 MachineBasicBlock *Backedge = *PI++;
574 MachineBasicBlock *Incoming = *PI++;
590 MachineBasicBlock *ExitingBlock = L->findLoopControlBlock();
601 MachineBasicBlock *Preheader = MLI->findLoopPreheader(L, SpecPreheader);
605 MachineBasicBlock *Latch = L->getLoopLatch();
607 MachineBasicBlock *MBB = IV_Phi->getOperand(i+1).getMBB();
617 MachineBasicBlock *TB = nullptr, *FB = nullptr;
622 MachineBasicBlock *Header = L->getHeader();
628 MachineBasicBlock *LTB = nullptr, *LFB = nullptr;
698 MachineBasicBlock *DefBB = MRI->getVRegDef(R)->getParent();
708 MachineBasicBlock *DefBB = MRI->getVRegDef(R)->getParent();
828 MachineBasicBlock *PH = MLI->findLoopPreheader(Loop, SpecPreheader);
830 MachineBasicBlock::iterator InsertPos = PH->getFirstTerminator();
1015 for (MachineBasicBlock *MBB : L->getBlocks()) {
1016 for (MachineBasicBlock::iterator
1178 MachineBasicBlock *LastMBB = L->findLoopControlBlock();
1183 MachineBasicBlock::iterator LastI = LastMBB->getFirstTerminator();
1193 MachineBasicBlock *Preheader = MLI->findLoopPreheader(L, SpecPreheader);
1200 MachineBasicBlock::iterator InsertPos = Preheader->getFirstTerminator();
1213 MachineBasicBlock *BBDef = TCDef->getParent();
1219 MachineBasicBlock *TopBlock = L->getTopBlock();
1220 MachineBasicBlock *ExitingBlock = L->findLoopControlBlock();
1221 MachineBasicBlock *LoopStart = nullptr;
1223 MachineBasicBlock *TB = nullptr, *FB = nullptr;
1288 MachineBasicBlock *BranchTarget = LastI->getOperand(1).getMBB();
1324 MachineBasicBlock *BB = BumpI->getParent();
1328 using instr_iterator = MachineBasicBlock::instr_iterator;
1364 bool HexagonHardwareLoops::isLoopFeeder(MachineLoop *L, MachineBasicBlock *A,
1372 for (MachineBasicBlock *MBB : L->getBlocks()) {
1387 MachineInstr *Phi, const MachineOperand *EndVal, MachineBasicBlock *MBB,
1416 MachineBasicBlock *MBB, MachineLoop *L,
1463 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1590 MachineBasicBlock &B = *DI->getParent();
1607 MachineBasicBlock *Header = L->getHeader();
1608 MachineBasicBlock *Latch = L->getLoopLatch();
1609 MachineBasicBlock *ExitingBlock = L->findLoopControlBlock();
1626 using instr_iterator = MachineBasicBlock::instr_iterator;
1657 MachineBasicBlock *TB = nullptr, *FB = nullptr;
1665 MachineBasicBlock *LTB = nullptr, *LFB = nullptr;
1848 MachineBasicBlock *HexagonHardwareLoops::createPreheaderForLoop(
1850 if (MachineBasicBlock *TmpPH = MLI->findLoopPreheader(L, SpecPreheader))
1855 MachineBasicBlock *Header = L->getHeader();
1856 MachineBasicBlock *Latch = L->getLoopLatch();
1857 MachineBasicBlock *ExitingBlock = L->findLoopControlBlock();
1869 using instr_iterator = MachineBasicBlock::instr_iterator;
1873 using MBBVector = std::vector<MachineBasicBlock *>;
1877 MachineBasicBlock *TB = nullptr, *FB = nullptr;
1883 MachineBasicBlock *PB = *I;
1889 MachineBasicBlock *NewPH = MF->CreateMachineBasicBlock();
1916 MachineBasicBlock *PredB = PN->getOperand(i+1).getMBB();
1929 MachineBasicBlock *PredB = PN->getOperand(i+1).getMBB();
1966 MachineBasicBlock *PB = *I;
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp 1270 MachineBasicBlock *EntryBB = &MF->front();
lib/Target/Hexagon/HexagonInstrInfo.cpp 132 static unsigned nonDbgMICount(MachineBasicBlock::const_instr_iterator MIB,
146 MachineInstr *HexagonInstrInfo::findLoopInstr(MachineBasicBlock *BB,
147 unsigned EndLoopOp, MachineBasicBlock *TargetBB,
148 SmallPtrSet<MachineBasicBlock *, 8> &Visited) const {
160 for (MachineBasicBlock *PB : BB->predecessors()) {
341 const MachineBasicBlock *MBB = MI.getParent();
342 MachineBasicBlock::const_instr_iterator MII = MI.getIterator();
359 const MachineBasicBlock *MBB = MI.getParent();
360 MachineBasicBlock::const_instr_iterator MII = MI.getIterator();
385 bool HexagonInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
386 MachineBasicBlock *&TBB,
387 MachineBasicBlock *&FBB,
395 MachineBasicBlock::instr_iterator I = MBB.instr_end();
555 unsigned HexagonInstrInfo::removeBranch(MachineBasicBlock &MBB,
560 MachineBasicBlock::iterator I = MBB.end();
578 unsigned HexagonInstrInfo::insertBranch(MachineBasicBlock &MBB,
579 MachineBasicBlock *TBB,
580 MachineBasicBlock *FBB,
602 MachineBasicBlock *NewTBB, *NewFBB;
618 SmallPtrSet<MachineBasicBlock *, 8> VisitedBBs;
660 SmallPtrSet<MachineBasicBlock *, 8> VisitedBBs;
706 createTripCountGreaterCondition(int TC, MachineBasicBlock &MBB,
723 void setPreheader(MachineBasicBlock *NewPreheader) override {
755 HexagonInstrInfo::analyzeLoopForPipelining(MachineBasicBlock *LoopBB) const {
757 MachineBasicBlock::iterator I = LoopBB->getFirstTerminator();
760 SmallPtrSet<MachineBasicBlock *, 8> VisitedBBs;
769 bool HexagonInstrInfo::isProfitableToIfCvt(MachineBasicBlock &MBB,
775 bool HexagonInstrInfo::isProfitableToIfCvt(MachineBasicBlock &TMBB,
776 unsigned NumTCycles, unsigned ExtraTCycles, MachineBasicBlock &FMBB,
782 bool HexagonInstrInfo::isProfitableToDupForIfCvt(MachineBasicBlock &MBB,
787 void HexagonInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
788 MachineBasicBlock::iterator I,
884 void HexagonInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
885 MachineBasicBlock::iterator I, unsigned SrcReg, bool isKill, int FI,
950 MachineBasicBlock &MBB, MachineBasicBlock::iterator I, unsigned DestReg,
950 MachineBasicBlock &MBB, MachineBasicBlock::iterator I, unsigned DestReg,
1008 const MachineBasicBlock &B = *MI.getParent();
1022 MachineBasicBlock &MBB = *MI.getParent();
1047 MachineBasicBlock::iterator MBBI = MI.getIterator();
1433 MachineBasicBlock::instr_iterator
1435 MachineBasicBlock &MBB = *MI.getParent();
1438 MachineBasicBlock::iterator First;
1537 void HexagonInstrInfo::insertNoop(MachineBasicBlock &MBB,
1538 MachineBasicBlock::iterator MI) const {
1576 MachineBasicBlock &B = *MI.getParent();
1603 MachineBasicBlock::instr_iterator TI = T->getIterator();
1681 const MachineBasicBlock *MBB,
2981 bool HexagonInstrInfo::hasEHLabel(const MachineBasicBlock *B) const {
3030 bool HexagonInstrInfo::hasUncondBranch(const MachineBasicBlock *B)
3032 MachineBasicBlock::const_iterator I = B->getFirstTerminator(), E = B->end();
3076 MachineBasicBlock::const_instr_iterator BII) const {
3081 MachineBasicBlock::const_instr_iterator MII = BII;
3082 MachineBasicBlock::const_instr_iterator MIE = MII->getParent()->instr_end();
3230 MachineBasicBlock::instr_iterator I = MBB.instr_end();
3574 const MachineBasicBlock *Src = MI.getParent();
3587 const MachineBasicBlock *Dst = BrTarget.getMBB();
3600 const MachineBasicBlock &B = *MI.getParent();
3618 MachineBasicBlock::const_instr_iterator It(MI);
3619 MachineBasicBlock::const_instr_iterator NextIt = std::next(It);
3622 for (const MachineBasicBlock *SB : B.successors()) {
3631 const MachineBasicBlock *BT = nullptr;
4306 const MachineBasicBlock &MBB = *MI.getParent();
4338 unsigned HexagonInstrInfo::nonDbgBBSize(const MachineBasicBlock *BB) const {
4343 MachineBasicBlock::const_iterator BundleHead) const {
4366 MachineInstr &MI, MachineBasicBlock *NewTarget) const {
4389 MachineBasicBlock &B = *A;
4390 MachineBasicBlock::iterator I = B.begin();
4432 setBundleNoShuf(MachineBasicBlock::instr_iterator MIB) const {
lib/Target/Hexagon/HexagonInstrInfo.h 106 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
106 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
107 MachineBasicBlock *&FBB,
114 unsigned removeBranch(MachineBasicBlock &MBB,
127 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
127 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
128 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
135 analyzeLoopForPipelining(MachineBasicBlock *LoopBB) const override;
142 bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
152 bool isProfitableToIfCvt(MachineBasicBlock &TMBB,
154 MachineBasicBlock &FMBB,
164 bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
175 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
175 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
183 void storeRegToStackSlot(MachineBasicBlock &MBB,
184 MachineBasicBlock::iterator MBBI,
192 void loadRegFromStackSlot(MachineBasicBlock &MBB,
193 MachineBasicBlock::iterator MBBI,
218 void insertNoop(MachineBasicBlock &MBB,
219 MachineBasicBlock::iterator MI) const override;
251 const MachineBasicBlock *MBB,
340 MachineInstr *findLoopInstr(MachineBasicBlock *BB, unsigned EndLoopOp,
341 MachineBasicBlock *TargetBB,
342 SmallPtrSet<MachineBasicBlock *, 8> &Visited) const;
415 bool hasEHLabel(const MachineBasicBlock *B) const;
418 bool hasUncondBranch(const MachineBasicBlock *B) const;
424 MachineBasicBlock::const_instr_iterator MII) const;
432 SmallVector<MachineInstr*,2> getBranchingInstrs(MachineBasicBlock& MBB) const;
466 MachineBasicBlock::instr_iterator expandVGatherPseudo(MachineInstr &MI) const;
470 unsigned nonDbgBBSize(const MachineBasicBlock *BB) const;
471 unsigned nonDbgBundleSize(MachineBasicBlock::const_iterator BundleHead) const;
475 MachineBasicBlock *NewTarget) const;
481 void setBundleNoShuf(MachineBasicBlock::instr_iterator MIB) const;
lib/Target/Hexagon/HexagonMachineScheduler.cpp 119 MachineBasicBlock *MBB = SU->getInstr()->getParent();
lib/Target/Hexagon/HexagonNewValueJump.cpp 118 MachineBasicBlock::iterator II,
178 MachineBasicBlock::iterator localII = II;
181 for (MachineBasicBlock::iterator localBegin = localII; localBegin != end;
200 MachineBasicBlock::iterator MII) {
239 MachineBasicBlock::iterator II,
303 for (MachineBasicBlock::iterator localII = II; localII != end; ++localII) {
336 MachineBasicBlock *jmpTarget,
340 MachineBasicBlock *Src = MI->getParent();
474 MachineBasicBlock *MBB = &*MBBb;
486 MachineBasicBlock::iterator jmpPos;
487 MachineBasicBlock::iterator cmpPos;
489 MachineBasicBlock *jmpTarget = nullptr;
494 for (MachineBasicBlock::iterator MII = MBB->end(), E = MBB->begin();
537 for (MachineBasicBlock::const_succ_iterator SI = MBB->succ_begin(),
540 MachineBasicBlock *succMBB = *SI;
600 MachineBasicBlock::iterator feederPos = MII;
lib/Target/Hexagon/HexagonOptAddrMode.cpp 485 MachineBasicBlock *BB = OldMI->getParent();
487 MachineBasicBlock::instr_iterator InsertPt = UsePos.getInstrIterator();
548 MachineBasicBlock *BB = OldMI->getParent();
550 MachineBasicBlock::instr_iterator InsertPt = UsePos.getInstrIterator();
628 MachineBasicBlock::instr_iterator InsertPt = UsePos.getInstrIterator();
635 MachineBasicBlock *BB = UseMI->getParent();
lib/Target/Hexagon/HexagonPeephole.cpp 125 MachineBasicBlock *MBB = &*MBBb;
lib/Target/Hexagon/HexagonRegisterInfo.cpp 180 void HexagonRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
188 MachineBasicBlock &MB = *MI.getParent();
lib/Target/Hexagon/HexagonRegisterInfo.h 41 void eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
lib/Target/Hexagon/HexagonSplitConst32AndConst64.cpp 72 for (MachineBasicBlock &B : Fn) {
lib/Target/Hexagon/HexagonSplitDouble.cpp 454 const MachineBasicBlock *PB = UseI->getParent();
478 const MachineBasicBlock *HB = L->getHeader();
479 const MachineBasicBlock *LB = L->getLoopLatch();
485 MachineBasicBlock *TB = nullptr, *FB = nullptr;
486 MachineBasicBlock *TmpLB = const_cast<MachineBasicBlock*>(LB);
596 MachineBasicBlock &B = *MI->getParent();
635 MachineBasicBlock &B = *MI->getParent();
707 MachineBasicBlock &B = *MI->getParent();
734 MachineBasicBlock &B = *MI->getParent();
763 MachineBasicBlock &B = *MI->getParent();
800 MachineBasicBlock &B = *MI->getParent();
920 MachineBasicBlock &B = *MI->getParent();
1101 MachineBasicBlock &B = *MI->getParent();
1181 MachineBasicBlock *B = MI->getParent();
lib/Target/Hexagon/HexagonStoreWidening.cpp 99 void createStoreGroups(MachineBasicBlock &MBB,
101 bool processBasicBlock(MachineBasicBlock &MBB);
208 void HexagonStoreWidening::createStoreGroups(MachineBasicBlock &MBB,
483 MachineBasicBlock *MBB = OG.back()->getParent();
484 MachineBasicBlock::iterator InsertAt = MBB->end();
567 bool HexagonStoreWidening::processBasicBlock(MachineBasicBlock &MBB) {
599 for (auto &B : MFn)
lib/Target/Hexagon/HexagonVExtract.cpp 68 MachineBasicBlock &ExtB = *ExtI->getParent();
109 for (MachineBasicBlock &MBB : MF) {
128 MachineBasicBlock::iterator At = std::next(DefI->getIterator());
129 MachineBasicBlock &DefB = *DefI->getParent();
145 MachineBasicBlock &ExtB = *ExtI->getParent();
lib/Target/Hexagon/HexagonVLIWPacketizer.cpp 160 static MachineBasicBlock::iterator moveInstrOut(MachineInstr &MI,
162 MachineBasicBlock::instr_iterator InsertPt;
168 MachineBasicBlock &B = *MI.getParent();
184 MachineBasicBlock::const_instr_iterator I = BundleIt.getInstrIterator();
185 MachineBasicBlock::const_instr_iterator E = B.instr_end();
196 MachineBasicBlock::iterator NextIt = std::next(BundleIt);
231 for (MachineBasicBlock &MB : MF) {
245 for (auto &MB : MF) {
250 MachineBasicBlock::iterator RB = Begin;
255 MachineBasicBlock::iterator RE = RB;
369 SDep::Kind DepType, MachineBasicBlock::iterator &MII,
400 const SUnit *PacketSU, unsigned DepReg, MachineBasicBlock::iterator &MII,
451 SDep::Kind DepType, MachineBasicBlock::iterator &MII,
814 MachineBasicBlock::iterator &MII) {
843 const SUnit *PacketSU, unsigned DepReg, MachineBasicBlock::iterator &MII,
1036 const MachineBasicBlock *) {
1149 for (auto &B : MF) {
1150 MachineBasicBlock::iterator BundleIt;
1151 MachineBasicBlock::instr_iterator NextI;
1319 MachineBasicBlock::iterator II = I.getIterator();
1347 MachineBasicBlock::iterator NextMII = I.getIterator();
1687 MachineBasicBlock::iterator
1689 MachineBasicBlock::iterator MII = MI.getIterator();
1690 MachineBasicBlock *MBB = MI.getParent();
1764 void HexagonPacketizerList::endPacket(MachineBasicBlock *MBB,
1765 MachineBasicBlock::iterator EndMI) {
1787 MachineBasicBlock::instr_iterator NextMI = std::next(MI->getIterator());
1794 MachineBasicBlock::instr_iterator FirstMI(OldPacketMIs.front());
1795 MachineBasicBlock::instr_iterator LastMI(EndMI.getInstrIterator());
1829 auto *OldBB = OldPacketMIs.front()->getParent();
lib/Target/Hexagon/HexagonVLIWPacketizer.h 80 const MachineBasicBlock *MBB) override;
95 MachineBasicBlock::iterator addToPacket(MachineInstr &MI) override;
96 void endPacket(MachineBasicBlock *MBB,
97 MachineBasicBlock::iterator MI) override;
112 MachineBasicBlock::iterator &MII,
115 unsigned DepReg, MachineBasicBlock::iterator &MII,
120 MachineBasicBlock::iterator &MII,
123 unsigned DepReg, MachineBasicBlock::iterator &MII,
126 unsigned DepReg, MachineBasicBlock::iterator &MII);
lib/Target/Hexagon/HexagonVectorPrint.cpp 95 static void addAsmInstr(MachineBasicBlock *MBB, unsigned Reg,
96 MachineBasicBlock::instr_iterator I,
136 for (auto &MBB : Fn)
139 MachineBasicBlock::instr_iterator MII = MI.getIterator();
165 MachineBasicBlock *MBB = I->getParent();
170 MachineBasicBlock::instr_iterator MII = I->getIterator();
lib/Target/Hexagon/RDFCopy.cpp 68 bool CopyPropagation::scanBlock(MachineBasicBlock *B) {
lib/Target/Hexagon/RDFCopy.h 53 bool scanBlock(MachineBasicBlock *B);
lib/Target/Hexagon/RDFGraph.cpp 267 MachineBasicBlock *BB = P.Obj.Addr->getCode();
281 for (MachineBasicBlock *B : BB->predecessors())
288 for (MachineBasicBlock *B : BB->successors())
576 NodeAddr<BlockNode*> FuncNode::findBlock(const MachineBasicBlock *BB,
589 MachineBasicBlock *EntryB = &getCode()->front();
852 MachineBasicBlock *BB) {
873 for (MachineBasicBlock &B : MF) {
895 MachineBasicBlock &EntryB = *EA.Addr->getCode();
922 const MachineBasicBlock &B = *BA.Addr->getCode();
928 for (MachineBasicBlock *PB : B.predecessors())
1388 MachineBasicBlock *BB = BA.Addr->getCode();
1406 SetVector<MachineBasicBlock*> IDF(DF.begin(), DF.end());
1470 const MachineBasicBlock *MBB = BA.Addr->getCode();
1471 for (MachineBasicBlock *PB : MBB->predecessors())
1678 MachineBasicBlock *SB = I->getBlock();
1693 MachineBasicBlock *MBB = BA.Addr->getCode();
1695 for (MachineBasicBlock *SB : MBB->successors()) {
lib/Target/Hexagon/RDFGraph.h 627 MachineBasicBlock *getCode() const {
628 return CodeNode::getCode<MachineBasicBlock*>();
639 NodeAddr<BlockNode*> findBlock(const MachineBasicBlock *BB,
768 NodeAddr<BlockNode*> findBlock(MachineBasicBlock *BB) const {
837 MachineBasicBlock *BB);
881 std::map<MachineBasicBlock*,NodeAddr<BlockNode*>> BlockNodes;
lib/Target/Hexagon/RDFLiveness.cpp 182 MachineBasicBlock *BA = Block(OA), *BB = Block(OB);
362 MachineBasicBlock *BB = BA.Addr->getCode();
687 MachineBasicBlock *BB = BA.Addr->getCode();
699 for (MachineBasicBlock &B : MF) {
703 SetVector<MachineBasicBlock*> IDFB(F1->second.begin(), F1->second.end());
725 MachineBasicBlock *MB = BA.Addr->getCode();
810 for (MachineBasicBlock &B : MF) {
836 for (auto &B : DFG.getMF()) {
853 for (auto &B : DFG.getMF())
857 void Liveness::resetKills(MachineBasicBlock *B) {
921 MachineBasicBlock *Liveness::getBlockWithRef(NodeId RN) const {
928 void Liveness::traverse(MachineBasicBlock *B, RefMap &LiveIn) {
956 MachineBasicBlock *SB = I->getBlock();
lib/Target/Hexagon/RDFLiveness.h 40 RegisterAggr &operator[] (MachineBasicBlock *B) {
46 std::map<MachineBasicBlock*,RegisterAggr> Map;
95 void resetKills(MachineBasicBlock *B);
113 using NodeBlockMap = DenseMap<NodeId, MachineBasicBlock *>;
124 std::map<MachineBasicBlock*,std::set<MachineBasicBlock*>> IIDF;
124 std::map<MachineBasicBlock*,std::set<MachineBasicBlock*>> IIDF;
127 std::map<MachineBasicBlock*,RefMap> PhiLON;
134 std::map<MachineBasicBlock*,RefMap> PhiLOX;
136 MachineBasicBlock *getBlockWithRef(NodeId RN) const;
137 void traverse(MachineBasicBlock *B, RefMap &LiveIn);
lib/Target/Hexagon/RDFRegisters.cpp 77 for (const MachineBasicBlock &B : mf)
lib/Target/Lanai/LanaiAsmPrinter.cpp 56 const MachineBasicBlock *MBB) const override;
198 MachineBasicBlock::const_instr_iterator I = MI->getIterator();
199 MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
216 const MachineBasicBlock *MBB) const {
218 const MachineBasicBlock *Pred = *MBB->pred_begin();
232 MachineBasicBlock::const_iterator I = Pred->end();
lib/Target/Lanai/LanaiDelaySlotFiller.cpp 39 MachineBasicBlock::instr_iterator LastFiller;
46 bool runOnMachineBasicBlock(MachineBasicBlock &MBB);
65 void insertDefsUses(MachineBasicBlock::instr_iterator MI,
71 bool delayHasHazard(MachineBasicBlock::instr_iterator MI, bool &SawLoad,
75 bool findDelayInstr(MachineBasicBlock &MBB,
76 MachineBasicBlock::instr_iterator Slot,
91 bool Filler::runOnMachineBasicBlock(MachineBasicBlock &MBB) {
95 for (MachineBasicBlock::instr_iterator I = MBB.instr_begin();
98 MachineBasicBlock::instr_iterator InstrWithSlot = I;
99 MachineBasicBlock::instr_iterator J = I;
107 MachineBasicBlock::reverse_instr_iterator RI = ++I.getReverse();
119 MachineBasicBlock::instr_iterator FI = RI.getReverse();
144 bool Filler::findDelayInstr(MachineBasicBlock &MBB,
145 MachineBasicBlock::instr_iterator Slot,
155 for (MachineBasicBlock::reverse_instr_iterator I = ++Slot.getReverse();
162 MachineBasicBlock::instr_iterator FI = I.getReverse();
178 bool Filler::delayHasHazard(MachineBasicBlock::instr_iterator MI, bool &SawLoad,
225 void Filler::insertDefsUses(MachineBasicBlock::instr_iterator MI,
lib/Target/Lanai/LanaiFrameLowering.cpp 70 MachineBasicBlock::iterator MBBI = MBB->begin();
92 MachineBasicBlock &MBB) const {
98 MachineBasicBlock::iterator MBBI = MBB.begin();
141 MachineBasicBlock::iterator LanaiFrameLowering::eliminateCallFramePseudoInstr(
179 MachineBasicBlock &MBB) const {
180 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
lib/Target/Lanai/LanaiFrameLowering.h 40 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
41 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
43 MachineBasicBlock::iterator
lib/Target/Lanai/LanaiInstrInfo.cpp 34 void LanaiInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
35 MachineBasicBlock::iterator Position,
50 MachineBasicBlock &MBB, MachineBasicBlock::iterator Position,
50 MachineBasicBlock &MBB, MachineBasicBlock::iterator Position,
70 MachineBasicBlock &MBB, MachineBasicBlock::iterator Position,
70 MachineBasicBlock &MBB, MachineBasicBlock::iterator Position,
292 MachineBasicBlock::iterator I = CmpInstr, E = MI,
420 MachineBasicBlock *MBB = CmpInstr.getParent();
421 for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
562 bool LanaiInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
563 MachineBasicBlock *&TrueBlock,
564 MachineBasicBlock *&FalseBlock,
568 MachineBasicBlock::iterator Instruction = MBB.end();
660 unsigned LanaiInstrInfo::insertBranch(MachineBasicBlock &MBB,
661 MachineBasicBlock *TrueBlock,
662 MachineBasicBlock *FalseBlock,
692 unsigned LanaiInstrInfo::removeBranch(MachineBasicBlock &MBB,
696 MachineBasicBlock::iterator Instruction = MBB.end();
lib/Target/Lanai/LanaiInstrInfo.h 50 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator Position,
50 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator Position,
55 storeRegToStackSlot(MachineBasicBlock &MBB,
56 MachineBasicBlock::iterator Position,
62 loadRegFromStackSlot(MachineBasicBlock &MBB,
63 MachineBasicBlock::iterator Position,
86 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TrueBlock,
86 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TrueBlock,
87 MachineBasicBlock *&FalseBlock,
91 unsigned removeBranch(MachineBasicBlock &MBB,
138 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TrueBlock,
138 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TrueBlock,
139 MachineBasicBlock *FalseBlock,
lib/Target/Lanai/LanaiMemAluCombiner.cpp 53 typedef MachineBasicBlock::iterator MbbIterator;
78 void insertMergedInstruction(MachineBasicBlock *BB,
81 bool combineMemAluInBasicBlock(MachineBasicBlock *BB);
236 void LanaiMemAluCombiner::insertMergedInstruction(MachineBasicBlock *BB,
364 bool LanaiMemAluCombiner::combineMemAluInBasicBlock(MachineBasicBlock *BB) {
lib/Target/Lanai/LanaiRegisterInfo.cpp 136 void LanaiRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
lib/Target/Lanai/LanaiRegisterInfo.h 39 void eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
lib/Target/MSP430/MSP430BranchSelector.cpp 96 for (auto &MBB : make_range(Begin, MF->end())) {
128 MachineBasicBlock *DestBB = MI->getOperand(0).getMBB();
152 MachineBasicBlock *NewBB =
160 for (MachineBasicBlock *Succ : MBB->successors()) {
184 MachineBasicBlock *NextMBB = &*std::next(MBB);
lib/Target/MSP430/MSP430FrameLowering.cpp 41 MachineBasicBlock &MBB) const {
48 MachineBasicBlock::iterator MBBI = MBB.begin();
107 MachineBasicBlock &MBB) const {
113 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
141 MachineBasicBlock::iterator PI = std::prev(MBBI);
180 MSP430FrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
181 MachineBasicBlock::iterator MI,
206 MSP430FrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
207 MachineBasicBlock::iterator MI,
225 MachineBasicBlock::iterator MSP430FrameLowering::eliminateCallFramePseudoInstr(
lib/Target/MSP430/MSP430FrameLowering.h 30 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
31 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
33 MachineBasicBlock::iterator
37 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
38 MachineBasicBlock::iterator MI,
41 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
42 MachineBasicBlock::iterator MI,
lib/Target/MSP430/MSP430ISelLowering.cpp 1409 MachineBasicBlock *
1411 MachineBasicBlock *BB) const {
1467 MachineBasicBlock *LoopBB = F->CreateMachineBasicBlock(LLVM_BB);
1468 MachineBasicBlock *RemBB = F->CreateMachineBasicBlock(LLVM_BB);
1539 MachineBasicBlock *
1541 MachineBasicBlock *BB) const {
1569 MachineBasicBlock *thisMBB = BB;
1571 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
1572 MachineBasicBlock *copy1MBB = F->CreateMachineBasicBlock(LLVM_BB);
lib/Target/MSP430/MSP430ISelLowering.h 129 MachineBasicBlock *
131 MachineBasicBlock *BB) const override;
132 MachineBasicBlock *EmitShiftInstr(MachineInstr &MI,
133 MachineBasicBlock *BB) const;
lib/Target/MSP430/MSP430InstrInfo.cpp 36 void MSP430InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
37 MachineBasicBlock::iterator MI,
63 void MSP430InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
64 MachineBasicBlock::iterator MI,
90 void MSP430InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
91 MachineBasicBlock::iterator I,
106 unsigned MSP430InstrInfo::removeBranch(MachineBasicBlock &MBB,
110 MachineBasicBlock::iterator I = MBB.end();
175 bool MSP430InstrInfo::analyzeBranch(MachineBasicBlock &MBB,
176 MachineBasicBlock *&TBB,
177 MachineBasicBlock *&FBB,
182 MachineBasicBlock::iterator I = MBB.end();
265 unsigned MSP430InstrInfo::insertBranch(MachineBasicBlock &MBB,
266 MachineBasicBlock *TBB,
267 MachineBasicBlock *FBB,
lib/Target/MSP430/MSP430InstrInfo.h 38 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
38 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
42 void storeRegToStackSlot(MachineBasicBlock &MBB,
43 MachineBasicBlock::iterator MI,
48 void loadRegFromStackSlot(MachineBasicBlock &MBB,
49 MachineBasicBlock::iterator MI,
60 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
60 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
61 MachineBasicBlock *&FBB,
65 unsigned removeBranch(MachineBasicBlock &MBB,
67 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
67 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
68 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
lib/Target/MSP430/MSP430RegisterInfo.cpp 103 MSP430RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
109 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/MSP430/MSP430RegisterInfo.h 35 void eliminateFrameIndex(MachineBasicBlock::iterator II,
lib/Target/Mips/MicroMipsSizeReduction.cpp 125 MachineBasicBlock::instr_iterator
129 MachineBasicBlock::instr_iterator &argNextMII)
151 bool ReduceMBB(MachineBasicBlock &MBB);
154 bool ReduceMI(const MachineBasicBlock::instr_iterator &MII,
414 bool MicroMipsSizeReduce::ReduceMI(const MachineBasicBlock::instr_iterator &MII,
457 MachineBasicBlock::instr_iterator &NextMII = Arguments->NextMII;
458 const MachineBasicBlock::instr_iterator &E =
614 MachineBasicBlock::instr_iterator &NextMII = Arguments->NextMII;
615 const MachineBasicBlock::instr_iterator &E =
671 bool MicroMipsSizeReduce::ReduceMBB(MachineBasicBlock &MBB) {
673 MachineBasicBlock::instr_iterator MII = MBB.instr_begin(),
675 MachineBasicBlock::instr_iterator NextMII;
708 MachineBasicBlock &MBB = *MI->getParent();
lib/Target/Mips/Mips16FrameLowering.cpp 43 MachineBasicBlock &MBB) const {
47 MachineBasicBlock::iterator MBBI = MBB.begin();
92 MachineBasicBlock &MBB) const {
93 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
113 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
114 MachineBasicBlock::iterator MI,
140 bool Mips16FrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
141 MachineBasicBlock::iterator MI,
lib/Target/Mips/Mips16FrameLowering.h 25 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
26 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
28 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
29 MachineBasicBlock::iterator MI,
33 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
34 MachineBasicBlock::iterator MI,
lib/Target/Mips/Mips16ISelDAGToDAG.cpp 70 MachineBasicBlock &MBB = MF.front();
71 MachineBasicBlock::iterator I = MBB.begin();
lib/Target/Mips/Mips16ISelLowering.cpp 163 MachineBasicBlock *
165 MachineBasicBlock *BB) const {
510 MachineBasicBlock *
512 MachineBasicBlock *BB) const {
530 MachineBasicBlock *thisMBB = BB;
532 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
533 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
573 MachineBasicBlock *
575 MachineBasicBlock *BB) const {
593 MachineBasicBlock *thisMBB = BB;
595 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
596 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
638 MachineBasicBlock *
641 MachineBasicBlock *BB) const {
659 MachineBasicBlock *thisMBB = BB;
661 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
662 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
704 MachineBasicBlock *
707 MachineBasicBlock *BB) const {
713 MachineBasicBlock *target = MI.getOperand(2).getMBB();
722 MachineBasicBlock *Mips16TargetLowering::emitFEXT_T8I8I16_ins(
724 MachineInstr &MI, MachineBasicBlock *BB) const {
730 MachineBasicBlock *target = MI.getOperand(2).getMBB();
755 MachineBasicBlock *
757 MachineBasicBlock *BB) const {
773 MachineBasicBlock *
776 MachineBasicBlock *BB) const {
lib/Target/Mips/Mips16ISelLowering.h 29 MachineBasicBlock *
31 MachineBasicBlock *MBB) const override;
53 MachineBasicBlock *emitSel16(unsigned Opc, MachineInstr &MI,
54 MachineBasicBlock *BB) const;
56 MachineBasicBlock *emitSeliT16(unsigned Opc1, unsigned Opc2,
58 MachineBasicBlock *BB) const;
60 MachineBasicBlock *emitSelT16(unsigned Opc1, unsigned Opc2,
62 MachineBasicBlock *BB) const;
64 MachineBasicBlock *emitFEXT_T8I816_ins(unsigned BtOpc, unsigned CmpOpc,
66 MachineBasicBlock *BB) const;
68 MachineBasicBlock *emitFEXT_T8I8I16_ins(unsigned BtOpc, unsigned CmpiOpc,
71 MachineBasicBlock *BB) const;
73 MachineBasicBlock *emitFEXT_CCRX16_ins(unsigned SltOpc, MachineInstr &MI,
74 MachineBasicBlock *BB) const;
76 MachineBasicBlock *emitFEXT_CCRXI16_ins(unsigned SltiOpc, unsigned SltiXOpc,
78 MachineBasicBlock *BB) const;
lib/Target/Mips/Mips16InstrInfo.cpp 69 void Mips16InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
70 MachineBasicBlock::iterator I,
110 void Mips16InstrInfo::storeRegToStack(MachineBasicBlock &MBB,
111 MachineBasicBlock::iterator I,
128 void Mips16InstrInfo::loadRegFromStack(MachineBasicBlock &MBB,
129 MachineBasicBlock::iterator I,
147 MachineBasicBlock &MBB = *MI.getParent();
215 MachineBasicBlock &MBB,
216 MachineBasicBlock::iterator I) const {
245 MachineBasicBlock &MBB,
246 MachineBasicBlock::iterator I) const {
280 MachineBasicBlock &MBB,
281 MachineBasicBlock::iterator I,
304 unsigned SP, int64_t Amount, MachineBasicBlock &MBB,
305 MachineBasicBlock::iterator I) const {
311 MachineBasicBlock &MBB,
312 MachineBasicBlock::iterator I) const {
325 MachineBasicBlock &MBB,
326 MachineBasicBlock::iterator II,
452 void Mips16InstrInfo::ExpandRetRA16(MachineBasicBlock &MBB,
453 MachineBasicBlock::iterator I,
466 (MachineBasicBlock &MBB, MachineBasicBlock::iterator I, int64_t Imm) const {
466 (MachineBasicBlock &MBB, MachineBasicBlock::iterator I, int64_t Imm) const {
lib/Target/Mips/Mips16InstrInfo.h 51 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
51 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
55 void storeRegToStack(MachineBasicBlock &MBB,
56 MachineBasicBlock::iterator MBBI,
62 void loadRegFromStack(MachineBasicBlock &MBB,
63 MachineBasicBlock::iterator MBBI,
74 void makeFrame(unsigned SP, int64_t FrameSize, MachineBasicBlock &MBB,
75 MachineBasicBlock::iterator I) const;
78 void restoreFrame(unsigned SP, int64_t FrameSize, MachineBasicBlock &MBB,
79 MachineBasicBlock::iterator I) const;
82 void adjustStackPtr(unsigned SP, int64_t Amount, MachineBasicBlock &MBB,
83 MachineBasicBlock::iterator I) const override;
88 unsigned loadImmediate(unsigned FrameReg, int64_t Imm, MachineBasicBlock &MBB,
89 MachineBasicBlock::iterator II, const DebugLoc &DL,
103 (MachineBasicBlock &MBB, MachineBasicBlock::iterator I, int64_t Imm) const;
103 (MachineBasicBlock &MBB, MachineBasicBlock::iterator I, int64_t Imm) const;
115 void ExpandRetRA16(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
115 void ExpandRetRA16(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
119 void adjustStackPtrBig(unsigned SP, int64_t Amount, MachineBasicBlock &MBB,
120 MachineBasicBlock::iterator I,
125 MachineBasicBlock &MBB,
126 MachineBasicBlock::iterator I) const;
lib/Target/Mips/Mips16RegisterInfo.cpp 57 (MachineBasicBlock &MBB,
58 MachineBasicBlock::iterator I,
75 void Mips16RegisterInfo::eliminateFI(MachineBasicBlock::iterator II,
134 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/Mips/Mips16RegisterInfo.h 31 bool saveScavengerRegister(MachineBasicBlock &MBB,
32 MachineBasicBlock::iterator I,
40 void eliminateFI(MachineBasicBlock::iterator II, unsigned OpNo,
lib/Target/Mips/MipsAsmPrinter.cpp 252 MachineBasicBlock::const_instr_iterator I = MI->getIterator();
253 MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
464 void MipsAsmPrinter::EmitBasicBlockEnd(const MachineBasicBlock &MBB) {
474 bool MipsAsmPrinter::isBlockOnlyReachableByFallthrough(const MachineBasicBlock*
477 const MachineBasicBlock *Pred = *MBB->pred_begin();
491 MachineBasicBlock::const_pred_iterator PI = MBB->pred_begin(), PI2 = PI;
507 MachineBasicBlock::const_iterator I = Pred->end();
1278 const std::vector<MachineBasicBlock*> &MBBs = JT[I].MBBs;
1286 for (auto &MBB : MF) {
lib/Target/Mips/MipsAsmPrinter.h 144 void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override;
146 const MachineBasicBlock* MBB) const override;
lib/Target/Mips/MipsBranchExpansion.cpp 123 using Iter = MachineBasicBlock::iterator;
124 using ReverseIter = MachineBasicBlock::reverse_iterator;
154 void splitMBB(MachineBasicBlock *MBB);
158 void replaceBranch(MachineBasicBlock &MBB, Iter Br, const DebugLoc &DL,
160 bool buildProperJumpMI(MachineBasicBlock *MBB,
161 MachineBasicBlock::iterator Pos, DebugLoc DL);
206 MachineBasicBlock *Succ = Parent->getNextNode();
225 static MachineBasicBlock *getTargetMBB(const MachineInstr &Br) {
247 void MipsBranchExpansion::splitMBB(MachineBasicBlock *MBB) {
267 MachineBasicBlock *NewMBB =
271 MachineBasicBlock *Tgt = getTargetMBB(*FirstBr);
286 for (auto &MBB : *MFp)
294 MachineBasicBlock *MBB = MFp->getBlockNumbered(I);
297 for (MachineBasicBlock::instr_iterator MI = MBB->instr_begin();
334 void MipsBranchExpansion::replaceBranch(MachineBasicBlock &MBB, Iter Br,
359 MachineBasicBlock::instr_iterator II = Br.getInstrIterator();
365 bool MipsBranchExpansion::buildProperJumpMI(MachineBasicBlock *MBB,
366 MachineBasicBlock::iterator Pos,
400 MachineBasicBlock::iterator Pos;
401 MachineBasicBlock *MBB = I.Br->getParent(), *TgtMBB = getTargetMBB(*I.Br);
405 MachineBasicBlock *LongBrMBB = MFp->CreateMachineBasicBlock(BB);
411 MachineBasicBlock *BalTgtMBB = MFp->CreateMachineBasicBlock(BB);
721 MachineBasicBlock &MBB = F.front();
722 MachineBasicBlock::iterator I = MBB.begin();
757 MachineBasicBlock::instr_iterator Iit = I->getIterator();
787 MachineBasicBlock *MBB = MFp->getBlockNumbered(I);
lib/Target/Mips/MipsConstantIslandPass.cpp 186 using Iter = MachineBasicBlock::iterator;
187 using ReverseIter = MachineBasicBlock::reverse_iterator;
233 std::vector<MachineBasicBlock*> WaterList;
237 SmallSet<MachineBasicBlock*, 4> NewWaterList;
239 using water_iterator = std::vector<MachineBasicBlock *>::iterator;
256 MachineBasicBlock *HighWaterMark;
385 void computeBlockSize(MachineBasicBlock *MBB);
386 MachineBasicBlock *splitBlockBeforeInstr(MachineInstr &MI);
387 void updateForInsertedWaterBlock(MachineBasicBlock *NewBB);
388 void adjustBBOffsetsAfter(MachineBasicBlock *BB);
395 MachineBasicBlock *&NewMBB);
402 bool isWaterInRange(unsigned UserOffset, MachineBasicBlock *Water,
404 bool isBBInRange(MachineInstr *MI, MachineBasicBlock *BB, unsigned Disp);
528 MachineBasicBlock *BB = MF->CreateMachineBasicBlock();
546 SmallVector<MachineBasicBlock::iterator, 8> InsPoint(Log2(MaxAlign) + 1,
565 MachineBasicBlock::iterator InsAt = InsPoint[LogAlign];
589 static bool BBHasFallthrough(MachineBasicBlock *MBB) {
596 MachineBasicBlock *NextBB = &*std::next(MBBI);
597 for (MachineBasicBlock::succ_iterator I = MBB->succ_begin(),
653 for (MachineBasicBlock &MBB : *MF) {
790 void MipsConstantIslands::computeBlockSize(MachineBasicBlock *MBB) {
802 MachineBasicBlock *MBB = MI->getParent();
810 for (MachineBasicBlock::iterator I = MBB->begin(); &*I != MI; ++I) {
819 static bool CompareMBBNumbers(const MachineBasicBlock *LHS,
820 const MachineBasicBlock *RHS) {
828 (MachineBasicBlock *NewBB) {
849 MachineBasicBlock *
851 MachineBasicBlock *OrigBB = MI.getParent();
854 MachineBasicBlock *NewBB =
889 MachineBasicBlock* WaterBB = *IP;
935 MachineBasicBlock* Water, CPUser &U,
1000 static bool BBIsJumpedOver(MachineBasicBlock *MBB) {
1003 MachineBasicBlock *Succ = *MBB->succ_begin();
1004 MachineBasicBlock *Pred = *MBB->pred_begin();
1012 void MipsConstantIslands::adjustBBOffsetsAfter(MachineBasicBlock *BB) {
1176 MachineBasicBlock* WaterBB = *IP;
1214 MachineBasicBlock *&NewMBB) {
1218 MachineBasicBlock *UserMBB = UserMI->getParent();
1277 MachineBasicBlock::iterator MI = UserMI;
1325 MachineBasicBlock *NewIsland = MF->CreateMachineBasicBlock();
1326 MachineBasicBlock *NewMBB;
1330 MachineBasicBlock *WaterBB = *IP;
1356 MachineBasicBlock *WaterBB = &*--NewMBB->getIterator();
1417 MachineBasicBlock *CPEBB = CPEMI->getParent();
1460 (MachineInstr *MI,MachineBasicBlock *DestBB, unsigned MaxDisp) {
1487 MachineBasicBlock *DestBB = MI->getOperand(TargetOperand).getMBB();
1505 MachineBasicBlock *MBB = MI->getParent();
1506 MachineBasicBlock *DestBB = MI->getOperand(0).getMBB();
1546 MachineBasicBlock *DestBB = MI->getOperand(TargetOperand).getMBB();
1569 MachineBasicBlock *MBB = MI->getParent();
1586 MachineBasicBlock *NewDest =
1609 MachineBasicBlock *NextBB = &*++MBB->getIterator();
1644 for (MachineBasicBlock::instr_iterator I =
lib/Target/Mips/MipsDelaySlotFiller.cpp 106 using Iter = MachineBasicBlock::iterator;
107 using ReverseIter = MachineBasicBlock::reverse_iterator;
108 using BB2BrMap = SmallDenseMap<MachineBasicBlock *, MachineInstr *, 2>;
124 void addLiveOut(const MachineBasicBlock &MBB,
125 const MachineBasicBlock &SuccBB);
249 bool runOnMachineBasicBlock(MachineBasicBlock &MBB);
263 bool searchRange(MachineBasicBlock &MBB, IterTy Begin, IterTy End,
269 bool searchBackward(MachineBasicBlock &MBB, MachineInstr &Slot) const;
273 bool searchForward(MachineBasicBlock &MBB, Iter Slot) const;
278 bool searchSuccBBs(MachineBasicBlock &MBB, Iter Slot) const;
282 MachineBasicBlock *selectSuccBB(MachineBasicBlock &B) const;
282 MachineBasicBlock *selectSuccBB(MachineBasicBlock &B) const;
287 getBranch(MachineBasicBlock &MBB, const MachineBasicBlock &Dst) const;
287 getBranch(MachineBasicBlock &MBB, const MachineBasicBlock &Dst) const;
291 bool examinePred(MachineBasicBlock &Pred, const MachineBasicBlock &Succ,
291 bool examinePred(MachineBasicBlock &Pred, const MachineBasicBlock &Succ,
404 void RegDefsUses::addLiveOut(const MachineBasicBlock &MBB,
405 const MachineBasicBlock &SuccBB) {
406 for (MachineBasicBlock::const_succ_iterator SI = MBB.succ_begin(),
597 bool MipsDelaySlotFiller::runOnMachineBasicBlock(MachineBasicBlock &MBB) {
628 MachineBasicBlock::instr_iterator DSI = I.getInstrIterator();
676 bool MipsDelaySlotFiller::searchRange(MachineBasicBlock &MBB, IterTy Begin,
741 bool MipsDelaySlotFiller::searchBackward(MachineBasicBlock &MBB,
753 MachineBasicBlock::iterator SlotI = Slot;
764 bool MipsDelaySlotFiller::searchForward(MachineBasicBlock &MBB,
785 bool MipsDelaySlotFiller::searchSuccBBs(MachineBasicBlock &MBB,
790 MachineBasicBlock *SuccBB = selectSuccBB(MBB);
803 for (MachineBasicBlock::pred_iterator PI = SuccBB->pred_begin(),
832 MachineBasicBlock *
833 MipsDelaySlotFiller::selectSuccBB(MachineBasicBlock &B) const {
839 MachineBasicBlock *S = *std::max_element(
849 MipsDelaySlotFiller::getBranch(MachineBasicBlock &MBB,
850 const MachineBasicBlock &Dst) const {
853 MachineBasicBlock *TrueBB = nullptr, *FalseBB = nullptr;
885 bool MipsDelaySlotFiller::examinePred(MachineBasicBlock &Pred,
886 const MachineBasicBlock &Succ,
lib/Target/Mips/MipsExpandPseudo.cpp 53 bool expandAtomicCmpSwap(MachineBasicBlock &MBB,
54 MachineBasicBlock::iterator MBBI,
56 bool expandAtomicCmpSwapSubword(MachineBasicBlock &MBB,
57 MachineBasicBlock::iterator MBBI,
60 bool expandAtomicBinOp(MachineBasicBlock &BB,
61 MachineBasicBlock::iterator I,
63 bool expandAtomicBinOpSubword(MachineBasicBlock &BB,
64 MachineBasicBlock::iterator I,
67 bool expandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
67 bool expandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
69 bool expandMBB(MachineBasicBlock &MBB);
75 MachineBasicBlock &BB, MachineBasicBlock::iterator I,
75 MachineBasicBlock &BB, MachineBasicBlock::iterator I,
114 MachineBasicBlock *loop1MBB = MF->CreateMachineBasicBlock(LLVM_BB);
115 MachineBasicBlock *loop2MBB = MF->CreateMachineBasicBlock(LLVM_BB);
116 MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(LLVM_BB);
117 MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
202 bool MipsExpandPseudo::expandAtomicCmpSwap(MachineBasicBlock &BB,
203 MachineBasicBlock::iterator I,
251 MachineBasicBlock *loop1MBB = MF->CreateMachineBasicBlock(LLVM_BB);
252 MachineBasicBlock *loop2MBB = MF->CreateMachineBasicBlock(LLVM_BB);
253 MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
303 MachineBasicBlock &BB, MachineBasicBlock::iterator I,
303 MachineBasicBlock &BB, MachineBasicBlock::iterator I,
388 MachineBasicBlock *loopMBB = MF->CreateMachineBasicBlock(LLVM_BB);
389 MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(LLVM_BB);
390 MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
482 bool MipsExpandPseudo::expandAtomicBinOp(MachineBasicBlock &BB,
483 MachineBasicBlock::iterator I,
578 MachineBasicBlock *loopMBB = MF->CreateMachineBasicBlock(LLVM_BB);
579 MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
620 bool MipsExpandPseudo::expandMI(MachineBasicBlock &MBB,
621 MachineBasicBlock::iterator MBBI,
669 bool MipsExpandPseudo::expandMBB(MachineBasicBlock &MBB) {
672 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
674 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
lib/Target/Mips/MipsFastISel.cpp 946 MachineBasicBlock *BrBB = FuncInfo.MBB;
954 MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
955 MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
lib/Target/Mips/MipsFrameLowering.cpp 137 MachineBasicBlock::iterator MipsFrameLowering::
lib/Target/Mips/MipsFrameLowering.h 43 MachineBasicBlock::iterator
lib/Target/Mips/MipsISelLowering.cpp 1263 static MachineBasicBlock *insertDivByZeroTrap(MachineInstr &MI,
1264 MachineBasicBlock &MBB,
1271 MachineBasicBlock::iterator I(MI);
1293 MachineBasicBlock *
1295 MachineBasicBlock *BB) const {
1421 MachineBasicBlock *
1423 MachineBasicBlock *BB) const {
1483 MachineBasicBlock::iterator II(MI);
1538 MachineBasicBlock *MipsTargetLowering::emitSignExtendToI32InReg(
1539 MachineInstr &MI, MachineBasicBlock *BB, unsigned Size, unsigned DstReg,
1568 MachineBasicBlock *MipsTargetLowering::emitAtomicBinaryPartword(
1569 MachineInstr &MI, MachineBasicBlock *BB, unsigned Size) const {
1648 MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
1720 MachineBasicBlock *
1722 MachineBasicBlock *BB) const {
1745 MachineBasicBlock::iterator II(MI);
1777 MachineBasicBlock *MipsTargetLowering::emitAtomicCmpSwapPartword(
1778 MachineInstr &MI, MachineBasicBlock *BB, unsigned Size) const {
1826 MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
4414 MachineBasicBlock *MipsTargetLowering::emitPseudoSELECT(MachineInstr &MI,
4415 MachineBasicBlock *BB,
4439 MachineBasicBlock *thisMBB = BB;
4441 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
4442 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
4492 MachineBasicBlock *MipsTargetLowering::emitPseudoD_SELECT(MachineInstr &MI,
4493 MachineBasicBlock *BB) const {
4515 MachineBasicBlock *thisMBB = BB;
4517 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
4518 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
lib/Target/Mips/MipsISelLowering.h 342 MachineBasicBlock *
344 MachineBasicBlock *MBB) const override;
692 MachineBasicBlock *emitSignExtendToI32InReg(MachineInstr &MI,
693 MachineBasicBlock *BB,
697 MachineBasicBlock *emitAtomicBinary(MachineInstr &MI,
698 MachineBasicBlock *BB) const;
699 MachineBasicBlock *emitAtomicBinaryPartword(MachineInstr &MI,
700 MachineBasicBlock *BB,
702 MachineBasicBlock *emitAtomicCmpSwap(MachineInstr &MI,
703 MachineBasicBlock *BB) const;
704 MachineBasicBlock *emitAtomicCmpSwapPartword(MachineInstr &MI,
705 MachineBasicBlock *BB,
707 MachineBasicBlock *emitSEL_D(MachineInstr &MI, MachineBasicBlock *BB) const;
707 MachineBasicBlock *emitSEL_D(MachineInstr &MI, MachineBasicBlock *BB) const;
708 MachineBasicBlock *emitPseudoSELECT(MachineInstr &MI, MachineBasicBlock *BB,
708 MachineBasicBlock *emitPseudoSELECT(MachineInstr &MI, MachineBasicBlock *BB,
710 MachineBasicBlock *emitPseudoD_SELECT(MachineInstr &MI,
711 MachineBasicBlock *BB) const;
lib/Target/Mips/MipsInstrInfo.cpp 58 insertNoop(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const
58 insertNoop(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const
65 MipsInstrInfo::GetMemOperand(MachineBasicBlock &MBB, int FI,
80 MachineBasicBlock *&BB,
94 bool MipsInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
95 MachineBasicBlock *&TBB,
96 MachineBasicBlock *&FBB,
105 void MipsInstrInfo::BuildCondBr(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
105 void MipsInstrInfo::BuildCondBr(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
120 unsigned MipsInstrInfo::insertBranch(MachineBasicBlock &MBB,
121 MachineBasicBlock *TBB,
122 MachineBasicBlock *FBB,
154 unsigned MipsInstrInfo::removeBranch(MachineBasicBlock &MBB,
158 MachineBasicBlock::reverse_iterator I = MBB.rbegin(), REnd = MBB.rend();
191 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
191 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
191 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
194 MachineBasicBlock::reverse_iterator I = MBB.rbegin(), REnd = MBB.rend();
439 const MachineBasicBlock::iterator I) const {
595 MachineBasicBlock::iterator I) const {
lib/Target/Mips/MipsInstrInfo.h 63 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
63 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
64 MachineBasicBlock *&FBB,
68 unsigned removeBranch(MachineBasicBlock &MBB,
71 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
71 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
72 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
79 BranchType analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
79 BranchType analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
80 MachineBasicBlock *&FBB,
86 unsigned getEquivalentCompactForm(const MachineBasicBlock::iterator I) const;
99 void insertNoop(MachineBasicBlock &MBB,
100 MachineBasicBlock::iterator MI) const override;
112 void storeRegToStackSlot(MachineBasicBlock &MBB,
113 MachineBasicBlock::iterator MBBI,
120 void loadRegFromStackSlot(MachineBasicBlock &MBB,
121 MachineBasicBlock::iterator MBBI,
128 virtual void storeRegToStack(MachineBasicBlock &MBB,
129 MachineBasicBlock::iterator MI,
135 virtual void loadRegFromStack(MachineBasicBlock &MBB,
136 MachineBasicBlock::iterator MI,
143 MachineBasicBlock &MBB,
144 MachineBasicBlock::iterator I) const = 0;
149 MachineBasicBlock::iterator I) const;
167 MachineMemOperand *GetMemOperand(MachineBasicBlock &MBB, int FI,
174 MachineBasicBlock *&BB,
177 void BuildCondBr(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
177 void BuildCondBr(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
lib/Target/Mips/MipsInstructionSelector.cpp 231 MachineBasicBlock &MBB = *I.getParent();
lib/Target/Mips/MipsMCInstLower.cpp 206 MCOperand MipsMCInstLower::createSub(MachineBasicBlock *BB1,
207 MachineBasicBlock *BB2,
lib/Target/Mips/MipsMCInstLower.h 43 MCOperand createSub(MachineBasicBlock *BB1, MachineBasicBlock *BB2,
43 MCOperand createSub(MachineBasicBlock *BB1, MachineBasicBlock *BB2,
lib/Target/Mips/MipsMachineFunction.cpp 66 MachineBasicBlock &MBB = MF.front();
67 MachineBasicBlock::iterator I = MBB.begin();
lib/Target/Mips/MipsOptimizePICCall.cpp 150 static void setCallTargetReg(MachineBasicBlock *MBB,
151 MachineBasicBlock::iterator I) {
230 MachineBasicBlock *MBB = MBBI.getNode()->getBlock();
232 for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E;
lib/Target/Mips/MipsRegisterInfo.cpp 257 eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
lib/Target/Mips/MipsRegisterInfo.h 64 void eliminateFrameIndex(MachineBasicBlock::iterator II,
78 virtual void eliminateFI(MachineBasicBlock::iterator II, unsigned OpNo,
lib/Target/Mips/MipsSEFrameLowering.cpp 73 using Iter = MachineBasicBlock::iterator;
75 bool expandInstr(MachineBasicBlock &MBB, Iter I);
76 void expandLoadCCond(MachineBasicBlock &MBB, Iter I);
77 void expandStoreCCond(MachineBasicBlock &MBB, Iter I);
78 void expandLoadACC(MachineBasicBlock &MBB, Iter I, unsigned RegSize);
79 void expandStoreACC(MachineBasicBlock &MBB, Iter I, unsigned MFHiOpc,
81 bool expandCopy(MachineBasicBlock &MBB, Iter I);
82 bool expandCopyACC(MachineBasicBlock &MBB, Iter I, unsigned MFHiOpc,
84 bool expandBuildPairF64(MachineBasicBlock &MBB,
85 MachineBasicBlock::iterator I, bool FP64) const;
86 bool expandExtractElementF64(MachineBasicBlock &MBB,
87 MachineBasicBlock::iterator I, bool FP64) const;
107 for (auto &MBB : MF) {
115 bool ExpandPseudo::expandInstr(MachineBasicBlock &MBB, Iter I) {
167 void ExpandPseudo::expandLoadCCond(MachineBasicBlock &MBB, Iter I) {
182 void ExpandPseudo::expandStoreCCond(MachineBasicBlock &MBB, Iter I) {
197 void ExpandPseudo::expandLoadACC(MachineBasicBlock &MBB, Iter I,
221 void ExpandPseudo::expandStoreACC(MachineBasicBlock &MBB, Iter I,
244 bool ExpandPseudo::expandCopy(MachineBasicBlock &MBB, Iter I) {
254 bool ExpandPseudo::expandCopyACC(MachineBasicBlock &MBB, Iter I,
286 bool ExpandPseudo::expandBuildPairF64(MachineBasicBlock &MBB,
287 MachineBasicBlock::iterator I,
342 bool ExpandPseudo::expandExtractElementF64(MachineBasicBlock &MBB,
343 MachineBasicBlock::iterator I,
402 MachineBasicBlock &MBB) const {
411 MachineBasicBlock::iterator MBBI = MBB.begin();
561 MachineFunction &MF, MachineBasicBlock &MBB) const {
563 MachineBasicBlock::iterator MBBI = MBB.begin();
689 MachineBasicBlock &MBB) const {
690 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
709 MachineBasicBlock::iterator I = MBBI;
723 MachineBasicBlock::iterator I = MBBI;
748 MachineFunction &MF, MachineBasicBlock &MBB) const {
749 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
793 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
794 MachineBasicBlock::iterator MI,
lib/Target/Mips/MipsSEFrameLowering.h 27 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
28 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
33 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
34 MachineBasicBlock::iterator MI,
45 MachineBasicBlock &MBB) const;
47 MachineBasicBlock &MBB) const;
lib/Target/Mips/MipsSEISelDAGToDAG.cpp 127 void MipsSEDAGToDAGISel::emitMCountABI(MachineInstr &MI, MachineBasicBlock &MBB,
159 for (auto &MBB: MF) {
lib/Target/Mips/MipsSEISelDAGToDAG.h 132 void emitMCountABI(MachineInstr &MI, MachineBasicBlock &MBB,
lib/Target/Mips/MipsSEISelLowering.cpp 1065 MachineBasicBlock *
1067 MachineBasicBlock *BB) const {
3020 MachineBasicBlock *
3022 MachineBasicBlock *BB) const {
3043 MachineBasicBlock *FBB = F->CreateMachineBasicBlock(LLVM_BB);
3044 MachineBasicBlock *TBB = F->CreateMachineBasicBlock(LLVM_BB);
3045 MachineBasicBlock *Sink = F->CreateMachineBasicBlock(LLVM_BB);
3089 MachineBasicBlock *MipsSETargetLowering::emitMSACBranchPseudo(
3090 MachineInstr &MI, MachineBasicBlock *BB, unsigned BranchOp) const {
3112 MachineBasicBlock *FBB = F->CreateMachineBasicBlock(LLVM_BB);
3113 MachineBasicBlock *TBB = F->CreateMachineBasicBlock(LLVM_BB);
3114 MachineBasicBlock *Sink = F->CreateMachineBasicBlock(LLVM_BB);
3168 MachineBasicBlock *
3170 MachineBasicBlock *BB) const {
3212 MachineBasicBlock *
3214 MachineBasicBlock *BB) const {
3243 MachineBasicBlock *
3245 MachineBasicBlock *BB) const {
3277 MachineBasicBlock *
3279 MachineBasicBlock *BB) const {
3325 MachineBasicBlock *MipsSETargetLowering::emitINSERT_DF_VIDX(
3326 MachineInstr &MI, MachineBasicBlock *BB, unsigned EltSizeInBytes,
3439 MachineBasicBlock *
3441 MachineBasicBlock *BB) const {
3472 MachineBasicBlock *
3474 MachineBasicBlock *BB) const {
3507 MachineBasicBlock *
3509 MachineBasicBlock *BB) const {
3562 MachineBasicBlock *
3564 MachineBasicBlock *BB) const {
3648 MachineBasicBlock *
3650 MachineBasicBlock *BB,
3753 MachineBasicBlock *
3755 MachineBasicBlock *BB,
3816 MachineBasicBlock *
3818 MachineBasicBlock *BB) const {
3845 MachineBasicBlock *
3847 MachineBasicBlock *BB) const {
lib/Target/Mips/MipsSEISelLowering.h 52 MachineBasicBlock *
54 MachineBasicBlock *MBB) const override;
91 MachineBasicBlock *emitBPOSGE32(MachineInstr &MI,
92 MachineBasicBlock *BB) const;
93 MachineBasicBlock *emitMSACBranchPseudo(MachineInstr &MI,
94 MachineBasicBlock *BB,
97 MachineBasicBlock *emitCOPY_FW(MachineInstr &MI,
98 MachineBasicBlock *BB) const;
100 MachineBasicBlock *emitCOPY_FD(MachineInstr &MI,
101 MachineBasicBlock *BB) const;
103 MachineBasicBlock *emitINSERT_FW(MachineInstr &MI,
104 MachineBasicBlock *BB) const;
106 MachineBasicBlock *emitINSERT_FD(MachineInstr &MI,
107 MachineBasicBlock *BB) const;
109 MachineBasicBlock *emitINSERT_DF_VIDX(MachineInstr &MI,
110 MachineBasicBlock *BB,
114 MachineBasicBlock *emitFILL_FW(MachineInstr &MI,
115 MachineBasicBlock *BB) const;
117 MachineBasicBlock *emitFILL_FD(MachineInstr &MI,
118 MachineBasicBlock *BB) const;
120 MachineBasicBlock *emitFEXP2_W_1(MachineInstr &MI,
121 MachineBasicBlock *BB) const;
123 MachineBasicBlock *emitFEXP2_D_1(MachineInstr &MI,
124 MachineBasicBlock *BB) const;
126 MachineBasicBlock *emitLD_F16_PSEUDO(MachineInstr &MI,
127 MachineBasicBlock *BB) const;
129 MachineBasicBlock *emitST_F16_PSEUDO(MachineInstr &MI,
130 MachineBasicBlock *BB) const;
132 MachineBasicBlock *emitFPEXTEND_PSEUDO(MachineInstr &MI,
133 MachineBasicBlock *BB,
136 MachineBasicBlock *emitFPROUND_PSEUDO(MachineInstr &MI,
137 MachineBasicBlock *BBi,
lib/Target/Mips/MipsSEInstrInfo.cpp 83 void MipsSEInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
84 MachineBasicBlock::iterator I,
250 storeRegToStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
250 storeRegToStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
324 loadRegFromStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
324 loadRegFromStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
409 MachineBasicBlock &MBB = *MI.getParent();
581 MachineBasicBlock &MBB,
582 MachineBasicBlock::iterator I) const {
608 unsigned MipsSEInstrInfo::loadImmediate(int64_t Imm, MachineBasicBlock &MBB,
609 MachineBasicBlock::iterator II,
677 void MipsSEInstrInfo::expandRetRA(MachineBasicBlock &MBB,
678 MachineBasicBlock::iterator I) const {
695 void MipsSEInstrInfo::expandERet(MachineBasicBlock &MBB,
696 MachineBasicBlock::iterator I) const {
712 void MipsSEInstrInfo::expandPseudoMFHiLo(MachineBasicBlock &MBB,
713 MachineBasicBlock::iterator I,
718 void MipsSEInstrInfo::expandPseudoMTLoHi(MachineBasicBlock &MBB,
719 MachineBasicBlock::iterator I,
748 void MipsSEInstrInfo::expandCvtFPInt(MachineBasicBlock &MBB,
749 MachineBasicBlock::iterator I,
772 void MipsSEInstrInfo::expandExtractElementF64(MachineBasicBlock &MBB,
773 MachineBasicBlock::iterator I,
815 void MipsSEInstrInfo::expandBuildPairF64(MachineBasicBlock &MBB,
816 MachineBasicBlock::iterator I,
875 void MipsSEInstrInfo::expandEhReturn(MachineBasicBlock &MBB,
876 MachineBasicBlock::iterator I) const {
lib/Target/Mips/MipsSEInstrInfo.h 45 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
45 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
49 void storeRegToStack(MachineBasicBlock &MBB,
50 MachineBasicBlock::iterator MI,
56 void loadRegFromStack(MachineBasicBlock &MBB,
57 MachineBasicBlock::iterator MI,
68 void adjustStackPtr(unsigned SP, int64_t Amount, MachineBasicBlock &MBB,
69 MachineBasicBlock::iterator I) const override;
74 unsigned loadImmediate(int64_t Imm, MachineBasicBlock &MBB,
75 MachineBasicBlock::iterator II, const DebugLoc &DL,
88 void expandRetRA(MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const;
88 void expandRetRA(MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const;
90 void expandERet(MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const;
90 void expandERet(MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const;
95 void expandPseudoMFHiLo(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
95 void expandPseudoMFHiLo(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
98 void expandPseudoMTLoHi(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
98 void expandPseudoMTLoHi(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
112 void expandCvtFPInt(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
112 void expandCvtFPInt(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
115 void expandExtractElementF64(MachineBasicBlock &MBB,
116 MachineBasicBlock::iterator I, bool isMicroMips,
118 void expandBuildPairF64(MachineBasicBlock &MBB,
119 MachineBasicBlock::iterator I, bool isMicroMips,
121 void expandEhReturn(MachineBasicBlock &MBB,
122 MachineBasicBlock::iterator I) const;
lib/Target/Mips/MipsSERegisterInfo.cpp 145 void MipsSERegisterInfo::eliminateFI(MachineBasicBlock::iterator II,
220 MachineBasicBlock &MBB = *MI.getParent();
239 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/Mips/MipsSERegisterInfo.h 33 void eliminateFI(MachineBasicBlock::iterator II, unsigned OpNo,
lib/Target/NVPTX/NVPTXAsmPrinter.cpp 411 const MachineBasicBlock &MBB) const {
421 const MachineBasicBlock *PMBB = *I;
437 void NVPTXAsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
lib/Target/NVPTX/NVPTXAsmPrinter.h 203 void EmitBasicBlockStart(const MachineBasicBlock &MBB) override;
275 bool isLoopHeaderOfNoUnroll(const MachineBasicBlock &MBB) const;
lib/Target/NVPTX/NVPTXFrameLowering.cpp 33 MachineBasicBlock &MBB) const {
75 MachineBasicBlock &MBB) const {}
79 MachineBasicBlock::iterator NVPTXFrameLowering::eliminateCallFramePseudoInstr(
lib/Target/NVPTX/NVPTXFrameLowering.h 25 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
26 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
30 MachineBasicBlock::iterator
lib/Target/NVPTX/NVPTXInstrInfo.cpp 32 void NVPTXInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
33 MachineBasicBlock::iterator I,
95 bool NVPTXInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
96 MachineBasicBlock *&TBB,
97 MachineBasicBlock *&FBB,
101 MachineBasicBlock::iterator I = MBB.end();
154 unsigned NVPTXInstrInfo::removeBranch(MachineBasicBlock &MBB,
157 MachineBasicBlock::iterator I = MBB.end();
180 unsigned NVPTXInstrInfo::insertBranch(MachineBasicBlock &MBB,
181 MachineBasicBlock *TBB,
182 MachineBasicBlock *FBB,
lib/Target/NVPTX/NVPTXInstrInfo.h 51 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
51 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
56 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
56 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
57 MachineBasicBlock *&FBB,
60 unsigned removeBranch(MachineBasicBlock &MBB,
62 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
62 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
63 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
lib/Target/NVPTX/NVPTXPeephole.cpp 74 auto &MBB = *Root.getParent();
105 auto &MBB = *Root.getParent();
132 for (auto &MBB : MF) {
lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp 58 for (MachineBasicBlock &MBB : MF) {
lib/Target/NVPTX/NVPTXProxyRegErasure.cpp 69 for (auto &BB : MF) {
102 for (auto &BB : MF) {
lib/Target/NVPTX/NVPTXRegisterInfo.cpp 112 void NVPTXRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
lib/Target/NVPTX/NVPTXRegisterInfo.h 41 void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
lib/Target/NVPTX/NVPTXReplaceImageHandles.cpp 61 for (MachineBasicBlock::iterator I = (*BI).begin(), E = (*BI).end();
lib/Target/PowerPC/PPCAsmPrinter.cpp 359 const MachineBasicBlock &MBB = *MI.getParent();
360 MachineBasicBlock::const_iterator MII(MI);
lib/Target/PowerPC/PPCBranchCoalescing.cpp 137 MachineBasicBlock *BranchBlock; // Block containing the branch
138 MachineBasicBlock *BranchTargetBlock; // Block branched to
139 MachineBasicBlock *FallThroughBlock; // Fall-through if branch not taken
178 const MachineBasicBlock &MBB) const;
180 const MachineBasicBlock &MBB) const;
183 void moveAndUpdatePHIs(MachineBasicBlock *SourceRegionMBB,
184 MachineBasicBlock *TargetRegionMBB);
236 MachineBasicBlock *FalseMBB = nullptr;
295 MachineBasicBlock *Succ =
388 void PPCBranchCoalescing::moveAndUpdatePHIs(MachineBasicBlock *SourceMBB,
389 MachineBasicBlock *TargetMBB) {
391 MachineBasicBlock::iterator MI = SourceMBB->begin();
392 MachineBasicBlock::iterator ME = SourceMBB->getFirstNonPHI();
400 for (MachineBasicBlock::iterator Iter = MI; Iter != ME; Iter++) {
422 const MachineBasicBlock &TargetMBB
453 const MachineBasicBlock &TargetMBB
535 for (MachineBasicBlock::iterator
560 for (MachineBasicBlock::iterator
652 MachineBasicBlock::iterator firstInstr =
654 MachineBasicBlock::iterator lastInstr =
657 MachineBasicBlock *Source = SourceRegion.MustMoveDown
661 MachineBasicBlock::iterator Target =
682 MachineBasicBlock::iterator I =
731 for (MachineBasicBlock &MBB : MF) {
lib/Target/PowerPC/PPCBranchSelector.cpp 50 unsigned GetAlignmentAdjustment(MachineBasicBlock &MBB, unsigned Offset);
54 const MachineBasicBlock *Src,
55 const MachineBasicBlock *Dest,
82 unsigned PPCBSel::GetAlignmentAdjustment(MachineBasicBlock &MBB,
122 MachineBasicBlock *MBB = &*MFI;
155 MachineBasicBlock *MBB = &*MFI;
177 const MachineBasicBlock *Src,
178 const MachineBasicBlock *Dest,
299 MachineBasicBlock &MBB = *MFI;
301 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
303 MachineBasicBlock *Dest = nullptr;
lib/Target/PowerPC/PPCCTRLoops.cpp 128 static bool verifyCTRBranch(MachineBasicBlock *MBB,
129 MachineBasicBlock::iterator I) {
130 MachineBasicBlock::iterator BI = I;
131 SmallSet<MachineBasicBlock *, 16> Visited;
132 SmallVector<MachineBasicBlock *, 8> Preds;
147 for (MachineBasicBlock::iterator IE = MBB->begin();; --I) {
181 for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(),
204 MachineBasicBlock *MBB = &*I;
208 for (MachineBasicBlock::iterator MII = MBB->getFirstTerminator(),
lib/Target/PowerPC/PPCEarlyReturn.cpp 52 bool processBlock(MachineBasicBlock &ReturnMBB) {
55 MachineBasicBlock::iterator I = ReturnMBB.begin();
64 SmallVector<MachineBasicBlock*, 8> PredToRemove;
65 for (MachineBasicBlock::pred_iterator PI = ReturnMBB.pred_begin(),
72 for (MachineBasicBlock::iterator J = (*PI)->getLastNonDebugInstr();;) {
82 MachineBasicBlock::iterator K = J--;
96 MachineBasicBlock::iterator K = J--;
111 MachineBasicBlock::iterator K = J--;
154 MachineBasicBlock &PrevMBB = **ReturnMBB.pred_begin();
185 MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCExpandISEL.cpp 51 MachineBasicBlock *TrueBlock;
52 MachineBasicBlock *FalseBlock;
53 MachineBasicBlock *NewSuccessor;
54 MachineBasicBlock::iterator TrueBlockI;
55 MachineBasicBlock::iterator FalseBlockI;
158 for (MachineBasicBlock &MBB : *MF) {
186 MachineBasicBlock::iterator PrevPushedMBBI = *PrevPushedMI;
187 MachineBasicBlock::iterator MBBI = *MI;
227 MachineBasicBlock *MBB = (*I)->getParent();
335 MachineBasicBlock *Successor = nullptr;
337 MachineBasicBlock::iterator MBBI = (*BIL.back());
497 MachineBasicBlock *MBB = BIL.back()->getParent();
lib/Target/PowerPC/PPCFastISel.cpp 771 MachineBasicBlock *BrBB = FuncInfo.MBB;
772 MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
773 MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
805 MachineBasicBlock *Target = (Imm == 0) ? FBB : TBB;
2361 MachineBasicBlock::iterator I(MI);
lib/Target/PowerPC/PPCFrameLowering.cpp 294 MachineBasicBlock *Entry = MI.getParent();
298 MachineBasicBlock::iterator MBBI = MI;
361 const MachineBasicBlock &MBB = *BI;
570 for (MachineBasicBlock::iterator MBBI = BI->end(); MBBI != BI->begin(); ) {
613 PPCFrameLowering::findScratchRegister(MachineBasicBlock *MBB,
642 MachineBasicBlock::iterator MBBI = MBB->getFirstTerminator();
704 PPCFrameLowering::twoUniqueScratchRegsRequired(MachineBasicBlock *MBB) const {
718 bool PPCFrameLowering::canUseAsPrologue(const MachineBasicBlock &MBB) const {
719 MachineBasicBlock *TmpMBB = const_cast<MachineBasicBlock *>(&MBB);
725 bool PPCFrameLowering::canUseAsEpilogue(const MachineBasicBlock &MBB) const {
726 MachineBasicBlock *TmpMBB = const_cast<MachineBasicBlock *>(&MBB);
776 MachineBasicBlock &MBB) const {
777 MachineBasicBlock::iterator MBBI = MBB.begin();
928 MachineBasicBlock::iterator StackUpdateLoc = MBBI;
1372 MachineBasicBlock &MBB) const {
1373 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
1512 MachineBasicBlock::iterator StackUpdateLoc = MBBI;
1724 void PPCFrameLowering::createTailCallBranchInstr(MachineBasicBlock &MBB) const {
1725 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
1855 MachineBasicBlock *RestoreBlock = MFI.getRestorePoint();
1856 for (MachineBasicBlock &MBB : MF) {
2185 PPCFrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
2186 MachineBasicBlock::iterator MI,
2275 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
2275 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
2308 MachineBasicBlock::iterator PPCFrameLowering::
2331 MachineBasicBlock::iterator MBBI = I;
2348 PPCFrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
2349 MachineBasicBlock::iterator MI,
2369 MachineBasicBlock::iterator I = MI, BeforeI = I;
lib/Target/PowerPC/PPCFrameLowering.h 61 bool findScratchRegister(MachineBasicBlock *MBB,
66 bool twoUniqueScratchRegsRequired(MachineBasicBlock *MBB) const;
73 void createTailCallBranchInstr(MachineBasicBlock &MBB) const;
101 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
102 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
114 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
115 MachineBasicBlock::iterator MI,
126 MachineBasicBlock::iterator
130 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
131 MachineBasicBlock::iterator MI,
171 bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
172 bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
lib/Target/PowerPC/PPCISelDAGToDAG.cpp 398 MachineBasicBlock &EntryBB = *Fn.begin();
404 MachineBasicBlock::iterator IP = EntryBB.begin(); // Insert Point
417 MachineBasicBlock::iterator I2 = IP;
434 MachineBasicBlock &FirstMBB = MF->front();
435 MachineBasicBlock::iterator MBBI = FirstMBB.begin();
lib/Target/PowerPC/PPCISelLowering.cpp10297 MachineBasicBlock *
10298 PPCTargetLowering::EmitAtomicBinary(MachineInstr &MI, MachineBasicBlock *BB,
10341 MachineBasicBlock *loopMBB = F->CreateMachineBasicBlock(LLVM_BB);
10342 MachineBasicBlock *loop2MBB =
10344 MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
10416 MachineBasicBlock *PPCTargetLowering::EmitPartwordAtomicBinary(
10417 MachineInstr &MI, MachineBasicBlock *BB,
10445 MachineBasicBlock *loopMBB = F->CreateMachineBasicBlock(LLVM_BB);
10446 MachineBasicBlock *loop2MBB =
10448 MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
10609 llvm::MachineBasicBlock *
10611 MachineBasicBlock *MBB) const {
10647 MachineBasicBlock *thisMBB = MBB;
10648 MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
10649 MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
10751 MachineBasicBlock *
10753 MachineBasicBlock *MBB) const {
10853 MachineBasicBlock *
10855 MachineBasicBlock *BB) const {
10940 MachineBasicBlock *thisMBB = BB;
10941 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
10942 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
11009 MachineBasicBlock *readMBB = F->CreateMachineBasicBlock(LLVM_BB);
11010 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
11181 MachineBasicBlock *loop1MBB = F->CreateMachineBasicBlock(LLVM_BB);
11182 MachineBasicBlock *loop2MBB = F->CreateMachineBasicBlock(LLVM_BB);
11183 MachineBasicBlock *midMBB = F->CreateMachineBasicBlock(LLVM_BB);
11184 MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
11260 MachineBasicBlock *loop1MBB = F->CreateMachineBasicBlock(LLVM_BB);
11261 MachineBasicBlock *loop2MBB = F->CreateMachineBasicBlock(LLVM_BB);
11262 MachineBasicBlock *midMBB = F->CreateMachineBasicBlock(LLVM_BB);
11263 MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
15014 void PPCTargetLowering::initializeSplitCSR(MachineBasicBlock *Entry) const {
15024 MachineBasicBlock *Entry,
15025 const SmallVectorImpl<MachineBasicBlock *> &Exits) const {
15033 MachineBasicBlock::iterator MBBI = Entry->begin();
15061 for (auto *Exit : Exits)
lib/Target/PowerPC/PPCISelLowering.h 669 void initializeSplitCSR(MachineBasicBlock *Entry) const override;
672 MachineBasicBlock *Entry,
673 const SmallVectorImpl<MachineBasicBlock *> &Exits) const override;
759 MachineBasicBlock *
761 MachineBasicBlock *MBB) const override;
762 MachineBasicBlock *EmitAtomicBinary(MachineInstr &MI,
763 MachineBasicBlock *MBB,
768 MachineBasicBlock *EmitPartwordAtomicBinary(MachineInstr &MI,
769 MachineBasicBlock *MBB,
775 MachineBasicBlock *emitEHSjLjSetJmp(MachineInstr &MI,
776 MachineBasicBlock *MBB) const;
778 MachineBasicBlock *emitEHSjLjLongJmp(MachineInstr &MI,
779 MachineBasicBlock *MBB) const;
lib/Target/PowerPC/PPCInstrInfo.cpp 468 void PPCInstrInfo::insertNoop(MachineBasicBlock &MBB,
469 MachineBasicBlock::iterator MI) const {
495 bool PPCInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
496 MachineBasicBlock *&TBB,
497 MachineBasicBlock *&FBB,
503 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
670 unsigned PPCInstrInfo::removeBranch(MachineBasicBlock &MBB,
674 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
702 unsigned PPCInstrInfo::insertBranch(MachineBasicBlock &MBB,
703 MachineBasicBlock *TBB,
704 MachineBasicBlock *FBB,
755 bool PPCInstrInfo::canInsertSelect(const MachineBasicBlock &MBB,
792 void PPCInstrInfo::insertSelect(MachineBasicBlock &MBB,
793 MachineBasicBlock::iterator MI,
904 void PPCInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
905 MachineBasicBlock::iterator I,
1224 void PPCInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
1225 MachineBasicBlock::iterator MI,
1277 PPCInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
1278 MachineBasicBlock::iterator MI,
1392 static bool MBBDefinesCTR(MachineBasicBlock &MBB) {
1393 for (MachineBasicBlock::iterator I = MBB.begin(), IE = MBB.end();
1406 bool PPCInstrInfo::isProfitableToIfCvt(MachineBasicBlock &TMBB,
1408 MachineBasicBlock &FMBB,
1465 MachineBasicBlock *MBB = MI.getOperand(0).getMBB();
1473 MachineBasicBlock *MBB = MI.getOperand(0).getMBB();
1481 MachineBasicBlock *MBB = MI.getOperand(0).getMBB();
1718 MachineBasicBlock::iterator I = CmpInstr;
1721 for (MachineBasicBlock::iterator EL = CmpInstr.getParent()->end(); I != EL;
1798 MachineBasicBlock::iterator E = MI, B = CmpInstr.getParent()->begin();
1912 MachineBasicBlock::iterator MII = MI;
2133 auto &MBB = *MI.getParent();
2328 MachineBasicBlock::reverse_iterator E = MI.getParent()->rend(), It = MI;
2489 MachineBasicBlock::reverse_iterator It = EndMI;
2490 MachineBasicBlock::reverse_iterator E = EndMI.getParent()->rend();
3521 MachineBasicBlock::const_reverse_iterator It = MI;
3522 MachineBasicBlock::const_reverse_iterator E = MI.getParent()->rend();
4029 const MachineBasicBlock *MBB = MI.getParent();
4030 MachineBasicBlock::const_instr_iterator II =
4185 createTripCountGreaterCondition(int TC, MachineBasicBlock &MBB,
4200 void setPreheader(MachineBasicBlock *NewPreheader) override {
4228 PPCInstrInfo::analyzeLoopForPipelining(MachineBasicBlock *LoopBB) const {
4230 MachineBasicBlock::iterator I = LoopBB->getFirstTerminator();
4231 MachineBasicBlock *Preheader = *LoopBB->pred_begin();
4237 SmallPtrSet<MachineBasicBlock *, 8> Visited;
4249 MachineBasicBlock &PreHeader,
4250 SmallPtrSet<MachineBasicBlock *, 8> &Visited) const {
lib/Target/PowerPC/PPCInstrInfo.h 258 void insertNoop(MachineBasicBlock &MBB,
259 MachineBasicBlock::iterator MI) const override;
263 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
263 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
264 MachineBasicBlock *&FBB,
267 unsigned removeBranch(MachineBasicBlock &MBB,
269 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
269 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
270 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
275 bool canInsertSelect(const MachineBasicBlock &, ArrayRef<MachineOperand> Cond,
277 void insertSelect(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
277 void insertSelect(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
282 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
282 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
286 void storeRegToStackSlot(MachineBasicBlock &MBB,
287 MachineBasicBlock::iterator MBBI,
292 void loadRegFromStackSlot(MachineBasicBlock &MBB,
293 MachineBasicBlock::iterator MBBI,
313 bool isProfitableToIfCvt(MachineBasicBlock &MBB,
319 bool isProfitableToIfCvt(MachineBasicBlock &TMBB,
321 MachineBasicBlock &FMBB,
325 bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
330 bool isProfitableToUnpredicate(MachineBasicBlock &TMBB,
331 MachineBasicBlock &FMBB) const override {
499 findLoopInstr(MachineBasicBlock &PreHeader,
500 SmallPtrSet<MachineBasicBlock *, 8> &Visited) const;
505 analyzeLoopForPipelining(MachineBasicBlock *LoopBB) const override;
lib/Target/PowerPC/PPCMIPeephole.cpp 224 MachineBasicBlock *Entry = &MF->front();
276 for (MachineBasicBlock &MBB : *MF) {
296 for (MachineBasicBlock &MBB : *MF) {
903 MachineBasicBlock *MBB) {
916 static unsigned getSrcVReg(unsigned Reg, MachineBasicBlock *BB1,
917 MachineBasicBlock *BB2, MachineRegisterInfo *MRI) {
936 static bool eligibleForCompareElimination(MachineBasicBlock &MBB,
937 MachineBasicBlock *&PredMBB,
938 MachineBasicBlock *&MBBtoMoveCmp,
983 MachineBasicBlock *TmpMBB = *MBB.pred_begin();
994 MachineBasicBlock::pred_iterator PI = MBB.pred_begin();
995 MachineBasicBlock *Pred1MBB = *PI;
996 MachineBasicBlock *Pred2MBB = *(PI+1);
1078 for (MachineBasicBlock &MBB2 : *MF) {
1079 MachineBasicBlock *MBB1 = nullptr, *MBBtoMoveCmp = nullptr;
lib/Target/PowerPC/PPCMachineScheduler.cpp 64 void PPCPostRASchedStrategy::enterMBB(MachineBasicBlock *MBB) {
lib/Target/PowerPC/PPCMachineScheduler.h 43 void enterMBB(MachineBasicBlock *MBB) override;
lib/Target/PowerPC/PPCPreEmitPeephole.cpp 71 bool removeRedundantLIs(MachineBasicBlock &MBB,
172 for (MachineBasicBlock &MBB : MF) {
229 MachineBasicBlock::reverse_iterator It = Br, Er = MBB.rend();
253 MachineBasicBlock::iterator It = Br, Er = MBB.end();
lib/Target/PowerPC/PPCQPXLoadSplat.cpp 65 MachineBasicBlock *MBB = &*MFI;
lib/Target/PowerPC/PPCReduceCRLogicals.cpp 55 static void updatePHIs(MachineBasicBlock *Successor, MachineBasicBlock *OrigMBB,
55 static void updatePHIs(MachineBasicBlock *Successor, MachineBasicBlock *OrigMBB,
56 MachineBasicBlock *NewMBB, MachineRegisterInfo *MRI) {
84 static void addIncomingValuesToPHIs(MachineBasicBlock *Successor,
85 MachineBasicBlock *OrigMBB,
86 MachineBasicBlock *NewMBB,
119 MachineBasicBlock *MBB = OrigBranch->getParent();
143 MachineBasicBlock *ThisMBB = BSI.OrigBranch->getParent();
163 MachineBasicBlock *OrigTarget = BSI.OrigBranch->getOperand(1).getMBB();
164 MachineBasicBlock *OrigFallThrough = OrigTarget == *ThisMBB->succ_begin()
167 MachineBasicBlock *NewBRTarget =
198 MachineBasicBlock::iterator InsertPoint = BSI.SplitBefore;
201 MachineBasicBlock *NewMBB = MF->CreateMachineBasicBlock(LLVM_BB);
241 for (auto *Succ : NewMBB->successors()) {
558 MachineBasicBlock::iterator Me = Copy, B = Copy->getParent()->begin();
638 MachineBasicBlock::iterator Def1It = CRI.TrueDefs.first;
639 MachineBasicBlock::iterator Def2It = CRI.TrueDefs.second;
663 MachineBasicBlock *MBB = SplitBefore->getParent();
665 MachineBasicBlock::iterator FirstInstrToMove =
667 MachineBasicBlock::iterator SecondInstrToMove =
711 for (MachineBasicBlock &MBB : *MF) {
lib/Target/PowerPC/PPCRegisterInfo.cpp 493 void PPCRegisterInfo::lowerDynamicAlloc(MachineBasicBlock::iterator II) const {
497 MachineBasicBlock &MBB = *MI.getParent();
612 MachineBasicBlock::iterator II) const {
616 MachineBasicBlock &MBB = *MI.getParent();
642 void PPCRegisterInfo::lowerCRSpilling(MachineBasicBlock::iterator II,
647 MachineBasicBlock &MBB = *MI.getParent();
687 void PPCRegisterInfo::lowerCRRestore(MachineBasicBlock::iterator II,
692 MachineBasicBlock &MBB = *MI.getParent();
730 void PPCRegisterInfo::lowerCRBitSpilling(MachineBasicBlock::iterator II,
735 MachineBasicBlock &MBB = *MI.getParent();
750 MachineBasicBlock::reverse_iterator Ins;
810 void PPCRegisterInfo::lowerCRBitRestore(MachineBasicBlock::iterator II,
815 MachineBasicBlock &MBB = *MI.getParent();
860 void PPCRegisterInfo::lowerVRSAVESpilling(MachineBasicBlock::iterator II,
865 MachineBasicBlock &MBB = *MI.getParent();
886 void PPCRegisterInfo::lowerVRSAVERestore(MachineBasicBlock::iterator II,
891 MachineBasicBlock &MBB = *MI.getParent();
983 PPCRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
991 MachineBasicBlock &MBB = *MI.getParent();
1196 MachineBasicBlock &MBB = *MI->getParent();
1220 materializeFrameBaseRegister(MachineBasicBlock *MBB,
1225 MachineBasicBlock::iterator Ins = MBB->begin();
1255 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/PowerPC/PPCRegisterInfo.h 112 void lowerDynamicAlloc(MachineBasicBlock::iterator II) const;
113 void lowerDynamicAreaOffset(MachineBasicBlock::iterator II) const;
114 void lowerCRSpilling(MachineBasicBlock::iterator II,
116 void lowerCRRestore(MachineBasicBlock::iterator II,
118 void lowerCRBitSpilling(MachineBasicBlock::iterator II,
120 void lowerCRBitRestore(MachineBasicBlock::iterator II,
122 void lowerVRSAVESpilling(MachineBasicBlock::iterator II,
124 void lowerVRSAVERestore(MachineBasicBlock::iterator II,
129 void eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
135 void materializeFrameBaseRegister(MachineBasicBlock *MBB,
lib/Target/PowerPC/PPCTLSDynamicCall.cpp 48 bool processBlock(MachineBasicBlock &MBB) {
53 for (MachineBasicBlock::iterator I = MBB.begin(), IE = MBB.end();
122 MachineBasicBlock::iterator First = I;
136 MachineBasicBlock::iterator Last = I;
159 MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCTOCRegDeps.cpp 110 bool processBlock(MachineBasicBlock &MBB) {
135 MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCVSXCopy.cpp 83 bool processBlock(MachineBasicBlock &MBB) {
152 MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCVSXFMAMutate.cpp 70 bool processBlock(MachineBasicBlock &MBB) {
75 for (MachineBasicBlock::iterator I = MBB.begin(), IE = MBB.end();
364 MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCVSXSwapRemoval.cpp 150 void insertSwap(MachineInstr *MI, MachineBasicBlock::iterator InsertPoint,
244 for (MachineBasicBlock &MBB : *MF) {
800 MachineBasicBlock::iterator InsertPoint,
950 MachineBasicBlock *MBB = MI->getParent();
lib/Target/RISCV/RISCVExpandPseudoInsts.cpp 43 bool expandMBB(MachineBasicBlock &MBB);
44 bool expandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
44 bool expandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
46 bool expandAtomicBinOp(MachineBasicBlock &MBB,
47 MachineBasicBlock::iterator MBBI, AtomicRMWInst::BinOp,
50 bool expandAtomicMinMaxOp(MachineBasicBlock &MBB,
51 MachineBasicBlock::iterator MBBI,
54 bool expandAtomicCmpXchg(MachineBasicBlock &MBB,
55 MachineBasicBlock::iterator MBBI, bool IsMasked,
57 bool expandAuipcInstPair(MachineBasicBlock &MBB,
58 MachineBasicBlock::iterator MBBI,
61 bool expandLoadLocalAddress(MachineBasicBlock &MBB,
62 MachineBasicBlock::iterator MBBI,
64 bool expandLoadAddress(MachineBasicBlock &MBB,
65 MachineBasicBlock::iterator MBBI,
67 bool expandLoadTLSIEAddress(MachineBasicBlock &MBB,
68 MachineBasicBlock::iterator MBBI,
70 bool expandLoadTLSGDAddress(MachineBasicBlock &MBB,
71 MachineBasicBlock::iterator MBBI,
80 for (auto &MBB : MF)
85 bool RISCVExpandPseudo::expandMBB(MachineBasicBlock &MBB) {
88 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
90 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
98 bool RISCVExpandPseudo::expandMI(MachineBasicBlock &MBB,
99 MachineBasicBlock::iterator MBBI,
234 DebugLoc DL, MachineBasicBlock *ThisMBB,
235 MachineBasicBlock *LoopMBB,
236 MachineBasicBlock *DoneMBB,
274 MachineBasicBlock *MBB, Register DestReg,
297 MachineBasicBlock *ThisMBB, MachineBasicBlock *LoopMBB,
297 MachineBasicBlock *ThisMBB, MachineBasicBlock *LoopMBB,
298 MachineBasicBlock *DoneMBB, AtomicRMWInst::BinOp BinOp, int Width) {
359 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
359 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
397 MachineBasicBlock *MBB, Register ValReg,
408 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
408 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
529 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, bool IsMasked,
529 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, bool IsMasked,
625 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
625 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
635 MachineBasicBlock *NewMBB = MF->CreateMachineBasicBlock(MBB.getBasicBlock());
666 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
666 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
673 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
673 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
691 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
691 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
702 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
702 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
lib/Target/RISCV/RISCVFrameLowering.cpp 62 void RISCVFrameLowering::adjustReg(MachineBasicBlock &MBB,
63 MachineBasicBlock::iterator MBBI,
102 MachineBasicBlock &MBB) const {
109 MachineBasicBlock::iterator MBBI = MBB.begin();
232 MachineBasicBlock &MBB) const {
233 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
439 MachineBasicBlock::iterator RISCVFrameLowering::eliminateCallFramePseudoInstr(
lib/Target/RISCV/RISCVFrameLowering.h 29 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
30 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
44 MachineBasicBlock::iterator
58 void adjustReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
58 void adjustReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
lib/Target/RISCV/RISCVISelLowering.cpp 1089 static MachineBasicBlock *emitReadCycleWidePseudo(MachineInstr &MI,
1090 MachineBasicBlock *BB) {
1108 MachineBasicBlock *LoopMBB = MF.CreateMachineBasicBlock(LLVM_BB);
1111 MachineBasicBlock *DoneMBB = MF.CreateMachineBasicBlock(LLVM_BB);
1151 static MachineBasicBlock *emitSplitF64Pseudo(MachineInstr &MI,
1152 MachineBasicBlock *BB) {
1182 static MachineBasicBlock *emitBuildPairF64Pseudo(MachineInstr &MI,
1183 MachineBasicBlock *BB) {
1226 static MachineBasicBlock *emitSelectPseudo(MachineInstr &MI,
1227 MachineBasicBlock *BB) {
1292 MachineBasicBlock *HeadMBB = BB;
1294 MachineBasicBlock *TailMBB = F->CreateMachineBasicBlock(LLVM_BB);
1295 MachineBasicBlock *IfFalseMBB = F->CreateMachineBasicBlock(LLVM_BB);
1349 MachineBasicBlock *
1351 MachineBasicBlock *BB) const {
lib/Target/RISCV/RISCVISelLowering.h 107 MachineBasicBlock *
109 MachineBasicBlock *BB) const override;
lib/Target/RISCV/RISCVInstrInfo.cpp 85 void RISCVInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
86 MachineBasicBlock::iterator MBBI,
110 void RISCVInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
111 MachineBasicBlock::iterator I,
137 void RISCVInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
138 MachineBasicBlock::iterator I,
161 void RISCVInstrInfo::movImm(MachineBasicBlock &MBB,
162 MachineBasicBlock::iterator MBBI,
203 static void parseCondBranch(MachineInstr &LastInst, MachineBasicBlock *&Target,
233 bool RISCVInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
234 MachineBasicBlock *&TBB,
235 MachineBasicBlock *&FBB,
242 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
248 MachineBasicBlock::iterator FirstUncondOrIndirectBr = MBB.end();
301 unsigned RISCVInstrInfo::removeBranch(MachineBasicBlock &MBB,
305 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
336 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
336 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
336 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
372 unsigned RISCVInstrInfo::insertIndirectBranch(MachineBasicBlock &MBB,
373 MachineBasicBlock &DestBB,
421 MachineBasicBlock *
lib/Target/RISCV/RISCVInstrInfo.h 36 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
36 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
40 void storeRegToStackSlot(MachineBasicBlock &MBB,
41 MachineBasicBlock::iterator MBBI, unsigned SrcReg,
46 void loadRegFromStackSlot(MachineBasicBlock &MBB,
47 MachineBasicBlock::iterator MBBI, unsigned DstReg,
52 void movImm(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
52 void movImm(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
58 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
58 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
59 MachineBasicBlock *&FBB,
63 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
63 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
64 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
68 unsigned insertIndirectBranch(MachineBasicBlock &MBB,
69 MachineBasicBlock &NewDestBB,
73 unsigned removeBranch(MachineBasicBlock &MBB,
79 MachineBasicBlock *getBranchDestBlock(const MachineInstr &MI) const override;
lib/Target/RISCV/RISCVMergeBaseOffset.cpp 264 for (MachineBasicBlock &MBB : Fn) {
lib/Target/RISCV/RISCVRegisterInfo.cpp 102 void RISCVRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
124 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/RISCV/RISCVRegisterInfo.h 40 void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
lib/Target/Sparc/DelaySlotFiller.cpp 47 bool runOnMachineBasicBlock(MachineBasicBlock &MBB);
67 void insertCallDefsUses(MachineBasicBlock::iterator MI,
71 void insertDefsUses(MachineBasicBlock::iterator MI,
78 bool delayHasHazard(MachineBasicBlock::iterator candidate,
83 MachineBasicBlock::iterator
86 bool needsUnimp(MachineBasicBlock::iterator I, unsigned &StructSize);
88 bool tryCombineRestoreWithPrevInst(MachineBasicBlock &MBB,
89 MachineBasicBlock::iterator MBBI);
106 bool Filler::runOnMachineBasicBlock(MachineBasicBlock &MBB) {
111 for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); ) {
112 MachineBasicBlock::iterator MI = I;
137 MachineBasicBlock::iterator D = MBB.end();
152 MachineBasicBlock::iterator J = MI;
166 MachineBasicBlock::iterator
182 MachineBasicBlock::iterator J = slot;
201 MachineBasicBlock::iterator I = slot;
227 bool Filler::delayHasHazard(MachineBasicBlock::iterator candidate,
289 void Filler::insertCallDefsUses(MachineBasicBlock::iterator MI,
318 void Filler::insertDefsUses(MachineBasicBlock::iterator MI,
353 bool Filler::needsUnimp(MachineBasicBlock::iterator I, unsigned &StructSize)
374 static bool combineRestoreADD(MachineBasicBlock::iterator RestoreMI,
401 static bool combineRestoreOR(MachineBasicBlock::iterator RestoreMI,
440 static bool combineRestoreSETHIi(MachineBasicBlock::iterator RestoreMI,
480 bool Filler::tryCombineRestoreWithPrevInst(MachineBasicBlock &MBB,
481 MachineBasicBlock::iterator MBBI)
493 MachineBasicBlock::iterator PrevInst = std::prev(MBBI);
lib/Target/Sparc/LeonPasses.cpp 47 MachineBasicBlock &MBB = *MFI;
52 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
82 MachineBasicBlock &MBB = *MFI;
134 MachineBasicBlock &MBB = *MFI;
147 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
lib/Target/Sparc/SparcAsmPrinter.cpp 264 MachineBasicBlock::const_instr_iterator I = MI->getIterator();
265 MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
lib/Target/Sparc/SparcFrameLowering.cpp 41 MachineBasicBlock &MBB,
42 MachineBasicBlock::iterator MBBI,
86 MachineBasicBlock &MBB) const {
96 MachineBasicBlock::iterator MBBI = MBB.begin();
204 MachineBasicBlock::iterator SparcFrameLowering::
221 MachineBasicBlock &MBB) const {
223 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
lib/Target/Sparc/SparcFrameLowering.h 28 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
29 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
31 MachineBasicBlock::iterator
59 MachineBasicBlock &MBB,
60 MachineBasicBlock::iterator MBBI,
lib/Target/Sparc/SparcISelLowering.cpp 3098 MachineBasicBlock *
3100 MachineBasicBlock *BB) const {
3116 MachineBasicBlock *
3117 SparcTargetLowering::expandSelectCC(MachineInstr &MI, MachineBasicBlock *BB,
3137 MachineBasicBlock *ThisMBB = BB;
3139 MachineBasicBlock *IfFalseMBB = F->CreateMachineBasicBlock(LLVM_BB);
3140 MachineBasicBlock *SinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
lib/Target/Sparc/SparcISelLowering.h 70 MachineBasicBlock *
72 MachineBasicBlock *MBB) const override;
211 MachineBasicBlock *expandSelectCC(MachineInstr &MI, MachineBasicBlock *BB,
211 MachineBasicBlock *expandSelectCC(MachineInstr &MI, MachineBasicBlock *BB,
lib/Target/Sparc/SparcInstrInfo.cpp 153 static void parseCondBranch(MachineInstr *LastInst, MachineBasicBlock *&Target,
159 bool SparcInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
160 MachineBasicBlock *&TBB,
161 MachineBasicBlock *&FBB,
164 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
242 unsigned SparcInstrInfo::insertBranch(MachineBasicBlock &MBB,
243 MachineBasicBlock *TBB,
244 MachineBasicBlock *FBB,
273 unsigned SparcInstrInfo::removeBranch(MachineBasicBlock &MBB,
277 MachineBasicBlock::iterator I = MBB.end();
305 void SparcInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
306 MachineBasicBlock::iterator I,
395 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
395 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
434 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
434 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
479 MachineBasicBlock &FirstMBB = MF->front();
480 MachineBasicBlock::iterator MBBI = FirstMBB.begin();
lib/Target/Sparc/SparcInstrInfo.h 67 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
67 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
68 MachineBasicBlock *&FBB,
72 unsigned removeBranch(MachineBasicBlock &MBB,
75 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
75 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
76 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
83 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
83 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
87 void storeRegToStackSlot(MachineBasicBlock &MBB,
88 MachineBasicBlock::iterator MBBI,
93 void loadRegFromStackSlot(MachineBasicBlock &MBB,
94 MachineBasicBlock::iterator MBBI,
lib/Target/Sparc/SparcRegisterInfo.cpp 111 static void replaceFI(MachineFunction &MF, MachineBasicBlock::iterator II,
164 SparcRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
lib/Target/Sparc/SparcRegisterInfo.h 37 void eliminateFrameIndex(MachineBasicBlock::iterator II,
lib/Target/SystemZ/SystemZAsmPrinter.cpp 580 const MachineBasicBlock &MBB = *MI.getParent();
581 MachineBasicBlock::const_iterator MII(MI);
lib/Target/SystemZ/SystemZElimCompare.cpp 74 bool processBlock(MachineBasicBlock &MBB);
107 static bool isCCLiveOut(MachineBasicBlock &MBB) {
225 MachineBasicBlock::iterator MBBI = Compare, MBBE = Branch;
269 MachineBasicBlock::iterator MBBI = Compare, MBBE = Branch;
386 MachineBasicBlock::iterator MBBI = MI, MBBE = MI.getParent()->end();
395 MachineBasicBlock::iterator MBBI = MI, MBBE = Compare;
430 MachineBasicBlock &MBB = *Compare.getParent();
433 for (MachineBasicBlock::reverse_iterator MBBI =
469 for (MachineBasicBlock::iterator MBBI =
528 MachineBasicBlock::iterator MBBI = Compare, MBBE = Branch;
592 bool SystemZElimCompare::processBlock(MachineBasicBlock &MBB) {
600 MachineBasicBlock::iterator MBBI = MBB.end();
631 for (auto &MBB : F)
lib/Target/SystemZ/SystemZFrameLowering.cpp 117 static void addSavedGPR(MachineBasicBlock &MBB, MachineInstrBuilder &MIB,
131 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
132 MachineBasicBlock::iterator MBBI,
225 restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
226 MachineBasicBlock::iterator MBBI,
313 static void emitIncrement(MachineBasicBlock &MBB,
314 MachineBasicBlock::iterator &MBBI,
342 MachineBasicBlock &MBB) const {
348 MachineBasicBlock::iterator MBBI = MBB.begin();
474 MachineBasicBlock &MBB) const {
475 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
530 MachineBasicBlock::iterator SystemZFrameLowering::
lib/Target/SystemZ/SystemZFrameLowering.h 31 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
32 MachineBasicBlock::iterator MBBI,
35 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
36 MachineBasicBlock::iterator MBBII,
42 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
43 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
46 MachineBasicBlock::iterator
lib/Target/SystemZ/SystemZHazardRecognizer.h 153 MachineBasicBlock::iterator getLastEmittedMI() { return LastEmittedMI; }
lib/Target/SystemZ/SystemZISelLowering.cpp 6474 static MachineBasicBlock *emitBlockAfter(MachineBasicBlock *MBB) {
6474 static MachineBasicBlock *emitBlockAfter(MachineBasicBlock *MBB) {
6476 MachineBasicBlock *NewMBB = MF.CreateMachineBasicBlock(MBB->getBasicBlock());
6483 static MachineBasicBlock *splitBlockAfter(MachineBasicBlock::iterator MI,
6483 static MachineBasicBlock *splitBlockAfter(MachineBasicBlock::iterator MI,
6485 MachineBasicBlock *NewMBB = emitBlockAfter(MBB);
6493 static MachineBasicBlock *splitBlockBefore(MachineBasicBlock::iterator MI,
6493 static MachineBasicBlock *splitBlockBefore(MachineBasicBlock::iterator MI,
6495 MachineBasicBlock *NewMBB = emitBlockAfter(MBB);
6507 MachineBasicBlock *MBB = MI.getParent();
6522 static bool checkCCKill(MachineInstr &MI, MachineBasicBlock *MBB) {
6524 MachineBasicBlock::iterator miI(std::next(MachineBasicBlock::iterator(MI)));
6525 for (MachineBasicBlock::iterator miE = MBB->end(); miI != miE; ++miI) {
6568 MachineBasicBlock *TrueMBB,
6569 MachineBasicBlock *FalseMBB,
6570 MachineBasicBlock *SinkMBB) {
6578 MachineBasicBlock::iterator SinkInsertionPoint = SinkMBB->begin();
6618 MachineBasicBlock *
6620 MachineBasicBlock *MBB) const {
6635 for (MachineBasicBlock::iterator NextMIIt =
6669 MachineBasicBlock *StartMBB = MBB;
6670 MachineBasicBlock *JoinMBB = splitBlockAfter(LastMI, MBB);
6671 MachineBasicBlock *FalseMBB = emitBlockAfter(StartMBB);
6702 MachineBasicBlock::iterator InsertPos = MBB->getFirstNonPHI();
6713 MachineBasicBlock *SystemZTargetLowering::emitCondStore(MachineInstr &MI,
6714 MachineBasicBlock *MBB,
6763 MachineBasicBlock *StartMBB = MBB;
6764 MachineBasicBlock *JoinMBB = splitBlockBefore(MI, MBB);
6765 MachineBasicBlock *FalseMBB = emitBlockAfter(StartMBB);
6805 MachineBasicBlock *SystemZTargetLowering::emitAtomicLoadBinary(
6806 MachineInstr &MI, MachineBasicBlock *MBB, unsigned BinOpcode,
6847 MachineBasicBlock *StartMBB = MBB;
6848 MachineBasicBlock *DoneMBB = splitBlockBefore(MI, MBB);
6849 MachineBasicBlock *LoopMBB = emitBlockAfter(StartMBB);
6924 MachineBasicBlock *SystemZTargetLowering::emitAtomicLoadMinMax(
6925 MachineInstr &MI, MachineBasicBlock *MBB, unsigned CompareOpcode,
6965 MachineBasicBlock *StartMBB = MBB;
6966 MachineBasicBlock *DoneMBB = splitBlockBefore(MI, MBB);
6967 MachineBasicBlock *LoopMBB = emitBlockAfter(StartMBB);
6968 MachineBasicBlock *UseAltMBB = emitBlockAfter(LoopMBB);
6969 MachineBasicBlock *UpdateMBB = emitBlockAfter(UseAltMBB);
7038 MachineBasicBlock *
7040 MachineBasicBlock *MBB) const {
7076 MachineBasicBlock *StartMBB = MBB;
7077 MachineBasicBlock *DoneMBB = splitBlockBefore(MI, MBB);
7078 MachineBasicBlock *LoopMBB = emitBlockAfter(StartMBB);
7079 MachineBasicBlock *SetMBB = emitBlockAfter(LoopMBB);
7163 MachineBasicBlock *
7165 MachineBasicBlock *MBB) const {
7191 MachineBasicBlock *SystemZTargetLowering::emitExt128(MachineInstr &MI,
7192 MachineBasicBlock *MBB,
7222 MachineBasicBlock *SystemZTargetLowering::emitMemMemWrapper(
7223 MachineInstr &MI, MachineBasicBlock *MBB, unsigned Opcode) const {
7238 MachineBasicBlock *EndMBB = (Length > 256 && Opcode == SystemZ::CLC ?
7262 MachineBasicBlock *StartMBB = MBB;
7263 MachineBasicBlock *DoneMBB = splitBlockBefore(MI, MBB);
7264 MachineBasicBlock *LoopMBB = emitBlockAfter(StartMBB);
7265 MachineBasicBlock *NextMBB = (EndMBB ? emitBlockAfter(LoopMBB) : LoopMBB);
7381 MachineBasicBlock *NextMBB = splitBlockBefore(MI, MBB);
7402 MachineBasicBlock *SystemZTargetLowering::emitStringWrapper(
7403 MachineInstr &MI, MachineBasicBlock *MBB, unsigned Opcode) const {
7420 MachineBasicBlock *StartMBB = MBB;
7421 MachineBasicBlock *DoneMBB = splitBlockBefore(MI, MBB);
7422 MachineBasicBlock *LoopMBB = emitBlockAfter(StartMBB);
7461 MachineBasicBlock *SystemZTargetLowering::emitTransactionBegin(
7462 MachineInstr &MI, MachineBasicBlock *MBB, unsigned Opcode,
7509 MachineBasicBlock *SystemZTargetLowering::emitLoadAndTestCmp0(
7510 MachineInstr &MI, MachineBasicBlock *MBB, unsigned Opcode) const {
7532 MachineBasicBlock *SystemZTargetLowering::EmitInstrWithCustomInserter(
7533 MachineInstr &MI, MachineBasicBlock *MBB) const {
lib/Target/SystemZ/SystemZISelLowering.h 476 MachineBasicBlock *
478 MachineBasicBlock *BB) const override;
621 bool convertPrevCompareToBranch(MachineBasicBlock *MBB,
622 MachineBasicBlock::iterator MBBI,
627 MachineBasicBlock *emitSelect(MachineInstr &MI, MachineBasicBlock *BB) const;
627 MachineBasicBlock *emitSelect(MachineInstr &MI, MachineBasicBlock *BB) const;
628 MachineBasicBlock *emitCondStore(MachineInstr &MI, MachineBasicBlock *BB,
628 MachineBasicBlock *emitCondStore(MachineInstr &MI, MachineBasicBlock *BB,
631 MachineBasicBlock *emitPair128(MachineInstr &MI,
632 MachineBasicBlock *MBB) const;
633 MachineBasicBlock *emitExt128(MachineInstr &MI, MachineBasicBlock *MBB,
633 MachineBasicBlock *emitExt128(MachineInstr &MI, MachineBasicBlock *MBB,
635 MachineBasicBlock *emitAtomicLoadBinary(MachineInstr &MI,
636 MachineBasicBlock *BB,
639 MachineBasicBlock *emitAtomicLoadMinMax(MachineInstr &MI,
640 MachineBasicBlock *MBB,
644 MachineBasicBlock *emitAtomicCmpSwapW(MachineInstr &MI,
645 MachineBasicBlock *BB) const;
646 MachineBasicBlock *emitMemMemWrapper(MachineInstr &MI, MachineBasicBlock *BB,
646 MachineBasicBlock *emitMemMemWrapper(MachineInstr &MI, MachineBasicBlock *BB,
648 MachineBasicBlock *emitStringWrapper(MachineInstr &MI, MachineBasicBlock *BB,
648 MachineBasicBlock *emitStringWrapper(MachineInstr &MI, MachineBasicBlock *BB,
650 MachineBasicBlock *emitTransactionBegin(MachineInstr &MI,
651 MachineBasicBlock *MBB,
653 MachineBasicBlock *emitLoadAndTestCmp0(MachineInstr &MI,
654 MachineBasicBlock *MBB,
lib/Target/SystemZ/SystemZInstrInfo.cpp 65 void SystemZInstrInfo::splitMove(MachineBasicBlock::iterator MI,
67 MachineBasicBlock *MBB = MI->getParent();
116 void SystemZInstrInfo::splitAdjDynAlloc(MachineBasicBlock::iterator MI) const {
117 MachineBasicBlock *MBB = MI->getParent();
212 MachineBasicBlock *MBB = MI->getParent();
246 SystemZInstrInfo::emitGRX32Move(MachineBasicBlock &MBB,
247 MachineBasicBlock::iterator MBBI,
353 bool SystemZInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
354 MachineBasicBlock *&TBB,
355 MachineBasicBlock *&FBB,
362 MachineBasicBlock::iterator I = MBB.end();
445 unsigned SystemZInstrInfo::removeBranch(MachineBasicBlock &MBB,
450 MachineBasicBlock::iterator I = MBB.end();
477 unsigned SystemZInstrInfo::insertBranch(MachineBasicBlock &MBB,
478 MachineBasicBlock *TBB,
479 MachineBasicBlock *FBB,
533 bool SystemZInstrInfo::canInsertSelect(const MachineBasicBlock &MBB,
566 void SystemZInstrInfo::insertSelect(MachineBasicBlock &MBB,
567 MachineBasicBlock::iterator I,
683 isProfitableToIfCvt(MachineBasicBlock &MBB,
702 isProfitableToIfCvt(MachineBasicBlock &TMBB,
704 MachineBasicBlock &FMBB,
712 isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
766 void SystemZInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
767 MachineBasicBlock::iterator MBBI,
872 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned SrcReg,
872 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned SrcReg,
887 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned DestReg,
887 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned DestReg,
950 MachineBasicBlock *MBB = MI.getParent();
999 MachineBasicBlock::iterator InsertPt, int FrameIndex,
1212 MachineBasicBlock::iterator InsertPt, MachineInstr &LoadMI,
1732 void SystemZInstrInfo::loadImmediate(MachineBasicBlock &MBB,
1733 MachineBasicBlock::iterator MBBI,
lib/Target/SystemZ/SystemZInstrInfo.h 130 MachineBasicBlock *getMBBTarget() {
163 void splitMove(MachineBasicBlock::iterator MI, unsigned NewOpcode) const;
164 void splitAdjDynAlloc(MachineBasicBlock::iterator MI) const;
178 emitGRX32Move(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
178 emitGRX32Move(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
211 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
211 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
212 MachineBasicBlock *&FBB,
215 unsigned removeBranch(MachineBasicBlock &MBB,
217 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
217 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
218 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
223 bool canInsertSelect(const MachineBasicBlock&, ArrayRef<MachineOperand> Cond,
225 void insertSelect(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
225 void insertSelect(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
232 bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
235 bool isProfitableToIfCvt(MachineBasicBlock &TMBB,
237 MachineBasicBlock &FMBB,
240 bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
244 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
244 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
247 void storeRegToStackSlot(MachineBasicBlock &MBB,
248 MachineBasicBlock::iterator MBBI,
252 void loadRegFromStackSlot(MachineBasicBlock &MBB,
253 MachineBasicBlock::iterator MBBI,
263 MachineBasicBlock::iterator InsertPt, int FrameIndex,
268 MachineBasicBlock::iterator InsertPt, MachineInstr &LoadMI,
321 void loadImmediate(MachineBasicBlock &MBB,
322 MachineBasicBlock::iterator MBBI,
lib/Target/SystemZ/SystemZLDCleanup.cpp 89 MachineBasicBlock *BB = Node->getBlock();
lib/Target/SystemZ/SystemZLongBranch.cpp 280 MachineBasicBlock *MBB = MF->getBlockNumbered(I);
287 MachineBasicBlock::iterator MI = MBB->begin();
288 MachineBasicBlock::iterator End = MBB->end();
356 MachineBasicBlock *MBB = MI->getParent();
375 MachineBasicBlock *MBB = MI->getParent();
lib/Target/SystemZ/SystemZMachineScheduler.cpp 40 static MachineBasicBlock *getSingleSchedPred(MachineBasicBlock *MBB,
40 static MachineBasicBlock *getSingleSchedPred(MachineBasicBlock *MBB,
42 MachineBasicBlock *PredMBB = nullptr;
61 advanceTo(MachineBasicBlock::iterator NextBegin) {
62 MachineBasicBlock::iterator LastEmittedMI = HazardRec->getLastEmittedMI();
63 MachineBasicBlock::iterator I =
78 void SystemZPostRASchedStrategy::enterMBB(MachineBasicBlock *NextMBB) {
94 MachineBasicBlock *SinglePredMBB =
108 for (MachineBasicBlock::iterator I = SinglePredMBB->getFirstTerminator();
146 void SystemZPostRASchedStrategy::initPolicy(MachineBasicBlock::iterator Begin,
lib/Target/SystemZ/SystemZMachineScheduler.h 99 MachineBasicBlock *MBB;
103 typedef std::map<MachineBasicBlock*, SystemZHazardRecognizer*> MBB2HazRec;
112 void advanceTo(MachineBasicBlock::iterator NextBegin);
119 void initPolicy(MachineBasicBlock::iterator Begin,
133 void enterMBB(MachineBasicBlock *NextMBB) override;
lib/Target/SystemZ/SystemZPostRewrite.cpp 50 void selectLOCRMux(MachineBasicBlock &MBB,
51 MachineBasicBlock::iterator MBBI,
55 void selectSELRMux(MachineBasicBlock &MBB,
56 MachineBasicBlock::iterator MBBI,
60 bool expandCondMove(MachineBasicBlock &MBB,
61 MachineBasicBlock::iterator MBBI,
63 bool selectMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
63 bool selectMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
65 bool selectMBB(MachineBasicBlock &MBB);
84 void SystemZPostRewrite::selectLOCRMux(MachineBasicBlock &MBB,
85 MachineBasicBlock::iterator MBBI,
105 void SystemZPostRewrite::selectSELRMux(MachineBasicBlock &MBB,
106 MachineBasicBlock::iterator MBBI,
157 bool SystemZPostRewrite::expandCondMove(MachineBasicBlock &MBB,
158 MachineBasicBlock::iterator MBBI,
177 MachineBasicBlock *RestMBB = MF.CreateMachineBasicBlock(BB);
185 MachineBasicBlock *MoveMBB = MF.CreateMachineBasicBlock(BB);
212 bool SystemZPostRewrite::selectMI(MachineBasicBlock &MBB,
213 MachineBasicBlock::iterator MBBI,
250 bool SystemZPostRewrite::selectMBB(MachineBasicBlock &MBB) {
253 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
255 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
267 for (auto &MBB : MF)
lib/Target/SystemZ/SystemZRegisterInfo.cpp 252 SystemZRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator MI,
257 MachineBasicBlock &MBB = *MI->getParent();
361 MachineBasicBlock *MBB = MI->getParent();
374 MachineBasicBlock::iterator MII = nullptr, MEE = nullptr;
lib/Target/SystemZ/SystemZRegisterInfo.h 82 void eliminateFrameIndex(MachineBasicBlock::iterator MI,
lib/Target/SystemZ/SystemZShortenInst.cpp 35 bool processBlock(MachineBasicBlock &MBB);
197 bool SystemZShortenInst::processBlock(MachineBasicBlock &MBB) {
375 for (auto &MBB : F)
lib/Target/WebAssembly/WebAssemblyArgumentMove.cpp 76 MachineBasicBlock &EntryMBB = MF.front();
77 MachineBasicBlock::iterator InsertPt = EntryMBB.end();
lib/Target/WebAssembly/WebAssemblyCFGSort.cpp 51 virtual MachineBasicBlock *getHeader() const = 0;
52 virtual bool contains(const MachineBasicBlock *MBB) const = 0;
54 using block_iterator = typename ArrayRef<MachineBasicBlock *>::const_iterator;
64 MachineBasicBlock *getHeader() const override { return Region->getHeader(); }
65 bool contains(const MachineBasicBlock *MBB) const override {
91 const Region *getRegionFor(const MachineBasicBlock *MBB) {
143 static void maybeUpdateTerminator(MachineBasicBlock *MBB) {
196 bool operator()(const MachineBasicBlock *A,
197 const MachineBasicBlock *B) const {
210 bool operator()(const MachineBasicBlock *A,
211 const MachineBasicBlock *B) const {
230 std::vector<MachineBasicBlock *> Deferred;
248 for (MachineBasicBlock &MBB : MF) {
252 for (const MachineBasicBlock *Pred : MBB.predecessors())
266 PriorityQueue<MachineBasicBlock *, std::vector<MachineBasicBlock *>,
266 PriorityQueue<MachineBasicBlock *, std::vector<MachineBasicBlock *>,
269 PriorityQueue<MachineBasicBlock *, std::vector<MachineBasicBlock *>,
269 PriorityQueue<MachineBasicBlock *, std::vector<MachineBasicBlock *>,
275 for (MachineBasicBlock *MBB = &MF.front();;) {
294 for (MachineBasicBlock *Succ : MBB->successors()) {
305 MachineBasicBlock *Next = nullptr;
366 for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp 56 SmallVector<MachineBasicBlock *, 8> ScopeTops;
60 void placeBlockMarker(MachineBasicBlock &MBB);
61 void placeLoopMarker(MachineBasicBlock &MBB);
62 void placeTryMarker(MachineBasicBlock &MBB);
73 DenseMap<const MachineInstr *, MachineBasicBlock *> TryToEHPad;
75 DenseMap<const MachineBasicBlock *, MachineInstr *> EHPadToTry;
81 MachineBasicBlock *AppendixBB = nullptr;
82 MachineBasicBlock *getAppendixBlock(MachineFunction &MF) {
96 MachineBasicBlock *EHPad);
121 static bool explicitlyBranchesTo(MachineBasicBlock *Pred,
122 MachineBasicBlock *MBB) {
135 static MachineBasicBlock::iterator
159 static MachineBasicBlock::iterator
186 MachineBasicBlock *EHPad) {
198 MachineBasicBlock *EHPad = TryToEHPad.lookup(Begin);
209 void WebAssemblyCFGStackify::placeBlockMarker(MachineBasicBlock &MBB) {
219 MachineBasicBlock *Header = nullptr;
224 for (MachineBasicBlock *Pred : MBB.predecessors()) {
243 MachineBasicBlock *LayoutPred = MBB.getPrevNode();
248 if (MachineBasicBlock *ScopeTop = ScopeTops[I->getNumber()]) {
271 auto *LoopBottom = BeginToEnd[&MI]->getParent()->getPrevNode();
373 void WebAssemblyCFGStackify::placeLoopMarker(MachineBasicBlock &MBB) {
384 MachineBasicBlock *Bottom = WebAssembly::getBottom(Loop);
390 MachineBasicBlock *AfterLoop = &*Iter;
439 void WebAssemblyCFGStackify::placeTryMarker(MachineBasicBlock &MBB) {
448 MachineBasicBlock *Header = nullptr;
450 for (auto *Pred : MBB.predecessors()) {
464 MachineBasicBlock *Bottom = WebAssembly::getBottom(WE);
471 MachineBasicBlock *Cont = &*Iter;
474 MachineBasicBlock *LayoutPred = Cont->getPrevNode();
479 if (MachineBasicBlock *ScopeTop = ScopeTops[I->getNumber()]) {
502 auto *LoopBottom = BeginToEnd[&MI]->getParent()->getPrevNode();
655 for (auto &MBB : MF) {
659 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
661 MachineBasicBlock *EHPadLayoutPred = MBB.getPrevNode();
662 MachineBasicBlock *Cont = BeginToEnd[EHPadToTry[&MBB]]->getParent();
681 for (auto &MBB : MF) {
687 MachineBasicBlock *TryBB = Try->getParent();
688 MachineBasicBlock *Cont = EndTry->getParent();
710 static void unstackifyVRegsUsedInSplitBB(MachineBasicBlock &MBB,
711 MachineBasicBlock &Split,
859 SmallVector<const MachineBasicBlock *, 8> EHPadStack;
863 DenseMap<MachineBasicBlock *, SmallVector<TryRange, 4>> UnwindDestToTryRanges;
865 DenseMap<MachineBasicBlock *, SmallVector<TryRange, 4>> BrDestToTryRanges;
867 DenseMap<MachineBasicBlock *, unsigned> BrDestToExnReg;
871 for (auto &MBB : reverse(MF)) {
890 MachineBasicBlock *UnwindDest = nullptr;
891 for (auto *Succ : MBB.successors()) {
912 for (auto &MBB : reverse(MF)) {
967 auto *AppendixBB = getAppendixBlock(MF);
1006 MachineBasicBlock *EHPad = P.first;
1032 MachineBasicBlock *Cont = EndTry->getParent();
1033 auto *BrDest = MF.CreateMachineBasicBlock();
1069 MachineBasicBlock *EHPadLayoutPred = &*std::prev(EHPad->getIterator());
1070 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1104 MachineBasicBlock *BrDest = P.first;
1111 auto *MBB = RangeBegin->getParent();
1121 MachineBasicBlock *EHPad = nullptr;
1122 for (auto *Succ : MBB->successors()) {
1136 MachineBasicBlock *NestedEHPad = MF.CreateMachineBasicBlock();
1146 MachineBasicBlock *NestedCont = MF.CreateMachineBasicBlock();
1173 for (auto &MBB : reverse(MF)) {
1194 SmallVector <MachineBasicBlock *, 8> BrDests;
1203 for (auto *Dest : BrDests)
1210 getDepth(const SmallVectorImpl<const MachineBasicBlock *> &Stack,
1211 const MachineBasicBlock *MBB) {
1243 for (MachineBasicBlock &MBB : reverse(MF)) {
1276 for (auto &MBB : MF)
1280 for (auto &MBB : MF) {
1299 SmallVector<const MachineBasicBlock *, 8> Stack;
1300 for (auto &MBB : reverse(MF)) {
lib/Target/WebAssembly/WebAssemblyCallIndirectFixup.cpp 110 for (MachineBasicBlock &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyDebugValueManager.cpp 26 MachineBasicBlock *MBB = Insert->getParent();
38 MachineBasicBlock *MBB = Insert->getParent();
lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp 50 MachineBasicBlock *EHPad = DomNode->getBlock();
60 MachineBasicBlock *MBB = DomNode->getBlock();
102 MachineBasicBlock *EHPad = WE->getEHPad();
103 SmallVector<MachineBasicBlock *, 8> WL;
106 MachineBasicBlock *MBB = WL.pop_back_val();
132 for (auto *Succ : MBB->successors())
142 WebAssemblyExceptionInfo::getOutermostException(MachineBasicBlock *MBB) const {
156 MachineBasicBlock *MBB = getBlocks()[I];
lib/Target/WebAssembly/WebAssemblyExceptionInfo.h 43 MachineBasicBlock *EHPad = nullptr;
47 std::vector<MachineBasicBlock *> Blocks;
48 SmallPtrSet<const MachineBasicBlock *, 8> BlockSet;
51 WebAssemblyException(MachineBasicBlock *EHPad) : EHPad(EHPad) {}
56 MachineBasicBlock *getEHPad() const { return EHPad; }
57 MachineBasicBlock *getHeader() const { return EHPad; }
68 bool contains(const MachineBasicBlock *MBB) const {
72 void addBlock(MachineBasicBlock *MBB) {
76 ArrayRef<MachineBasicBlock *> getBlocks() const { return Blocks; }
77 using block_iterator = typename ArrayRef<MachineBasicBlock *>::const_iterator;
84 std::vector<MachineBasicBlock *> &getBlocksVector() { return Blocks; }
119 DenseMap<const MachineBasicBlock *, WebAssemblyException *> BBMap;
125 WebAssemblyException *getOutermostException(MachineBasicBlock *MBB) const;
147 WebAssemblyException *getExceptionFor(const MachineBasicBlock *MBB) const {
151 void changeExceptionFor(MachineBasicBlock *MBB, WebAssemblyException *WE) {
lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp 204 for (MachineBasicBlock::iterator I = MF.begin()->begin(),
227 for (MachineBasicBlock &MBB : MF) {
228 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E;) {
384 for (const MachineBasicBlock &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyFastISel.cpp 1148 MachineBasicBlock::iterator Iter = FuncInfo.InsertPt;
1272 MachineBasicBlock *MSucc = FuncInfo.MBBMap[Br->getSuccessor(0)];
1277 MachineBasicBlock *TBB = FuncInfo.MBBMap[Br->getSuccessor(0)];
1278 MachineBasicBlock *FBB = FuncInfo.MBBMap[Br->getSuccessor(1)];
lib/Target/WebAssembly/WebAssemblyFixIrreducibleControlFlow.cpp 66 using BlockVector = SmallVector<MachineBasicBlock *, 4>;
67 using BlockSet = SmallPtrSet<MachineBasicBlock *, 4>;
74 ReachabilityGraph(MachineBasicBlock *Entry, const BlockSet &Blocks)
78 for (auto *MBB : Blocks) {
80 for (auto *Pred : MBB->predecessors()) {
89 bool canReach(MachineBasicBlock *From, MachineBasicBlock *To) const {
89 bool canReach(MachineBasicBlock *From, MachineBasicBlock *To) const {
113 MachineBasicBlock *Entry;
117 DenseMap<MachineBasicBlock *, BlockSet> LoopEnterers;
119 bool inRegion(MachineBasicBlock *MBB) const { return Blocks.count(MBB); }
122 DenseMap<MachineBasicBlock *, BlockSet> Reachable;
127 using BlockPair = std::pair<MachineBasicBlock *, MachineBasicBlock *>;
127 using BlockPair = std::pair<MachineBasicBlock *, MachineBasicBlock *>;
131 for (auto *MBB : Blocks) {
132 for (auto *Succ : MBB->successors()) {
141 MachineBasicBlock *MBB, *Succ;
147 for (auto *Pred : MBB->predecessors()) {
156 for (auto *MBB : Blocks) {
165 for (auto *Looper : Loopers) {
166 for (auto *Pred : Looper->predecessors()) {
182 LoopBlocks(MachineBasicBlock *Entry, const BlockSet &Enterers)
190 MachineBasicBlock *Entry;
201 for (auto *Pred : Entry->predecessors()) {
209 auto *MBB = WorkList.pop_back_val();
212 for (auto *Pred : MBB->predecessors()) {
230 bool processRegion(MachineBasicBlock *Entry, BlockSet &Blocks,
242 MachineBasicBlock *Entry, BlockSet &Blocks, MachineFunction &MF) {
252 for (auto *LoopEntry : Graph.getLoopEntries()) {
274 for (auto *OtherLoopEntry : Graph.getLoopEntries()) {
299 for (auto *LoopEntry : Graph.getLoopEntries()) {
350 MachineBasicBlock *Dispatch = MF.CreateMachineBasicBlock();
367 DenseMap<MachineBasicBlock *, unsigned> Indices;
368 for (auto *Entry : SortedEntries) {
384 for (auto *Entry : SortedEntries) {
385 for (auto *Pred : Entry->predecessors()) {
393 DenseSet<MachineBasicBlock *> InLoop;
394 for (auto *Pred : AllPreds) {
395 for (auto *Entry : Pred->successors()) {
407 std::map<std::pair<bool, MachineBasicBlock *>, MachineBasicBlock *>
407 std::map<std::pair<bool, MachineBasicBlock *>, MachineBasicBlock *>
409 for (auto *Pred : AllPreds)
410 for (auto *Entry : Pred->successors())
418 std::map<std::pair<bool, MachineBasicBlock *>, MachineBasicBlock *> Map;
418 std::map<std::pair<bool, MachineBasicBlock *>, MachineBasicBlock *> Map;
419 for (auto *Pred : AllPreds) {
421 for (auto *Entry : Pred->successors()) {
433 MachineBasicBlock *Routing = MF.CreateMachineBasicBlock();
450 for (auto *Pred : AllPreds) {
458 for (auto *Succ : Pred->successors()) {
461 auto *Routing = Map[std::make_pair(PredInLoop, Succ)];
490 for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyFrameLowering.cpp 126 unsigned SrcReg, MachineFunction &MF, MachineBasicBlock &MBB,
127 MachineBasicBlock::iterator &InsertStore, const DebugLoc &DL) const {
137 MachineBasicBlock::iterator
153 MachineBasicBlock &MBB) const {
226 MachineBasicBlock &MBB) const {
lib/Target/WebAssembly/WebAssemblyFrameLowering.h 37 MachineBasicBlock::iterator
42 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
43 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
52 MachineBasicBlock &MBB,
53 MachineBasicBlock::iterator &InsertStore,
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp 331 static MachineBasicBlock *LowerFPToInt(MachineInstr &MI, DebugLoc DL,
332 MachineBasicBlock *BB,
356 MachineBasicBlock *TrueMBB = F->CreateMachineBasicBlock(LLVMBB);
357 MachineBasicBlock *FalseMBB = F->CreateMachineBasicBlock(LLVMBB);
358 MachineBasicBlock *DoneMBB = F->CreateMachineBasicBlock(LLVMBB);
424 MachineBasicBlock *WebAssemblyTargetLowering::EmitInstrWithCustomInserter(
425 MachineInstr &MI, MachineBasicBlock *BB) const {
lib/Target/WebAssembly/WebAssemblyISelLowering.h 50 MachineBasicBlock *
52 MachineBasicBlock *MBB) const override;
lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp 55 void WebAssemblyInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
56 MachineBasicBlock::iterator I,
101 bool WebAssemblyInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
102 MachineBasicBlock *&TBB,
103 MachineBasicBlock *&FBB,
157 unsigned WebAssemblyInstrInfo::removeBranch(MachineBasicBlock &MBB,
161 MachineBasicBlock::instr_iterator I = MBB.instr_end();
180 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
180 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
180 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
lib/Target/WebAssembly/WebAssemblyInstrInfo.h 48 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
48 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
55 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
55 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
56 MachineBasicBlock *&FBB,
59 unsigned removeBranch(MachineBasicBlock &MBB,
61 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
61 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
62 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp 60 static MachineBasicBlock *getMatchingEHPad(MachineInstr *MI) {
62 SmallVector<MachineBasicBlock *, 2> WL;
63 SmallPtrSet<MachineBasicBlock *, 2> Visited;
65 MachineBasicBlock *EHPad = nullptr;
67 MachineBasicBlock *MBB = WL.pop_back_val();
88 SmallVector<MachineBasicBlock *, 8> WL(MBBs.begin(), MBBs.end());
90 MachineBasicBlock *MBB = WL.pop_back_val();
93 SmallVector<MachineBasicBlock *, 4> Succs(MBB->succ_begin(),
96 for (auto *Succ : Succs)
129 for (auto &MBB : MF) {
147 for (auto &MBB : MF) {
156 MachineBasicBlock *TBB = TI->getOperand(0).getMBB();
167 auto *EHPad = getMatchingEHPad(TI);
187 for (auto &MBB : MF) {
199 SmallVector<MachineBasicBlock *, 8> Succs(MBB.succ_begin(),
201 for (auto *Succ : Succs)
241 for (auto &MBB : MF) {
258 SmallSet<MachineBasicBlock *, 8> TerminatePads;
259 for (auto &MBB : MF) {
271 MachineBasicBlock *EHPad = getMatchingEHPad(Extract);
298 auto *ThenMBB = MF.CreateMachineBasicBlock();
299 auto *ElseMBB = MF.CreateMachineBasicBlock();
371 for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyLowerBrUnless.cpp 65 for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp 84 static bool replaceDominatedUses(MachineBasicBlock &MBB, MachineInstr &MI,
149 static bool optimizeCall(MachineBasicBlock &MBB, MachineInstr &MI,
198 for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyPeephole.cpp 74 static bool maybeRewriteToFallthrough(MachineInstr &MI, MachineBasicBlock &MBB,
84 MachineBasicBlock::iterator End = MBB.end();
147 for (auto &MBB : MF)
lib/Target/WebAssembly/WebAssemblyPrepareForLiveIntervals.cpp 82 MachineBasicBlock &Entry = *MF.begin();
lib/Target/WebAssembly/WebAssemblyRegNumbering.cpp 73 MachineBasicBlock &EntryMBB = MF.front();
lib/Target/WebAssembly/WebAssemblyRegStackify.cpp 324 const MachineBasicBlock *MBB = Def->getParent();
373 MachineBasicBlock::const_iterator D(Def), I(Insert);
401 const MachineBasicBlock &MBB,
484 MachineInstr *Def, MachineBasicBlock &MBB,
529 unsigned Reg, MachineOperand &Op, MachineInstr &Def, MachineBasicBlock &MBB,
530 MachineBasicBlock::instr_iterator Insert, LiveIntervals &LIS,
597 unsigned Reg, MachineOperand &Op, MachineInstr *Def, MachineBasicBlock &MBB,
785 for (MachineBasicBlock &MBB : MF) {
904 for (MachineBasicBlock &MBB : MF)
911 for (MachineBasicBlock &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyRegisterInfo.cpp 54 MachineBasicBlock::iterator II, int SPAdj, unsigned FIOperandNum,
59 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/WebAssembly/WebAssemblyRegisterInfo.h 37 void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
lib/Target/WebAssembly/WebAssemblySetP2AlignOperands.cpp 85 for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyUtilities.h 39 template <typename T> MachineBasicBlock *getBottom(const T *Unit) {
40 MachineBasicBlock *Bottom = Unit->getHeader();
41 for (MachineBasicBlock *MBB : Unit->blocks())
lib/Target/X86/X86AsmPrinter.h 132 void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override {
lib/Target/X86/X86AvoidStoreForwardingBlocks.cpp 359 MachineBasicBlock *MBB = LoadInst->getParent();
361 for (MachineBasicBlock::pred_iterator PB = MBB->pred_begin(),
364 MachineBasicBlock *PMBB = *PB;
366 for (MachineBasicBlock::reverse_iterator PBInst = PMBB->rbegin(),
390 MachineBasicBlock *MBB = LoadInst->getParent();
537 for (auto &MBB : MF)
lib/Target/X86/X86AvoidTrailingCall.cpp 69 for (MachineBasicBlock &MBB : MF) {
72 MachineBasicBlock *NextMBB = MBB.getNextNode();
78 MachineBasicBlock::reverse_iterator LastRealInstr;
79 for (MachineBasicBlock &RMBB :
100 MachineBasicBlock::iterator MBBI = std::next(LastRealInstr.getReverse());
lib/Target/X86/X86CallFrameOptimization.cpp 74 MachineBasicBlock::iterator FrameSetup;
101 void collectCallInfo(MachineFunction &MF, MachineBasicBlock &MBB,
102 MachineBasicBlock::iterator I, CallContext &Context);
106 MachineInstr *canFoldIntoRegPush(MachineBasicBlock::iterator FrameSetup,
111 InstClassification classifyInstruction(MachineBasicBlock &MBB,
112 MachineBasicBlock::iterator MI,
168 for (MachineBasicBlock &BB : MF) {
257 for (auto &MBB : MF)
280 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
280 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
354 MachineBasicBlock &MBB,
355 MachineBasicBlock::iterator I,
364 MachineBasicBlock::iterator FrameSetup = I++;
498 MachineBasicBlock::iterator FrameSetup = Context.FrameSetup;
499 MachineBasicBlock &MBB = *(FrameSetup->getParent());
508 MachineBasicBlock::iterator Store = *Context.ArgStoreVector[Idx];
510 MachineBasicBlock::iterator Push = nullptr;
600 MachineBasicBlock::iterator FrameSetup, unsigned Reg) {
629 for (MachineBasicBlock::iterator I = DefMI; I != FrameSetup; ++I)
lib/Target/X86/X86CallLowering.cpp 364 MachineBasicBlock &MBB = MIRBuilder.getMBB();
lib/Target/X86/X86CmovConversion.cpp 129 bool collectCmovCandidates(ArrayRef<MachineBasicBlock *> Blocks,
139 bool checkForProfitableCmovCandidates(ArrayRef<MachineBasicBlock *> Blocks,
181 SmallVector<MachineBasicBlock *, 4> Blocks;
182 for (auto &MBB : MF)
254 ArrayRef<MachineBasicBlock *> Blocks, CmovGroups &CmovInstGroups,
277 for (auto *MBB : Blocks) {
375 ArrayRef<MachineBasicBlock *> Blocks, CmovGroups &CmovInstGroups) {
425 for (auto *MBB : Blocks) {
570 MachineBasicBlock *BB = MI->getParent();
571 MachineBasicBlock::iterator ItrMI = MI;
605 MachineBasicBlock *MBB = First->getParent();
664 MachineBasicBlock *MBB = MI.getParent();
669 MachineBasicBlock *FalseMBB = F->CreateMachineBasicBlock(BB);
670 MachineBasicBlock *SinkMBB = F->CreateMachineBasicBlock(BB);
697 MachineBasicBlock::iterator MIItBegin = MachineBasicBlock::iterator(MI);
698 MachineBasicBlock::iterator MIItEnd =
700 MachineBasicBlock::iterator FalseInsertionPoint = FalseMBB->begin();
701 MachineBasicBlock::iterator SinkInsertionPoint = SinkMBB->begin();
708 for (MachineBasicBlock::iterator MIIt = MIItBegin; MIIt != MIItEnd;) {
812 for (MachineBasicBlock::iterator MIIt = MIItBegin; MIIt != MIItEnd; ++MIIt) {
lib/Target/X86/X86CondBrFolding.cpp 89 MachineBasicBlock *TBB;
90 MachineBasicBlock *FBB;
114 SmallVector<MachineBasicBlock *, 4> RemoveList;
116 void optimizeCondBr(MachineBasicBlock &MBB,
117 SmallVectorImpl<MachineBasicBlock *> &BranchPath);
118 void fixBranchProb(MachineBasicBlock *NextMBB, MachineBasicBlock *RootMBB,
118 void fixBranchProb(MachineBasicBlock *NextMBB, MachineBasicBlock *RootMBB,
119 SmallVectorImpl<MachineBasicBlock *> &BranchPath);
120 void replaceBrDest(MachineBasicBlock *MBB, MachineBasicBlock *OrigDest,
120 void replaceBrDest(MachineBasicBlock *MBB, MachineBasicBlock *OrigDest,
121 MachineBasicBlock *NewDest);
122 void fixupModifiedCond(MachineBasicBlock *MBB);
123 std::unique_ptr<TargetMBBInfo> analyzeMBB(MachineBasicBlock &MBB);
126 bool findPath(MachineBasicBlock *MBB,
127 SmallVectorImpl<MachineBasicBlock *> &BranchPath);
128 TargetMBBInfo *getMBBInfo(MachineBasicBlock *MBB) const {
140 MachineBasicBlock *MBB, SmallVectorImpl<MachineBasicBlock *> &BranchPath) {
140 MachineBasicBlock *MBB, SmallVectorImpl<MachineBasicBlock *> &BranchPath) {
145 MachineBasicBlock *PredMBB = *MBB->pred_begin();
146 MachineBasicBlock *SaveMBB = MBB;
185 static void fixPHIsInSucc(MachineBasicBlock *MBB, MachineBasicBlock *OldMBB,
185 static void fixPHIsInSucc(MachineBasicBlock *MBB, MachineBasicBlock *OldMBB,
186 MachineBasicBlock *NewMBB) {
199 static inline bool setBranchProb(MachineBasicBlock *MBB,
200 MachineBasicBlock *SuccMBB,
210 static inline MachineBasicBlock::iterator
219 void X86CondBrFolding::replaceBrDest(MachineBasicBlock *MBB,
220 MachineBasicBlock *OrigDest,
221 MachineBasicBlock *NewDest) {
232 MachineBasicBlock::iterator UncondBrI = findUncondBrI(MBB);
246 void X86CondBrFolding::fixupModifiedCond(MachineBasicBlock *MBB) {
259 MachineBasicBlock::iterator UncondBrI = findUncondBrI(MBB);
281 MachineBasicBlock &MBB, SmallVectorImpl<MachineBasicBlock *> &BranchPath) {
281 MachineBasicBlock &MBB, SmallVectorImpl<MachineBasicBlock *> &BranchPath) {
286 MachineBasicBlock *TargetMBB = MBBInfo->TBB;
290 MachineBasicBlock *PredMBB = BranchPath.front();
301 MachineBasicBlock *RootMBB = BranchPath.back();
309 MachineBasicBlock::iterator UncondBrI = findUncondBrI(RootMBB);
350 MachineBasicBlock *ThisMBB = I;
393 for (auto &MBB : MF)
396 for (auto &MBB : MF) {
404 SmallVector<MachineBasicBlock *, 4> BranchPath;
413 MachineBasicBlock *PMBB = *I;
481 X86CondBrFolding::analyzeMBB(MachineBasicBlock &MBB) {
482 MachineBasicBlock *TBB;
483 MachineBasicBlock *FBB;
498 MachineBasicBlock::iterator I = MBB.end();
lib/Target/X86/X86DiscriminateMemOps.cpp 108 for (auto &MBB : MF) {
127 for (auto &MBB : MF) {
lib/Target/X86/X86DomainReassignment.cpp 182 MachineBasicBlock *MBB = MI->getParent();
lib/Target/X86/X86EvexToVex.cpp 105 for (MachineBasicBlock &MBB : MF) {
lib/Target/X86/X86ExpandPseudo.cpp 62 void ExpandICallBranchFunnel(MachineBasicBlock *MBB,
63 MachineBasicBlock::iterator MBBI);
65 bool ExpandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI);
65 bool ExpandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI);
66 bool ExpandMBB(MachineBasicBlock &MBB);
76 MachineBasicBlock *MBB, MachineBasicBlock::iterator MBBI) {
76 MachineBasicBlock *MBB, MachineBasicBlock::iterator MBBI) {
77 MachineBasicBlock *JTMBB = MBB;
84 std::vector<std::pair<MachineBasicBlock *, unsigned>> TargetMBBs;
105 auto *NewMBB = MF->CreateMachineBasicBlock(BB);
115 auto *ElseMBB = CreateMBB();
122 auto *ThenMBB = CreateMBB();
154 auto *ThenMBB = CreateMBB();
179 bool X86ExpandPseudo::ExpandMI(MachineBasicBlock &MBB,
180 MachineBasicBlock::iterator MBBI) {
383 bool X86ExpandPseudo::ExpandMBB(MachineBasicBlock &MBB) {
387 MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
389 MachineBasicBlock::iterator NMBBI = std::next(MBBI);
405 for (MachineBasicBlock &MBB : MF)
lib/Target/X86/X86FastISel.cpp 1628 MachineBasicBlock *TrueMBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
1629 MachineBasicBlock *FalseMBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
3969 MachineBasicBlock::iterator I(MI);
lib/Target/X86/X86FixupBWInsts.cpp 77 void processBasicBlock(MachineFunction &MF, MachineBasicBlock &MBB);
104 MachineInstr *tryReplaceInstr(MachineInstr *MI, MachineBasicBlock &MBB) const;
164 for (auto &MBB : MF)
363 MachineBasicBlock &MBB) const {
409 MachineBasicBlock &MBB) {
lib/Target/X86/X86FixupLEAs.cpp 43 void seekLEAFixup(MachineOperand &p, MachineBasicBlock::iterator &I,
50 void processInstruction(MachineBasicBlock::iterator &I,
55 void processInstructionForSlowLEA(MachineBasicBlock::iterator &I,
70 void processInstrForSlow3OpLEA(MachineBasicBlock::iterator &I,
75 bool optTwoAddrLEA(MachineBasicBlock::iterator &I,
81 RegUsageState usesRegister(MachineOperand &p, MachineBasicBlock::iterator I);
86 MachineBasicBlock::iterator searchBackwards(MachineOperand &p,
93 MachineInstr *postRAConvertToLEA(MachineBasicBlock &MBB,
94 MachineBasicBlock::iterator &MBBI) const;
126 FixupLEAPass::postRAConvertToLEA(MachineBasicBlock &MBB,
127 MachineBasicBlock::iterator &MBBI) const {
210 for (MachineBasicBlock &MBB : MF) {
212 for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); ++I) {
228 for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); ++I)
239 FixupLEAPass::usesRegister(MachineOperand &p, MachineBasicBlock::iterator I) {
258 static inline bool getPreviousInstr(MachineBasicBlock::iterator &I,
271 MachineBasicBlock::iterator
275 MachineBasicBlock::iterator CurInst;
352 bool FixupLEAPass::optTwoAddrLEA(MachineBasicBlock::iterator &I,
442 void FixupLEAPass::processInstruction(MachineBasicBlock::iterator &I,
462 MachineBasicBlock::iterator &I,
464 MachineBasicBlock::iterator MBI = searchBackwards(p, I, MBB);
473 MachineBasicBlock::iterator J =
480 void FixupLEAPass::processInstructionForSlowLEA(MachineBasicBlock::iterator &I,
529 void FixupLEAPass::processInstrForSlow3OpLEA(MachineBasicBlock::iterator &I,
lib/Target/X86/X86FixupSetCC.cpp 47 MachineInstr *findFlagsImpDef(MachineBasicBlock *MBB,
48 MachineBasicBlock::reverse_iterator MI);
75 X86FixupSetCCPass::findFlagsImpDef(MachineBasicBlock *MBB,
76 MachineBasicBlock::reverse_iterator MI) {
102 for (auto &MBB : MF) {
lib/Target/X86/X86FlagsCopyLowering.cpp 97 CondRegArray collectCondsInRegs(MachineBasicBlock &MBB,
98 MachineBasicBlock::iterator CopyDefI);
100 unsigned promoteCondToReg(MachineBasicBlock &MBB,
101 MachineBasicBlock::iterator TestPos,
104 getCondOrInverseInReg(MachineBasicBlock &TestMBB,
105 MachineBasicBlock::iterator TestPos, DebugLoc TestLoc,
107 void insertTest(MachineBasicBlock &MBB, MachineBasicBlock::iterator Pos,
107 void insertTest(MachineBasicBlock &MBB, MachineBasicBlock::iterator Pos,
110 void rewriteArithmetic(MachineBasicBlock &TestMBB,
111 MachineBasicBlock::iterator TestPos, DebugLoc TestLoc,
114 void rewriteCMov(MachineBasicBlock &TestMBB,
115 MachineBasicBlock::iterator TestPos, DebugLoc TestLoc,
118 void rewriteCondJmp(MachineBasicBlock &TestMBB,
119 MachineBasicBlock::iterator TestPos, DebugLoc TestLoc,
123 void rewriteSetCarryExtended(MachineBasicBlock &TestMBB,
124 MachineBasicBlock::iterator TestPos,
127 void rewriteSetCC(MachineBasicBlock &TestMBB,
128 MachineBasicBlock::iterator TestPos, DebugLoc TestLoc,
237 static MachineBasicBlock &splitBlock(MachineBasicBlock &MBB,
237 static MachineBasicBlock &splitBlock(MachineBasicBlock &MBB,
258 MachineBasicBlock &UnsplitSucc = *PrevI.getOperand(0).getMBB();
275 MachineBasicBlock &NewMBB = *MF.CreateMachineBasicBlock();
295 for (MachineBasicBlock *Succ : NewMBB.successors())
304 for (MachineBasicBlock *Succ : NewMBB.successors()) {
358 for (MachineBasicBlock *MBB : RPOT)
365 MachineBasicBlock &MBB = *CopyI->getParent();
408 MachineBasicBlock *TestMBB = CopyDefI.getParent();
439 SmallPtrSet<MachineBasicBlock *, 4> Visited;
440 SmallVector<MachineBasicBlock *, 4> Worklist;
445 auto *MBB = Worklist.pop_back_val();
446 for (auto *PredMBB : MBB->predecessors()) {
462 MachineBasicBlock *HoistMBB =
516 SmallVector<MachineBasicBlock *, 2> Blocks;
517 SmallPtrSet<MachineBasicBlock *, 2> VisitedBlocks;
521 MachineBasicBlock &UseMBB = *Blocks.pop_back_val();
644 for (MachineBasicBlock *SuccMBB : UseMBB.successors())
683 MachineBasicBlock *LastJmpMBB = nullptr;
700 for (MachineBasicBlock &MBB : MF)
717 MachineBasicBlock &MBB, MachineBasicBlock::iterator TestPos) {
717 MachineBasicBlock &MBB, MachineBasicBlock::iterator TestPos) {
741 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
741 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
753 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
753 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
766 void X86FlagsCopyLoweringPass::insertTest(MachineBasicBlock &MBB,
767 MachineBasicBlock::iterator Pos,
777 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
777 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
814 MachineBasicBlock &MBB = *MI.getParent();
829 void X86FlagsCopyLoweringPass::rewriteCMov(MachineBasicBlock &TestMBB,
830 MachineBasicBlock::iterator TestPos,
842 MachineBasicBlock &MBB = *CMovI.getParent();
856 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
856 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
865 MachineBasicBlock &JmpMBB = *JmpI.getParent();
887 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
887 MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos,
911 MachineBasicBlock &MBB = *SetBI.getParent();
1010 void X86FlagsCopyLoweringPass::rewriteSetCC(MachineBasicBlock &TestMBB,
1011 MachineBasicBlock::iterator TestPos,
lib/Target/X86/X86FloatingPoint.cpp 125 static unsigned calcLiveInMask(MachineBasicBlock *MBB, bool RemoveFPs) {
127 for (MachineBasicBlock::livein_iterator I = MBB->livein_begin();
146 MachineBasicBlock *MBB; // Current basic block
224 void moveToTop(unsigned RegNo, MachineBasicBlock::iterator I) {
245 MachineBasicBlock::iterator I) {
255 void popStackAfter(MachineBasicBlock::iterator &I);
262 void freeStackSlotAfter(MachineBasicBlock::iterator &I, unsigned Reg);
266 MachineBasicBlock::iterator
270 void adjustLiveRegs(unsigned Mask, MachineBasicBlock::iterator I);
275 MachineBasicBlock::iterator I);
277 bool processBasicBlock(MachineFunction &MF, MachineBasicBlock &MBB);
279 void handleCall(MachineBasicBlock::iterator &I);
280 void handleReturn(MachineBasicBlock::iterator &I);
281 void handleZeroArgFP(MachineBasicBlock::iterator &I);
282 void handleOneArgFP(MachineBasicBlock::iterator &I);
283 void handleOneArgFPRW(MachineBasicBlock::iterator &I);
284 void handleTwoArgFP(MachineBasicBlock::iterator &I);
285 void handleCompareFP(MachineBasicBlock::iterator &I);
286 void handleCondMovFP(MachineBasicBlock::iterator &I);
287 void handleSpecialFP(MachineBasicBlock::iterator &I);
298 void setKillFlags(MachineBasicBlock &MBB) const;
350 df_iterator_default_set<MachineBasicBlock*> Processed;
351 MachineBasicBlock *Entry = &MF.front();
373 for (MachineBasicBlock *BB : depth_first_ext(Entry, Processed))
378 for (MachineBasicBlock &BB : MF)
397 for (MachineBasicBlock &MBB : MF) {
411 bool FPS::processBasicBlock(MachineFunction &MF, MachineBasicBlock &BB) {
417 for (MachineBasicBlock::iterator I = BB.begin(); I != BB.end(); ++I) {
556 MachineBasicBlock::iterator Term = MBB->getFirstTerminator();
833 void FPS::popStackAfter(MachineBasicBlock::iterator &I) {
855 void FPS::freeStackSlotAfter(MachineBasicBlock::iterator &I, unsigned FPRegNo) {
869 MachineBasicBlock::iterator
885 void FPS::adjustLiveRegs(unsigned Mask, MachineBasicBlock::iterator I) {
913 MachineBasicBlock::iterator I2 = std::prev(I);
951 MachineBasicBlock::iterator I) {
973 void FPS::handleCall(MachineBasicBlock::iterator &I) {
1010 void FPS::handleReturn(MachineBasicBlock::iterator &I) {
1097 void FPS::handleZeroArgFP(MachineBasicBlock::iterator &I) {
1113 void FPS::handleOneArgFP(MachineBasicBlock::iterator &I) {
1173 void FPS::handleOneArgFPRW(MachineBasicBlock::iterator &I) {
1282 void FPS::handleTwoArgFP(MachineBasicBlock::iterator &I) {
1380 void FPS::handleCompareFP(MachineBasicBlock::iterator &I) {
1408 void FPS::handleCondMovFP(MachineBasicBlock::iterator &I) {
1437 void FPS::handleSpecialFP(MachineBasicBlock::iterator &Inst) {
1682 void FPS::setKillFlags(MachineBasicBlock &MBB) const {
1689 for (MachineBasicBlock::reverse_iterator I = MBB.rbegin(), E = MBB.rend();
lib/Target/X86/X86FrameLowering.cpp 145 static unsigned findDeadCallerSavedReg(MachineBasicBlock &MBB,
146 MachineBasicBlock::iterator &MBBI,
196 static bool isEAXLiveIn(MachineBasicBlock &MBB) {
197 for (MachineBasicBlock::RegisterMaskPair RegMask : MBB.liveins()) {
213 flagsNeedToBePreservedBeforeTheTerminators(const MachineBasicBlock &MBB) {
240 for (const MachineBasicBlock *Succ : MBB.successors())
249 void X86FrameLowering::emitSPUpdate(MachineBasicBlock &MBB,
250 MachineBasicBlock::iterator &MBBI,
347 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
347 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
394 int X86FrameLowering::mergeSPUpdates(MachineBasicBlock &MBB,
395 MachineBasicBlock::iterator &MBBI,
401 MachineBasicBlock::iterator PI = doMergeWithPrevious ? std::prev(MBBI) : MBBI;
450 void X86FrameLowering::BuildCFI(MachineBasicBlock &MBB,
451 MachineBasicBlock::iterator MBBI,
461 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
461 MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
485 MachineBasicBlock &MBB,
486 MachineBasicBlock::iterator MBBI,
501 MachineBasicBlock &PrologMBB) const {
516 MachineBasicBlock::iterator MBBI = std::next(ChkStkStub->getIterator());
526 MachineBasicBlock &MBB,
527 MachineBasicBlock::iterator MBBI,
564 MachineBasicBlock *RoundMBB = MF.CreateMachineBasicBlock(LLVM_BB);
565 MachineBasicBlock *LoopMBB = MF.CreateMachineBasicBlock(LLVM_BB);
566 MachineBasicBlock *ContinueMBB = MF.CreateMachineBasicBlock(LLVM_BB);
574 MachineBasicBlock::iterator BeforeMBBI = std::prev(MBBI);
715 MachineBasicBlock::iterator ContinueMBBI = ContinueMBB->getFirstNonPHI();
754 for (MachineBasicBlock::iterator CMBBI = ContinueMBB->begin();
762 MachineBasicBlock &MBB,
763 MachineBasicBlock::iterator MBBI,
782 MachineBasicBlock::iterator ExpansionMBBI = std::prev(MBBI);
825 MachineFunction &MF, MachineBasicBlock &MBB,
826 MachineBasicBlock::iterator MBBI, const DebugLoc &DL, bool InProlog) const {
860 void X86FrameLowering::BuildStackAlignAND(MachineBasicBlock &MBB,
861 MachineBasicBlock::iterator MBBI,
972 MachineBasicBlock &MBB) const {
975 MachineBasicBlock::iterator MBBI = MBB.begin();
1591 MachineBasicBlock &MBB) const {
1594 MachineBasicBlock::iterator Terminator = MBB.getFirstTerminator();
1595 MachineBasicBlock::iterator MBBI = Terminator;
1653 MachineBasicBlock::iterator FirstCSPop = MBBI;
1656 MachineBasicBlock::iterator PI = std::prev(MBBI);
1737 MachineBasicBlock::iterator PI = MBBI;
2065 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
2065 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
2136 void X86FrameLowering::emitCatchRetReturnValue(MachineBasicBlock &MBB,
2137 MachineBasicBlock::iterator MBBI,
2144 MachineBasicBlock *CatchRetTarget = CatchRet->getOperand(0).getMBB();
2166 bool X86FrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
2167 MachineBasicBlock::iterator MI,
2289 MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
2327 MachineBasicBlock *allocMBB = MF.CreateMachineBasicBlock();
2328 MachineBasicBlock *checkMBB = MF.CreateMachineBasicBlock();
2556 static bool blockEndIsUnreachable(const MachineBasicBlock &MBB,
2557 MachineBasicBlock::const_iterator MBBI) {
2582 MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
2618 for (auto &MBB : MF) {
2657 MachineBasicBlock *stackCheckMBB = MF.CreateMachineBasicBlock();
2658 MachineBasicBlock *incStackMBB = MF.CreateMachineBasicBlock();
2716 bool X86FrameLowering::adjustStackWithPops(MachineBasicBlock &MBB,
2717 MachineBasicBlock::iterator MBBI,
2736 MachineBasicBlock::iterator Prev = std::prev(MBBI);
2792 MachineBasicBlock::iterator X86FrameLowering::
2895 MachineBasicBlock::iterator CI = I;
2896 MachineBasicBlock::iterator B = MBB.begin();
2905 bool X86FrameLowering::canUseAsPrologue(const MachineBasicBlock &MBB) const {
2911 bool X86FrameLowering::canUseAsEpilogue(const MachineBasicBlock &MBB) const {
2944 MachineBasicBlock::iterator X86FrameLowering::restoreWin32EHStackPointers(
3216 MachineBasicBlock &MBB = MF.front();
lib/Target/X86/X86FrameLowering.h 53 void emitStackProbe(MachineFunction &MF, MachineBasicBlock &MBB,
54 MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
59 MachineBasicBlock &PrologMBB) const override;
61 void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
62 MachineBasicBlock::iterator MBBI,
67 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
68 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
71 MachineBasicBlock &PrologueMBB) const override;
74 MachineBasicBlock &PrologueMBB) const override;
84 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
85 MachineBasicBlock::iterator MI,
89 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
90 MachineBasicBlock::iterator MI,
110 MachineBasicBlock::iterator
123 int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
123 int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
128 void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
128 void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
142 bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
149 bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
162 void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
162 void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
167 MachineBasicBlock::iterator
184 void emitStackProbeCall(MachineFunction &MF, MachineBasicBlock &MBB,
185 MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
189 void emitStackProbeInline(MachineFunction &MF, MachineBasicBlock &MBB,
190 MachineBasicBlock::iterator MBBI,
194 void emitStackProbeInlineStub(MachineFunction &MF, MachineBasicBlock &MBB,
195 MachineBasicBlock::iterator MBBI,
199 void BuildStackAlignAND(MachineBasicBlock &MBB,
200 MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
204 bool adjustStackWithPops(MachineBasicBlock &MBB,
205 MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
209 MachineInstrBuilder BuildStackAdjustment(MachineBasicBlock &MBB,
210 MachineBasicBlock::iterator MBBI,
219 void emitCatchRetReturnValue(MachineBasicBlock &MBB,
220 MachineBasicBlock::iterator MBBI,
lib/Target/X86/X86ISelLowering.cpp 2220 const MachineBasicBlock *MBB,
29175 static MachineBasicBlock *emitXBegin(MachineInstr &MI, MachineBasicBlock *MBB,
29175 static MachineBasicBlock *emitXBegin(MachineInstr &MI, MachineBasicBlock *MBB,
29197 MachineBasicBlock *thisMBB = MBB;
29199 MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
29200 MachineBasicBlock *fallMBB = MF->CreateMachineBasicBlock(BB);
29201 MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
29252 MachineBasicBlock *
29254 MachineBasicBlock *MBB) const {
29319 MachineBasicBlock *thisMBB = MBB;
29320 MachineBasicBlock *overflowMBB;
29321 MachineBasicBlock *offsetMBB;
29322 MachineBasicBlock *endMBB;
29512 MachineBasicBlock *X86TargetLowering::EmitVAStartSaveXMMRegsWithCustomInserter(
29513 MachineInstr &MI, MachineBasicBlock *MBB) const {
29528 MachineBasicBlock *XMMSaveMBB = F->CreateMachineBasicBlock(LLVM_BB);
29529 MachineBasicBlock *EndMBB = F->CreateMachineBasicBlock(LLVM_BB);
29592 static bool checkAndUpdateEFLAGSKill(MachineBasicBlock::iterator SelectItr,
29596 MachineBasicBlock::iterator miI(std::next(SelectItr));
29597 for (MachineBasicBlock::iterator miE = BB->end(); miI != miE; ++miI) {
29608 for (MachineBasicBlock::succ_iterator sItr = BB->succ_begin(),
29611 MachineBasicBlock* succ = *sItr;
29662 MachineBasicBlock::iterator MIItBegin, MachineBasicBlock::iterator MIItEnd,
29672 MachineBasicBlock::iterator SinkInsertionPoint = SinkMBB->begin();
29683 for (MachineBasicBlock::iterator MIIt = MIItBegin; MIIt != MIItEnd; ++MIIt) {
29714 MachineBasicBlock *
29717 MachineBasicBlock *ThisMBB) const {
29794 MachineBasicBlock *FirstInsertedMBB = F->CreateMachineBasicBlock(LLVM_BB);
29795 MachineBasicBlock *SecondInsertedMBB = F->CreateMachineBasicBlock(LLVM_BB);
29796 MachineBasicBlock *SinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
29870 MachineBasicBlock *
29872 MachineBasicBlock *ThisMBB) const {
29926 MachineBasicBlock::iterator NextMIIt = MachineBasicBlock::iterator(MI);
29956 MachineBasicBlock *FalseMBB = F->CreateMachineBasicBlock(LLVM_BB);
29957 MachineBasicBlock *SinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
30001 MachineBasicBlock::iterator MIItBegin = MachineBasicBlock::iterator(MI);
30002 MachineBasicBlock::iterator MIItEnd =
30012 MachineBasicBlock *
30014 MachineBasicBlock *BB) const {
30044 MachineBasicBlock *mallocMBB = MF->CreateMachineBasicBlock(LLVM_BB);
30045 MachineBasicBlock *bumpMBB = MF->CreateMachineBasicBlock(LLVM_BB);
30046 MachineBasicBlock *continueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
30146 MachineBasicBlock *
30148 MachineBasicBlock *BB) const {
30151 MachineBasicBlock *TargetMBB = MI.getOperand(0).getMBB();
30164 MachineBasicBlock *RestoreMBB =
30178 MachineBasicBlock *
30180 MachineBasicBlock *BB) const {
30194 MachineBasicBlock *
30196 MachineBasicBlock *BB) const {
30223 MachineBasicBlock *
30225 MachineBasicBlock *BB) const {
30357 MachineBasicBlock *
30359 MachineBasicBlock *BB) const {
30423 MachineBasicBlock *MBB) const {
30464 MachineBasicBlock *
30466 MachineBasicBlock *MBB) const {
30514 MachineBasicBlock *thisMBB = MBB;
30515 MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
30516 MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
30517 MachineBasicBlock *restoreMBB = MF->CreateMachineBasicBlock(BB);
30624 MachineBasicBlock *
30626 MachineBasicBlock *MBB) const {
30666 MachineBasicBlock *checkSspMBB = MF->CreateMachineBasicBlock(BB);
30667 MachineBasicBlock *fallMBB = MF->CreateMachineBasicBlock(BB);
30668 MachineBasicBlock *fixShadowMBB = MF->CreateMachineBasicBlock(BB);
30669 MachineBasicBlock *fixShadowLoopPrepareMBB = MF->CreateMachineBasicBlock(BB);
30670 MachineBasicBlock *fixShadowLoopMBB = MF->CreateMachineBasicBlock(BB);
30671 MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
30800 MachineBasicBlock *
30802 MachineBasicBlock *MBB) const {
30832 MachineBasicBlock *thisMBB = MBB;
30884 MachineBasicBlock *MBB,
30885 MachineBasicBlock *DispatchBB,
30933 MachineBasicBlock *
30935 MachineBasicBlock *BB) const {
30944 DenseMap<unsigned, SmallVector<MachineBasicBlock *, 2>> CallSiteNumToLPad;
30946 for (auto &MBB : *MF) {
30970 std::vector<MachineBasicBlock *> LPadList;
30971 SmallPtrSet<MachineBasicBlock *, 32> InvokeBBs;
30987 MachineBasicBlock *DispatchBB = MF->CreateMachineBasicBlock();
30990 MachineBasicBlock *TrapBB = MF->CreateMachineBasicBlock();
30994 MachineBasicBlock *DispContBB = MF->CreateMachineBasicBlock();
31103 SmallPtrSet<MachineBasicBlock *, 8> SeenMBBs;
31109 SmallVector<MachineBasicBlock *, 64> MBBLPads;
31111 for (MachineBasicBlock *MBB : InvokeBBs) {
31115 SmallVector<MachineBasicBlock *, 8> Successors(MBB->succ_rbegin(),
31161 MachineBasicBlock *
31163 MachineBasicBlock *BB) const {
31390 MachineBasicBlock::reverse_iterator RMBBI(MI.getReverseIterator());
31397 MachineBasicBlock::iterator MBBI(RMBBI);
46164 void X86TargetLowering::initializeSplitCSR(MachineBasicBlock *Entry) const {
46175 MachineBasicBlock *Entry,
46176 const SmallVectorImpl<MachineBasicBlock *> &Exits) const {
46184 MachineBasicBlock::iterator MBBI = Entry->begin();
46206 for (auto *Exit : Exits)
lib/Target/X86/X86ISelLowering.h 714 const MachineBasicBlock *MBB, unsigned uid,
816 MachineBasicBlock *
818 MachineBasicBlock *MBB) const override;
1388 void initializeSplitCSR(MachineBasicBlock *Entry) const override;
1390 MachineBasicBlock *Entry,
1391 const SmallVectorImpl<MachineBasicBlock *> &Exits) const override;
1421 void SetupEntryBlockForSjLj(MachineInstr &MI, MachineBasicBlock *MBB,
1422 MachineBasicBlock *DispatchBB, int FI) const;
1425 MachineBasicBlock *
1427 MachineBasicBlock *MBB) const;
1430 MachineBasicBlock *
1432 MachineBasicBlock *BB) const;
1434 MachineBasicBlock *EmitLoweredCascadedSelect(MachineInstr &MI1,
1436 MachineBasicBlock *BB) const;
1438 MachineBasicBlock *EmitLoweredSelect(MachineInstr &I,
1439 MachineBasicBlock *BB) const;
1441 MachineBasicBlock *EmitLoweredAtomicFP(MachineInstr &I,
1442 MachineBasicBlock *BB) const;
1444 MachineBasicBlock *EmitLoweredCatchRet(MachineInstr &MI,
1445 MachineBasicBlock *BB) const;
1447 MachineBasicBlock *EmitLoweredCatchPad(MachineInstr &MI,
1448 MachineBasicBlock *BB) const;
1450 MachineBasicBlock *EmitLoweredSegAlloca(MachineInstr &MI,
1451 MachineBasicBlock *BB) const;
1453 MachineBasicBlock *EmitLoweredTLSAddr(MachineInstr &MI,
1454 MachineBasicBlock *BB) const;
1456 MachineBasicBlock *EmitLoweredTLSCall(MachineInstr &MI,
1457 MachineBasicBlock *BB) const;
1459 MachineBasicBlock *EmitLoweredRetpoline(MachineInstr &MI,
1460 MachineBasicBlock *BB) const;
1462 MachineBasicBlock *emitEHSjLjSetJmp(MachineInstr &MI,
1463 MachineBasicBlock *MBB) const;
1466 MachineBasicBlock *MBB) const;
1468 MachineBasicBlock *emitEHSjLjLongJmp(MachineInstr &MI,
1469 MachineBasicBlock *MBB) const;
1471 MachineBasicBlock *emitLongJmpShadowStackFix(MachineInstr &MI,
1472 MachineBasicBlock *MBB) const;
1474 MachineBasicBlock *emitFMA3Instr(MachineInstr &MI,
1475 MachineBasicBlock *MBB) const;
1477 MachineBasicBlock *EmitSjLjDispatchBlock(MachineInstr &MI,
1478 MachineBasicBlock *MBB) const;
lib/Target/X86/X86IndirectBranchTracking.cpp 60 bool addENDBR(MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const;
60 bool addENDBR(MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const;
72 MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const {
72 MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const {
124 for (auto &MBB : MF) {
130 for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); ++I) {
lib/Target/X86/X86InsertPrefetch.cpp 190 for (auto &MBB : MF) {
lib/Target/X86/X86InstrInfo.cpp 155 const MachineBasicBlock *MBB = MI.getParent();
640 void X86InstrInfo::reMaterialize(MachineBasicBlock &MBB,
641 MachineBasicBlock::iterator I,
790 MachineBasicBlock::iterator MBBI = MI.getIterator();
2438 MachineBasicBlock &MBB, SmallVectorImpl<MachineOperand> &BranchCond,
2442 MachineBasicBlock::iterator I = MBB.end();
2484 static MachineBasicBlock *getFallThroughMBB(MachineBasicBlock *MBB,
2484 static MachineBasicBlock *getFallThroughMBB(MachineBasicBlock *MBB,
2485 MachineBasicBlock *TBB) {
2490 MachineBasicBlock *FallthroughBB = nullptr;
2503 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
2503 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
2503 MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB,
2509 MachineBasicBlock::iterator I = MBB.end();
2510 MachineBasicBlock::iterator UnCondBrIter = MBB.end();
2568 MachineBasicBlock *TargetBB = I->getOperand(0).getMBB();
2589 MachineBasicBlock::iterator OldInst = I;
2668 bool X86InstrInfo::analyzeBranch(MachineBasicBlock &MBB,
2669 MachineBasicBlock *&TBB,
2670 MachineBasicBlock *&FBB,
2677 bool X86InstrInfo::analyzeBranchPredicate(MachineBasicBlock &MBB,
2715 for (auto *Succ : MBB.successors())
2746 unsigned X86InstrInfo::removeBranch(MachineBasicBlock &MBB,
2750 MachineBasicBlock::iterator I = MBB.end();
2769 unsigned X86InstrInfo::insertBranch(MachineBasicBlock &MBB,
2770 MachineBasicBlock *TBB,
2771 MachineBasicBlock *FBB,
2829 canInsertSelect(const MachineBasicBlock &MBB,
2865 void X86InstrInfo::insertSelect(MachineBasicBlock &MBB,
2866 MachineBasicBlock::iterator I,
2964 void X86InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
2965 MachineBasicBlock::iterator MI,
3244 void X86InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
3245 MachineBasicBlock::iterator MI,
3261 void X86InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
3262 MachineBasicBlock::iterator MI,
3610 MachineBasicBlock::iterator I = CmpInstr, Def = MI;
3627 for (MachineBasicBlock::iterator J = MI;; ++J) {
3656 MachineBasicBlock::reverse_iterator
3703 MachineBasicBlock::iterator E = CmpInstr.getParent()->end();
3786 MachineBasicBlock *MBB = CmpInstr.getParent();
3787 for (MachineBasicBlock *Successor : MBB->successors())
3798 MachineBasicBlock::reverse_iterator InsertI = Def.getReverse(),
3908 MachineBasicBlock &MBB = *MIB->getParent();
3927 MachineBasicBlock &MBB = *MIB->getParent();
3931 MachineBasicBlock::iterator I = MIB.getInstr();
3984 MachineBasicBlock &MBB = *MIB->getParent();
3994 MachineBasicBlock::iterator I = MIB.getInstr();
4005 MachineBasicBlock &MBB = *MIB->getParent();
4660 MachineBasicBlock::iterator InsertPt,
4683 MachineBasicBlock *MBB = InsertPt->getParent();
4691 MachineBasicBlock::iterator InsertPt,
4711 MachineBasicBlock *MBB = InsertPt->getParent();
4719 MachineBasicBlock::iterator InsertPt,
4729 ArrayRef<MachineOperand> MOs, MachineBasicBlock::iterator InsertPt,
4824 ArrayRef<MachineOperand> MOs, MachineBasicBlock::iterator InsertPt,
5002 MachineBasicBlock::iterator InsertPt,
5193 MachineBasicBlock::iterator InsertPt, MachineInstr &LoadMI,
7235 const MachineBasicBlock *MBB) const {
7760 MachineBasicBlock &FirstMBB = MF.front();
7761 MachineBasicBlock::iterator MBBI = FirstMBB.begin();
7867 MachineBasicBlock *BB = Node->getBlock();
7871 for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;
8045 X86InstrInfo::getOutliningType(MachineBasicBlock::iterator &MIT, unsigned Flags) const {
8104 void X86InstrInfo::buildOutlinedFrame(MachineBasicBlock &MBB,
8118 MachineBasicBlock::iterator
lib/Target/X86/X86InstrInfo.h 138 bool AnalyzeBranchImpl(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
138 bool AnalyzeBranchImpl(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
139 MachineBasicBlock *&FBB,
210 void reMaterialize(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
210 void reMaterialize(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
285 void replaceBranchWithTailCall(MachineBasicBlock &MBB,
289 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
289 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
290 MachineBasicBlock *&FBB,
298 bool analyzeBranchPredicate(MachineBasicBlock &MBB,
302 unsigned removeBranch(MachineBasicBlock &MBB,
304 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
304 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
305 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
308 bool canInsertSelect(const MachineBasicBlock &, ArrayRef<MachineOperand> Cond,
310 void insertSelect(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
310 void insertSelect(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
314 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
314 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
317 void storeRegToStackSlot(MachineBasicBlock &MBB,
318 MachineBasicBlock::iterator MI, unsigned SrcReg,
323 void loadRegFromStackSlot(MachineBasicBlock &MBB,
324 MachineBasicBlock::iterator MI, unsigned DestReg,
343 MachineBasicBlock::iterator InsertPt, int FrameIndex,
352 MachineBasicBlock::iterator InsertPt, MachineInstr &LoadMI,
409 bool isSafeToClobberEFLAGS(MachineBasicBlock &MBB,
410 MachineBasicBlock::iterator I) const {
412 MachineBasicBlock::LQR_Dead;
445 MachineBasicBlock::iterator InsertPt,
462 const MachineBasicBlock *MBB) const override;
508 getOutliningType(MachineBasicBlock::iterator &MIT, unsigned Flags) const override;
510 void buildOutlinedFrame(MachineBasicBlock &MBB, MachineFunction &MF,
513 MachineBasicBlock::iterator
565 MachineBasicBlock::iterator InsertPt,
lib/Target/X86/X86InstructionSelector.cpp 311 MachineBasicBlock &MBB = *I.getParent();
1408 MachineBasicBlock *DestMBB = I.getOperand(1).getMBB();
lib/Target/X86/X86MCInstLower.cpp 1591 static MachineBasicBlock::const_iterator
1593 const MachineBasicBlock *MBB = MBBI->getParent();
2089 MachineBasicBlock::const_iterator MBBI(MI);
lib/Target/X86/X86OptimizeLEAs.cpp 281 void findLEAs(const MachineBasicBlock &MBB, MemOpMap &LEAs);
471 void X86OptimizeLEAPass::findLEAs(const MachineBasicBlock &MBB,
494 MachineBasicBlock *MBB = (*LEAs.begin()->second.begin())->getParent();
577 MachineBasicBlock *MBB = MI.getParent();
686 for (auto &MBB : MF) {
lib/Target/X86/X86PadShortFunction.cpp 65 void findReturns(MachineBasicBlock *MBB,
68 bool cyclesUntilReturn(MachineBasicBlock *MBB,
71 void addPadding(MachineBasicBlock *MBB,
72 MachineBasicBlock::iterator &MBBI,
79 DenseMap<MachineBasicBlock*, unsigned int> ReturnBBs;
82 DenseMap<MachineBasicBlock*, VisitedBBInfo> VisitedBBs;
116 for (DenseMap<MachineBasicBlock*, unsigned int>::iterator I = ReturnBBs.begin();
118 MachineBasicBlock *MBB = I->first;
126 MachineBasicBlock::iterator ReturnLoc = --MBB->end();
144 void PadShortFunc::findReturns(MachineBasicBlock *MBB, unsigned int Cycles) {
156 for (MachineBasicBlock::succ_iterator I = MBB->succ_begin();
168 bool PadShortFunc::cyclesUntilReturn(MachineBasicBlock *MBB,
171 DenseMap<MachineBasicBlock*, VisitedBBInfo>::iterator it
201 void PadShortFunc::addPadding(MachineBasicBlock *MBB,
202 MachineBasicBlock::iterator &MBBI,
lib/Target/X86/X86RegisterInfo.cpp 678 static bool tryOptimizeLEAtoMOV(MachineBasicBlock::iterator II) {
715 X86RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
719 MachineBasicBlock &MBB = *MI.getParent();
721 MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
lib/Target/X86/X86RegisterInfo.h 131 void eliminateFrameIndex(MachineBasicBlock::iterator MI,
lib/Target/X86/X86RetpolineThunks.cpp 75 void insertRegReturnAddrClobber(MachineBasicBlock &MBB, unsigned Reg);
223 MachineBasicBlock *EntryMBB = MF.CreateMachineBasicBlock(Entry);
229 void X86RetpolineThunks::insertRegReturnAddrClobber(MachineBasicBlock &MBB,
244 MachineBasicBlock *Entry = &MF.front();
249 MachineBasicBlock *CaptureSpec = MF.CreateMachineBasicBlock(Entry->getBasicBlock());
250 MachineBasicBlock *CallTarget = MF.CreateMachineBasicBlock(Entry->getBasicBlock());
lib/Target/X86/X86SpeculativeLoadHardening.cpp 140 MachineBasicBlock *MBB;
182 unsigned saveEFLAGS(MachineBasicBlock &MBB,
183 MachineBasicBlock::iterator InsertPt, DebugLoc Loc);
184 void restoreEFLAGS(MachineBasicBlock &MBB,
185 MachineBasicBlock::iterator InsertPt, DebugLoc Loc,
188 void mergePredStateIntoSP(MachineBasicBlock &MBB,
189 MachineBasicBlock::iterator InsertPt, DebugLoc Loc,
191 unsigned extractPredStateFromSP(MachineBasicBlock &MBB,
192 MachineBasicBlock::iterator InsertPt,
203 unsigned hardenValueInRegister(unsigned Reg, MachineBasicBlock &MBB,
204 MachineBasicBlock::iterator InsertPt,
223 static MachineBasicBlock &splitEdge(MachineBasicBlock &MBB,
223 static MachineBasicBlock &splitEdge(MachineBasicBlock &MBB,
224 MachineBasicBlock &Succ, int SuccCount,
231 MachineBasicBlock &NewMBB = *MF.CreateMachineBasicBlock();
248 MachineBasicBlock &OldLayoutSucc =
328 SmallPtrSet<MachineBasicBlock *, 4> Preds;
330 for (auto &MBB : MF)
372 for (MachineBasicBlock &MBB : MF) {
429 MachineBasicBlock &Entry = *MF.begin();
517 for (MachineBasicBlock &MBB : MF) {
569 SmallSetVector<MachineBasicBlock *, 8> Blocks;
570 for (MachineBasicBlock &MBB : MF) {
584 for (MachineBasicBlock *SuccMBB : MBB.successors())
589 for (MachineBasicBlock *MBB : Blocks) {
603 for (MachineBasicBlock &MBB : MF) {
699 MachineBasicBlock &MBB = *Info.MBB;
709 MachineBasicBlock *UncondSucc =
716 SmallDenseMap<MachineBasicBlock *, int> SuccCounts;
730 auto &CheckingMBB =
786 MachineBasicBlock &Succ = *CondBr->getOperand(0).getMBB();
851 for (MachineBasicBlock &MBB : MF)
966 SmallPtrSet<MachineBasicBlock *, 4> IndirectTerminatedMBBs;
971 SmallPtrSet<MachineBasicBlock *, 4> IndirectTargetMBBs;
975 for (MachineBasicBlock &MBB : MF) {
1042 for (MachineBasicBlock *Succ : MBB.successors())
1056 for (MachineBasicBlock &MBB : MF) {
1077 for (MachineBasicBlock *Pred : MBB.predecessors()) {
1588 static bool isEFLAGSLive(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
1588 static bool isEFLAGSLive(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
1653 for (MachineBasicBlock &MBB : MF) {
1877 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt,
1877 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt,
1895 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt, DebugLoc Loc,
1895 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt, DebugLoc Loc,
1906 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt, DebugLoc Loc,
1906 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt, DebugLoc Loc,
1926 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt,
1926 MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt,
1949 MachineBasicBlock &MBB = *MI.getParent();
2281 unsigned Reg, MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt,
2281 unsigned Reg, MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertPt,
2331 MachineBasicBlock &MBB = *MI.getParent();
2382 MachineBasicBlock &MBB = *MI.getParent();
2429 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/X86/X86VZeroUpper.cpp 60 void processBasicBlock(MachineBasicBlock &MBB);
61 void insertVZeroUpper(MachineBasicBlock::iterator I,
63 void addDirtySuccessor(MachineBasicBlock &MBB);
90 MachineBasicBlock::iterator FirstUnguardedCall;
96 using DirtySuccessorsWorkList = SmallVector<MachineBasicBlock *, 8>;
178 void VZeroUpperInserter::insertVZeroUpper(MachineBasicBlock::iterator I,
187 void VZeroUpperInserter::addDirtySuccessor(MachineBasicBlock &MBB) {
196 void VZeroUpperInserter::processBasicBlock(MachineBasicBlock &MBB) {
270 for (MachineBasicBlock::succ_iterator SI = MBB.succ_begin(),
316 for (MachineBasicBlock &MBB : MF)
328 MachineBasicBlock &MBB = *DirtySuccessors.back();
343 for (MachineBasicBlock *Succ : MBB.successors())
lib/Target/X86/X86WinAllocaExpander.cpp 137 DenseMap<MachineBasicBlock *, int64_t> OutOffset;
138 for (MachineBasicBlock &MBB : MF)
148 for (MachineBasicBlock *MBB : RPO) {
150 for (MachineBasicBlock *Pred : MBB->predecessors())
199 MachineBasicBlock *MBB = MI->getParent();
200 MachineBasicBlock::iterator I = *MI;
lib/Target/XCore/XCoreAsmPrinter.cpp 192 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
195 MachineBasicBlock *MBB = JTBBs[i];
lib/Target/XCore/XCoreFrameLowering.cpp 60 static void EmitDefCfaRegister(MachineBasicBlock &MBB,
61 MachineBasicBlock::iterator MBBI,
70 static void EmitDefCfaOffset(MachineBasicBlock &MBB,
71 MachineBasicBlock::iterator MBBI,
81 static void EmitCfiOffset(MachineBasicBlock &MBB,
82 MachineBasicBlock::iterator MBBI, const DebugLoc &dl,
98 static void IfNeededExtSP(MachineBasicBlock &MBB,
99 MachineBasicBlock::iterator MBBI, const DebugLoc &dl,
121 static void IfNeededLDAWSP(MachineBasicBlock &MBB,
122 MachineBasicBlock::iterator MBBI, const DebugLoc &dl,
175 static MachineMemOperand *getFrameIndexMMO(MachineBasicBlock &MBB,
190 static void RestoreSpillList(MachineBasicBlock &MBB,
191 MachineBasicBlock::iterator MBBI,
224 MachineBasicBlock &MBB) const {
226 MachineBasicBlock::iterator MBBI = MBB.begin();
316 MachineBasicBlock::iterator Pos = SpillLabel.first;
344 MachineBasicBlock &MBB) const {
346 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
416 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
417 MachineBasicBlock::iterator MI,
452 restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
453 MachineBasicBlock::iterator MI,
459 MachineBasicBlock::iterator BeforeI = MI;
486 MachineBasicBlock::iterator XCoreFrameLowering::eliminateCallFramePseudoInstr(
lib/Target/XCore/XCoreFrameLowering.h 30 MachineBasicBlock &MBB) const override;
32 MachineBasicBlock &MBB) const override;
34 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
35 MachineBasicBlock::iterator MI,
38 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
39 MachineBasicBlock::iterator MI,
43 MachineBasicBlock::iterator
lib/Target/XCore/XCoreFrameToArgsOffsetElim.cpp 53 MachineBasicBlock &MBB = *MFI;
54 for (MachineBasicBlock::iterator MBBI = MBB.begin(), EE = MBB.end();
lib/Target/XCore/XCoreISelLowering.cpp 1522 MachineBasicBlock *
1524 MachineBasicBlock *BB) const {
1543 MachineBasicBlock *thisMBB = BB;
1545 MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
1546 MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
lib/Target/XCore/XCoreISelLowering.h 120 MachineBasicBlock *
122 MachineBasicBlock *MBB) const override;
lib/Target/XCore/XCoreInstrInfo.cpp 189 bool XCoreInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
190 MachineBasicBlock *&TBB,
191 MachineBasicBlock *&FBB,
195 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
271 unsigned XCoreInstrInfo::insertBranch(MachineBasicBlock &MBB,
272 MachineBasicBlock *TBB,
273 MachineBasicBlock *FBB,
306 XCoreInstrInfo::removeBranch(MachineBasicBlock &MBB, int *BytesRemoved) const {
309 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
331 void XCoreInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
332 MachineBasicBlock::iterator I,
358 void XCoreInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
359 MachineBasicBlock::iterator I,
381 void XCoreInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
382 MachineBasicBlock::iterator I,
426 MachineBasicBlock::iterator XCoreInstrInfo::loadImmediate(
lib/Target/XCore/XCoreInstrInfo.h 52 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
52 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
53 MachineBasicBlock *&FBB,
57 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
57 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
58 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
62 unsigned removeBranch(MachineBasicBlock &MBB,
65 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
65 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
69 void storeRegToStackSlot(MachineBasicBlock &MBB,
70 MachineBasicBlock::iterator MI,
75 void loadRegFromStackSlot(MachineBasicBlock &MBB,
76 MachineBasicBlock::iterator MI,
86 MachineBasicBlock::iterator loadImmediate(MachineBasicBlock &MBB,
lib/Target/XCore/XCoreMachineFunctionInfo.h 38 std::vector<std::pair<MachineBasicBlock::iterator, CalleeSavedInfo>>
87 std::vector<std::pair<MachineBasicBlock::iterator, CalleeSavedInfo>> &
lib/Target/XCore/XCoreRegisterInfo.cpp 61 static void InsertFPImmInst(MachineBasicBlock::iterator II,
65 MachineBasicBlock &MBB = *MI.getParent();
92 static void InsertFPConstInst(MachineBasicBlock::iterator II,
98 MachineBasicBlock &MBB = *MI.getParent();
128 static void InsertSPImmInst(MachineBasicBlock::iterator II,
132 MachineBasicBlock &MBB = *MI.getParent();
161 static void InsertSPConstInst(MachineBasicBlock::iterator II,
166 MachineBasicBlock &MBB = *MI.getParent();
259 XCoreRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
319 MachineBasicBlock &MBB = *MI.getParent();
lib/Target/XCore/XCoreRegisterInfo.h 41 void eliminateFrameIndex(MachineBasicBlock::iterator II,
tools/llvm-exegesis/lib/Assembler.cpp 89 BasicBlockFiller::BasicBlockFiller(MachineFunction &MF, MachineBasicBlock *MBB,
141 MachineBasicBlock *MBB = MF.CreateMachineBasicBlock();
tools/llvm-exegesis/lib/Assembler.h 46 BasicBlockFiller(MachineFunction &MF, MachineBasicBlock *MBB,
55 MachineBasicBlock *const MBB;
tools/llvm-exegesis/lib/Target.h 91 virtual void decrementLoopCounterAndJump(MachineBasicBlock &MBB,
92 MachineBasicBlock &TargetMBB,
tools/llvm-exegesis/lib/X86/Target.cpp 549 void decrementLoopCounterAndJump(MachineBasicBlock &MBB,
550 MachineBasicBlock &TargetMBB,
652 MachineBasicBlock &MBB, MachineBasicBlock &TargetMBB,
652 MachineBasicBlock &MBB, MachineBasicBlock &TargetMBB,
unittests/CodeGen/GlobalISel/GISelMITest.h 129 for (auto &MBB : *MF)
157 MachineBasicBlock *EntryMBB;
unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp 678 MachineBasicBlock *MidMBB = MF->CreateMachineBasicBlock();
679 MachineBasicBlock *EndMBB = MF->CreateMachineBasicBlock();
unittests/CodeGen/MachineInstrTest.cpp 44 MachineBasicBlock &MBB) const override {}
46 MachineBasicBlock &MBB) const override {}
97 void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
unittests/MI/LiveIntervalTest.cpp 105 MachineBasicBlock &MBB = *MF.getBlockNumbered(BlockNum);
125 MachineBasicBlock &MBB = *FromInstr.getParent();
unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp 180 auto *MBB2 = MF->getBlockNumbered(2);
187 auto *MBB3 = MF->getBlockNumbered(3);
194 auto *MBB4 = MF->getBlockNumbered(4);
199 auto *MBB5 = MF->getBlockNumbered(5);
204 auto *MBB6 = MF->getBlockNumbered(6);
209 auto *MBB10 = MF->getBlockNumbered(10);
214 auto *MBB8 = MF->getBlockNumbered(8);
221 auto *MBB9 = MF->getBlockNumbered(9);
355 auto *MBB1 = MF->getBlockNumbered(1);
362 auto *MBB2 = MF->getBlockNumbered(2);
367 auto *MBB7 = MF->getBlockNumbered(7);
372 auto *MBB8 = MF->getBlockNumbered(8);
377 auto *MBB3 = MF->getBlockNumbered(3);
384 auto *MBB4 = MF->getBlockNumbered(4);
389 auto *MBB5 = MF->getBlockNumbered(5);
394 auto *MBB6 = MF->getBlockNumbered(6);
399 auto *MBB12 = MF->getBlockNumbered(12);
404 auto *MBB10 = MF->getBlockNumbered(10);
411 auto *MBB11 = MF->getBlockNumbered(11);
unittests/Target/X86/MachineSizeOptsTest.cpp 107 MachineBasicBlock &BB0 = F->front();
109 MachineBasicBlock *BB1 = *iter;
111 MachineBasicBlock *BB2 = *iter;
114 MachineBasicBlock *BB3 = *BB1->succ_begin();
unittests/tools/llvm-exegesis/X86/SnippetRepetitorTest.cpp 66 return Field(&MachineBasicBlock::RegisterMaskPair::PhysReg, Eq(Reg));
82 const auto &LoopBlock = *MF->getBlockNumbered(1);
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/type_traits 1633 { typedef _Tp type; };
1983 { typedef _Up type; };
2171 { typedef _Iffalse type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 407 T* p, ::std::ostream* os) {
416 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {