[llvm] c21f1fe - ValueTracking: Drop rounding mode check for constrained_sqrt in CannotBeNegativeZero
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Mon May 22 02:49:44 PDT 2023
Author: Matt Arsenault
Date: 2023-05-22T10:49:10+01:00
New Revision: c21f1feed390a818458ebd069424ca80b0e4dfd5
URL: https://github.com/llvm/llvm-project/commit/c21f1feed390a818458ebd069424ca80b0e4dfd5
DIFF: https://github.com/llvm/llvm-project/commit/c21f1feed390a818458ebd069424ca80b0e4dfd5.diff
LOG: ValueTracking: Drop rounding mode check for constrained_sqrt in CannotBeNegativeZero
The only value that can produce -0 is exactly -0, no rounding is involved. If the
denormal mode has flushed denormal inputs, a negative value could produce -0.
The constrained intrinsics do not track the denormal mode, and this is just
generally broken in the current set of FP predicates. The move to computeKnownFPClass
will address some of these issues.
Added:
Modified:
llvm/lib/Analysis/ValueTracking.cpp
llvm/test/Transforms/InstSimplify/strictfp-sqrt-nonneg.ll
Removed:
################################################################################
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index cc056b5526aef..ece00132b51fb 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -3817,18 +3817,12 @@ bool llvm::CannotBeNegativeZero(const Value *V, const TargetLibraryInfo *TLI,
switch (IID) {
default:
break;
- // sqrt(-0.0) = -0.0, no other negative results are possible.
case Intrinsic::sqrt:
+ case Intrinsic::experimental_constrained_sqrt:
+ // sqrt(-0.0) = -0.0, no other negative results are possible.
+ // FIXME: Account for denormal-fp-math=preserve-sign denormal inputs
case Intrinsic::canonicalize:
return CannotBeNegativeZero(Call->getArgOperand(0), TLI, Depth + 1);
- case Intrinsic::experimental_constrained_sqrt: {
- // NOTE: This rounding mode restriction may be too strict.
- const auto *CI = cast<ConstrainedFPIntrinsic>(Call);
- if (CI->getRoundingMode() == RoundingMode::NearestTiesToEven)
- return CannotBeNegativeZero(Call->getArgOperand(0), TLI, Depth + 1);
- else
- return false;
- }
// fabs(x) != -0.0
case Intrinsic::fabs:
return true;
diff --git a/llvm/test/Transforms/InstSimplify/strictfp-sqrt-nonneg.ll b/llvm/test/Transforms/InstSimplify/strictfp-sqrt-nonneg.ll
index 2ed2802dd8ee7..a1294561a3d9e 100644
--- a/llvm/test/Transforms/InstSimplify/strictfp-sqrt-nonneg.ll
+++ b/llvm/test/Transforms/InstSimplify/strictfp-sqrt-nonneg.ll
@@ -81,15 +81,14 @@ define float @nonneg_s_ebstrict(i32 %a) #0 {
ret float %sub
}
-; Test all the rounding modes. Exception handling shouldn't matter.
+; Test all the rounding modes. Rounding mode and exception handling
+; shouldn't matter.
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_u_downward(i32 %a) #0 {
; CHECK-LABEL: @nonneg_u_downward(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[A:%.*]], metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %a, metadata !"round.downward", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.downward", metadata !"fpexcept.ignore") #0
@@ -97,13 +96,11 @@ define float @nonneg_u_downward(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_s_downward(i32 %a) #0 {
; CHECK-LABEL: @nonneg_s_downward(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[A:%.*]], metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %a, metadata !"round.downward", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.downward", metadata !"fpexcept.ignore") #0
@@ -111,13 +108,11 @@ define float @nonneg_s_downward(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_u_upward(i32 %a) #0 {
; CHECK-LABEL: @nonneg_u_upward(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[A:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %a, metadata !"round.upward", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.upward", metadata !"fpexcept.ignore") #0
@@ -125,13 +120,11 @@ define float @nonneg_u_upward(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_s_upward(i32 %a) #0 {
; CHECK-LABEL: @nonneg_s_upward(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[A:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %a, metadata !"round.upward", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.upward", metadata !"fpexcept.ignore") #0
@@ -139,13 +132,11 @@ define float @nonneg_s_upward(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_u_towardzero(i32 %a) #0 {
; CHECK-LABEL: @nonneg_u_towardzero(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[A:%.*]], metadata !"round.towardzero", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.towardzero", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.towardzero", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %a, metadata !"round.towardzero", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.towardzero", metadata !"fpexcept.ignore") #0
@@ -153,13 +144,11 @@ define float @nonneg_u_towardzero(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_s_towardzero(i32 %a) #0 {
; CHECK-LABEL: @nonneg_s_towardzero(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[A:%.*]], metadata !"round.towardzero", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.towardzero", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.towardzero", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %a, metadata !"round.towardzero", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.towardzero", metadata !"fpexcept.ignore") #0
@@ -167,13 +156,11 @@ define float @nonneg_s_towardzero(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_u_tonearestaway(i32 %a) #0 {
; CHECK-LABEL: @nonneg_u_tonearestaway(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[A:%.*]], metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %a, metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #0
@@ -181,13 +168,11 @@ define float @nonneg_u_tonearestaway(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_s_tonearestaway(i32 %a) #0 {
; CHECK-LABEL: @nonneg_s_tonearestaway(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[A:%.*]], metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %a, metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.tonearestaway", metadata !"fpexcept.ignore") #0
@@ -195,13 +180,11 @@ define float @nonneg_s_tonearestaway(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_u_dynamic(i32 %a) #0 {
; CHECK-LABEL: @nonneg_u_dynamic(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[A:%.*]], metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %a, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
@@ -209,13 +192,11 @@ define float @nonneg_u_dynamic(i32 %a) #0 {
ret float %sub
}
-; Negative test: should not fire due to rounding mode metadata.
define float @nonneg_s_dynamic(i32 %a) #0 {
; CHECK-LABEL: @nonneg_s_dynamic(
; CHECK-NEXT: [[FPA:%.*]] = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[A:%.*]], metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: [[SQRA:%.*]] = call float @llvm.experimental.constrained.sqrt.f32(float [[FPA]], metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: [[SUB:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[SQRA]], float -0.000000e+00, metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT: ret float [[SUB]]
+; CHECK-NEXT: ret float [[SQRA]]
;
%fpa = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %a, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
%sqra = call float @llvm.experimental.constrained.sqrt.f32(float %fpa, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
More information about the llvm-commits
mailing list