[clang][ExprConst] Check float operation input for signaling NaNs

[tbaeder]

Summary

Split out from https://reviews.llvm.org/D156506.

Before adding this behavior to the new constexpr interpreter, I'd like to first see it in the current one.

This patch removes the checks for a NaN result of floating point operations and instead checks the input operands for signaling NaNs.

There are only three tests for the NaN-result check as far as I can see, so I added a few new ones.

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[sepavloff]

clang/test/CXX/expr/expr.const/p2-0x.cpp

281–283

I don't think silent NaN origination is a right behavior. By design NaN is used to represent errors, so if a NaN appears, it may indicate a situation that needs user's attention. NaN propagation should be silent, an error has already appeared somewhere in the code.

I don't think it should be an error either. A user can use NaN to mark an error and treat it as if it were created by hardware. The code like:

const double PosNan = 1.0 / 0.0;
const double NegNaN = -1.0 /0.0;
const double NaN = 0.0 / 0.0;

is used enough often and there is no reason to prohibit it even in constant evaluations. So the best reaction could be a warning. Some users may suppress it, some promote to error.

This applies to other FP exceptions as well, but they were implemented previously.

clang/include/clang/Basic/DiagnosticASTKinds.td

def note_constexpr_static_local : Note<
   "control flows through the definition of a %select{static|thread_local}0 variable">;
 def note_constexpr_subobject_declared_here : Note<
   "subobject declared here">;
 def note_constexpr_array_index : Note<"cannot refer to element %0 of "
   "%select{array of %2 element%plural{1:|:s}2|non-array object}1 "
   "in a constant expression">;
 def note_constexpr_float_arithmetic : Note<
   "floating point arithmetic produces %select{an infinity|a NaN}0">;
+def note_constexpr_float_nan_input : Note<
+  "NaN input to a floating point operation">;
 def note_constexpr_dynamic_rounding : Note<
   "cannot evaluate this expression if rounding mode is dynamic">;
 def note_constexpr_float_arithmetic_strict : Note<
   "compile time floating point arithmetic suppressed in strict evaluation modes">;
 def note_constexpr_pointer_subtraction_not_same_array : Note<
   "subtracted pointers are not elements of the same array">;
 def note_constexpr_pointer_subtraction_zero_size : Note<
   "subtraction of pointers to type %0 of zero size">;

clang/lib/AST/ExprConstant.cpp

 static llvm::RoundingMode getActiveRoundingMode(EvalInfo &Info, const Expr *E) {
   llvm::RoundingMode RM =
       E->getFPFeaturesInEffect(Info.Ctx.getLangOpts()).getRoundingMode();
   if (RM == llvm::RoundingMode::Dynamic)
     RM = llvm::RoundingMode::NearestTiesToEven;
   return RM;
 }
 
