[mlir][Arithmetic] Add constant folder for RemF.

[jacquesguan]

Summary

This patch adds the constant folder for RemF.

[jacquesguan]

ping.

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

 }
 
 //===----------------------------------------------------------------------===//
 // RemFOp
 //===----------------------------------------------------------------------===//
 
 def Arith_RemFOp : Arith_FloatBinaryOp<"remf"> {
   let summary = "floating point division remainder operation";
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ExtUIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_ExtUIOp : Arith_IToICastOp<"extui"> {
   let summary = "integer zero extension operation";

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

OpFoldResult arith::DivFOp::fold(ArrayRef<Attribute> operands) {
   if (matchPattern(getRhs(), m_OneFloat()))
     return getLhs();
 
   return constFoldBinaryOp<FloatAttr>(
       operands, [](const APFloat &a, const APFloat &b) { return a / b; });
 }
 
 //===----------------------------------------------------------------------===//
+// RemFOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult arith::RemFOp::fold(ArrayRef<Attribute> operands) {
+  return constFoldBinaryOp<FloatAttr>(operands,
+                                      [](const APFloat &a, const APFloat &b) {
+                                        APFloat Result(a);
+                                        (void)Result.remainder(b);
+                                        return Result;
+                                      });
+}
+
+//===----------------------------------------------------------------------===//
 // Utility functions for verifying cast ops
 //===----------------------------------------------------------------------===//
 
 template <typename... Types>
 using type_list = std::tuple<Types...> *;
 
 /// Returns a non-null type only if the provided type is one of the allowed
 /// types or one of the allowed shaped types of the allowed types. Returns the

mlir/test/Dialect/Arithmetic/canonicalize.mlir

 // CHECK-LABEL: @test_remsi_1(
 // CHECK: %[[res:.+]] = arith.constant dense<0> : vector<4xi32>
 // CHECK: return %[[res]]
 func.func @test_remsi_1(%arg : vector<4xi32>) -> (vector<4xi32>) {
   %v = arith.constant dense<[1, 1, 1, 1]> : vector<4xi32>
   %0 = arith.remsi %arg, %v : vector<4xi32>
   return %0 : vector<4xi32>
 }
+
+// -----
+
+// CHECK-LABEL: @test_remf(
+// CHECK: %[[res:.+]] = arith.constant -1.000000e+00 : f32
+// CHECK: return %[[res]]
+func.func @test_remf() -> (f32) {
+  %v1 = arith.constant 3.0 : f32
+  %v2 = arith.constant 2.0 : f32
+  %0 = arith.remf %v1, %v2 : f32
+  return %0 : f32
+}
+
+// CHECK-LABEL: @test_remf_vec(
+// CHECK: %[[res:.+]] = arith.constant dense<[1.000000e+00, 0.000000e+00, -1.000000e+00, 0.000000e+00]> : vector<4xf32>
+// CHECK: return %[[res]]
+func.func @test_remf_vec() -> (vector<4xf32>) {
+  %v1 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : vector<4xf32>
+  %v2 = arith.constant dense<[2.0, 2.0, 2.0, 2.0]> : vector<4xf32>
+  %0 = arith.remf %v1, %v2 : vector<4xf32>
+  return %0 : vector<4xf32>
+}