[C PATCH] Warn about unused RHS of COMPOUND_EXPR (PR c/59871)

Marek Polacek polacek@redhat.com
Wed Jan 22 10:08:00 GMT 2014


On Wed, Jan 22, 2014 at 12:15:00AM +0100, Jakub Jelinek wrote:
> And for
>   (bar (), (bar (), (bar (), (bar (), (bar (), (bar (), (bar (), 7)))))));
> ?

Argh, for this one we've got COMPOUND_EXPRs even in TREE_OPERAND (r, 1).
Fixed & sorry.
 
> On the other side, there is warn_if_unused_value, which specifically has:
>       /* Let people do `(foo (), 0)' without a warning.  */
>       if (TREE_CONSTANT (TREE_OPERAND (exp, 1)))
>         return false;
> so perhaps it is intentional that we don't warn about this?
> That stuff dates all the way back to r759.  Though I wonder why it would
> be desirable to warn about this for C++ and not for C.

This is confusing.  I'll try to sumarize what I see.  Let A, B, C, D
be stmts:

	A: bar (), 1;
	B: (bar (), 1);
	C: bar (), 5 * i;
	D: (bar (), 5 * i);

C++ warns on A and C ("right operand..."), those parentheses suppress warnings.
C before patch warns on C and D with "value computed is not used".
C with my patch warns on A, B, C, and D with "right-hand operand...".

I think what my patch does should be desirable.  I added a few more
tests into the testcase.

2014-01-22  Marek Polacek  <polacek@redhat.com>

	PR c/59871
c/
	* c-typeck.c (build_compound_expr): Warn even for right-hand operand
	of a comma expression.
	(emit_side_effect_warnings): Likewise.
libdecnumber/
	* decNumberLocal.h (UBFROMUS, UBFROMUI): Remove last argument.
testsuite/
	* gcc.dg/20020220-2.c: Adjust dg-warning message.
	* gcc.dg/pr59871.c: New test.

--- gcc/libdecnumber/decNumberLocal.h.mp	2014-01-21 18:34:32.235540589 +0100
+++ gcc/libdecnumber/decNumberLocal.h	2014-01-21 22:04:34.331223218 +0100
@@ -153,10 +153,9 @@ see the files COPYING3 and COPYING.RUNTI
   #define UBTOUI(b)  (memcpy((void *)&uiwork, b, 4), uiwork)
 
   /* Store a uInt, etc., into bytes starting at a char* or uByte*.    */
-  /* Returns i, evaluated, for convenience; has to use uiwork because */
-  /* i may be an expression.					      */
-  #define UBFROMUS(b, i)  (uswork=(i), memcpy(b, (void *)&uswork, 2), uswork)
-  #define UBFROMUI(b, i)  (uiwork=(i), memcpy(b, (void *)&uiwork, 4), uiwork)
+  /* Has to use uiwork because i may be an expression.		      */
+  #define UBFROMUS(b, i)  (uswork=(i), memcpy(b, (void *)&uswork, 2))
+  #define UBFROMUI(b, i)  (uiwork=(i), memcpy(b, (void *)&uiwork, 4))
 
   /* X10 and X100 -- multiply integer i by 10 or 100		      */
   /* [shifts are usually faster than multiply; could be conditional]  */
--- gcc/gcc/c/c-typeck.c.mp	2014-01-21 11:59:33.221215248 +0100
+++ gcc/gcc/c/c-typeck.c	2014-01-22 11:04:51.681894533 +0100
@@ -4776,6 +4776,23 @@ build_compound_expr (location_t loc, tre
 			"left-hand operand of comma expression has no effect");
 	}
     }
