re PR c++/24745 (unpleasant warning for "if (NULL)")

2007-01-30  Manuel Lopez-Ibanez  <manu@gcc.gnu.org>

	PR c++/24745
	* doc/invoke.texi (Wpointer-arith): Document warning.

cp/
	* typeck.c (build_binary_op): Fix logic for warning. Move warning
	to -Wpointer-arith.
	* call.c (convert_like_real): Don't warn when converting to
	boolean type.

testsuite/
	* g++.dg/warn/null4.C: New.

From-SVN: r121361

gcc/ChangeLog

+2007-01-30  Manuel Lopez-Ibanez  <manu@gcc.gnu.org>
+
+	PR c++/24745
+	* doc/invoke.texi (Wpointer-arith): Document warning.
+	
 2007-01-30  Janis Johnson
 
 	* doc/extend.texi (Decimal Floating Types): Remove decfloat.h from

gcc/cp/ChangeLog

+2007-01-30  Manuel Lopez-Ibanez  <manu@gcc.gnu.org>
+
+	PR c++/24745
+	* typeck.c (build_binary_op): Fix logic for warning. Move warning
+	to -Wpointer-arith.
+	* call.c (convert_like_real): Don't warn when converting to
+	boolean type.
+	
 2007-01-29  Manuel Lopez-Ibanez  <manu@gcc.gnu.org>
 
 	* decl.c (pop_label): Replace warning with call to

gcc/cp/call.c

@@ -4250,7 +4250,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
       tree t = non_reference (totype);
 
       /* Issue warnings about peculiar, but valid, uses of NULL.  */
-      if (ARITHMETIC_TYPE_P (t) && expr == null_node)
+      if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
 	{
 	  if (fn)
 	    warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",

gcc/cp/typeck.c

@@ -3828,30 +3828,28 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
 	}
     }
 
-  /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
-     Then the expression will be built.
-     It will be given type FINAL_TYPE if that is nonzero;
-     otherwise, it will be given type RESULT_TYPE.  */
-
   /* Issue warnings about peculiar, but valid, uses of NULL.  */
-  if (/* It's reasonable to use pointer values as operands of &&
+  if ((orig_op0 == null_node || orig_op1 == null_node)
+      /* It's reasonable to use pointer values as operands of &&
 	 and ||, so NULL is no exception.  */
-      !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
-      && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa.  */
-	  (orig_op0 == null_node
-	   && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
-	  /* Or vice versa.  */
-	  || (orig_op1 == null_node
-	      && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
-	  /* Or, both are NULL and the operation was not a comparison.  */
-	  || (orig_op0 == null_node && orig_op1 == null_node
-	      && code != EQ_EXPR && code != NE_EXPR)))
+      && code != TRUTH_ANDIF_EXPR && code != TRUTH_ORIF_EXPR 
+      && ( /* Both are NULL (or 0) and the operation was not a comparison.  */
+	  (null_ptr_cst_p (orig_op0) && null_ptr_cst_p (orig_op1) 
+	   && code != EQ_EXPR && code != NE_EXPR) 
+	  /* Or if one of OP0 or OP1 is neither a pointer nor NULL.  */
+	  || (!null_ptr_cst_p (orig_op0) && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
+	  || (!null_ptr_cst_p (orig_op1) && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)))
     /* Some sort of arithmetic operation involving NULL was
        performed.  Note that pointer-difference and pointer-addition
        have already been handled above, and so we don't end up here in
        that case.  */
-    warning (0, "NULL used in arithmetic");
+    warning (OPT_Wpointer_arith, "NULL used in arithmetic");
+  
 
+  /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
+     Then the expression will be built.
+     It will be given type FINAL_TYPE if that is nonzero;
+     otherwise, it will be given type RESULT_TYPE.  */
   if (! converted)
     {
       if (TREE_TYPE (op0) != result_type)

gcc/doc/invoke.texi

@@ -3153,7 +3153,8 @@ such assumptions.
 Warn about anything that depends on the ``size of'' a function type or
 of @code{void}.  GNU C assigns these types a size of 1, for
 convenience in calculations with @code{void *} pointers and pointers
-to functions.
+to functions.  In C++, warn also when an arithmetic operation involves
+@code{NULL}.  This warning is also enabled by @option{-pedantic}.
 
 @item -Wbad-function-cast @r{(C only)}
 @opindex Wbad-function-cast

gcc/testsuite/ChangeLog

+2007-01-30  Manuel Lopez-Ibanez  <manu@gcc.gnu.org>
+
+	PR c++/24745
+	* g++.dg/warn/null4.C: New.
+
 2001-01-30  Roger Sayle  <roger@eyesopen.com>
 	    Uros Bizjak  <ubizjak@gmail.com>
 

gcc/testsuite/g++.dg/warn/null4.C

+// PR c++/24745 : warnings for NULL constant.
+// { dg-do compile  }
+// { dg-options "-Wpointer-arith -Wconversion " }
+
+#include <cstddef>
+
+int foo (void) 
+{
+  if (NULL == 1) return -1;   // { dg-warning "NULL used in arithmetic" } 
+  if (NULL > NULL) return -1; // { dg-warning "NULL used in arithmetic" } 
+  if (NULL < NULL) return -1; // { dg-warning "NULL used in arithmetic" } 
+  if (NULL >= 0) return -1;   // { dg-warning "NULL used in arithmetic" } 
+  if (NULL <= 0) return -1;   // { dg-warning "NULL used in arithmetic" } 
+  return 0;
+}
+
+int bar (void) 
+{
+  if (NULL) return -1;
+  if (!NULL) return -1;
+  if (!NULL == 1) return -1;
+  if (NULL || NULL) return -1;
+  if (!NULL && NULL) return -1;
+  if (NULL == NULL) return -1;
+  if (NULL != NULL) return -1;
+  if (NULL == 0) return -1;
+  if (NULL != 0) return -1;
+  return 0;
+}