Fix the value_type of defusechain_iterator to match its operator*()

[nlguillemot]

Summary

defusechain_iterator has an operator*() and operator->() that return
references to a MachineOperand, but its "reference" and "pointer"
typedefs are set as if the iterator returns a MachineInstr reference.
This causes compilation errors when defusechain_iterator is used in
generic code that uses the "reference" and "pointer" typedefs.
This patch fixes this by updating the typedefs to use MachineOperand
instead of MachineInstr.

[nlguillemot]

llvm/include/llvm/CodeGen/MachineRegisterInfo.h

974

There's another use here that needs to be updated.

By the way, I think this bug was introduced because defusechain_instr_iterator was copy/pasted make defusechain_iterator. Then maybe nobody ever tried to run a std algorithm with this iterator in a way that requires the typedefs to be correct.

[nlguillemot]

Also fixed the wrong type in the base class.

[mkitzan]

Will take a look at this one on Monday (March 1)

[mkitzan]

Good catch!

llvm/include/llvm/CodeGen/MachineRegisterInfo.h

public:
   LaneBitmask getMaxLaneMaskForVReg(Register Reg) const;
 
   /// defusechain_iterator - This class provides iterator support for machine
   /// operands in the function that use or define a specific register.  If
   /// ReturnUses is true it returns uses of registers, if ReturnDefs is true it
   /// returns defs.  If neither are true then you are silly and it always
   /// returns end().  If SkipDebug is true it skips uses marked Debug
   /// when incrementing.
-  template<bool ReturnUses, bool ReturnDefs, bool SkipDebug,
-           bool ByOperand, bool ByInstr, bool ByBundle>
-  class defusechain_iterator
-    : public std::iterator<std::forward_iterator_tag, MachineInstr, ptrdiff_t> {
+  template <bool ReturnUses, bool ReturnDefs, bool SkipDebug, bool ByOperand,
+            bool ByInstr, bool ByBundle>
+  class defusechain_iterator : public std::iterator<std::forward_iterator_tag,
+                                                    MachineOperand, ptrdiff_t> {
     friend class MachineRegisterInfo;
 
     MachineOperand *Op = nullptr;
 
     explicit defusechain_iterator(MachineOperand *op) : Op(op) {
       // If the first node isn't one we're interested in, advance to one that
       // we are interested in.
       if (op) {
void advance() {
         // If this is an operand we don't care about, skip it.
         while (Op && ((!ReturnDefs && Op->isDef()) ||
                       (SkipDebug && Op->isDebug())))
           Op = getNextOperandForReg(Op);
       }
     }
 
   public:
-    using reference = std::iterator<std::forward_iterator_tag,
-                                    MachineInstr, ptrdiff_t>::reference;
-    using pointer = std::iterator<std::forward_iterator_tag,
-                                  MachineInstr, ptrdiff_t>::pointer;
+    using reference = std::iterator<std::forward_iterator_tag, MachineOperand,
+                                    ptrdiff_t>::reference;
+    using pointer = std::iterator<std::forward_iterator_tag, MachineOperand,
+                                  ptrdiff_t>::pointer;
 
     defusechain_iterator() = default;
 
     bool operator==(const defusechain_iterator &x) const {
       return Op == x.Op;
     }
     bool operator!=(const defusechain_iterator &x) const {
       return !operator==(x);