ValueTracking: fadd +0 cannot return -0

[kpn]

llvm/lib/Analysis/ValueTracking.cpp

4493

We're in the default FP environment here since we're looking at FAdd and FSub instructions. The check for FAdd isn't needed?

[arsenm]

Also handle sub

llvm/lib/Analysis/ValueTracking.cpp

4493

I was just copying from CannotBeNegativeZero but I guess we can improve on it at the same time

[foad]

llvm/lib/Analysis/ValueTracking.cpp

4493

As I understand it, with default rounding the only addition that can return -0 is -0 + -0. So if either operand is known not to be -0, the result cannot be -0. And the only subtraction that can return -0 is -0 - +0.

[arsenm]

llvm/lib/Analysis/ValueTracking.cpp

4493

Checking what instcombine thinks,

define float @fsub_p0_p0(float %arg0) {
  %sub = fsub float 0.0, 0.0
  ret float %sub
}

define float @fsub_n0_n0(float %arg0) {
  %sub = fsub float -0.0, -0.0
  ret float %sub
}

define float @fsub_p0_n0(float %arg0) {
  %sub = fsub float 0.0, -0.0
  ret float %sub
}

define float @fsub_n0_p0(float %arg0) {
  %sub = fsub float -0.0, 0.0
  ret float %sub
}

define float @fsub_p0_p0(float %arg0) {
  ret float 0.000000e+00
}

define float @fsub_n0_n0(float %arg0) {
  ret float 0.000000e+00
}

define float @fsub_p0_n0(float %arg0) {
  ret float 0.000000e+00
}

define float @fsub_n0_p0(float %arg0) {
  ret float -0.000000e+00
}

The missing optimization we could do here is check if DAZ is enabled and also cover denormal inputs

[arsenm]

ping

[foad]

llvm/lib/Analysis/ValueTracking.cpp

4493

First, this is wrong for FSub, since -0 - +0 = -0

Second, you can generalize KnownRHS.KnownFPClasses == fcPosZero to KnownRHS.isKnownNot(fcNegZero) (or fcPosZero for FSub).

Third you could do a similar check on the LHS. For both FAdd and FSub, if the LHS is not -0 then the result can't be -0.

[arsenm]

Fix fsub and DAZ handling

[foad]

llvm/include/llvm/Analysis/ValueTracking.h

281

Matter of taste I guess, but I don't think a helper function this simple actually helps.

llvm/lib/Analysis/ValueTracking.cpp

3936

Could use inputDenormalIsIEEEOrPosZero here.

3943

This doesn't work. If denormal mode is PosZero then a denormal can be flushed to +0, so this function should return false.

[arsenm]

Fix pos zero bug by just fully handling the denormal modes

[arsenm]

ping

llvm/include/llvm/Analysis/ValueTracking.h

281

Mostly for consistency with the others

[foad]

LGTM

llvm/lib/Analysis/ValueTracking.cpp

3945

Nit: might as well push this into the PositiveZero/default case.

[arsenm]

llvm/lib/Analysis/ValueTracking.cpp

3945

That wouldn't short circuit the attribute parsing

[arsenm]

c9f88e5bf027edcebd3ecbc2cebcda57887e04cf

llvm/include/llvm/Analysis/ValueTracking.h

bool isKnownNeverNegInfinity() const {
     return isKnownNever(fcNegInf);
   }
 
   /// Return true if it's known this can never be a subnormal
   bool isKnownNeverSubnormal() const {
     return isKnownNever(fcSubnormal);
   }
 
-  /// Return true if it's known this can never be a negativesubnormal
+  /// Return true if it's known this can never be a negative subnormal
   bool isKnownNeverNegSubnormal() const {
     return isKnownNever(fcNegSubnormal);
   }
 
+  /// Return true if it's known this can never be a positive subnormal
+  bool isKnownNeverPosSubnormal() const {
+    return isKnownNever(fcPosSubnormal);
+  }
+
   /// Return true if it's known this can never be a zero. This means a literal
   /// [+-]0, and does not include denormal inputs implicitly treated as [+-]0.
   bool isKnownNeverZero() const {
     return isKnownNever(fcZero);
   }
 
   /// Return true if it's known this can never be a literal negative zero.
   bool isKnownNeverNegZero() const {
     return isKnownNever(fcNegZero);
   }
 