+  else if (TREE_CODE (expr1) == COMPOUND_EXPR
+	   && warn_unused_value)
+    {
+      tree r = expr1;
+      location_t cloc = loc;
+      while (TREE_CODE (r) == COMPOUND_EXPR)
+        {
+	  if (EXPR_HAS_LOCATION (r))
+	    cloc = EXPR_LOCATION (r);
+	  r = TREE_OPERAND (r, 1);
+	}
+      if (!TREE_SIDE_EFFECTS (r)
+	  && !VOID_TYPE_P (TREE_TYPE (r))
+	  && !CONVERT_EXPR_P (r))
+	warning_at (cloc, OPT_Wunused_value,
+	            "right-hand operand of comma expression has no effect");
+    }
 
   /* With -Wunused, we should also warn if the left-hand operand does have
      side-effects, but computes a value which is not used.  For example, in
@@ -9641,6 +9658,23 @@ emit_side_effect_warnings (location_t lo
       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
 	warning_at (loc, OPT_Wunused_value, "statement with no effect");
     }
+  else if (TREE_CODE (expr) == COMPOUND_EXPR)
+    {
+      tree r = expr;
+      location_t cloc = loc;
+      while (TREE_CODE (r) == COMPOUND_EXPR)
+	{
+	  if (EXPR_HAS_LOCATION (r))
+	    cloc = EXPR_LOCATION (r);
+	  r = TREE_OPERAND (r, 1);
+	}
+      if (!TREE_SIDE_EFFECTS (r)
+	  && !VOID_TYPE_P (TREE_TYPE (r))
+	  && !CONVERT_EXPR_P (r)
+	  && !TREE_NO_WARNING (expr))
+	warning_at (cloc, OPT_Wunused_value,
+		    "right-hand operand of comma expression has no effect");
+    }
   else
     warn_if_unused_value (expr, loc);
 }
--- gcc/gcc/testsuite/gcc.dg/20020220-2.c.mp	2014-01-21 14:47:58.888754509 +0100
+++ gcc/gcc/testsuite/gcc.dg/20020220-2.c	2014-01-21 23:13:23.758405040 +0100
@@ -1,5 +1,5 @@
 /* PR c/4697
-   Test whether value computed not used warning is given for compound
+   Test whether operand has no effect warning is given for compound
    expression.  */
 /* { dg-do compile } */
 /* { dg-options "-O2 -Wunused" } */
@@ -7,6 +7,6 @@
 int b;
 int foo (int a)
 {
-  a = a + 1, 5 * b;	/* { dg-warning "value computed is not used" } */
+  a = a + 1, 5 * b; /* { dg-warning "right-hand operand of comma expression has no effect" } */
   return a;
 }
--- gcc/gcc/testsuite/gcc.dg/pr59871.c.mp	2014-01-21 16:17:49.000000000 +0100
+++ gcc/gcc/testsuite/gcc.dg/pr59871.c	2014-01-22 11:00:54.669889124 +0100
@@ -0,0 +1,22 @@
+/* PR c/59871 */
+/* { dg-do compile } */
+/* { dg-options "-Wunused" } */
+
+extern int bar ();
+
+void
+foo (int *p, int i)
+{
+  p[0] = (bar (), 1, bar ()); /* { dg-warning "right-hand operand of comma expression has no effect" } */
+  p[1] = (1, bar ()); /* { dg-warning "left-hand operand of comma expression has no effect" } */
+  bar (), 1, bar (); /* { dg-warning "right-hand operand of comma expression has no effect" } */
+  bar (), 1; /* { dg-warning "right-hand operand of comma expression has no effect" } */
+  1, bar (); /* { dg-warning "left-hand operand of comma expression has no effect" } */
+  (bar (), 1); /* { dg-warning "right-hand operand of comma expression has no effect" } */
+  bar (), 5 * i; /* { dg-warning "right-hand operand of comma expression has no effect" } */
+  (bar (), 5 * i); /* { dg-warning "right-hand operand of comma expression has no effect" } */
+  (bar (), (bar (), (bar (), (bar (), (bar (), (bar (), (bar (), 7))))))); /* { dg-warning "right-hand operand of comma expression has no effect" } */
+  bar (), (bar (), (bar (), (bar (), (bar (), (bar (), (bar (), 7)))))); /* { dg-warning "right-hand operand of comma expression has no effect" } */
+  bar (), (bar (), (bar (), (bar (), (bar (), (bar (), (7, bar ())))))); /* { dg-warning "left-hand operand of comma expression has no effect" } */
+  (bar (), (bar (), (bar (), (bar (), (bar (), (bar (), (7, bar ()))))))); /* { dg-warning "left-hand operand of comma expression has no effect" } */
+}

	Marek



More information about the Gcc-patches mailing list