From patchwork Mon Jul 5 10:04:14 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Shujing Zhao X-Patchwork-Id: 57885 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id DC453B6EFF for ; Mon, 5 Jul 2010 20:05:41 +1000 (EST) Received: (qmail 7544 invoked by alias); 5 Jul 2010 10:05:39 -0000 Received: (qmail 7527 invoked by uid 22791); 5 Jul 2010 10:05:35 -0000 X-SWARE-Spam-Status: No, hits=-0.9 required=5.0 tests=AWL, BAYES_40, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY X-Spam-Check-By: sourceware.org Received: from rcsinet10.oracle.com (HELO rcsinet10.oracle.com) (148.87.113.121) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 05 Jul 2010 10:05:29 +0000 Received: from rcsinet15.oracle.com (rcsinet15.oracle.com [148.87.113.117]) by rcsinet10.oracle.com (Switch-3.4.2/Switch-3.4.2) with ESMTP id o65A5Pfg004683 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Mon, 5 Jul 2010 10:05:27 GMT Received: from acsmt353.oracle.com (acsmt353.oracle.com [141.146.40.153]) by rcsinet15.oracle.com (Switch-3.4.2/Switch-3.4.1) with ESMTP id o64MtdiQ018889; Mon, 5 Jul 2010 10:05:24 GMT Received: from abhmt009.oracle.com by acsmt353.oracle.com with ESMTP id 381079671278324270; Mon, 05 Jul 2010 03:04:30 -0700 Received: from dhcp-beijing-cdc-10-182-121-28.cn.oracle.com (/10.182.121.28) by default (Oracle Beehive Gateway v4.0) with ESMTP ; Mon, 05 Jul 2010 03:04:28 -0700 Message-ID: <4C31AE1E.4030706@oracle.com> Date: Mon, 05 Jul 2010 18:04:14 +0800 From: Shujing Zhao User-Agent: Thunderbird 2.0.0.24 (X11/20100228) MIME-Version: 1.0 To: Jason Merrill CC: GCC Patches , Gabriel Dos Reis , Paolo Carlini , =?ISO-8859-1?Q?Manuel_L=F3pe?= =?ISO-8859-1?Q?z-Ib=E1=F1ez?= Subject: Re: [PATCH, c++] Emit the diagnostic messages of convert_to_void References: <4C19DA81.1080807@oracle.com> <4C19E122.1010900@oracle.com> <4C19EEA3.4040601@oracle.com> <4C19F181.1050205@oracle.com> <4C2E48BC.3030603@redhat.com> In-Reply-To: <4C2E48BC.3030603@redhat.com> X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org On 07/03/2010 04:14 AM, Jason Merrill wrote: >> + The IMPLICIT is ICV_NULL when the user is explicitly converting an >> expression >> + to void via a cast. > > In that case let's call it ICV_CAST. > > Let's improve the error messages here, too. > >> + warning (0, "object of incomplete type %qT will not " >> + "be accessed in void context", type); > > "conversion to void will not access object of incomplete type %qT" > > (Incidentally, I'm surprised these warnings are unconditional rather > than being controlled by a -Wvolatile option or something, but I guess > we can leave that alone for now since volatile is relatively rare.) > >> + warning (0, "object of incomplete type %qT will not " >> + "be accessed in second operand of conditional", > > "indirection will not access object of incomplete type %qT in second > operand of conditional expression" (or third) > > "indirection will not access object of incomplete type %qT in right > operand of comma operator" (or left) > > "indirection will not access object of incomplete type %qT in statement" > > "indirection will not access object of incomplete type %qT in for > increment expression" > >> /* Don't load the value if this is an implicit dereference, or if >> the type needs to be handled by ctors/dtors. */ >> else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type))) > > Let's split up these cases. > > is_reference: > > "conversion to void will not access object of type %qT" > > "implicit dereference will not access object of type %qT in..." > > TREE_ADDRESSABLE: > > "conversion to void will not access object of non-trivially-copyable > type %qT" > > "indirection will not access object of non-trivially-copyable type %qT > in..." > >> + warning (0, "object %qE of incomplete type %qT will not " >> + "be accessed in void context", expr, type); > > "conversion to void will not access object %qE of incomplete type %qT" > > "variable %qE of incomplete type %qT will not be accessed in..." > >> + error ("void cast " >> + "cannot resolve address of overloaded function"); > > conversion to void, etc. > >> + "second operand of conditional " >> + "is a reference, not call, to function %qE", expr); > > conditional expression, etc. > >> + warning (OPT_Wunused_value, >> + "second operand of conditional has no effect"); > > Likewise. Thanks. Adjust the diagnostic messages and the comments at enum definition. Some test cases are updated too. Tested on i686-pc-linux-gnu. Is it ok? Regards Pearly gcc/cp/ 2010-07-05 Shujing Zhao * cp-tree.h (impl_conv_void): New type. (convert_to_void): Adjust prototype. * cvt.c (convert_to_void): Use impl_conv_void and emit and adjust the diagnostic for easy translation. Change caller. * typeck.c: Update call to convert_to_void. * semantics.c: Likewise. * init.c: Likewise. gcc/testsuite/ 2010-07-05 Shujing Zhao * g++.dg/warn/noeffect2.C: Adjust expected warning. * g++.dg/warn/volatile1.C: Likewise. * g++.dg/template/warn1.C: Likewise. Index: cp/typeck.c =================================================================== --- cp/typeck.c (revision 161363) +++ cp/typeck.c (working copy) @@ -5591,7 +5591,7 @@ build_compound_expr (location_t loc ATTR tree cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain) { - lhs = convert_to_void (lhs, "left-hand operand of comma", complain); + lhs = convert_to_void (lhs, ICV_LEFT_OF_COMMA, complain); if (lhs == error_mark_node || rhs == error_mark_node) return error_mark_node; @@ -5858,7 +5858,7 @@ build_static_cast_1 (tree type, tree exp Any expression can be explicitly converted to type cv void. */ if (TREE_CODE (type) == VOID_TYPE) - return convert_to_void (expr, /*implicit=*/NULL, complain); + return convert_to_void (expr, ICV_CAST, complain); /* [expr.static.cast] Index: cp/init.c =================================================================== --- cp/init.c (revision 161363) +++ cp/init.c (working copy) @@ -1375,7 +1375,7 @@ expand_default_init (tree binfo, tree tr release_tree_vector (parms); if (TREE_SIDE_EFFECTS (rval)) - finish_expr_stmt (convert_to_void (rval, NULL, complain)); + finish_expr_stmt (convert_to_void (rval, ICV_CAST, complain)); } /* This function is responsible for initializing EXP with INIT @@ -2718,7 +2718,7 @@ build_vec_delete_1 (tree base, tree maxi /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */ body = build2 (COMPOUND_EXPR, void_type_node, base, body); - return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error); + return convert_to_void (body, ICV_CAST, tf_warning_or_error); } /* Create an unnamed variable of the indicated TYPE. */ Index: cp/semantics.c =================================================================== --- cp/semantics.c (revision 161363) +++ cp/semantics.c (working copy) @@ -608,10 +608,10 @@ finish_expr_stmt (tree expr) { if (warn_sequence_point) verify_sequence_points (expr); - expr = convert_to_void (expr, "statement", tf_warning_or_error); + expr = convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error); } else if (!type_dependent_expression_p (expr)) - convert_to_void (build_non_dependent_expr (expr), "statement", + convert_to_void (build_non_dependent_expr (expr), ICV_STATEMENT, tf_warning_or_error); if (check_for_bare_parameter_packs (expr)) @@ -869,11 +869,11 @@ finish_for_expr (tree expr, tree for_stm { if (warn_sequence_point) verify_sequence_points (expr); - expr = convert_to_void (expr, "3rd expression in for", + expr = convert_to_void (expr, ICV_THIRD_IN_FOR, tf_warning_or_error); } else if (!type_dependent_expression_p (expr)) - convert_to_void (build_non_dependent_expr (expr), "3rd expression in for", + convert_to_void (build_non_dependent_expr (expr), ICV_THIRD_IN_FOR, tf_warning_or_error); expr = maybe_cleanup_point_expr_void (expr); if (check_for_bare_parameter_packs (expr)) Index: cp/cvt.c =================================================================== --- cp/cvt.c (revision 161363) +++ cp/cvt.c (working copy) @@ -651,7 +651,7 @@ ocp_convert (tree type, tree expr, int c if (code == VOID_TYPE && (convtype & CONV_STATIC)) { - e = convert_to_void (e, /*implicit=*/NULL, tf_warning_or_error); + e = convert_to_void (e, ICV_CAST, tf_warning_or_error); return e; } @@ -814,19 +814,18 @@ ocp_convert (tree type, tree expr, int c make it impossible to ignore the reference return value from functions. We issue warnings in the confusing cases. - IMPLICIT is non-NULL iff an expression is being implicitly converted; it - is NULL when the user is explicitly converting an expression to void via - a cast. When non-NULL, IMPLICIT is a string indicating the context of - the implicit conversion. */ + The IMPLICIT is ICV_CAST when the user is explicitly converting an expression + to void via a cast. If an expression is being implicitly converted, IMPLICIT + indicates the context of the implicit conversion. */ tree -convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain) +convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) { if (expr == error_mark_node || TREE_TYPE (expr) == error_mark_node) return error_mark_node; - if (implicit == NULL) + if (implicit == ICV_CAST) mark_exp_read (expr); else { @@ -865,12 +864,17 @@ convert_to_void (tree expr, const char * tree op1 = TREE_OPERAND (expr,1); tree op2 = TREE_OPERAND (expr,2); bool side_effects = TREE_SIDE_EFFECTS (op1) || TREE_SIDE_EFFECTS (op2); - tree new_op1 = convert_to_void - (op1, (implicit && !side_effects - ? "second operand of conditional" : NULL), complain); - tree new_op2 = convert_to_void - (op2, (implicit && !side_effects - ? "third operand of conditional" : NULL), complain); + tree new_op1, new_op2; + if (implicit != ICV_CAST && !side_effects) + { + new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain); + new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain); + } + else + { + new_op1 = convert_to_void (op1, ICV_CAST, complain); + new_op2 = convert_to_void (op2, ICV_CAST, complain); + } expr = build3 (COND_EXPR, TREE_TYPE (new_op1), TREE_OPERAND (expr, 0), new_op1, new_op2); @@ -881,9 +885,11 @@ convert_to_void (tree expr, const char * { /* 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_NO_WARNING (expr) - ? "right-hand operand of comma" : NULL), complain); + tree new_op1; + if (implicit != ICV_CAST && !TREE_NO_WARNING (expr)) + new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain); + else + new_op1 = convert_to_void (op1, ICV_CAST, complain); if (new_op1 != op1) { @@ -915,18 +921,133 @@ convert_to_void (tree expr, const char * if (is_volatile && !is_complete) { if (complain & tf_warning) - warning (0, "object of incomplete type %qT will not be accessed in %s", - type, implicit ? implicit : "void context"); + switch (implicit) + { + case ICV_CAST: + warning (0, "conversion to void will not access " + "object of incomplete type %qT", type); + break; + case ICV_SECOND_OF_COND: + warning (0, "indirection will not access object of " + "incomplete type %qT in second operand " + "of conditional expression", type); + break; + case ICV_THIRD_OF_COND: + warning (0, "indirection will not access object of " + "incomplete type %qT in third operand " + "of conditional expression", type); + break; + case ICV_RIGHT_OF_COMMA: + warning (0, "indirection will not access object of " + "incomplete type %qT in right operand of " + "comma operator", type); + break; + case ICV_LEFT_OF_COMMA: + warning (0, "indirection will not access object of " + "incomplete type %qT in left operand of " + "comma operator", type); + break; + case ICV_STATEMENT: + warning (0, "indirection will not access object of " + "incomplete type %qT in statement", type); + break; + case ICV_THIRD_IN_FOR: + warning (0, "indirection will not access object of " + "incomplete type %qT in for increment " + "expression", type); + break; + default: + gcc_unreachable (); + } } /* Don't load the value if this is an implicit dereference, or if the type needs to be handled by ctors/dtors. */ - else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type))) + else if (is_volatile && is_reference) { if (complain & tf_warning) - warning (0, "object of type %qT will not be accessed in %s", - TREE_TYPE (TREE_OPERAND (expr, 0)), - implicit ? implicit : "void context"); + switch (implicit) + { + case ICV_CAST: + warning (0, "conversion to void will not access " + "object of type %qT", type); + break; + case ICV_SECOND_OF_COND: + warning (0, "implicit dereference will not access object " + "of type %qT in second operand of " + "conditional expression", type); + break; + case ICV_THIRD_OF_COND: + warning (0, "implicit dereference will not access object " + "of type %qT in third operand of " + "conditional expression", type); + break; + case ICV_RIGHT_OF_COMMA: + warning (0, "implicit dereference will not access object " + "of type %qT in right operand of " + "comma operator", type); + break; + case ICV_LEFT_OF_COMMA: + warning (0, "implicit dereference will not access object " + "of type %qT in left operand of comma operator", + type); + break; + case ICV_STATEMENT: + warning (0, "implicit dereference will not access object " + "of type %qT in statement", type); + break; + case ICV_THIRD_IN_FOR: + warning (0, "implicit dereference will not access object " + "of type %qT in for increment expression", + type); + break; + default: + gcc_unreachable (); + } } + else if (is_volatile && TREE_ADDRESSABLE (type)) + { + if (complain & tf_warning) + switch (implicit) + { + case ICV_CAST: + warning (0, "conversion to void will not access " + "object of non-trivially-copyable type %qT", + type); + break; + case ICV_SECOND_OF_COND: + warning (0, "indirection will not access object of " + "non-trivially-copyable type %qT in second " + "operand of conditional expression", type); + break; + case ICV_THIRD_OF_COND: + warning (0, "indirection will not access object of " + "non-trivially-copyable type %qT in third " + "operand of conditional expression", type); + break; + case ICV_RIGHT_OF_COMMA: + warning (0, "indirection will not access object of " + "non-trivially-copyable type %qT in right " + "operand of comma operator", type); + break; + case ICV_LEFT_OF_COMMA: + warning (0, "indirection will not access object of " + "non-trivially-copyable type %qT in left " + "operand of comma operator", type); + break; + case ICV_STATEMENT: + warning (0, "indirection will not access object of " + "non-trivially-copyable type %qT in statement", + type); + break; + case ICV_THIRD_IN_FOR: + warning (0, "indirection will not access object of " + "non-trivially-copyable type %qT in for " + "increment expression", type); + break; + default: + gcc_unreachable (); + } + } if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type)) { /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF @@ -936,7 +1057,7 @@ convert_to_void (tree expr, const char * - automatic dereferencing of references, since the user cannot control it. (See also warn_if_unused_value() in stmt.c.) */ if (warn_unused_value - && implicit + && implicit != ICV_CAST && (complain & tf_warning) && !TREE_NO_WARNING (expr) && !is_reference) @@ -954,8 +1075,45 @@ convert_to_void (tree expr, const char * int is_complete = COMPLETE_TYPE_P (complete_type (type)); if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning)) - warning (0, "object %qE of incomplete type %qT will not be accessed in %s", - expr, type, implicit ? implicit : "void context"); + switch (implicit) + { + case ICV_CAST: + warning (0, "conversion to void will not access " + "object %qE of incomplete type %qT", expr, type); + break; + case ICV_SECOND_OF_COND: + warning (0, "variable %qE of incomplete type %qT will not " + "be accessed in second operand of " + "conditional expression", expr, type); + break; + case ICV_THIRD_OF_COND: + warning (0, "variable %qE of incomplete type %qT will not " + "be accessed in third operand of " + "conditional expression", expr, type); + break; + case ICV_RIGHT_OF_COMMA: + warning (0, "variable %qE of incomplete type %qT will not " + "be accessed in right operand of comma operator", + expr, type); + break; + case ICV_LEFT_OF_COMMA: + warning (0, "variable %qE of incomplete type %qT will not " + "be accessed in left operand of comma operator", + expr, type); + break; + case ICV_STATEMENT: + warning (0, "variable %qE of incomplete type %qT will not " + "be accessed in statement", expr, type); + break; + case ICV_THIRD_IN_FOR: + warning (0, "variable %qE of incomplete type %qT will not " + "be accessed in for increment expression", + expr, type); + break; + default: + gcc_unreachable (); + } + break; } @@ -994,18 +1152,81 @@ convert_to_void (tree expr, const char * /* [over.over] enumerates the places where we can take the address of an overloaded function, and this is not one of them. */ if (complain & tf_error) - error ("%s cannot resolve address of overloaded function", - implicit ? implicit : "void cast"); + switch (implicit) + { + case ICV_CAST: + error ("conversion to void " + "cannot resolve address of overloaded function"); + break; + case ICV_SECOND_OF_COND: + error ("second operand of conditional expression " + "cannot resolve address of overloaded function"); + break; + case ICV_THIRD_OF_COND: + error ("third operand of conditional expression " + "cannot resolve address of overloaded function"); + break; + case ICV_RIGHT_OF_COMMA: + error ("right operand of comma operator " + "cannot resolve address of overloaded function"); + break; + case ICV_LEFT_OF_COMMA: + error ("left operand of comma operator " + "cannot resolve address of overloaded function"); + break; + case ICV_STATEMENT: + error ("statement " + "cannot resolve address of overloaded function"); + break; + case ICV_THIRD_IN_FOR: + error ("for increment expression " + "cannot resolve address of overloaded function"); + break; + } else return error_mark_node; expr = void_zero_node; } - else if (implicit && probe == expr && is_overloaded_fn (probe)) + else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe)) { /* Only warn when there is no &. */ if (complain & tf_warning) - warning (OPT_Waddress, "%s is a reference, not call, to function %qE", - implicit, expr); + switch (implicit) + { + case ICV_SECOND_OF_COND: + warning (OPT_Waddress, + "second operand of conditional expression " + "is a reference, not call, to function %qE", expr); + break; + case ICV_THIRD_OF_COND: + warning (OPT_Waddress, + "third operand of conditional expression " + "is a reference, not call, to function %qE", expr); + break; + case ICV_RIGHT_OF_COMMA: + warning (OPT_Waddress, + "right operand of comma operator " + "is a reference, not call, to function %qE", expr); + break; + case ICV_LEFT_OF_COMMA: + warning (OPT_Waddress, + "left operand of comma operator " + "is a reference, not call, to function %qE", expr); + break; + case ICV_STATEMENT: + warning (OPT_Waddress, + "statement is a reference, not call, to function %qE", + expr); + break; + case ICV_THIRD_IN_FOR: + warning (OPT_Waddress, + "for increment expression " + "is a reference, not call, to function %qE", expr); + break; + default: + gcc_unreachable (); + } + if (TREE_CODE (expr) == COMPONENT_REF) expr = TREE_OPERAND (expr, 0); } @@ -1013,7 +1234,7 @@ convert_to_void (tree expr, const char * if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr))) { - if (implicit + if (implicit != ICV_CAST && warn_unused_value && !TREE_NO_WARNING (expr) && !processing_template_decl) @@ -1022,7 +1243,35 @@ convert_to_void (tree expr, const char * been explicitly cast to void, so we must do so here. */ if (!TREE_SIDE_EFFECTS (expr)) { if (complain & tf_warning) - warning (OPT_Wunused_value, "%s has no effect", implicit); + switch (implicit) + { + case ICV_SECOND_OF_COND: + warning (OPT_Wunused_value, + "second operand of conditional expression has no effect"); + break; + case ICV_THIRD_OF_COND: + warning (OPT_Wunused_value, + "third operand of conditional expression has no effect"); + break; + case ICV_RIGHT_OF_COMMA: + warning (OPT_Wunused_value, + "right operand of comma operator has no effect"); + break; + case ICV_LEFT_OF_COMMA: + warning (OPT_Wunused_value, + "left operand of comma operator has no effect"); + break; + case ICV_STATEMENT: + warning (OPT_Wunused_value, + "statement has no effect"); + break; + case ICV_THIRD_IN_FOR: + warning (OPT_Wunused_value, + "for increment expression has no effect"); + break; + default: + gcc_unreachable (); + } } else { Index: cp/cp-tree.h =================================================================== --- cp/cp-tree.h (revision 161363) +++ cp/cp-tree.h (working copy) @@ -435,6 +435,17 @@ typedef enum impl_conv_rhs { ICR_ASSIGN /* assignment */ } impl_conv_rhs; +/* Possible cases of implicit or explicit bad conversions to void. */ +typedef enum impl_conv_void { + ICV_CAST, /* (explicit) conversion to void */ + ICV_SECOND_OF_COND, /* second operand of conditional expression */ + ICV_THIRD_OF_COND, /* third operand of conditional expression */ + ICV_RIGHT_OF_COMMA, /* right operand of comma operator */ + ICV_LEFT_OF_COMMA, /* left operand of comma operator */ + ICV_STATEMENT, /* statement */ + ICV_THIRD_IN_FOR /* for increment expression */ +} impl_conv_void; + /* Macros for access to language-specific slots in an identifier. */ #define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \ @@ -4669,8 +4680,8 @@ extern tree ocp_convert (tree, tree, extern tree cp_convert (tree, tree); extern tree cp_convert_and_check (tree, tree); extern tree cp_fold_convert (tree, tree); -extern tree convert_to_void (tree, const char */*implicit context*/, - tsubst_flags_t); +extern tree convert_to_void (tree, impl_conv_void, + tsubst_flags_t); extern tree convert_force (tree, tree, int); extern tree build_expr_type_conversion (int, tree, bool); extern tree type_promotes_to (tree); Index: testsuite/g++.dg/warn/noeffect2.C =================================================================== --- testsuite/g++.dg/warn/noeffect2.C (revision 161363) +++ testsuite/g++.dg/warn/noeffect2.C (working copy) @@ -10,11 +10,11 @@ extern "C" void FormatDisk(); template struct C { - C(){ FormatDisk(), 0; } // { dg-warning "right-hand operand of comma" "" } + C(){ FormatDisk(), 0; } // { dg-warning "right operand of comma" "" } }; template struct C; // { dg-message "instantiated" } template - void f() { FormatDisk(), 0; } // { dg-warning "right-hand operand of comma" "" } + void f() { FormatDisk(), 0; } // { dg-warning "right operand of comma" "" } template void f (); // { dg-message "instantiated" } -void g() { FormatDisk(), 0; } // { dg-warning "right-hand operand of comma" "" } +void g() { FormatDisk(), 0; } // { dg-warning "right operand of comma" "" } Index: testsuite/g++.dg/warn/volatile1.C =================================================================== --- testsuite/g++.dg/warn/volatile1.C (revision 161363) +++ testsuite/g++.dg/warn/volatile1.C (working copy) @@ -8,5 +8,5 @@ struct A }; void A::baz() volatile { - *this; // { dg-warning "will not be accessed" } + *this; // { dg-warning "indirection will not access" } } Index: testsuite/g++.dg/template/warn1.C =================================================================== --- testsuite/g++.dg/template/warn1.C (revision 161363) +++ testsuite/g++.dg/template/warn1.C (working copy) @@ -9,8 +9,8 @@ template void Foo(T i) { i++, i++; - i, i++; // { dg-warning "left-hand operand" "" } - i++, i; // { dg-warning "right-hand operand" "" } + i, i++; // { dg-warning "left operand" "" } + i++, i; // { dg-warning "right operand" "" } for (;; --i, ++i) ; }