CodeGen: MachineInstr::getIterator() => getInstrIterator(), NFC

Delete MachineInstr::getIterator(), since the term "iterator" is
overloaded when talking about MachineInstr.

- Downcast to ilist_node in iplist::getNextNode() and getPrevNode() so
  that ilist_node::getIterator() is still available.
- Add it back as MachineInstr::getInstrIterator().  This matches the
  naming in MachineBasicBlock.
- Add MachineInstr::getBundleIterator().  This is explicitly called
  "bundle" (not matching MachineBasicBlock) to disintinguish it clearly
  from ilist_node::getIterator().
- Update all calls.  Some of these I switched to `auto` to remove
  boiler-plate, since the new name is clear about the type.

There was one call I updated that looked fishy, but it wasn't clear what
the right answer was.  This was in X86FrameLowering::inlineStackProbe(),
added in r252578 in lib/Target/X86/X86FrameLowering.cpp.  I opted to
leave the behaviour unchanged, but I'll reply to the original commit on
the list in a moment.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@261504 91177308-0d34-0410-b5e6-96231b3b80d8

Author: dexonsmith

include/llvm/ADT/ilist.h

@@ -638,7 +638,7 @@ class iplist : public Traits {
 
   /// \brief Get the previous node, or \c nullptr for the list head.
   NodeTy *getPrevNode(NodeTy &N) const {
-    auto I = N.getIterator();
+    auto I = static_cast<ilist_node<NodeTy> &>(N).getIterator();
     if (I == begin())
       return nullptr;
     return &*std::prev(I);
@@ -650,7 +650,7 @@ class iplist : public Traits {
 
   /// \brief Get the next node, or \c nullptr for the list tail.
   NodeTy *getNextNode(NodeTy &N) const {
-    auto Next = std::next(N.getIterator());
+    auto Next = std::next(static_cast<ilist_node<NodeTy> &>(N).getIterator());
     if (Next == end())
       return nullptr;
     return &*Next;

include/llvm/CodeGen/MachineInstr.h

@@ -25,6 +25,7 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/CodeGen/MachineOperand.h"
+#include "llvm/CodeGen/MachineInstrBundleIterator.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/InlineAsm.h"
@@ -139,6 +140,21 @@ class MachineInstr
   const MachineBasicBlock* getParent() const { return Parent; }
   MachineBasicBlock* getParent() { return Parent; }
 
+  // Disallow getIterator(), since it's ambiguous.
+  void getIterator() = delete;
+  typedef ilist_iterator<MachineInstr> instr_iterator;
+  typedef ilist_iterator<const MachineInstr> const_instr_iterator;
+  instr_iterator getInstrIterator() { return instr_iterator(this); }
+  const_instr_iterator getInstrIterator() const {
+    return const_instr_iterator(this);
+  }
+  typedef MachineInstrBundleIterator<MachineInstr> bundle_iterator;
+  typedef MachineInstrBundleIterator<const MachineInstr> const_bundle_iterator;
+  bundle_iterator getBundleIterator() { return bundle_iterator(this); }
+  const_bundle_iterator getBundleIterator() const {
+    return const_bundle_iterator(this);
+  }
+
   /// Return the asm printer flags bitvector.
   uint8_t getAsmPrinterFlags() const { return AsmPrinterFlags; }
 

include/llvm/CodeGen/MachineInstrBuilder.h

@@ -472,7 +472,7 @@ class MIBundleBuilder {
     if (I == Begin) {
       if (!empty())
         MI->bundleWithSucc();
-      Begin = MI->getIterator();
+      Begin = MI->getInstrIterator();
       return *this;
     }
     if (I == End) {

include/llvm/CodeGen/MachineInstrBundle.h

@@ -116,10 +116,10 @@ class MachineOperandIteratorBase {
   ///
   explicit MachineOperandIteratorBase(MachineInstr *MI, bool WholeBundle) {
     if (WholeBundle) {
-      InstrI = getBundleStart(MI)->getIterator();
+      InstrI = getBundleStart(MI)->getInstrIterator();
       InstrE = MI->getParent()->instr_end();
     } else {
-      InstrI = InstrE = MI->getIterator();
+      InstrI = InstrE = MI->getInstrIterator();
       ++InstrE;
     }
     OpI = InstrI->operands_begin();

lib/CodeGen/DFAPacketizer.cpp

@@ -198,7 +198,7 @@ VLIWPacketizerList::~VLIWPacketizerList() {
 void VLIWPacketizerList::endPacket(MachineBasicBlock *MBB, MachineInstr *MI) {
   if (CurrentPacketMIs.size() > 1) {
     MachineInstr *MIFirst = CurrentPacketMIs.front();
-    finalizeBundle(*MBB, MIFirst->getIterator(), MI->getIterator());
+    finalizeBundle(*MBB, MIFirst->getInstrIterator(), MI->getInstrIterator());
   }
   CurrentPacketMIs.clear();
   ResourceTracker->clearResources();

lib/CodeGen/MachineCopyPropagation.cpp

@@ -90,8 +90,10 @@ static bool NoInterveningSideEffect(const MachineInstr *CopyMI,
   if (MI->getParent() != MBB)
     return false;
 
-  for (MachineBasicBlock::const_iterator I = std::next(CopyMI->getIterator()),
-       E = MBB->end(), E2 = MI->getIterator(); I != E && I != E2; ++I) {
+  for (MachineBasicBlock::const_instr_iterator
+           I = std::next(CopyMI->getInstrIterator()),
+           E = MBB->instr_end(), E2 = MI->getInstrIterator();
+       I != E && I != E2; ++I) {
     if (I->hasUnmodeledSideEffects() || I->isCall() ||
         I->isTerminator())
       return false;
@@ -163,8 +165,8 @@ void MachineCopyPropagation::CopyPropagateBlock(MachineBasicBlock &MBB) {
 
           // Clear any kills of Def between CopyMI and MI. This extends the
           // live range.
-          for (MachineInstr &MMI
-               : make_range(CopyMI->getIterator(), MI->getIterator()))
+          for (MachineInstr &MMI :
+               make_range(CopyMI->getInstrIterator(), MI->getInstrIterator()))
             MMI.clearRegisterKills(Def, TRI);
 
           MI->eraseFromParent();

lib/CodeGen/MachineInstr.cpp

@@ -934,7 +934,7 @@ MachineInstr::mergeMemRefsWith(const MachineInstr& Other) {
 
 bool MachineInstr::hasPropertyInBundle(unsigned Mask, QueryType Type) const {
   assert(!isBundledWithPred() && "Must be called on bundle header");
-  for (MachineBasicBlock::const_instr_iterator MII = getIterator();; ++MII) {
+  for (auto MII = getInstrIterator();; ++MII) {
     if (MII->getDesc().getFlags() & Mask) {
       if (Type == AnyInBundle)
         return true;
@@ -958,10 +958,10 @@ bool MachineInstr::isIdenticalTo(const MachineInstr *Other,
 
   if (isBundle()) {
     // Both instructions are bundles, compare MIs inside the bundle.
-    MachineBasicBlock::const_instr_iterator I1 = getIterator();
-    MachineBasicBlock::const_instr_iterator E1 = getParent()->instr_end();
-    MachineBasicBlock::const_instr_iterator I2 = Other->getIterator();
-    MachineBasicBlock::const_instr_iterator E2= Other->getParent()->instr_end();
+    auto I1 = getInstrIterator();
+    auto E1 = getParent()->instr_end();
+    auto I2 = Other->getInstrIterator();
+    auto E2 = Other->getParent()->instr_end();
     while (++I1 != E1 && I1->isInsideBundle()) {
       ++I2;
       if (I2 == E2 || !I2->isInsideBundle() || !I1->isIdenticalTo(&*I2, Check))
@@ -1069,35 +1069,31 @@ unsigned MachineInstr::getNumExplicitOperands() const {
 void MachineInstr::bundleWithPred() {
   assert(!isBundledWithPred() && "MI is already bundled with its predecessor");
   setFlag(BundledPred);
-  MachineBasicBlock::instr_iterator Pred = getIterator();
-  --Pred;
+  auto Pred = --getInstrIterator();
   assert(!Pred->isBundledWithSucc() && "Inconsistent bundle flags");
   Pred->setFlag(BundledSucc);
 }
 
 void MachineInstr::bundleWithSucc() {
   assert(!isBundledWithSucc() && "MI is already bundled with its successor");
   setFlag(BundledSucc);
-  MachineBasicBlock::instr_iterator Succ = getIterator();
-  ++Succ;
+  auto Succ = ++getInstrIterator();
   assert(!Succ->isBundledWithPred() && "Inconsistent bundle flags");
   Succ->setFlag(BundledPred);
 }
 
 void MachineInstr::unbundleFromPred() {
   assert(isBundledWithPred() && "MI isn't bundled with its predecessor");
   clearFlag(BundledPred);
-  MachineBasicBlock::instr_iterator Pred = getIterator();
-  --Pred;
+  auto Pred = --getInstrIterator();
   assert(Pred->isBundledWithSucc() && "Inconsistent bundle flags");
   Pred->clearFlag(BundledSucc);
 }
 
 void MachineInstr::unbundleFromSucc() {
   assert(isBundledWithSucc() && "MI isn't bundled with its successor");
   clearFlag(BundledSucc);
-  MachineBasicBlock::instr_iterator Succ = getIterator();
-  ++Succ;
+  auto Succ = ++getInstrIterator();
   assert(Succ->isBundledWithPred() && "Inconsistent bundle flags");
   Succ->clearFlag(BundledPred);
 }
@@ -1232,7 +1228,7 @@ const TargetRegisterClass *MachineInstr::getRegClassConstraintEffect(
 /// Return the number of instructions inside the MI bundle, not counting the
 /// header instruction.
 unsigned MachineInstr::getBundleSize() const {
-  MachineBasicBlock::const_instr_iterator I = getIterator();
+  auto I = getInstrIterator();
   unsigned Size = 0;
   while (I->isBundledWithSucc()) {
     ++Size;

lib/CodeGen/ProcessImplicitDefs.cpp

@@ -96,8 +96,8 @@ void ProcessImplicitDefs::processImplicitDef(MachineInstr *MI) {
 
   // This is a physreg implicit-def.
   // Look for the first instruction to use or define an alias.
-  MachineBasicBlock::instr_iterator UserMI = MI->getIterator();
-  MachineBasicBlock::instr_iterator UserE = MI->getParent()->instr_end();
+  auto UserMI = MI->getInstrIterator();
+  auto UserE = MI->getParent()->instr_end();
   bool Found = false;
   for (++UserMI; UserMI != UserE; ++UserMI) {
     for (MachineOperand &MO : UserMI->operands()) {

lib/CodeGen/ScheduleDAGInstrs.cpp

@@ -1200,8 +1200,8 @@ static void toggleBundleKillFlag(MachineInstr *MI, unsigned Reg,
   // Once we set a kill flag on an instruction, we bail out, as otherwise we
   // might set it on too many operands.  We will clear as many flags as we
   // can though.
-  MachineBasicBlock::instr_iterator Begin = MI->getIterator();
-  MachineBasicBlock::instr_iterator End = getBundleEnd(MI);
+  auto Begin = MI->getInstrIterator();
+  auto End = getBundleEnd(MI);
   while (Begin != End) {
     for (MachineOperand &MO : (--End)->operands()) {
       if (!MO.isReg() || MO.isDef() || Reg != MO.getReg())
@@ -1334,8 +1334,8 @@ void ScheduleDAGInstrs::fixupKills(MachineBasicBlock *MBB) {
         toggleKillFlag(MI, MO);
         DEBUG(MI->dump());
         DEBUG(if (MI->getOpcode() == TargetOpcode::BUNDLE) {
-          MachineBasicBlock::instr_iterator Begin = MI->getIterator();
-          MachineBasicBlock::instr_iterator End = getBundleEnd(MI);
+          auto Begin = MI->getInstrIterator();
+          auto End = getBundleEnd(MI);
           while (++Begin != End)
             DEBUG(Begin->dump());
         });

lib/Target/AArch64/AArch64CleanupLocalDynamicTLSPass.cpp

@@ -118,7 +118,7 @@ struct LDTLSCleanup : public MachineFunctionPass {
 
     // Insert a copy from X0 to TLSBaseAddrReg for later.
     MachineInstr *Copy =
-        BuildMI(*I->getParent(), ++I->getIterator(), I->getDebugLoc(),
+        BuildMI(*I->getParent(), ++I->getInstrIterator(), I->getDebugLoc(),
                 TII->get(TargetOpcode::COPY), *TLSBaseAddrReg)
             .addReg(AArch64::X0);