+  /// Return true if it's known this can never be a literal positive zero.
+  bool isKnownNeverPosZero() const {
+    return isKnownNever(fcPosZero);
+  }
+
   /// Return true if it's know this can never be interpreted as a zero. This
   /// extends isKnownNeverZero to cover the case where the assumed
   /// floating-point mode for the function interprets denormals as zero.
   bool isKnownNeverLogicalZero(const Function &F, Type *Ty) const;
 
   /// Return true if it's know this can never be interpreted as a negative zero.
   bool isKnownNeverLogicalNegZero(const Function &F, Type *Ty) const;
 
+  /// Return true if it's know this can never be interpreted as a positive zero.
+  bool isKnownNeverLogicalPosZero(const Function &F, Type *Ty) const;
+
   /// Return true if we can prove that the analyzed floating-point value is
   /// either NaN or never less than -0.0.
   ///
   ///      NaN --> true
   ///       +0 --> true
   ///       -0 --> true
   ///   x > +0 --> true
   ///   x < -0 --> false

llvm/lib/Analysis/ValueTracking.cpp

 
 /// Return true if it's possible to assume IEEE treatment of input denormals in
 /// \p F for \p Val.
 static bool inputDenormalIsIEEE(const Function &F, const Type *Ty) {
   Ty = Ty->getScalarType();
   return F.getDenormalMode(Ty->getFltSemantics()).Input == DenormalMode::IEEE;
 }
 
+static bool inputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty) {
+  Ty = Ty->getScalarType();
+  DenormalMode Mode = F.getDenormalMode(Ty->getFltSemantics());
+  return Mode.Output == DenormalMode::IEEE ||
+         Mode.Output == DenormalMode::PositiveZero;
+}
+
+static bool outputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty) {
+  Ty = Ty->getScalarType();
+  DenormalMode Mode = F.getDenormalMode(Ty->getFltSemantics());
+  return Mode.Output == DenormalMode::IEEE ||
+         Mode.Output == DenormalMode::PositiveZero;
+}
+
 bool KnownFPClass::isKnownNeverLogicalZero(const Function &F, Type *Ty) const {
   return isKnownNeverZero() &&
          (isKnownNeverSubnormal() || inputDenormalIsIEEE(F, Ty));
 }
 
 bool KnownFPClass::isKnownNeverLogicalNegZero(const Function &F, Type *Ty) const {
   return isKnownNeverNegZero() &&
          (isKnownNeverNegSubnormal() || inputDenormalIsIEEE(F, Ty));
 }
 
+bool KnownFPClass::isKnownNeverLogicalPosZero(const Function &F,
+                                              Type *Ty) const {
+  // TODO: Could refine subnormal handling for positive vs. preserve sign mode
+  return isKnownNeverPosZero() &&
+         (isKnownNeverSubnormal() || inputDenormalIsIEEEOrPosZero(F, Ty));
+}
+
 /// Returns a pair of values, which if passed to llvm.is.fpclass, returns the
 /// same result as an fcmp with the given operands.
 std::pair<Value *, FPClassTest> llvm::fcmpToClassTest(FCmpInst::Predicate Pred,
                                                       const Function &F,
                                                       Value *LHS, Value *RHS,
                                                       bool LookThroughSrc) {
   const APFloat *ConstRHS;
   if (!match(RHS, m_APFloat(ConstRHS)))
case Instruction::Call: {
 
     break;
   }
   case Instruction::FAdd:
   case Instruction::FSub: {
     KnownFPClass KnownLHS, KnownRHS;
     computeKnownFPClass(Op->getOperand(1), DemandedElts, fcNan | fcInf,
                         KnownRHS, Depth + 1, Q, TLI);
+
+    const Function *F = cast<Instruction>(Op)->getFunction();
+
+    if (Op->getOpcode() == Instruction::FAdd) {
+      // (fadd x, 0.0) is guaranteed to return +0.0, not -0.0.
+      if ((KnownLHS.isKnownNeverLogicalNegZero(*F, Op->getType()) ||
+           KnownRHS.isKnownNeverLogicalNegZero(*F, Op->getType())) &&
+          // Make sure output negative denormal can't flush to -0
+          outputDenormalIsIEEEOrPosZero(*F, Op->getType()))
+        Known.knownNot(fcNegZero);
+    } else {
+      // Only fsub -0, +0 can return -0
+      if ((KnownLHS.isKnownNeverLogicalNegZero(*F, Op->getType()) ||
+           KnownRHS.isKnownNeverLogicalPosZero(*F, Op->getType())) &&
+          // Make sure output negative denormal can't flush to -0
+          outputDenormalIsIEEEOrPosZero(*F, Op->getType()))
+        Known.knownNot(fcNegZero);
+    }
+
     if (KnownRHS.isKnownNeverNaN()) {
       // RHS is canonically cheaper to compute. Skip inspecting the LHS if
       // there's no point.
       computeKnownFPClass(Op->getOperand(0), DemandedElts, fcNan | fcInf,
                           KnownLHS, Depth + 1, Q, TLI);
       // Adding positive and negative infinity produces NaN.
       // TODO: Check sign of infinities.
       if (KnownLHS.isKnownNeverNaN() &&

llvm/test/Transforms/Attributor/nofpclass.ll

 ; CHECK-NEXT:    ret float [[VAL]]
 ;
   %val = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
   ret float %val
 }
 
 define float @fadd_p0(float %arg0) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_p0
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0
 ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, 0.0
   ret float %add
 }
 

 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub float %arg0, 0.0
   ret float %sub
 }
 
 define float @fsub_n0(float %arg0) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fsub_n0
+; CHECK-LABEL: define nofpclass(nzero) float @fsub_n0
 ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+00
 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub float %arg0, -0.0
   ret float %sub
 }
 

 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub float -0.0, %arg0
   ret float %sub
 }
 
 define float @fadd_p0_ftz_daz(float %arg0) #3 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_p0_ftz_daz
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_ftz_daz
 ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR6:[0-9]+]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, 0.0
   ret float %add
 }
 

 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub float -0.0, %arg0
   ret float %sub
 }
 
 define float @fadd_p0_ieee_daz(float %arg0) #2 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_p0_ieee_daz
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_ieee_daz
 ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8:[0-9]+]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, 0.0
   ret float %add
 }
 
 define float @fadd_p0_dapz_ieee(float %arg0) #4 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_p0_dapz_ieee
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_dapz_ieee
 ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR9:[0-9]+]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, 0.0
   ret float %add
 }
 

 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub float %arg0, 0.0
   ret float %sub
 }
 
 define float @fsub_n0_ieee_daz(float %arg0) #2 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fsub_n0_ieee_daz
