[llvm] 1ca54c1 - [KnownFPClass] Apply denormal modes at the fmul/fdiv boundaries (#229638)

via llvm-commits llvm-commits at lists.llvm.org
Sun Oct 11 10:16:44 PDT 2026


Author: Eric Ross
Date: 2026-10-11T17:16:39Z
New Revision: 1ca54c147406b82ed83d9cc670face2f2f78da30

URL: https://github.com/llvm/llvm-project/commit/1ca54c147406b82ed83d9cc670face2f2f78da30
DIFF: https://github.com/llvm/llvm-project/commit/1ca54c147406b82ed83d9cc670face2f2f78da30.diff

LOG: [KnownFPClass] Apply denormal modes at the fmul/fdiv boundaries (#229638)

I added `applyInputDenormalMode`/`applyOutputDenormalMode` to
`KnownFPClass::fmul`/`KnownFPClass::fdiv`. I also inlined
`propagateXorSign` back into `fmul` and `fdiv` to make the logic easier
to follow, and because I have follow up PRs that would need to remove it
either way.

Adding `applyOutputDenormalMode` allowed `fmul`/`fdiv` to rule out
positive zero for these cases for the `FTPZ` and `dynamic` output modes:
- `fmul(+0.0, neg-normal)`
- `fmul(-0.0, pos-normal)`
- `fdiv(+0.0, neg-normal)`
- `fdiv(-0.0, pos-normal)`

This is because `fmul`/`fdiv` rule out subnormal if the LHS is a known
zero, which also means that a subnormal will not flush to positive zero.
Previously, the always zero LHS deduction was applied after
`propagateXorSign`, so `propagateXorSign` could not rule out a result
flushing to positive zero.

Other cases such as `fdiv(-inf, +normal)` also are now able to rule out
`fcPosZero` under `FTPZ` and `dynamic` output modes because both
`fcNegSubnormal` and `fcPosSubnormal` were ruled out earlier by the
function.

AI Disclosure:
I used Claude Opus 5 to help implement the code and tests.

Added: 
    

Modified: 
    llvm/include/llvm/Support/KnownFPClass.h
    llvm/lib/Support/KnownFPClass.cpp
    llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
    llvm/test/Transforms/Attributor/nofpclass-fmul.ll

Removed: 
    


################################################################################
diff  --git a/llvm/include/llvm/Support/KnownFPClass.h b/llvm/include/llvm/Support/KnownFPClass.h
index 03c28fcc42e44..bf0c2776748a9 100644
--- a/llvm/include/llvm/Support/KnownFPClass.h
+++ b/llvm/include/llvm/Support/KnownFPClass.h
@@ -453,27 +453,6 @@ struct KnownFPClass {
       knownNot(fcNan);
   }
 
-  // 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,
-                        DenormalMode Mode) {
-    const bool LHSCannotHavePositiveInput =
-        LHS.isKnownNever(fcPositive) && LHS.isKnownNeverLogicalPosZero(Mode);
-    const bool RHSCannotHavePositiveInput =
-        RHS.isKnownNever(fcPositive) && RHS.isKnownNeverLogicalPosZero(Mode);
-    if ((LHS.isKnownNever(fcNegative) && RHS.isKnownNever(fcNegative)) ||
-        (LHSCannotHavePositiveInput && RHSCannotHavePositiveInput))
-      knownNot(fcNegative);
-
-    if ((LHSCannotHavePositiveInput && RHS.isKnownNever(fcNegative)) ||
-        (LHS.isKnownNever(fcNegative) && RHSCannotHavePositiveInput)) {
-      knownNot(fcPosInf | fcPosNormal | fcPosSubnormal);
-      if (!Mode.outputsMayBePositiveZero())
-        knownNot(fcPosZero);
-    }
-  }
-
   /// 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/Support/KnownFPClass.cpp b/llvm/lib/Support/KnownFPClass.cpp
index e69cb55d174be..4a756af775930 100644
--- a/llvm/lib/Support/KnownFPClass.cpp
+++ b/llvm/lib/Support/KnownFPClass.cpp
@@ -537,16 +537,26 @@ KnownFPClass KnownFPClass::fsub(const KnownFPClass &KnownLHS,
   return fadd(KnownLHS, fneg(KnownRHS), Mode);
 }
 
-KnownFPClass KnownFPClass::fmul(const KnownFPClass &KnownLHS,
-                                const KnownFPClass &KnownRHS,
+KnownFPClass KnownFPClass::fmul(const KnownFPClass &KnownLHS_,
+                                const KnownFPClass &KnownRHS_,
                                 DenormalMode Mode) {
+  KnownFPClass KnownLHS = applyInputDenormalMode(KnownLHS_, Mode);
+  KnownFPClass KnownRHS = applyInputDenormalMode(KnownRHS_, Mode);
+
   KnownFPClass Known;
 
   Known.propagateNonSNaN(KnownLHS, KnownRHS);
 
   // +X * +Y or -X * -Y => +Q
   // +X * -Y or -X * +Y => -Q
-  Known.propagateXorSign(KnownLHS, KnownRHS, Mode);
+  if ((KnownLHS.isKnownNever(fcNegative) &&
+       KnownRHS.isKnownNever(fcNegative)) ||
+      (KnownLHS.isKnownNever(fcPositive) && KnownRHS.isKnownNever(fcPositive)))
+    Known.knownNot(fcNegative);
+  if ((KnownLHS.isKnownNever(fcPositive) &&
+       KnownRHS.isKnownNever(fcNegative)) ||
+      (KnownLHS.isKnownNever(fcNegative) && KnownRHS.isKnownNever(fcPositive)))
+    Known.knownNot(fcPositive);
 
   // Inf * Y => Inf or NaN
   if (KnownLHS.isKnownAlways(fcInf | fcNan) ||
@@ -558,17 +568,13 @@ KnownFPClass KnownFPClass::fmul(const KnownFPClass &KnownLHS,
       KnownLHS.isKnownAlways(fcZero | fcNan))
     Known.knownNot(fcNormal | fcSubnormal | fcInf);
 
-  if (!KnownLHS.isKnownNeverNaN() || !KnownRHS.isKnownNeverNaN())
-    return Known;
-
   // 0 * +/-inf => NaN
-  if ((KnownRHS.isKnownNeverInfinity() ||
-       KnownLHS.isKnownNeverLogicalZero(Mode)) &&
-      (KnownLHS.isKnownNeverInfinity() ||
-       KnownRHS.isKnownNeverLogicalZero(Mode)))
+  if (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN() &&
+      (KnownRHS.isKnownNeverInfinity() || KnownLHS.isKnownNeverZero()) &&
+      (KnownLHS.isKnownNeverInfinity() || KnownRHS.isKnownNeverZero()))
     Known.knownNot(fcNan);
 
-  return Known;
+  return applyOutputDenormalMode(Known, Mode);
 }
 
 // TODO: This generalizes to known ranges
@@ -600,9 +606,12 @@ KnownFPClass KnownFPClass::fmul(const KnownFPClass &KnownLHS,
   return Known;
 }
 
-KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS,
-                                const KnownFPClass &KnownRHS,
+KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS_,
+                                const KnownFPClass &KnownRHS_,
                                 DenormalMode Mode) {
+  KnownFPClass KnownLHS = applyInputDenormalMode(KnownLHS_, Mode);
+  KnownFPClass KnownRHS = applyInputDenormalMode(KnownRHS_, Mode);
+
   KnownFPClass Known;
 
   Known.propagateNonSNaN(KnownLHS, KnownRHS);
@@ -610,15 +619,21 @@ KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS,
   // Only 0/0, Inf/Inf produce NaN.
   if (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN() &&
       (KnownLHS.isKnownNeverInfinity() || KnownRHS.isKnownNeverInfinity()) &&
-      (KnownLHS.isKnownNeverLogicalZero(Mode) ||
-       KnownRHS.isKnownNeverLogicalZero(Mode))) {
+      (KnownLHS.isKnownNeverZero() || KnownRHS.isKnownNeverZero())) {
     Known.knownNot(fcNan);
   }
 
   //  X / -0.0 => -Inf (or NaN)
   // +X / +Y or -X / -Y => +Q
   // +X / -Y or -X / +Y => -Q
-  Known.propagateXorSign(KnownLHS, KnownRHS, Mode);
+  if ((KnownLHS.isKnownNever(fcNegative) &&
+       KnownRHS.isKnownNever(fcNegative)) ||
+      (KnownLHS.isKnownNever(fcPositive) && KnownRHS.isKnownNever(fcPositive)))
+    Known.knownNot(fcNegative);
+  if ((KnownLHS.isKnownNever(fcPositive) &&
+       KnownRHS.isKnownNever(fcNegative)) ||
+      (KnownLHS.isKnownNever(fcNegative) && KnownRHS.isKnownNever(fcPositive)))
+    Known.knownNot(fcPositive);
 
   // Normal and subnormal results require two non-zero finite operands.
   if ((KnownLHS.isKnownNever(fcNegNormal | fcNegSubnormal) &&
@@ -640,7 +655,7 @@ KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS,
   if (KnownRHS.isKnownAlways(fcZero))
     Known.knownNot(fcFinite);
 
-  return Known;
+  return applyOutputDenormalMode(Known, Mode);
 }
 
 KnownFPClass KnownFPClass::fdiv_self(const KnownFPClass &KnownSrc,

diff  --git a/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll b/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
index e3f35fcaf9ad1..506d082682a0e 100644
--- a/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
+++ b/llvm/test/Transforms/Attributor/nofpclass-fdiv.ll
@@ -1292,6 +1292,106 @@ define float @ret_fdiv_self_negnormal_negsubnormal_mode_ftpz_dapz(float noundef
   ret float %fdiv
 }
 
+; -normal / +normal may underflow to a negative subnormal, which may flush to
+; +0.0 under FTPZ. That has to be accounted for on every path, including the one
+; taken when an operand may be a NaN.
+
+define float @ret_fdiv_negnormal_posnormal_or_nan__mode_ieee_ieee(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(snan inf zero sub nnorm) %rhs) #0 {
+; CHECK-LABEL: define nofpclass(snan pinf pzero psub pnorm) float @ret_fdiv_negnormal_posnormal_or_nan__mode_ieee_ieee
+; CHECK-SAME: (float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(snan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
+define float @ret_fdiv_negnormal_posnormal_or_nan__mode_ftpz_dapz(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(snan inf zero sub nnorm) %rhs) #4 {
+; CHECK-LABEL: define nofpclass(snan pinf psub pnorm) float @ret_fdiv_negnormal_posnormal_or_nan__mode_ftpz_dapz
+; CHECK-SAME: (float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(snan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR5]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
+define float @ret_fdiv_negnormal_posnormal_or_nan__mode_dynamic_dynamic(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(snan inf zero sub nnorm) %rhs) #5 {
+; CHECK-LABEL: define nofpclass(snan pinf psub pnorm) float @ret_fdiv_negnormal_posnormal_or_nan__mode_dynamic_dynamic
+; CHECK-SAME: (float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(snan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR6]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
+; An exact -0.0 result is produced without rounding, so no output flushing
+; applies and the result stays known negative.
+
+define float @ret_fdiv_exact_negzero__mode_ieee_ieee(float nofpclass(nan inf norm sub nzero) %lhs, float nofpclass(nan inf zero sub pnorm) %rhs) #0 {
+; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_fdiv_exact_negzero__mode_ieee_ieee
+; CHECK-SAME: (float nofpclass(nan inf nzero sub norm) [[LHS:%.*]], float nofpclass(nan inf zero sub pnorm) [[RHS:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
+define float @ret_fdiv_exact_negzero__mode_ftpz_dapz(float nofpclass(nan inf norm sub nzero) %lhs, float nofpclass(nan inf zero sub pnorm) %rhs) #4 {
+; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_fdiv_exact_negzero__mode_ftpz_dapz
+; CHECK-SAME: (float nofpclass(nan inf nzero sub norm) [[LHS:%.*]], float nofpclass(nan inf zero sub pnorm) [[RHS:%.*]]) #[[ATTR5]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
+define float @ret_fdiv_exact_negzero__mode_dynamic_dynamic(float nofpclass(nan inf norm sub nzero) %lhs, float nofpclass(nan inf zero sub pnorm) %rhs) #5 {
+; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_fdiv_exact_negzero__mode_dynamic_dynamic
+; CHECK-SAME: (float nofpclass(nan inf nzero sub norm) [[LHS:%.*]], float nofpclass(nan inf zero sub pnorm) [[RHS:%.*]]) #[[ATTR6]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
+; -inf / +normal is always -inf. The normal and subnormal rule-outs leave no
+; subnormal result behind, so nothing can flush to +0.0 under FTPZ.
+
+define float @ret_fdiv_neginf_posnormal__mode_ieee_ieee(float nofpclass(nan pinf zero sub norm) %lhs, float nofpclass(nan inf zero sub nnorm) %rhs) #0 {
+; CHECK-LABEL: define nofpclass(nan pinf pzero sub norm) float @ret_fdiv_neginf_posnormal__mode_ieee_ieee
+; CHECK-SAME: (float nofpclass(nan pinf zero sub norm) [[LHS:%.*]], float nofpclass(nan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
+define float @ret_fdiv_neginf_posnormal__mode_ftpz_dapz(float nofpclass(nan pinf zero sub norm) %lhs, float nofpclass(nan inf zero sub nnorm) %rhs) #4 {
+; CHECK-LABEL: define nofpclass(nan pinf pzero sub norm) float @ret_fdiv_neginf_posnormal__mode_ftpz_dapz
+; CHECK-SAME: (float nofpclass(nan pinf zero sub norm) [[LHS:%.*]], float nofpclass(nan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR5]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
+define float @ret_fdiv_neginf_posnormal__mode_dynamic_dynamic(float nofpclass(nan pinf zero sub norm) %lhs, float nofpclass(nan inf zero sub nnorm) %rhs) #5 {
+; CHECK-LABEL: define nofpclass(nan pinf pzero sub norm) float @ret_fdiv_neginf_posnormal__mode_dynamic_dynamic
+; CHECK-SAME: (float nofpclass(nan pinf zero sub norm) [[LHS:%.*]], float nofpclass(nan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR6]] {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FDIV]]
+;
+  %fdiv = fdiv float %lhs, %rhs
+  ret float %fdiv
+}
+
 attributes #0 = { denormal_fpenv(ieee|ieee) }
 attributes #1 = { denormal_fpenv(ieee|preservesign) }
 attributes #2 = { denormal_fpenv(ieee|positivezero) }

diff  --git a/llvm/test/Transforms/Attributor/nofpclass-fmul.ll b/llvm/test/Transforms/Attributor/nofpclass-fmul.ll
index b1fda620898c0..312bfc76b8874 100644
--- a/llvm/test/Transforms/Attributor/nofpclass-fmul.ll
+++ b/llvm/test/Transforms/Attributor/nofpclass-fmul.ll
@@ -1188,6 +1188,73 @@ define float @ret_fmul_self_negnormal_negsubnormal_mode_ftpz_dapz(float noundef
   ret float %fmul
 }
 
+; -normal * +normal may underflow to a negative subnormal, which may flush to
+; +0.0 under FTPZ. That has to be accounted for on every path, including the one
+; taken when an operand may be a NaN.
+
+define float @ret_fmul_negnormal_posnormal_or_nan__mode_ieee_ieee(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(snan inf zero sub nnorm) %rhs) #0 {
+; CHECK-LABEL: define nofpclass(snan pinf pzero psub pnorm) float @ret_fmul_negnormal_posnormal_or_nan__mode_ieee_ieee(
+; CHECK-SAME: float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(snan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FMUL]]
+;
+  %fmul = fmul float %lhs, %rhs
+  ret float %fmul
+}
+
+define float @ret_fmul_negnormal_posnormal_or_nan__mode_ftpz_dapz(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(snan inf zero sub nnorm) %rhs) #4 {
+; CHECK-LABEL: define nofpclass(snan pinf psub pnorm) float @ret_fmul_negnormal_posnormal_or_nan__mode_ftpz_dapz(
+; CHECK-SAME: float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(snan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR5]] {
+; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FMUL]]
+;
+  %fmul = fmul float %lhs, %rhs
+  ret float %fmul
+}
+
+define float @ret_fmul_negnormal_posnormal_or_nan__mode_dynamic_dynamic(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(snan inf zero sub nnorm) %rhs) #5 {
+; CHECK-LABEL: define nofpclass(snan pinf psub pnorm) float @ret_fmul_negnormal_posnormal_or_nan__mode_dynamic_dynamic(
+; CHECK-SAME: float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(snan inf zero sub nnorm) [[RHS:%.*]]) #[[ATTR6]] {
+; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FMUL]]
+;
+  %fmul = fmul float %lhs, %rhs
+  ret float %fmul
+}
+
+; An exact -0.0 result is produced without rounding, so no output flushing
+; applies and the result stays known negative.
+
+define float @ret_fmul_exact_negzero__mode_ieee_ieee(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(nan inf norm sub nzero) %rhs) #0 {
+; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_fmul_exact_negzero__mode_ieee_ieee(
+; CHECK-SAME: float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(nan inf nzero sub norm) [[RHS:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FMUL]]
+;
+  %fmul = fmul float %lhs, %rhs
+  ret float %fmul
+}
+
+define float @ret_fmul_exact_negzero__mode_ftpz_dapz(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(nan inf norm sub nzero) %rhs) #4 {
+; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_fmul_exact_negzero__mode_ftpz_dapz(
+; CHECK-SAME: float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(nan inf nzero sub norm) [[RHS:%.*]]) #[[ATTR5]] {
+; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FMUL]]
+;
+  %fmul = fmul float %lhs, %rhs
+  ret float %fmul
+}
+
+define float @ret_fmul_exact_negzero__mode_dynamic_dynamic(float nofpclass(nan inf zero sub pnorm) %lhs, float nofpclass(nan inf norm sub nzero) %rhs) #5 {
+; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_fmul_exact_negzero__mode_dynamic_dynamic(
+; CHECK-SAME: float nofpclass(nan inf zero sub pnorm) [[LHS:%.*]], float nofpclass(nan inf nzero sub norm) [[RHS:%.*]]) #[[ATTR6]] {
+; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[LHS]], [[RHS]]
+; CHECK-NEXT:    ret float [[FMUL]]
+;
+  %fmul = fmul float %lhs, %rhs
+  ret float %fmul
+}
+
 attributes #0 = { denormal_fpenv(ieee|ieee) }
 attributes #1 = { denormal_fpenv(ieee|preservesign) }
 attributes #2 = { denormal_fpenv(ieee|positivezero) }


        


More information about the llvm-commits mailing list