[llvm] [Support][KnownFPClass] Generalize scaling refinement to an exponent range (PR #215094)
via llvm-commits
llvm-commits at lists.llvm.org
Sun Aug 9 06:26:24 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-globalisel
Author: Max Graey (MaxGraey)
<details>
<summary>Changes</summary>
Added:
- `propagateExpRange`. Shared refinement for a value scaled by a factor in `[2^LoExp, 2^HiExp]` which used in `fdiv` (by const), `fmul` (by const), `fadd_self` and `ldexp`
- `fdiv` (by const variant) wired up in `ValueTracking` and `GISel`.
Improved:
- `fmul` by constant, `ldexp` and `fadd_self` share the helper now, each gets more precise
- Non-growing scale rules out normals too, not just `Inf`s.
- Exact output flush table so `positivezero` no longer blocks `-0.0`
- `fdiv` no longer gives up when caller asks only about positive classes.
Fixed:
- `ppc_fp128` (double-double arith) reports precision `0` so any non-shrinking scale claimed "never subnormal". Hit `fmul` by constant and `ldexp`
- `ldexp` ruled out zero even when flushing output could make one from a subnormal result
---
Patch is 135.42 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/215094.diff
11 Files Affected:
- (modified) llvm/include/llvm/Support/KnownFPClass.h (+13-1)
- (modified) llvm/lib/Analysis/ValueTracking.cpp (+21-15)
- (modified) llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp (+17-7)
- (modified) llvm/lib/Support/KnownFPClass.cpp (+104-51)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp (+1-1)
- (modified) llvm/test/Transforms/Attributor/nofpclass-fdiv.ll (+295-10)
- (modified) llvm/test/Transforms/Attributor/nofpclass-fmul.ll (+173-15)
- (modified) llvm/test/Transforms/Attributor/nofpclass-ldexp.ll (+216-101)
- (modified) llvm/test/Transforms/Attributor/nofpclass.ll (+61-13)
- (modified) llvm/test/Transforms/InstCombine/fptoui-of-fdiv.ll (+1-4)
- (modified) llvm/unittests/CodeGen/GlobalISel/KnownFPClassTest.cpp (+23)
``````````diff
diff --git a/llvm/include/llvm/Support/KnownFPClass.h b/llvm/include/llvm/Support/KnownFPClass.h
index 956141b9449a2..ed4af9b18af29 100644
--- a/llvm/include/llvm/Support/KnownFPClass.h
+++ b/llvm/include/llvm/Support/KnownFPClass.h
@@ -248,7 +248,7 @@ struct KnownFPClass {
/// Report known values for fadd x, x
LLVM_ABI static KnownFPClass
- fadd_self(const KnownFPClass &Src,
+ fadd_self(const KnownFPClass &Src, const fltSemantics &Sem,
DenormalMode Mode = DenormalMode::getDynamic());
/// Report known values for fsub
@@ -281,6 +281,10 @@ struct KnownFPClass {
fdiv(const KnownFPClass &LHS, const KnownFPClass &RHS,
DenormalMode Mode = DenormalMode::getDynamic());
+ LLVM_ABI static KnownFPClass
+ fdiv(const KnownFPClass &LHS, const APFloat &RHS,
+ DenormalMode Mode = DenormalMode::getDynamic());
+
/// Report known values for fdiv x, x
LLVM_ABI static KnownFPClass
fdiv_self(const KnownFPClass &Src,
@@ -405,6 +409,14 @@ struct KnownFPClass {
knownNot(fcPositive);
}
+ /// Refine the known classes of Src scaled by a factor with magnitude in
+ /// [2^LoExp, 2^HiExp], as ldexp and a constant multiply or divide do. A
+ /// scale that cannot grow rules out infinities and normals, one that cannot
+ /// shrink rules out subnormals and zeroes. NegativeScale flips the sign.
+ LLVM_ABI void propagateExpRange(const KnownFPClass &Src, int LoExp, int HiExp,
+ bool NegativeScale, const fltSemantics &Sem,
+ DenormalMode Mode);
+
/// Propagate knowledge from a source value that could be a denormal or
/// zero. We have to be conservative since output flushing is not guaranteed,
/// so known-never-zero may not hold.
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 44a1240f5635a..66f587f950f6b 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -5592,18 +5592,17 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
break;
}
case Intrinsic::ldexp: {
+ // Ruling out a zero result also reads the source subnormal classes.
+ FPClassTest InterestedSrcs = InterestedClasses;
+ if (InterestedClasses & fcZero)
+ InterestedSrcs |= fcSubnormal;
+
KnownFPClass KnownSrc;
- computeKnownFPClass(II->getArgOperand(0), DemandedElts, InterestedClasses,
+ computeKnownFPClass(II->getArgOperand(0), DemandedElts, InterestedSrcs,
KnownSrc, Q, Depth + 1);
- // Can refine inf/zero handling based on the exponent operand.
- const FPClassTest ExpInfoMask = fcZero | fcSubnormal | fcInf;
- const Value *ExpArg = II->getArgOperand(1);
- ConstantRange ExpKnownRange =
- ((KnownSrc.KnownFPClasses & ExpInfoMask) != fcNone)
- ? computeConstantRange(ExpArg, /*ForSigned=*/true, Q, Depth + 1)
- : ConstantRange::getFull(
- ExpArg->getType()->getScalarSizeInBits());
+ ConstantRange ExpKnownRange = computeConstantRange(
+ II->getArgOperand(1), /*ForSigned=*/true, Q, Depth + 1);
const fltSemantics &Flt =
II->getType()->getScalarType()->getFltSemantics();
@@ -5811,7 +5810,7 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
F ? F->getDenormalMode(FltSem) : DenormalMode::getDynamic();
if (Self && Opc == Instruction::FAdd) {
- Known = KnownFPClass::fadd_self(KnownLHS, Mode);
+ Known = KnownFPClass::fadd_self(KnownLHS, FltSem, Mode);
} else {
// RHS is canonically cheaper to compute. Skip inspecting the LHS if
// there's no point.
@@ -5852,6 +5851,7 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
const APFloat *CRHS;
if (match(RHS, m_APFloat(CRHS))) {
+ KnownRHS = KnownFPClass(*CRHS);
computeKnownFPClass(LHS, DemandedElts, fcAllFlags, KnownLHS, Q,
Depth + 1);
Known = KnownFPClass::fmul(KnownLHS, *CRHS, Mode);
@@ -5913,17 +5913,22 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
break;
}
+ // A constant divisor bounds the scale factor, which refines both signs.
+ const APFloat *CRHS = nullptr;
+ if (Opc == Instruction::FDiv)
+ match(Op->getOperand(1), m_APFloat(CRHS));
+
const bool WantNegative = (InterestedClasses & fcNegative) != fcNone;
- const bool WantPositive =
- Opc == Instruction::FRem && (InterestedClasses & fcPositive) != fcNone;
+ const bool WantPositive = (InterestedClasses & fcPositive) != fcNone &&
+ (Opc == Instruction::FRem || CRHS);
if (!WantNan && !WantNegative && !WantPositive)
break;
KnownFPClass KnownLHS, KnownRHS;
computeKnownFPClass(Op->getOperand(1), DemandedElts,
- fcNan | fcInf | fcZero | fcNegative, KnownRHS, Q,
- Depth + 1);
+ fcNan | fcInf | fcZero | fcSubnormal | fcNegative,
+ KnownRHS, Q, Depth + 1);
bool KnowSomethingUseful = KnownRHS.isKnownNeverNaN() ||
KnownRHS.isKnownNever(fcNegative) ||
@@ -5941,7 +5946,8 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
if (Op->getOpcode() == Instruction::FDiv) {
DenormalMode Mode =
F ? F->getDenormalMode(FltSem) : DenormalMode::getDynamic();
- Known = KnownFPClass::fdiv(KnownLHS, KnownRHS, Mode);
+ Known = CRHS ? KnownFPClass::fdiv(KnownLHS, *CRHS, Mode)
+ : KnownFPClass::fdiv(KnownLHS, KnownRHS, Mode);
} else {
// Inf REM x and x REM 0 produce NaN.
if (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN() &&
diff --git a/llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp b/llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp
index 139d70f28a4d9..a7491a9a0004c 100644
--- a/llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp
@@ -1683,8 +1683,8 @@ void GISelValueTracking::computeKnownFPClass(Register R,
break;
}
- DenormalMode Mode =
- MF->getDenormalMode(getFltSemanticForLLT(DstTy.getScalarType()));
+ const fltSemantics &Flt = getFltSemanticForLLT(DstTy.getScalarType());
+ DenormalMode Mode = MF->getDenormalMode(Flt);
FPClassTest InterestedSrcs = InterestedClasses;
if (WantNegative)
@@ -1697,7 +1697,7 @@ void GISelValueTracking::computeKnownFPClass(Register R,
KnownFPClass KnownSelf;
computeKnownFPClass(LHS, DemandedElts, InterestedSrcs, KnownSelf,
Depth + 1);
- Known = KnownFPClass::fadd_self(KnownSelf, Mode);
+ Known = KnownFPClass::fadd_self(KnownSelf, Flt, Mode);
break;
}
@@ -1795,17 +1795,26 @@ void GISelValueTracking::computeKnownFPClass(Register R,
break;
}
+ // A constant divisor bounds the scale factor, which refines both signs.
+ std::optional<APFloat> CRHS;
+ if (Opcode == TargetOpcode::G_FDIV) {
+ auto RHSCst = GFConstant::getConstant(RHS, MRI);
+ if (RHSCst && RHSCst->getKind() == GFConstant::GFConstantKind::Scalar)
+ CRHS = RHSCst->getScalarValue();
+ }
+
const bool WantNan = (InterestedClasses & fcNan) != fcNone;
const bool WantNegative = (InterestedClasses & fcNegative) != fcNone;
- const bool WantPositive = Opcode == TargetOpcode::G_FREM &&
- (InterestedClasses & fcPositive) != fcNone;
+ const bool WantPositive = (InterestedClasses & fcPositive) != fcNone &&
+ (Opcode == TargetOpcode::G_FREM || CRHS);
if (!WantNan && !WantNegative && !WantPositive) {
break;
}
KnownFPClass KnownLHS, KnownRHS;
- computeKnownFPClass(RHS, DemandedElts, fcNan | fcInf | fcZero | fcNegative,
+ computeKnownFPClass(RHS, DemandedElts,
+ fcNan | fcInf | fcZero | fcSubnormal | fcNegative,
KnownRHS, Depth + 1);
bool KnowSomethingUseful = KnownRHS.isKnownNeverNaN() ||
@@ -1817,7 +1826,8 @@ void GISelValueTracking::computeKnownFPClass(Register R,
}
if (Opcode == TargetOpcode::G_FDIV) {
- Known = KnownFPClass::fdiv(KnownLHS, KnownRHS, Mode);
+ Known = CRHS ? KnownFPClass::fdiv(KnownLHS, *CRHS, Mode)
+ : KnownFPClass::fdiv(KnownLHS, KnownRHS, Mode);
} else {
// Inf REM x and x REM 0 produce NaN.
if (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN() &&
diff --git a/llvm/lib/Support/KnownFPClass.cpp b/llvm/lib/Support/KnownFPClass.cpp
index eccd83451a05f..f9522fadfcf02 100644
--- a/llvm/lib/Support/KnownFPClass.cpp
+++ b/llvm/lib/Support/KnownFPClass.cpp
@@ -13,8 +13,10 @@
#include "llvm/Support/KnownFPClass.h"
#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APInt.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/KnownBits.h"
+#include <climits>
using namespace llvm;
@@ -65,6 +67,62 @@ bool KnownFPClass::isKnownNeverLogicalPosZero(DenormalMode Mode) const {
llvm_unreachable("covered switch over denormal mode");
}
+void KnownFPClass::propagateExpRange(const KnownFPClass &Src, int LoExp,
+ int HiExp, bool NegativeScale,
+ const fltSemantics &Sem,
+ DenormalMode Mode) {
+ FPClassTest Result = fcNone;
+ FPClassTest KnownFPClasses = Src.KnownFPClasses;
+
+ if (!Src.isKnownNeverLogicalPosZero(Mode))
+ KnownFPClasses |= fcPosZero;
+ if (!Src.isKnownNeverLogicalNegZero(Mode))
+ KnownFPClasses |= fcNegZero;
+
+ if (NegativeScale)
+ KnownFPClasses = llvm::fneg(KnownFPClasses);
+
+ // A scale that cannot grow keeps |result| <= |source|.
+ if (HiExp <= 0)
+ Result |= ~KnownFPClasses & (fcInf | fcNormal);
+
+ if (LoExp >= 0) {
+ // 2^MantissaBits lifts even the smallest value 2^(emin - MantissaBits) into
+ // the normal range. Double-double reports no precision and has no such
+ // threshold, only its source can rule a subnormal out.
+ const unsigned Precision = APFloat::semanticsPrecision(Sem);
+ const bool LiftsOutOfSubnormals =
+ Precision != 0 && LoExp >= static_cast<int>(Precision) - 1;
+
+ Result |=
+ LiftsOutOfSubnormals ? fcSubnormal : ~KnownFPClasses & fcSubnormal;
+
+ // A subnormal result can still be flushed onto a zero
+ //
+ // ieee no flush
+ // preservesign +sub => +0, -sub => -0
+ // positivezero +sub => +0, -sub => +0
+ // dynamic +sub => +0, -sub => +/-0
+
+ FPClassTest FlushToPos = fcNone;
+ FPClassTest FlushToNeg = fcNone;
+
+ if (Mode.Output != DenormalMode::IEEE) {
+ const bool IsKeepSign = Mode.Output == DenormalMode::PreserveSign;
+ const bool IsPosZero = Mode.Output == DenormalMode::PositiveZero;
+ FlushToPos = IsKeepSign ? fcPosSubnormal : fcSubnormal;
+ FlushToNeg = IsPosZero ? fcNone : fcNegSubnormal;
+ }
+
+ if ((Result & FlushToPos) == FlushToPos)
+ Result |= ~KnownFPClasses & fcPosZero;
+ if ((Result & FlushToNeg) == FlushToNeg)
+ Result |= ~KnownFPClasses & fcNegZero;
+ }
+
+ knownNot(Result);
+}
+
void KnownFPClass::propagateDenormal(const KnownFPClass &Src,
DenormalMode Mode) {
KnownFPClasses = Src.KnownFPClasses;
@@ -334,18 +392,17 @@ KnownFPClass KnownFPClass::fadd(const KnownFPClass &KnownLHS,
}
KnownFPClass KnownFPClass::fadd_self(const KnownFPClass &KnownSrc,
+ const fltSemantics &Sem,
DenormalMode Mode) {
KnownFPClass Known = fadd(KnownSrc, KnownSrc, Mode);
- // Doubling 0 will give the same 0.
- if (KnownSrc.isKnownNeverLogicalPosZero(Mode) &&
- (Mode.Output == DenormalMode::IEEE ||
- (Mode.Output == DenormalMode::PreserveSign &&
- KnownSrc.isKnownNeverPosSubnormal()) ||
- (Mode.Output == DenormalMode::PositiveZero &&
- KnownSrc.isKnownNeverSubnormal())))
- Known.knownNot(fcPosZero);
+ // The scale can only refine the subnormal and zero classes here.
+ if ((KnownSrc.KnownFPClasses & (fcZero | fcSubnormal)) ==
+ (fcZero | fcSubnormal))
+ return Known;
+ // x + x scales by 2, down to 1 when one read flushes and leaves x + 0 = x.
+ Known.propagateExpRange(KnownSrc, 0, 1, /*NegativeScale=*/false, Sem, Mode);
return Known;
}
@@ -387,32 +444,20 @@ KnownFPClass KnownFPClass::fmul(const KnownFPClass &KnownLHS,
return Known;
}
-// TODO: This generalizes to known ranges
KnownFPClass KnownFPClass::fmul(const KnownFPClass &KnownLHS,
- const APFloat &CRHS, DenormalMode Mode) {
- // Match denormal scaling pattern, similar to the case in ldexp. If the
- // constant's exponent is sufficiently large, the result cannot be subnormal.
-
- const fltSemantics &Flt = CRHS.getSemantics();
- unsigned Precision = APFloat::semanticsPrecision(Flt);
- const int MantissaBits = Precision - 1;
+ const APFloat &ConstRHS, DenormalMode Mode) {
+ auto Known = KnownFPClass::fmul(KnownLHS, KnownFPClass(ConstRHS), Mode);
- int MinKnownExponent = ilogb(CRHS);
- bool CannotBeSubnormal = (MinKnownExponent >= MantissaBits);
-
- KnownFPClass Known = KnownFPClass::fmul(KnownLHS, KnownFPClass(CRHS), Mode);
- if (CannotBeSubnormal)
- Known.knownNot(fcSubnormal);
+ // ilogb needs a finite nonzero magnitude.
+ if (!ConstRHS.isFiniteNonZero())
+ return Known;
- // Multiply of values <= 1 cannot introduce overflow.
- if (KnownLHS.isKnownNever(fcInf)) {
- if (MinKnownExponent < 0)
- Known.knownNot(fcInf);
- else if (MinKnownExponent == 0 && CRHS.compareAbsoluteValue(APFloat::getOne(
- Flt)) == APFloat::cmpEqual)
- Known.knownNot(fcInf);
- }
+ const int Exp = ilogb(ConstRHS);
+ const bool IsPow2 = ConstRHS.getExactLog2Abs() != INT_MIN;
+ // |C| in [2^Exp, 2^(Exp+1)), exactly 2^Exp for a power of two.
+ Known.propagateExpRange(KnownLHS, Exp, IsPow2 ? Exp : Exp + 1,
+ ConstRHS.isNegative(), ConstRHS.getSemantics(), Mode);
return Known;
}
@@ -445,6 +490,23 @@ KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS,
return Known;
}
+KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS,
+ const APFloat &ConstRHS, DenormalMode Mode) {
+ auto Known = KnownFPClass::fdiv(KnownLHS, KnownFPClass(ConstRHS), Mode);
+
+ // ilogb needs a finite nonzero magnitude.
+ if (!ConstRHS.isFiniteNonZero())
+ return Known;
+
+ const int Exp = ilogb(ConstRHS);
+ const bool IsPow2 = ConstRHS.getExactLog2Abs() != INT_MIN;
+
+ // |1 / C| in (2^(-Exp-1), 2^-Exp], exactly 2^-Exp for a power of two.
+ Known.propagateExpRange(KnownLHS, IsPow2 ? -Exp : -Exp - 1, -Exp,
+ ConstRHS.isNegative(), ConstRHS.getSemantics(), Mode);
+ return Known;
+}
+
KnownFPClass KnownFPClass::fdiv_self(const KnownFPClass &KnownSrc,
DenormalMode Mode) {
// X / X is always exactly 1.0 or a NaN.
@@ -803,32 +865,23 @@ KnownFPClass KnownFPClass::ldexp(const KnownFPClass &KnownSrc,
else if (KnownSrc.cannotBeOrderedGreaterThanZero())
Known.knownNot(OrderedGreaterThanZeroMask);
- unsigned Precision = APFloat::semanticsPrecision(Flt);
- const int MantissaBits = Precision - 1;
- if (ConstantRangeExpMin.sge(MantissaBits))
- Known.knownNot(fcSubnormal);
-
if (ConstantRangeExpMin.isZero() && ConstantRangeExpMax.isZero()) {
// ldexp(x, 0) -> x, so propagate everything.
Known.propagateCanonicalizingSrc(KnownSrc, Mode);
- } else if (ConstantRangeExpMax.isNonPositive()) {
- // If we know the power is <= 0, can't introduce inf
- if (KnownSrc.isKnownNeverPosInfinity())
- Known.knownNot(fcPosInf);
- if (KnownSrc.isKnownNeverNegInfinity())
- Known.knownNot(fcNegInf);
- } else if (ConstantRangeExpMin.isNonNegative()) {
- // If we know the power is >= 0, can't introduce subnormal or zero
- if (KnownSrc.isKnownNeverPosSubnormal())
- Known.knownNot(fcPosSubnormal);
- if (KnownSrc.isKnownNeverNegSubnormal())
- Known.knownNot(fcNegSubnormal);
- if (KnownSrc.isKnownNeverLogicalPosZero(Mode))
- Known.knownNot(fcPosZero);
- if (KnownSrc.isKnownNeverLogicalNegZero(Mode))
- Known.knownNot(fcNegZero);
+ return Known;
}
+ // The exponent operand can be any integer width. Truncating it would map a
+ // huge exponent onto a small one and invert the tests below.
+ auto SaturatedIntExp = [](const APInt &Exp) {
+ if (Exp.isSignedIntN(sizeof(int) * CHAR_BIT))
+ return static_cast<int>(Exp.getSExtValue());
+ return Exp.isNegative() ? INT_MIN : INT_MAX;
+ };
+
+ Known.propagateExpRange(KnownSrc, SaturatedIntExp(ConstantRangeExpMin),
+ SaturatedIntExp(ConstantRangeExpMax),
+ /*NegativeScale=*/false, Flt, Mode);
return Known;
}
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
index 0a7c0375106f2..4c93d39f5eb31 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
@@ -2488,7 +2488,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
Depth + 1))
return I;
- Known = KnownFPClass::fadd_self(KnownLHS, Mode);
+ Known = KnownFPClass::fadd_self(KnownLHS, EltTy->getFltSemantics(), Mode);
KnownRHS = KnownLHS;
} else {
FPClassTest SrcDemandedMask = fcFinite;
diff --git a/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll b/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
index fef871a1e85f7..d30530e66e72c 100644
--- a/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
+++ b/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
@@ -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]]) #[[ATTR7:[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]]) #[[ATTR7]]
; 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]]) #[[ATTR7]]
+; CHECK-NEXT: [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR7]]
; 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:%....
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/215094
More information about the llvm-commits
mailing list