+; CHECK-LABEL: define nofpclass(nzero) float @fsub_n0_ieee_daz
 ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] {
 ; CHECK-NEXT:    [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+00
 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub float %arg0, -0.0
   ret float %sub
 }
 

 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub float -0.0, %arg0
   ret float %sub
 }
 
 define float @fadd_never_negzero_or_negsub(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_never_negzero_or_negsub
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub
 ; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %a, %b
   ret float %add
 }
 
 define float @fadd_never_negzero_or_negsub_daz(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) #2 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_never_negzero_or_negsub_daz
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub_daz
 ; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR8]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %a, %b
   ret float %add
 }
 
 define float @fadd_never_negzero_or_negsub_dapz(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) #5 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_never_negzero_or_negsub_dapz
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub_dapz
 ; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR11:[0-9]+]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %a, %b
   ret float %add
 }
 
 define float @fadd_never_negzero_or_possub(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_never_negzero_or_possub
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_possub
 ; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %a, %b
   ret float %add
 }
 

 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %a, %b
   ret float %add
 }
 
 define float @fadd_never_negzero_or_sub_daz(float nofpclass(nzero sub) %a, float nofpclass(nzero sub) %b) #2 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_never_negzero_or_sub_daz
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_sub_daz
 ; CHECK-SAME: (float nofpclass(nzero sub) [[A:%.*]], float nofpclass(nzero sub) [[B:%.*]]) #[[ATTR8]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %a, %b
   ret float %add
 }
 
 define float @fadd_never_negzero_or_sub_dapz(float nofpclass(nzero sub) %a, float nofpclass(nzero sub) %b) #5 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_never_negzero_or_sub_dapz
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_sub_dapz
 ; CHECK-SAME: (float nofpclass(nzero sub) [[A:%.*]], float nofpclass(nzero sub) [[B:%.*]]) #[[ATTR11]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %a, %b
   ret float %add
 }
 

 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, %arg1
   ret float %add
 }
 
 define float @fadd_known_positive_nzero_rhs(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_known_positive_nzero_rhs
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero_rhs
 ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, %arg1
   ret float %add
 }
 
 define float @fadd_known_positive_nzero(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_known_positive_nzero
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero
 ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, %arg1
   ret float %add
 }
 

 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, %arg1
   ret float %add
 }
 
 define float @fadd_known_positive_nzero_daz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #2 {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_known_positive_nzero_daz
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero_daz
 ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR8]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, %arg1
   ret float %add
 }
 
 define float @fadd_known_positive_normal(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define float @fadd_known_positive_normal
+; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_normal
 ; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %add = fadd float %arg0, %arg1
   ret float %add
 }