[llvm] [KnownFPClass] Refine fdiv and fdiv_self class propagation + some minor fixes for propagateXorSign (PR #215014)
via llvm-commits
llvm-commits at lists.llvm.org
Sat Aug 8 12:48:43 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-support
Author: Max Graey (MaxGraey)
<details>
<summary>Changes</summary>
- **`fdiv`** now better handle subnormals. The quotient can be subnormal only when the divisor is normal and can be zero only when the dividend is zero, when divisor is infinite or division underflows. When either operand can only be zero, inf or nan, quotient narrows to two classes.
- **`fdiv_self`**. `x / x` is exactly +1.0 for a finite nonzero `x` and NaN for everything else.
- Fix **`propagateXorSign`** under a positive-zero input mode a negative subnormal operand is read as `+0.0`, so it no longer counts as negative. The same minor bug affected `fmul`.
---
Patch is 38.05 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/215014.diff
4 Files Affected:
- (modified) llvm/include/llvm/Support/KnownFPClass.h (+25-5)
- (modified) llvm/lib/Support/KnownFPClass.cpp (+41-8)
- (modified) llvm/test/Transforms/Attributor/nofpclass-fdiv.ll (+219-27)
- (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fdiv.ll (+12-17)
``````````diff
diff --git a/llvm/include/llvm/Support/KnownFPClass.h b/llvm/include/llvm/Support/KnownFPClass.h
index 956141b9449a2..e4217eddb261f 100644
--- a/llvm/include/llvm/Support/KnownFPClass.h
+++ b/llvm/include/llvm/Support/KnownFPClass.h
@@ -100,6 +100,10 @@ struct KnownFPClass {
/// zero.
LLVM_ABI bool isKnownNeverLogicalPosZero(DenormalMode Mode) const;
+ /// Return true if it's known this can never be interpreted as a finite
+ /// nonzero value, accounting for denormals the mode reads as zero.
+ LLVM_ABI bool isKnownNeverLogicalFiniteNonZero(DenormalMode Mode) const;
+
static constexpr FPClassTest OrderedLessThanZeroMask =
fcNegSubnormal | fcNegNormal | fcNegInf;
static constexpr FPClassTest OrderedGreaterThanZeroMask =
@@ -395,13 +399,29 @@ struct KnownFPClass {
// Propagate knowledge for operations whose result sign is the xor of the
// operand signs, such as multiply and divide. This only rules out possible
// non-NaN sign classes. NaNs do not have a constrained sign class here.
- void propagateXorSign(const KnownFPClass &LHS, const KnownFPClass &RHS) {
- if ((LHS.isKnownNever(fcNegative) && RHS.isKnownNever(fcNegative)) ||
- (LHS.isKnownNever(fcPositive) && RHS.isKnownNever(fcPositive)))
+ //
+ // A negative subnormal is read as +0.0 under a positive-zero input mode, so
+ // it counts towards the positive side and not the negative one.
+ //
+ // TODO: With a positive-zero output mode a -sub result is flushed to +0.0, so
+ // the result can be positive after all. Fix it in fmul and fdiv by adding
+ // fcPosZero back and dropping SignBit before they rule out fcSubnormal.
+ void propagateXorSign(const KnownFPClass &LHS, const KnownFPClass &RHS,
+ DenormalMode Mode) {
+ bool MustFlushNegSub = Mode.Input == DenormalMode::PositiveZero;
+ bool MayFlushNegSub = Mode.inputsMayBePositiveZero();
+
+ FPClassTest NegMask =
+ MustFlushNegSub ? fcNegative & ~fcNegSubnormal : fcNegative;
+ FPClassTest PosMask =
+ MayFlushNegSub ? fcPositive | fcNegSubnormal : fcPositive;
+
+ if ((LHS.isKnownNever(NegMask) && RHS.isKnownNever(NegMask)) ||
+ (LHS.isKnownNever(PosMask) && RHS.isKnownNever(PosMask)))
knownNot(fcNegative);
- if ((LHS.isKnownNever(fcPositive) && RHS.isKnownNever(fcNegative)) ||
- (LHS.isKnownNever(fcNegative) && RHS.isKnownNever(fcPositive)))
+ if ((LHS.isKnownNever(PosMask) && RHS.isKnownNever(NegMask)) ||
+ (LHS.isKnownNever(NegMask) && RHS.isKnownNever(PosMask)))
knownNot(fcPositive);
}
diff --git a/llvm/lib/Support/KnownFPClass.cpp b/llvm/lib/Support/KnownFPClass.cpp
index eccd83451a05f..1cd08315ff2fd 100644
--- a/llvm/lib/Support/KnownFPClass.cpp
+++ b/llvm/lib/Support/KnownFPClass.cpp
@@ -65,6 +65,11 @@ bool KnownFPClass::isKnownNeverLogicalPosZero(DenormalMode Mode) const {
llvm_unreachable("covered switch over denormal mode");
}
+bool KnownFPClass::isKnownNeverLogicalFiniteNonZero(DenormalMode Mode) const {
+ return isKnownNever(fcNormal) &&
+ (isKnownNeverSubnormal() || Mode.inputsAreZero());
+}
+
void KnownFPClass::propagateDenormal(const KnownFPClass &Src,
DenormalMode Mode) {
KnownFPClasses = Src.KnownFPClasses;
@@ -362,7 +367,7 @@ KnownFPClass KnownFPClass::fmul(const KnownFPClass &KnownLHS,
// +X * +Y or -X * -Y => +Q
// +X * -Y or -X * +Y => -Q
- Known.propagateXorSign(KnownLHS, KnownRHS);
+ Known.propagateXorSign(KnownLHS, KnownRHS, Mode);
// Inf * Y => Inf or NaN
if (KnownLHS.isKnownAlways(fcInf | fcNan) ||
@@ -432,14 +437,35 @@ KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS,
// X / -0.0 => -Inf (or NaN)
// +X / +Y or -X / -Y => +Q
// +X / -Y or -X / +Y => -Q
- Known.propagateXorSign(KnownLHS, KnownRHS);
+ Known.propagateXorSign(KnownLHS, KnownRHS, Mode);
- // 0 / X => 0 or NaN
- if (KnownLHS.isKnownAlways(fcZero))
+ // {0, Inf, NaN} / Y => {0, Inf, NaN}
+ if (KnownLHS.isKnownNeverLogicalFiniteNonZero(Mode))
+ Known.knownNot(fcNormal | fcSubnormal);
+
+ // X / 0 => Inf
+ // X / Sub => Normal or Inf
+ // X / Inf => 0
+ if (KnownRHS.isKnownNever(fcNormal) || Mode.outputsAreZero())
+ Known.knownNot(fcSubnormal);
+
+ // 0 / Y => 0
+ // X / Inf => 0
+ // X / Normal => 0 on underflow
+ if (KnownLHS.isKnownNeverLogicalZero(Mode) &&
+ KnownRHS.isKnownNever(fcNormal | fcInf))
+ Known.knownNot(fcZero);
+
+ // {0, NaN} / Y => 0 or NaN
+ // X / {Inf, NaN} => 0 or NaN
+ if (KnownLHS.isKnownAlways(fcZero | fcNan) ||
+ KnownRHS.isKnownAlways(fcInf | fcNan))
Known.knownNot(fcSubnormal | fcNormal | fcInf);
- // X / 0 => NaN or Inf
- if (KnownRHS.isKnownAlways(fcZero))
+ // {Inf, NaN} / Y => Inf or NaN
+ // X / {0, NaN} => Inf or NaN
+ if (KnownLHS.isKnownAlways(fcInf | fcNan) ||
+ KnownRHS.isKnownAlways(fcZero | fcNan))
Known.knownNot(fcFinite);
return Known;
@@ -447,16 +473,23 @@ KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS,
KnownFPClass KnownFPClass::fdiv_self(const KnownFPClass &KnownSrc,
DenormalMode Mode) {
- // X / X is always exactly 1.0 or a NaN.
+ // X / X is always exactly +1.0 or NaN.
KnownFPClass Known(fcNan | fcPosNormal);
+ // X / X => +1.0 only for finite nonzero X
+ if (KnownSrc.isKnownNeverLogicalFiniteNonZero(Mode))
+ Known.knownNot(fcPosNormal);
+
+ // X / X => NaN only for 0, Inf and NaN
if (KnownSrc.isKnownNeverInfOrNaN() && KnownSrc.isKnownNeverLogicalZero(Mode))
Known.knownNot(fcNan);
- else if (KnownSrc.isKnownNever(fcSNan))
+
+ if (KnownSrc.isKnownNever(fcSNan))
Known.knownNot(fcSNan);
return Known;
}
+
KnownFPClass KnownFPClass::frem_self(const KnownFPClass &KnownSrc,
DenormalMode Mode) {
// X % X is always exactly [+-]0.0 or a NaN.
diff --git a/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll b/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
index fef871a1e85f7..432a12bb1e86b 100644
--- a/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
+++ b/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
@@ -589,7 +589,7 @@ define float @ret_fdiv_f32_known_zero_or_nan_lhs(float nofpclass(inf norm sub) %
}
define float @ret_fdiv_f32_known_zero_or_nan_rhs(float %arg0, float nofpclass(inf norm sub) %arg1) {
-; CHECK-LABEL: define float @ret_fdiv_f32_known_zero_or_nan_rhs
+; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fdiv_f32_known_zero_or_nan_rhs
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(inf sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -629,7 +629,7 @@ define float @ret_fdiv_f32_known_pzero_or_nan_lhs(float nofpclass(inf norm sub n
}
define float @ret_fdiv_f32_known_pzero_or_nan_rhs(float %arg0, float nofpclass(inf norm sub nzero) %arg1) {
-; CHECK-LABEL: define float @ret_fdiv_f32_known_pzero_or_nan_rhs
+; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fdiv_f32_known_pzero_or_nan_rhs
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(inf nzero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -669,7 +669,7 @@ define float @ret_fdiv_f32_known_nzero_or_nan_lhs(float nofpclass(inf norm sub p
}
define float @ret_fdiv_f32_known_nzero_or_nan_rhs(float %arg0, float nofpclass(inf norm sub pzero) %arg1) {
-; CHECK-LABEL: define float @ret_fdiv_f32_known_nzero_or_nan_rhs
+; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fdiv_f32_known_nzero_or_nan_rhs
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(inf pzero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -709,7 +709,7 @@ define float @ret_fdiv_f32_known_inf_or_nan_lhs(float nofpclass(zero norm sub) %
}
define float @ret_fdiv_f32_known_inf_or_nan_rhs(float %arg0, float nofpclass(zero norm sub) %arg1) {
-; CHECK-LABEL: define float @ret_fdiv_f32_known_inf_or_nan_rhs
+; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fdiv_f32_known_inf_or_nan_rhs
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -729,7 +729,7 @@ define float @ret_fdiv_f32_known_inf_lhs(float nofpclass(nan zero norm sub) %arg
}
define float @ret_fdiv_f32_known_inf_rhs(float %arg0, float nofpclass(nan zero norm sub) %arg1) {
-; CHECK-LABEL: define float @ret_fdiv_f32_known_inf_rhs
+; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fdiv_f32_known_inf_rhs
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -749,7 +749,7 @@ define float @ret_fdiv_f32_known_pinf_or_nan_lhs(float nofpclass(ninf zero norm
}
define float @ret_fdiv_f32_known_pinf_or_nan_rhs(float %arg0, float nofpclass(ninf zero norm sub) %arg1) {
-; CHECK-LABEL: define float @ret_fdiv_f32_known_pinf_or_nan_rhs
+; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fdiv_f32_known_pinf_or_nan_rhs
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(ninf zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -769,7 +769,7 @@ define float @ret_fdiv_f32_known_ninf_or_nan_lhs(float nofpclass(pinf zero norm
}
define float @ret_fdiv_f32_known_ninf_or_nan_rhs(float %arg0, float nofpclass(pinf zero norm sub) %arg1) {
-; CHECK-LABEL: define float @ret_fdiv_f32_known_ninf_or_nan_rhs
+; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fdiv_f32_known_ninf_or_nan_rhs
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(pinf zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -802,7 +802,7 @@ define float @ret_known_inf_or_nan_fdiv_known_zero(float nofpclass(norm sub zero
; -> nan
define float @ret_known_inf_fdiv_known_zero_or_nan(float nofpclass(nan norm sub zero) %arg0, float nofpclass(inf norm sub) %arg1) {
-; CHECK-LABEL: define float @ret_known_inf_fdiv_known_zero_or_nan
+; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_known_inf_fdiv_known_zero_or_nan
; CHECK-SAME: (float nofpclass(nan zero sub norm) [[ARG0:%.*]], float nofpclass(inf sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -846,7 +846,7 @@ define float @ret_known_zero_fdiv_known_inf(float nofpclass(nan inf norm sub) %a
; -> zero
define float @ret_known_zero_fdiv_known_inf_or_nan(float nofpclass(nan inf norm sub) %arg0, float nofpclass(norm sub zero) %arg1) {
-; CHECK-LABEL: define float @ret_known_zero_fdiv_known_inf_or_nan
+; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_known_zero_fdiv_known_inf_or_nan
; CHECK-SAME: (float nofpclass(nan inf sub norm) [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -857,7 +857,7 @@ define float @ret_known_zero_fdiv_known_inf_or_nan(float nofpclass(nan inf norm
; -> zero or nan
define float @ret_known_zero_or_nan_fdiv_known_inf(float nofpclass(inf norm sub) %arg0, float nofpclass(nan norm sub zero) %arg1) {
-; CHECK-LABEL: define float @ret_known_zero_or_nan_fdiv_known_inf
+; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_known_zero_or_nan_fdiv_known_inf
; CHECK-SAME: (float nofpclass(inf sub norm) [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -870,7 +870,7 @@ define float @ret_known_zero_or_nan_fdiv_known_inf(float nofpclass(inf norm sub)
define float @ret_fdiv_lhs_known_positive_or_nan(float %lhs, float %rhs) {
; CHECK-LABEL: define float @ret_fdiv_lhs_known_positive_or_nan
; CHECK-SAME: (float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR4]] {
-; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR6:[0-9]+]]
+; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR8:[0-9]+]]
; CHECK-NEXT: [[MUL:%.*]] = fdiv float [[LHS_FABS]], [[RHS]]
; CHECK-NEXT: ret float [[MUL]]
;
@@ -883,7 +883,7 @@ define float @ret_fdiv_lhs_known_positive_or_nan(float %lhs, float %rhs) {
define float @ret_fdiv_rhs_known_positive_or_nan(float %lhs, float %rhs) {
; CHECK-LABEL: define float @ret_fdiv_rhs_known_positive_or_nan
; CHECK-SAME: (float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR4]] {
-; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR6]]
+; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR8]]
; CHECK-NEXT: [[MUL:%.*]] = fdiv float [[LHS]], [[RHS_FABS]]
; CHECK-NEXT: ret float [[MUL]]
;
@@ -896,8 +896,8 @@ define float @ret_fdiv_rhs_known_positive_or_nan(float %lhs, float %rhs) {
define float @ret_fdiv_both_signs_positive_or_nan(float %lhs, float %rhs) {
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_fdiv_both_signs_positive_or_nan
; CHECK-SAME: (float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR4]] {
-; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR6]]
-; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR6]]
+; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR8]]
+; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR8]]
; CHECK-NEXT: [[MUL:%.*]] = fdiv float [[LHS_FABS]], [[RHS_FABS]]
; CHECK-NEXT: ret float [[MUL]]
;
@@ -911,8 +911,8 @@ define float @ret_fdiv_both_signs_positive_or_nan(float %lhs, float %rhs) {
define float @ret_fdiv_both_signs_negative_or_nan(float %lhs, float %rhs) {
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_fdiv_both_signs_negative_or_nan
; CHECK-SAME: (float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR4]] {
-; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR6]]
-; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR6]]
+; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR8]]
+; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR8]]
; CHECK-NEXT: [[LHS_NEG_FABS:%.*]] = fneg float [[LHS_FABS]]
; CHECK-NEXT: [[RHS_NEG_FABS:%.*]] = fneg float [[RHS_FABS]]
; CHECK-NEXT: [[MUL:%.*]] = fdiv float [[LHS_NEG_FABS]], [[RHS_NEG_FABS]]
@@ -930,8 +930,8 @@ define float @ret_fdiv_both_signs_negative_or_nan(float %lhs, float %rhs) {
define float @ret_fdiv_lhs_negative_rhs_positive(float %lhs, float %rhs) {
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_fdiv_lhs_negative_rhs_positive
; CHECK-SAME: (float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR4]] {
-; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR6]]
-; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR6]]
+; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR8]]
+; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR8]]
; CHECK-NEXT: [[LHS_NEG_FABS:%.*]] = fneg float [[LHS_FABS]]
; CHECK-NEXT: [[MUL:%.*]] = fdiv float [[LHS_NEG_FABS]], [[RHS_FABS]]
; CHECK-NEXT: ret float [[MUL]]
@@ -947,8 +947,8 @@ define float @ret_fdiv_lhs_negative_rhs_positive(float %lhs, float %rhs) {
define float @ret_fdiv_rhs_negative_lhs_positive(float %lhs, float %rhs) {
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_fdiv_rhs_negative_lhs_positive
; CHECK-SAME: (float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR4]] {
-; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR6]]
-; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR6]]
+; CHECK-NEXT: [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR8]]
+; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR8]]
; CHECK-NEXT: [[RHS_NEG_FABS:%.*]] = fneg float [[RHS_FABS]]
; CHECK-NEXT: [[MUL:%.*]] = fdiv float [[LHS_FABS]], [[RHS_NEG_FABS]]
; CHECK-NEXT: ret float [[MUL]]
@@ -962,7 +962,7 @@ define float @ret_fdiv_rhs_negative_lhs_positive(float %lhs, float %rhs) {
; Could be inf of either sign
define float @ret_known_inf_fdiv_known_inf(float nofpclass(norm sub zero nan) %arg0, float nofpclass(norm sub zero nan) %arg1) {
-; CHECK-LABEL: define float @ret_known_inf_fdiv_known_inf
+; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_inf_fdiv_known_inf
; CHECK-SAME: (float nofpclass(nan zero sub norm) [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -973,7 +973,7 @@ define float @ret_known_inf_fdiv_known_inf(float nofpclass(norm sub zero nan) %a
; Could be inf of either sign, or nan
define float @ret_known_inf_fdiv_known_inf_or_nan(float nofpclass(norm sub zero nan) %arg0, float nofpclass(norm sub zero) %arg1) {
-; CHECK-LABEL: define float @ret_known_inf_fdiv_known_inf_or_nan
+; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_known_inf_fdiv_known_inf_or_nan
; CHECK-SAME: (float nofpclass(nan zero sub norm) [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -984,7 +984,7 @@ define float @ret_known_inf_fdiv_known_inf_or_nan(float nofpclass(norm sub zero
; Could be inf of either sign, or nan
define float @ret_known_inf_or_nan_fdiv_known_inf(float nofpclass(norm sub zero) %arg0, float nofpclass(norm sub zero nan) %arg1) {
-; CHECK-LABEL: define float @ret_known_inf_or_nan_fdiv_known_inf
+; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_inf_or_nan_fdiv_known_inf
; CHECK-SAME: (float nofpclass(zero sub norm) [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -1006,7 +1006,7 @@ define float @ret_known_zero_fdiv_known_zero(float nofpclass(inf norm sub nan) %
; Could be zero of either sign, or nan
define float @ret_known_zero_fdiv_known_zero_or_nan(float nofpclass(inf norm sub nan) %arg0, float nofpclass(inf norm sub) %arg1) {
-; CHECK-LABEL: define float @ret_known_zero_fdiv_known_zero_or_nan
+; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_known_zero_fdiv_known_zero_or_nan
; CHECK-SAME: (float nofpclass(nan inf sub norm) [[ARG0:%.*]], float nofpclass(inf sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -1017,7 +1017,7 @@ define float @ret_known_zero_fdiv_known_zero_or_nan(float nofpclass(inf norm sub
; Could be zero of either sign, or nan
define float @ret_known_zero_or_nan_fdiv_known_zero(float nofpclass(inf norm sub) %arg0, float nofpclass(inf norm sub nan) %arg1) {
-; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_known_zero_or_nan_fdiv_known_zero
+; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_zero_or_nan_fdiv_known_zero
; CHECK-SAME: (float nofpclass(inf sub norm) [[ARG0:%.*]], float nofpclass(nan inf sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]]
@@ -1037,7 +1037,7 @@ define float @ret_known_inf_or_nan_fdiv_unknown(float nofpclass(norm sub zero) %
}
define float @ret_unknown_fdiv_known_inf_or_nan(float %arg0, float nofpclass(norm sub zero) %arg1) {
-; CHECK-LABEL: define float @ret_unknown_fdiv_known_inf_or_nan
+; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_unknown_fdiv_known_inf_or_nan
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FDIV]...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/215014
More information about the llvm-commits
mailing list