Canonicalize max/min operations on integers.

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

let description = [{
 
     Example:
 
     ```mlir
     // Scalar signed integer maximum.
     %a = maxsi %b, %c : i64
     ```
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // MaxUIOp
 //===----------------------------------------------------------------------===//
 
 def MaxUIOp : IntBinaryOp<"maxui"> {
   let summary = "unsigned integer maximum operation";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `maxui` ssa-use `,` ssa-use `:` type
     ```
 
     Returns the larger of %a and %b comparing the values as unsigned integers.
 
     Example:
 
     ```mlir
     // Scalar unsigned integer maximum.
     %a = maxui %b, %c : i64
     ```
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // MinFOp
 //===----------------------------------------------------------------------===//
 
 def MinFOp : FloatBinaryOp<"minf"> {
   let summary = "floating-point minimum operation";
let description = [{
 
     Example:
 
     ```mlir
     // Scalar signed integer minimum.
     %a = minsi %b, %c : i64
     ```
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // MinUIOp
 //===----------------------------------------------------------------------===//
 
 def MinUIOp : IntBinaryOp<"minui"> {
   let summary = "unsigned integer minimum operation";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `minui` ssa-use `,` ssa-use `:` type
     ```
 
     Returns the smaller of %a and %b comparing the values as unsigned integers.
 
     Example:
 
     ```mlir
     // Scalar unsigned integer minimum.
     %a = minui %b, %c : i64
     ```
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
 def RankOp : Std_Op<"rank", [NoSideEffect]> {
   let summary = "rank operation";

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

if (auto arrAttr = value.dyn_cast<ArrayAttr>()) {
     auto complexEltTy = complexTy.getElementType();
     return arrAttr.size() == 2 && arrAttr[0].getType() == complexEltTy &&
            arrAttr[1].getType() == complexEltTy;
   }
   return value.isa<UnitAttr>();
 }
 
 //===----------------------------------------------------------------------===//
+// MaxSIOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult MaxSIOp::fold(ArrayRef<Attribute> operands) {
+  assert(operands.size() == 2 && "binary operation takes two operands");
+
+  // maxsi(x,x) -> x
+  if (lhs() == rhs())
+    return rhs();
+
+  APInt intValue;
+  // maxsi(x,MAX_INT) -> MAX_INT
+  if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
+      intValue.isMaxSignedValue())
+    return rhs();
+
+  // maxsi(x, MIN_INT) -> x
+  if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
+      intValue.isMinSignedValue())
+    return lhs();
+
+  return constFoldBinaryOp<IntegerAttr>(
+      operands, [](APInt a, APInt b) { return llvm::APIntOps::smax(a, b); });
+}
+
+//===----------------------------------------------------------------------===//
+// MaxUIOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult MaxUIOp::fold(ArrayRef<Attribute> operands) {
+  assert(operands.size() == 2 && "binary operation takes two operands");
+
+  // maxui(x,x) -> x
+  if (lhs() == rhs())
+    return rhs();
+
+  APInt intValue;
+  // maxui(x,MAX_INT) -> MAX_INT
+  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
+    return rhs();
+
+  // maxui(x, MIN_INT) -> x
+  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
+    return lhs();
+
+  return constFoldBinaryOp<IntegerAttr>(
+      operands, [](APInt a, APInt b) { return llvm::APIntOps::umax(a, b); });
+}
+
+//===----------------------------------------------------------------------===//
+// MinSIOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult MinSIOp::fold(ArrayRef<Attribute> operands) {
+  assert(operands.size() == 2 && "binary operation takes two operands");
+
+  // minsi(x,x) -> x
+  if (lhs() == rhs())
+    return rhs();
+
+  APInt intValue;
+  // minsi(x,MIN_INT) -> MIN_INT
+  if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
+      intValue.isMinSignedValue())
+    return rhs();
+
+  // minsi(x, MAX_INT) -> x
+  if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
+      intValue.isMaxSignedValue())
+    return lhs();
+
+  return constFoldBinaryOp<IntegerAttr>(
+      operands, [](APInt a, APInt b) { return llvm::APIntOps::smin(a, b); });
+}
+
+//===----------------------------------------------------------------------===//
+// MinUIOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult MinUIOp::fold(ArrayRef<Attribute> operands) {
+  assert(operands.size() == 2 && "binary operation takes two operands");
+
+  // minui(x,x) -> x
+  if (lhs() == rhs())
+    return rhs();
+
+  APInt intValue;
+  // minui(x,MIN_INT) -> MIN_INT
+  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
+    return rhs();
+
+  // minui(x, MAX_INT) -> x
+  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
+    return lhs();
+
+  return constFoldBinaryOp<IntegerAttr>(
+      operands, [](APInt a, APInt b) { return llvm::APIntOps::umin(a, b); });
+}
+
+//===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult RankOp::fold(ArrayRef<Attribute> operands) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
   if (auto shapedType = type.dyn_cast<ShapedType>())
     if (shapedType.hasRank())