+/// Signaling NaNs are invalid inputs to floating point operations.
+static bool checkFloatingPointInput(EvalInfo &Info, const Expr *E,
+                                    const APFloat &Input) {
+  if (!Input.isSignaling())
+    return true;
+
+  Info.CCEDiag(E, diag::note_constexpr_float_nan_input) << E->getSourceRange();
+  return Info.noteUndefinedBehavior();
+}
+
 /// Check if the given evaluation result is allowed for constant evaluation.
 static bool checkFloatingPointResult(EvalInfo &Info, const Expr *E,
                                      APFloat::opStatus St) {
   // In a constant context, assume that any dynamic rounding mode or FP
   // exception state matches the default floating-point environment.
   if (Info.InConstantContext)
     return true;
 
case BO_Cmp:
     llvm_unreachable("BO_Cmp should be handled elsewhere");
   }
 }
 
 /// Perform the given binary floating-point operation, in-place, on LHS.
 static bool handleFloatFloatBinOp(EvalInfo &Info, const BinaryOperator *E,
                                   APFloat &LHS, BinaryOperatorKind Opcode,
                                   const APFloat &RHS) {
+  if (!checkFloatingPointInput(Info, E->getLHS(), LHS) ||
+      !checkFloatingPointInput(Info, E->getRHS(), RHS))
+    return false;
+
   llvm::RoundingMode RM = getActiveRoundingMode(Info, E);
   APFloat::opStatus St;
   switch (Opcode) {
   default:
     Info.FFDiag(E);
     return false;
   case BO_Mul:
     St = LHS.multiply(RHS, RM);
     break;
   case BO_Add:
     St = LHS.add(RHS, RM);
     break;
   case BO_Sub:
     St = LHS.subtract(RHS, RM);
     break;
   case BO_Div:
     // [expr.mul]p4:
     //   If the second operand of / or % is zero the behavior is undefined.
     if (RHS.isZero())
       Info.CCEDiag(E, diag::note_expr_divide_by_zero);
     St = LHS.divide(RHS, RM);
     break;
   }
 
-  // [expr.pre]p4:
-  //   If during the evaluation of an expression, the result is not
-  //   mathematically defined [...], the behavior is undefined.
-  // FIXME: C++ rules require us to not conform to IEEE 754 here.
-  if (LHS.isNaN()) {
-    Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
-    return Info.noteUndefinedBehavior();
-  }
-
   return checkFloatingPointResult(Info, E, St);
 }
 
 static bool handleLogicalOpForVector(const APInt &LHSValue,
                                      BinaryOperatorKind Opcode,
                                      const APInt &RHSValue, APInt &Result) {
   bool LHS = (LHSValue != 0);
   bool RHS = (RHSValue != 0);

clang/test/CXX/expr/expr.const/p2-0x.cpp

namespace Overflow {
     constexpr float f2 = 1e38f * 3.4029f; // ok, +inf is in range of representable values
     constexpr float f3 = 1e38f / -.2939f; // ok
     constexpr float f4 = 1e38f / -.2938f; // ok, -inf is in range of representable values
     constexpr float f5 = 2e38f + 2e38f; // ok, +inf is in range of representable values
     constexpr float f6 = -2e38f - 2e38f; // ok, -inf is in range of representable values
     constexpr float f7 = 0.f / 0.f; // expected-error {{constant expression}} expected-note {{division by zero}}
     constexpr float f8 = 1.f / 0.f; // expected-error {{constant expression}} expected-note {{division by zero}}
     constexpr float f9 = 1e308 / 1e-308; // ok, +inf
-    constexpr float f10 = f2 - f2; // expected-error {{constant expression}} expected-note {{produces a NaN}}
-    constexpr float f11 = f2 + f4; // expected-error {{constant expression}} expected-note {{produces a NaN}}
-    constexpr float f12 = f2 / f2; // expected-error {{constant expression}} expected-note {{produces a NaN}}
+    constexpr float f10 = f2 - f2;
+    constexpr float f11 = f2 + f4;
+    constexpr float f12 = f2 / f2;
 #pragma float_control(push)
 #pragma float_control(except, on)
 constexpr float pi = 3.14f;
 constexpr unsigned ubig = 0xFFFFFFFF;
 constexpr float ce = 1.0 / 3.0; // not-expected-error {{constant expression}} not-expected-note {{floating point arithmetic suppressed in strict evaluation modes}}
 constexpr int ci = (int) pi;
 constexpr float fbig = (float) ubig; // not-expected-error {{constant expression}} not-expected-note {{floating point arithmetic suppressed in strict evaluation modes}}
 constexpr float fabspi = __builtin_fabs(pi); // no error expected

clang/test/SemaCXX/constexpr-float.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+
+template<typename T>
+constexpr bool isNan(T V) {
+  return __builtin_isnan(V);
+}
+
+constexpr double Signaling = __builtin_nans("");
+static_assert(isNan(Signaling), "");
+constexpr double Quiet = __builtin_nan("");
+static_assert(isNan(Quiet), "");
+
+
+static_assert(Signaling + 1 == 0, ""); // expected-error {{not an integral constant expression}} \
+                                       // expected-note {{NaN input to a floating point operation}}
+static_assert(Signaling - 1 == 0, ""); // expected-error {{not an integral constant expression}} \
+                                       // expected-note {{NaN input to a floating point operation}}
+static_assert(Signaling / 1 == 0, ""); // expected-error {{not an integral constant expression}} \
+                                       // expected-note {{NaN input to a floating point operation}}
+static_assert(Signaling * 1 == 0, ""); // expected-error {{not an integral constant expression}} \
+                                       // expected-note {{NaN input to a floating point operation}}
+
+static_assert(Quiet + 1 != 0, "");
+static_assert(isNan(Quiet + 1), "");
+static_assert(-Signaling != 0, "");
+static_assert(+Signaling != 0, "");