diff --git a/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp b/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp --- a/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp +++ b/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp @@ -77,14 +77,223 @@ return success(); } }; + +struct DivOpConversion : public OpConversionPattern { + using OpConversionPattern::OpConversionPattern; + + LogicalResult + matchAndRewrite(complex::DivOp op, ArrayRef operands, + ConversionPatternRewriter &rewriter) const override { + complex::DivOp::Adaptor transformed(operands); + auto loc = op.getLoc(); + auto type = transformed.lhs().getType().template cast(); + auto elementType = type.getElementType().cast(); + + Value lhsReal = + rewriter.create(loc, elementType, transformed.lhs()); + Value lhsImag = + rewriter.create(loc, elementType, transformed.lhs()); + Value rhsReal = + rewriter.create(loc, elementType, transformed.rhs()); + Value rhsImag = + rewriter.create(loc, elementType, transformed.rhs()); + + // Smith's algorithm to divide complex numbers. It is just a bit smarter + // way to compute the following formula: + // (lhsReal + lhsImag * i) / (rhsReal + rhsImag * i) + // = (lhsReal + lhsImag * i) (rhsReal - rhsImag * i) / + // ((rhsReal + rhsImag * i)(rhsReal - rhsImag * i)) + // = ((lhsReal * rhsReal + lhsImag * rhsImag) + + // (lhsImag * rhsReal - lhsReal * rhsImag) * i) / ||rhs||^2 + // + // Depending on whether |rhsReal| < |rhsImag| we compute either + // rhsRealImagRatio = rhsReal / rhsImag + // rhsRealImagDenom = rhsImag + rhsReal * rhsRealImagRatio + // resultReal = (lhsReal * rhsRealImagRatio + lhsImag) / rhsRealImagDenom + // resultImag = (lhsImag * rhsRealImagRatio - lhsReal) / rhsRealImagDenom + // + // or + // + // rhsImagRealRatio = rhsImag / rhsReal + // rhsImagRealDenom = rhsReal + rhsImag * rhsImagRealRatio + // resultReal = (lhsReal + lhsImag * rhsImagRealRatio) / rhsImagRealDenom + // resultImag = (lhsImag - lhsReal * rhsImagRealRatio) / rhsImagRealDenom + // + // See https://dl.acm.org/citation.cfm?id=368661 for more details. + Value rhsRealImagRatio = rewriter.create(loc, rhsReal, rhsImag); + Value rhsRealImagDenom = rewriter.create( + loc, rhsImag, rewriter.create(loc, rhsRealImagRatio, rhsReal)); + Value realNumerator1 = rewriter.create( + loc, rewriter.create(loc, lhsReal, rhsRealImagRatio), lhsImag); + Value resultReal1 = + rewriter.create(loc, realNumerator1, rhsRealImagDenom); + Value imagNumerator1 = rewriter.create( + loc, rewriter.create(loc, lhsImag, rhsRealImagRatio), lhsReal); + Value resultImag1 = + rewriter.create(loc, imagNumerator1, rhsRealImagDenom); + + Value rhsImagRealRatio = rewriter.create(loc, rhsImag, rhsReal); + Value rhsImagRealDenom = rewriter.create( + loc, rhsReal, rewriter.create(loc, rhsImagRealRatio, rhsImag)); + Value realNumerator2 = rewriter.create( + loc, lhsReal, rewriter.create(loc, lhsImag, rhsImagRealRatio)); + Value resultReal2 = + rewriter.create(loc, realNumerator2, rhsImagRealDenom); + Value imagNumerator2 = rewriter.create( + loc, lhsImag, rewriter.create(loc, lhsReal, rhsImagRealRatio)); + Value resultImag2 = + rewriter.create(loc, imagNumerator2, rhsImagRealDenom); + + // Consider corner cases. + // Case 1. Zero denominator, numerator contains at most one NaN value. + Value zero = rewriter.create(loc, elementType, + rewriter.getZeroAttr(elementType)); + Value rhsRealAbs = rewriter.create(loc, rhsReal); + Value rhsRealIsZero = + rewriter.create(loc, CmpFPredicate::OEQ, rhsRealAbs, zero); + Value rhsImagAbs = rewriter.create(loc, rhsImag); + Value rhsImagIsZero = + rewriter.create(loc, CmpFPredicate::OEQ, rhsImagAbs, zero); + Value lhsRealIsNotNaN = + rewriter.create(loc, CmpFPredicate::ORD, lhsReal, zero); + Value lhsImagIsNotNaN = + rewriter.create(loc, CmpFPredicate::ORD, lhsImag, zero); + Value lhsContainsNotNaNValue = + rewriter.create(loc, lhsRealIsNotNaN, lhsImagIsNotNaN); + Value resultIsInfinity = rewriter.create( + loc, lhsContainsNotNaNValue, + rewriter.create(loc, rhsRealIsZero, rhsImagIsZero)); + Value inf = rewriter.create( + loc, elementType, + rewriter.getFloatAttr( + elementType, APFloat::getInf(elementType.getFloatSemantics()))); + Value infWithSignOfRhsReal = rewriter.create(loc, inf, rhsReal); + Value infinityResultReal = + rewriter.create(loc, infWithSignOfRhsReal, lhsReal); + Value infinityResultImag = + rewriter.create(loc, infWithSignOfRhsReal, lhsImag); + + // Case 2. Infinite numerator, finite denominator. + Value rhsRealFinite = + rewriter.create(loc, CmpFPredicate::ONE, rhsRealAbs, inf); + Value rhsImagFinite = + rewriter.create(loc, CmpFPredicate::ONE, rhsImagAbs, inf); + Value rhsFinite = rewriter.create(loc, rhsRealFinite, rhsImagFinite); + Value lhsRealAbs = rewriter.create(loc, lhsReal); + Value lhsRealInfinite = + rewriter.create(loc, CmpFPredicate::OEQ, lhsRealAbs, inf); + Value lhsImagAbs = rewriter.create(loc, lhsImag); + Value lhsImagInfinite = + rewriter.create(loc, CmpFPredicate::OEQ, lhsImagAbs, inf); + Value lhsInfinite = + rewriter.create(loc, lhsRealInfinite, lhsImagInfinite); + Value infNumFiniteDenom = + rewriter.create(loc, lhsInfinite, rhsFinite); + Value one = rewriter.create( + loc, elementType, rewriter.getFloatAttr(elementType, 1)); + Value lhsRealIsInfWithSign = rewriter.create( + loc, rewriter.create(loc, lhsRealInfinite, one, zero), + lhsReal); + Value lhsImagIsInfWithSign = rewriter.create( + loc, rewriter.create(loc, lhsImagInfinite, one, zero), + lhsImag); + Value lhsRealIsInfWithSignTimesRhsReal = + rewriter.create(loc, lhsRealIsInfWithSign, rhsReal); + Value lhsImagIsInfWithSignTimesRhsImag = + rewriter.create(loc, lhsImagIsInfWithSign, rhsImag); + Value resultReal3 = rewriter.create( + loc, inf, + rewriter.create(loc, lhsRealIsInfWithSignTimesRhsReal, + lhsImagIsInfWithSignTimesRhsImag)); + Value lhsRealIsInfWithSignTimesRhsImag = + rewriter.create(loc, lhsRealIsInfWithSign, rhsImag); + Value lhsImagIsInfWithSignTimesRhsReal = + rewriter.create(loc, lhsImagIsInfWithSign, rhsReal); + Value resultImag3 = rewriter.create( + loc, inf, + rewriter.create(loc, lhsImagIsInfWithSignTimesRhsReal, + lhsRealIsInfWithSignTimesRhsImag)); + + // Case 3: Finite numerator, infinite denominator. + Value lhsRealFinite = + rewriter.create(loc, CmpFPredicate::ONE, lhsRealAbs, inf); + Value lhsImagFinite = + rewriter.create(loc, CmpFPredicate::ONE, lhsImagAbs, inf); + Value lhsFinite = rewriter.create(loc, lhsRealFinite, lhsImagFinite); + Value rhsRealInfinite = + rewriter.create(loc, CmpFPredicate::OEQ, rhsRealAbs, inf); + Value rhsImagInfinite = + rewriter.create(loc, CmpFPredicate::OEQ, rhsImagAbs, inf); + Value rhsInfinite = + rewriter.create(loc, rhsRealInfinite, rhsImagInfinite); + Value finiteNumInfiniteDenom = + rewriter.create(loc, lhsFinite, rhsInfinite); + Value rhsRealIsInfWithSign = rewriter.create( + loc, rewriter.create(loc, rhsRealInfinite, one, zero), + rhsReal); + Value rhsImagIsInfWithSign = rewriter.create( + loc, rewriter.create(loc, rhsImagInfinite, one, zero), + rhsImag); + Value rhsRealIsInfWithSignTimesLhsReal = + rewriter.create(loc, lhsReal, rhsRealIsInfWithSign); + Value rhsImagIsInfWithSignTimesLhsImag = + rewriter.create(loc, lhsImag, rhsImagIsInfWithSign); + Value resultReal4 = rewriter.create( + loc, zero, + rewriter.create(loc, rhsRealIsInfWithSignTimesLhsReal, + rhsImagIsInfWithSignTimesLhsImag)); + Value rhsRealIsInfWithSignTimesLhsImag = + rewriter.create(loc, lhsImag, rhsRealIsInfWithSign); + Value rhsImagIsInfWithSignTimesLhsReal = + rewriter.create(loc, lhsReal, rhsImagIsInfWithSign); + Value resultImag4 = rewriter.create( + loc, zero, + rewriter.create(loc, rhsRealIsInfWithSignTimesLhsImag, + rhsImagIsInfWithSignTimesLhsReal)); + + Value realAbsSmallerThanImagAbs = rewriter.create( + loc, CmpFPredicate::OLT, rhsRealAbs, rhsImagAbs); + Value resultReal = rewriter.create(loc, realAbsSmallerThanImagAbs, + resultReal1, resultReal2); + Value resultImag = rewriter.create(loc, realAbsSmallerThanImagAbs, + resultImag1, resultImag2); + Value resultRealSpecialCase3 = rewriter.create( + loc, finiteNumInfiniteDenom, resultReal4, resultReal); + Value resultImagSpecialCase3 = rewriter.create( + loc, finiteNumInfiniteDenom, resultImag4, resultImag); + Value resultRealSpecialCase2 = rewriter.create( + loc, infNumFiniteDenom, resultReal3, resultRealSpecialCase3); + Value resultImagSpecialCase2 = rewriter.create( + loc, infNumFiniteDenom, resultImag3, resultImagSpecialCase3); + Value resultRealSpecialCase1 = rewriter.create( + loc, resultIsInfinity, infinityResultReal, resultRealSpecialCase2); + Value resultImagSpecialCase1 = rewriter.create( + loc, resultIsInfinity, infinityResultImag, resultImagSpecialCase2); + + Value resultRealIsNaN = + rewriter.create(loc, CmpFPredicate::UNO, resultReal, zero); + Value resultImagIsNaN = + rewriter.create(loc, CmpFPredicate::UNO, resultImag, zero); + Value resultIsNaN = + rewriter.create(loc, resultRealIsNaN, resultImagIsNaN); + Value resultRealWithSpecialCases = rewriter.create( + loc, resultIsNaN, resultRealSpecialCase1, resultReal); + Value resultImagWithSpecialCases = rewriter.create( + loc, resultIsNaN, resultImagSpecialCase1, resultImag); + + rewriter.replaceOpWithNewOp( + op, type, resultRealWithSpecialCases, resultImagWithSpecialCases); + return success(); + } +}; } // namespace void mlir::populateComplexToStandardConversionPatterns( RewritePatternSet &patterns) { patterns.add, - ComparisonOpConversion>( - patterns.getContext()); + ComparisonOpConversion, + DivOpConversion>(patterns.getContext()); } namespace { @@ -103,7 +312,8 @@ ConversionTarget target(getContext()); target.addLegalDialect(); - target.addIllegalOp(); + target.addIllegalOp(); if (failed(applyPartialConversion(function, target, std::move(patterns)))) signalPassFailure(); } diff --git a/mlir/test/Conversion/ComplexToStandard/convert-to-standard.mlir b/mlir/test/Conversion/ComplexToStandard/convert-to-standard.mlir --- a/mlir/test/Conversion/ComplexToStandard/convert-to-standard.mlir +++ b/mlir/test/Conversion/ComplexToStandard/convert-to-standard.mlir @@ -14,6 +14,115 @@ // CHECK: %[[NORM:.*]] = math.sqrt %[[SQ_NORM]] : f32 // CHECK: return %[[NORM]] : f32 +// CHECK-LABEL: func @complex_div +// CHECK-SAME: (%[[LHS:.*]]: complex, %[[RHS:.*]]: complex) +func @complex_div(%lhs: complex, %rhs: complex) -> complex { + %div = complex.div %lhs, %rhs : complex + return %div : complex +} +// CHECK: %[[LHS_REAL:.*]] = complex.re %[[LHS]] : complex +// CHECK: %[[LHS_IMAG:.*]] = complex.im %[[LHS]] : complex +// CHECK: %[[RHS_REAL:.*]] = complex.re %[[RHS]] : complex +// CHECK: %[[RHS_IMAG:.*]] = complex.im %[[RHS]] : complex + +// CHECK: %[[RHS_REAL_IMAG_RATIO:.*]] = divf %[[RHS_REAL]], %[[RHS_IMAG]] : f32 +// CHECK: %[[RHS_REAL_TIMES_RHS_REAL_IMAG_RATIO:.*]] = mulf %[[RHS_REAL_IMAG_RATIO]], %[[RHS_REAL]] : f32 +// CHECK: %[[RHS_REAL_IMAG_DENOM:.*]] = addf %[[RHS_IMAG]], %[[RHS_REAL_TIMES_RHS_REAL_IMAG_RATIO]] : f32 +// CHECK: %[[LHS_REAL_TIMES_RHS_REAL_IMAG_RATIO:.*]] = mulf %[[LHS_REAL]], %[[RHS_REAL_IMAG_RATIO]] : f32 +// CHECK: %[[REAL_NUMERATOR_1:.*]] = addf %[[LHS_REAL_TIMES_RHS_REAL_IMAG_RATIO]], %[[LHS_IMAG]] : f32 +// CHECK: %[[RESULT_REAL_1:.*]] = divf %[[REAL_NUMERATOR_1]], %[[RHS_REAL_IMAG_DENOM]] : f32 +// CHECK: %[[LHS_IMAG_TIMES_RHS_REAL_IMAG_RATIO:.*]] = mulf %[[LHS_IMAG]], %[[RHS_REAL_IMAG_RATIO]] : f32 +// CHECK: %[[IMAG_NUMERATOR_1:.*]] = subf %[[LHS_IMAG_TIMES_RHS_REAL_IMAG_RATIO]], %[[LHS_REAL]] : f32 +// CHECK: %[[RESULT_IMAG_1:.*]] = divf %[[IMAG_NUMERATOR_1]], %[[RHS_REAL_IMAG_DENOM]] : f32 + +// CHECK: %[[RHS_IMAG_REAL_RATIO:.*]] = divf %[[RHS_IMAG]], %[[RHS_REAL]] : f32 +// CHECK: %[[RHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO:.*]] = mulf %[[RHS_IMAG_REAL_RATIO]], %[[RHS_IMAG]] : f32 +// CHECK: %[[RHS_IMAG_REAL_DENOM:.*]] = addf %[[RHS_REAL]], %[[RHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO]] : f32 +// CHECK: %[[LHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO:.*]] = mulf %[[LHS_IMAG]], %[[RHS_IMAG_REAL_RATIO]] : f32 +// CHECK: %[[REAL_NUMERATOR_2:.*]] = addf %[[LHS_REAL]], %[[LHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO]] : f32 +// CHECK: %[[RESULT_REAL_2:.*]] = divf %[[REAL_NUMERATOR_2]], %[[RHS_IMAG_REAL_DENOM]] : f32 +// CHECK: %[[LHS_REAL_TIMES_RHS_IMAG_REAL_RATIO:.*]] = mulf %[[LHS_REAL]], %[[RHS_IMAG_REAL_RATIO]] : f32 +// CHECK: %[[IMAG_NUMERATOR_2:.*]] = subf %[[LHS_IMAG]], %[[LHS_REAL_TIMES_RHS_IMAG_REAL_RATIO]] : f32 +// CHECK: %[[RESULT_IMAG_2:.*]] = divf %[[IMAG_NUMERATOR_2]], %[[RHS_IMAG_REAL_DENOM]] : f32 + +// Case 1. Zero denominator, numerator contains at most one NaN value. +// CHECK: %[[ZERO:.*]] = constant 0.000000e+00 : f32 +// CHECK: %[[RHS_REAL_ABS:.*]] = absf %[[RHS_REAL]] : f32 +// CHECK: %[[RHS_REAL_ABS_IS_ZERO:.*]] = cmpf oeq, %[[RHS_REAL_ABS]], %[[ZERO]] : f32 +// CHECK: %[[RHS_IMAG_ABS:.*]] = absf %[[RHS_IMAG]] : f32 +// CHECK: %[[RHS_IMAG_ABS_IS_ZERO:.*]] = cmpf oeq, %[[RHS_IMAG_ABS]], %[[ZERO]] : f32 +// CHECK: %[[LHS_REAL_IS_NOT_NAN:.*]] = cmpf ord, %[[LHS_REAL]], %[[ZERO]] : f32 +// CHECK: %[[LHS_IMAG_IS_NOT_NAN:.*]] = cmpf ord, %[[LHS_IMAG]], %[[ZERO]] : f32 +// CHECK: %[[LHS_CONTAINS_NOT_NAN_VALUE:.*]] = or %[[LHS_REAL_IS_NOT_NAN]], %[[LHS_IMAG_IS_NOT_NAN]] : i1 +// CHECK: %[[RHS_IS_ZERO:.*]] = and %[[RHS_REAL_ABS_IS_ZERO]], %[[RHS_IMAG_ABS_IS_ZERO]] : i1 +// CHECK: %[[RESULT_IS_INFINITY:.*]] = and %[[LHS_CONTAINS_NOT_NAN_VALUE]], %[[RHS_IS_ZERO]] : i1 +// CHECK: %[[INF:.*]] = constant 0x7F800000 : f32 +// CHECK: %[[INF_WITH_SIGN_OF_RHS_REAL:.*]] = copysign %[[INF]], %[[RHS_REAL]] : f32 +// CHECK: %[[INFINITY_RESULT_REAL:.*]] = mulf %[[INF_WITH_SIGN_OF_RHS_REAL]], %[[LHS_REAL]] : f32 +// CHECK: %[[INFINITY_RESULT_IMAG:.*]] = mulf %[[INF_WITH_SIGN_OF_RHS_REAL]], %[[LHS_IMAG]] : f32 + +// Case 2. Infinite numerator, finite denominator. +// CHECK: %[[RHS_REAL_FINITE:.*]] = cmpf one, %[[RHS_REAL_ABS]], %[[INF]] : f32 +// CHECK: %[[RHS_IMAG_FINITE:.*]] = cmpf one, %[[RHS_IMAG_ABS]], %[[INF]] : f32 +// CHECK: %[[RHS_IS_FINITE:.*]] = and %[[RHS_REAL_FINITE]], %[[RHS_IMAG_FINITE]] : i1 +// CHECK: %[[LHS_REAL_ABS:.*]] = absf %[[LHS_REAL]] : f32 +// CHECK: %[[LHS_REAL_INFINITE:.*]] = cmpf oeq, %[[LHS_REAL_ABS]], %[[INF]] : f32 +// CHECK: %[[LHS_IMAG_ABS:.*]] = absf %[[LHS_IMAG]] : f32 +// CHECK: %[[LHS_IMAG_INFINITE:.*]] = cmpf oeq, %[[LHS_IMAG_ABS]], %[[INF]] : f32 +// CHECK: %[[LHS_IS_INFINITE:.*]] = or %[[LHS_REAL_INFINITE]], %[[LHS_IMAG_INFINITE]] : i1 +// CHECK: %[[INF_NUM_FINITE_DENOM:.*]] = and %[[LHS_IS_INFINITE]], %[[RHS_IS_FINITE]] : i1 +// CHECK: %[[ONE:.*]] = constant 1.000000e+00 : f32 +// CHECK: %[[LHS_REAL_IS_INF:.*]] = select %[[LHS_REAL_INFINITE]], %[[ONE]], %[[ZERO]] : f32 +// CHECK: %[[LHS_REAL_IS_INF_WITH_SIGN:.*]] = copysign %[[LHS_REAL_IS_INF]], %[[LHS_REAL]] : f32 +// CHECK: %[[LHS_IMAG_IS_INF:.*]] = select %[[LHS_IMAG_INFINITE]], %[[ONE]], %[[ZERO]] : f32 +// CHECK: %[[LHS_IMAG_IS_INF_WITH_SIGN:.*]] = copysign %[[LHS_IMAG_IS_INF]], %[[LHS_IMAG]] : f32 +// CHECK: %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_REAL:.*]] = mulf %[[LHS_REAL_IS_INF_WITH_SIGN]], %[[RHS_REAL]] : f32 +// CHECK: %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_IMAG:.*]] = mulf %[[LHS_IMAG_IS_INF_WITH_SIGN]], %[[RHS_IMAG]] : f32 +// CHECK: %[[INF_MULTIPLICATOR_1:.*]] = addf %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_REAL]], %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_IMAG]] : f32 +// CHECK: %[[RESULT_REAL_3:.*]] = mulf %[[INF]], %[[INF_MULTIPLICATOR_1]] : f32 +// CHECK: %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_IMAG:.*]] = mulf %[[LHS_REAL_IS_INF_WITH_SIGN]], %[[RHS_IMAG]] : f32 +// CHECK: %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_REAL:.*]] = mulf %[[LHS_IMAG_IS_INF_WITH_SIGN]], %[[RHS_REAL]] : f32 +// CHECK: %[[INF_MULTIPLICATOR_2:.*]] = subf %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_REAL]], %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_IMAG]] : f32 +// CHECK: %[[RESULT_IMAG_3:.*]] = mulf %[[INF]], %[[INF_MULTIPLICATOR_2]] : f32 + +// Case 3. Finite numerator, infinite denominator. +// CHECK: %[[LHS_REAL_FINITE:.*]] = cmpf one, %[[LHS_REAL_ABS]], %[[INF]] : f32 +// CHECK: %[[LHS_IMAG_FINITE:.*]] = cmpf one, %[[LHS_IMAG_ABS]], %[[INF]] : f32 +// CHECK: %[[LHS_IS_FINITE:.*]] = and %[[LHS_REAL_FINITE]], %[[LHS_IMAG_FINITE]] : i1 +// CHECK: %[[RHS_REAL_INFINITE:.*]] = cmpf oeq, %[[RHS_REAL_ABS]], %[[INF]] : f32 +// CHECK: %[[RHS_IMAG_INFINITE:.*]] = cmpf oeq, %[[RHS_IMAG_ABS]], %[[INF]] : f32 +// CHECK: %[[RHS_IS_INFINITE:.*]] = or %[[RHS_REAL_INFINITE]], %[[RHS_IMAG_INFINITE]] : i1 +// CHECK: %[[FINITE_NUM_INFINITE_DENOM:.*]] = and %[[LHS_IS_FINITE]], %[[RHS_IS_INFINITE]] : i1 +// CHECK: %[[RHS_REAL_IS_INF:.*]] = select %[[RHS_REAL_INFINITE]], %[[ONE]], %[[ZERO]] : f32 +// CHECK: %[[RHS_REAL_IS_INF_WITH_SIGN:.*]] = copysign %[[RHS_REAL_IS_INF]], %[[RHS_REAL]] : f32 +// CHECK: %[[RHS_IMAG_IS_INF:.*]] = select %[[RHS_IMAG_INFINITE]], %[[ONE]], %[[ZERO]] : f32 +// CHECK: %[[RHS_IMAG_IS_INF_WITH_SIGN:.*]] = copysign %[[RHS_IMAG_IS_INF]], %[[RHS_IMAG]] : f32 +// CHECK: %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_REAL:.*]] = mulf %[[LHS_REAL]], %[[RHS_REAL_IS_INF_WITH_SIGN]] : f32 +// CHECK: %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_IMAG:.*]] = mulf %[[LHS_IMAG]], %[[RHS_IMAG_IS_INF_WITH_SIGN]] : f32 +// CHECK: %[[ZERO_MULTIPLICATOR_1:.*]] = addf %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_REAL]], %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_IMAG]] : f32 +// CHECK: %[[RESULT_REAL_4:.*]] = mulf %[[ZERO]], %[[ZERO_MULTIPLICATOR_1]] : f32 +// CHECK: %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_IMAG:.*]] = mulf %[[LHS_IMAG]], %[[RHS_REAL_IS_INF_WITH_SIGN]] : f32 +// CHECK: %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_REAL:.*]] = mulf %[[LHS_REAL]], %[[RHS_IMAG_IS_INF_WITH_SIGN]] : f32 +// CHECK: %[[ZERO_MULTIPLICATOR_2:.*]] = subf %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_IMAG]], %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_REAL]] : f32 +// CHECK: %[[RESULT_IMAG_4:.*]] = mulf %[[ZERO]], %[[ZERO_MULTIPLICATOR_2]] : f32 + +// CHECK: %[[REAL_ABS_SMALLER_THAN_IMAG_ABS:.*]] = cmpf olt, %[[RHS_REAL_ABS]], %[[RHS_IMAG_ABS]] : f32 +// CHECK: %[[RESULT_REAL:.*]] = select %[[REAL_ABS_SMALLER_THAN_IMAG_ABS]], %[[RESULT_REAL_1]], %[[RESULT_REAL_2]] : f32 +// CHECK: %[[RESULT_IMAG:.*]] = select %[[REAL_ABS_SMALLER_THAN_IMAG_ABS]], %[[RESULT_IMAG_1]], %[[RESULT_IMAG_2]] : f32 +// CHECK: %[[RESULT_REAL_SPECIAL_CASE_3:.*]] = select %[[FINITE_NUM_INFINITE_DENOM]], %[[RESULT_REAL_4]], %[[RESULT_REAL]] : f32 +// CHECK: %[[RESULT_IMAG_SPECIAL_CASE_3:.*]] = select %[[FINITE_NUM_INFINITE_DENOM]], %[[RESULT_IMAG_4]], %[[RESULT_IMAG]] : f32 +// CHECK: %[[RESULT_REAL_SPECIAL_CASE_2:.*]] = select %[[INF_NUM_FINITE_DENOM]], %[[RESULT_REAL_3]], %[[RESULT_REAL_SPECIAL_CASE_3]] : f32 +// CHECK: %[[RESULT_IMAG_SPECIAL_CASE_2:.*]] = select %[[INF_NUM_FINITE_DENOM]], %[[RESULT_IMAG_3]], %[[RESULT_IMAG_SPECIAL_CASE_3]] : f32 +// CHECK: %[[RESULT_REAL_SPECIAL_CASE_1:.*]] = select %[[RESULT_IS_INFINITY]], %[[INFINITY_RESULT_REAL]], %[[RESULT_REAL_SPECIAL_CASE_2]] : f32 +// CHECK: %[[RESULT_IMAG_SPECIAL_CASE_1:.*]] = select %[[RESULT_IS_INFINITY]], %[[INFINITY_RESULT_IMAG]], %[[RESULT_IMAG_SPECIAL_CASE_2]] : f32 +// CHECK: %[[RESULT_REAL_IS_NAN:.*]] = cmpf uno, %[[RESULT_REAL]], %[[ZERO]] : f32 +// CHECK: %[[RESULT_IMAG_IS_NAN:.*]] = cmpf uno, %[[RESULT_IMAG]], %[[ZERO]] : f32 +// CHECK: %[[RESULT_IS_NAN:.*]] = and %[[RESULT_REAL_IS_NAN]], %[[RESULT_IMAG_IS_NAN]] : i1 +// CHECK: %[[RESULT_REAL_WITH_SPECIAL_CASES:.*]] = select %[[RESULT_IS_NAN]], %[[RESULT_REAL_SPECIAL_CASE_1]], %[[RESULT_REAL]] : f32 +// CHECK: %[[RESULT_IMAG_WITH_SPECIAL_CASES:.*]] = select %[[RESULT_IS_NAN]], %[[RESULT_IMAG_SPECIAL_CASE_1]], %[[RESULT_IMAG]] : f32 +// CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL_WITH_SPECIAL_CASES]], %[[RESULT_IMAG_WITH_SPECIAL_CASES]] : complex +// CHECK: return %[[RESULT]] : complex + // CHECK-LABEL: func @complex_eq // CHECK-SAME: %[[LHS:.*]]: complex, %[[RHS:.*]]: complex func @complex_eq(%lhs: complex, %rhs: complex) -> i1 {