[MLIR] expose applyCmpPredicate

[stephenneuendorffer]

Summary

This is useful for manipulating the standard dialect from transformations
outside of the standard dialect.

[ftynse]

Would it make sense to put them in the relevant Ops so as not to pollute the mlir:: namespace?

[stephenneuendorffer]

In D80609#2057374, @ftynse wrote:

Would it make sense to put them in the relevant Ops so as not to pollute the mlir:: namespace?

Maybe... I think if the standard dialect had a namespace they would logically go there. (Maybe it should?)
They are more tied to the Predicate than do the comparison itself, but since it's an enum class it can't have methods.

[bondhugula]

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

343

Triple / please.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

 /// ```
 ///
 /// may fold into:
 ///
 /// ```
 ///   consumer %0 ... : memref<?x16xf32, affine_map<(i, j)->(16 * i + j)>>
 /// ```
 bool canFoldIntoConsumerOp(MemRefCastOp castOp);
+
+/// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
+/// comparison predicates.
+bool applyCmpPredicate(CmpIPredicate predicate, const APInt &lhs,
+                       const APInt &rhs);
+
+/// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
+/// comparison predicates.
+bool applyCmpPredicate(CmpFPredicate predicate, const APFloat &lhs,
+                       const APFloat &rhs);
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_IR_STANDARDOPS_IR_OPS_H

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

static void buildCmpIOp(OpBuilder &build, OperationState &result,
   result.addOperands({lhs, rhs});
   result.types.push_back(getI1SameShape(lhs.getType()));
   result.addAttribute(CmpIOp::getPredicateAttrName(),
                       build.getI64IntegerAttr(static_cast<int64_t>(predicate)));
 }
 
 // Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
 // comparison predicates.
-static bool applyCmpPredicate(CmpIPredicate predicate, const APInt &lhs,
-                              const APInt &rhs) {
+bool mlir::applyCmpPredicate(CmpIPredicate predicate, const APInt &lhs,
   switch (predicate) {
   case CmpIPredicate::eq:
     return lhs.eq(rhs);
   case CmpIPredicate::ne:
     return lhs.ne(rhs);
   case CmpIPredicate::slt:
     return lhs.slt(rhs);
   case CmpIPredicate::sle:
static void buildCmpFOp(OpBuilder &build, OperationState &result,
   result.addOperands({lhs, rhs});
   result.types.push_back(getI1SameShape(lhs.getType()));
   result.addAttribute(CmpFOp::getPredicateAttrName(),
                       build.getI64IntegerAttr(static_cast<int64_t>(predicate)));
 }
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
 /// comparison predicates.
-static bool applyCmpPredicate(CmpFPredicate predicate, const APFloat &lhs,
-                              const APFloat &rhs) {
+bool mlir::applyCmpPredicate(CmpFPredicate predicate, const APFloat &lhs,
   auto cmpResult = lhs.compare(rhs);
   switch (predicate) {
   case CmpFPredicate::AlwaysFalse:
     return false;
   case CmpFPredicate::OEQ:
     return cmpResult == APFloat::cmpEqual;
   case CmpFPredicate::OGT:
     return cmpResult == APFloat::cmpGreaterThan;