[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

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());
   }
 
+  /// Returns an iterator range over all operands that are (explicit or
+  /// implicit) register defs.
+  auto all_defs() {
+    return make_filter_range(operands(), [](MachineOperand &Op) {
+      return Op.isReg() && Op.isDef();
+    });
+  }
+  /// \copydoc all_defs()
+  auto all_defs() const {
+    return make_filter_range(operands(), [](const MachineOperand &Op) {
+      return Op.isReg() && Op.isDef();
+    });
+  }
+
+  /// Returns an iterator range over all operands that are (explicit or
+  /// implicit) register uses.
+  auto all_uses() {
+    return make_filter_range(
+        uses(), [](MachineOperand &Op) { return Op.isReg() && Op.isUse(); });
+  }
+  /// \copydoc all_uses()
+  auto all_uses() const {
+    return make_filter_range(uses(), [](const MachineOperand &Op) {
+      return Op.isReg() && Op.isUse();
+    });
+  }
+
   /// 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.