[AST] add warnings for out-of-bounds FP values when using relaxed FP math compile flags

[spatel]

Summary

There's currently ongoing discussion on the dev lists about how to handle related cases with isnan() / isinf(), but I don't think the problem addressed by this patch is controversial:
If the compile specified loose FP math because special values like NaN / Inf / -0.0 are not expected, then we should warn if the code contains an obvious occurrence of any of those values.

My understanding of clang isn't good though. Is this the right place to detect the unexpected values? I commented in the test file that I don't see the expected warnings in all cases before CodeGen. But if we run through to IR creation, then I sometimes see duplicate warnings for the same line of code.

For example, I see duplicate 3 warnings on this program based on https://llvm.org/PR51775 :

% cat 51775.c 
#include <math.h>
#include <stdlib.h>
int main() {
    const double d = strtod("1E+1000000", NULL);
    return d == HUGE_VAL;
}

% clang -O1 -ffast-math 51775.c -S -o -
51775.c:5:17: warning: floating-point infinity may be optimized out of computation or comparison [-Wliteral-range]
    return d == HUGE_VAL;
                ^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/math.h:57:28: note: expanded from macro 'HUGE_VAL'
#   define    HUGE_VAL     __builtin_huge_val()
                           ^
51775.c:5:17: warning: floating-point infinity may be optimized out of computation or comparison [-Wliteral-range]
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/math.h:57:28: note: expanded from macro 'HUGE_VAL'
#   define    HUGE_VAL     __builtin_huge_val()
                           ^
51775.c:5:17: warning: floating-point infinity may be optimized out of computation or comparison [-Wliteral-range]
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/math.h:57:28: note: expanded from macro 'HUGE_VAL'
#   define    HUGE_VAL     __builtin_huge_val()
...

[sepavloff]

I don't think the constant evaluator is a right place for such warnings. The option -ffast-math is a hint to the compiler, which, in particular, tells that no operation on Nans/Infs take place. It allows a compiler to generate better code. None is pertinent for the constant evaluator, as it already has all information necessary for the evaluation and it does not generate any code. It does not make sense to add a new mode for constant evaluation as well. To make the warnings useful you probably need to check if a constant value is an operand of an arithmetic operation.

clang/test/AST/warn-fp-values.c

49

-ffast-math does not prohibit using negative zero, it only treat it identically to positive zero.

clang/include/clang/Basic/DiagnosticASTKinds.td

def err_experimental_clang_interp_failed : Error<
   "the experimental clang interpreter failed to evaluate an expression">;
 
 def warn_integer_constant_overflow : Warning<
   "overflow in expression; result is %0 with type %1">,
   InGroup<DiagGroup<"integer-overflow">>;
 def warn_fixedpoint_constant_overflow : Warning<
   "overflow in expression; result is %0 with type %1">,
   InGroup<DiagGroup<"fixed-point-overflow">>;
+def warn_fp_infinity : Warning<
+  "floating-point infinity may be optimized out of computation or comparison">,
+  InGroup<LiteralRange>;
+def warn_fp_nan: Warning<
+  "floating-point NaN may be optimized out of computation or comparison">,
+  InGroup<LiteralRange>;
+def warn_fp_negzero: Warning<
+  "floating-point -0.0 may be optimized out of computation or comparison">,
+  InGroup<LiteralRange>;
 
 // This is a temporary diagnostic, and shall be removed once our
 // implementation is complete, and like the preceding constexpr notes belongs
 // in Sema.
 def note_unimplemented_constexpr_lambda_feature_ast : Note<
     "unimplemented constexpr lambda feature: %0 (coming soon!)">;
 
 def warn_is_constant_evaluated_always_true_constexpr : Warning<

clang/lib/AST/ExprConstant.cpp

 
   bool VisitUnaryReal(const UnaryOperator *E);
   bool VisitUnaryImag(const UnaryOperator *E);
 
   // FIXME: Missing: array subscript of vector, member of vector
 };
 } // end anonymous namespace
 
-static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
+static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isRealFloatingType());
-  return FloatExprEvaluator(Info, Result).Visit(E);
+  bool Status = FloatExprEvaluator(Info, Result).Visit(E);
+
+  // Warn if we encounter a floating-point special value that is potentially
+  // constant-folded by the optimizer.
+  const FPOptions &FPO = E->getFPFeaturesInEffect(Info.Ctx.getLangOpts());
+  if (Result.isInfinity() && FPO.getNoHonorInfs())
+    Info.Ctx.getDiagnostics().Report(E->getExprLoc(), diag::warn_fp_infinity);
+  else if (Result.isNaN() && FPO.getNoHonorNaNs())
+    Info.Ctx.getDiagnostics().Report(E->getExprLoc(), diag::warn_fp_nan);
+  else if (Result.isNegZero() && FPO.getNoSignedZero())
+    Info.Ctx.getDiagnostics().Report(E->getExprLoc(), diag::warn_fp_negzero);
+
+  return Status;
 }
 
 static bool TryEvaluateBuiltinNaN(const ASTContext &Context,
                                   QualType ResultTy,
                                   const Expr *Arg,
                                   bool SNaN,
                                   llvm::APFloat &Result) {
   const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());

clang/test/AST/warn-fp-values.c

+// RUN: %clang_cc1 %s -triple x86_64-unknown-unknown -verify -fsyntax-only -ffast-math -Wliteral-range
+
+#define INFINITY_MATH_MACRO  1.0 / 0.0
+
+#define NAN_MATH_MACRO  0.0f / 0.0f
+
+// Infinity
+
+double inf_by_macro() {
+  double d = INFINITY_MATH_MACRO; // expected-warning {{floating-point infinity may be optimized}}
+  return d;
+}
+
+float inf_by_overflow() {
+  const float huge_literal = 10e100f; // expected-warning {{magnitude of floating-point constant too large}} {{floating-point infinity may be optimized}}
+  return huge_literal;
+}
+
+double inf_by_builtin() {
+  double b = __builtin_inf(); // shows warning if compile continues with -emit-llvm
+  return b;
+}
+
+float inf_by_builtin_cast() {
+  float b = __builtin_inf(); // expected-warning {{floating-point infinity may be optimized}}
+  return b;
+}
+
+// NaN
+
+float nan_by_macro() {
+  float f = NAN_MATH_MACRO; // expected-warning {{floating-point NaN may be optimized}}
+  return f;
+}
+
+double nan_by_builtin() {
+  double b = __builtin_nan(""); // shows warning if compile continues with -emit-llvm
+  return b;
+}
+
+float nan_by_builtin_cast() {
+  float b = __builtin_nan(""); // expected-warning {{floating-point NaN may be optimized}}
+  return b;
+}
+
+// -0.0
+
+double neg_zero_literal() {
+  return -0.0; // shows warning if compile continues with -emit-llvm
+}