[mlir][Math] Add constant folder for ExpM1Op.

[jacquesguan]

Summary

This patch adds constant folder for ExpM1Op which only supports single and double precision floating-point.

[ftynse]

Windows build error seems relevant. I suspect some underlying implementation differs across platforms.

[jacquesguan]

In D130567#3682023, @ftynse wrote:

Windows build error seems relevant. I suspect some underlying implementation differs across platforms.

I found that the result of expm1(4.0) is 53.5981483 on Windows but 53.5981522 on Linux. Any good advice? Or just change to a nother number case?

[ftynse]

I'd just drop it. I am generally skeptical about the utility of tests with hardcoded numbers that cannot be easily verifiable with pen an paper. The only thing that we need to verify here is that applies to a the vector elementwise, which should be visible from a denes<[1.0, 0.0, 1.0]> just fine.

[jacquesguan]

Refactor test.

[jacquesguan]

In D130567#3684759, @ftynse wrote:

I'd just drop it. I am generally skeptical about the utility of tests with hardcoded numbers that cannot be easily verifiable with pen an paper. The only thing that we need to verify here is that applies to a the vector elementwise, which should be visible from a denes<[1.0, 0.0, 1.0]> just fine.

Done, thank you.

[Mogball]

mlir/test/Dialect/Math/canonicalize.mlir

278

you could use a regex to match fewer decimal places if it varies too much across platforms (adding a float matching feature to FileCheck is also highly-requested)

mlir/include/mlir/Dialect/Math/IR/MathOps.td

let description = [{
 
     Example:
 
     ```mlir
     // Scalar natural exponential minus 1.
     %a = math.expm1 %b : f64
     ```
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // FloorOp
 //===----------------------------------------------------------------------===//
 
 def Math_FloorOp : Math_FloatUnaryOp<"floor"> {
   let summary = "floor of the specified value";

mlir/lib/Dialect/Math/IR/MathOps.cpp

return constFoldUnaryOpConditional<FloatAttr>(
         case 32:
           return APFloat(exp2f(a.convertToFloat()));
         default:
           return {};
         }
       });
 }
 
+//===----------------------------------------------------------------------===//
+// ExpM1Op folder
+//===----------------------------------------------------------------------===//
+
+OpFoldResult math::ExpM1Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldUnaryOpConditional<FloatAttr>(
+      operands, [](const APFloat &a) -> Optional<APFloat> {
+        switch (a.getSizeInBits(a.getSemantics())) {
+        case 64:
+          return APFloat(expm1(a.convertToDouble()));
+        case 32:
+          return APFloat(expm1f(a.convertToFloat()));
+        default:
+          return {};
+        }
+      });
+}
+
 /// Materialize an integer or floating point constant.
 Operation *math::MathDialect::materializeConstant(OpBuilder &builder,
                                                   Attribute value, Type type,
                                                   Location loc) {
   return builder.create<arith::ConstantOp>(loc, value, type);
 }

mlir/test/Dialect/Math/canonicalize.mlir

 // CHECK-LABEL: @exp2_fold_vec
 // CHECK-NEXT: %[[cst:.+]] = arith.constant dense<[2.000000e+00, 4.000000e+00, 8.000000e+00, 1.600000e+01]> : vector<4xf32>
 // CHECK-NEXT:   return %[[cst]]
 func.func @exp2_fold_vec() -> (vector<4xf32>) {
   %v1 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : vector<4xf32>
   %0 = math.exp2 %v1 : vector<4xf32>
   return %0 : vector<4xf32>
 }
+
+// CHECK-LABEL: @expm1_fold
+// CHECK-NEXT: %[[cst:.+]] = arith.constant 6.3890562 : f32
+// CHECK-NEXT:   return %[[cst]]
+func.func @expm1_fold() -> f32 {
+  %c = arith.constant 2.0 : f32
+  %r = math.expm1 %c : f32
+  return %r : f32
+}
+
+// CHECK-LABEL: @expm1_fold_vec
+// CHECK-NEXT: %[[cst:.+]] = arith.constant dense<[0.000000e+00, 1.71828175, 0.000000e+00, 1.71828175]> : vector<4xf32>
+// CHECK-NEXT:   return %[[cst]]
+func.func @expm1_fold_vec() -> (vector<4xf32>) {
+  %v1 = arith.constant dense<[0.0, 1.0, 0.0, 1.0]> : vector<4xf32>
+  %0 = math.expm1 %v1 : vector<4xf32>
+  return %0 : vector<4xf32>
+}