Lower complex.expm1 to standard dialect.

[bixia]

Summary

Add a test.

[aartbik]

Very neat. The general idea LGTM but I leave to it our math experts to approve.

[pifon2a]

Thank you, Bixia!

mlir/test/Conversion/ComplexToStandard/convert-to-standard.mlir

196–213

nit: remove some of the whitespaces in the test to make it fit 80 chars.

[bixia]

Remove unnecessary spaces in the test.

mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp

matchAndRewrite(complex::ExpOp op, OpAdaptor adaptor,
     Value resultImag = rewriter.create<arith::MulFOp>(loc, expReal, sinImag);
 
     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,
                                                    resultImag);
     return success();
   }
 };
 
+struct Expm1OpConversion : public OpConversionPattern<complex::Expm1Op> {
+  using OpConversionPattern<complex::Expm1Op>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(complex::Expm1Op op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    auto type = adaptor.getComplex().getType().cast<ComplexType>();
+    auto elementType = type.getElementType().cast<FloatType>();
+
+    mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
+    Value exp = b.create<complex::ExpOp>(adaptor.getComplex());
+
+    Value real = b.create<complex::ReOp>(elementType, exp);
+    Value one = b.create<arith::ConstantOp>(elementType,
+                                            b.getFloatAttr(elementType, 1));
+    Value realMinusOne = b.create<arith::SubFOp>(real, one);
+    Value imag = b.create<complex::ImOp>(elementType, exp);
+
+    rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, realMinusOne,
+                                                   imag);
+    return success();
+  }
+};
+
 struct LogOpConversion : public OpConversionPattern<complex::LogOp> {
   using OpConversionPattern<complex::LogOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(complex::LogOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto type = adaptor.getComplex().getType().cast<ComplexType>();
     auto elementType = type.getElementType().cast<FloatType>();
patterns.add<
       AbsOpConversion,
       ComparisonOpConversion<complex::EqualOp, arith::CmpFPredicate::OEQ>,
       ComparisonOpConversion<complex::NotEqualOp, arith::CmpFPredicate::UNE>,
       BinaryComplexOpConversion<complex::AddOp, arith::AddFOp>,
       BinaryComplexOpConversion<complex::SubOp, arith::SubFOp>,
       CosOpConversion,
       DivOpConversion,
       ExpOpConversion,
+      Expm1OpConversion,
       LogOpConversion,
       Log1pOpConversion,
       MulOpConversion,
       NegOpConversion,
       SignOpConversion,
       SinOpConversion>(patterns.getContext());
   // clang-format on
 }

mlir/test/Conversion/ComplexToStandard/convert-to-standard.mlir

 // CHECK-DAG: %[[COS_IMAG:.*]] = math.cos %[[IMAG]] : f32
 // CHECK-DAG: %[[EXP_REAL:.*]] = math.exp %[[REAL]] : f32
 // CHECK-DAG: %[[RESULT_REAL:.]] = arith.mulf %[[EXP_REAL]], %[[COS_IMAG]] : f32
 // CHECK-DAG: %[[SIN_IMAG:.*]] = math.sin %[[IMAG]] : f32
 // CHECK-DAG: %[[RESULT_IMAG:.*]] = arith.mulf %[[EXP_REAL]], %[[SIN_IMAG]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-LABEL:   func.func @complex_expm1(
+// CHECK-SAME:                             %[[ARG:.*]]: complex<f32>) -> complex<f32> {
+func.func @complex_expm1(%arg: complex<f32>) -> complex<f32> {
+  %expm1 = complex.expm1 %arg: complex<f32>
+  return %expm1 : complex<f32>
+}
+// CHECK:           %[[REAL_I:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK:           %[[IMAG_I:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK:           %[[EXP:.*]] = math.exp %[[REAL_I]] : f32
+// CHECK:           %[[COS:.*]] = math.cos %[[IMAG_I]] : f32
+// CHECK:           %[[RES_REAL:.*]] = arith.mulf %[[EXP]], %[[COS]] : f32
+// CHECK:           %[[SIN:.*]] = math.sin %[[IMAG_I]] : f32
+// CHECK:           %[[RES_IMAG:.*]] = arith.mulf %[[EXP]], %[[SIN]] : f32
+// CHECK:           %[[RES_EXP:.*]] = complex.create %[[RES_REAL]], %[[RES_IMAG]] : complex<f32>
+// CHECK:           %[[REAL:.*]] = complex.re %[[RES_EXP]] : complex<f32>
+// CHECK:           %[[ONE:.*]] = arith.constant 1.000000e+00 : f32
+// CHECK:           %[[REAL_M1:.*]] = arith.subf %[[REAL]], %[[ONE]] : f32
+// CHECK:           %[[IMAG:.*]] = complex.im %[[RES_EXP]] : complex<f32>
+// CHECK:           %[[RES:.*]] = complex.create %[[REAL_M1]], %[[IMAG]] : complex<f32>
+// CHECK:           return %[[RES]] : complex<f32>
+// CHECK:         }
+
 // CHECK-LABEL: func @complex_log
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_log(%arg: complex<f32>) -> complex<f32> {
   %log = complex.log %arg: complex<f32>
   return %log : complex<f32>
 }
 // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>