25 struct AbsOpConversion : public OpConversionPattern<complex::AbsOp> {
26   using OpConversionPattern<complex::AbsOp>::OpConversionPattern;
29   matchAndRewrite(complex::AbsOp op, OpAdaptor adaptor,  in matchAndRewrite()
35         rewriter.create<complex::ReOp>(loc, type, adaptor.getComplex());  in matchAndRewrite()
37         rewriter.create<complex::ImOp>(loc, type, adaptor.getComplex());  in matchAndRewrite()
48 struct Atan2OpConversion : public OpConversionPattern<complex::Atan2Op> {
49   using OpConversionPattern<complex::Atan2Op>::OpConversionPattern;
52   matchAndRewrite(complex::Atan2Op op, OpAdaptor adaptor,  in matchAndRewrite()
62     Value rhsSquared = b.create<complex::MulOp>(type, rhs, rhs);  in matchAndRewrite()
63     Value lhsSquared = b.create<complex::MulOp>(type, lhs, lhs);  in matchAndRewrite()
65         b.create<complex::AddOp>(type, rhsSquared, lhsSquared);  in matchAndRewrite()
67         b.create<complex::SqrtOp>(type, rhsSquaredPlusLhsSquared);  in matchAndRewrite()
73     Value i = b.create<complex::CreateOp>(type, zero, one);  in matchAndRewrite()
74     Value iTimesLhs = b.create<complex::MulOp>(i, lhs);  in matchAndRewrite()
75     Value rhsPlusILhs = b.create<complex::AddOp>(rhs, iTimesLhs);  in matchAndRewrite()
78         b.create<complex::DivOp>(rhsPlusILhs, sqrtOfRhsSquaredPlusLhsSquared);  in matchAndRewrite()
79     Value logResult = b.create<complex::LogOp>(divResult);  in matchAndRewrite()
83     Value negativeI = b.create<complex::CreateOp>(type, zero, negativeOne);  in matchAndRewrite()
85     rewriter.replaceOpWithNewOp<complex::MulOp>(op, negativeI, logResult);  in matchAndRewrite()
94       std::conditional_t<std::is_same<ComparisonOp, complex::EqualOp>::value,
106     Value realLhs = rewriter.create<complex::ReOp>(loc, type, adaptor.getLhs());  in matchAndRewrite()
107     Value imagLhs = rewriter.create<complex::ImOp>(loc, type, adaptor.getLhs());  in matchAndRewrite()
108     Value realRhs = rewriter.create<complex::ReOp>(loc, type, adaptor.getRhs());  in matchAndRewrite()
109     Value imagRhs = rewriter.create<complex::ImOp>(loc, type, adaptor.getRhs());  in matchAndRewrite()
135     Value realLhs = b.create<complex::ReOp>(elementType, adaptor.getLhs());  in matchAndRewrite()
136     Value realRhs = b.create<complex::ReOp>(elementType, adaptor.getRhs());  in matchAndRewrite()
139     Value imagLhs = b.create<complex::ImOp>(elementType, adaptor.getLhs());  in matchAndRewrite()
140     Value imagRhs = b.create<complex::ImOp>(elementType, adaptor.getRhs());  in matchAndRewrite()
143     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,  in matchAndRewrite()
163         rewriter.create<complex::ReOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
165         rewriter.create<complex::ImOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
181     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultPair.first,  in matchAndRewrite()
191 struct CosOpConversion : public TrigonometricOpConversion<complex::CosOp> {
192   using TrigonometricOpConversion<complex::CosOp>::TrigonometricOpConversion;
214 struct DivOpConversion : public OpConversionPattern<complex::DivOp> {
215   using OpConversionPattern<complex::DivOp>::OpConversionPattern;
218   matchAndRewrite(complex::DivOp op, OpAdaptor adaptor,  in matchAndRewrite()
225         rewriter.create<complex::ReOp>(loc, elementType, adaptor.getLhs());  in matchAndRewrite()
227         rewriter.create<complex::ImOp>(loc, elementType, adaptor.getLhs());  in matchAndRewrite()
229         rewriter.create<complex::ReOp>(loc, elementType, adaptor.getRhs());  in matchAndRewrite()
231         rewriter.create<complex::ImOp>(loc, elementType, adaptor.getRhs());  in matchAndRewrite()
427     rewriter.replaceOpWithNewOp<complex::CreateOp>(  in matchAndRewrite()
433 struct ExpOpConversion : public OpConversionPattern<complex::ExpOp> {
434   using OpConversionPattern<complex::ExpOp>::OpConversionPattern;
437   matchAndRewrite(complex::ExpOp op, OpAdaptor adaptor,  in matchAndRewrite()
444         rewriter.create<complex::ReOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
446         rewriter.create<complex::ImOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
453     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,  in matchAndRewrite()
459 struct Expm1OpConversion : public OpConversionPattern<complex::Expm1Op> {
460   using OpConversionPattern<complex::Expm1Op>::OpConversionPattern;
463   matchAndRewrite(complex::Expm1Op op, OpAdaptor adaptor,  in matchAndRewrite()
469     Value exp = b.create<complex::ExpOp>(adaptor.getComplex());  in matchAndRewrite()
471     Value real = b.create<complex::ReOp>(elementType, exp);  in matchAndRewrite()
475     Value imag = b.create<complex::ImOp>(elementType, exp);  in matchAndRewrite()
477     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, realMinusOne,  in matchAndRewrite()
483 struct LogOpConversion : public OpConversionPattern<complex::LogOp> {
484   using OpConversionPattern<complex::LogOp>::OpConversionPattern;
487   matchAndRewrite(complex::LogOp op, OpAdaptor adaptor,  in matchAndRewrite()
493     Value abs = b.create<complex::AbsOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
495     Value real = b.create<complex::ReOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
496     Value imag = b.create<complex::ImOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
498     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,  in matchAndRewrite()
504 struct Log1pOpConversion : public OpConversionPattern<complex::Log1pOp> {
505   using OpConversionPattern<complex::Log1pOp>::OpConversionPattern;
508   matchAndRewrite(complex::Log1pOp op, OpAdaptor adaptor,  in matchAndRewrite()
514     Value real = b.create<complex::ReOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
515     Value imag = b.create<complex::ImOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
519     Value newComplex = b.create<complex::CreateOp>(type, realPlusOne, imag);  in matchAndRewrite()
520     rewriter.replaceOpWithNewOp<complex::LogOp>(op, type, newComplex);  in matchAndRewrite()
525 struct MulOpConversion : public OpConversionPattern<complex::MulOp> {
526   using OpConversionPattern<complex::MulOp>::OpConversionPattern;
529   matchAndRewrite(complex::MulOp op, OpAdaptor adaptor,  in matchAndRewrite()
535     Value lhsReal = b.create<complex::ReOp>(elementType, adaptor.getLhs());  in matchAndRewrite()
537     Value lhsImag = b.create<complex::ImOp>(elementType, adaptor.getLhs());  in matchAndRewrite()
539     Value rhsReal = b.create<complex::ReOp>(elementType, adaptor.getRhs());  in matchAndRewrite()
541     Value rhsImag = b.create<complex::ImOp>(elementType, adaptor.getRhs());  in matchAndRewrite()
697     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, real, imag);  in matchAndRewrite()
702 struct NegOpConversion : public OpConversionPattern<complex::NegOp> {
703   using OpConversionPattern<complex::NegOp>::OpConversionPattern;
706   matchAndRewrite(complex::NegOp op, OpAdaptor adaptor,  in matchAndRewrite()
713         rewriter.create<complex::ReOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
715         rewriter.create<complex::ImOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
718     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, negReal, negImag);  in matchAndRewrite()
723 struct SinOpConversion : public TrigonometricOpConversion<complex::SinOp> {
724   using TrigonometricOpConversion<complex::SinOp>::TrigonometricOpConversion;
747 struct SqrtOpConversion : public OpConversionPattern<complex::SqrtOp> {
748   using OpConversionPattern<complex::SqrtOp>::OpConversionPattern;
751   matchAndRewrite(complex::SqrtOp op, OpAdaptor adaptor,  in matchAndRewrite()
762     Value real = b.create<complex::ReOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
763     Value imag = b.create<complex::ImOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
766     Value absArg = b.create<complex::AbsOp>(elementType, arg);  in matchAndRewrite()
807     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,  in matchAndRewrite()
813 struct SignOpConversion : public OpConversionPattern<complex::SignOp> {
814   using OpConversionPattern<complex::SignOp>::OpConversionPattern;
817   matchAndRewrite(complex::SignOp op, OpAdaptor adaptor,  in matchAndRewrite()
823     Value real = b.create<complex::ReOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
824     Value imag = b.create<complex::ImOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
832     auto abs = b.create<complex::AbsOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
835     Value sign = b.create<complex::CreateOp>(type, realSign, imagSign);  in matchAndRewrite()
842 struct TanOpConversion : public OpConversionPattern<complex::TanOp> {
843   using OpConversionPattern<complex::TanOp>::OpConversionPattern;
846   matchAndRewrite(complex::TanOp op, OpAdaptor adaptor,  in matchAndRewrite()
849     Value cos = rewriter.create<complex::CosOp>(loc, adaptor.getComplex());  in matchAndRewrite()
850     Value sin = rewriter.create<complex::SinOp>(loc, adaptor.getComplex());  in matchAndRewrite()
851     rewriter.replaceOpWithNewOp<complex::DivOp>(op, sin, cos);  in matchAndRewrite()
856 struct TanhOpConversion : public OpConversionPattern<complex::TanhOp> {
857   using OpConversionPattern<complex::TanhOp>::OpConversionPattern;
860   matchAndRewrite(complex::TanhOp op, OpAdaptor adaptor,  in matchAndRewrite()
870         rewriter.create<complex::ReOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
872         rewriter.create<complex::ImOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
878         rewriter.create<complex::CreateOp>(loc, type, tanhA, tanB);  in matchAndRewrite()
882     Value denominator = rewriter.create<complex::CreateOp>(loc, type, one, mul);  in matchAndRewrite()
883     rewriter.replaceOpWithNewOp<complex::DivOp>(op, numerator, denominator);  in matchAndRewrite()
888 struct ConjOpConversion : public OpConversionPattern<complex::ConjOp> {
889   using OpConversionPattern<complex::ConjOp>::OpConversionPattern;
892   matchAndRewrite(complex::ConjOp op, OpAdaptor adaptor,  in matchAndRewrite()
898         rewriter.create<complex::ReOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
900         rewriter.create<complex::ImOp>(loc, elementType, adaptor.getComplex());  in matchAndRewrite()
903     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, real, negImag);  in matchAndRewrite()
955   Value complexZero = builder.create<complex::CreateOp>(type, zero, zero);  in powOpConversionImpl()
956   Value complexOne = builder.create<complex::CreateOp>(type, one, zero);  in powOpConversionImpl()
957   Value complexOther = builder.create<complex::CreateOp>(  in powOpConversionImpl()
970 struct PowOpConversion : public OpConversionPattern<complex::PowOp> {
971   using OpConversionPattern<complex::PowOp>::OpConversionPattern;
974   matchAndRewrite(complex::PowOp op, OpAdaptor adaptor,  in matchAndRewrite()
980     Value a = builder.create<complex::ReOp>(elementType, adaptor.getLhs());  in matchAndRewrite()
981     Value b = builder.create<complex::ImOp>(elementType, adaptor.getLhs());  in matchAndRewrite()
982     Value c = builder.create<complex::ReOp>(elementType, adaptor.getRhs());  in matchAndRewrite()
983     Value d = builder.create<complex::ImOp>(elementType, adaptor.getRhs());  in matchAndRewrite()
990 struct RsqrtOpConversion : public OpConversionPattern<complex::RsqrtOp> {
991   using OpConversionPattern<complex::RsqrtOp>::OpConversionPattern;
994   matchAndRewrite(complex::RsqrtOp op, OpAdaptor adaptor,  in matchAndRewrite()
1000     Value a = builder.create<complex::ReOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
1001     Value b = builder.create<complex::ImOp>(elementType, adaptor.getComplex());  in matchAndRewrite()
1012 struct AngleOpConversion : public OpConversionPattern<complex::AngleOp> {
1013   using OpConversionPattern<complex::AngleOp>::OpConversionPattern;
1016   matchAndRewrite(complex::AngleOp op, OpAdaptor adaptor,  in matchAndRewrite()
1022         rewriter.create<complex::ReOp>(loc, type, adaptor.getComplex());  in matchAndRewrite()
1024         rewriter.create<complex::ImOp>(loc, type, adaptor.getComplex());  in matchAndRewrite()
1041       BinaryComplexOpConversion<complex::AddOp, arith::AddFOp>,  in populateComplexToStandardConversionPatterns()
1042       BinaryComplexOpConversion<complex::SubOp, arith::SubFOp>,  in populateComplexToStandardConversionPatterns()
1043       ComparisonOpConversion<complex::EqualOp, arith::CmpFPredicate::OEQ>,  in populateComplexToStandardConversionPatterns()
1044       ComparisonOpConversion<complex::NotEqualOp, arith::CmpFPredicate::UNE>,  in populateComplexToStandardConversionPatterns()
1078   target.addLegalOp<complex::CreateOp, complex::ImOp, complex::ReOp>();  in runOnOperation()