OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

re PR c++/62199 (ICE with -Wlogical-not-parentheses)

Browse Source 
PR c++/62199
	* doc/invoke.texi: Update -Wlogical-not-parentheses description.
c-family/
	* c-common.c (warn_logical_not_parentheses): Don't check LHS.  Don't
	check for vector types.  Drop LHS argument.
	* c-common.h (warn_logical_not_parentheses): Adjust.
c/
	* c-typeck.c (parser_build_binary_op): Adjust call to
	warn_logical_not_parentheses.
cp/
	* parser.c (cp_parser_binary_expression): Check each LHS if it's
	preceded with logical not.  Adjust call to
	warn_logical_not_parentheses.
testsuite/
	* c-c++-common/pr62199.c: New test.
	* c-c++-common/pr62199-2.c: New test.
	* g++.dg/warn/Wparentheses-25.C: Drop XFAILs.

From-SVN: r214360
This commit is contained in:
Marek Polacek 2014-08-22 19:44:27 +00:00 committed by Marek Polacek
parent e0bf0dc2c0
commit 59ea036456
13 changed files with 144 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gcc/ChangeLog
View File

@ -1,3 +1,8 @@
2014-08-22 Marek Polacek <polacek@redhat.com>
PR c++/62199
* doc/invoke.texi: Update -Wlogical-not-parentheses description.
2014-08-22 Marek Polacek <polacek@redhat.com>
PR c/61271

7
gcc/c-family/ChangeLog
View File

@ -1,3 +1,10 @@
2014-08-22 Marek Polacek <polacek@redhat.com>
PR c++/62199
* c-common.c (warn_logical_not_parentheses): Don't check LHS. Don't
check for vector types. Drop LHS argument.
* c-common.h (warn_logical_not_parentheses): Adjust.
2014-08-22 Manuel López-Ibáñez <manu@gcc.gnu.org>
* c.opt (Wcomment): Use CPP, Var and LangEnabledBy.

16
gcc/c-family/c-common.c
View File

