r267054 - Split interesting warnings off from -Wfloat-conversion

Richard Trieu via cfe-commits cfe-commits at lists.llvm.org
Fri Apr 22 14:15:08 PDT 2016


On Fri, Apr 22, 2016 at 10:50 AM, David Blaikie <dblaikie at gmail.com> wrote:

>
>
> On Thu, Apr 21, 2016 at 2:04 PM, Richard Trieu via cfe-commits <
> cfe-commits at lists.llvm.org> wrote:
>
>> Author: rtrieu
>> Date: Thu Apr 21 16:04:55 2016
>> New Revision: 267054
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=267054&view=rev
>> Log:
>> Split interesting warnings off from -Wfloat-conversion
>>
>> Restructure the implict floating point to integer conversions so that
>> interesting sub-groups are under different flags.  Breakdown of warnings:
>>
>> No warning:
>> Exact conversions from floating point to integer:
>> int x = 10.0;
>> int x = 1e10;
>>
>> -Wliteral-conversion - Floating point literal to integer with rounding:
>> int x = 5.5;
>> int x = -3.4;
>>
>> -Wfloat-conversion - All conversions not covered by the above two:
>> int x = GetFloat();
>> int x = 5.5 + 3.5;
>>
>> -Wfloat-zero-conversion - The expression converted has a non-zero floating
>> point value that gets converted to a zero integer value, excluded the
>> cases
>> falling under -Wliteral-conversion.  Subset of -Wfloat-conversion.
>> int x = 1.0 / 2.0;
>>
>
> This ^ seems like a slightly odd special case. Why is it particularly
> beneficial to have that slice separate from, say, 3.0/2.0 ?
>

I was seeing things such as sleep(.5), where sleep takes an int of seconds,
or error_rate = .001 where the intention was for a small non-zero value to
be used and there was a large jump between meanings of non-zero value and
zero values.   For non-zero to non-zero conversion, the change in meaning
is smaller, and usually intentional.

>
>
>> -Wfloat-overflow-conversion - The floating point value is outside the
>> range
>> of the integer type, exluding cases from -Wliteral conversion.  Subset of
>> -Wfloat-conversion.
>> char x = 500;
>> char x = -1000;
>>
>> -Wfloat-bool-conversion - Any conversion of a floating point type to bool.
>> Subset of -Wfloat-conversion.
>> if (GetFloat()) {}
>> bool x = 5.0;
>
>
>> -Wfloat-bool-constant-conversion - Conversion of a compile time
>> evaluatable
>> floating point value to bool.  Subset of -Wfloat-bool-conversion.
>> bool x = 1.0;
>> bool x = 4.0 / 20.0;
>>
>
> Why this particular slice? Are there cases where literal floats converted
> to bool are desirable that you're carving out by having this (& the
> float-overflow-conversion, float-zero-conversion, etc) split out?
>
Float to bool conversion is being reverted for the time being.

