[mlir][Standard] Add minf/maxf operations.

[herhut]

Summary

Having min and max on floats is useful for lowering to special
hardware intrinsics.

[ftynse]

Please document and test the semantics of these operations in presence of NaNs, and update docs/Rationale.md to mention why we have minf/maxf (presumably because they offer NaN-propagation semantics that cannot be expressed with a single cmpf+select).

[mehdi_amini]

So far we've consider these as easy to pattern match, anything changed here?

[ftynse]

In D82751#2121770, @mehdi_amini wrote:

So far we've consider these as easy to pattern match, anything changed here?

I think the intended semantics is to propagate NaNs, which can be implemented as various combinations of 4 operations that becomes less straightforward to match.

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

def Log10Op : FloatUnaryOp<"log10"> {
   let summary = "base-10 logarithm of the specified value";
 }
 
 def Log2Op : FloatUnaryOp<"log2"> {
   let summary = "base-2 logarithm of the specified value";
 }
 
 //===----------------------------------------------------------------------===//
+// MaxFOp
+//===----------------------------------------------------------------------===//
+
+def MaxFOp : FloatArithmeticOp<"maxf"> {
+  let summary = "floating point maximum operation";
+  let description = [{
+    Syntax:
+
+    ```
+    operation ::= ssa-id `=` `std.maxf` ssa-use `,` ssa-use `:` type
+    ```
+
+    The `maxf` operation takes two operands and returns one result, each of
+    these is required to be the same type. This type may be a floating point
+    scalar type, a vector whose element type is a floating point type, or a
+    floating point tensor.
+
+    Example:
+
+    ```mlir
+    // Scalar maximum.
+    %a = maxf %b, %c : f64
+
+    // SIMD pointwise vector maximum, e.g. for Intel SSE.
+    %f = maxf %g, %h : vector<4xf32>
+
+    // Tensor pointwise maximum.
+    %x = maxf %y, %z : tensor<4x?xbf16>
+    ```
+
+    TODO: In the distant future, this will accept optional attributes for fast
+    math, contraction, rounding mode, and other controls.
+  }];
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // MemRefCastOp
 //===----------------------------------------------------------------------===//
 
 def MemRefCastOp : CastOp<"memref_cast"> {
   let summary = "memref cast operation";
   let description = [{
     Syntax:
 
let extraClassDeclaration = [{
     static bool areCastCompatible(Type a, Type b);
 
     /// The result of a memref_cast is always a memref.
     Type getType() { return getResult().getType(); }
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// MinFOp
+//===----------------------------------------------------------------------===//
+
+def MinFOp : FloatArithmeticOp<"minf"> {
+  let summary = "floating point minimum operation";
+  let description = [{
+    Syntax:
+
+    ```
+    operation ::= ssa-id `=` `std.minf` ssa-use `,` ssa-use `:` type
+    ```
+
+    The `minf` operation takes two operands and returns one result, each of
+    these is required to be the same type. This type may be a floating point
+    scalar type, a vector whose element type is a floating point type, or a
+    floating point tensor.
+
+    Example:
+
+    ```mlir
+    // Scalar minimum.
+    %a = minf %b, %c : f64
+
+    // SIMD pointwise vector minimum, e.g. for Intel SSE.
+    %f = minf %g, %h : vector<4xf32>
+
+    // Tensor pointwise minimum.
+    %x = minf %y, %z : tensor<4x?xbf16>
+    ```
+
+    TODO: In the distant future, this will accept optional attributes for fast
+    math, contraction, rounding mode, and other controls.
+  }];
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // MulFOp
 //===----------------------------------------------------------------------===//
 
 def MulFOp : FloatArithmeticOp<"mulf"> {
   let summary = "floating point multiplication operation";
   let description = [{
     Syntax:
 

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

 OpFoldResult LoadOp::fold(ArrayRef<Attribute> cstOperands) {
   /// load(memrefcast) -> load
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return OpFoldResult();
 }
 
 //===----------------------------------------------------------------------===//
+// MaxFOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult MaxFOp::fold(ArrayRef<Attribute> operands) {
+  return constFoldBinaryOp<FloatAttr>(
+      operands, [](APFloat a, APFloat b) { return std::max(a, b); });
+}
+
+//===----------------------------------------------------------------------===//
 // MemRefCastOp
 //===----------------------------------------------------------------------===//
 
 bool MemRefCastOp::areCastCompatible(Type a, Type b) {
   auto aT = a.dyn_cast<MemRefType>();
   auto bT = b.dyn_cast<MemRefType>();
 
   auto uaT = a.dyn_cast<UnrankedMemRefType>();
bool MemRefCastOp::areCastCompatible(Type a, Type b) {
   return false;
 }
 
 OpFoldResult MemRefCastOp::fold(ArrayRef<Attribute> operands) {
   return impl::foldCastOp(*this);
 }
 
 //===----------------------------------------------------------------------===//
+// MinFOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult MinFOp::fold(ArrayRef<Attribute> operands) {
+  return constFoldBinaryOp<FloatAttr>(
+      operands, [](APFloat a, APFloat b) { return std::min(a, b); });
+}
+
+//===----------------------------------------------------------------------===//
 // MulFOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MulFOp::fold(ArrayRef<Attribute> operands) {
   return constFoldBinaryOp<FloatAttr>(
       operands, [](APFloat a, APFloat b) { return a * b; });
 }
 

mlir/test/IR/core-ops.mlir

^bb42(%t: tensor<4x4x?xf32>, %f: f32, %i: i32, %idx : index, %j: i64, %half: f16):
   %160 = fptosi %f : f32 to i64
 
   // CHECK: = fptosi {{.*}} : f16 to i32
   %161 = fptosi %half : f16 to i32
 
   // CHECK: = fptosi {{.*}} : f16 to i64
   %162 = fptosi %half : f16 to i64
 
+  // CHECK: %[[F6:.*]] = minf %[[F2]], %[[F2]] : f32
+  %163 = minf %f2, %f2 : f32
+
+  // CHECK: %[[F6:.*]] = maxf %[[F2]], %[[F2]] : f32
+  %164 = maxf %f2, %f2 : f32
+
   return
 }
 
 // CHECK-LABEL: func @affine_apply() {
 func @affine_apply() {
   %i = "std.constant"() {value = 0: index} : () -> index
   %j = "std.constant"() {value = 1: index} : () -> index
 

mlir/test/Transforms/constant-fold.mlir

func @affine_apply(%variable : index) -> (index, index, index) {
   %y = affine.apply affine_map<(d0) -> (42)> (%variable)
 
   // CHECK: return [[C1159]], [[C1152]], [[C42]]
   return %x0, %x1, %y : index, index, index
 }
 
 // -----
 
+// CHECK-LABEL: func @simple_maxf
+func @simple_maxf() -> f32 {
+  %0 = constant 4.5 : f32
+  %1 = constant 1.5 : f32
+
+  // CHECK-NEXT: [[C:%.+]] = constant 4.5{{0*}}e+00 : f32
+  %2 = maxf %0, %1 : f32
+
+  // CHECK-NEXT: return [[C]]
+  return %2 : f32
+}
+
+// -----
+
+// CHECK-LABEL: func @maxf_splat_tensor
+func @maxf_splat_tensor() -> tensor<4xf32> {
+  %0 = constant dense<4.5> : tensor<4xf32>
+  %1 = constant dense<1.5> : tensor<4xf32>
+
+  // CHECK-NEXT: [[C:%.+]] = constant dense<4.5{{0*}}e+00> : tensor<4xf32>
+  %2 = maxf %0, %1 : tensor<4xf32>
+
+  // CHECK-NEXT: return [[C]]
+  return %2 : tensor<4xf32>
+}
+
+// -----
+
+// CHECK-LABEL: func @simple_minf
+func @simple_minf() -> f32 {
+  %0 = constant 4.5 : f32
+  %1 = constant 1.5 : f32
+
+  // CHECK-NEXT: [[C:%.+]] = constant 1.5{{0*}}e+00 : f32
+  %2 = minf %0, %1 : f32
+
+  // CHECK-NEXT: return [[C]]
+  return %2 : f32
+}
+
+// -----
+
+// CHECK-LABEL: func @minf_splat_tensor
+func @minf_splat_tensor() -> tensor<4xf32> {
+  %0 = constant dense<4.5> : tensor<4xf32>
+  %1 = constant dense<1.5> : tensor<4xf32>
+
+  // CHECK-NEXT: [[C:%.+]] = constant dense<1.5{{0*}}e+00> : tensor<4xf32>
+  %2 = minf %0, %1 : tensor<4xf32>
+
+  // CHECK-NEXT: return [[C]]
+  return %2 : tensor<4xf32>
+}
+
+// -----
+
 // CHECK-LABEL: func @simple_mulf
 func @simple_mulf() -> f32 {
   %0 = constant 4.5 : f32
   %1 = constant 1.5 : f32
 
   // CHECK-NEXT: [[C:%.+]] = constant 6.75{{0*}}e+00 : f32
   %2 = mulf %0, %1 : f32