@ -1727,21 +1727,15 @@ warn_logical_operator (location_t location, enum tree_code code, tree type,
/* Warn about logical not used on the left hand side operand of a comparison.
This function assumes that the LHS is inside of TRUTH_NOT_EXPR.
Do not warn if the LHS or RHS is of a boolean or a vector type. */
Do not warn if RHS is of a boolean type. */
void
warn_logical_not_parentheses (location_t location, enum tree_code code,
tree lhs, tree rhs)
tree rhs)
{
if (TREE_CODE_CLASS (code) != tcc_comparison)
return;
if (TREE_TYPE (lhs) == NULL_TREE
|| TREE_TYPE (rhs) == NULL_TREE)
;
else if (TREE_CODE (TREE_TYPE (lhs)) == BOOLEAN_TYPE
|| TREE_CODE (TREE_TYPE (rhs)) == BOOLEAN_TYPE
|| VECTOR_TYPE_P (TREE_TYPE (lhs))
|| VECTOR_TYPE_P (TREE_TYPE (rhs)))
if (TREE_CODE_CLASS (code) != tcc_comparison
|| TREE_TYPE (rhs) == NULL_TREE
|| TREE_CODE (TREE_TYPE (rhs)) == BOOLEAN_TYPE)
return;
warning_at (location, OPT_Wlogical_not_parentheses,

3
gcc/c-family/c-common.h
View File

@ -780,8 +780,7 @@ extern void overflow_warning (location_t, tree);
extern bool warn_if_unused_value (const_tree, location_t);
extern void warn_logical_operator (location_t, enum tree_code, tree,
enum tree_code, tree, enum tree_code, tree);
extern void warn_logical_not_parentheses (location_t, enum tree_code, tree,
tree);
extern void warn_logical_not_parentheses (location_t, enum tree_code, tree);
extern void check_main_parameter_types (tree decl);
extern bool c_determine_visibility (tree);
extern bool vector_types_compatible_elements_p (tree, tree);

6
gcc/c/ChangeLog
View File

@ -1,3 +1,9 @@
2014-08-22 Marek Polacek <polacek@redhat.com>
PR c++/62199
* c-typeck.c (parser_build_binary_op): Adjust call to
warn_logical_not_parentheses.
2014-08-22 Igor Zamyatin <igor.zamyatin@intel.com>
PR other/62008

2
gcc/c/c-typeck.c
View File

@ -3414,7 +3414,7 @@ parser_build_binary_op (location_t location, enum tree_code code,
if (warn_logical_not_paren
&& code1 == TRUTH_NOT_EXPR
&& code2 != TRUTH_NOT_EXPR)
warn_logical_not_parentheses (location, code, arg1.value, arg2.value);
warn_logical_not_parentheses (location, code, arg2.value);
/* Warn about comparisons against string literals, with the exception
of testing for equality or inequality of a string literal with NULL. */

7
gcc/cp/ChangeLog
View File

@ -1,3 +1,10 @@
2014-08-22 Marek Polacek <polacek@redhat.com>
PR c++/62199
* parser.c (cp_parser_binary_expression): Check each LHS if it's
preceded with logical not. Adjust call to
warn_logical_not_parentheses.
2014-08-22 Manuel López-Ibáñez <manu@gcc.gnu.org>
PR c++/57709

13
gcc/cp/parser.c
View File

@ -8020,13 +8020,12 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
enum tree_code rhs_type;
enum cp_parser_prec new_prec, lookahead_prec;
tree overload;
bool parenthesized_not_lhs_warn
= cp_lexer_next_token_is (parser->lexer, CPP_NOT);
/* Parse the first expression. */
current.lhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
? TRUTH_NOT_EXPR : ERROR_MARK);
current.lhs = cp_parser_cast_expression (parser, /*address_p=*/false,
cast_p, decltype_p, pidk);
current.lhs_type = ERROR_MARK;
current.prec = prec;
if (cp_parser_error_occurred (parser))
@ -8081,8 +8080,9 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
/* Extract another operand. It may be the RHS of this expression
or the LHS of a new, higher priority expression. */
rhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
? TRUTH_NOT_EXPR : ERROR_MARK);
rhs = cp_parser_simple_cast_expression (parser);
rhs_type = ERROR_MARK;
/* Get another operator token. Look up its precedence to avoid
building a useless (immediately popped) stack entry for common
@ -8125,9 +8125,8 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
c_inhibit_evaluation_warnings -= current.lhs == truthvalue_true_node;
if (warn_logical_not_paren
&& parenthesized_not_lhs_warn)
warn_logical_not_parentheses (current.loc, current.tree_type,
TREE_OPERAND (current.lhs, 0), rhs);
&& current.lhs_type == TRUTH_NOT_EXPR)
warn_logical_not_parentheses (current.loc, current.tree_type, rhs);
overload = NULL;
/* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==

4
gcc/doc/invoke.texi
View File

@ -4776,8 +4776,8 @@ bit-wise operator is likely to be expected.
@opindex Wlogical-not-parentheses
@opindex Wno-logical-not-parentheses
Warn about logical not used on the left hand side operand of a comparison.
This option does not warn if the LHS or RHS operand is of a boolean or
a vector type. Its purpose is to detect suspicious code like the following:
This option does not warn if the RHS operand is of a boolean type. Its
purpose is to detect suspicious code like the following:
@smallexample
int a;
@dots{}

7
gcc/testsuite/ChangeLog
View File

@ -1,3 +1,10 @@
2014-08-22 Marek Polacek <polacek@redhat.com>
PR c++/62199
* c-c++-common/pr62199.c: New test.
* c-c++-common/pr62199-2.c: New test.
* g++.dg/warn/Wparentheses-25.C: Drop XFAILs.
2014-08-22 Manuel López-Ibáñez <manu@gcc.gnu.org>
PR c++/57709

20
gcc/testsuite/c-c++-common/pr62199-2.c Normal file
View File

@ -0,0 +1,20 @@
/* PR c++/62199 */
/* { dg-do compile } */
/* { dg-options "-Wlogical-not-parentheses" } */
#ifndef __cplusplus
# define bool _Bool
#endif
bool r;
void
foo (bool b)
{
r = !b == 1; /* { dg-warning "logical not is only applied to the left hand side of comparison" } */
r = !b != 1; /* { dg-warning "logical not is only applied to the left hand side of comparison" } */
r = !b > 1; /* { dg-warning "logical not is only applied to the left hand side of comparison" } */
r = !b >= 1; /* { dg-warning "logical not is only applied to the left hand side of comparison" } */
r = !b < 1; /* { dg-warning "logical not is only applied to the left hand side of comparison" } */
r = !b <= 1; /* { dg-warning "logical not is only applied to the left hand side of comparison" } */
}

22
gcc/testsuite/c-c++-common/pr62199.c Normal file
View File

@ -0,0 +1,22 @@
/* PR c++/62199 */
/* { dg-do compile } */
/* { dg-options "-Wlogical-not-parentheses" } */
int r;
void
foo (int a)
{
r = a > 0 || !a >= 2; /* { dg-warning "19:logical not is only applied to the left hand side of comparison" } */
r = !a || a == 10;
r = !a && !a < 4; /* { dg-warning "16:logical not is only applied to the left hand side of comparison" } */
r = !a > 0 && a < 6; /* { dg-warning "10:logical not is only applied to the left hand side of comparison" } */
r = a + (!a < 12); /* { dg-warning "15:logical not is only applied to the left hand side of comparison" } */
r = a == 7 || !a < 12; /* { dg-warning "20:logical not is only applied to the left hand side of comparison" } */
r = (a == 7 * a > 0) || !a < 2; /* { dg-warning "30:logical not is only applied to the left hand side of comparison" } */
r = (1 > !a) || (!42 > a); /* { dg-warning "24:logical not is only applied to the left hand side of comparison" } */
r = (!5 > a); /* { dg-warning "11:logical not is only applied to the left hand side of comparison" } */
r = (!0 > a); /* { dg-warning "11:logical not is only applied to the left hand side of comparison" } */
r = (!-5 > a); /* { dg-warning "12:logical not is only applied to the left hand side of comparison" } */
r = (!(5 + 3) > a); /* { dg-warning "17:logical not is only applied to the left hand side of comparison" } */
r = (!(5 - a) > a); /* { dg-warning "17:logical not is only applied to the left hand side of comparison" } */
}

110
gcc/testsuite/g++.dg/warn/Wparentheses-25.C
View File

@ -8,7 +8,7 @@ int foo (int);
int
bar (int a, int b, int c)
{
foo (!a & b); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & b); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (b < c));
foo (!a & (b > c));
foo (!a & (b == c));
@ -20,7 +20,7 @@ bar (int a, int b, int c)
foo (!a & !b);
foo (!(a & b));
foo ((!a) & b);
foo (!a & 2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & 2); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (2 < c));
foo (!a & (2 > c));
foo (!a & (2 == c));
@ -32,7 +32,7 @@ bar (int a, int b, int c)
foo (!a & !2);
foo (!(a & 2));
foo ((!a) & 2);
foo (!1 & 2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & 2); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 & (2 < c));
foo (!1 & (2 > c));
foo (!1 & (2 == c));
@ -44,7 +44,7 @@ bar (int a, int b, int c)
foo (!1 & !2);
foo (!(1 & 2));
foo (!a | b); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | b); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (b < c));
foo (!a | (b > c));
foo (!a | (b == c));
@ -56,7 +56,7 @@ bar (int a, int b, int c)
foo (!a | !b);
foo (!(a | b));
foo ((!a) | b);
foo (!a | 2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | 2); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (2 < c));
foo (!a | (2 > c));
foo (!a | (2 == c));
@ -68,7 +68,7 @@ bar (int a, int b, int c)
foo (!a | !2);
foo (!(a | 2));
foo ((!a) | 2);
foo (!1 | 2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | 2); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 | (2 < c));
foo (!1 | (2 > c));
foo (!1 | (2 == c));
@ -159,55 +159,55 @@ bar (int a, int b, int c)
int
baz (int a, int b, int c)
{
foo (!a & (b << c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (b >> c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (b + c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (b - c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (b = c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & ~b); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (b & c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (b | c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & 2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (2 << c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (2 >> c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (2 + c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (2 - c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (c = 2)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & ~2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (2 & c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (2 | c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & (2 << c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & (2 >> c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & (2 + c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & (2 - c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & (c = 2)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & ~2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & (2 & c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 & (2 | c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (b << c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (b >> c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (b + c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (b - c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (b = c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | ~b); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (b & c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (b | c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (2 << c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (2 >> c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (2 + c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (2 - c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (c = 2)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | ~2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (2 & c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a | (2 | c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | (2 << c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | (2 >> c));/* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | (2 + c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | (2 - c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | (c = 2)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | ~2); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | (2 & c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!1 | (2 | c)); /* { dg-warning "parentheses" "correct warning" { xfail *-*-* } } */
foo (!a & (b << c));/* { dg-warning "parentheses" "correct warning" } */
foo (!a & (b >> c));/* { dg-warning "parentheses" "correct warning" } */
foo (!a & (b + c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (b - c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (b = c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & ~b); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (b & c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (b | c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & 2); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (2 << c));/* { dg-warning "parentheses" "correct warning" } */
foo (!a & (2 >> c));/* { dg-warning "parentheses" "correct warning" } */
foo (!a & (2 + c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (2 - c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (c = 2)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & ~2); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (2 & c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a & (2 | c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 & (2 << c));/* { dg-warning "parentheses" "correct warning" } */
foo (!1 & (2 >> c));/* { dg-warning "parentheses" "correct warning" } */
foo (!1 & (2 + c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 & (2 - c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 & (c = 2)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 & ~2); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 & (2 & c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 & (2 | c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (b << c));/* { dg-warning "parentheses" "correct warning" } */
foo (!a | (b >> c));/* { dg-warning "parentheses" "correct warning" } */
foo (!a | (b + c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (b - c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (b = c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | ~b); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (b & c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (b | c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (2 << c));/* { dg-warning "parentheses" "correct warning" } */
foo (!a | (2 >> c));/* { dg-warning "parentheses" "correct warning" } */
foo (!a | (2 + c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (2 - c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (c = 2)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | ~2); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (2 & c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!a | (2 | c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 | (2 << c));/* { dg-warning "parentheses" "correct warning" } */
foo (!1 | (2 >> c));/* { dg-warning "parentheses" "correct warning" } */
foo (!1 | (2 + c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 | (2 - c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 | (c = 2)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 | ~2); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 | (2 & c)); /* { dg-warning "parentheses" "correct warning" } */
foo (!1 | (2 | c)); /* { dg-warning "parentheses" "correct warning" } */
foo ((b << c) & !a);
foo ((b >> c) & !a);
foo ((b + c) & !a);