[mlir][arith] Fold on extension of FP constants using arith.extf

[victor-eds]

Summary

It is safe to fold when extending, as we will not lose precision.

mlir/include/mlir/Dialect/Arith/IR/ArithOps.td

 def Arith_ExtFOp : Arith_FToFCastOp<"extf"> {
   let summary = "cast from floating-point to wider floating-point";
   let description = [{
     Cast a floating-point value to a larger floating-point-typed value.
     The destination type must to be strictly wider than the source type.
     When operating on vectors, casts elementwise.
   }];
   let hasVerifier = 1;
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TruncIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_TruncIOp : Arith_IToICastOp<"trunci"> {
   let summary = "integer truncation operation";

mlir/lib/Dialect/Arith/IR/ArithOps.cpp

 LogicalResult arith::ExtSIOp::verify() {
   return verifyExtOp<IntegerType>(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // ExtFOp
 //===----------------------------------------------------------------------===//
 
+/// Always fold extension of FP constants.
+OpFoldResult arith::ExtFOp::fold(FoldAdaptor adaptor) {
+  auto constOperand = adaptor.getIn().dyn_cast_or_null<FloatAttr>();
+  if (!constOperand)
+    return {};
+
+  // Convert to target type via 'double'.
+  return FloatAttr::get(getType(), constOperand.getValue().convertToDouble());
+}
+
 bool arith::ExtFOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkWidthChangeCast<std::greater, FloatType>(inputs, outputs);
 }
 
 LogicalResult arith::ExtFOp::verify() { return verifyExtOp<FloatType>(*this); }
 
 //===----------------------------------------------------------------------===//
 // TruncIOp

mlir/test/Dialect/Arith/canonicalize.mlir

 //       CHECK:   %[[cres:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi16>
 //       CHECK:   return %[[cres]]
 func.func @unsignedExtendConstantVector() -> vector<4xi16> {
   %vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi8>
   %ext = arith.extui %vector : vector<4xi8> to vector<4xi16>
   return %ext : vector<4xi16>
 }
 
+// CHECK-LABEL: @extFPConstant
+//       CHECK:   %[[cres:.+]] = arith.constant 1.000000e+00 : f64
+//       CHECK:   return %[[cres]]
+func.func @extFPConstant() -> f64 {
+  %cst = arith.constant 1.000000e+00 : f32
+  %0 = arith.extf %cst : f32 to f64
+  return %0 : f64
+}
+
 // CHECK-LABEL: @truncConstant
 //       CHECK:   %[[cres:.+]] = arith.constant -2 : i16
 //       CHECK:   return %[[cres]]
 func.func @truncConstant(%arg0: i8) -> i16 {
   %c-2 = arith.constant -2 : i32
   %tr = arith.trunci %c-2 : i32 to i16
   return %tr : i16
 }