Implement FPToUI and UIToFP ops in standard dialect

[mars1026]

Summary

Add the unsigned complements to the existing FPToSI and SIToFP operations in the
standard dialect, with one-to-one lowerings to the corresponding LLVM operations.

[ftynse]

Please post an RFC at https://llvm.discourse.group for any additions to the standard dialect.

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

1787

MLIR supports unsigned integers natively, why is this restricted to signless integers only?

[mars1026]

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

1787

Consistency with the existing FPToSIOp, which only applies to conversions between floats and signless integers. It would make sense to me that FPToSIOp should also accept signed integer types, and FPToUIOp should accept unsigned integers, but that would expand the scope of this proposal.

[rriddle]

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

1787

The standard dialect does not operate on signed/unsigned types, it is explicitly signless.

https://mlir.llvm.org/docs/Rationale/Rationale/#integer-signedness-semantics

[flaub]

Friendly poke, wondering what the status of this is. Looks like we have an RFC here https://llvm.discourse.group/t/rfc-standard-add-std-fptoui-and-std-uitofp-operations/1567. AFAICT, there aren't any outstanding issues. This is a required op for certain situations. Because the standard dialect only deals with 'signless' integers, we must be able to reintroduce signedness in a few key areas, one of them being casts, otherwise we get incorrect behavior (we've run into this in real-world situations).

[flaub]

Thanks @ftynse :)

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

let extraClassDeclaration = [{
     /// the operation.
     static bool areCastCompatible(Type a, Type b);
   }];
 
   let hasFolder = 0;
 }
 
 //===----------------------------------------------------------------------===//
