[mlir][Index] Add index.mins and index.minu

[krzysz00]

Summary

Signed and unsigned minimum operations were missing from the Index
dialect and are needed to test integer range inference.

[Mogball]

thank

mlir/include/mlir/Dialect/Index/IR/IndexOps.td

let description = [{
     ```mlir
     // c = max(a, b)
     %c = index.maxu %a, %b
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// MinSOp
+//===----------------------------------------------------------------------===//
+
+def Index_MinSOp : IndexBinaryOp<"mins"> {
+  let summary = "index signed minimum";
+  let description = [{
+    The `index.mins` operation takes two index values and computes their signed
+    minimum value. Treats the leading bit as the sign, i.e. `min(-2, 6) = -2`.
+
+    Example:
+
+    ```mlir
+    // c = min(a, b)
+    %c = index.mins %a, %b
+    ```
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// MinUOp
+//===----------------------------------------------------------------------===//
+
+def Index_MinUOp : IndexBinaryOp<"minu"> {
+  let summary = "index unsigned minimum";
+  let description = [{
+    The `index.minu` operation takes two index values and computes their
+    unsigned minimum value. Treats the leading bit as the most significant, i.e.
+    `min(15, 6) = 6` or `min(-2, 6) = 6`.
+
+    Example:
+
+    ```mlir
+    // c = min(a, b)
+    %c = index.minu %a, %b
+    ```
+  }];
+}
+
+//===----------------------------------------------------------------------===//
 // ShlOp
 //===----------------------------------------------------------------------===//
 
 def Index_ShlOp : IndexBinaryOp<"shl"> {
   let summary = "index shift left";
   let description = [{
     The `index.shl` operation shifts an index value to the left by a variable
     amount. The low order bits are filled with zeroes. The RHS operand is always

mlir/lib/Conversion/IndexToLLVM/IndexToLLVM.cpp

 using ConvertIndexRemS =
     mlir::OneToOneConvertToLLVMPattern<RemSOp, LLVM::SRemOp>;
 using ConvertIndexRemU =
     mlir::OneToOneConvertToLLVMPattern<RemUOp, LLVM::URemOp>;
 using ConvertIndexMaxS =
     mlir::OneToOneConvertToLLVMPattern<MaxSOp, LLVM::SMaxOp>;
 using ConvertIndexMaxU =
     mlir::OneToOneConvertToLLVMPattern<MaxUOp, LLVM::UMaxOp>;
+using ConvertIndexMinS =
+    mlir::OneToOneConvertToLLVMPattern<MinSOp, LLVM::SMinOp>;
+using ConvertIndexMinU =
+    mlir::OneToOneConvertToLLVMPattern<MinUOp, LLVM::UMinOp>;
 using ConvertIndexShl = mlir::OneToOneConvertToLLVMPattern<ShlOp, LLVM::ShlOp>;
 using ConvertIndexShrS =
     mlir::OneToOneConvertToLLVMPattern<ShrSOp, LLVM::AShrOp>;
 using ConvertIndexShrU =
     mlir::OneToOneConvertToLLVMPattern<ShrUOp, LLVM::LShrOp>;
 using ConvertIndexAnd = mlir::OneToOneConvertToLLVMPattern<AndOp, LLVM::AndOp>;
 using ConvertIndexOr = mlir::OneToOneConvertToLLVMPattern<OrOp, LLVM::OrOp>;
 using ConvertIndexXor = mlir::OneToOneConvertToLLVMPattern<XOrOp, LLVM::XOrOp>;
patterns.insert<
       ConvertIndexSub,
       ConvertIndexMul,
       ConvertIndexDivS,
       ConvertIndexDivU,
       ConvertIndexRemS,
       ConvertIndexRemU,
       ConvertIndexMaxS,
       ConvertIndexMaxU,
+      ConvertIndexMinS,
+      ConvertIndexMinU,
       ConvertIndexShl,
       ConvertIndexShrS,
       ConvertIndexShrU,
       ConvertIndexAnd,
       ConvertIndexOr,
       ConvertIndexXor,
       ConvertIndexCeilDivS,
       ConvertIndexCeilDivU,

mlir/lib/Dialect/Index/IR/IndexOps.cpp

 
 OpFoldResult MaxUOp::fold(ArrayRef<Attribute> operands) {
   return foldBinaryOpChecked(operands, [](const APInt &lhs, const APInt &rhs) {
     return lhs.ugt(rhs) ? lhs : rhs;
   });
 }
 
 //===----------------------------------------------------------------------===//
+// MinSOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult MinSOp::fold(ArrayRef<Attribute> operands) {
+  return foldBinaryOpChecked(operands, [](const APInt &lhs, const APInt &rhs) {
+    return lhs.slt(rhs) ? lhs : rhs;
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// MinUOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult MinUOp::fold(ArrayRef<Attribute> operands) {
+  return foldBinaryOpChecked(operands, [](const APInt &lhs, const APInt &rhs) {
+    return lhs.ult(rhs) ? lhs : rhs;
+  });
+}
+
+//===----------------------------------------------------------------------===//
 // ShlOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult ShlOp::fold(ArrayRef<Attribute> operands) {
   return foldBinaryOpUnchecked(
       operands, [](const APInt &lhs, const APInt &rhs) -> Optional<APInt> {
         // We cannot fold if the RHS is greater than or equal to 32 because
         // this would be UB in 32-bit systems but not on 64-bit systems. RHS is

mlir/test/Conversion/IndexToLLVM/index-to-llvm.mlir

func.func @trivial_ops(%a: index, %b: index) {
   // CHECK: llvm.srem
   %5 = index.rems %a, %b
   // CHECK: llvm.urem
   %6 = index.remu %a, %b
   // CHECK: llvm.intr.smax
   %7 = index.maxs %a, %b
   // CHECK: llvm.intr.umax
   %8 = index.maxu %a, %b
+  // CHECK: llvm.intr.smin
+  %9 = index.mins %a, %b
+  // CHECK: llvm.intr.umin
+  %10 = index.minu %a, %b
   // CHECK: llvm.shl
-  %9 = index.shl %a, %b
+  %11 = index.shl %a, %b
   // CHECK: llvm.ashr
-  %10 = index.shrs %a, %b
+  %12 = index.shrs %a, %b
   // CHECK: llvm.lshr
-  %11 = index.shru %a, %b
+  %13 = index.shru %a, %b
   // CHECK: llvm.add
-  %12 = index.add %a, %b
+  %14 = index.add %a, %b
   // CHECK: llvm.or
-  %13 = index.or %a, %b
+  %15 = index.or %a, %b
   // CHECK: llvm.xor
-  %14 = index.xor %a, %b
+  %16 = index.xor %a, %b
   // CHECK: llvm.mlir.constant(true
-  %15 = index.bool.constant true
+  %17 = index.bool.constant true
   return
 }
 
 // CHECK-LABEL: @ceildivs
 // CHECK-SAME: %[[NI:.*]]: index, %[[MI:.*]]: index
 func.func @ceildivs(%n: index, %m: index) -> index {
   // CHECK: %[[N:.*]] = builtin.unrealized_conversion_cast %[[NI]]
   // CHECK: %[[M:.*]] = builtin.unrealized_conversion_cast %[[MI]]

mlir/test/Dialect/Index/index-canonicalize.mlir

func.func @maxu() -> index {
   %lhs = index.constant -1
   %rhs = index.constant 1
   // CHECK: %[[A:.*]] = index.constant -1
   %0 = index.maxu %lhs, %rhs
   // CHECK: return %[[A]]
   return %0 : index
 }
 
+// CHECK-LABEL: @mins
+func.func @mins() -> index {
+  %lhs = index.constant -4
+  %rhs = index.constant 2
+  // CHECK: %[[A:.*]] = index.constant -4
+  %0 = index.mins %lhs, %rhs
+  // CHECK: return %[[A]]
+  return %0 : index
+}
+
+// CHECK-LABEL: @mins_nofold
+func.func @mins_nofold() -> index {
+  %lhs = index.constant 1
+  %rhs = index.constant 0x100000000
+  // 32-bit result differs from 64-bit.
+  // CHECK: index.mins
+  %0 = index.mins %lhs, %rhs
+  return %0 : index
+}
+
+// CHECK-LABEL: @mins_nofold_2
+func.func @mins_nofold_2() -> index {
+  %lhs = index.constant 0x7fffffff
+  %rhs = index.constant 0x80000000
+  // 32-bit result differs from 64-bit.
+  // CHECK: index.mins
+  %0 = index.mins %lhs, %rhs
+  return %0 : index
+}
+
+// CHECK-LABEL: @minu
+func.func @minu() -> index {
+  %lhs = index.constant -1
+  %rhs = index.constant 1
+  // CHECK: %[[A:.*]] = index.constant 1
+  %0 = index.minu %lhs, %rhs
+  // CHECK: return %[[A]]
+  return %0 : index
+}
+
 // CHECK-LABEL: @shl
 func.func @shl() -> index {
   %lhs = index.constant 128
   %rhs = index.constant 2
   // CHECK: %[[A:.*]] = index.constant 512
   %0 = index.shl %lhs, %rhs
   // CHECK: return %[[A]]
   return %0 : index

mlir/test/Dialect/Index/index-ops.mlir

func.func @binary_ops(%a: index, %b: index) {
   // CHECK-NEXT: index.rems %[[A]], %[[B]]
   %8 = index.rems %a, %b
   // CHECK-NEXT: index.remu %[[A]], %[[B]]
   %9 = index.remu %a, %b
   // CHECK-NEXT: index.maxs %[[A]], %[[B]]
   %10 = index.maxs %a, %b
   // CHECK-NEXT: index.maxu %[[A]], %[[B]]
   %11 = index.maxu %a, %b
+  // CHECK-NEXT: index.mins %[[A]], %[[B]]
+  %12 = index.mins %a, %b
+  // CHECK-NEXT: index.minu %[[A]], %[[B]]
+  %13 = index.minu %a, %b
   // CHECK-NEXT: index.shl %[[A]], %[[B]]
-  %12 = index.shl %a, %b
+  %14 = index.shl %a, %b
   // CHECK-NEXT: index.shrs %[[A]], %[[B]]
-  %13 = index.shrs %a, %b
+  %15 = index.shrs %a, %b
   // CHECK-NEXT: index.shru %[[A]], %[[B]]
-  %14 = index.shru %a, %b
+  %16 = index.shru %a, %b
   // CHECK-NEXT: index.and %[[A]], %[[B]]
-  %15 = index.and %a, %b
+  %17 = index.and %a, %b
   // CHECK-NEXT: index.or %[[A]], %[[B]]
-  %16 = index.or %a, %b
+  %18 = index.or %a, %b
   // CHECK-NEXT: index.xor %[[A]], %[[B]]
-  %17 = index.xor %a, %b
+  %19 = index.xor %a, %b
   return
 }
 
 // CHECK-LABEL: @cmp_op
 // CHECK-SAME: %[[A:.*]]: index, %[[B:.*]]: index
 func.func @cmp_op(%a: index, %b: index) {
   // CHECK-NEXT: index.cmp eq(%[[A]], %[[B]])
   %0 = index.cmp eq(%a, %b)