forked from OSchip/llvm-project
[InstCombine] Expand the simplification of pow(x, 0.5) to sqrt(x)
Expand the number of cases when `pow(x, 0.5)` is simplified into `sqrt(x)` by considering the math semantics with more granularity. Differential revision: https://reviews.llvm.org/D50036 llvm-svn: 339887
This commit is contained in:
Evandro Menezes
parent
0a1e2f9f7e
commit
c05c7e11bb
|
|
@ -1181,12 +1181,9 @@ static Value *getPow(Value *InnerChain[33], unsigned Exp, IRBuilder<> &B) {
|
|||
|
||||
/// 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 @@ Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B) {
|
|||
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 @@ Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
|
|||
// 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<CallInst>(Base);
|
||||
if (BaseFn && BaseFn->isFast() && Pow->isFast()) {
|
||||
LibFunc LibFn;
|
||||
|
|
@ -1299,28 +1310,6 @@ Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
|
|||
if (Value *Sqrt = replacePowWithSqrt(Pow, B))
|
||||
return Sqrt;
|
||||
|
||||
// FIXME: Correct the transforms and pull this into replacePowWithSqrt().
|
||||
ConstantFP *ExpoC = dyn_cast<ConstantFP>(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))) {
|
||||
|
|
|
|||
|
|
@ -293,7 +293,7 @@ define <2 x double> @pow_neg1_double_fastv(<2 x double> %x) {
|
|||
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]]
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ define double @pow_libcall_half_no_FMF(double %x) {
|
|||
|
||||
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 @@ define double @pow_libcall_half_approx(double %x) {
|
|||
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> <double 5.000000e-01, double 5.000000e-01>)
|
||||
; 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]], <double 0xFFF0000000000000, double 0xFFF0000000000000>
|
||||
; CHECK-NEXT: [[TMP1:%.*]] = select <2 x i1> [[ISINF]], <2 x double> <double 0x7FF0000000000000, double 0x7FF0000000000000>, <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> <double 5.0e-01, double 5.0e-01>)
|
||||
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> <double 5.000000e-01, double 5.000000e-01>)
|
||||
; 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> <double 5.0e-01, double 5.0e-01>)
|
||||
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 float @pow_libcall_half_fast(float %x) {
|
|||
|
||||
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> <double -5.000000e-01, double -5.000000e-01>)
|
||||
; 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]], <double 0xFFF0000000000000, double 0xFFF0000000000000>
|
||||
; CHECK-NEXT: [[ABS_OP:%.*]] = fdiv <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[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> <double -5.0e-01, double -5.0e-01>)
|
||||
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> <double -5.000000e-01, double -5.000000e-01>)
|
||||
; 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> <double 1.000000e+00, double 1.000000e+00>, [[ABS]]
|
||||
; CHECK-NEXT: ret <2 x double> [[RECIPROCAL]]
|
||||
;
|
||||
%pow = call ninf <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double -5.0e-01, double -5.0e-01>)
|
||||
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 @@ define float @pow_libcall_neghalf_fast(float %x) {
|
|||
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 @@ define double @pow_intrinsic_neghalf_fast(double %x) {
|
|||
}
|
||||
|
||||
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)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue