[MIBundle] Remove unused/obsolete MIOperands/ConstMIOperands (NFC).

[fhahn]

Summary

Those iterators are unused and the respective iterators from
MachineInstr should be used (e.g. MachineInstr::operands(),
https://llvm.org/doxygen/classllvm_1_1MachineInstr.html#aef0e7e42e45e15f86b2a122b56ab829c)

[fhahn]

ping

[ab]

llvm/include/llvm/CodeGen/MachineInstrBundle.h

82

Not on "a MachineInstr" anymore

llvm/include/llvm/CodeGen/MachineInstrBundle.h

inline MachineBasicBlock::const_instr_iterator getBundleEnd(
   return I;
 }
 
 //===----------------------------------------------------------------------===//
 // MachineOperand iterator
 //
 
 /// MachineOperandIteratorBase - Iterator that can visit all operands on a
 /// MachineInstr, or all operands on a bundle of MachineInstrs.  This class is
 /// not intended to be used directly, use one of the sub-classes instead.
 ///
 /// Intended use:
 ///
 ///   for (MIBundleOperands MIO(MI); MIO.isValid(); ++MIO) {
 ///     if (!MIO->isReg())
 ///       continue;
 ///     ...
void advance() {
     }
   }
 
 protected:
   /// MachineOperandIteratorBase - Create an iterator that visits all operands
   /// on MI, or all operands on every instruction in the bundle containing MI.
   ///
   /// @param MI The instruction to examine.
-  /// @param WholeBundle When true, visit all operands on the entire bundle.
   ///
-  explicit MachineOperandIteratorBase(MachineInstr &MI, bool WholeBundle) {
-    if (WholeBundle) {
-      InstrI = getBundleStart(MI.getIterator());
-      InstrE = MI.getParent()->instr_end();
-    } else {
-      InstrI = InstrE = MI.getIterator();
-      ++InstrE;
-    }
+  explicit MachineOperandIteratorBase(MachineInstr &MI) {
     OpI = InstrI->operands_begin();
     OpE = InstrI->operands_end();
-    if (WholeBundle)
-      advance();
   }
 
   MachineOperand &deref() const { return *OpI; }
 
 public:
   /// isValid - Returns true until all the operands have been visited.
   bool isValid() const { return OpI != OpE; }
 
   /// Preincrement.  Move to the next operand.
   void operator++() {
     assert(isValid() && "Cannot advance MIOperands beyond the last operand");
     ++OpI;
     advance();
   }
 
   /// getOperandNo - Returns the number of the current operand relative to its
   /// instruction.
   ///
   unsigned getOperandNo() const {
     return OpI - InstrI->operands_begin();
   }
 
 };
 
-/// MIOperands - Iterate over operands of a single instruction.
-///
-class MIOperands : public MachineOperandIteratorBase {
-public:
-  MIOperands(MachineInstr &MI) : MachineOperandIteratorBase(MI, false) {}
-  MachineOperand &operator* () const { return deref(); }
-  MachineOperand *operator->() const { return &deref(); }
-};
-
-/// ConstMIOperands - Iterate over operands of a single const instruction.
-///
-class ConstMIOperands : public MachineOperandIteratorBase {
-public:
-  ConstMIOperands(const MachineInstr &MI)
-      : MachineOperandIteratorBase(const_cast<MachineInstr &>(MI), false) {}
-  const MachineOperand &operator* () const { return deref(); }
-  const MachineOperand *operator->() const { return &deref(); }
-};
-
 /// MIBundleOperands - Iterate over all operands in a bundle of machine
 /// instructions.
 ///
 class MIBundleOperands : public MachineOperandIteratorBase {
 public:
-  MIBundleOperands(MachineInstr &MI) : MachineOperandIteratorBase(MI, true) {}
+  MIBundleOperands(MachineInstr &MI) : MachineOperandIteratorBase(MI) {}
   MachineOperand &operator* () const { return deref(); }
   MachineOperand *operator->() const { return &deref(); }
 };
 
 /// ConstMIBundleOperands - Iterate over all operands in a const bundle of
 /// machine instructions.
 ///
 class ConstMIBundleOperands : public MachineOperandIteratorBase {
 public:
   ConstMIBundleOperands(const MachineInstr &MI)
-      : MachineOperandIteratorBase(const_cast<MachineInstr &>(MI), true) {}
+      : MachineOperandIteratorBase(const_cast<MachineInstr &>(MI)) {}
   const MachineOperand &operator* () const { return deref(); }
   const MachineOperand *operator->() const { return &deref(); }
 };
 
 /// VirtRegInfo - Information about a virtual register used by a set of
 /// operands.
 ///
 struct VirtRegInfo {