[MLIR] Add constant folder for fptosi and friends

[wsmoses]

Summary

This patch adds constant folds for FPToSI/FPToUI/SIToFP/UIToFP

[mehdi_amini]

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

891

The doc for UIToFPOp says "rounded using the default rounding mode", I haven't found where is the "default rounding mode" defined?

(the FPToUI are well defined)

961

Can you add tests for the invalid case here?

[wsmoses]

Add tests where conversion is not applied

[wsmoses]

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

891

I wasn't entirely sure either (besides a potential runtime CPU flag).

LLVM itself has a similar ambiguity (https://llvm.org/docs/LangRef.html#uitofp-to-instruction), though uses the same conversion (https://llvm.org/doxygen/ConstantFold_8cpp_source.html#l00477).

[bondhugula]

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

910

929

956

mlir/test/Dialect/Arithmetic/canonicalize.mlir

490

Nit: please use snake case in function names to be consistent with other test cases.

[wsmoses]

Address nits

[bondhugula]

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

953

Please use camelBack. All of these lead to clang-tidy warnings with code completion engines and several editor environments masking other actionable warnings. You have numerous PascalCase variables mixed here and above.

[wsmoses]

Address style nits

[wsmoses]

Fix clang-tidy

[bondhugula]

LGTM - please do wait for Mehdi's feedback before merging this is.

[mehdi_amini]

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

891

OK I dug into this, and it comes from IEEE 754. It'd be nice if this was acknowledged in the doc though...

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

 def Arith_UIToFPOp : Arith_IToFCastOp<"uitofp"> {
   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. When operating on vectors, casts
     elementwise.
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SIToFPOp
 //===----------------------------------------------------------------------===//
 
 def Arith_SIToFPOp : Arith_IToFCastOp<"sitofp"> {
   let summary = "cast from integer type to floating-point";
   let description = [{
     Cast from a value interpreted as a signed integer to the corresponding
     floating-point value. If the value cannot be exactly represented, it is
     rounded using the default rounding mode. When operating on vectors, casts
     elementwise.
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // FPToUIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_FPToUIOp : Arith_FToICastOp<"fptoui"> {
   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. When operating on vectors, casts
     elementwise.
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // FPToSIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_FPToSIOp : Arith_FToICastOp<"fptosi"> {
   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. When operating on vectors, casts
     elementwise.
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // IndexCastOp
 //===----------------------------------------------------------------------===//
 
 // Index cast can convert between memrefs of signless integers and indices too.
 def IndexCastTypeConstraint : TypeConstraint<Or<[

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

 //===- ArithmeticOps.cpp - MLIR Arithmetic dialect ops implementation -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/CommonFolders.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 
+#include "llvm/ADT/APSInt.h"
+
 using namespace mlir;
 using namespace mlir::arith;
 
 //===----------------------------------------------------------------------===//
 // Pattern helpers
 //===----------------------------------------------------------------------===//
 
 static IntegerAttr addIntegerAttrs(PatternRewriter &builder, Value res,

 //===----------------------------------------------------------------------===//
 // UIToFPOp
 //===----------------------------------------------------------------------===//
 
 bool arith::UIToFPOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkIntFloatCast<IntegerType, FloatType>(inputs, outputs);
 }
 
+OpFoldResult arith::UIToFPOp::fold(ArrayRef<Attribute> operands) {
+  if (auto lhs = operands[0].dyn_cast_or_null<IntegerAttr>()) {
+    const APInt &api = lhs.getValue();
+    FloatType FT = getType().cast<FloatType>();
+    APFloat apf(FT.getFloatSemantics(), APInt::getZero(FT.getWidth()));
+    apf.convertFromAPInt(api, /*signed*/ false, APFloat::rmNearestTiesToEven);
+    return FloatAttr::get(FT, apf);
+  }
+  return {};
+}
+
 //===----------------------------------------------------------------------===//
 // SIToFPOp
 //===----------------------------------------------------------------------===//
 
 bool arith::SIToFPOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkIntFloatCast<IntegerType, FloatType>(inputs, outputs);
 }
 
+OpFoldResult arith::SIToFPOp::fold(ArrayRef<Attribute> operands) {
+  if (auto lhs = operands[0].dyn_cast_or_null<IntegerAttr>()) {
+    const APInt &api = lhs.getValue();
+    FloatType FT = getType().cast<FloatType>();
+    APFloat apf(FT.getFloatSemantics(), APInt::getZero(FT.getWidth()));
+    apf.convertFromAPInt(api, /*signed*/ true, APFloat::rmNearestTiesToEven);
+    return FloatAttr::get(FT, apf);
+  }
+  return {};
+}
 //===----------------------------------------------------------------------===//
 // FPToUIOp
 //===----------------------------------------------------------------------===//
 
 bool arith::FPToUIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkIntFloatCast<FloatType, IntegerType>(inputs, outputs);
 }
 
+OpFoldResult arith::FPToUIOp::fold(ArrayRef<Attribute> operands) {
+  if (auto lhs = operands[0].dyn_cast_or_null<FloatAttr>()) {
+    const APFloat &V = lhs.getValue();
+    IntegerType IT = getType().cast<IntegerType>();
+    bool ignored;
+    uint32_t DestBitWidth = IT.getWidth();
+    APSInt IntVal(DestBitWidth, /*unsigned*/ true);
+    if (APFloat::opInvalidOp ==
+        V.convertToInteger(IntVal, APFloat::rmTowardZero, &ignored)) {
+      // Undefined behavior invoked - the destination type can't represent
+      // the input constant.
+      return {};
+    }
+    return IntegerAttr::get(getType(), IntVal);
+  }
+
+  return {};
+}
+
 //===----------------------------------------------------------------------===//
 // FPToSIOp
 //===----------------------------------------------------------------------===//
 
 bool arith::FPToSIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkIntFloatCast<FloatType, IntegerType>(inputs, outputs);
 }
 
+OpFoldResult arith::FPToSIOp::fold(ArrayRef<Attribute> operands) {
+  if (auto lhs = operands[0].dyn_cast_or_null<FloatAttr>()) {
+    const APFloat &V = lhs.getValue();
+    IntegerType IT = getType().cast<IntegerType>();
+    bool ignored;
+    uint32_t DestBitWidth = IT.getWidth();
+    APSInt IntVal(DestBitWidth, /*unsigned*/ false);
+    if (APFloat::opInvalidOp ==
+        V.convertToInteger(IntVal, APFloat::rmTowardZero, &ignored)) {
+      // Undefined behavior invoked - the destination type can't represent
+      // the input constant.
+      return {};
+    }
+    return IntegerAttr::get(getType(), IntVal);
+  }
+
+  return {};
+}
+
 //===----------------------------------------------------------------------===//
 // IndexCastOp
 //===----------------------------------------------------------------------===//
 
 bool arith::IndexCastOp::areCastCompatible(TypeRange inputs,
                                            TypeRange outputs) {
   if (!areValidCastInputsAndOutputs(inputs, outputs))
     return false;

mlir/test/Dialect/Arithmetic/canonicalize.mlir

func @test_minui(%arg0 : i8) -> (i8, i8, i8, i8) {
   %minIntCst = arith.constant 0 : i8
   %c0 = arith.constant 42 : i8
   %0 = arith.minui %arg0, %arg0 : i8
   %1 = arith.minui %arg0, %maxIntCst : i8
   %2 = arith.minui %arg0, %minIntCst : i8
   %3 = arith.minui %arg0, %c0 : i8
   return %0, %1, %2, %3: i8, i8, i8, i8
 }
+
+// -----
+
+// CHECK-LABEL: @constantFPtoUI(
+func @constantFPtoUI() -> i32 {
+  // CHECK: %[[C0:.+]] = arith.constant 2 : i32
+  // CHECK: return %[[C0]]
+  %c0 = arith.constant 2.0 : f32
+  %res = arith.fptoui %c0 : f32 to i32
+  return %res : i32
+}
+
+// CHECK-LABEL: @constantFPtoSI(
+func @constantFPtoSI() -> i32 {
+  // CHECK: %[[C0:.+]] = arith.constant -2 : i32
+  // CHECK: return %[[C0]]
+  %c0 = arith.constant -2.0 : f32
+  %res = arith.fptosi %c0 : f32 to i32
+  return %res : i32
+}
+
+// CHECK-LABEL: @constantSItoFP(
+func @constantSItoFP() -> f32 {
+  // CHECK: %[[C0:.+]] = arith.constant -2.000000e+00 : f32
+  // CHECK: return %[[C0]]
+  %c0 = arith.constant -2 : i32
+  %res = arith.sitofp %c0 : i32 to f32
+  return %res : f32
+}
+
+// CHECK-LABEL: @constantUItoFP(
+func @constantUItoFP() -> f32 {
+  // CHECK: %[[C0:.+]] = arith.constant 2.000000e+00 : f32
+  // CHECK: return %[[C0]]
+  %c0 = arith.constant 2 : i32
+  %res = arith.sitofp %c0 : i32 to f32
+  return %res : f32
+}