>
>
>>
>> Also add EvaluateAsFloat to Sema, which is similar to EvaluateAsInt, but
>> for
>> floating point values.
>>
>>
>> Modified:
>>     cfe/trunk/include/clang/AST/Expr.h
>>     cfe/trunk/include/clang/Basic/DiagnosticGroups.td
>>     cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
>>     cfe/trunk/lib/AST/ExprConstant.cpp
>>     cfe/trunk/lib/Sema/SemaChecking.cpp
>>     cfe/trunk/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp
>>     cfe/trunk/test/SemaCXX/warn-float-conversion.cpp
>>     cfe/trunk/test/SemaCXX/warn-literal-conversion.cpp
>>
>> Modified: cfe/trunk/include/clang/AST/Expr.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/Expr.h?rev=267054&r1=267053&r2=267054&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/include/clang/AST/Expr.h (original)
>> +++ cfe/trunk/include/clang/AST/Expr.h Thu Apr 21 16:04:55 2016
>> @@ -594,6 +594,13 @@ public:
>>    bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx,
>>                       SideEffectsKind AllowSideEffects =
>> SE_NoSideEffects) const;
>>
>> +  /// EvaluateAsFloat - Return true if this is a constant which we can
>> fold and
>> +  /// convert to a floating point value, using any crazy technique that
>> we
>> +  /// want to.
>> +  bool
>> +  EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx,
>> +                  SideEffectsKind AllowSideEffects = SE_NoSideEffects)
>> const;
>> +
>>    /// isEvaluatable - Call EvaluateAsRValue to see if this expression
>> can be
>>    /// constant folded without side-effects, but discard the result.
>>    bool isEvaluatable(const ASTContext &Ctx,
>>
>> Modified: cfe/trunk/include/clang/Basic/DiagnosticGroups.td
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticGroups.td?rev=267054&r1=267053&r2=267054&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/include/clang/Basic/DiagnosticGroups.td (original)
>> +++ cfe/trunk/include/clang/Basic/DiagnosticGroups.td Thu Apr 21 16:04:55
>> 2016
>> @@ -46,7 +46,17 @@ def BoolConversion : DiagGroup<"bool-con
>>
>> UndefinedBoolConversion]>;
>>  def IntConversion : DiagGroup<"int-conversion">;
>>  def EnumConversion : DiagGroup<"enum-conversion">;
>> -def FloatConversion : DiagGroup<"float-conversion">;
>> +
>> +def FloatOverflowConversion : DiagGroup<"float-overflow-conversion">;
>> +def FloatZeroConversion : DiagGroup<"float-zero-conversion">;
>> +def FloatBoolConstantConversion :
>> DiagGroup<"float-bool-constant-conversion">;
>> +def FloatBoolConversion :
>> +  DiagGroup<"float-bool-conversion", [FloatBoolConstantConversion]>;
>> +def FloatConversion :
>> +  DiagGroup<"float-conversion", [FloatBoolConversion,
>> +                                 FloatOverflowConversion,
>> +                                 FloatZeroConversion]>;
>> +
>>  def DoublePromotion : DiagGroup<"double-promotion">;
>>  def EnumTooLarge : DiagGroup<"enum-too-large">;
>>  def UnsupportedNan : DiagGroup<"unsupported-nan">;
>>
>> Modified: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td?rev=267054&r1=267053&r2=267054&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td (original)
>> +++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td Thu Apr 21
>> 16:04:55 2016
>> @@ -2742,9 +2742,6 @@ def warn_impcast_float_precision : Warni
>>  def warn_impcast_double_promotion : Warning<
>>    "implicit conversion increases floating-point precision: %0 to %1">,
>>    InGroup<DoublePromotion>, DefaultIgnore;
>> -def warn_impcast_float_integer : Warning<
>> -  "implicit conversion turns floating-point number into integer: %0 to
>> %1">,
>> -  InGroup<FloatConversion>, DefaultIgnore;
>>  def warn_impcast_integer_sign : Warning<
>>    "implicit conversion changes signedness: %0 to %1">,
>>    InGroup<SignConversion>, DefaultIgnore;
>> @@ -2763,9 +2760,29 @@ def warn_impcast_integer_precision_const
>>  def warn_impcast_bitfield_precision_constant : Warning<
>>    "implicit truncation from %2 to bitfield changes value from %0 to %1">,
>>    InGroup<BitFieldConstantConversion>;
>> +
>>  def warn_impcast_literal_float_to_integer : Warning<
>>    "implicit conversion from %0 to %1 changes value from %2 to %3">,
>>    InGroup<LiteralConversion>;
>> +def warn_impcast_float_integer : Warning<
>> +  "implicit conversion turns floating-point number into integer: %0 to
>> %1">,
>> +  InGroup<FloatConversion>, DefaultIgnore;
>> +
>> +def warn_impcast_float_bool : Warning<
>> +  "implicit conversion turns floating-point number into boolean: %0 to
>> %1">,
>> +  InGroup<FloatBoolConversion>, DefaultIgnore;
>> +def warn_impcast_float_to_bool : Warning<
>> +  "implicit conversion from %0 to %1 changes value from %2 to %3">,
>> +  InGroup<FloatBoolConstantConversion>;
>> +
>> +def warn_impcast_float_to_integer : Warning<
>> +  "implicit conversion of out of range value from %0 to %1 changes value
>> "
>> +  "from %2 to %3">,
>> +  InGroup<FloatOverflowConversion>, DefaultIgnore;
>> +def warn_impcast_float_to_integer_zero : Warning<
>> +  "implicit conversion from %0 to %1 changes non-zero value from %2 to
>> %3">,
>> +  InGroup<FloatZeroConversion>, DefaultIgnore;
>> +
>>  def warn_impcast_string_literal_to_bool : Warning<
>>    "implicit conversion turns string literal into bool: %0 to %1">,
>>    InGroup<StringConversion>, DefaultIgnore;
>>
>> Modified: cfe/trunk/lib/AST/ExprConstant.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ExprConstant.cpp?rev=267054&r1=267053&r2=267054&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/ExprConstant.cpp (original)
>> +++ cfe/trunk/lib/AST/ExprConstant.cpp Thu Apr 21 16:04:55 2016
>> @@ -9027,6 +9027,20 @@ bool Expr::EvaluateAsInt(APSInt &Result,
>>    return true;
>>  }
>>
>> +bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx,
>> +                           SideEffectsKind AllowSideEffects) const {
>> +  if (!getType()->isRealFloatingType())
>> +    return false;
>> +
>> +  EvalResult ExprResult;
>> +  if (!EvaluateAsRValue(ExprResult, Ctx) || !ExprResult.Val.isFloat() ||
>> +      hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
>> +    return false;
>> +
>> +  Result = ExprResult.Val.getFloat();
>> +  return true;
>> +}
>> +
>>  bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx)
>> const {
>>    EvalInfo Info(Ctx, Result, EvalInfo::EM_ConstantFold);
>>
>>
>> Modified: cfe/trunk/lib/Sema/SemaChecking.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaChecking.cpp?rev=267054&r1=267053&r2=267054&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaChecking.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaChecking.cpp Thu Apr 21 16:04:55 2016
>> @@ -7382,19 +7382,78 @@ void DiagnoseImpCast(Sema &S, Expr *E, Q
>>    DiagnoseImpCast(S, E, E->getType(), T, CContext, diag,
>> pruneControlFlow);
>>  }
>>
>> -/// Diagnose an implicit cast from a literal expression. Does not warn
>> when the
>> -/// cast wouldn't lose information.
>> -void DiagnoseFloatingLiteralImpCast(Sema &S, FloatingLiteral *FL,
>> QualType T,
>> -                                    SourceLocation CContext) {
>> -  // Try to convert the literal exactly to an integer. If we can, don't
>> warn.
>> +
>> +/// Diagnose an implicit cast from a floating point value to an integer
>> value.
>> +void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T,
>> +
>> +                             SourceLocation CContext) {
>> +  const bool IsBool = T->isSpecificBuiltinType(BuiltinType::Bool);
>> +  const bool PruneWarnings = !S.ActiveTemplateInstantiations.empty();
>> +
>> +  Expr *InnerE = E->IgnoreParenImpCasts();
>> +  // We also want to warn on, e.g., "int i = -1.234"
>> +  if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(InnerE))
>> +    if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
>> +      InnerE = UOp->getSubExpr()->IgnoreParenImpCasts();
>> +
>> +  const bool IsLiteral =
>> +      isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
>> +
>> +  llvm::APFloat Value(0.0);
>> +  bool IsConstant =
>> +    E->EvaluateAsFloat(Value, S.Context, Expr::SE_AllowSideEffects);
>> +  if (!IsConstant) {
>> +    if (IsBool) {
>> +      return DiagnoseImpCast(S, E, T, CContext,
>> diag::warn_impcast_float_bool,
>> +                             PruneWarnings);
>> +    } else {
>> +      return DiagnoseImpCast(S, E, T, CContext,
>> +                             diag::warn_impcast_float_integer,
>> PruneWarnings);
>> +    }
>> +  }
>> +
>>    bool isExact = false;
>> -  const llvm::APFloat &Value = FL->getValue();
>> +
>>    llvm::APSInt IntegerValue(S.Context.getIntWidth(T),
>>                              T->hasUnsignedIntegerRepresentation());
>> -  if (Value.convertToInteger(IntegerValue,
>> -                             llvm::APFloat::rmTowardZero, &isExact)
>> -      == llvm::APFloat::opOK && isExact)
>> -    return;
>> +  if (Value.convertToInteger(IntegerValue, llvm::APFloat::rmTowardZero,
>> +                             &isExact) == llvm::APFloat::opOK &&
>> +      isExact && !IsBool) {
>> +    if (IsLiteral) return;
>> +    return DiagnoseImpCast(S, E, T, CContext,
>> diag::warn_impcast_float_integer,
>> +                           PruneWarnings);
>> +  }
>> +
>> +  unsigned DiagID = 0;
>> +  if (IsBool) {
>> +    // Warn on all floating point to bool conversions
>> +    DiagID = diag::warn_impcast_float_to_bool;
>> +  } else if (IsLiteral) {
>> +    // Warn on floating point literal to integer.
>> +    DiagID = diag::warn_impcast_literal_float_to_integer;
>> +  } else if (IntegerValue == 0) {
>> +    if (Value.isZero()) {  // Skip -0.0 to 0 conversion.
>> +      return DiagnoseImpCast(S, E, T, CContext,
>> +                             diag::warn_impcast_float_integer,
>> PruneWarnings);
>> +    }
>> +    // Warn on non-zero to zero conversion.
>> +    DiagID = diag::warn_impcast_float_to_integer_zero;
>> +  } else {
>> +    if (IntegerValue.isUnsigned()) {
>> +      if (!IntegerValue.isMaxValue()) {
>> +        return DiagnoseImpCast(S, E, T, CContext,
>> +                               diag::warn_impcast_float_integer,
>> PruneWarnings);
>> +      }
>> +    } else {  // IntegerValue.isSigned()
>> +      if (!IntegerValue.isMaxSignedValue() &&
>> +          !IntegerValue.isMinSignedValue()) {
>> +        return DiagnoseImpCast(S, E, T, CContext,
>> +                               diag::warn_impcast_float_integer,
>> PruneWarnings);
>> +      }
>> +    }
>> +    // Warn on evaluatable floating point expression to integer
>> conversion.
>> +    DiagID = diag::warn_impcast_float_to_integer;
>> +  }
>>
>>    // FIXME: Force the precision of the source value down so we don't
>> print
>>    // digits which are usually useless (we don't really care here if we
>> @@ -7407,14 +7466,22 @@ void DiagnoseFloatingLiteralImpCast(Sema
>>    Value.toString(PrettySourceValue, precision);
>>
>>    SmallString<16> PrettyTargetValue;
>> -  if (T->isSpecificBuiltinType(BuiltinType::Bool))
>> +  if (IsBool)
>>      PrettyTargetValue = Value.isZero() ? "false" : "true";
>>    else
>>      IntegerValue.toString(PrettyTargetValue);
>>
>> -  S.Diag(FL->getExprLoc(), diag::warn_impcast_literal_float_to_integer)
>> -    << FL->getType() << T.getUnqualifiedType() << PrettySourceValue
>> -    << PrettyTargetValue << FL->getSourceRange() <<
>> SourceRange(CContext);
>> +  if (PruneWarnings) {
>> +    S.DiagRuntimeBehavior(E->getExprLoc(), E,
>> +                          S.PDiag(DiagID)
>> +                              << E->getType() << T.getUnqualifiedType()
>> +                              << PrettySourceValue << PrettyTargetValue
>> +                              << E->getSourceRange() <<
>> SourceRange(CContext));
>> +  } else {
>> +    S.Diag(E->getExprLoc(), DiagID)
>> +        << E->getType() << T.getUnqualifiedType() << PrettySourceValue
>> +        << PrettyTargetValue << E->getSourceRange() <<
>> SourceRange(CContext);
>> +  }
>>  }
>>
>>  std::string PrettyPrintInRange(const llvm::APSInt &Value, IntRange
>> Range) {
>> @@ -7748,22 +7815,12 @@ void CheckImplicitConversion(Sema &S, Ex
>>        return;
>>      }
>>
>> -    // If the target is integral, always warn.
>> +    // If the target is integral, always warn.
>>      if (TargetBT && TargetBT->isInteger()) {
>>        if (S.SourceMgr.isInSystemMacro(CC))
>>          return;
>> -
>> -      Expr *InnerE = E->IgnoreParenImpCasts();
>> -      // We also want to warn on, e.g., "int i = -1.234"
>> -      if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(InnerE))
>> -        if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
>> -          InnerE = UOp->getSubExpr()->IgnoreParenImpCasts();
>> -
>> -      if (FloatingLiteral *FL = dyn_cast<FloatingLiteral>(InnerE)) {
>> -        DiagnoseFloatingLiteralImpCast(S, FL, T, CC);
>> -      } else {
>> -        DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_float_integer);
>> -      }
>> +
>> +      DiagnoseFloatingImpCast(S, E, T, CC);
>>      }
>>
>>      // Detect the case where a call result is converted from
>> floating-point to
>>
>> Modified: cfe/trunk/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp?rev=267054&r1=267053&r2=267054&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp
>> (original)
>> +++ cfe/trunk/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp Thu Apr
>> 21 16:04:55 2016
>> @@ -58,8 +58,8 @@ void float_to_int() {
>>    Agg<char> ce1 = { Convert<float>(1.0) }; // expected-error {{type
>> 'float' cannot be narrowed to 'char'}} expected-note {{silence}}
>>    Agg<char> ce2 = { ConvertVar<double>() }; // expected-error {{type
>> 'double' cannot be narrowed to 'char'}} expected-note {{silence}}
>>
>> -  bool b{1.0}; // expected-error {{type 'double' cannot be narrowed to
>> 'bool'}} expected-note {{silence}}
>> -  Agg<bool> ab = {0.0}; // expected-error {{type 'double' cannot be
>> narrowed to 'bool'}} expected-note {{silence}}
>> +  bool b{1.0}; // expected-error {{type 'double' cannot be narrowed to
>> 'bool'}} expected-note {{silence}} expected-warning {{changes value}}
>> +  Agg<bool> ab = {0.0}; // expected-error {{type 'double' cannot be
>> narrowed to 'bool'}} expected-note {{silence}} expected-warning {{changes
>> value}}
>>  }
>>
>>  // * from long double to double or float, or from double to float,
>> except where
>>
>> Modified: cfe/trunk/test/SemaCXX/warn-float-conversion.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/warn-float-conversion.cpp?rev=267054&r1=267053&r2=267054&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/test/SemaCXX/warn-float-conversion.cpp (original)
>> +++ cfe/trunk/test/SemaCXX/warn-float-conversion.cpp Thu Apr 21 16:04:55
>> 2016
>> @@ -1,5 +1,12 @@
>> -// RUN: %clang_cc1 -verify -fsyntax-only %s -Wfloat-conversion
>> +// RUN: %clang_cc1 -verify -fsyntax-only -triple x86_64-pc-linux-gnu %s
>> -Wno-literal-conversion -Wfloat-conversion -DFLOAT_CONVERSION -DZERO -DBOOL
>> -DCONSTANT_BOOL -DOVERFLOW
>> +// RUN: %clang_cc1 -verify -fsyntax-only -triple x86_64-pc-linux-gnu %s
>> -Wno-conversion -Wfloat-overflow-conversion -DOVERFLOW
>> +// RUN: %clang_cc1 -verify -fsyntax-only -triple x86_64-pc-linux-gnu %s
>> -Wno-conversion -Wfloat-zero-conversion -DZERO
>> +// RUN: %clang_cc1 -verify -fsyntax-only -triple x86_64-pc-linux-gnu %s
>> -Wno-conversion -Wfloat-bool-constant-conversion -DCONSTANT_BOOL
>> +// RUN: %clang_cc1 -verify -fsyntax-only -triple x86_64-pc-linux-gnu %s
>> -Wno-conversion -Wfloat-bool-conversion -DCONSTANT_BOOL -DBOOL
>>
>> +float ReturnFloat();
>> +
>> +#ifdef FLOAT_CONVERSION
>>  bool ReturnBool(float f) {
>>    return f;  //expected-warning{{conversion}}
>>  }
>> @@ -36,3 +43,80 @@ void Convert(float f, double d, long dou
>>    l = ld;  //expected-warning{{conversion}}
>>  }
>>
>> +void Test() {
>> +  int a1 = 10.0/2.0;  //expected-warning{{conversion}}
>> +  int a2 = 1.0/2.0;  //expected-warning{{conversion}}
>> +  bool a3 = ReturnFloat();  //expected-warning{{conversion}}
>> +  int a4 = 1e30 + 1;  //expected-warning{{conversion}}
>> +}
>> +
>> +void TestConstantFloat() {
>> +  // Don't warn on exact floating literals.
>> +  int a1 = 5.0;
>> +  int a2 = 1e3;
>> +
>> +  int a3 = 5.5;  // caught by -Wliteral-conversion
>> +  int a4 = 500.44;  // caught by -Wliteral-convserion
>> +
>> +  int b1 = 5.0 / 1.0;  //expected-warning{{conversion}}
>> +  int b2 = 5.0 / 2.0;  //expected-warning{{conversion}}
>> +
>> +  const float five = 5.0;
>> +
>> +  int b3 = five / 1.0;  //expected-warning{{conversion}}
>> +  int b4 = five / 2.0;  //expected-warning{{conversion}}
>> +}
>> +#endif  // FLOAT_CONVERSION
>> +
>> +#ifdef CONSTANT_BOOL
>> +const float pi = 3.1415;
>> +
>> +void TestConstantBool() {
>> +  bool b1 = 0.99f; // expected-warning {{implicit conversion from
>> 'float' to 'bool' changes value from 0.99 to true}}
>> +  bool b2 = 0.99; // expected-warning {{implicit conversion from
>> 'double' to 'bool' changes value from 0.99 to true}}
>> +  bool b3 = 0.0f; // expected-warning {{implicit conversion from 'float'
>> to 'bool' changes value from 0 to false}}
>> +  bool b4 = 0.0; // expected-warning {{implicit conversion from 'double'
>> to 'bool' changes value from 0 to false}}
>> +  bool b5 = 1.0f; // expected-warning {{implicit conversion from 'float'
>> to 'bool' changes value from 1 to true}}
>> +  bool b6 = 1.0; // expected-warning {{implicit conversion from 'double'
>> to 'bool' changes value from 1 to true}}
>> +  bool b7 = pi; // expected-warning {{implicit conversion from 'const
>> float' to 'bool' changes value from 3.1415 to true}}
>> +  bool b8 = pi - pi; // expected-warning {{implicit conversion from
>> 'float' to 'bool' changes value from 0 to false}}
>> +}
>> +#endif  // CONSTANT_BOOL
>> +
>> +#ifdef BOOL
>> +const float E = 2.718;
>> +
>> +float GetFloat();
>> +double GetDouble();
>> +
>> +void TestBool() {
>> +  bool b1 = GetFloat(); // expected-warning {{implicit conversion turns
>> floating-point number into boolean: 'float' to 'bool'}}
>> +  bool b2 = GetDouble(); // expected-warning {{implicit conversion turns
>> floating-point number into boolean: 'double' to 'bool'}}
>> +  bool b3 = 0.0 * GetDouble(); // expected-warning {{implicit conversion
>> turns floating-point number into boolean: 'double' to 'bool'}}
>> +  bool b4 = GetFloat() + GetDouble(); // expected-warning {{implicit
>> conversion turns floating-point number into boolean: 'double' to 'bool'}}
>> +  bool b5 = E + GetFloat(); // expected-warning {{implicit conversion
>> turns floating-point number into boolean: 'float' to 'bool'}}
>> +}
>> +
>> +#endif  // BOOL
>> +
>> +#ifdef ZERO
>> +void TestZero() {
>> +  const float half = .5;
>> +  int a1 = half;  // expected-warning{{implicit conversion from 'const
>> float' to 'int' changes non-zero value from 0.5 to 0}}
>> +  int a2 = 1.0 / 2.0;  // expected-warning{{implicit conversion from
>> 'double' to 'int' changes non-zero value from 0.5 to 0}}
>> +  int a3 = 5;
>> +}
>> +#endif  // ZERO
>> +
>> +#ifdef OVERFLOW
>> +void TestOverflow() {
>> +  char a = 500.0;  // caught by -Wliteral-conversion
>> +  char b = -500.0;  // caught by -Wliteral-conversion
>> +
>> +  const float LargeNumber = 1024;
>> +  char c = LargeNumber;  // expected-warning{{implicit conversion of out
>> of range value from 'const float' to 'char' changes value from 1024 to 127}}
>> +  char d = 400.0 + 400.0;  // expected-warning{{implicit conversion of
>> out of range value from 'double' to 'char' changes value from 800 to 127}}
>> +
>> +  char e = 1.0 / 0.0;  // expected-warning{{implicit conversion of out
>> of range value from 'double' to 'char' changes value from +Inf to 127}}
>> +}
>> +#endif  // OVERFLOW
>>
>> Modified: cfe/trunk/test/SemaCXX/warn-literal-conversion.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/warn-literal-conversion.cpp?rev=267054&r1=267053&r2=267054&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/test/SemaCXX/warn-literal-conversion.cpp (original)
>> +++ cfe/trunk/test/SemaCXX/warn-literal-conversion.cpp Thu Apr 21
>> 16:04:55 2016
>> @@ -25,7 +25,7 @@ void test0() {
>>    // Test passing a literal floating-point value to a function that
>> takes an integer.
>>    foo(1.2F); // expected-warning {{implicit conversion from 'float' to
>> 'int' changes value from 1.2 to 1}}
>>
>> -  int y10 = -1.2F;  // expected-warning {{implicit conversion from
>> 'float' to 'int' changes value from 1.2 to 1}}
>> +  int y10 = -1.2F;  // expected-warning {{implicit conversion from
>> 'float' to 'int' changes value from -1.2 to -1}}
>>
>>    // -Wliteral-conversion does NOT catch const values.
>>    // (-Wconversion DOES catch them.)
>> @@ -38,14 +38,3 @@ void test0() {
>>    int y = (24*60*60) * 0.25;
>>    int pennies = 123.45 * 100;
>>  }
>> -
>> -// Similarly, test floating point conversion to bool. Only float values
>> of zero
>> -// are converted to false; everything else is converted to true.
>> -void test1() {
>> -  bool b1 = 0.99f; // expected-warning {{implicit conversion from
>> 'float' to 'bool' changes value from 0.99 to true}}
>> -  bool b2 = 0.99; // expected-warning {{implicit conversion from
>> 'double' to 'bool' changes value from 0.99 to true}}
>> -  // These do not warn because they can be directly converted to integral
>> -  // values.
>> -  bool b3 = 0.0f;
>> -  bool b4 = 0.0;
>> -}
>>
>>
>> _______________________________________________
>> cfe-commits mailing list
>> cfe-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20160422/6a4d1c0b/attachment-0001.html>


More information about the cfe-commits mailing list