[WebAssembly] Simplify iterator navigations (NFC)

[aheejin]

Summary

• Replaces some uses of MachineFunction::iterator(MBB) with MBB->getIterator() and MachineBasicBlock::iterator(MI) with MI->getIterator(), which are simpler.
• Replaces some uses of std::prev of std::next that takes a MachineFunction or MachineBasicBlock iterator with getPrevNode and getNextNode, which are also simpler.

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

for (MachineBasicBlock *Pred : MBB.predecessors()) {
     }
   }
   if (!Header)
     return;
   if (!IsBranchedTo)
     return;
 
   assert(&MBB != &MF.front() && "Header blocks shouldn't have predecessors");
-  MachineBasicBlock *LayoutPred = &*std::prev(MachineFunction::iterator(&MBB));
+  MachineBasicBlock *LayoutPred = MBB.getPrevNode();
 
   // If the nearest common dominator is inside a more deeply nested context,
   // walk out to the nearest scope which isn't more deeply nested.
   for (MachineFunction::iterator I(LayoutPred), E(Header); I != E; --I) {
     if (MachineBasicBlock *ScopeTop = ScopeTops[I->getNumber()]) {
       if (ScopeTop->getNumber() > Header->getNumber()) {
         // Skip over an intervening scope.
-        I = std::next(MachineFunction::iterator(ScopeTop));
+        I = std::next(ScopeTop->getIterator());
       } else {
         // We found a scope level at an appropriate depth.
         Header = ScopeTop;
         break;
       }
     }
   }
 
   // Decide where in Header to put the BLOCK.
 
   // Instructions that should go before the BLOCK.
   SmallPtrSet<const MachineInstr *, 4> BeforeSet;
   // Instructions that should go after the BLOCK.
   SmallPtrSet<const MachineInstr *, 4> AfterSet;
   for (const auto &MI : *Header) {
     // If there is a previously placed LOOP/TRY marker and the bottom block of
     // the loop/exception is above MBB, it should be after the BLOCK, because
     // the loop/exception is nested in this block. Otherwise it should be before
     // the BLOCK.
     if (MI.getOpcode() == WebAssembly::LOOP ||
         MI.getOpcode() == WebAssembly::TRY) {
-      auto *BottomBB =
-          &*std::prev(MachineFunction::iterator(BeginToEnd[&MI]->getParent()));
+      auto *BottomBB = BeginToEnd[&MI]->getParent()->getPrevNode();
       if (MBB.getNumber() > BottomBB->getNumber())
         AfterSet.insert(&MI);
 #ifndef NDEBUG
       else
         BeforeSet.insert(&MI);
 #endif
     }
 
void WebAssemblyCFGStackify::placeLoopMarker(MachineBasicBlock &MBB) {
 
   MachineLoop *Loop = MLI.getLoopFor(&MBB);
   if (!Loop || Loop->getHeader() != &MBB)
     return;
 
   // The operand of a LOOP is the first block after the loop. If the loop is the
   // bottom of the function, insert a dummy block at the end.
   MachineBasicBlock *Bottom = WebAssembly::getBottom(Loop);
-  auto Iter = std::next(MachineFunction::iterator(Bottom));
+  auto Iter = std::next(Bottom->getIterator());
   if (Iter == MF.end()) {
     MachineBasicBlock *Label = MF.CreateMachineBasicBlock();
     // Give it a fake predecessor so that AsmPrinter prints its label.
     Label->addSuccessor(Label);
     MF.push_back(Label);
-    Iter = std::next(MachineFunction::iterator(Bottom));
+    Iter = std::next(Bottom->getIterator());
   }
   MachineBasicBlock *AfterLoop = &*Iter;
 
   // Decide where in Header to put the LOOP.
   SmallPtrSet<const MachineInstr *, 4> BeforeSet;
   SmallPtrSet<const MachineInstr *, 4> AfterSet;
   for (const auto &MI : MBB) {
     // LOOP marker should be after any existing loop that ends here. Otherwise
if (!Header)
     return;
 
   // If this try is at the bottom of the function, insert a dummy block at the
   // end.
   WebAssemblyException *WE = WEI.getExceptionFor(&MBB);
   assert(WE);
   MachineBasicBlock *Bottom = WebAssembly::getBottom(WE);
 
-  auto Iter = std::next(MachineFunction::iterator(Bottom));
+  auto Iter = std::next(Bottom->getIterator());
   if (Iter == MF.end()) {
     MachineBasicBlock *Label = MF.CreateMachineBasicBlock();
     // Give it a fake predecessor so that AsmPrinter prints its label.
     Label->addSuccessor(Label);
     MF.push_back(Label);
-    Iter = std::next(MachineFunction::iterator(Bottom));
+    Iter = std::next(Bottom->getIterator());
   }
   MachineBasicBlock *Cont = &*Iter;
 
   assert(Cont != &MF.front());
-  MachineBasicBlock *LayoutPred =
-      &*std::prev(MachineFunction::iterator(Cont));
+  MachineBasicBlock *LayoutPred = Cont->getPrevNode();
 
   // If the nearest common dominator is inside a more deeply nested context,
   // walk out to the nearest scope which isn't more deeply nested.
   for (MachineFunction::iterator I(LayoutPred), E(Header); I != E; --I) {
     if (MachineBasicBlock *ScopeTop = ScopeTops[I->getNumber()]) {
       if (ScopeTop->getNumber() > Header->getNumber()) {
         // Skip over an intervening scope.
-        I = std::next(MachineFunction::iterator(ScopeTop));
+        I = std::next(ScopeTop->getIterator());
       } else {
         // We found a scope level at an appropriate depth.
         Header = ScopeTop;
         break;
       }
     }
   }
 
void WebAssemblyCFGStackify::removeUnnecessaryInstrs(MachineFunction &MF) {
   // bb2:
   //   end
   for (auto &MBB : MF) {
     if (!MBB.isEHPad())
       continue;
 
     MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
     SmallVector<MachineOperand, 4> Cond;
-    MachineBasicBlock *EHPadLayoutPred =
-        &*std::prev(MachineFunction::iterator(&MBB));
+    MachineBasicBlock *EHPadLayoutPred = MBB.getPrevNode();
     MachineBasicBlock *Cont = BeginToEnd[EHPadToTry[&MBB]]->getParent();
     bool Analyzable = !TII.analyzeBranch(*EHPadLayoutPred, TBB, FBB, Cond);
     if (Analyzable && ((Cond.empty() && TBB && TBB == Cont) ||
                        (!Cond.empty() && FBB && FBB == Cont)))
       TII.removeBranch(*EHPadLayoutPred);
   }
 
   // When there are block / end_block markers that overlap with try / end_try
for (auto &MBB : MF) {
     for (auto &MI : MBB) {
       if (MI.getOpcode() != WebAssembly::TRY)
         continue;
 
       MachineInstr *Try = &MI, *EndTry = BeginToEnd[Try];
       MachineBasicBlock *TryBB = Try->getParent();
       MachineBasicBlock *Cont = EndTry->getParent();
       int64_t RetType = Try->getOperand(0).getImm();
-      for (auto B = MachineBasicBlock::iterator(Try),
-                E = std::next(MachineBasicBlock::iterator(EndTry));
+      for (auto B = Try->getIterator(), E = std::next(EndTry->getIterator());
            B != TryBB->begin() && E != Cont->end() &&
            std::prev(B)->getOpcode() == WebAssembly::BLOCK &&
            E->getOpcode() == WebAssembly::END_BLOCK &&
            std::prev(B)->getOperand(0).getImm() == RetType;
            --B, ++E) {
         ToDelete.push_back(&*std::prev(B));
         ToDelete.push_back(&*E);
       }

lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp

for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E;) {
       // Insert local.sets for any defs that aren't stackified yet. Currently
       // we handle at most one def.
       assert(MI.getDesc().getNumDefs() <= 1);
       if (MI.getDesc().getNumDefs() == 1) {
         unsigned OldReg = MI.getOperand(0).getReg();
         if (!MFI.isVRegStackified(OldReg)) {
           const TargetRegisterClass *RC = MRI.getRegClass(OldReg);
           unsigned NewReg = MRI.createVirtualRegister(RC);
-          auto InsertPt = std::next(MachineBasicBlock::iterator(&MI));
+          auto InsertPt = std::next(MI.getIterator());
           if (MI.getOpcode() == WebAssembly::IMPLICIT_DEF) {
             MI.eraseFromParent();
             Changed = true;
             continue;
           }
           if (UseEmpty[TargetRegisterInfo::virtReg2Index(OldReg)]) {
             unsigned Opc = getDropOpcode(RC);
             MachineInstr *Drop =

lib/Target/WebAssembly/WebAssemblyFixIrreducibleControlFlow.cpp

for (MachineBasicBlock *MBB : AllPreds) {
     DenseMap<MachineBasicBlock *, MachineBasicBlock *> Map;
     for (auto *Succ : MBB->successors()) {
       if (!Entries.count(Succ)) {
         continue;
       }
 
       // This is a successor we need to rewrite.
       MachineBasicBlock *Split = MF.CreateMachineBasicBlock();
-      MF.insert(MBB->isLayoutSuccessor(Succ) ? MachineFunction::iterator(Succ)
-                                             : MF.end(),
+      MF.insert(MBB->isLayoutSuccessor(Succ) ? Succ->getIterator() : MF.end(),
                 Split);
       MLI.changeLoopFor(Split, Loop);
 
       // Set the jump table's register of the index of the block we wish to
       // jump to, and jump to the jump table.
       BuildMI(*Split, Split->end(), DebugLoc(), TII.get(WebAssembly::CONST_I32),
               Reg)
           .addImm(Indices[Succ]);

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

static MachineBasicBlock *LowerFPToInt(MachineInstr &MI, DebugLoc DL,
   MachineBasicBlock *DoneMBB = F->CreateMachineBasicBlock(LLVMBB);
 
   MachineFunction::iterator It = ++BB->getIterator();
   F->insert(It, FalseMBB);
   F->insert(It, TrueMBB);
   F->insert(It, DoneMBB);
 
   // Transfer the remainder of BB and its successor edges to DoneMBB.
-  DoneMBB->splice(DoneMBB->begin(), BB,
-                  std::next(MachineBasicBlock::iterator(MI)), BB->end());
+  DoneMBB->splice(DoneMBB->begin(), BB, std::next(MI.getIterator()), BB->end());
   DoneMBB->transferSuccessorsAndUpdatePHIs(BB);
 
   BB->addSuccessor(TrueMBB);
   BB->addSuccessor(FalseMBB);
   TrueMBB->addSuccessor(DoneMBB);
   FalseMBB->addSuccessor(DoneMBB);
 
   unsigned Tmp0, Tmp1, CmpReg, EqzReg, FalseReg, TrueReg;

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

for (auto &MI : MBB) {
           MI.getOpcode() != WebAssembly::RETHROW)
         continue;
       Changed = true;
 
       // The instruction after the throw should be an unreachable or a branch to
       // another BB that should eventually lead to an unreachable. Delete it
       // because throw itself is a terminator, and also delete successors if
       // any.
-      MBB.erase(std::next(MachineBasicBlock::iterator(MI)), MBB.end());
+      MBB.erase(std::next(MI.getIterator()), MBB.end());
       SmallVector<MachineBasicBlock *, 8> Succs(MBB.succ_begin(),
                                                 MBB.succ_end());
       for (auto *Succ : Succs)
         MBB.removeSuccessor(Succ);
       eraseDeadBBsAndChildren(Succs);
     }
   }