[m_Constant] Check #operands/results before hasTrait()

[lattner]

Summary

We know that all ConstantLike operations have one result and no operands,
so check this first before doing the trait check. This change speeds up
Canonicalize on a CIRCT testcase by ~5%.

[lattner]

thank you for the review!

mlir/include/mlir/IR/Matchers.h

bool match(const Attribute &attr) {
     if (auto intAttr = attr.dyn_cast<AttrClass>()) {
       *bind_value = intAttr.getValue();
       return true;
     }
     return false;
   }
 };
 
+/// Check to see if the specified operation is ConstantLike.  This includes some
+/// quick filters to avoid a semi-expensive test in the common case.
+static bool isConstantLike(Operation *op) {
+  return op->getNumOperands() == 0 && op->getNumResults() == 1 &&
+         op->hasTrait<OpTrait::ConstantLike>();
+}
+
 /// The matcher that matches operations that have the `ConstantLike` trait.
 struct constant_op_matcher {
-  bool match(Operation *op) { return op->hasTrait<OpTrait::ConstantLike>(); }
+  bool match(Operation *op) { return isConstantLike(op); }
 };
 
 /// The matcher that matches operations that have the `ConstantLike` trait, and
 /// binds the folded attribute value.
-template <typename AttrT> struct constant_op_binder {
+template <typename AttrT>
+struct constant_op_binder {
   AttrT *bind_value;
 
   /// Creates a matcher instance that binds the constant attribute value to
   /// bind_value if match succeeds.
   constant_op_binder(AttrT *bind_value) : bind_value(bind_value) {}
   /// Creates a matcher instance that doesn't bind if match succeeds.
   constant_op_binder() : bind_value(nullptr) {}
 
   bool match(Operation *op) {
-    if (!op->hasTrait<OpTrait::ConstantLike>())
+    if (!isConstantLike(op))
       return false;
 
     // Fold the constant to an attribute.
     SmallVector<OpFoldResult, 1> foldedOp;
     LogicalResult result = op->fold(/*operands=*/llvm::None, foldedOp);
     (void)result;
     assert(succeeded(result) && "expected ConstantLike op to be foldable");
 
if (type.isa<VectorType, RankedTensorType>()) {
       }
     }
     return false;
   }
 };
 
 /// The matcher that matches a given target constant scalar / vector splat /
 /// tensor splat integer value.
-template <int64_t TargetValue> struct constant_int_value_matcher {
+template <int64_t TargetValue>
+struct constant_int_value_matcher {
   bool match(Operation *op) {
     APInt value;
     return constant_int_op_binder(&value).match(op) && TargetValue == value;
   }
 };
 
 /// The matcher that matches anything except the given target constant scalar /
 /// vector splat / tensor splat integer value.
-template <int64_t TargetNotValue> struct constant_int_not_value_matcher {
+template <int64_t TargetNotValue>
+struct constant_int_not_value_matcher {
   bool match(Operation *op) {
     APInt value;
     return constant_int_op_binder(&value).match(op) && TargetNotValue != value;
   }
 };
 
 /// The matcher that matches a certain kind of op.
-template <typename OpClass> struct op_matcher {
+template <typename OpClass>
+struct op_matcher {
   bool match(Operation *op) { return isa<OpClass>(op); }
 };
 
 /// Trait to check whether T provides a 'match' method with type
 /// `OperationOrValue`.
 template <typename T, typename OperationOrValue>
 using has_operation_or_value_matcher_t =
     decltype(std::declval<T>().match(std::declval<OperationOrValue>()));

 }
 
 /// Matches a constant scalar / vector splat / tensor splat integer one.
 inline detail::constant_int_value_matcher<1> m_One() {
   return detail::constant_int_value_matcher<1>();
 }
 
 /// Matches the given OpClass.
-template <typename OpClass> inline detail::op_matcher<OpClass> m_Op() {
+template <typename OpClass>
+inline detail::op_matcher<OpClass> m_Op() {
   return detail::op_matcher<OpClass>();
 }
 
 /// Matches a constant scalar / vector splat / tensor splat integer zero.
 inline detail::constant_int_value_matcher<0> m_Zero() {
   return detail::constant_int_value_matcher<0>();
 }
 

mlir/lib/Transforms/Utils/FoldUtils.cpp

auto processConstant = [&](Operation *op, Attribute value) {
     else
       ++constantIterator; // It was pointing at the constant.
   };
 
   SmallVector<Operation *> isolatedOps;
   region.walk<WalkOrder::PreOrder>([&](Operation *op) {
     // If this is a constant, process it.
     Attribute value;
-    if (op->getNumOperands() == 0 && op->getNumResults() == 1 &&
-        matchPattern(op, m_Constant(&value))) {
+    if (matchPattern(op, m_Constant(&value))) {
       processConstant(op, value);
       // We may have deleted the operation, don't check it for regions.
       return WalkResult::advance();
     }
 
     // If the operation has regions and is isolated, don't recurse into it.
     if (op->getNumRegions() != 0) {
       auto hasDifferentInsertRegion = [&](Region &region) {