[MLIR]Add support for Arith MAX & MIN operations

[Leporacanthicus]

Summary

There are some of this supported in various places, but the
basic conversion of single operations to LLVM was not supported.

Adding this to allow Flang to use these.

[kiranchandramohan]

mlir/test/Conversion/ArithmeticToLLVM/arith-to-llvm.mlir

389–409

Do we have to test the vector version as well?
Do you know why intrinsics are used in the conversion instead of regular llvm instructions like llvm.minimum.*? Also, this seems to be the first place where llvm.intr instructions are used.

[bondhugula]

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

337–342

Not sure why this list was not sorted earlier but it'll be good to add these in sorted order.

mlir/test/Conversion/ArithmeticToLLVM/arith-to-llvm.mlir

391–406

Consider avoiding numbered SSA values in CHECK lines - although the use/scope is a bit limited here.

[Leporacanthicus]

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

337–342

I will submit a patch to get all of them in sorted order.

mlir/test/Conversion/ArithmeticToLLVM/arith-to-llvm.mlir

391–406

I was following the pattern in the test on the lines above this one.

It seems like most of the rest of the tests are also using direct numbers.

I'll take a look and see if I can fix up the whole lot.

[Leporacanthicus]

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

337–342

Sorting the table (and the declarations a few lines further up):
https://reviews.llvm.org/D132046

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

 using FPToUIOpLowering =
     VectorConvertToLLVMPattern<arith::FPToUIOp, LLVM::FPToUIOp>;
 using FPToSIOpLowering =
     VectorConvertToLLVMPattern<arith::FPToSIOp, LLVM::FPToSIOp>;
 using BitcastOpLowering =
     VectorConvertToLLVMPattern<arith::BitcastOp, LLVM::BitcastOp>;
 using SelectOpLowering =
     VectorConvertToLLVMPattern<arith::SelectOp, LLVM::SelectOp>;
+using MaxFOpLowering =
+    VectorConvertToLLVMPattern<arith::MaxFOp, LLVM::MaxNumOp>;
+using MaxSIOpLowering =
+    VectorConvertToLLVMPattern<arith::MaxSIOp, LLVM::SMaxOp>;
+using MaxUIOpLowering =
+    VectorConvertToLLVMPattern<arith::MaxUIOp, LLVM::UMaxOp>;
+using MinFOpLowering =
+    VectorConvertToLLVMPattern<arith::MinFOp, LLVM::MinNumOp>;
+using MinSIOpLowering =
+    VectorConvertToLLVMPattern<arith::MinSIOp, LLVM::SMinOp>;
+using MinUIOpLowering =
+    VectorConvertToLLVMPattern<arith::MinUIOp, LLVM::UMinOp>;
 
 //===----------------------------------------------------------------------===//
 // Op Lowering Patterns
 //===----------------------------------------------------------------------===//
 
 /// Directly lower to LLVM op.
 struct ConstantOpLowering : public ConvertOpToLLVMPattern<arith::ConstantOp> {
   using ConvertOpToLLVMPattern<arith::ConstantOp>::ConvertOpToLLVMPattern;
patterns.add<
     UIToFPOpLowering,
     SIToFPOpLowering,
     FPToUIOpLowering,
     FPToSIOpLowering,
     IndexCastOpLowering,
     BitcastOpLowering,
     CmpIOpLowering,
     CmpFOpLowering,
-    SelectOpLowering
+    SelectOpLowering,
+    MaxFOpLowering,
+    MaxUIOpLowering,
+    MaxSIOpLowering,
+    MinFOpLowering,
+    MinUIOpLowering,
+    MinSIOpLowering
   >(converter);
   // clang-format on
 }
 
 std::unique_ptr<Pass> mlir::arith::createConvertArithmeticToLLVMPass() {
   return std::make_unique<ConvertArithmeticToLLVMPass>();
 }

mlir/test/Conversion/ArithmeticToLLVM/arith-to-llvm.mlir

 // -----
 
 // CHECK-LABEL: @select
 func.func @select(%arg0 : i1, %arg1 : i32, %arg2 : i32) -> i32 {
   // CHECK: = llvm.select %arg0, %arg1, %arg2 : i1, i32
   %0 = arith.select %arg0, %arg1, %arg2 : i32
   return %0 : i32
 }
+
+// -----
+
+// CHECK-LABEL: @minmaxi
+func.func @minmaxi(%arg0 : i32, %arg1 : i32) -> i32 {
+  // CHECK: = "llvm.intr.smin"(%arg0, %arg1) : (i32, i32) -> i32
+  %0 = arith.minsi %arg0, %arg1 : i32
+  // CHECK: = "llvm.intr.smax"(%arg0, %arg1) : (i32, i32) -> i32
+  %1 = arith.maxsi %arg0, %arg1 : i32
+  // CHECK: = "llvm.intr.umin"(%arg0, %arg1) : (i32, i32) -> i32
+  %2 = arith.minui %arg0, %arg1 : i32
+  // CHECK: = "llvm.intr.umax"(%arg0, %arg1) : (i32, i32) -> i32
+  %3 = arith.maxui %arg0, %arg1 : i32
+  return %0 : i32
+}
+
+// CHECK-LABEL: @minmaxf
+func.func @minmaxf(%arg0 : f32, %arg1 : f32) -> f32 {
+  // CHECK: = "llvm.intr.minnum"(%arg0, %arg1) : (f32, f32) -> f32
+  %0 = arith.minf %arg0, %arg1 : f32
+  // CHECK: = "llvm.intr.maxnum"(%arg0, %arg1) : (f32, f32) -> f32
+  %1 = arith.maxf %arg0, %arg1 : f32
+  return %0 : f32
+}