[clang] Missed rounding mode use in constant evaluation

[sepavloff]

Summary

Integer-to-float conversion was handled in constant evaluator with
default rounding mode. This change fixes the behavior and the conversion
is made using rounding mode stored in ImplicitCastExpr node.

[tbaeder]

clang/lib/AST/ExprConstant.cpp

2652

SrcType was already unused before, but not so is FPO.

[tbaeder]

clang/lib/AST/ExprConstant.cpp

2652

now so is FPO.

[sepavloff]

Removed unused parateters from HandleIntToFloatCast

[sepavloff]

Remove accidentally added file

[sepavloff]

Ping.

[aaron.ballman]

The changes look correct to me, but adding @jcranmer-intel for floating-point expertise.

clang/test/AST/const-fpfeatures.c

37

Should we add a test without the -fexperimental-strict-floating-point on the RUN line?

[rjmccall]

Looks good to me.

[sepavloff]

Thanks!

clang/test/AST/const-fpfeatures.c

37

Yes, I will remove it.

clang/lib/AST/ExprConstant.cpp

static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
   APSInt Result = Value.extOrTrunc(DestWidth);
   Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType());
   if (DestType->isBooleanType())
     Result = Value.getBoolValue();
   return Result;
 }
 
 static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
-                                 const FPOptions FPO,
-                                 QualType SrcType, const APSInt &Value,
-                                 QualType DestType, APFloat &Result) {
+                                 const APSInt &Value, QualType DestType,
+                                 APFloat &Result) {
   Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
-  APFloat::opStatus St = Result.convertFromAPInt(Value, Value.isSigned(),
-       APFloat::rmNearestTiesToEven);
-  if (!Info.InConstantContext && St != llvm::APFloatBase::opOK &&
-      FPO.isFPConstrained()) {
-    Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
-    return false;
-  }
-  return true;
+  llvm::RoundingMode RM = getActiveRoundingMode(Info, E);
+  APFloat::opStatus St = Result.convertFromAPInt(Value, Value.isSigned(), RM);
+  return checkFloatingPointResult(Info, E, St);
 }
 
 static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
                                   APValue &Value, const FieldDecl *FD) {
   assert(FD->isBitField() && "truncateBitfieldValue on non-bitfield");
 
   if (!Value.isInt()) {
     // Trying to store a pointer-cast-to-integer into a bitfield.
bool found(APSInt &Value, QualType SubobjType) {
     if (RHS.isInt()) {
       APSInt LHS =
           HandleIntToIntCast(Info, E, PromotedLHSType, SubobjType, Value);
       if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS))
         return false;
       Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS);
       return true;
     } else if (RHS.isFloat()) {
-      const FPOptions FPO = E->getFPFeaturesInEffect(
-                                    Info.Ctx.getLangOpts());
       APFloat FValue(0.0);
-      return HandleIntToFloatCast(Info, E, FPO, SubobjType, Value,
-                                  PromotedLHSType, FValue) &&
+      return HandleIntToFloatCast(Info, E, Value, PromotedLHSType, FValue) &&
              handleFloatFloatBinOp(Info, E, FValue, Opcode, RHS.getFloat()) &&
              HandleFloatToIntCast(Info, E, PromotedLHSType, FValue, SubobjType,
                                   Value);
     }
 
     Info.FFDiag(E);
     return false;
   }
