+2003-08-16 Nathan Sidwell <nathan@codesourcery.com>
+
+ PR c++/11512
+ * stmt.c (expand_expr_stmt_value): Don't warn about any void
+ typed expression.
+
2003-08-16 Jan Hubicka <jh@suse.cz>
* i386.c (ix86_fntype_regparm): Rename from ...
+2003-08-16 Nathan Sidwell <nathan@codesourcery.com>
+
+ PR c++/11512
+ * cvt.c (convert_to_void): Indicate which side of conditional has
+ no effects, and rhs of comma operator. Test for no sideeffect
+ expressions here and always build a convert expr.
+ * init.c (expand_default_init): Convert the init to void.
+ * typeck.c (build_x_compound_expr): Do not check for side effects
+ here.
+ (build_compound_expr): Do not convert lhs when building a
+ template.
+
2003-08-15 Nathan Sidwell <nathan@codesourcery.com>
* cp-tree.def (NON_DEPENDENT_EXPR): Add operand.
/* The two parts of a cond expr might be separate lvalues. */
tree op1 = TREE_OPERAND (expr,1);
tree op2 = TREE_OPERAND (expr,2);
- tree new_op1 = convert_to_void (op1, implicit);
- tree new_op2 = convert_to_void (op2, implicit);
+ tree new_op1 = convert_to_void
+ (op1, (implicit && !TREE_SIDE_EFFECTS (op2)
+ ? "second operand of conditional" : NULL));
+ tree new_op2 = convert_to_void
+ (op2, (implicit && !TREE_SIDE_EFFECTS (op1)
+ ? "third operand of conditional" : NULL));
expr = build (COND_EXPR, TREE_TYPE (new_op1),
TREE_OPERAND (expr, 0), new_op1, new_op2);
{
/* The second part of a compound expr contains the value. */
tree op1 = TREE_OPERAND (expr,1);
- tree new_op1 = convert_to_void (op1, implicit);
+ tree new_op1 = convert_to_void
+ (op1, implicit ? "right-hand operand of comma" : NULL);
if (new_op1 != op1)
{
if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
{
- /* FIXME: This is where we should check for expressions with no
- effects. At the moment we do that in both build_x_component_expr
- and expand_expr_stmt -- inconsistently too. For the moment
- leave implicit void conversions unadorned so that expand_expr_stmt
- has a chance of detecting some of the cases. */
- if (!implicit)
- expr = build1 (CONVERT_EXPR, void_type_node, expr);
+ if (implicit && !TREE_SIDE_EFFECTS (expr) && warn_unused_value)
+ warning ("%s has no effect", implicit);
+ expr = build1 (CONVERT_EXPR, void_type_node, expr);
}
return expr;
}
rval = build_special_member_call (exp, ctor_name, parms, binfo, flags);
if (TREE_SIDE_EFFECTS (rval))
- finish_expr_stmt (rval);
+ finish_expr_stmt (convert_to_void (rval, NULL));
}
/* This function is responsible for initializing EXP with INIT
result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE);
if (!result)
- {
- if (! TREE_SIDE_EFFECTS (op1))
- {
- /* FIXME: This test should be in the implicit cast to void
- of the LHS. */
- /* the left-hand operand of a comma expression is like an expression
- statement: we should warn if it doesn't have any side-effects,
- unless it was explicitly cast to (void). */
- if (warn_unused_value
- && !(TREE_CODE (op1) == CONVERT_EXPR
- && VOID_TYPE_P (TREE_TYPE (op1))))
- warning("left-hand operand of comma expression has no effect");
- }
- result = build_compound_expr (op1, op2);
- }
+ result = build_compound_expr (op1, op2);
if (processing_template_decl && result != error_mark_node)
return build_min (COMPOUND_EXPR, TREE_TYPE (result),
tree
build_compound_expr (tree lhs, tree rhs)
{
- lhs = decl_constant_value (lhs);
- lhs = convert_to_void (lhs, "left-hand operand of comma");
+ if (!processing_template_decl)
+ {
+ lhs = decl_constant_value (lhs);
+ lhs = convert_to_void (lhs, "left-hand operand of comma");
+ }
+
if (lhs == error_mark_node || rhs == error_mark_node)
return error_mark_node;
-
+
if (TREE_CODE (rhs) == TARGET_EXPR)
{
/* If the rhs is a TARGET_EXPR, then build the compound
expression inside the target_expr's initializer. This
helps the compiler to eliminate unncessary temporaries. */
tree init = TREE_OPERAND (rhs, 1);
-
+
init = build (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
TREE_OPERAND (rhs, 1) = init;
except for last statement in ({...}) where they may be useful. */
if (! want_value
&& (expr_stmts_for_value == 0 || ! maybe_last)
- && exp != error_mark_node)
+ && exp != error_mark_node
+ && warn_unused_value)
{
- if (! TREE_SIDE_EFFECTS (exp))
- {
- if (warn_unused_value
- && !(TREE_CODE (exp) == CONVERT_EXPR
- && VOID_TYPE_P (TREE_TYPE (exp))))
- warning ("%Hstatement with no effect", &emit_locus);
- }
- else if (warn_unused_value)
+ if (TREE_SIDE_EFFECTS (exp))
warn_if_unused_value (exp);
+ else if (!VOID_TYPE_P (TREE_TYPE (exp)))
+ warning ("%Hstatement with no effect", &emit_locus);
}
/* If EXP is of function type and we are expanding statements for
+2003-08-16 Nathan Sidwell <nathan@codesourcery.com>
+
+ PR C++/11512
+ * g++.dg/template/warn1.C: New.
+
2003-08-15 Nathan Sidwell <nathan@codesourcery.com>
* g++.dg/template/error2.C: New test.
--- /dev/null
+// { dg-do compile }
+// { dg-options "-Wall" }
+
+// Copyright (C) 2003 Free Software Foundation, Inc.
+// Contributed by Nathan Sidwell 14 Aug 2003 <nathan@codesourcery.com>
+
+// PR 11512. erroneous warnings
+
+template <class T> void Foo(T i)
+{
+ i++, i++;
+ i, i++; // { dg-warning "left-hand operand" "" }
+ i++, i; // { dg-warning "right-hand operand" "" }
+ for (;; --i, ++i)
+ ;
+}
+
+void Bar ()
+{
+ Foo (1); // { dg-error "instantiated" "" }
+}
+
+struct M {};
+
+struct C
+{
+ M m;
+ C () :m (M ()) {}
+};
+
+
+void Baz (int i)
+{
+ i ? i + 1 : i + 2; // { dg-error "operand of" "" }
+ i ? i++ : 0;
+}
projects / gcc.git / commitdiff