[llvm] 8f111ec - InstSimplify: Split isKnownNeverInfinity tests into separate file
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Thu Dec 22 06:38:22 PST 2022
Author: Matt Arsenault
Date: 2022-12-22T09:38:14-05:00
New Revision: 8f111ecd75fce9d20b96a0f6b521d8efb30fbed7
URL: https://github.com/llvm/llvm-project/commit/8f111ecd75fce9d20b96a0f6b521d8efb30fbed7
DIFF: https://github.com/llvm/llvm-project/commit/8f111ecd75fce9d20b96a0f6b521d8efb30fbed7.diff
LOG: InstSimplify: Split isKnownNeverInfinity tests into separate file
This fixes an annoying assymmetry in the test organization. We have
known-never-nan.ll for dedicated isKnownNeverNaN handling tests, but
the isKnownNeverInfinity were in floating-point-compare.ll. Move the
more targeted tests into a separate file to match.
Added:
llvm/test/Transforms/InstSimplify/known-never-infinity.ll
Modified:
llvm/test/Transforms/InstSimplify/floating-point-compare.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/InstSimplify/floating-point-compare.ll b/llvm/test/Transforms/InstSimplify/floating-point-compare.ll
index a8c3ffff7bf5..1c05707c1a83 100644
--- a/llvm/test/Transforms/InstSimplify/floating-point-compare.ll
+++ b/llvm/test/Transforms/InstSimplify/floating-point-compare.ll
@@ -169,27 +169,6 @@ define i1 @one_with_self(double %arg) {
; and between uge and olt, to give reasonble coverage
; without combinatorial explosion.
-declare half @llvm.fabs.f16(half)
-declare float @llvm.fabs.f32(float)
-declare double @llvm.fabs.f64(double)
-declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
-declare <3 x float> @llvm.fabs.v3f32(<3 x float>)
-declare <2 x double> @llvm.fabs.v2f64(<2 x double>)
-declare float @llvm.sqrt.f32(float)
-declare double @llvm.powi.f64.i32(double,i32)
-declare float @llvm.exp.f32(float)
-declare float @llvm.minnum.f32(float, float)
-declare <2 x float> @llvm.minnum.v2f32(<2 x float>, <2 x float>)
-declare float @llvm.maxnum.f32(float, float)
-declare <2 x float> @llvm.maxnum.v2f32(<2 x float>, <2 x float>)
-declare float @llvm.maximum.f32(float, float)
-declare double @llvm.exp2.f64(double)
-declare float @llvm.fma.f32(float,float,float)
-declare double @llvm.canonicalize.f64(double)
-declare double @llvm.copysign.f64(double, double)
-
-declare void @expect_equal(i1,i1)
-
define i1 @orderedLessZeroTree(float,float,float,float) {
; CHECK-LABEL: @orderedLessZeroTree(
; CHECK-NEXT: ret i1 true
@@ -1152,1007 +1131,19 @@ define <2 x i1> @is_finite_commute(<2 x i8> %x) {
ret <2 x i1> %r
}
-; largest unsigned i15 = 2^15 - 1 = 32767
-; largest half (max exponent = 15 -> 2^15 * (1 + 1023/1024) = 65504
-
-define i1 @isKnownNeverInfinity_uitofp(i15 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_uitofp(
-; CHECK-NEXT: ret i1 true
-;
- %f = uitofp i15 %x to half
- %r = fcmp une half %f, 0xH7c00
- ret i1 %r
-}
-
-; negative test
-
-define i1 @isNotKnownNeverInfinity_uitofp(i16 %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_uitofp(
-; CHECK-NEXT: [[F:%.*]] = uitofp i16 [[X:%.*]] to half
-; CHECK-NEXT: [[R:%.*]] = fcmp une half [[F]], 0xH7C00
-; CHECK-NEXT: ret i1 [[R]]
-;
- %f = uitofp i16 %x to half
- %r = fcmp une half %f, 0xH7c00
- ret i1 %r
-}
-
-define i1 @isKnownNeverNegativeInfinity_uitofp(i15 %x) {
-; CHECK-LABEL: @isKnownNeverNegativeInfinity_uitofp(
-; CHECK-NEXT: ret i1 false
-;
- %f = uitofp i15 %x to half
- %r = fcmp oeq half %f, 0xHfc00
- ret i1 %r
-}
-
-; uitofp can't be negative, so this still works.
-
-define i1 @isNotKnownNeverNegativeInfinity_uitofp(i16 %x) {
-; CHECK-LABEL: @isNotKnownNeverNegativeInfinity_uitofp(
-; CHECK-NEXT: ret i1 false
-;
- %f = uitofp i16 %x to half
- %r = fcmp oeq half %f, 0xHfc00
- ret i1 %r
-}
-
-; largest magnitude signed i16 = 2^15 - 1 = 32767 --> -32768
-; largest half (max exponent = 15 -> 2^15 * (1 + 1023/1024) = 65504
-
-define i1 @isKnownNeverInfinity_sitofp(i16 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_sitofp(
-; CHECK-NEXT: ret i1 true
-;
- %f = sitofp i16 %x to half
- %r = fcmp une half %f, 0xH7c00
- ret i1 %r
-}
-
-; negative test
-
-define i1 @isNotKnownNeverInfinity_sitofp(i17 %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_sitofp(
-; CHECK-NEXT: [[F:%.*]] = sitofp i17 [[X:%.*]] to half
-; CHECK-NEXT: [[R:%.*]] = fcmp une half [[F]], 0xH7C00
-; CHECK-NEXT: ret i1 [[R]]
-;
- %f = sitofp i17 %x to half
- %r = fcmp une half %f, 0xH7c00
- ret i1 %r
-}
-
-define i1 @isKnownNeverNegativeInfinity_sitofp(i16 %x) {
-; CHECK-LABEL: @isKnownNeverNegativeInfinity_sitofp(
-; CHECK-NEXT: ret i1 false
-;
- %f = sitofp i16 %x to half
- %r = fcmp oeq half %f, 0xHfc00
- ret i1 %r
-}
-
-; negative test
-
-define i1 @isNotKnownNeverNegativeInfinity_sitofp(i17 %x) {
-; CHECK-LABEL: @isNotKnownNeverNegativeInfinity_sitofp(
-; CHECK-NEXT: [[F:%.*]] = sitofp i17 [[X:%.*]] to half
-; CHECK-NEXT: [[R:%.*]] = fcmp oeq half [[F]], 0xHFC00
-; CHECK-NEXT: ret i1 [[R]]
-;
- %f = sitofp i17 %x to half
- %r = fcmp oeq half %f, 0xHfc00
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_fpext(float %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fpext(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf float %x, 1.0
- %e = fpext float %a to double
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_fpext_sitofp(i16 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fpext_sitofp(
-; CHECK-NEXT: ret i1 false
-;
- %f = sitofp i16 %x to half
- %e = fpext half %f to double
- %r = fcmp oeq double %e, 0xfff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_fptrunc(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fptrunc(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = fptrunc double [[A]] to float
-; CHECK-NEXT: [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf double %x, 1.0
- %e = fptrunc double %a to float
- %r = fcmp une float %e, 0x7FF0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_fptrunc(double %unknown) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fptrunc(
-; CHECK-NEXT: [[E:%.*]] = fptrunc double [[UNKNOWN:%.*]] to float
-; CHECK-NEXT: [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = fptrunc double %unknown to float
- %r = fcmp une float %e, 0x7FF0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_canonicalize(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_canonicalize(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.canonicalize.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_canonicalize(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_canonicalize(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.canonicalize.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.canonicalize.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_fabs(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fabs(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.fabs.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_fabs(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fabs(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.fabs.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.fabs.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_fneg(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fneg(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = fneg double %a
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_fneg(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fneg(
-; CHECK-NEXT: [[E:%.*]] = fneg double [[X:%.*]]
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = fneg double %x
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_copysign(double %x, double %sign) {
-; CHECK-LABEL: @isKnownNeverInfinity_copysign(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.copysign.f64(double %a, double %sign)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_copysign(double %x, double %sign) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_copysign(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.copysign.f64(double [[X:%.*]], double [[SIGN:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.copysign.f64(double %x, double %sign)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_arithmetic_fence(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_arithmetic_fence(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.arithmetic.fence.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_arithmetic_fence(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_arithmetic_fence(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.arithmetic.fence.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.arithmetic.fence.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.arithmetic.fence.f64(double)
-
-define i1 @isKnownNeverInfinity_floor(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_floor(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.floor.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_floor(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_floor(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.floor.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.floor.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.floor.f64(double)
-
-define i1 @isKnownNeverInfinity_ceil(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_ceil(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.ceil.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_ceil(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_ceil(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.ceil.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.ceil.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.ceil.f64(double)
-
-define i1 @isKnownNeverInfinity_trunc(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_trunc(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.trunc.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_trunc(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_trunc(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.trunc.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.trunc.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.trunc.f64(double)
-
-define i1 @isKnownNeverInfinity_rint(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_rint(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.rint.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_rint(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_rint(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.rint.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.rint.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.rint.f64(double)
-
-define i1 @isKnownNeverInfinity_nearbyint(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_nearbyint(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.nearbyint.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_nearbyint(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_nearbyint(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.nearbyint.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.nearbyint.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.nearbyint.f64(double)
-
-define i1 @isKnownNeverInfinity_round(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_round(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.round.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_round(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_round(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.round.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.round.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.round.f64(double)
-
-define i1 @isKnownNeverInfinity_roundeven(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_roundeven(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.roundeven.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_roundeven(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_roundeven(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.roundeven.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.roundeven.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.roundeven.f64(double)
-
-define i1 @isNotKnownNeverInfinity_fptrunc_round(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fptrunc_round(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[A]], metadata !"round.downward")
-; CHECK-NEXT: [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf double %x, 1.0
- %e = call float @llvm.fptrunc.round.f32.f64(double %a, metadata !"round.downward")
- %r = fcmp une float %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare float @llvm.fptrunc.round.f32.f64(double, metadata)
-
-declare ppc_fp128 @llvm.floor.ppcf128(ppc_fp128)
-
-define i1 @isKnownNeverInfinity_floor_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_floor_ppcf128(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
-; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf ppc_fp128 %x, %x
- %e = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %a)
- %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
- ret i1 %r
-}
-
-declare ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128)
-
-define i1 @isKnownNeverInfinity_ceil_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_ceil_ppcf128(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
-; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf ppc_fp128 %x, %x
- %e = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %a)
- %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
- ret i1 %r
-}
-
-declare ppc_fp128 @llvm.rint.ppcf128(ppc_fp128)
-
-define i1 @isKnownNeverInfinity_rint_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_rint_ppcf128(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
-; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf ppc_fp128 %x, %x
- %e = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %a)
- %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
- ret i1 %r
-}
-
-declare ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128)
-
-define i1 @isKnownNeverInfinity_nearbyint_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_nearbyint_ppcf128(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
-; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf ppc_fp128 %x, %x
- %e = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %a)
- %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
- ret i1 %r
-}
-
-declare ppc_fp128 @llvm.round.ppcf128(ppc_fp128)
-
-define i1 @isKnownNeverInfinity_round_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_round_ppcf128(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
-; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf ppc_fp128 %x, %x
- %e = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %a)
- %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
- ret i1 %r
-}
-
-declare ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128)
-
-define i1 @isKnownNeverInfinity_roundeven_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_roundeven_ppcf128(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
-; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf ppc_fp128 %x, %x
- %e = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %a)
- %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
- ret i1 %r
-}
-
-declare ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128)
-
-define i1 @isKnownNeverInfinity_trunc_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_trunc_ppcf128(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf ppc_fp128 %x, %x
- %e = call ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 %a)
- %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
- ret i1 %r
-}
-
-declare x86_fp80 @llvm.ceil.f80(x86_fp80)
-
-define i1 @isKnownNeverInfinity_ceil_x86_fp80(x86_fp80 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_ceil_x86_fp80(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf x86_fp80 %x, %x
- %e = call x86_fp80 @llvm.ceil.f80(x86_fp80 %a)
- %r = fcmp une x86_fp80 %e, 0xK7FFF8000000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverInfinity_minnum(double %x, double %y) {
-; CHECK-LABEL: @isKnownNeverInfinity_minnum(
-; CHECK-NEXT: ret i1 true
-;
- %ninf.x = fadd ninf double %x, 1.0
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.minnum.f64(double %ninf.x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-define i1 @isNotKnownNeverInfinity_minnum_lhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_minnum_lhs(
-; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.minnum.f64(double [[X:%.*]], double [[NINF_Y]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.minnum.f64(double %x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-define i1 @isNotKnownNeverInfinity_minnum_rhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_minnum_rhs(
-; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.minnum.f64(double [[NINF_X]], double [[Y:%.*]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.x = fadd ninf double %x, 1.0
- %op = call double @llvm.minnum.f64(double %ninf.x, double %y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-declare double @llvm.minnum.f64(double, double)
-
-define i1 @isKnownNeverInfinity_maxnum(double %x, double %y) {
-; CHECK-LABEL: @isKnownNeverInfinity_maxnum(
-; CHECK-NEXT: ret i1 true
-;
- %ninf.x = fadd ninf double %x, 1.0
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.maxnum.f64(double %ninf.x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-define i1 @isNotKnownNeverInfinity_maxnum_lhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_maxnum_lhs(
-; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double [[NINF_Y]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.maxnum.f64(double %x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-define i1 @isNotKnownNeverInfinity_maxnum_rhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_maxnum_rhs(
-; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.maxnum.f64(double [[NINF_X]], double [[Y:%.*]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.x = fadd ninf double %x, 1.0
- %op = call double @llvm.maxnum.f64(double %ninf.x, double %y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-declare double @llvm.maxnum.f64(double, double)
-
-define i1 @isKnownNeverInfinity_minimum(double %x, double %y) {
-; CHECK-LABEL: @isKnownNeverInfinity_minimum(
-; CHECK-NEXT: ret i1 true
-;
- %ninf.x = fadd ninf double %x, 1.0
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.minimum.f64(double %ninf.x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-define i1 @isNotKnownNeverInfinity_minimum_lhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_minimum_lhs(
-; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.minimum.f64(double [[X:%.*]], double [[NINF_Y]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.minimum.f64(double %x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-define i1 @isNotKnownNeverInfinity_minimum_rhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_minimum_rhs(
-; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.minimum.f64(double [[NINF_X]], double [[Y:%.*]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.x = fadd ninf double %x, 1.0
- %op = call double @llvm.minimum.f64(double %ninf.x, double %y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-declare double @llvm.minimum.f64(double, double)
-
-define i1 @isKnownNeverInfinity_maximum(double %x, double %y) {
-; CHECK-LABEL: @isKnownNeverInfinity_maximum(
-; CHECK-NEXT: ret i1 true
-;
- %ninf.x = fadd ninf double %x, 1.0
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.maximum.f64(double %ninf.x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-define i1 @isNotKnownNeverInfinity_maximum_lhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_maximum_lhs(
-; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.maximum.f64(double [[X:%.*]], double [[NINF_Y]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.maximum.f64(double %x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-define i1 @isNotKnownNeverInfinity_maximum_rhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_maximum_rhs(
-; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.maximum.f64(double [[NINF_X]], double [[Y:%.*]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.x = fadd ninf double %x, 1.0
- %op = call double @llvm.maximum.f64(double %ninf.x, double %y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-declare double @llvm.maximum.f64(double, double)
-
-define i1 @isKnownNeverInfinity_sqrt(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_sqrt(
-; CHECK-NEXT: ret i1 true
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.sqrt.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_sqrt(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_sqrt(
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %e = call double @llvm.sqrt.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.sqrt.f64(double)
-
-; No source check required
-define i1 @isKnownNeverInfinity_sin(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_sin(
-; CHECK-NEXT: ret i1 true
-;
- %e = call double @llvm.sin.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.sin.f64(double)
-
-; No source check required
-define i1 @isKnownNeverInfinity_cos(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_cos(
-; CHECK-NEXT: ret i1 true
-;
- %e = call double @llvm.cos.f64(double %x)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.cos.f64(double)
-
-define i1 @isKnownNeverInfinity_log(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_log(
-; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log.f64(double [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
- %a = fadd ninf double %x.clamp.zero, 1.0
- %e = call double @llvm.log.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_log_maybe_negative(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log_maybe_negative(
-; CHECK-NEXT: [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log.f64(double [[X_NOT_INF]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
-
- %x.not.inf = fadd ninf double %x, 1.0
- %e = call double @llvm.log.f64(double %x.not.inf)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_log_maybe_inf(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log_maybe_inf(
-; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log.f64(double [[X_CLAMP_ZERO]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
- %e = call double @llvm.log.f64(double %x.clamp.zero)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverNegInfinity_log_maybe_0(double %x) {
-; CHECK-LABEL: @isKnownNeverNegInfinity_log_maybe_0(
-; CHECK-NEXT: [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log.f64(double [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = call ninf double @llvm.sqrt.f64(double %x) ; could be 0.0
- %e = call double @llvm.log.f64(double %a) ; log(0.0) --> -inf
- %r = fcmp une double %e, 0xfff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.log.f64(double)
-
-define i1 @isKnownNeverInfinity_log10(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_log10(
-; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log10.f64(double [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
- %a = fadd ninf double %x.clamp.zero, 1.0
- %e = call double @llvm.log10.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_log10_maybe_negative(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log10_maybe_negative(
-; CHECK-NEXT: [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log10.f64(double [[X_NOT_INF]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
-
- %x.not.inf = fadd ninf double %x, 1.0
- %e = call double @llvm.log10.f64(double %x.not.inf)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_log10_maybe_inf(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log10_maybe_inf(
-; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log10.f64(double [[X_CLAMP_ZERO]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
- %e = call double @llvm.log10.f64(double %x.clamp.zero)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverNegInfinity_log10_maybe_0(double %x) {
-; CHECK-LABEL: @isKnownNeverNegInfinity_log10_maybe_0(
-; CHECK-NEXT: [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log10.f64(double [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = call ninf double @llvm.sqrt.f64(double %x) ; could be 0.0
- %e = call double @llvm.log10.f64(double %a) ; log(0.0) --> -inf
- %r = fcmp une double %e, 0xfff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.log10.f64(double)
-
-define i1 @isKnownNeverInfinity_log2(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_log2(
-; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log2.f64(double [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
- %a = fadd ninf double %x.clamp.zero, 1.0
- %e = call double @llvm.log2.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_log2_maybe_negative(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log2_maybe_negative(
-; CHECK-NEXT: [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log2.f64(double [[X_NOT_INF]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
-
- %x.not.inf = fadd ninf double %x, 1.0
- %e = call double @llvm.log2.f64(double %x.not.inf)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_log2_maybe_inf(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log2_maybe_inf(
-; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log2.f64(double [[X_CLAMP_ZERO]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
- %e = call double @llvm.log2.f64(double %x.clamp.zero)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isKnownNeverNegInfinity_log2_maybe_0(double %x) {
-; CHECK-LABEL: @isKnownNeverNegInfinity_log2_maybe_0(
-; CHECK-NEXT: [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.log2.f64(double [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = call ninf double @llvm.sqrt.f64(double %x) ; could be 0.0
- %e = call double @llvm.log2.f64(double %a) ; log(0.0) --> -inf
- %r = fcmp une double %e, 0xfff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.log2.f64(double)
-
-define i1 @isNotKnownNeverInfinity_pow(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_pow(
-; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.pow.f64(double [[NINF_X]], double [[NINF_Y]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.x = fadd ninf double %x, 1.0
- %ninf.y = fadd ninf double %y, 1.0
- %op = call double @llvm.pow.f64(double %ninf.x, double %ninf.y)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-declare double @llvm.pow.f64(double, double)
-
-define i1 @isNotKnownNeverInfinity_powi(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_powi(
-; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.powi.f64.i32(double [[NINF_X]], i32 2)
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.x = fadd ninf double %x, 1.0
- %op = call double @llvm.powi.f64.i32(double %ninf.x, i32 2)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-declare double @llvm.powi.f64(double, i32)
-
-define i1 @isNotKnownNeverInfinity_exp(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_exp(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.exp.f64(double [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.exp.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-declare double @llvm.exp.f64(double)
-
-define i1 @isNotKnownNeverInfinity_exp2(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_exp2(
-; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[E:%.*]] = call double @llvm.exp2.f64(double [[A]])
-; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[R]]
-;
- %a = fadd ninf double %x, 1.0
- %e = call double @llvm.exp2.f64(double %a)
- %r = fcmp une double %e, 0x7ff0000000000000
- ret i1 %r
-}
-
-define i1 @isNotKnownNeverInfinity_fma(double %x, double %y, double %z) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fma(
-; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT: [[NINF_Z:%.*]] = fadd ninf double [[Z:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.fma.f64(double [[NINF_X]], double [[NINF_Y]], double [[NINF_Z]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.x = fadd ninf double %x, 1.0
- %ninf.y = fadd ninf double %y, 1.0
- %ninf.z = fadd ninf double %z, 1.0
- %op = call double @llvm.fma.f64(double %ninf.x, double %ninf.y, double %ninf.z)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-declare double @llvm.fma.f64(double, double, double)
-
-define i1 @isNotKnownNeverInfinity_fmuladd(double %x, double %y, double %z) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fmuladd(
-; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT: [[NINF_Z:%.*]] = fadd ninf double [[Z:%.*]], 1.000000e+00
-; CHECK-NEXT: [[OP:%.*]] = call double @llvm.fmuladd.f64(double [[NINF_X]], double [[NINF_Y]], double [[NINF_Z]])
-; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
-; CHECK-NEXT: ret i1 [[CMP]]
-;
- %ninf.x = fadd ninf double %x, 1.0
- %ninf.y = fadd ninf double %y, 1.0
- %ninf.z = fadd ninf double %z, 1.0
- %op = call double @llvm.fmuladd.f64(double %ninf.x, double %ninf.y, double %ninf.z)
- %cmp = fcmp une double %op, 0x7ff0000000000000
- ret i1 %cmp
-}
-
-declare double @llvm.fmuladd.f64(double, double, double)
+declare <2 x double> @llvm.fabs.v2f64(<2 x double>)
+declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
+declare <2 x float> @llvm.maxnum.v2f32(<2 x float>, <2 x float>)
+declare <2 x float> @llvm.minnum.v2f32(<2 x float>, <2 x float>)
+declare <3 x float> @llvm.fabs.v3f32(<3 x float>)
+declare double @llvm.exp2.f64(double)
+declare double @llvm.fabs.f64(double)
+declare double @llvm.powi.f64.i32(double, i32)
+declare float @llvm.exp.f32(float)
+declare float @llvm.fabs.f32(float)
+declare float @llvm.fma.f32(float, float, float)
+declare float @llvm.maximum.f32(float, float)
+declare float @llvm.maxnum.f32(float, float)
+declare float @llvm.minnum.f32(float, float)
+declare float @llvm.sqrt.f32(float)
+declare half @llvm.fabs.f16(half)
diff --git a/llvm/test/Transforms/InstSimplify/known-never-infinity.ll b/llvm/test/Transforms/InstSimplify/known-never-infinity.ll
new file mode 100644
index 000000000000..da044aa64e54
--- /dev/null
+++ b/llvm/test/Transforms/InstSimplify/known-never-infinity.ll
@@ -0,0 +1,979 @@
+; RUN: opt < %s -S -passes=instsimplify | FileCheck %s
+
+; largest unsigned i15 = 2^15 - 1 = 32767
+; largest half (max exponent = 15 -> 2^15 * (1 + 1023/1024) = 65504
+
+define i1 @isKnownNeverInfinity_uitofp(i15 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_uitofp(
+; CHECK-NEXT: ret i1 true
+;
+ %f = uitofp i15 %x to half
+ %r = fcmp une half %f, 0xH7c00
+ ret i1 %r
+}
+
+; negative test
+
+define i1 @isNotKnownNeverInfinity_uitofp(i16 %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_uitofp(
+; CHECK-NEXT: [[F:%.*]] = uitofp i16 [[X:%.*]] to half
+; CHECK-NEXT: [[R:%.*]] = fcmp une half [[F]], 0xH7C00
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %f = uitofp i16 %x to half
+ %r = fcmp une half %f, 0xH7c00
+ ret i1 %r
+}
+
+define i1 @isKnownNeverNegativeInfinity_uitofp(i15 %x) {
+; CHECK-LABEL: @isKnownNeverNegativeInfinity_uitofp(
+; CHECK-NEXT: ret i1 false
+;
+ %f = uitofp i15 %x to half
+ %r = fcmp oeq half %f, 0xHfc00
+ ret i1 %r
+}
+
+; uitofp can't be negative, so this still works.
+
+define i1 @isNotKnownNeverNegativeInfinity_uitofp(i16 %x) {
+; CHECK-LABEL: @isNotKnownNeverNegativeInfinity_uitofp(
+; CHECK-NEXT: ret i1 false
+;
+ %f = uitofp i16 %x to half
+ %r = fcmp oeq half %f, 0xHfc00
+ ret i1 %r
+}
+
+; largest magnitude signed i16 = 2^15 - 1 = 32767 --> -32768
+; largest half (max exponent = 15 -> 2^15 * (1 + 1023/1024) = 65504
+
+define i1 @isKnownNeverInfinity_sitofp(i16 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_sitofp(
+; CHECK-NEXT: ret i1 true
+;
+ %f = sitofp i16 %x to half
+ %r = fcmp une half %f, 0xH7c00
+ ret i1 %r
+}
+
+; negative test
+
+define i1 @isNotKnownNeverInfinity_sitofp(i17 %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_sitofp(
+; CHECK-NEXT: [[F:%.*]] = sitofp i17 [[X:%.*]] to half
+; CHECK-NEXT: [[R:%.*]] = fcmp une half [[F]], 0xH7C00
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %f = sitofp i17 %x to half
+ %r = fcmp une half %f, 0xH7c00
+ ret i1 %r
+}
+
+define i1 @isKnownNeverNegativeInfinity_sitofp(i16 %x) {
+; CHECK-LABEL: @isKnownNeverNegativeInfinity_sitofp(
+; CHECK-NEXT: ret i1 false
+;
+ %f = sitofp i16 %x to half
+ %r = fcmp oeq half %f, 0xHfc00
+ ret i1 %r
+}
+
+; negative test
+
+define i1 @isNotKnownNeverNegativeInfinity_sitofp(i17 %x) {
+; CHECK-LABEL: @isNotKnownNeverNegativeInfinity_sitofp(
+; CHECK-NEXT: [[F:%.*]] = sitofp i17 [[X:%.*]] to half
+; CHECK-NEXT: [[R:%.*]] = fcmp oeq half [[F]], 0xHFC00
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %f = sitofp i17 %x to half
+ %r = fcmp oeq half %f, 0xHfc00
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_fpext(float %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_fpext(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf float %x, 1.0
+ %e = fpext float %a to double
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_fpext_sitofp(i16 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_fpext_sitofp(
+; CHECK-NEXT: ret i1 false
+;
+ %f = sitofp i16 %x to half
+ %e = fpext half %f to double
+ %r = fcmp oeq double %e, 0xfff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_fptrunc(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_fptrunc(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = fptrunc double [[A]] to float
+; CHECK-NEXT: [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf double %x, 1.0
+ %e = fptrunc double %a to float
+ %r = fcmp une float %e, 0x7FF0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_fptrunc(double %unknown) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_fptrunc(
+; CHECK-NEXT: [[E:%.*]] = fptrunc double [[UNKNOWN:%.*]] to float
+; CHECK-NEXT: [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = fptrunc double %unknown to float
+ %r = fcmp une float %e, 0x7FF0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_canonicalize(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_canonicalize(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.canonicalize.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_canonicalize(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_canonicalize(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.canonicalize.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.canonicalize.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_fabs(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_fabs(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.fabs.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_fabs(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_fabs(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.fabs.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.fabs.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_fneg(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_fneg(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = fneg double %a
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_fneg(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_fneg(
+; CHECK-NEXT: [[E:%.*]] = fneg double [[X:%.*]]
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = fneg double %x
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_copysign(double %x, double %sign) {
+; CHECK-LABEL: @isKnownNeverInfinity_copysign(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.copysign.f64(double %a, double %sign)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_copysign(double %x, double %sign) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_copysign(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.copysign.f64(double [[X:%.*]], double [[SIGN:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.copysign.f64(double %x, double %sign)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_arithmetic_fence(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_arithmetic_fence(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.arithmetic.fence.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_arithmetic_fence(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_arithmetic_fence(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.arithmetic.fence.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.arithmetic.fence.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_floor(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_floor(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.floor.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_floor(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_floor(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.floor.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.floor.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_ceil(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_ceil(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.ceil.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_ceil(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_ceil(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.ceil.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.ceil.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_trunc(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_trunc(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.trunc.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_trunc(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_trunc(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.trunc.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.trunc.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_rint(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_rint(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.rint.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_rint(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_rint(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.rint.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.rint.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_nearbyint(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_nearbyint(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.nearbyint.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_nearbyint(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_nearbyint(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.nearbyint.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.nearbyint.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_round(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_round(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.round.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_round(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_round(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.round.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.round.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_roundeven(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_roundeven(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.roundeven.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_roundeven(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_roundeven(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.roundeven.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.roundeven.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_fptrunc_round(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_fptrunc_round(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[A]], metadata !"round.downward")
+; CHECK-NEXT: [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call float @llvm.fptrunc.round.f32.f64(double %a, metadata !"round.downward")
+ %r = fcmp une float %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_floor_ppcf128(ppc_fp128 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_floor_ppcf128(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf ppc_fp128 %x, %x
+ %e = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %a)
+ %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_ceil_ppcf128(ppc_fp128 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_ceil_ppcf128(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf ppc_fp128 %x, %x
+ %e = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %a)
+ %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_rint_ppcf128(ppc_fp128 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_rint_ppcf128(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf ppc_fp128 %x, %x
+ %e = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %a)
+ %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_nearbyint_ppcf128(ppc_fp128 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_nearbyint_ppcf128(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf ppc_fp128 %x, %x
+ %e = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %a)
+ %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_round_ppcf128(ppc_fp128 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_round_ppcf128(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf ppc_fp128 %x, %x
+ %e = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %a)
+ %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_roundeven_ppcf128(ppc_fp128 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_roundeven_ppcf128(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-NEXT: [[E:%.*]] = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf ppc_fp128 %x, %x
+ %e = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %a)
+ %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_trunc_ppcf128(ppc_fp128 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_trunc_ppcf128(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf ppc_fp128 %x, %x
+ %e = call ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 %a)
+ %r = fcmp une ppc_fp128 %e, 0xM7FF00000000000000000000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_ceil_x86_fp80(x86_fp80 %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_ceil_x86_fp80(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf x86_fp80 %x, %x
+ %e = call x86_fp80 @llvm.ceil.f80(x86_fp80 %a)
+ %r = fcmp une x86_fp80 %e, 0xK7FFF8000000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_minnum(double %x, double %y) {
+; CHECK-LABEL: @isKnownNeverInfinity_minnum(
+; CHECK-NEXT: ret i1 true
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.minnum.f64(double %ninf.x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_minnum_lhs(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_minnum_lhs(
+; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.minnum.f64(double [[X:%.*]], double [[NINF_Y]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.minnum.f64(double %x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_minnum_rhs(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_minnum_rhs(
+; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.minnum.f64(double [[NINF_X]], double [[Y:%.*]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %op = call double @llvm.minnum.f64(double %ninf.x, double %y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isKnownNeverInfinity_maxnum(double %x, double %y) {
+; CHECK-LABEL: @isKnownNeverInfinity_maxnum(
+; CHECK-NEXT: ret i1 true
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.maxnum.f64(double %ninf.x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_maxnum_lhs(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_maxnum_lhs(
+; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double [[NINF_Y]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.maxnum.f64(double %x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_maxnum_rhs(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_maxnum_rhs(
+; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.maxnum.f64(double [[NINF_X]], double [[Y:%.*]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %op = call double @llvm.maxnum.f64(double %ninf.x, double %y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isKnownNeverInfinity_minimum(double %x, double %y) {
+; CHECK-LABEL: @isKnownNeverInfinity_minimum(
+; CHECK-NEXT: ret i1 true
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.minimum.f64(double %ninf.x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_minimum_lhs(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_minimum_lhs(
+; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.minimum.f64(double [[X:%.*]], double [[NINF_Y]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.minimum.f64(double %x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_minimum_rhs(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_minimum_rhs(
+; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.minimum.f64(double [[NINF_X]], double [[Y:%.*]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %op = call double @llvm.minimum.f64(double %ninf.x, double %y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isKnownNeverInfinity_maximum(double %x, double %y) {
+; CHECK-LABEL: @isKnownNeverInfinity_maximum(
+; CHECK-NEXT: ret i1 true
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.maximum.f64(double %ninf.x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_maximum_lhs(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_maximum_lhs(
+; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.maximum.f64(double [[X:%.*]], double [[NINF_Y]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.maximum.f64(double %x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_maximum_rhs(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_maximum_rhs(
+; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.maximum.f64(double [[NINF_X]], double [[Y:%.*]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %op = call double @llvm.maximum.f64(double %ninf.x, double %y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isKnownNeverInfinity_sqrt(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_sqrt(
+; CHECK-NEXT: ret i1 true
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.sqrt.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_sqrt(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_sqrt(
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %e = call double @llvm.sqrt.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+; No source check required
+define i1 @isKnownNeverInfinity_sin(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_sin(
+; CHECK-NEXT: ret i1 true
+;
+ %e = call double @llvm.sin.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+; No source check required
+define i1 @isKnownNeverInfinity_cos(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_cos(
+; CHECK-NEXT: ret i1 true
+;
+ %e = call double @llvm.cos.f64(double %x)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_log(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_log(
+; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log.f64(double [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
+ %a = fadd ninf double %x.clamp.zero, 1.0
+ %e = call double @llvm.log.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_log_maybe_negative(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_log_maybe_negative(
+; CHECK-NEXT: [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log.f64(double [[X_NOT_INF]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+
+ %x.not.inf = fadd ninf double %x, 1.0
+ %e = call double @llvm.log.f64(double %x.not.inf)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_log_maybe_inf(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_log_maybe_inf(
+; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log.f64(double [[X_CLAMP_ZERO]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
+ %e = call double @llvm.log.f64(double %x.clamp.zero)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverNegInfinity_log_maybe_0(double %x) {
+; CHECK-LABEL: @isKnownNeverNegInfinity_log_maybe_0(
+; CHECK-NEXT: [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log.f64(double [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = call ninf double @llvm.sqrt.f64(double %x) ; could be 0.0
+ %e = call double @llvm.log.f64(double %a) ; log(0.0) --> -inf
+ %r = fcmp une double %e, 0xfff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_log10(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_log10(
+; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log10.f64(double [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
+ %a = fadd ninf double %x.clamp.zero, 1.0
+ %e = call double @llvm.log10.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_log10_maybe_negative(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_log10_maybe_negative(
+; CHECK-NEXT: [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log10.f64(double [[X_NOT_INF]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+
+ %x.not.inf = fadd ninf double %x, 1.0
+ %e = call double @llvm.log10.f64(double %x.not.inf)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_log10_maybe_inf(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_log10_maybe_inf(
+; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log10.f64(double [[X_CLAMP_ZERO]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
+ %e = call double @llvm.log10.f64(double %x.clamp.zero)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverNegInfinity_log10_maybe_0(double %x) {
+; CHECK-LABEL: @isKnownNeverNegInfinity_log10_maybe_0(
+; CHECK-NEXT: [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log10.f64(double [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = call ninf double @llvm.sqrt.f64(double %x) ; could be 0.0
+ %e = call double @llvm.log10.f64(double %a) ; log(0.0) --> -inf
+ %r = fcmp une double %e, 0xfff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverInfinity_log2(double %x) {
+; CHECK-LABEL: @isKnownNeverInfinity_log2(
+; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log2.f64(double [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
+ %a = fadd ninf double %x.clamp.zero, 1.0
+ %e = call double @llvm.log2.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_log2_maybe_negative(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_log2_maybe_negative(
+; CHECK-NEXT: [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log2.f64(double [[X_NOT_INF]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+
+ %x.not.inf = fadd ninf double %x, 1.0
+ %e = call double @llvm.log2.f64(double %x.not.inf)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_log2_maybe_inf(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_log2_maybe_inf(
+; CHECK-NEXT: [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log2.f64(double [[X_CLAMP_ZERO]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
+ %e = call double @llvm.log2.f64(double %x.clamp.zero)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isKnownNeverNegInfinity_log2_maybe_0(double %x) {
+; CHECK-LABEL: @isKnownNeverNegInfinity_log2_maybe_0(
+; CHECK-NEXT: [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.log2.f64(double [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = call ninf double @llvm.sqrt.f64(double %x) ; could be 0.0
+ %e = call double @llvm.log2.f64(double %a) ; log(0.0) --> -inf
+ %r = fcmp une double %e, 0xfff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_pow(double %x, double %y) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_pow(
+; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.pow.f64(double [[NINF_X]], double [[NINF_Y]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %ninf.y = fadd ninf double %y, 1.0
+ %op = call double @llvm.pow.f64(double %ninf.x, double %ninf.y)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_powi(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_powi(
+; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.powi.f64.i32(double [[NINF_X]], i32 2)
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %op = call double @llvm.powi.f64.i32(double %ninf.x, i32 2)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_exp(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_exp(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.exp.f64(double [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.exp.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_exp2(double %x) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_exp2(
+; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[E:%.*]] = call double @llvm.exp2.f64(double [[A]])
+; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %a = fadd ninf double %x, 1.0
+ %e = call double @llvm.exp2.f64(double %a)
+ %r = fcmp une double %e, 0x7ff0000000000000
+ ret i1 %r
+}
+
+define i1 @isNotKnownNeverInfinity_fma(double %x, double %y, double %z) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_fma(
+; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
+; CHECK-NEXT: [[NINF_Z:%.*]] = fadd ninf double [[Z:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.fma.f64(double [[NINF_X]], double [[NINF_Y]], double [[NINF_Z]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %ninf.y = fadd ninf double %y, 1.0
+ %ninf.z = fadd ninf double %z, 1.0
+ %op = call double @llvm.fma.f64(double %ninf.x, double %ninf.y, double %ninf.z)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+define i1 @isNotKnownNeverInfinity_fmuladd(double %x, double %y, double %z) {
+; CHECK-LABEL: @isNotKnownNeverInfinity_fmuladd(
+; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
+; CHECK-NEXT: [[NINF_Z:%.*]] = fadd ninf double [[Z:%.*]], 1.000000e+00
+; CHECK-NEXT: [[OP:%.*]] = call double @llvm.fmuladd.f64(double [[NINF_X]], double [[NINF_Y]], double [[NINF_Z]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %ninf.x = fadd ninf double %x, 1.0
+ %ninf.y = fadd ninf double %y, 1.0
+ %ninf.z = fadd ninf double %z, 1.0
+ %op = call double @llvm.fmuladd.f64(double %ninf.x, double %ninf.y, double %ninf.z)
+ %cmp = fcmp une double %op, 0x7ff0000000000000
+ ret i1 %cmp
+}
+
+declare double @llvm.arithmetic.fence.f64(double)
+declare double @llvm.canonicalize.f64(double)
+declare double @llvm.ceil.f64(double)
+declare double @llvm.copysign.f64(double, double)
+declare double @llvm.cos.f64(double)
+declare double @llvm.exp2.f64(double)
+declare double @llvm.exp.f64(double)
+declare double @llvm.fabs.f64(double)
+declare double @llvm.floor.f64(double)
+declare double @llvm.fma.f64(double, double, double)
+declare double @llvm.fmuladd.f64(double, double, double)
+declare double @llvm.log10.f64(double)
+declare double @llvm.log2.f64(double)
+declare double @llvm.log.f64(double)
+declare double @llvm.maximum.f64(double, double)
+declare double @llvm.maxnum.f64(double, double)
+declare double @llvm.minimum.f64(double, double)
+declare double @llvm.minnum.f64(double, double)
+declare double @llvm.nearbyint.f64(double)
+declare double @llvm.pow.f64(double, double)
+declare double @llvm.powi.f64.i32(double, i32)
+declare double @llvm.rint.f64(double)
+declare double @llvm.roundeven.f64(double)
+declare double @llvm.round.f64(double)
+declare double @llvm.sin.f64(double)
+declare double @llvm.sqrt.f64(double)
+declare double @llvm.trunc.f64(double)
+declare float @llvm.fptrunc.round.f32.f64(double, metadata)
+declare ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128)
+declare ppc_fp128 @llvm.floor.ppcf128(ppc_fp128)
+declare ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128)
+declare ppc_fp128 @llvm.rint.ppcf128(ppc_fp128)
+declare ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128)
+declare ppc_fp128 @llvm.round.ppcf128(ppc_fp128)
+declare ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128)
+declare x86_fp80 @llvm.ceil.f80(x86_fp80)
More information about the llvm-commits
mailing list