[MachineInstr] Implement new operand accessors all_defs and all_uses

[barannikov88]

Q: What is the type of auto? Can it be spelled explicitly or is it unspellable?

I guess the overloads should also be doxygenated? (Methods above use @copydoc).

[foad]

Q: What is the type of auto? Can it be spelled explicitly or is it unspellable?

I'm sure it can be spelled. See other methods that use make_filter_range like:

iterator_range<filter_iterator<const MachineOperand *,
                               std::function<bool(const MachineOperand &Op)>>>
getDebugOperandsForReg(Register Reg) const {
  return MachineInstr::getDebugOperandsForReg<const MachineOperand,
                                              const MachineInstr>(this, Reg);
}

But I'm not sure that spelling it out in that much detail is useful. Perhaps there is a simpler type that would work? I don't know.

[foad]

\copydoc

[foad]

Here's a version with non-auto return types. I don't love it.

[barannikov88]

In D151423#4372071, @foad wrote:

Here's a version with non-auto return types. I don't love it.

I'm fine with auto here, I think this is one of the cases where auto does more good than harm. Also, std::function is not cheap while a lambda can be inlined.
I asked because I thought it could be as simple as iterator_range<const_mop_iterator> above.

[foad]

@qcolombet I was planning to go back to the previous diff which used auto for the return types: https://reviews.llvm.org/D151423?vs=on&id=525565. Do you have a preference?

[qcolombet]

In D151423#4387264, @foad wrote:

@qcolombet I was planning to go back to the previous diff which used auto for the return types: https://reviews.llvm.org/D151423?vs=on&id=525565. Do you have a preference?

I prefer with the explicit types personally.

llvm/include/llvm/CodeGen/MachineInstr.h

private:
 
   // MachineInstrs are pool-allocated and owned by MachineFunction.
   friend class MachineFunction;
 
   void
   dumprImpl(const MachineRegisterInfo &MRI, unsigned Depth, unsigned MaxDepth,
             SmallPtrSetImpl<const MachineInstr *> &AlreadySeenInstrs) const;
 
+  static bool opIsRegDef(const MachineOperand &Op) {
+    return Op.isReg() && Op.isDef();
+  }
+
+  static bool opIsRegUse(const MachineOperand &Op) {
+    return Op.isReg() && Op.isUse();
+  }
+
 public:
   MachineInstr(const MachineInstr &) = delete;
   MachineInstr &operator=(const MachineInstr &) = delete;
   // Use MachineFunction::DeleteMachineInstr() instead.
   ~MachineInstr() = delete;
 
   const MachineBasicBlock* getParent() const { return Parent; }
   MachineBasicBlock* getParent() { return Parent; }
iterator_range<mop_iterator> explicit_uses() {
     return make_range(operands_begin() + getNumExplicitDefs(),
                       operands_begin() + getNumExplicitOperands());
   }
   iterator_range<const_mop_iterator> explicit_uses() const {
     return make_range(operands_begin() + getNumExplicitDefs(),
                       operands_begin() + getNumExplicitOperands());
   }
 
+  using filtered_mop_iterator =
+      filter_iterator<mop_iterator, std::function<bool(MachineOperand &)>>;
+  using filtered_const_mop_iterator =
+      filter_iterator<const_mop_iterator,
+                      std::function<bool(const MachineOperand &)>>;
+
+  /// Returns an iterator range over all operands that are (explicit or
+  /// implicit) register defs.
+  iterator_range<filtered_mop_iterator> all_defs() {
+    return make_filter_range(operands(),
+                             std::function<bool(MachineOperand &)>(opIsRegDef));
+  }
+  /// \copydoc all_defs()
+  iterator_range<filtered_const_mop_iterator> all_defs() const {
+    return make_filter_range(
+        operands(), std::function<bool(const MachineOperand &)>(opIsRegDef));
+  }
+
+  /// Returns an iterator range over all operands that are (explicit or
+  /// implicit) register uses.
+  iterator_range<filtered_mop_iterator> all_uses() {
+    return make_filter_range(uses(),
+                             std::function<bool(MachineOperand &)>(opIsRegUse));
+  }
+  /// \copydoc all_uses()
+  iterator_range<filtered_const_mop_iterator> all_uses() const {
+    return make_filter_range(
+        uses(), std::function<bool(const MachineOperand &)>(opIsRegUse));
+  }
+
   /// Returns the number of the operand iterator \p I points to.
   unsigned getOperandNo(const_mop_iterator I) const {
     return I - operands_begin();
   }
 
   /// Access to memory operands of the instruction. If there are none, that does
   /// not imply anything about whether the function accesses memory. Instead,
   /// the caller must behave conservatively.