Attachment 30979 Details for Bug 53001 – Patch to add -Wfloat-conversion option against trunk

[patch] Patch to add -Wfloat-conversion option against trunk

warn_float_patch_simple_trunk.diff (text/plain), 11.29 KB, created by Joshua Cogliati on 2013-10-11 02:23:46 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Joshua Cogliati

Created: 2013-10-11 02:23:46 UTC

Size: 11.29 KB

patch

obsolete

>Index: gcc/c-family/c-common.c
>===================================================================
>--- gcc/c-family/c-common.c	(revision 203112)
>+++ gcc/c-family/c-common.c	(working copy)
>@@ -2517,10 +2517,10 @@ shorten_binary_op (tree result_type, tre
>    Function allows conversions between types of different signedness and
>    does not return true in that case.  Function can produce signedness
>    warnings if PRODUCE_WARNS is true.  */
>-bool
>+enum conversion_safety
> unsafe_conversion_p (tree type, tree expr, bool produce_warns)
> {
>-  bool give_warning = false;
>+  enum conversion_safety give_warning = SAFE_CONVERSION; /* is 0 or false */
>   tree expr_type = TREE_TYPE (expr);
>   location_t loc = EXPR_LOC_OR_HERE (expr);
> 
>@@ -2532,7 +2532,7 @@ unsafe_conversion_p (tree type, tree exp
> 	  && TREE_CODE (type) == INTEGER_TYPE)
> 	{
> 	  if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
>-	    give_warning = true;
>+	    give_warning = UNSAFE_REAL;
> 	}
>       /* Warn for an integer constant that does not fit into integer type.  */
>       else if (TREE_CODE (expr_type) == INTEGER_TYPE
>@@ -2553,7 +2553,7 @@ unsafe_conversion_p (tree type, tree exp
> 			    " constant value to negative integer");
> 	    }
> 	  else
>-	    give_warning = true;
>+	    give_warning = UNSAFE_OTHER;
> 	}
>       else if (TREE_CODE (type) == REAL_TYPE)
> 	{
>@@ -2562,7 +2562,7 @@ unsafe_conversion_p (tree type, tree exp
> 	    {
> 	      REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
> 	      if (!exact_real_truncate (TYPE_MODE (type), &a))
>-		give_warning = true;
>+		give_warning = UNSAFE_REAL;
> 	    }
> 	  /* Warn for a real constant that does not fit into a smaller
> 	     real type.  */
>@@ -2571,7 +2571,7 @@ unsafe_conversion_p (tree type, tree exp
> 	    {
> 	      REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
> 	      if (!exact_real_truncate (TYPE_MODE (type), &a))
>-		give_warning = true;
>+		give_warning = UNSAFE_REAL;
> 	    }
> 	}
>     }
>@@ -2580,7 +2580,7 @@ unsafe_conversion_p (tree type, tree exp
>       /* Warn for real types converted to integer types.  */
>       if (TREE_CODE (expr_type) == REAL_TYPE
> 	  && TREE_CODE (type) == INTEGER_TYPE)
>-	give_warning = true;
>+	give_warning = UNSAFE_REAL;
> 
>       else if (TREE_CODE (expr_type) == INTEGER_TYPE
> 	       && TREE_CODE (type) == INTEGER_TYPE)
>@@ -2618,7 +2618,7 @@ unsafe_conversion_p (tree type, tree exp
> 			  && int_fits_type_p (op1, c_common_signed_type (type))
> 			  && int_fits_type_p (op1,
> 					      c_common_unsigned_type (type))))
>-		    return false;
>+		    return SAFE_CONVERSION;
> 		  /* If constant is unsigned and fits in the target
> 		     type, then the result will also fit.  */
> 		  else if ((TREE_CODE (op0) == INTEGER_CST
>@@ -2627,12 +2627,12 @@ unsafe_conversion_p (tree type, tree exp
> 			   || (TREE_CODE (op1) == INTEGER_CST
> 			       && unsigned1
> 			       && int_fits_type_p (op1, type)))
>-		    return false;
>+		    return SAFE_CONVERSION;
> 		}
> 	    }
> 	  /* Warn for integer types converted to smaller integer types.  */
> 	  if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
>-	    give_warning = true;
>+	    give_warning = UNSAFE_OTHER;
> 
> 	  /* When they are the same width but different signedness,
> 	     then the value may change.  */
>@@ -2668,14 +2668,14 @@ unsafe_conversion_p (tree type, tree exp
> 
> 	  if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
> 	      || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
>-	    give_warning = true;
>+	    give_warning = UNSAFE_OTHER;
> 	}
> 
>       /* Warn for real types converted to smaller real types.  */
>       else if (TREE_CODE (expr_type) == REAL_TYPE
> 	       && TREE_CODE (type) == REAL_TYPE
> 	       && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
>-	give_warning = true;
>+	give_warning = UNSAFE_REAL;
>     }
> 
>   return give_warning;
>@@ -2689,8 +2689,9 @@ conversion_warning (tree type, tree expr
> {
>   tree expr_type = TREE_TYPE (expr);
>   location_t loc = EXPR_LOC_OR_HERE (expr);
>+  enum conversion_safety conversion_kind;
> 
>-  if (!warn_conversion && !warn_sign_conversion)
>+  if (!warn_conversion && !warn_sign_conversion && !warn_float_conversion)
>     return;
> 
>   switch (TREE_CODE (expr))
>@@ -2717,10 +2718,19 @@ conversion_warning (tree type, tree expr
> 
>     case REAL_CST:
>     case INTEGER_CST:
>-      if (unsafe_conversion_p (type, expr, true))
>-	warning_at (loc, OPT_Wconversion,
>-		    "conversion to %qT alters %qT constant value",
>-		    type, expr_type);
>+      conversion_kind = unsafe_conversion_p (type, expr, true);
>+      if(conversion_kind == UNSAFE_REAL) 
>+	{
>+	  warning_at (loc, OPT_Wfloat_conversion,
>+		      "conversion to %qT alters %qT constant value",
>+		      type, expr_type);
>+	} 
>+      else if(conversion_kind)
>+	{
>+	  warning_at (loc, OPT_Wconversion,
>+		      "conversion to %qT alters %qT constant value",
>+		      type, expr_type);
>+	}
>       return;
> 
>     case COND_EXPR:
>@@ -2736,10 +2746,19 @@ conversion_warning (tree type, tree expr
>       }
> 
>     default: /* 'expr' is not a constant.  */
>-      if (unsafe_conversion_p (type, expr, true))
>-	warning_at (loc, OPT_Wconversion,
>-		    "conversion to %qT from %qT may alter its value",
>-		    type, expr_type);
>+      conversion_kind = unsafe_conversion_p (type, expr, true);
>+      if(conversion_kind == UNSAFE_REAL)
>+	{
>+	  warning_at (loc, OPT_Wfloat_conversion,
>+		      "conversion to %qT from %qT may alter its value",
>+		      type, expr_type);
>+	} 
>+      else if(conversion_kind)
>+	{
>+	  warning_at (loc, OPT_Wconversion,
>+		      "conversion to %qT from %qT may alter its value",
>+		      type, expr_type);
>+	}
>     }
> }
> 
>Index: gcc/c-family/c-common.h
>===================================================================
>--- gcc/c-family/c-common.h	(revision 203112)
>+++ gcc/c-family/c-common.h	(working copy)
>@@ -685,6 +685,16 @@ struct visibility_flags
>   unsigned inlines_hidden : 1;	/* True when -finlineshidden in effect.  */
> };
> 
>+/* These variables are possible types of unsafe conversions. 
>+   SAFE_CONVERSION The conversion is safe
>+   UNSAFE_OTHER Another type of conversion with problems
>+   UNSAFE_SIGN Conversion between signed and unsigned integers 
>+    which are all warned about immediately, so this is unused
>+   UNSAFE_REAL Conversions that reduce the precision of reals 
>+    including conversions from reals to integers
>+ */
>+enum conversion_safety { SAFE_CONVERSION = 0, UNSAFE_OTHER, UNSAFE_SIGN, UNSAFE_REAL };
>+
> /* Global visibility options.  */
> extern struct visibility_flags visibility_options;
> 
>@@ -738,7 +748,7 @@ extern tree c_common_signed_type (tree);
> extern tree c_common_signed_or_unsigned_type (int, tree);
> extern void c_common_init_ts (void);
> extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);
>-extern bool unsafe_conversion_p (tree, tree, bool);
>+extern enum conversion_safety unsafe_conversion_p (tree, tree, bool);
> extern bool decl_with_nonnull_addr_p (const_tree);
> extern tree c_fully_fold (tree, bool, bool *);
> extern tree decl_constant_value_for_optimization (tree);
>Index: gcc/c-family/c.opt
>===================================================================
>--- gcc/c-family/c.opt	(revision 203112)
>+++ gcc/c-family/c.opt	(working copy)
>@@ -387,6 +387,10 @@ Werror-implicit-function-declaration
> C ObjC RejectNegative Warning Alias(Werror=, implicit-function-declaration)
> This switch is deprecated; use -Werror=implicit-function-declaration instead
> 
>+Wfloat-conversion
>+C ObjC C++ ObjC++ Var(warn_float_conversion) LangEnabledBy(C ObjC C++ ObjC++,Wconversion)
>+Warn for implicit type conversions that cause loss of floating point precision
>+
> Wfloat-equal
> C ObjC C++ ObjC++ Var(warn_float_equal) Warning
> Warn if testing floating point numbers for equality
>Index: gcc/doc/invoke.texi
>===================================================================
>--- gcc/doc/invoke.texi	(revision 203112)
>+++ gcc/doc/invoke.texi	(working copy)
>@@ -263,7 +263,8 @@ Objective-C and Objective-C++ Dialects}.
> -Wpointer-arith  -Wno-pointer-to-int-cast @gol
> -Wredundant-decls  -Wno-return-local-addr @gol
> -Wreturn-type  -Wsequence-point  -Wshadow @gol
>--Wsign-compare  -Wsign-conversion  -Wsizeof-pointer-memaccess @gol
>+-Wsign-compare  -Wsign-conversion -Wfloat-conversion @gol 
>+-Wsizeof-pointer-memaccess @gol
> -Wstack-protector -Wstack-usage=@var{len} -Wstrict-aliasing @gol
> -Wstrict-aliasing=n @gol -Wstrict-overflow -Wstrict-overflow=@var{n} @gol
> -Wsuggest-attribute=@r{[}pure@r{|}const@r{|}noreturn@r{|}format@r{]} @gol
>@@ -4570,6 +4571,14 @@ value, like assigning a signed integer e
> integer variable. An explicit cast silences the warning. In C, this
> option is enabled also by @option{-Wconversion}.
> 
>+@item -Wfloat-conversion
>+@opindex Wfloat-conversion
>+@opindex Wno-float-conversion
>+Warn for implicit conversions that reduce the precision of a real value. 
>+This includes conversions from real to integer, and from higher precision
>+real to lower precision real values.  This option is also enabled by 
>+@option{-Wconversion}.
>+
> @item -Wsizeof-pointer-memaccess
> @opindex Wsizeof-pointer-memaccess
> @opindex Wno-sizeof-pointer-memaccess
>Index: gcc/testsuite/c-c++-common/Wconversion-real.c
>===================================================================
>--- gcc/testsuite/c-c++-common/Wconversion-real.c	(revision 203112)
>+++ gcc/testsuite/c-c++-common/Wconversion-real.c	(working copy)
>@@ -2,8 +2,8 @@
> 
> /* { dg-do compile } */
> /* { dg-skip-if "doubles are floats" { "avr-*-*" } { "*" } { "" } } */
>-/* { dg-options "-std=c99 -Wconversion" { target c } } */
>-/* { dg-options "-Wconversion" { target c++ } } */
>+/* { dg-options "-std=c99 -Wfloat-conversion" { target c } } */
>+/* { dg-options "-Wfloat-conversion" { target c++ } } */
> /* { dg-require-effective-target large_double } */
> 
> float  vfloat;
>@@ -20,18 +20,18 @@ void h (void)
>   double d = 0;
>   long double ld = 0;
> 
>-  ffloat (3.1); /* { dg-warning "conversion" } */
>-  vfloat = 3.1; /* { dg-warning "conversion" } */
>-  ffloat (3.1L); /* { dg-warning "conversion" } */
>-  vfloat = 3.1L;  /* { dg-warning "conversion" } */
>-  fdouble (3.1L); /* { dg-warning "conversion" "" { target large_long_double } } */
>-  vdouble = 3.1L; /* { dg-warning "conversion" "" { target large_long_double } } */
>-  ffloat (vdouble); /* { dg-warning "conversion" } */
>-  vfloat = vdouble; /* { dg-warning "conversion" } */
>-  ffloat (vlongdouble); /* { dg-warning "conversion" } */
>-  vfloat = vlongdouble; /* { dg-warning "conversion" } */
>-  fdouble (vlongdouble); /* { dg-warning "conversion" "" { target large_long_double } } */
>-  vdouble = vlongdouble; /* { dg-warning "conversion" "" { target large_long_double } } */
>+  ffloat (3.1); /* { dg-warning "float-conversion" } */
>+  vfloat = 3.1; /* { dg-warning "float-conversion" } */
>+  ffloat (3.1L); /* { dg-warning "float-conversion" } */
>+  vfloat = 3.1L;  /* { dg-warning "float-conversion" } */
>+  fdouble (3.1L); /* { dg-warning "float-conversion" "" { target large_long_double } } */
>+  vdouble = 3.1L; /* { dg-warning "float-conversion" "" { target large_long_double } } */
>+  ffloat (vdouble); /* { dg-warning "float-conversion" } */
>+  vfloat = vdouble; /* { dg-warning "float-conversion" } */
>+  ffloat (vlongdouble); /* { dg-warning "float-conversion" } */
>+  vfloat = vlongdouble; /* { dg-warning "float-conversion" } */
>+  fdouble (vlongdouble); /* { dg-warning "float-conversion" "" { target large_long_double } } */
>+  vdouble = vlongdouble; /* { dg-warning "float-conversion" "" { target large_long_double } } */
> 
> 
>   ffloat ((float) 3.1);

Actions: View | Diff

Attachments on bug 53001: 30870 | 30871 | 30873 | 30882 | 30899 | 30913 | 30937 | 30979 | 30980 | 30994 | 31014 | 31065 | 31097