[mlir] Add FPToSIOp to Standard dialect.

[hanchung]

Summary

Cast from a value interpreted as floating-point to the corresponding signed
integer value. Similar to an element-wise static_cast in C++, performs an
element-wise conversion operation.

[rriddle]

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

1553

This is a little light on semantics, i.e., what is the rounding mode? towards zero? Can you beef this up? I would expect it to at least cover the same beats as the llvm equivalent:
https://llvm.org/docs/LangRef.html#fptosi-to-instruction

[hanchung]

Address comments.

[hanchung]

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

1553

I was referring it in the later sentence, but it would be great to point it out directly. Fixed.

[mravishankar]

Looks good to me. Please wait for River to accept.

[antiagainst]

In D79373#2023053, @mravishankar wrote:

Looks good to me. Please wait for River to accept.

I think River's concerns were addressed. He is OOO for the next week; let's land this and we can always fix afterwards if he has more concerns.

[hanchung]

In D79373#2026852, @antiagainst wrote:

In D79373#2023053, @mravishankar wrote:

Looks good to me. Please wait for River to accept.

I think River's concerns were addressed. He is OOO for the next week; let's land this and we can always fix afterwards if he has more concerns.

Sounds good to me. @rriddle Feel free to ping me or leave comments here if there are other concerns. I'm happy to address them.

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

let extraClassDeclaration = [{
     /// the operation.
     static bool areCastCompatible(Type a, Type b);
   }];
 
   let hasFolder = 0;
 }
 
 //===----------------------------------------------------------------------===//
+// FPToSIOp
+//===----------------------------------------------------------------------===//
+
+def FPToSIOp : CastOp<"fptosi">, Arguments<(ins AnyType:$in)> {
+  let summary = "cast from floating-point type to integer type";
+  let description = [{
+    Cast from a value interpreted as floating-point to the nearest (rounding
+    towards zero) signed integer value.
+  }];
+
+  let extraClassDeclaration = [{
+    /// Return true if `a` and `b` are valid operand and result pairs for
+    /// the operation.
+    static bool areCastCompatible(Type a, Type b);
+  }];
+
+  let hasFolder = 0;
+}
+
+//===----------------------------------------------------------------------===//
 // FPTruncOp
 //===----------------------------------------------------------------------===//
 
 def FPTruncOp : CastOp<"fptrunc">, Arguments<(ins AnyType:$in)> {
   let summary = "cast from floating-point to narrower floating-point";
   let description = [{
     Truncate a floating-point value to a smaller floating-point-typed value.
     The destination type must be strictly narrower than the source type.

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

bool FPExtOp::areCastCompatible(Type a, Type b) {
   if (auto va = a.dyn_cast<VectorType>())
     if (auto vb = b.dyn_cast<VectorType>())
       return va.getShape().equals(vb.getShape()) &&
              areCastCompatible(va.getElementType(), vb.getElementType());
   return false;
 }
 
 //===----------------------------------------------------------------------===//
+// FPToSIOp
+//===----------------------------------------------------------------------===//
+
+bool FPToSIOp::areCastCompatible(Type a, Type b) {
+  return a.isa<FloatType>() && b.isSignlessInteger();
+}
+
+//===----------------------------------------------------------------------===//
 // FPTruncOp
 //===----------------------------------------------------------------------===//
 
 bool FPTruncOp::areCastCompatible(Type a, Type b) {
   if (auto fa = a.dyn_cast<FloatType>())
     if (auto fb = b.dyn_cast<FloatType>())
       return fa.getWidth() > fb.getWidth();
   if (auto va = a.dyn_cast<VectorType>())

mlir/test/IR/core-ops.mlir

^bb42(%t: tensor<4x4x?xf32>, %f: f32, %i: i32, %idx : index, %j: i64, %half: f16):
   %147 = sin %f : f32
 
   // CHECK: %{{[0-9]+}} = sin %cst_8 : vector<4xf32>
   %148 = sin %vcf32 : vector<4xf32>
 
   // CHECK: %{{[0-9]+}} = sin %arg0 : tensor<4x4x?xf32>
   %149 = sin %t : tensor<4x4x?xf32>
 
+  // CHECK: = fptosi {{.*}} : f32 to i32
+  %159 = fptosi %f : f32 to i32
+
+  // CHECK: = fptosi {{.*}} : f32 to i64
+  %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
+
   return
 }
 
 // CHECK-LABEL: func @affine_apply() {
 func @affine_apply() {
   %i = "std.constant"() {value = 0: index} : () -> index
   %j = "std.constant"() {value = 1: index} : () -> index