+// FPToUIOp
+//===----------------------------------------------------------------------===//
+
+def FPToUIOp : CastOp<"fptoui">, 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) unsigned 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.
let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
     return printStandardCastOp(this->getOperation(), p);
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// UIToFPOp
+//===----------------------------------------------------------------------===//
+
+def UIToFPOp : CastOp<"uitofp">, Arguments<(ins AnyType:$in)> {
+  let summary = "cast from unsigned integer type to floating-point";
+  let description = [{
+    Cast from a value interpreted as unsigned integer to the corresponding
+    floating-point value. If the value cannot be exactly represented, it is
+    rounded using the default rounding mode. Only scalars are currently
+    supported.
+  }];
+
+  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;
+}
+
+//===----------------------------------------------------------------------===//
 // UnsignedDivIOp
 //===----------------------------------------------------------------------===//
 
 def UnsignedDivIOp : IntArithmeticOp<"divi_unsigned"> {
   let summary = "unsigned integer division operation";
   let description = [{
     Syntax:
     ```

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

struct CmpFOpLowering : public ConvertOpToLLVMPattern<CmpFOp> {
   }
 };
 
 struct SIToFPLowering
     : public OneToOneConvertToLLVMPattern<SIToFPOp, LLVM::SIToFPOp> {
   using Super::Super;
 };
 
+struct UIToFPLowering
+    : public OneToOneConvertToLLVMPattern<UIToFPOp, LLVM::UIToFPOp> {
+  using Super::Super;
+};
+
 struct FPExtLowering
     : public OneToOneConvertToLLVMPattern<FPExtOp, LLVM::FPExtOp> {
   using Super::Super;
 };
 
 struct FPToSILowering
     : public OneToOneConvertToLLVMPattern<FPToSIOp, LLVM::FPToSIOp> {
   using Super::Super;
 };
 
+struct FPToUILowering
+    : public OneToOneConvertToLLVMPattern<FPToUIOp, LLVM::FPToUIOp> {
+  using Super::Super;
+};
+
 struct FPTruncLowering
     : public OneToOneConvertToLLVMPattern<FPTruncOp, LLVM::FPTruncOp> {
   using Super::Super;
 };
 
 struct SignExtendIOpLowering
     : public OneToOneConvertToLLVMPattern<SignExtendIOp, LLVM::SExtOp> {
   using Super::Super;
patterns.insert<
       Exp2OpLowering,
       FloorFOpLowering,
       GenericAtomicRMWOpLowering,
       LogOpLowering,
       Log10OpLowering,
       Log2OpLowering,
       FPExtLowering,
       FPToSILowering,
+      FPToUILowering,
       FPTruncLowering,
       ImOpLowering,
       IndexCastOpLowering,
       MulFOpLowering,
       MulIOpLowering,
       NegFOpLowering,
       OrOpLowering,
       PrefetchOpLowering,
patterns.insert<
       SinOpLowering,
       SplatOpLowering,
       SplatNdOpLowering,
       SqrtOpLowering,
       SubCFOpLowering,
       SubFOpLowering,
       SubIOpLowering,
       TruncateIOpLowering,
+      UIToFPLowering,
       UnsignedDivIOpLowering,
       UnsignedRemIOpLowering,
       UnsignedShiftRightOpLowering,
       XOrOpLowering,
       ZeroExtendIOpLowering>(converter);
   // clang-format on
 }
 

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

 // FPToSIOp
 //===----------------------------------------------------------------------===//
 
 bool FPToSIOp::areCastCompatible(Type a, Type b) {
   return a.isa<FloatType>() && b.isSignlessInteger();
 }
 
 //===----------------------------------------------------------------------===//
+// FPToUIOp
+//===----------------------------------------------------------------------===//
+
+bool FPToUIOp::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>())
OpFoldResult SubIOp::fold(ArrayRef<Attribute> operands) {
   if (matchPattern(rhs(), m_Zero()))
     return lhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a - b; });
 }
 
 //===----------------------------------------------------------------------===//
+// UIToFPOp
+//===----------------------------------------------------------------------===//
+
+// uitofp is applicable from integer types to float types.
+bool UIToFPOp::areCastCompatible(Type a, Type b) {
+  return a.isSignlessInteger() && b.isa<FloatType>();
+}
+
+//===----------------------------------------------------------------------===//
 // SubViewOp
 //===----------------------------------------------------------------------===//
 
 /// Print a list with either (1) the static integer value in `arrayAttr` if
 /// `isDynamic` evaluates to false or (2) the next value otherwise.
 /// This allows idiomatic printing of mixed value and integer attributes in a
 /// list. E.g. `[%arg0, 7, 42, %arg42]`.
 static void printSubViewListOfOperandsOrIntegers(

mlir/test/Conversion/StandardToLLVM/convert-to-llvmir.mlir

 func @index_cast(%arg0: index, %arg1: i1) {
 // CHECK-NEXT: = llvm.trunc %arg0 : !llvm.i{{.*}} to !llvm.i1
   %0 = index_cast %arg0: index to i1
 // CHECK-NEXT: = llvm.sext %arg1 : !llvm.i1 to !llvm.i{{.*}}
   %1 = index_cast %arg1: i1 to index
   return
 }
 
-// Checking conversion of integer types to floating point.
+// Checking conversion of signed integer types to floating point.
 // CHECK-LABEL: @sitofp
 func @sitofp(%arg0 : i32, %arg1 : i64) {
 // CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.i32 to !llvm.float
   %0 = sitofp %arg0: i32 to f32
 // CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.i32 to !llvm.double
   %1 = sitofp %arg0: i32 to f64
 // CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.i64 to !llvm.float
   %2 = sitofp %arg1: i64 to f32
 // CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.i64 to !llvm.double
   %3 = sitofp %arg1: i64 to f64
   return
 }
 
+// Checking conversion of unsigned integer types to floating point.
+// CHECK-LABEL: @uitofp
+func @uitofp(%arg0 : i32, %arg1 : i64) {
+// CHECK-NEXT: = llvm.uitofp {{.*}} : !llvm.i32 to !llvm.float
+  %0 = uitofp %arg0: i32 to f32
+// CHECK-NEXT: = llvm.uitofp {{.*}} : !llvm.i32 to !llvm.double
+  %1 = uitofp %arg0: i32 to f64
+// CHECK-NEXT: = llvm.uitofp {{.*}} : !llvm.i64 to !llvm.float
+  %2 = uitofp %arg1: i64 to f32
+// CHECK-NEXT: = llvm.uitofp {{.*}} : !llvm.i64 to !llvm.double
+  %3 = uitofp %arg1: i64 to f64
+  return
+}
+
 // Checking conversion of integer types to floating point.
 // CHECK-LABEL: @fpext
 func @fpext(%arg0 : f16, %arg1 : f32) {
 // CHECK-NEXT: = llvm.fpext {{.*}} : !llvm.half to !llvm.float
   %0 = fpext %arg0: f16 to f32
 // CHECK-NEXT: = llvm.fpext {{.*}} : !llvm.half to !llvm.double
   %1 = fpext %arg0: f16 to f64
 // CHECK-NEXT: = llvm.fpext {{.*}} : !llvm.float to !llvm.double
// CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.float to !llvm.i64
   %1 = fptosi %arg0: f32 to i64
 // CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.double to !llvm.i32
   %2 = fptosi %arg1: f64 to i32
 // CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.double to !llvm.i64
   %3 = fptosi %arg1: f64 to i64
   return
 }
 
+// Checking conversion of floating point to integer types.
+// CHECK-LABEL: @fptoui
+func @fptoui(%arg0 : f32, %arg1 : f64) {
+// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.float to !llvm.i32
+  %0 = fptoui %arg0: f32 to i32
+// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.float to !llvm.i64
+  %1 = fptoui %arg0: f32 to i64
+// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.double to !llvm.i32
+  %2 = fptoui %arg1: f64 to i32
+// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.double to !llvm.i64
+  %3 = fptoui %arg1: f64 to i64
+  return
+}
+
+
 // Checking conversion of integer types to floating point.
 // CHECK-LABEL: @fptrunc
 func @fptrunc(%arg0 : f32, %arg1 : f64) {
 // CHECK-NEXT: = llvm.fptrunc {{.*}} : !llvm.float to !llvm.half
   %0 = fptrunc %arg0: f32 to f16
 // CHECK-NEXT: = llvm.fptrunc {{.*}} : !llvm.double to !llvm.half
   %1 = fptrunc %arg1: f64 to f16
 // CHECK-NEXT: = llvm.fptrunc {{.*}} : !llvm.double to !llvm.float