bool FloatExprEvaluator::VisitCastExpr(const CastExpr *E) {
   const Expr* SubExpr = E->getSubExpr();
 
   switch (E->getCastKind()) {
   default:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
 
   case CK_IntegralToFloating: {
     APSInt IntResult;
-    const FPOptions FPO = E->getFPFeaturesInEffect(
-                                  Info.Ctx.getLangOpts());
     return EvaluateInteger(SubExpr, IntResult, Info) &&
-           HandleIntToFloatCast(Info, E, FPO, SubExpr->getType(),
-                                IntResult, E->getType(), Result);
+           HandleIntToFloatCast(Info, E, IntResult, E->getType(), Result);
   }
 
   case CK_FixedPointToFloating: {
     APFixedPoint FixResult(Info.Ctx.getFixedPointSemantics(SubExpr->getType()));
     if (!EvaluateFixedPoint(SubExpr, FixResult, Info))
       return false;
     Result =
         FixResult.convertToFloat(Info.Ctx.getFloatTypeSemantics(E->getType()));
case CK_IntegralComplexCast: {
     Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag);
     return true;
   }
 
   case CK_IntegralComplexToFloatingComplex: {
     if (!Visit(E->getSubExpr()))
       return false;
 
-    const FPOptions FPO = E->getFPFeaturesInEffect(
-                                  Info.Ctx.getLangOpts());
     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
-    QualType From
-      = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
     Result.makeComplexFloat();
-    return HandleIntToFloatCast(Info, E, FPO, From, Result.IntReal,
-                                To, Result.FloatReal) &&
-           HandleIntToFloatCast(Info, E, FPO, From, Result.IntImag,
-                                To, Result.FloatImag);
+    return HandleIntToFloatCast(Info, E, Result.IntReal, To,
+                                Result.FloatReal) &&
+           HandleIntToFloatCast(Info, E, Result.IntImag, To, Result.FloatImag);
   }
   }
 
   llvm_unreachable("unknown cast resulting in complex value");
 }
 
 bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
   if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)

clang/test/AST/const-fpfeatures.c

 // RUN: %clang_cc1 -fexperimental-strict-floating-point -S -emit-llvm -triple i386-linux -Wno-unknown-pragmas %s -o - | FileCheck %s
 
 // nextUp(1.F) == 0x1.000002p0F
 
 const double _Complex C0 = 0x1.000001p0 + 0x1.000001p0I;
 
 #pragma STDC FENV_ROUND FE_UPWARD
 
 float F1u = 1.0F + 0x0.000002p0F;
 float F2u = 1.0F + 0x0.000001p0F;
 float F3u = 0x1.000001p0;
 // CHECK: @F1u = {{.*}} float 0x3FF0000020000000
 // CHECK: @F2u = {{.*}} float 0x3FF0000020000000
 // CHECK: @F3u = {{.*}} float 0x3FF0000020000000
 
+float FI1u = 0xFFFFFFFFU;
+// CHECK: @FI1u = {{.*}} float 0x41F0000000000000
+
 float _Complex C1u = C0;
 // CHECK: @C1u = {{.*}} { float, float } { float 0x3FF0000020000000, float 0x3FF0000020000000 }
 
 
 #pragma STDC FENV_ROUND FE_DOWNWARD
 
 float F1d = 1.0F + 0x0.000002p0F;
 float F2d = 1.0F + 0x0.000001p0F;
 float F3d = 0x1.000001p0;
 
 // CHECK: @F1d = {{.*}} float 0x3FF0000020000000
 // CHECK: @F2d = {{.*}} float 1.000000e+00
 // CHECK: @F3d = {{.*}} float 1.000000e+00
 
+float FI1d = 0xFFFFFFFFU;
+// CHECK: @FI1d = {{.*}} float 0x41EFFFFFE0000000
+
 float _Complex C1d = C0;
 // CHECK: @C1d = {{.*}} { float, float } { float 1.000000e+00, float 1.000000e+00 }

clang/test/Sema/constant-conversion.c

-// RUN: %clang_cc1 -fsyntax-only -ffreestanding -verify=expected,one-bit -triple x86_64-apple-darwin %s
-// RUN: %clang_cc1 -fsyntax-only -ffreestanding -Wno-single-bit-bitfield-constant-conversion -verify -triple x86_64-apple-darwin %s
+// RUN: %clang_cc1 -fsyntax-only -ffreestanding -Wno-unknown-pragmas -verify=expected,one-bit -triple x86_64-apple-darwin %s
+// RUN: %clang_cc1 -fsyntax-only -ffreestanding -Wno-unknown-pragmas -Wno-single-bit-bitfield-constant-conversion -verify -triple x86_64-apple-darwin %s
 
 #include <stdbool.h>
 
 // This file tests -Wconstant-conversion, a subcategory of -Wconversion
 // which is on by default.
 
 // rdar://problem/6792488
 void test_6792488(void) {