Index: llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -1181,12 +1181,9 @@ /// Use square root in place of pow(x, +/-0.5). Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B) { - // TODO: There is some subset of 'fast' under which these transforms should - // be allowed. - if (!Pow->isFast()) - return nullptr; - Value *Sqrt, *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1); + AttributeList Attrs = Pow->getCalledFunction()->getAttributes(); + Module *Mod = Pow->getModule(); Type *Ty = Pow->getType(); const APFloat *ExpoF; @@ -1198,18 +1195,32 @@ if (Pow->hasFnAttr(Attribute::ReadNone)) { Function *SqrtFn = Intrinsic::getDeclaration(Pow->getModule(), Intrinsic::sqrt, Ty); - Sqrt = B.CreateCall(SqrtFn, Base); + Sqrt = B.CreateCall(SqrtFn, Base, "sqrt"); } // Otherwise, use the libcall for sqrt(). else if (hasUnaryFloatFn(TLI, Ty, LibFunc_sqrt, LibFunc_sqrtf, LibFunc_sqrtl)) // TODO: We also should check that the target can in fact lower the sqrt() // libcall. We currently have no way to ask this question, so we ask if // the target has a sqrt() libcall, which is not exactly the same. - Sqrt = emitUnaryFloatFnCall(Base, TLI->getName(LibFunc_sqrt), B, - Pow->getCalledFunction()->getAttributes()); + Sqrt = emitUnaryFloatFnCall(Base, TLI->getName(LibFunc_sqrt), B, Attrs); else return nullptr; + // Handle signed zero base by expanding to fabs(sqrt(x)). + if (!Pow->hasNoSignedZeros()) { + Function *FAbsFn = Intrinsic::getDeclaration(Mod, Intrinsic::fabs, Ty); + Sqrt = B.CreateCall(FAbsFn, Sqrt, "abs"); + } + + // Handle non finite base by expanding to + // (x == -infinity ? +infinity : sqrt(x)). + if (!Pow->hasNoInfs()) { + Value *PosInf = ConstantFP::getInfinity(Ty), + *NegInf = ConstantFP::getInfinity(Ty, true); + Value *FCmp = B.CreateFCmpOEQ(Base, NegInf, "isinf"); + Sqrt = B.CreateSelect(FCmp, PosInf, Sqrt); + } + // If the exponent is negative, then get the reciprocal. if (ExpoF->isNegative()) Sqrt = B.CreateFDiv(ConstantFP::get(Ty, 1.0), Sqrt, "reciprocal"); @@ -1265,7 +1276,7 @@ // We enable these only with fast-math. Besides rounding differences, the // transformation changes overflow and underflow behavior quite dramatically. // Example: x = 1000, y = 0.001. - // pow(exp(x), y) = pow(inf, 0.001) = inf, whereas exp(x*y) = exp(1). + // pow(exp(x), y) = pow(inf, 0.001) = inf, whereas exp(x * y) = exp(1). auto *BaseFn = dyn_cast(Base); if (BaseFn && BaseFn->isFast() && Pow->isFast()) { LibFunc LibFn; @@ -1299,28 +1310,6 @@ if (Value *Sqrt = replacePowWithSqrt(Pow, B)) return Sqrt; - // FIXME: Correct the transforms and pull this into replacePowWithSqrt(). - ConstantFP *ExpoC = dyn_cast(Expo); - if (ExpoC && ExpoC->isExactlyValue(0.5) && - hasUnaryFloatFn(TLI, Ty, LibFunc_sqrt, LibFunc_sqrtf, LibFunc_sqrtl)) { - // Expand pow(x, 0.5) to (x == -infinity ? +infinity : fabs(sqrt(x))). - // This is faster than calling pow(), and still handles -0.0 and - // negative infinity correctly. - // TODO: In finite-only mode, this could be just fabs(sqrt(x)). - Value *PosInf = ConstantFP::getInfinity(Ty); - Value *NegInf = ConstantFP::getInfinity(Ty, true); - - // TODO: As above, we should lower to the sqrt() intrinsic if the pow() is - // an intrinsic, to match errno semantics. - Value *Sqrt = emitUnaryFloatFnCall(Base, TLI->getName(LibFunc_sqrt), - B, Attrs); - Function *FAbsFn = Intrinsic::getDeclaration(Module, Intrinsic::fabs, Ty); - Value *FAbs = B.CreateCall(FAbsFn, Sqrt, "abs"); - Value *FCmp = B.CreateFCmpOEQ(Base, NegInf, "isinf"); - Sqrt = B.CreateSelect(FCmp, PosInf, FAbs); - return Sqrt; - } - // pow(x, n) -> x * x * x * ... const APFloat *ExpoF; if (Pow->isFast() && match(Expo, m_APFloat(ExpoF))) { Index: llvm/trunk/test/Transforms/InstCombine/pow-1.ll =================================================================== --- llvm/trunk/test/Transforms/InstCombine/pow-1.ll +++ llvm/trunk/test/Transforms/InstCombine/pow-1.ll @@ -293,7 +293,7 @@ declare double @llvm.pow.f64(double %Val, double %Power) define double @test_simplify17(double %x) { ; ANY-LABEL: @test_simplify17( -; ANY-NEXT: [[SQRT:%.*]] = call double @sqrt(double [[X:%.*]]) #2 +; ANY-NEXT: [[SQRT:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]]) ; ANY-NEXT: [[ABS:%.*]] = call double @llvm.fabs.f64(double [[SQRT]]) ; ANY-NEXT: [[ISINF:%.*]] = fcmp oeq double [[X]], 0xFFF0000000000000 ; ANY-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]] Index: llvm/trunk/test/Transforms/InstCombine/pow-sqrt.ll =================================================================== --- llvm/trunk/test/Transforms/InstCombine/pow-sqrt.ll +++ llvm/trunk/test/Transforms/InstCombine/pow-sqrt.ll @@ -19,7 +19,7 @@ define double @pow_intrinsic_half_no_FMF(double %x) { ; CHECK-LABEL: @pow_intrinsic_half_no_FMF( -; CHECK-NEXT: [[SQRT:%.*]] = call double @sqrt(double [[X:%.*]]) #1 +; CHECK-NEXT: [[SQRT:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]]) ; CHECK-NEXT: [[ABS:%.*]] = call double @llvm.fabs.f64(double [[SQRT]]) ; CHECK-NEXT: [[ISINF:%.*]] = fcmp oeq double [[X]], 0xFFF0000000000000 ; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]] @@ -43,96 +43,88 @@ ret double %pow } -; FIXME - define <2 x double> @pow_intrinsic_half_approx(<2 x double> %x) { ; CHECK-LABEL: @pow_intrinsic_half_approx( -; CHECK-NEXT: [[POW:%.*]] = call afn <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> ) -; CHECK-NEXT: ret <2 x double> [[POW]] +; CHECK-NEXT: [[SQRT:%.*]] = call afn <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X:%.*]]) +; CHECK-NEXT: [[ABS:%.*]] = call afn <2 x double> @llvm.fabs.v2f64(<2 x double> [[SQRT]]) +; CHECK-NEXT: [[ISINF:%.*]] = fcmp afn oeq <2 x double> [[X]], +; CHECK-NEXT: [[TMP1:%.*]] = select <2 x i1> [[ISINF]], <2 x double> , <2 x double> [[ABS]] +; CHECK-NEXT: ret <2 x double> [[TMP1]] ; %pow = call afn <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> ) ret <2 x double> %pow } -; FIXME: +define float @powf_intrinsic_half_fast(float %x) { +; CHECK-LABEL: @powf_intrinsic_half_fast( +; CHECK-NEXT: [[SQRT:%.*]] = call fast float @llvm.sqrt.f32(float [[X:%.*]]) +; CHECK-NEXT: ret float [[SQRT]] +; + %pow = call fast float @llvm.pow.f32(float %x, float 5.0e-01) + ret float %pow +} + ; If we can disregard INFs, no need for a select. define double @pow_libcall_half_ninf(double %x) { ; CHECK-LABEL: @pow_libcall_half_ninf( ; CHECK-NEXT: [[SQRT:%.*]] = call ninf double @sqrt(double [[X:%.*]]) ; CHECK-NEXT: [[ABS:%.*]] = call ninf double @llvm.fabs.f64(double [[SQRT]]) -; CHECK-NEXT: [[ISINF:%.*]] = fcmp ninf oeq double [[X]], 0xFFF0000000000000 -; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]] -; CHECK-NEXT: ret double [[TMP1]] +; CHECK-NEXT: ret double [[ABS]] ; %pow = call ninf double @pow(double %x, double 5.0e-01) ret double %pow } -; FIXME: - define <2 x double> @pow_intrinsic_half_ninf(<2 x double> %x) { ; CHECK-LABEL: @pow_intrinsic_half_ninf( -; CHECK-NEXT: [[POW:%.*]] = call ninf <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> ) -; CHECK-NEXT: ret <2 x double> [[POW]] +; CHECK-NEXT: [[SQRT:%.*]] = call ninf <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X:%.*]]) +; CHECK-NEXT: [[ABS:%.*]] = call ninf <2 x double> @llvm.fabs.v2f64(<2 x double> [[SQRT]]) +; CHECK-NEXT: ret <2 x double> [[ABS]] ; %pow = call ninf <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> ) ret <2 x double> %pow } -; FIXME: ; If we can disregard -0.0, no need for fabs. define double @pow_libcall_half_nsz(double %x) { ; CHECK-LABEL: @pow_libcall_half_nsz( ; CHECK-NEXT: [[SQRT:%.*]] = call nsz double @sqrt(double [[X:%.*]]) -; CHECK-NEXT: [[ABS:%.*]] = call nsz double @llvm.fabs.f64(double [[SQRT]]) ; CHECK-NEXT: [[ISINF:%.*]] = fcmp nsz oeq double [[X]], 0xFFF0000000000000 -; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]] +; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[SQRT]] ; CHECK-NEXT: ret double [[TMP1]] ; %pow = call nsz double @pow(double %x, double 5.0e-01) ret double %pow } -; FIXME: - define double @pow_intrinsic_half_nsz(double %x) { ; CHECK-LABEL: @pow_intrinsic_half_nsz( -; CHECK-NEXT: [[SQRT:%.*]] = call nsz double @sqrt(double [[X:%.*]]) #1 -; CHECK-NEXT: [[ABS:%.*]] = call nsz double @llvm.fabs.f64(double [[SQRT]]) +; CHECK-NEXT: [[SQRT:%.*]] = call nsz double @llvm.sqrt.f64(double [[X:%.*]]) ; CHECK-NEXT: [[ISINF:%.*]] = fcmp nsz oeq double [[X]], 0xFFF0000000000000 -; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]] +; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[SQRT]] ; CHECK-NEXT: ret double [[TMP1]] ; %pow = call nsz double @llvm.pow.f64(double %x, double 5.0e-01) ret double %pow } -; FIXME: ; This is just sqrt. define float @pow_libcall_half_ninf_nsz(float %x) { ; CHECK-LABEL: @pow_libcall_half_ninf_nsz( ; CHECK-NEXT: [[SQRTF:%.*]] = call ninf nsz float @sqrtf(float [[X:%.*]]) -; CHECK-NEXT: [[ABS:%.*]] = call ninf nsz float @llvm.fabs.f32(float [[SQRTF]]) -; CHECK-NEXT: [[ISINF:%.*]] = fcmp ninf nsz oeq float [[X]], 0xFFF0000000000000 -; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], float 0x7FF0000000000000, float [[ABS]] -; CHECK-NEXT: ret float [[TMP1]] +; CHECK-NEXT: ret float [[SQRTF]] ; %pow = call ninf nsz float @powf(float %x, float 5.0e-01) ret float %pow } -; FIXME: - define double @pow_intrinsic_half_ninf_nsz(double %x) { ; CHECK-LABEL: @pow_intrinsic_half_ninf_nsz( -; CHECK-NEXT: [[SQRT:%.*]] = call ninf nsz double @sqrt(double [[X:%.*]]) #1 -; CHECK-NEXT: [[ABS:%.*]] = call ninf nsz double @llvm.fabs.f64(double [[SQRT]]) -; CHECK-NEXT: [[ISINF:%.*]] = fcmp ninf nsz oeq double [[X]], 0xFFF0000000000000 -; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]] -; CHECK-NEXT: ret double [[TMP1]] +; CHECK-NEXT: [[SQRT:%.*]] = call ninf nsz double @llvm.sqrt.f64(double [[X:%.*]]) +; CHECK-NEXT: ret double [[SQRT]] ; %pow = call ninf nsz double @llvm.pow.f64(double %x, double 5.0e-01) ret double %pow @@ -151,100 +143,108 @@ define double @pow_intrinsic_half_fast(double %x) { ; CHECK-LABEL: @pow_intrinsic_half_fast( -; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.sqrt.f64(double [[X:%.*]]) -; CHECK-NEXT: ret double [[TMP1]] +; CHECK-NEXT: [[SQRT:%.*]] = call fast double @llvm.sqrt.f64(double [[X:%.*]]) +; CHECK-NEXT: ret double [[SQRT]] ; %pow = call fast double @llvm.pow.f64(double %x, double 5.0e-01) ret double %pow } -; FIXME: ; -0.5 means take the reciprocal. define float @pow_libcall_neghalf_no_FMF(float %x) { ; CHECK-LABEL: @pow_libcall_neghalf_no_FMF( -; CHECK-NEXT: [[POW:%.*]] = call float @powf(float [[X:%.*]], float -5.000000e-01) -; CHECK-NEXT: ret float [[POW]] +; CHECK-NEXT: [[SQRTF:%.*]] = call float @sqrtf(float [[X:%.*]]) +; CHECK-NEXT: [[ABS:%.*]] = call float @llvm.fabs.f32(float [[SQRTF]]) +; CHECK-NEXT: [[ISINF:%.*]] = fcmp oeq float [[X]], 0xFFF0000000000000 +; CHECK-NEXT: [[ABS_OP:%.*]] = fdiv float 1.000000e+00, [[ABS]] +; CHECK-NEXT: [[RECIPROCAL:%.*]] = select i1 [[ISINF]], float 0.000000e+00, float [[ABS_OP]] +; CHECK-NEXT: ret float [[RECIPROCAL]] ; %pow = call float @powf(float %x, float -5.0e-01) ret float %pow } -; FIXME: - define <2 x double> @pow_intrinsic_neghalf_no_FMF(<2 x double> %x) { ; CHECK-LABEL: @pow_intrinsic_neghalf_no_FMF( -; CHECK-NEXT: [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> ) -; CHECK-NEXT: ret <2 x double> [[POW]] +; CHECK-NEXT: [[SQRT:%.*]] = call <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X:%.*]]) +; CHECK-NEXT: [[ABS:%.*]] = call <2 x double> @llvm.fabs.v2f64(<2 x double> [[SQRT]]) +; CHECK-NEXT: [[ISINF:%.*]] = fcmp oeq <2 x double> [[X]], +; CHECK-NEXT: [[ABS_OP:%.*]] = fdiv <2 x double> , [[ABS]] +; CHECK-NEXT: [[RECIPROCAL:%.*]] = select <2 x i1> [[ISINF]], <2 x double> zeroinitializer, <2 x double> [[ABS_OP]] +; CHECK-NEXT: ret <2 x double> [[RECIPROCAL]] ; %pow = call <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> ) ret <2 x double> %pow } -; FIXME: ; If we can disregard INFs, no need for a select. define double @pow_libcall_neghalf_ninf(double %x) { ; CHECK-LABEL: @pow_libcall_neghalf_ninf( -; CHECK-NEXT: [[POW:%.*]] = call ninf double @pow(double [[X:%.*]], double -5.000000e-01) -; CHECK-NEXT: ret double [[POW]] +; CHECK-NEXT: [[SQRT:%.*]] = call ninf double @sqrt(double [[X:%.*]]) +; CHECK-NEXT: [[ABS:%.*]] = call ninf double @llvm.fabs.f64(double [[SQRT]]) +; CHECK-NEXT: [[RECIPROCAL:%.*]] = fdiv ninf double 1.000000e+00, [[ABS]] +; CHECK-NEXT: ret double [[RECIPROCAL]] ; %pow = call ninf double @pow(double %x, double -5.0e-01) ret double %pow } -; FIXME: - define <2 x double> @pow_intrinsic_neghalf_ninf(<2 x double> %x) { ; CHECK-LABEL: @pow_intrinsic_neghalf_ninf( -; CHECK-NEXT: [[POW:%.*]] = call ninf <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> ) -; CHECK-NEXT: ret <2 x double> [[POW]] +; CHECK-NEXT: [[SQRT:%.*]] = call ninf <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X:%.*]]) +; CHECK-NEXT: [[ABS:%.*]] = call ninf <2 x double> @llvm.fabs.v2f64(<2 x double> [[SQRT]]) +; CHECK-NEXT: [[RECIPROCAL:%.*]] = fdiv ninf <2 x double> , [[ABS]] +; CHECK-NEXT: ret <2 x double> [[RECIPROCAL]] ; %pow = call ninf <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> ) ret <2 x double> %pow } -; FIXME: ; If we can disregard -0.0, no need for fabs. define double @pow_libcall_neghalf_nsz(double %x) { ; CHECK-LABEL: @pow_libcall_neghalf_nsz( -; CHECK-NEXT: [[POW:%.*]] = call nsz double @pow(double [[X:%.*]], double -5.000000e-01) -; CHECK-NEXT: ret double [[POW]] +; CHECK-NEXT: [[SQRT:%.*]] = call nsz double @sqrt(double [[X:%.*]]) +; CHECK-NEXT: [[ISINF:%.*]] = fcmp nsz oeq double [[X]], 0xFFF0000000000000 +; CHECK-NEXT: [[SQRT_OP:%.*]] = fdiv nsz double 1.000000e+00, [[SQRT]] +; CHECK-NEXT: [[RECIPROCAL:%.*]] = select i1 [[ISINF]], double 0.000000e+00, double [[SQRT_OP]] +; CHECK-NEXT: ret double [[RECIPROCAL]] ; %pow = call nsz double @pow(double %x, double -5.0e-01) ret double %pow } -; FIXME: - define double @pow_intrinsic_neghalf_nsz(double %x) { ; CHECK-LABEL: @pow_intrinsic_neghalf_nsz( -; CHECK-NEXT: [[POW:%.*]] = call nsz double @llvm.pow.f64(double [[X:%.*]], double -5.000000e-01) -; CHECK-NEXT: ret double [[POW]] +; CHECK-NEXT: [[SQRT:%.*]] = call nsz double @llvm.sqrt.f64(double [[X:%.*]]) +; CHECK-NEXT: [[ISINF:%.*]] = fcmp nsz oeq double [[X]], 0xFFF0000000000000 +; CHECK-NEXT: [[SQRT_OP:%.*]] = fdiv nsz double 1.000000e+00, [[SQRT]] +; CHECK-NEXT: [[RECIPROCAL:%.*]] = select i1 [[ISINF]], double 0.000000e+00, double [[SQRT_OP]] +; CHECK-NEXT: ret double [[RECIPROCAL]] ; %pow = call nsz double @llvm.pow.f64(double %x, double -5.0e-01) ret double %pow } -; FIXME: ; This is just recip-sqrt. define double @pow_intrinsic_neghalf_ninf_nsz(double %x) { ; CHECK-LABEL: @pow_intrinsic_neghalf_ninf_nsz( -; CHECK-NEXT: [[POW:%.*]] = call ninf nsz double @llvm.pow.f64(double [[X:%.*]], double -5.000000e-01) -; CHECK-NEXT: ret double [[POW]] +; CHECK-NEXT: [[SQRT:%.*]] = call ninf nsz double @llvm.sqrt.f64(double [[X:%.*]]) +; CHECK-NEXT: [[RECIPROCAL:%.*]] = fdiv ninf nsz double 1.000000e+00, [[SQRT]] +; CHECK-NEXT: ret double [[RECIPROCAL]] ; %pow = call ninf nsz double @llvm.pow.f64(double %x, double -5.0e-01) ret double %pow } -; FIXME: - define float @pow_libcall_neghalf_ninf_nsz(float %x) { ; CHECK-LABEL: @pow_libcall_neghalf_ninf_nsz( -; CHECK-NEXT: [[POW:%.*]] = call ninf nsz float @powf(float [[X:%.*]], float -5.000000e-01) -; CHECK-NEXT: ret float [[POW]] +; CHECK-NEXT: [[SQRTF:%.*]] = call ninf nsz float @sqrtf(float [[X:%.*]]) +; CHECK-NEXT: [[RECIPROCAL:%.*]] = fdiv ninf nsz float 1.000000e+00, [[SQRTF]] +; CHECK-NEXT: ret float [[RECIPROCAL]] ; %pow = call ninf nsz float @powf(float %x, float -5.0e-01) ret float %pow @@ -262,10 +262,23 @@ ret float %pow } +define float @powf_libcall_neghalf_approx(float %x) { +; CHECK-LABEL: @powf_libcall_neghalf_approx( +; CHECK-NEXT: [[SQRTF:%.*]] = call afn float @sqrtf(float [[X:%.*]]) +; CHECK-NEXT: [[ABS:%.*]] = call afn float @llvm.fabs.f32(float [[SQRTF]]) +; CHECK-NEXT: [[ISINF:%.*]] = fcmp afn oeq float [[X]], 0xFFF0000000000000 +; CHECK-NEXT: [[ABS_OP:%.*]] = fdiv afn float 1.000000e+00, [[ABS]] +; CHECK-NEXT: [[RECIPROCAL:%.*]] = select i1 [[ISINF]], float 0.000000e+00, float [[ABS_OP]] +; CHECK-NEXT: ret float [[RECIPROCAL]] +; + %pow = call afn float @powf(float %x, float -5.0e-01) + ret float %pow +} + define double @pow_intrinsic_neghalf_fast(double %x) { ; CHECK-LABEL: @pow_intrinsic_neghalf_fast( -; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.sqrt.f64(double [[X:%.*]]) -; CHECK-NEXT: [[RECIPROCAL:%.*]] = fdiv fast double 1.000000e+00, [[TMP1]] +; CHECK-NEXT: [[SQRT:%.*]] = call fast double @llvm.sqrt.f64(double [[X:%.*]]) +; CHECK-NEXT: [[RECIPROCAL:%.*]] = fdiv fast double 1.000000e+00, [[SQRT]] ; CHECK-NEXT: ret double [[RECIPROCAL]] ; %pow = call fast double @llvm.pow.f64(double %x, double -5.0e-01) @@ -273,7 +286,10 @@ } declare double @llvm.pow.f64(double, double) #0 +declare float @llvm.pow.f32(float, float) #0 declare <2 x double> @llvm.pow.v2f64(<2 x double>, <2 x double>) #0 +declare <2 x float> @llvm.pow.v2f32(<2 x float>, <2 x float>) #0 +declare <4 x float> @llvm.pow.v4f32(<4 x float>, <4 x float>) #0 declare double @pow(double, double) declare float @powf(float, float)