mlir/test/Dialect/Standard/canonicalize.mlir

 //       CHECK:       %[[trueval:.+]] = arith.constant true
 //       CHECK:       %{{.+}} = arith.xori %arg0, %[[trueval]] : i1
 func @selToNot(%arg0: i1) -> i1 {
   %true = arith.constant true
   %false = arith.constant false
   %res = select %arg0, %false, %true : i1
   return %res : i1
 }
+
+// CHECK-LABEL: test_maxsi
+// CHECK: %[[C0:.+]] = arith.constant 42
+// CHECK: %[[MAX_INT_CST:.+]] = arith.constant 127
+// CHECK: %[[X:.+]] = maxsi %arg0, %[[C0]]
+// CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]]
+func @test_maxsi(%arg0 : i8) -> (i8, i8, i8, i8) {
+  %maxIntCst = arith.constant 127 : i8
+  %minIntCst = arith.constant -128 : i8
+  %c0 = arith.constant 42 : i8
+  %0 = maxsi %arg0, %arg0 : i8
+  %1 = maxsi %arg0, %maxIntCst : i8
+  %2 = maxsi %arg0, %minIntCst : i8
+  %3 = maxsi %arg0, %c0 : i8
+  return %0, %1, %2, %3: i8, i8, i8, i8
+}
+
+// CHECK-LABEL: test_maxui
+// CHECK: %[[C0:.+]] = arith.constant 42
+// CHECK: %[[MAX_INT_CST:.+]] = arith.constant -1
+// CHECK: %[[X:.+]] = maxui %arg0, %[[C0]]
+// CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]]
+func @test_maxui(%arg0 : i8) -> (i8, i8, i8, i8) {
+  %maxIntCst = arith.constant 255 : i8
+  %minIntCst = arith.constant 0 : i8
+  %c0 = arith.constant 42 : i8
+  %0 = maxui %arg0, %arg0 : i8
+  %1 = maxui %arg0, %maxIntCst : i8
+  %2 = maxui %arg0, %minIntCst : i8
+  %3 = maxui %arg0, %c0 : i8
+  return %0, %1, %2, %3: i8, i8, i8, i8
+}
+
+
+// CHECK-LABEL: test_minsi
+// CHECK: %[[C0:.+]] = arith.constant 42
+// CHECK: %[[MIN_INT_CST:.+]] = arith.constant -128
+// CHECK: %[[X:.+]] = minsi %arg0, %[[C0]]
+// CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]]
+func @test_minsi(%arg0 : i8) -> (i8, i8, i8, i8) {
+  %maxIntCst = arith.constant 127 : i8
+  %minIntCst = arith.constant -128 : i8
+  %c0 = arith.constant 42 : i8
+  %0 = minsi %arg0, %arg0 : i8
+  %1 = minsi %arg0, %maxIntCst : i8
+  %2 = minsi %arg0, %minIntCst : i8
+  %3 = minsi %arg0, %c0 : i8
+  return %0, %1, %2, %3: i8, i8, i8, i8
+}
+
+// CHECK-LABEL: test_minui
+// CHECK: %[[C0:.+]] = arith.constant 42
+// CHECK: %[[MIN_INT_CST:.+]] = arith.constant 0
+// CHECK: %[[X:.+]] = minui %arg0, %[[C0]]
+// CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]]
+func @test_minui(%arg0 : i8) -> (i8, i8, i8, i8) {
+  %maxIntCst = arith.constant 255 : i8
+  %minIntCst = arith.constant 0 : i8
+  %c0 = arith.constant 42 : i8
+  %0 = minui %arg0, %arg0 : i8
+  %1 = minui %arg0, %maxIntCst : i8
+  %2 = minui %arg0, %minIntCst : i8
+  %3 = minui %arg0, %c0 : i8
+  return %0, %1, %2, %3: i8, i8, i8, i8
+}