1 /* Diagnostic routines shared by all languages that are variants of C.
2 Copyright (C) 1992-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
29 #include "diagnostic.h"
31 #include "stringpool.h"
34 #include "gcc-rich-location.h"
36 #include "c-family/c-indentation.h"
38 /* Print a warning if a constant expression had overflow in folding.
39 Invoke this function on every expression that the language
40 requires to be a constant expression.
41 Note the ANSI C standard says it is erroneous for a
42 constant expression to overflow. */
45 constant_expression_warning (tree value
)
47 if (warn_overflow
&& pedantic
48 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
49 || TREE_CODE (value
) == FIXED_CST
50 || TREE_CODE (value
) == VECTOR_CST
51 || TREE_CODE (value
) == COMPLEX_CST
)
52 && TREE_OVERFLOW (value
))
53 pedwarn (input_location
, OPT_Woverflow
, "overflow in constant expression");
56 /* The same as above but print an unconditional error. */
59 constant_expression_error (tree value
)
61 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
62 || TREE_CODE (value
) == FIXED_CST
63 || TREE_CODE (value
) == VECTOR_CST
64 || TREE_CODE (value
) == COMPLEX_CST
)
65 && TREE_OVERFLOW (value
))
66 error ("overflow in constant expression");
69 /* Print a warning if an expression result VALUE had an overflow
70 in folding and its operands hadn't. EXPR, which may be null, is
71 the operand of the expression.
73 Invoke this function on every expression that
74 (1) appears in the source code, and
75 (2) is a constant expression that overflowed, and
76 (3) is not already checked by convert_and_check;
77 however, do not invoke this function on operands of explicit casts
78 or when the expression is the result of an operator and any operand
79 already overflowed. */
82 overflow_warning (location_t loc
, tree value
, tree expr
)
84 if (c_inhibit_evaluation_warnings
!= 0)
87 const char *warnfmt
= NULL
;
89 switch (TREE_CODE (value
))
93 ? G_("integer overflow in expression %qE of type %qT "
95 : G_("integer overflow in expression of type %qT "
101 ? G_ ("floating point overflow in expression %qE "
102 "of type %qT results in %qE")
103 : G_ ("floating point overflow in expression of type %qT "
109 ? G_("fixed-point overflow in expression %qE of type %qT "
111 : G_("fixed-point overflow in expression of type %qT "
117 ? G_("vector overflow in expression %qE of type %qT "
119 : G_("vector overflow in expression of type %qT "
124 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
126 ? G_("complex integer overflow in expression %qE "
127 "of type %qT results in %qE")
128 : G_("complex integer overflow in expression of type %qT "
130 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
132 ? G_("complex floating point overflow in expression %qE "
133 "of type %qT results in %qE")
134 : G_("complex floating point overflow in expression "
135 "of type %qT results in %qE"));
145 warning_at (loc
, OPT_Woverflow
, warnfmt
, expr
, TREE_TYPE (expr
), value
);
147 warning_at (loc
, OPT_Woverflow
, warnfmt
, TREE_TYPE (value
), value
);
149 TREE_NO_WARNING (value
) = 1;
152 /* Helper function for walk_tree. Unwrap C_MAYBE_CONST_EXPRs in an expression
156 unwrap_c_maybe_const (tree
*tp
, int *walk_subtrees
, void *)
158 if (TREE_CODE (*tp
) == C_MAYBE_CONST_EXPR
)
160 *tp
= C_MAYBE_CONST_EXPR_EXPR (*tp
);
161 /* C_MAYBE_CONST_EXPRs don't nest. */
162 *walk_subtrees
= false;
167 /* Warn about uses of logical || / && operator in a context where it
168 is likely that the bitwise equivalent was intended by the
169 programmer. We have seen an expression in which CODE is a binary
170 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
171 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
174 warn_logical_operator (location_t location
, enum tree_code code
, tree type
,
175 enum tree_code code_left
, tree op_left
,
176 enum tree_code
ARG_UNUSED (code_right
), tree op_right
)
178 int or_op
= (code
== TRUTH_ORIF_EXPR
|| code
== TRUTH_OR_EXPR
);
179 int in0_p
, in1_p
, in_p
;
180 tree low0
, low1
, low
, high0
, high1
, high
, lhs
, rhs
, tem
;
181 bool strict_overflow_p
= false;
183 if (code
!= TRUTH_ANDIF_EXPR
184 && code
!= TRUTH_AND_EXPR
185 && code
!= TRUTH_ORIF_EXPR
186 && code
!= TRUTH_OR_EXPR
)
189 /* We don't want to warn if either operand comes from a macro
190 expansion. ??? This doesn't work with e.g. NEGATE_EXPR yet;
192 if (from_macro_expansion_at (EXPR_LOCATION (op_left
))
193 || from_macro_expansion_at (EXPR_LOCATION (op_right
)))
196 /* Warn if &&/|| are being used in a context where it is
197 likely that the bitwise equivalent was intended by the
198 programmer. That is, an expression such as op && MASK
199 where op should not be any boolean expression, nor a
200 constant, and mask seems to be a non-boolean integer constant. */
201 if (TREE_CODE (op_right
) == CONST_DECL
)
202 /* An enumerator counts as a constant. */
203 op_right
= DECL_INITIAL (op_right
);
204 if (!truth_value_p (code_left
)
205 && INTEGRAL_TYPE_P (TREE_TYPE (op_left
))
206 && !CONSTANT_CLASS_P (op_left
)
207 && !TREE_NO_WARNING (op_left
)
208 && TREE_CODE (op_right
) == INTEGER_CST
209 && !integer_zerop (op_right
)
210 && !integer_onep (op_right
))
213 warning_at (location
, OPT_Wlogical_op
, "logical %<or%>"
214 " applied to non-boolean constant");
216 warning_at (location
, OPT_Wlogical_op
, "logical %<and%>"
217 " applied to non-boolean constant");
218 TREE_NO_WARNING (op_left
) = true;
222 /* We do not warn for constants because they are typical of macro
223 expansions that test for features. */
224 if (CONSTANT_CLASS_P (fold_for_warn (op_left
))
225 || CONSTANT_CLASS_P (fold_for_warn (op_right
)))
228 /* This warning only makes sense with logical operands. */
229 if (!(truth_value_p (TREE_CODE (op_left
))
230 || INTEGRAL_TYPE_P (TREE_TYPE (op_left
)))
231 || !(truth_value_p (TREE_CODE (op_right
))
232 || INTEGRAL_TYPE_P (TREE_TYPE (op_right
))))
235 /* The range computations only work with scalars. */
236 if (VECTOR_TYPE_P (TREE_TYPE (op_left
))
237 || VECTOR_TYPE_P (TREE_TYPE (op_right
)))
240 /* We first test whether either side separately is trivially true
241 (with OR) or trivially false (with AND). If so, do not warn.
242 This is a common idiom for testing ranges of data types in
244 op_left
= unshare_expr (op_left
);
245 walk_tree_without_duplicates (&op_left
, unwrap_c_maybe_const
, NULL
);
246 lhs
= make_range (op_left
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
250 /* If this is an OR operation, invert both sides; now, the result
251 should be always false to get a warning. */
255 tem
= build_range_check (UNKNOWN_LOCATION
, type
, lhs
, in0_p
, low0
, high0
);
256 if (tem
&& integer_zerop (tem
))
259 op_right
= unshare_expr (op_right
);
260 walk_tree_without_duplicates (&op_right
, unwrap_c_maybe_const
, NULL
);
261 rhs
= make_range (op_right
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
265 /* If this is an OR operation, invert both sides; now, the result
266 should be always false to get a warning. */
270 tem
= build_range_check (UNKNOWN_LOCATION
, type
, rhs
, in1_p
, low1
, high1
);
271 if (tem
&& integer_zerop (tem
))
274 /* If both expressions have the same operand, if we can merge the
276 if (operand_equal_p (lhs
, rhs
, 0)
277 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
280 tem
= build_range_check (UNKNOWN_LOCATION
, type
, lhs
, in_p
, low
, high
);
281 /* ... and if the range test is always false, then warn. */
282 if (tem
&& integer_zerop (tem
))
285 warning_at (location
, OPT_Wlogical_op
,
286 "logical %<or%> of collectively exhaustive tests is "
289 warning_at (location
, OPT_Wlogical_op
,
290 "logical %<and%> of mutually exclusive tests is "
293 /* Or warn if the operands have exactly the same range, e.g.
295 else if (tree_int_cst_equal (low0
, low1
)
296 && tree_int_cst_equal (high0
, high1
))
299 warning_at (location
, OPT_Wlogical_op
,
300 "logical %<or%> of equal expressions");
302 warning_at (location
, OPT_Wlogical_op
,
303 "logical %<and%> of equal expressions");
308 /* Helper function for warn_tautological_cmp. Look for ARRAY_REFs
309 with constant indices. */
312 find_array_ref_with_const_idx_r (tree
*expr_p
, int *, void *)
316 if ((TREE_CODE (expr
) == ARRAY_REF
317 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
318 && TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
)
319 return integer_type_node
;
324 /* Subroutine of warn_tautological_cmp. Warn about bitwise comparison
325 that always evaluate to true or false. LOC is the location of the
326 ==/!= comparison specified by CODE; LHS and RHS are the usual operands
327 of this comparison. */
330 warn_tautological_bitwise_comparison (location_t loc
, tree_code code
,
333 if (code
!= EQ_EXPR
&& code
!= NE_EXPR
)
336 /* Extract the operands from e.g. (x & 8) == 4. */
339 if ((TREE_CODE (lhs
) == BIT_AND_EXPR
340 || TREE_CODE (lhs
) == BIT_IOR_EXPR
)
341 && TREE_CODE (rhs
) == INTEGER_CST
)
342 bitop
= lhs
, cst
= rhs
;
343 else if ((TREE_CODE (rhs
) == BIT_AND_EXPR
344 || TREE_CODE (rhs
) == BIT_IOR_EXPR
)
345 && TREE_CODE (lhs
) == INTEGER_CST
)
346 bitop
= rhs
, cst
= lhs
;
351 if (TREE_CODE (TREE_OPERAND (bitop
, 0)) == INTEGER_CST
)
352 bitopcst
= TREE_OPERAND (bitop
, 0);
353 else if (TREE_CODE (TREE_OPERAND (bitop
, 1)) == INTEGER_CST
)
354 bitopcst
= TREE_OPERAND (bitop
, 1);
359 if (TREE_CODE (bitop
) == BIT_AND_EXPR
)
360 res
= wi::bit_and (bitopcst
, cst
);
362 res
= wi::bit_or (bitopcst
, cst
);
364 /* For BIT_AND only warn if (CST2 & CST1) != CST1, and
365 for BIT_OR only if (CST2 | CST1) != CST1. */
370 warning_at (loc
, OPT_Wtautological_compare
,
371 "bitwise comparison always evaluates to false");
373 warning_at (loc
, OPT_Wtautological_compare
,
374 "bitwise comparison always evaluates to true");
377 /* Warn if a self-comparison always evaluates to true or false. LOC
378 is the location of the comparison with code CODE, LHS and RHS are
379 operands of the comparison. */
382 warn_tautological_cmp (location_t loc
, enum tree_code code
, tree lhs
, tree rhs
)
384 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
387 /* Don't warn for various macro expansions. */
388 if (from_macro_expansion_at (loc
)
389 || from_macro_expansion_at (EXPR_LOCATION (lhs
))
390 || from_macro_expansion_at (EXPR_LOCATION (rhs
)))
393 warn_tautological_bitwise_comparison (loc
, code
, lhs
, rhs
);
395 /* We do not warn for constants because they are typical of macro
396 expansions that test for features, sizeof, and similar. */
397 if (CONSTANT_CLASS_P (fold_for_warn (lhs
))
398 || CONSTANT_CLASS_P (fold_for_warn (rhs
)))
401 /* Don't warn for e.g.
404 if (n == (long) n) ...
406 if ((CONVERT_EXPR_P (lhs
) || TREE_CODE (lhs
) == NON_LVALUE_EXPR
)
407 || (CONVERT_EXPR_P (rhs
) || TREE_CODE (rhs
) == NON_LVALUE_EXPR
))
410 /* Don't warn if either LHS or RHS has an IEEE floating-point type.
411 It could be a NaN, and NaN never compares equal to anything, even
413 if (FLOAT_TYPE_P (TREE_TYPE (lhs
)) || FLOAT_TYPE_P (TREE_TYPE (rhs
)))
416 if (operand_equal_p (lhs
, rhs
, 0))
418 /* Don't warn about array references with constant indices;
419 these are likely to come from a macro. */
420 if (walk_tree_without_duplicates (&lhs
, find_array_ref_with_const_idx_r
,
423 const bool always_true
= (code
== EQ_EXPR
|| code
== LE_EXPR
424 || code
== GE_EXPR
|| code
== UNLE_EXPR
425 || code
== UNGE_EXPR
|| code
== UNEQ_EXPR
);
427 warning_at (loc
, OPT_Wtautological_compare
,
428 "self-comparison always evaluates to true");
430 warning_at (loc
, OPT_Wtautological_compare
,
431 "self-comparison always evaluates to false");
435 /* Return true iff EXPR only contains boolean operands, or comparisons. */
438 expr_has_boolean_operands_p (tree expr
)
442 if (CONVERT_EXPR_P (expr
))
443 return bool_promoted_to_int_p (expr
);
444 else if (UNARY_CLASS_P (expr
))
445 return expr_has_boolean_operands_p (TREE_OPERAND (expr
, 0));
446 else if (BINARY_CLASS_P (expr
))
447 return (expr_has_boolean_operands_p (TREE_OPERAND (expr
, 0))
448 && expr_has_boolean_operands_p (TREE_OPERAND (expr
, 1)));
449 else if (COMPARISON_CLASS_P (expr
))
455 /* Warn about logical not used on the left hand side operand of a comparison.
456 This function assumes that the LHS is inside of TRUTH_NOT_EXPR.
457 Do not warn if RHS is of a boolean type, a logical operator, or
461 warn_logical_not_parentheses (location_t location
, enum tree_code code
,
464 if (TREE_CODE_CLASS (code
) != tcc_comparison
465 || TREE_TYPE (rhs
) == NULL_TREE
466 || TREE_CODE (TREE_TYPE (rhs
)) == BOOLEAN_TYPE
467 || truth_value_p (TREE_CODE (rhs
)))
470 /* Don't warn for expression like !x == ~(bool1 | bool2). */
471 if (expr_has_boolean_operands_p (rhs
))
474 /* Don't warn for !x == 0 or !y != 0, those are equivalent to
475 !(x == 0) or !(y != 0). */
476 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
477 && integer_zerop (rhs
))
480 if (warning_at (location
, OPT_Wlogical_not_parentheses
,
481 "logical not is only applied to the left hand side of "
483 && EXPR_HAS_LOCATION (lhs
))
485 location_t lhs_loc
= EXPR_LOCATION (lhs
);
486 rich_location
richloc (line_table
, lhs_loc
);
487 richloc
.add_fixit_insert_before (lhs_loc
, "(");
488 richloc
.add_fixit_insert_after (lhs_loc
, ")");
489 inform_at_rich_loc (&richloc
, "add parentheses around left hand side "
490 "expression to silence this warning");
494 /* Warn if EXP contains any computations whose results are not used.
495 Return true if a warning is printed; false otherwise. LOCUS is the
496 (potential) location of the expression. */
499 warn_if_unused_value (const_tree exp
, location_t locus
)
502 if (TREE_USED (exp
) || TREE_NO_WARNING (exp
))
505 /* Don't warn about void constructs. This includes casting to void,
506 void function calls, and statement expressions with a final cast
508 if (VOID_TYPE_P (TREE_TYPE (exp
)))
511 if (EXPR_HAS_LOCATION (exp
))
512 locus
= EXPR_LOCATION (exp
);
514 switch (TREE_CODE (exp
))
516 case PREINCREMENT_EXPR
:
517 case POSTINCREMENT_EXPR
:
518 case PREDECREMENT_EXPR
:
519 case POSTDECREMENT_EXPR
:
530 /* For a binding, warn if no side effect within it. */
531 exp
= BIND_EXPR_BODY (exp
);
535 case NON_LVALUE_EXPR
:
537 exp
= TREE_OPERAND (exp
, 0);
540 case TRUTH_ORIF_EXPR
:
541 case TRUTH_ANDIF_EXPR
:
542 /* In && or ||, warn if 2nd operand has no side effect. */
543 exp
= TREE_OPERAND (exp
, 1);
547 if (warn_if_unused_value (TREE_OPERAND (exp
, 0), locus
))
549 /* Let people do `(foo (), 0)' without a warning. */
550 if (TREE_CONSTANT (TREE_OPERAND (exp
, 1)))
552 exp
= TREE_OPERAND (exp
, 1);
556 /* If this is an expression with side effects, don't warn; this
557 case commonly appears in macro expansions. */
558 if (TREE_SIDE_EFFECTS (exp
))
563 /* Don't warn about automatic dereferencing of references, since
564 the user cannot control it. */
565 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
567 exp
= TREE_OPERAND (exp
, 0);
573 /* Referencing a volatile value is a side effect, so don't warn. */
574 if ((DECL_P (exp
) || REFERENCE_CLASS_P (exp
))
575 && TREE_THIS_VOLATILE (exp
))
578 /* If this is an expression which has no operands, there is no value
579 to be unused. There are no such language-independent codes,
580 but front ends may define such. */
581 if (EXPRESSION_CLASS_P (exp
) && TREE_OPERAND_LENGTH (exp
) == 0)
585 return warning_at (locus
, OPT_Wunused_value
, "value computed is not used");
589 /* Print a warning about casts that might indicate violation
590 of strict aliasing rules if -Wstrict-aliasing is used and
591 strict aliasing mode is in effect. OTYPE is the original
592 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
595 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
597 /* Strip pointer conversion chains and get to the correct original type. */
599 otype
= TREE_TYPE (expr
);
601 if (!(flag_strict_aliasing
602 && POINTER_TYPE_P (type
)
603 && POINTER_TYPE_P (otype
)
604 && !VOID_TYPE_P (TREE_TYPE (type
)))
605 /* If the type we are casting to is a ref-all pointer
606 dereferencing it is always valid. */
607 || TYPE_REF_CAN_ALIAS_ALL (type
))
610 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
611 && (DECL_P (TREE_OPERAND (expr
, 0))
612 || handled_component_p (TREE_OPERAND (expr
, 0))))
614 /* Casting the address of an object to non void pointer. Warn
615 if the cast breaks type based aliasing. */
616 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
618 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
619 "might break strict-aliasing rules");
624 /* warn_strict_aliasing >= 3. This includes the default (3).
625 Only warn if the cast is dereferenced immediately. */
627 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
628 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
632 && !alias_set_subset_of (set2
, set1
)
633 && !alias_sets_conflict_p (set1
, set2
))
635 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
636 "pointer will break strict-aliasing rules");
639 else if (warn_strict_aliasing
== 2
640 && !alias_sets_must_conflict_p (set1
, set2
))
642 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
643 "pointer might break strict-aliasing rules");
648 else if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
650 /* At this level, warn for any conversions, even if an address is
651 not taken in the same statement. This will likely produce many
652 false positives, but could be useful to pinpoint problems that
653 are not revealed at higher levels. */
654 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
655 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
656 if (!COMPLETE_TYPE_P (type
)
657 || !alias_sets_must_conflict_p (set1
, set2
))
659 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
660 "pointer might break strict-aliasing rules");
668 /* Warn about memset (&a, 0, sizeof (&a)); and similar mistakes with
669 sizeof as last operand of certain builtins. */
672 sizeof_pointer_memaccess_warning (location_t
*sizeof_arg_loc
, tree callee
,
673 vec
<tree
, va_gc
> *params
, tree
*sizeof_arg
,
674 bool (*comp_types
) (tree
, tree
))
676 tree type
, dest
= NULL_TREE
, src
= NULL_TREE
, tem
;
677 bool strop
= false, cmp
= false;
678 unsigned int idx
= ~0;
681 if (TREE_CODE (callee
) != FUNCTION_DECL
682 || DECL_BUILT_IN_CLASS (callee
) != BUILT_IN_NORMAL
683 || vec_safe_length (params
) <= 1)
686 switch (DECL_FUNCTION_CODE (callee
))
688 case BUILT_IN_STRNCMP
:
689 case BUILT_IN_STRNCASECMP
:
692 case BUILT_IN_STRNCPY
:
693 case BUILT_IN_STRNCPY_CHK
:
694 case BUILT_IN_STRNCAT
:
695 case BUILT_IN_STRNCAT_CHK
:
696 case BUILT_IN_STPNCPY
:
697 case BUILT_IN_STPNCPY_CHK
:
700 case BUILT_IN_MEMCPY
:
701 case BUILT_IN_MEMCPY_CHK
:
702 case BUILT_IN_MEMMOVE
:
703 case BUILT_IN_MEMMOVE_CHK
:
704 if (params
->length () < 3)
711 if (params
->length () < 3)
717 case BUILT_IN_MEMCMP
:
719 if (params
->length () < 3)
726 case BUILT_IN_MEMSET
:
727 case BUILT_IN_MEMSET_CHK
:
728 if (params
->length () < 3)
737 case BUILT_IN_STRNDUP
:
742 case BUILT_IN_MEMCHR
:
743 if (params
->length () < 3)
748 case BUILT_IN_SNPRINTF
:
749 case BUILT_IN_SNPRINTF_CHK
:
750 case BUILT_IN_VSNPRINTF
:
751 case BUILT_IN_VSNPRINTF_CHK
:
763 if (sizeof_arg
[idx
] == NULL
|| sizeof_arg
[idx
] == error_mark_node
)
766 type
= TYPE_P (sizeof_arg
[idx
])
767 ? sizeof_arg
[idx
] : TREE_TYPE (sizeof_arg
[idx
]);
768 if (!POINTER_TYPE_P (type
))
772 && (tem
= tree_strip_nop_conversions (dest
))
773 && POINTER_TYPE_P (TREE_TYPE (tem
))
774 && comp_types (TREE_TYPE (TREE_TYPE (tem
)), type
))
778 && (tem
= tree_strip_nop_conversions (src
))
779 && POINTER_TYPE_P (TREE_TYPE (tem
))
780 && comp_types (TREE_TYPE (TREE_TYPE (tem
)), type
))
783 loc
= sizeof_arg_loc
[idx
];
787 if (!TYPE_P (sizeof_arg
[idx
])
788 && operand_equal_p (dest
, sizeof_arg
[idx
], 0)
789 && comp_types (TREE_TYPE (dest
), type
))
791 if (TREE_CODE (sizeof_arg
[idx
]) == ADDR_EXPR
&& !strop
)
792 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
793 "argument to %<sizeof%> in %qD call is the same "
794 "expression as the destination; did you mean to "
795 "remove the addressof?", callee
);
796 else if ((TYPE_PRECISION (TREE_TYPE (type
))
797 == TYPE_PRECISION (char_type_node
))
799 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
800 "argument to %<sizeof%> in %qD call is the same "
801 "expression as the destination; did you mean to "
802 "provide an explicit length?", callee
);
804 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
805 "argument to %<sizeof%> in %qD call is the same "
806 "expression as the destination; did you mean to "
807 "dereference it?", callee
);
811 if (POINTER_TYPE_P (TREE_TYPE (dest
))
813 && comp_types (TREE_TYPE (dest
), type
)
814 && !VOID_TYPE_P (TREE_TYPE (type
)))
816 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
817 "argument to %<sizeof%> in %qD call is the same "
818 "pointer type %qT as the destination; expected %qT "
819 "or an explicit length", callee
, TREE_TYPE (dest
),
820 TREE_TYPE (TREE_TYPE (dest
)));
827 if (!TYPE_P (sizeof_arg
[idx
])
828 && operand_equal_p (src
, sizeof_arg
[idx
], 0)
829 && comp_types (TREE_TYPE (src
), type
))
831 if (TREE_CODE (sizeof_arg
[idx
]) == ADDR_EXPR
&& !strop
)
832 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
833 "argument to %<sizeof%> in %qD call is the same "
834 "expression as the source; did you mean to "
835 "remove the addressof?", callee
);
836 else if ((TYPE_PRECISION (TREE_TYPE (type
))
837 == TYPE_PRECISION (char_type_node
))
839 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
840 "argument to %<sizeof%> in %qD call is the same "
841 "expression as the source; did you mean to "
842 "provide an explicit length?", callee
);
844 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
845 "argument to %<sizeof%> in %qD call is the same "
846 "expression as the source; did you mean to "
847 "dereference it?", callee
);
851 if (POINTER_TYPE_P (TREE_TYPE (src
))
853 && comp_types (TREE_TYPE (src
), type
)
854 && !VOID_TYPE_P (TREE_TYPE (type
)))
856 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
857 "argument to %<sizeof%> in %qD call is the same "
858 "pointer type %qT as the source; expected %qT "
859 "or an explicit length", callee
, TREE_TYPE (src
),
860 TREE_TYPE (TREE_TYPE (src
)));
867 if (!TYPE_P (sizeof_arg
[idx
])
868 && operand_equal_p (dest
, sizeof_arg
[idx
], 0)
869 && comp_types (TREE_TYPE (dest
), type
))
871 if (TREE_CODE (sizeof_arg
[idx
]) == ADDR_EXPR
&& !strop
)
872 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
873 "argument to %<sizeof%> in %qD call is the same "
874 "expression as the first source; did you mean to "
875 "remove the addressof?", callee
);
876 else if ((TYPE_PRECISION (TREE_TYPE (type
))
877 == TYPE_PRECISION (char_type_node
))
879 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
880 "argument to %<sizeof%> in %qD call is the same "
881 "expression as the first source; did you mean to "
882 "provide an explicit length?", callee
);
884 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
885 "argument to %<sizeof%> in %qD call is the same "
886 "expression as the first source; did you mean to "
887 "dereference it?", callee
);
891 if (POINTER_TYPE_P (TREE_TYPE (dest
))
893 && comp_types (TREE_TYPE (dest
), type
)
894 && !VOID_TYPE_P (TREE_TYPE (type
)))
896 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
897 "argument to %<sizeof%> in %qD call is the same "
898 "pointer type %qT as the first source; expected %qT "
899 "or an explicit length", callee
, TREE_TYPE (dest
),
900 TREE_TYPE (TREE_TYPE (dest
)));
907 if (!TYPE_P (sizeof_arg
[idx
])
908 && operand_equal_p (src
, sizeof_arg
[idx
], 0)
909 && comp_types (TREE_TYPE (src
), type
))
911 if (TREE_CODE (sizeof_arg
[idx
]) == ADDR_EXPR
&& !strop
)
912 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
913 "argument to %<sizeof%> in %qD call is the same "
914 "expression as the second source; did you mean to "
915 "remove the addressof?", callee
);
916 else if ((TYPE_PRECISION (TREE_TYPE (type
))
917 == TYPE_PRECISION (char_type_node
))
919 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
920 "argument to %<sizeof%> in %qD call is the same "
921 "expression as the second source; did you mean to "
922 "provide an explicit length?", callee
);
924 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
925 "argument to %<sizeof%> in %qD call is the same "
926 "expression as the second source; did you mean to "
927 "dereference it?", callee
);
931 if (POINTER_TYPE_P (TREE_TYPE (src
))
933 && comp_types (TREE_TYPE (src
), type
)
934 && !VOID_TYPE_P (TREE_TYPE (type
)))
936 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
937 "argument to %<sizeof%> in %qD call is the same "
938 "pointer type %qT as the second source; expected %qT "
939 "or an explicit length", callee
, TREE_TYPE (src
),
940 TREE_TYPE (TREE_TYPE (src
)));
947 /* Warn for unlikely, improbable, or stupid DECL declarations
951 check_main_parameter_types (tree decl
)
953 function_args_iterator iter
;
957 FOREACH_FUNCTION_ARGS (TREE_TYPE (decl
), type
, iter
)
959 /* XXX void_type_node belies the abstraction. */
960 if (type
== void_type_node
|| type
== error_mark_node
)
965 pedwarn (input_location
, OPT_Wmain
,
966 "%<_Atomic%>-qualified parameter type %qT of %q+D",
968 while (POINTER_TYPE_P (t
))
972 pedwarn (input_location
, OPT_Wmain
,
973 "%<_Atomic%>-qualified parameter type %qT of %q+D",
981 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
982 pedwarn (input_location
, OPT_Wmain
,
983 "first argument of %q+D should be %<int%>", decl
);
987 if (TREE_CODE (type
) != POINTER_TYPE
988 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
989 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
991 pedwarn (input_location
, OPT_Wmain
,
992 "second argument of %q+D should be %<char **%>", decl
);
996 if (TREE_CODE (type
) != POINTER_TYPE
997 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
998 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1000 pedwarn (input_location
, OPT_Wmain
,
1001 "third argument of %q+D should probably be "
1002 "%<char **%>", decl
);
1007 /* It is intentional that this message does not mention the third
1008 argument because it's only mentioned in an appendix of the
1010 if (argct
> 0 && (argct
< 2 || argct
> 3))
1011 pedwarn (input_location
, OPT_Wmain
,
1012 "%q+D takes only zero or two arguments", decl
);
1014 if (stdarg_p (TREE_TYPE (decl
)))
1015 pedwarn (input_location
, OPT_Wmain
,
1016 "%q+D declared as variadic function", decl
);
1019 /* Warns if the conversion of EXPR to TYPE may alter a value.
1020 This is a helper function for warnings_for_convert_and_check. */
1023 conversion_warning (location_t loc
, tree type
, tree expr
, tree result
)
1025 tree expr_type
= TREE_TYPE (expr
);
1026 enum conversion_safety conversion_kind
;
1028 if (!warn_conversion
&& !warn_sign_conversion
&& !warn_float_conversion
)
1031 /* This may happen, because for LHS op= RHS we preevaluate
1032 RHS and create C_MAYBE_CONST_EXPR <SAVE_EXPR <RHS>>, which
1033 means we could no longer see the code of the EXPR. */
1034 if (TREE_CODE (expr
) == C_MAYBE_CONST_EXPR
)
1035 expr
= C_MAYBE_CONST_EXPR_EXPR (expr
);
1036 if (TREE_CODE (expr
) == SAVE_EXPR
)
1037 expr
= TREE_OPERAND (expr
, 0);
1039 switch (TREE_CODE (expr
))
1047 case TRUTH_ANDIF_EXPR
:
1048 case TRUTH_ORIF_EXPR
:
1049 case TRUTH_AND_EXPR
:
1051 case TRUTH_XOR_EXPR
:
1052 case TRUTH_NOT_EXPR
:
1053 /* Conversion from boolean to a signed:1 bit-field (which only
1054 can hold the values 0 and -1) doesn't lose information - but
1055 it does change the value. */
1056 if (TYPE_PRECISION (type
) == 1 && !TYPE_UNSIGNED (type
))
1057 warning_at (loc
, OPT_Wconversion
,
1058 "conversion to %qT from boolean expression", type
);
1065 conversion_kind
= unsafe_conversion_p (loc
, type
, expr
, result
, true);
1067 if (conversion_kind
== UNSAFE_REAL
)
1068 warnopt
= OPT_Wfloat_conversion
;
1069 else if (conversion_kind
)
1070 warnopt
= OPT_Wconversion
;
1074 if (TREE_CODE_CLASS (TREE_CODE (result
)) == tcc_constant
)
1075 warning_at (loc
, warnopt
,
1076 "conversion from %qT to %qT changes value from %qE to %qE",
1077 expr_type
, type
, expr
, result
);
1079 warning_at (loc
, warnopt
,
1080 "conversion from %qT to %qT changes the value of %qE",
1081 expr_type
, type
, expr
);
1086 /* In case of COND_EXPR, we do not care about the type of
1087 COND_EXPR, only about the conversion of each operand. */
1088 tree op1
= TREE_OPERAND (expr
, 1);
1089 tree op2
= TREE_OPERAND (expr
, 2);
1091 conversion_warning (loc
, type
, op1
, result
);
1092 conversion_warning (loc
, type
, op2
, result
);
1096 default: /* 'expr' is not a constant. */
1097 conversion_kind
= unsafe_conversion_p (loc
, type
, expr
, result
, true);
1098 if (conversion_kind
== UNSAFE_IMAGINARY
)
1099 warning_at (loc
, OPT_Wconversion
,
1100 "conversion from %qT to to %qT discards imaginary "
1106 if (conversion_kind
== UNSAFE_REAL
)
1107 warnopt
= OPT_Wfloat_conversion
;
1108 else if (conversion_kind
)
1109 warnopt
= OPT_Wconversion
;
1112 warning_at (loc
, warnopt
,
1113 "conversion from %qT to %qT may change value",
1119 /* Produce warnings after a conversion. RESULT is the result of
1120 converting EXPR to TYPE. This is a helper function for
1121 convert_and_check and cp_convert_and_check. */
1124 warnings_for_convert_and_check (location_t loc
, tree type
, tree expr
,
1127 loc
= expansion_point_location_if_in_system_header (loc
);
1129 bool cst
= TREE_CODE_CLASS (TREE_CODE (result
)) == tcc_constant
;
1131 tree exprtype
= TREE_TYPE (expr
);
1133 if (TREE_CODE (expr
) == INTEGER_CST
1134 && (TREE_CODE (type
) == INTEGER_TYPE
1135 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1136 && !int_fits_type_p (expr
, type
))
1138 /* Do not diagnose overflow in a constant expression merely
1139 because a conversion overflowed. */
1140 if (TREE_OVERFLOW (result
))
1141 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
1143 if (TYPE_UNSIGNED (type
))
1145 /* This detects cases like converting -129 or 256 to
1147 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
1150 warning_at (loc
, OPT_Woverflow
,
1151 (TYPE_UNSIGNED (exprtype
)
1152 ? G_("conversion from %qT to %qT "
1153 "changes value from %qE to %qE")
1154 : G_("unsigned conversion from %qT to %qT "
1155 "changes value from %qE to %qE")),
1156 exprtype
, type
, expr
, result
);
1158 warning_at (loc
, OPT_Woverflow
,
1159 (TYPE_UNSIGNED (exprtype
)
1160 ? G_("conversion from %qT to %qT "
1161 "changes the value of %qE")
1162 : G_("unsigned conversion from %qT to %qT "
1163 "changes the value of %qE")),
1164 exprtype
, type
, expr
);
1167 conversion_warning (loc
, type
, expr
, result
);
1169 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
1172 warning_at (loc
, OPT_Woverflow
,
1173 "overflow in conversion from %qT to %qT "
1174 "changes value from %qE to %qE",
1175 exprtype
, type
, expr
, result
);
1177 warning_at (loc
, OPT_Woverflow
,
1178 "overflow in conversion from %qT to %qT "
1179 "changes the value of %qE",
1180 exprtype
, type
, expr
);
1182 /* No warning for converting 0x80000000 to int. */
1184 && (TREE_CODE (exprtype
) != INTEGER_TYPE
1185 || TYPE_PRECISION (exprtype
)
1186 != TYPE_PRECISION (type
)))
1189 warning_at (loc
, OPT_Woverflow
,
1190 "overflow in conversion from %qT to %qT "
1191 "changes value from %qE to %qE",
1192 exprtype
, type
, expr
, result
);
1194 warning_at (loc
, OPT_Woverflow
,
1195 "overflow in conversion from %qT to %qT "
1196 "changes the value of %qE",
1197 exprtype
, type
, expr
);
1200 conversion_warning (loc
, type
, expr
, result
);
1202 else if ((TREE_CODE (result
) == INTEGER_CST
1203 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
1206 warning_at (loc
, OPT_Woverflow
,
1207 "overflow in conversion from %qT to %qT "
1208 "chages value from %qE to %qE",
1209 exprtype
, type
, expr
, result
);
1211 warning_at (loc
, OPT_Woverflow
,
1212 "overflow in conversion from %qT to %qT "
1213 "chages the value of %qE",
1214 exprtype
, type
, expr
);
1217 conversion_warning (loc
, type
, expr
, result
);
1220 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
1221 Used to verify that case values match up with enumerator values. */
1224 match_case_to_enum_1 (tree key
, tree type
, tree label
)
1226 /* Avoid warning about enums that have no enumerators. */
1227 if (TYPE_VALUES (type
) == NULL_TREE
)
1230 char buf
[WIDE_INT_PRINT_BUFFER_SIZE
];
1232 if (tree_fits_uhwi_p (key
))
1233 print_dec (key
, buf
, UNSIGNED
);
1234 else if (tree_fits_shwi_p (key
))
1235 print_dec (key
, buf
, SIGNED
);
1237 print_hex (key
, buf
);
1239 if (TYPE_NAME (type
) == NULL_TREE
)
1240 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
1241 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
1242 "case value %qs not in enumerated type",
1245 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
1246 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
1247 "case value %qs not in enumerated type %qT",
1251 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
1252 Used to verify that case values match up with enumerator values. */
1255 match_case_to_enum (splay_tree_node node
, void *data
)
1257 tree label
= (tree
) node
->value
;
1258 tree type
= (tree
) data
;
1260 /* Skip default case. */
1261 if (!CASE_LOW (label
))
1264 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
1265 when we did our enum->case scan. Reset our scratch bit after. */
1266 if (!CASE_LOW_SEEN (label
))
1267 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
1269 CASE_LOW_SEEN (label
) = 0;
1271 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
1272 not set, that means that CASE_HIGH did not appear when we did our
1273 enum->case scan. Reset our scratch bit after. */
1274 if (CASE_HIGH (label
))
1276 if (!CASE_HIGH_SEEN (label
))
1277 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
1279 CASE_HIGH_SEEN (label
) = 0;
1285 /* Handle -Wswitch*. Called from the front end after parsing the
1286 switch construct. */
1287 /* ??? Should probably be somewhere generic, since other languages
1288 besides C and C++ would want this. At the moment, however, C/C++
1289 are the only tree-ssa languages that support enumerations at all,
1290 so the point is moot. */
1293 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
1294 tree type
, tree cond
, bool bool_cond_p
,
1295 bool outside_range_p
)
1297 splay_tree_node default_node
;
1298 splay_tree_node node
;
1301 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
1302 && !warn_switch_bool
)
1305 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
1307 warning_at (switch_location
, OPT_Wswitch_default
,
1308 "switch missing default case");
1310 /* There are certain cases where -Wswitch-bool warnings aren't
1317 so be careful here. */
1318 if (warn_switch_bool
&& bool_cond_p
)
1320 splay_tree_node min_node
;
1321 /* If there's a default node, it's also the value with the minimal
1322 key. So look at the penultimate key (if any). */
1324 min_node
= splay_tree_successor (cases
, (splay_tree_key
) NULL
);
1326 min_node
= splay_tree_min (cases
);
1327 tree min
= min_node
? (tree
) min_node
->key
: NULL_TREE
;
1329 splay_tree_node max_node
= splay_tree_max (cases
);
1330 /* This might be a case range, so look at the value with the
1331 maximal key and then check CASE_HIGH. */
1332 tree max
= max_node
? (tree
) max_node
->value
: NULL_TREE
;
1334 max
= CASE_HIGH (max
) ? CASE_HIGH (max
) : CASE_LOW (max
);
1336 /* If there's a case value > 1 or < 0, that is outside bool
1339 || (max
&& wi::gts_p (max
, 1))
1340 || (min
&& wi::lts_p (min
, 0))
1348 case, where we want to warn. */
1350 && max
&& wi::eq_p (max
, 1)
1351 && min
&& wi::eq_p (min
, 0)))
1352 warning_at (switch_location
, OPT_Wswitch_bool
,
1353 "switch condition has boolean value");
1356 /* From here on, we only care about enumerated types. */
1357 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
1360 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
1361 if (!warn_switch_enum
&& !warn_switch
)
1364 /* Check the cases. Warn about case values which are not members of
1365 the enumerated type. For -Wswitch-enum, or for -Wswitch when
1366 there is no default case, check that exactly all enumeration
1367 literals are covered by the cases. */
1369 /* Clearing COND if it is not an integer constant simplifies
1370 the tests inside the loop below. */
1371 if (TREE_CODE (cond
) != INTEGER_CST
)
1374 /* The time complexity here is O(N*lg(N)) worst case, but for the
1375 common case of monotonically increasing enumerators, it is
1376 O(N), since the nature of the splay tree will keep the next
1377 element adjacent to the root at all times. */
1379 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
1381 tree value
= TREE_VALUE (chain
);
1382 if (TREE_CODE (value
) == CONST_DECL
)
1383 value
= DECL_INITIAL (value
);
1384 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
1387 /* Mark the CASE_LOW part of the case entry as seen. */
1388 tree label
= (tree
) node
->value
;
1389 CASE_LOW_SEEN (label
) = 1;
1393 /* Even though there wasn't an exact match, there might be a
1394 case range which includes the enumerator's value. */
1395 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
1396 if (node
&& CASE_HIGH ((tree
) node
->value
))
1398 tree label
= (tree
) node
->value
;
1399 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
1402 /* If we match the upper bound exactly, mark the CASE_HIGH
1403 part of the case entry as seen. */
1405 CASE_HIGH_SEEN (label
) = 1;
1410 /* We've now determined that this enumerated literal isn't
1411 handled by the case labels of the switch statement. */
1413 /* If the switch expression is a constant, we only really care
1414 about whether that constant is handled by the switch. */
1415 if (cond
&& tree_int_cst_compare (cond
, value
))
1418 /* If there is a default_node, the only relevant option is
1419 Wswitch-enum. Otherwise, if both are enabled then we prefer
1420 to warn using -Wswitch because -Wswitch is enabled by -Wall
1421 while -Wswitch-enum is explicit. */
1422 warning_at (switch_location
,
1423 (default_node
|| !warn_switch
1426 "enumeration value %qE not handled in switch",
1427 TREE_PURPOSE (chain
));
1430 /* Warn if there are case expressions that don't correspond to
1431 enumerators. This can occur since C and C++ don't enforce
1432 type-checking of assignments to enumeration variables.
1434 The time complexity here is now always O(N) worst case, since
1435 we should have marked both the lower bound and upper bound of
1436 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
1437 above. This scan also resets those fields. */
1439 splay_tree_foreach (cases
, match_case_to_enum
, type
);
1442 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
1443 expression, because B will always be true. */
1446 warn_for_omitted_condop (location_t location
, tree cond
)
1448 /* In C++ template declarations it can happen that the type is dependent
1449 and not yet known, thus TREE_TYPE (cond) == NULL_TREE. */
1450 if (truth_value_p (TREE_CODE (cond
))
1451 || (TREE_TYPE (cond
) != NULL_TREE
1452 && TREE_CODE (TREE_TYPE (cond
)) == BOOLEAN_TYPE
))
1453 warning_at (location
, OPT_Wparentheses
,
1454 "the omitted middle operand in ?: will always be %<true%>, "
1455 "suggest explicit middle operand");
1458 /* Give an error for storing into ARG, which is 'const'. USE indicates
1459 how ARG was being used. */
1462 readonly_error (location_t loc
, tree arg
, enum lvalue_use use
)
1464 gcc_assert (use
== lv_assign
|| use
== lv_increment
|| use
== lv_decrement
1466 /* Using this macro rather than (for example) arrays of messages
1467 ensures that all the format strings are checked at compile
1469 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
1470 : (use == lv_increment ? (I) \
1471 : (use == lv_decrement ? (D) : (AS))))
1472 if (TREE_CODE (arg
) == COMPONENT_REF
)
1474 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
1475 error_at (loc
, READONLY_MSG (G_("assignment of member "
1476 "%qD in read-only object"),
1477 G_("increment of member "
1478 "%qD in read-only object"),
1479 G_("decrement of member "
1480 "%qD in read-only object"),
1481 G_("member %qD in read-only object "
1482 "used as %<asm%> output")),
1483 TREE_OPERAND (arg
, 1));
1485 error_at (loc
, READONLY_MSG (G_("assignment of read-only member %qD"),
1486 G_("increment of read-only member %qD"),
1487 G_("decrement of read-only member %qD"),
1488 G_("read-only member %qD used as %<asm%> output")),
1489 TREE_OPERAND (arg
, 1));
1491 else if (VAR_P (arg
))
1492 error_at (loc
, READONLY_MSG (G_("assignment of read-only variable %qD"),
1493 G_("increment of read-only variable %qD"),
1494 G_("decrement of read-only variable %qD"),
1495 G_("read-only variable %qD used as %<asm%> output")),
1497 else if (TREE_CODE (arg
) == PARM_DECL
)
1498 error_at (loc
, READONLY_MSG (G_("assignment of read-only parameter %qD"),
1499 G_("increment of read-only parameter %qD"),
1500 G_("decrement of read-only parameter %qD"),
1501 G_("read-only parameter %qD use as %<asm%> output")),
1503 else if (TREE_CODE (arg
) == RESULT_DECL
)
1505 gcc_assert (c_dialect_cxx ());
1506 error_at (loc
, READONLY_MSG (G_("assignment of "
1507 "read-only named return value %qD"),
1509 "read-only named return value %qD"),
1511 "read-only named return value %qD"),
1512 G_("read-only named return value %qD "
1513 "used as %<asm%>output")),
1516 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
1517 error_at (loc
, READONLY_MSG (G_("assignment of function %qD"),
1518 G_("increment of function %qD"),
1519 G_("decrement of function %qD"),
1520 G_("function %qD used as %<asm%> output")),
1523 error_at (loc
, READONLY_MSG (G_("assignment of read-only location %qE"),
1524 G_("increment of read-only location %qE"),
1525 G_("decrement of read-only location %qE"),
1526 G_("read-only location %qE used as %<asm%> output")),
1530 /* Print an error message for an invalid lvalue. USE says
1531 how the lvalue is being used and so selects the error message. LOC
1532 is the location for the error. */
1535 lvalue_error (location_t loc
, enum lvalue_use use
)
1540 error_at (loc
, "lvalue required as left operand of assignment");
1543 error_at (loc
, "lvalue required as increment operand");
1546 error_at (loc
, "lvalue required as decrement operand");
1549 error_at (loc
, "lvalue required as unary %<&%> operand");
1552 error_at (loc
, "lvalue required in asm statement");
1559 /* Print an error message for an invalid indirection of type TYPE.
1560 ERRSTRING is the name of the operator for the indirection. */
1563 invalid_indirection_error (location_t loc
, tree type
, ref_operator errstring
)
1568 gcc_assert (c_dialect_cxx ());
1569 error_at (loc
, "invalid type argument (have %qT)", type
);
1571 case RO_ARRAY_INDEXING
:
1573 "invalid type argument of array indexing (have %qT)",
1578 "invalid type argument of unary %<*%> (have %qT)",
1583 "invalid type argument of %<->%> (have %qT)",
1588 "invalid type argument of %<->*%> (have %qT)",
1591 case RO_IMPLICIT_CONVERSION
:
1593 "invalid type argument of implicit conversion (have %qT)",
1601 /* Subscripting with type char is likely to lose on a machine where
1602 chars are signed. So warn on any machine, but optionally. Don't
1603 warn for unsigned char since that type is safe. Don't warn for
1604 signed char because anyone who uses that must have done so
1605 deliberately. Furthermore, we reduce the false positive load by
1606 warning only for non-constant value of type char. */
1609 warn_array_subscript_with_type_char (location_t loc
, tree index
)
1611 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
1612 && TREE_CODE (index
) != INTEGER_CST
)
1613 warning_at (loc
, OPT_Wchar_subscripts
,
1614 "array subscript has type %<char%>");
1617 /* Implement -Wparentheses for the unexpected C precedence rules, to
1618 cover cases like x + y << z which readers are likely to
1619 misinterpret. We have seen an expression in which CODE is a binary
1620 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
1621 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
1622 CODE_RIGHT may be ERROR_MARK, which means that that side of the
1623 expression was not formed using a binary or unary operator, or it
1624 was enclosed in parentheses. */
1627 warn_about_parentheses (location_t loc
, enum tree_code code
,
1628 enum tree_code code_left
, tree arg_left
,
1629 enum tree_code code_right
, tree arg_right
)
1631 if (!warn_parentheses
)
1634 /* This macro tests that the expression ARG with original tree code
1635 CODE appears to be a boolean expression. or the result of folding a
1636 boolean expression. */
1637 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
1638 (truth_value_p (TREE_CODE (ARG)) \
1639 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
1640 /* Folding may create 0 or 1 integers from other expressions. */ \
1641 || ((CODE) != INTEGER_CST \
1642 && (integer_onep (ARG) || integer_zerop (ARG))))
1647 if (code_left
== PLUS_EXPR
)
1648 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1649 "suggest parentheses around %<+%> inside %<<<%>");
1650 else if (code_right
== PLUS_EXPR
)
1651 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1652 "suggest parentheses around %<+%> inside %<<<%>");
1653 else if (code_left
== MINUS_EXPR
)
1654 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1655 "suggest parentheses around %<-%> inside %<<<%>");
1656 else if (code_right
== MINUS_EXPR
)
1657 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1658 "suggest parentheses around %<-%> inside %<<<%>");
1662 if (code_left
== PLUS_EXPR
)
1663 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1664 "suggest parentheses around %<+%> inside %<>>%>");
1665 else if (code_right
== PLUS_EXPR
)
1666 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1667 "suggest parentheses around %<+%> inside %<>>%>");
1668 else if (code_left
== MINUS_EXPR
)
1669 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1670 "suggest parentheses around %<-%> inside %<>>%>");
1671 else if (code_right
== MINUS_EXPR
)
1672 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1673 "suggest parentheses around %<-%> inside %<>>%>");
1676 case TRUTH_ORIF_EXPR
:
1677 if (code_left
== TRUTH_ANDIF_EXPR
)
1678 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1679 "suggest parentheses around %<&&%> within %<||%>");
1680 else if (code_right
== TRUTH_ANDIF_EXPR
)
1681 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1682 "suggest parentheses around %<&&%> within %<||%>");
1686 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
1687 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
)
1688 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1689 "suggest parentheses around arithmetic in operand of %<|%>");
1690 else if (code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
1691 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
1692 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1693 "suggest parentheses around arithmetic in operand of %<|%>");
1694 /* Check cases like x|y==z */
1695 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
1696 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1697 "suggest parentheses around comparison in operand of %<|%>");
1698 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
1699 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1700 "suggest parentheses around comparison in operand of %<|%>");
1701 /* Check cases like !x | y */
1702 else if (code_left
== TRUTH_NOT_EXPR
1703 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
1704 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1705 "suggest parentheses around operand of "
1706 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
1710 if (code_left
== BIT_AND_EXPR
1711 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
)
1712 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1713 "suggest parentheses around arithmetic in operand of %<^%>");
1714 else if (code_right
== BIT_AND_EXPR
1715 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
1716 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1717 "suggest parentheses around arithmetic in operand of %<^%>");
1718 /* Check cases like x^y==z */
1719 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
1720 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1721 "suggest parentheses around comparison in operand of %<^%>");
1722 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
1723 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1724 "suggest parentheses around comparison in operand of %<^%>");
1728 if (code_left
== PLUS_EXPR
)
1729 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1730 "suggest parentheses around %<+%> in operand of %<&%>");
1731 else if (code_right
== PLUS_EXPR
)
1732 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1733 "suggest parentheses around %<+%> in operand of %<&%>");
1734 else if (code_left
== MINUS_EXPR
)
1735 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1736 "suggest parentheses around %<-%> in operand of %<&%>");
1737 else if (code_right
== MINUS_EXPR
)
1738 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1739 "suggest parentheses around %<-%> in operand of %<&%>");
1740 /* Check cases like x&y==z */
1741 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
1742 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1743 "suggest parentheses around comparison in operand of %<&%>");
1744 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
1745 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1746 "suggest parentheses around comparison in operand of %<&%>");
1747 /* Check cases like !x & y */
1748 else if (code_left
== TRUTH_NOT_EXPR
1749 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
1750 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1751 "suggest parentheses around operand of "
1752 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
1756 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
1757 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1758 "suggest parentheses around comparison in operand of %<==%>");
1759 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
1760 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1761 "suggest parentheses around comparison in operand of %<==%>");
1764 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
1765 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1766 "suggest parentheses around comparison in operand of %<!=%>");
1767 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
1768 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1769 "suggest parentheses around comparison in operand of %<!=%>");
1773 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
1775 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
1776 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
1777 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left
)))
1778 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
1779 "comparisons like %<X<=Y<=Z%> do not "
1780 "have their mathematical meaning");
1781 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
1782 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
1783 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right
)))
1784 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
1785 "comparisons like %<X<=Y<=Z%> do not "
1786 "have their mathematical meaning");
1790 #undef NOT_A_BOOLEAN_EXPR_P
1793 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
1796 warn_for_unused_label (tree label
)
1798 if (!TREE_USED (label
))
1800 if (DECL_INITIAL (label
))
1801 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
1803 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
1805 else if (asan_sanitize_use_after_scope ())
1807 if (asan_used_labels
== NULL
)
1808 asan_used_labels
= new hash_set
<tree
> (16);
1810 asan_used_labels
->add (label
);
1814 /* Warn for division by zero according to the value of DIVISOR. LOC
1815 is the location of the division operator. */
1818 warn_for_div_by_zero (location_t loc
, tree divisor
)
1820 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
1821 about division by zero. Do not issue a warning if DIVISOR has a
1822 floating-point type, since we consider 0.0/0.0 a valid way of
1823 generating a NaN. */
1824 if (c_inhibit_evaluation_warnings
== 0
1825 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
1826 warning_at (loc
, OPT_Wdiv_by_zero
, "division by zero");
1829 /* Warn for patterns where memset appears to be used incorrectly. The
1830 warning location should be LOC. ARG0, and ARG2 are the first and
1831 last arguments to the call, while LITERAL_ZERO_MASK has a 1 bit for
1832 each argument that was a literal zero. */
1835 warn_for_memset (location_t loc
, tree arg0
, tree arg2
,
1836 int literal_zero_mask
)
1838 if (warn_memset_transposed_args
1839 && integer_zerop (arg2
)
1840 && (literal_zero_mask
& (1 << 2)) != 0
1841 && (literal_zero_mask
& (1 << 1)) == 0)
1842 warning_at (loc
, OPT_Wmemset_transposed_args
,
1843 "%<memset%> used with constant zero length "
1844 "parameter; this could be due to transposed "
1847 if (warn_memset_elt_size
&& TREE_CODE (arg2
) == INTEGER_CST
)
1850 if (TREE_CODE (arg0
) == ADDR_EXPR
)
1851 arg0
= TREE_OPERAND (arg0
, 0);
1852 tree type
= TREE_TYPE (arg0
);
1853 if (type
!= NULL_TREE
&& TREE_CODE (type
) == ARRAY_TYPE
)
1855 tree elt_type
= TREE_TYPE (type
);
1856 tree domain
= TYPE_DOMAIN (type
);
1857 if (!integer_onep (TYPE_SIZE_UNIT (elt_type
))
1858 && domain
!= NULL_TREE
1859 && TYPE_MAX_VALUE (domain
)
1860 && TYPE_MIN_VALUE (domain
)
1861 && integer_zerop (TYPE_MIN_VALUE (domain
))
1862 && integer_onep (fold_build2 (MINUS_EXPR
, domain
,
1864 TYPE_MAX_VALUE (domain
))))
1865 warning_at (loc
, OPT_Wmemset_elt_size
,
1866 "%<memset%> used with length equal to "
1867 "number of elements without multiplication "
1873 /* Subroutine of build_binary_op. Give warnings for comparisons
1874 between signed and unsigned quantities that may fail. Do the
1875 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
1876 so that casts will be considered, but default promotions won't
1879 LOCATION is the location of the comparison operator.
1881 The arguments of this function map directly to local variables
1882 of build_binary_op. */
1885 warn_for_sign_compare (location_t location
,
1886 tree orig_op0
, tree orig_op1
,
1888 tree result_type
, enum tree_code resultcode
)
1890 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
1891 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
1892 int unsignedp0
, unsignedp1
;
1894 /* In C++, check for comparison of different enum types. */
1896 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
1897 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
1898 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
1899 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
1901 warning_at (location
,
1902 OPT_Wsign_compare
, "comparison between types %qT and %qT",
1903 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
1906 /* Do not warn if the comparison is being done in a signed type,
1907 since the signed type will only be chosen if it can represent
1908 all the values of the unsigned type. */
1909 if (!TYPE_UNSIGNED (result_type
))
1911 /* Do not warn if both operands are unsigned. */
1912 else if (op0_signed
== op1_signed
)
1916 tree sop
, uop
, base_type
;
1920 sop
= orig_op0
, uop
= orig_op1
;
1922 sop
= orig_op1
, uop
= orig_op0
;
1924 STRIP_TYPE_NOPS (sop
);
1925 STRIP_TYPE_NOPS (uop
);
1926 base_type
= (TREE_CODE (result_type
) == COMPLEX_TYPE
1927 ? TREE_TYPE (result_type
) : result_type
);
1929 /* Do not warn if the signed quantity is an unsuffixed integer
1930 literal (or some static constant expression involving such
1931 literals or a conditional expression involving such literals)
1932 and it is non-negative. */
1933 if (tree_expr_nonnegative_warnv_p (sop
, &ovf
))
1935 /* Do not warn if the comparison is an equality operation, the
1936 unsigned quantity is an integral constant, and it would fit
1937 in the result if the result were signed. */
1938 else if (TREE_CODE (uop
) == INTEGER_CST
1939 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
1940 && int_fits_type_p (uop
, c_common_signed_type (base_type
)))
1942 /* In C, do not warn if the unsigned quantity is an enumeration
1943 constant and its maximum value would fit in the result if the
1944 result were signed. */
1945 else if (!c_dialect_cxx() && TREE_CODE (uop
) == INTEGER_CST
1946 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
1947 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
1948 c_common_signed_type (base_type
)))
1951 warning_at (location
, OPT_Wsign_compare
,
1952 "comparison of integer expressions of different "
1953 "signedness: %qT and %qT", TREE_TYPE (orig_op0
),
1954 TREE_TYPE (orig_op1
));
1957 /* Warn if two unsigned values are being compared in a size larger
1958 than their original size, and one (and only one) is the result of
1959 a `~' operator. This comparison will always fail.
1961 Also warn if one operand is a constant, and the constant does not
1962 have all bits set that are set in the ~ operand when it is
1965 op0
= c_common_get_narrower (op0
, &unsignedp0
);
1966 op1
= c_common_get_narrower (op1
, &unsignedp1
);
1968 if ((TREE_CODE (op0
) == BIT_NOT_EXPR
)
1969 ^ (TREE_CODE (op1
) == BIT_NOT_EXPR
))
1971 if (TREE_CODE (op0
) == BIT_NOT_EXPR
)
1972 op0
= c_common_get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
1973 if (TREE_CODE (op1
) == BIT_NOT_EXPR
)
1974 op1
= c_common_get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
1976 if (tree_fits_shwi_p (op0
) || tree_fits_shwi_p (op1
))
1979 HOST_WIDE_INT constant
, mask
;
1983 if (tree_fits_shwi_p (op0
))
1986 unsignedp
= unsignedp1
;
1987 constant
= tree_to_shwi (op0
);
1992 unsignedp
= unsignedp0
;
1993 constant
= tree_to_shwi (op1
);
1996 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
1997 if (bits
< TYPE_PRECISION (result_type
)
1998 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
2000 mask
= HOST_WIDE_INT_M1U
<< bits
;
2001 if ((mask
& constant
) != mask
)
2004 warning_at (location
, OPT_Wsign_compare
,
2005 "promoted ~unsigned is always non-zero");
2007 warning_at (location
, OPT_Wsign_compare
,
2008 "comparison of promoted ~unsigned with constant");
2012 else if (unsignedp0
&& unsignedp1
2013 && (TYPE_PRECISION (TREE_TYPE (op0
))
2014 < TYPE_PRECISION (result_type
))
2015 && (TYPE_PRECISION (TREE_TYPE (op1
))
2016 < TYPE_PRECISION (result_type
)))
2017 warning_at (location
, OPT_Wsign_compare
,
2018 "comparison of promoted ~unsigned with unsigned");
2022 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
2023 type via c_common_type. If -Wdouble-promotion is in use, and the
2024 conditions for warning have been met, issue a warning. GMSGID is
2025 the warning message. It must have two %T specifiers for the type
2026 that was converted (generally "float") and the type to which it was
2027 converted (generally "double), respectively. LOC is the location
2028 to which the warning should refer. */
2031 do_warn_double_promotion (tree result_type
, tree type1
, tree type2
,
2032 const char *gmsgid
, location_t loc
)
2036 if (!warn_double_promotion
)
2038 /* If the conversion will not occur at run-time, there is no need to
2040 if (c_inhibit_evaluation_warnings
)
2042 /* If an invalid conversion has occured, don't warn. */
2043 if (result_type
== error_mark_node
)
2045 if (TYPE_MAIN_VARIANT (result_type
) != double_type_node
2046 && TYPE_MAIN_VARIANT (result_type
) != complex_double_type_node
)
2048 if (TYPE_MAIN_VARIANT (type1
) == float_type_node
2049 || TYPE_MAIN_VARIANT (type1
) == complex_float_type_node
)
2050 source_type
= type1
;
2051 else if (TYPE_MAIN_VARIANT (type2
) == float_type_node
2052 || TYPE_MAIN_VARIANT (type2
) == complex_float_type_node
)
2053 source_type
= type2
;
2056 warning_at (loc
, OPT_Wdouble_promotion
, gmsgid
, source_type
, result_type
);
2059 /* Possibly warn about unused parameters. */
2062 do_warn_unused_parameter (tree fn
)
2066 for (decl
= DECL_ARGUMENTS (fn
);
2067 decl
; decl
= DECL_CHAIN (decl
))
2068 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
2069 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)
2070 && !TREE_NO_WARNING (decl
))
2071 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wunused_parameter
,
2072 "unused parameter %qD", decl
);
2075 /* If DECL is a typedef that is declared in the current function,
2076 record it for the purpose of -Wunused-local-typedefs. */
2079 record_locally_defined_typedef (tree decl
)
2081 struct c_language_function
*l
;
2083 if (!warn_unused_local_typedefs
2085 /* if this is not a locally defined typedef then we are not
2087 || !is_typedef_decl (decl
)
2088 || !decl_function_context (decl
))
2091 l
= (struct c_language_function
*) cfun
->language
;
2092 vec_safe_push (l
->local_typedefs
, decl
);
2095 /* If T is a TYPE_DECL declared locally, mark it as used. */
2098 maybe_record_typedef_use (tree t
)
2100 if (!is_typedef_decl (t
))
2103 TREE_USED (t
) = true;
2106 /* Warn if there are some unused locally defined typedefs in the
2107 current function. */
2110 maybe_warn_unused_local_typedefs (void)
2114 /* The number of times we have emitted -Wunused-local-typedefs
2115 warnings. If this is different from errorcount, that means some
2116 unrelated errors have been issued. In which case, we'll avoid
2117 emitting "unused-local-typedefs" warnings. */
2118 static int unused_local_typedefs_warn_count
;
2119 struct c_language_function
*l
;
2124 if ((l
= (struct c_language_function
*) cfun
->language
) == NULL
)
2127 if (warn_unused_local_typedefs
2128 && errorcount
== unused_local_typedefs_warn_count
)
2130 FOR_EACH_VEC_SAFE_ELT (l
->local_typedefs
, i
, decl
)
2131 if (!TREE_USED (decl
))
2132 warning_at (DECL_SOURCE_LOCATION (decl
),
2133 OPT_Wunused_local_typedefs
,
2134 "typedef %qD locally defined but not used", decl
);
2135 unused_local_typedefs_warn_count
= errorcount
;
2138 vec_free (l
->local_typedefs
);
2141 /* If we're creating an if-else-if condition chain, first see if we
2142 already have this COND in the CHAIN. If so, warn and don't add COND
2143 into the vector, otherwise add the COND there. LOC is the location
2147 warn_duplicated_cond_add_or_warn (location_t loc
, tree cond
, vec
<tree
> **chain
)
2149 /* No chain has been created yet. Do nothing. */
2153 if (TREE_SIDE_EFFECTS (cond
))
2155 /* Uh-oh! This condition has a side-effect, thus invalidates
2165 FOR_EACH_VEC_ELT (**chain
, ix
, t
)
2166 if (operand_equal_p (cond
, t
, 0))
2168 if (warning_at (loc
, OPT_Wduplicated_cond
,
2169 "duplicated %<if%> condition"))
2170 inform (EXPR_LOCATION (t
), "previously used here");
2176 && !CONSTANT_CLASS_P (cond
)
2177 /* Don't infinitely grow the chain. */
2178 && (*chain
)->length () < 512)
2179 (*chain
)->safe_push (cond
);
2182 /* Check and possibly warn if two declarations have contradictory
2183 attributes, such as always_inline vs. noinline. */
2186 diagnose_mismatched_attributes (tree olddecl
, tree newdecl
)
2188 bool warned
= false;
2190 tree a1
= lookup_attribute ("optimize", DECL_ATTRIBUTES (olddecl
));
2191 tree a2
= lookup_attribute ("optimize", DECL_ATTRIBUTES (newdecl
));
2192 /* An optimization attribute applied on a declaration after the
2193 definition is likely not what the user wanted. */
2195 && DECL_SAVED_TREE (olddecl
) != NULL_TREE
2196 && (a1
== NULL_TREE
|| !attribute_list_equal (a1
, a2
)))
2197 warned
|= warning (OPT_Wattributes
,
2198 "optimization attribute on %qD follows "
2199 "definition but the attribute doesn%'t match",
2202 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2203 if (DECL_DECLARED_INLINE_P (newdecl
)
2204 && DECL_UNINLINABLE (olddecl
)
2205 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2206 warned
|= warning (OPT_Wattributes
, "inline declaration of %qD follows "
2207 "declaration with attribute noinline", newdecl
);
2208 else if (DECL_DECLARED_INLINE_P (olddecl
)
2209 && DECL_UNINLINABLE (newdecl
)
2210 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
2211 warned
|= warning (OPT_Wattributes
, "declaration of %q+D with attribute "
2212 "noinline follows inline declaration ", newdecl
);
2213 else if (lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
))
2214 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (olddecl
)))
2215 warned
|= warning (OPT_Wattributes
, "declaration of %q+D with attribute "
2216 "%qs follows declaration with attribute %qs",
2217 newdecl
, "noinline", "always_inline");
2218 else if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (newdecl
))
2219 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2220 warned
|= warning (OPT_Wattributes
, "declaration of %q+D with attribute "
2221 "%qs follows declaration with attribute %qs",
2222 newdecl
, "always_inline", "noinline");
2223 else if (lookup_attribute ("cold", DECL_ATTRIBUTES (newdecl
))
2224 && lookup_attribute ("hot", DECL_ATTRIBUTES (olddecl
)))
2225 warned
|= warning (OPT_Wattributes
, "declaration of %q+D with attribute "
2226 "%qs follows declaration with attribute %qs",
2227 newdecl
, "cold", "hot");
2228 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (newdecl
))
2229 && lookup_attribute ("cold", DECL_ATTRIBUTES (olddecl
)))
2230 warned
|= warning (OPT_Wattributes
, "declaration of %q+D with attribute "
2231 "%qs follows declaration with attribute %qs",
2232 newdecl
, "hot", "cold");
2236 /* Warn if signed left shift overflows. We don't warn
2237 about left-shifting 1 into the sign bit in C++14; cf.
2238 <http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3367.html#1457>
2239 LOC is a location of the shift; OP0 and OP1 are the operands.
2240 Return true if an overflow is detected, false otherwise. */
2243 maybe_warn_shift_overflow (location_t loc
, tree op0
, tree op1
)
2245 if (TREE_CODE (op0
) != INTEGER_CST
2246 || TREE_CODE (op1
) != INTEGER_CST
)
2249 tree type0
= TREE_TYPE (op0
);
2250 unsigned int prec0
= TYPE_PRECISION (type0
);
2252 /* Left-hand operand must be signed. */
2253 if (TYPE_UNSIGNED (type0
))
2256 unsigned int min_prec
= (wi::min_precision (op0
, SIGNED
)
2257 + TREE_INT_CST_LOW (op1
));
2258 /* Handle the case of left-shifting 1 into the sign bit.
2259 * However, shifting 1 _out_ of the sign bit, as in
2260 * INT_MIN << 1, is considered an overflow.
2262 if (!tree_int_cst_sign_bit(op0
) && min_prec
== prec0
+ 1)
2264 /* Never warn for C++14 onwards. */
2265 if (cxx_dialect
>= cxx14
)
2267 /* Otherwise only if -Wshift-overflow=2. But return
2268 true to signal an overflow for the sake of integer
2269 constant expressions. */
2270 if (warn_shift_overflow
< 2)
2274 bool overflowed
= min_prec
> prec0
;
2275 if (overflowed
&& c_inhibit_evaluation_warnings
== 0)
2276 warning_at (loc
, OPT_Wshift_overflow_
,
2277 "result of %qE requires %u bits to represent, "
2278 "but %qT only has %u bits",
2279 build2_loc (loc
, LSHIFT_EXPR
, type0
, op0
, op1
),
2280 min_prec
, type0
, prec0
);
2285 /* Warn about boolean expression compared with an integer value different
2286 from true/false. Warns also e.g. about "(i1 == i2) == 2".
2287 LOC is the location of the comparison, CODE is its code, OP0 and OP1
2288 are the operands of the comparison. The caller must ensure that
2289 either operand is a boolean expression. */
2292 maybe_warn_bool_compare (location_t loc
, enum tree_code code
, tree op0
,
2295 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
2299 if (f
= fold_for_warn (op0
),
2300 TREE_CODE (f
) == INTEGER_CST
)
2302 else if (f
= fold_for_warn (op1
),
2303 TREE_CODE (f
) == INTEGER_CST
)
2308 if (!integer_zerop (cst
) && !integer_onep (cst
))
2310 int sign
= (TREE_CODE (op0
) == INTEGER_CST
2311 ? tree_int_cst_sgn (cst
) : -tree_int_cst_sgn (cst
));
2313 || ((code
== GT_EXPR
|| code
== GE_EXPR
) && sign
< 0)
2314 || ((code
== LT_EXPR
|| code
== LE_EXPR
) && sign
> 0))
2315 warning_at (loc
, OPT_Wbool_compare
, "comparison of constant %qE "
2316 "with boolean expression is always false", cst
);
2318 warning_at (loc
, OPT_Wbool_compare
, "comparison of constant %qE "
2319 "with boolean expression is always true", cst
);
2321 else if (integer_zerop (cst
) || integer_onep (cst
))
2323 /* If the non-constant operand isn't of a boolean type, we
2324 don't want to warn here. */
2325 tree noncst
= TREE_CODE (op0
) == INTEGER_CST
? op1
: op0
;
2326 /* Handle booleans promoted to integers. */
2327 if (bool_promoted_to_int_p (noncst
))
2329 else if (TREE_CODE (TREE_TYPE (noncst
)) != BOOLEAN_TYPE
2330 && !truth_value_p (TREE_CODE (noncst
)))
2332 /* Do some magic to get the right diagnostics. */
2333 bool flag
= TREE_CODE (op0
) == INTEGER_CST
;
2334 flag
= integer_zerop (cst
) ? flag
: !flag
;
2335 if ((code
== GE_EXPR
&& !flag
) || (code
== LE_EXPR
&& flag
))
2336 warning_at (loc
, OPT_Wbool_compare
, "comparison of constant %qE "
2337 "with boolean expression is always true", cst
);
2338 else if ((code
== LT_EXPR
&& !flag
) || (code
== GT_EXPR
&& flag
))
2339 warning_at (loc
, OPT_Wbool_compare
, "comparison of constant %qE "
2340 "with boolean expression is always false", cst
);
2344 /* Warn if an argument at position param_pos is passed to a
2345 restrict-qualified param, and it aliases with another argument. */
2348 warn_for_restrict (unsigned param_pos
, tree
*argarray
, unsigned nargs
)
2350 tree arg
= argarray
[param_pos
];
2351 if (TREE_VISITED (arg
) || integer_zerop (arg
))
2354 location_t loc
= EXPR_LOC_OR_LOC (arg
, input_location
);
2355 gcc_rich_location
richloc (loc
);
2358 auto_vec
<int, 16> arg_positions
;
2360 for (i
= 0; i
< nargs
; i
++)
2365 tree current_arg
= argarray
[i
];
2366 if (operand_equal_p (arg
, current_arg
, 0))
2368 TREE_VISITED (current_arg
) = 1;
2369 arg_positions
.safe_push (i
+ 1);
2373 if (arg_positions
.is_empty ())
2377 FOR_EACH_VEC_ELT (arg_positions
, i
, pos
)
2379 arg
= argarray
[pos
- 1];
2380 if (EXPR_HAS_LOCATION (arg
))
2381 richloc
.add_range (EXPR_LOCATION (arg
), false);
2384 warning_at_rich_loc_n (&richloc
, OPT_Wrestrict
, arg_positions
.length (),
2385 "passing argument %i to restrict-qualified parameter"
2386 " aliases with argument %Z",
2387 "passing argument %i to restrict-qualified parameter"
2388 " aliases with arguments %Z",
2389 param_pos
+ 1, arg_positions
.address (),
2390 arg_positions
.length ());
2393 /* Callback function to determine whether an expression TP or one of its
2394 subexpressions comes from macro expansion. Used to suppress bogus
2398 expr_from_macro_expansion_r (tree
*tp
, int *, void *)
2400 if (CAN_HAVE_LOCATION_P (*tp
)
2401 && from_macro_expansion_at (EXPR_LOCATION (*tp
)))
2402 return integer_zero_node
;
2407 /* Possibly warn when an if-else has identical branches. */
2410 do_warn_duplicated_branches (tree expr
)
2412 tree thenb
= COND_EXPR_THEN (expr
);
2413 tree elseb
= COND_EXPR_ELSE (expr
);
2415 /* Don't bother if any of the branches is missing. */
2416 if (thenb
== NULL_TREE
|| elseb
== NULL_TREE
)
2419 /* And don't warn for empty statements. */
2420 if (TREE_CODE (thenb
) == NOP_EXPR
2421 && TREE_TYPE (thenb
) == void_type_node
2422 && TREE_OPERAND (thenb
, 0) == size_zero_node
)
2425 /* ... or empty branches. */
2426 if (TREE_CODE (thenb
) == STATEMENT_LIST
2427 && STATEMENT_LIST_HEAD (thenb
) == NULL
)
2430 /* Compute the hash of the then branch. */
2431 inchash::hash
hstate0 (0);
2432 inchash::add_expr (thenb
, hstate0
);
2433 hashval_t h0
= hstate0
.end ();
2435 /* Compute the hash of the else branch. */
2436 inchash::hash
hstate1 (0);
2437 inchash::add_expr (elseb
, hstate1
);
2438 hashval_t h1
= hstate1
.end ();
2440 /* Compare the hashes. */
2442 && operand_equal_p (thenb
, elseb
, OEP_LEXICOGRAPHIC
)
2443 /* Don't warn if any of the branches or their subexpressions comes
2445 && !walk_tree_without_duplicates (&thenb
, expr_from_macro_expansion_r
,
2447 && !walk_tree_without_duplicates (&elseb
, expr_from_macro_expansion_r
,
2449 warning_at (EXPR_LOCATION (expr
), OPT_Wduplicated_branches
,
2450 "this condition has identical branches");
2453 /* Callback for c_genericize to implement -Wduplicated-branches. */
2456 do_warn_duplicated_branches_r (tree
*tp
, int *, void *)
2458 if (TREE_CODE (*tp
) == COND_EXPR
)
2459 do_warn_duplicated_branches (*tp
);
2463 /* Implementation of -Wmultistatement-macros. This warning warns about
2464 cases when a macro expands to multiple statements not wrapped in
2465 do {} while (0) or ({ }) and is used as a body of if/else/for/while
2466 conditionals. For example,
2468 #define DOIT x++; y++
2473 will increment y unconditionally.
2475 BODY_LOC is the location of the first token in the body after labels
2476 have been parsed, NEXT_LOC is the location of the next token after the
2477 body of the conditional has been parsed, and GUARD_LOC is the location
2478 of the conditional. */
2481 warn_for_multistatement_macros (location_t body_loc
, location_t next_loc
,
2482 location_t guard_loc
, enum rid keyword
)
2484 if (!warn_multistatement_macros
)
2487 /* Ain't got time to waste. We only care about macros here. */
2488 if (!from_macro_expansion_at (body_loc
)
2489 || !from_macro_expansion_at (next_loc
))
2492 /* Let's skip macros defined in system headers. */
2493 if (in_system_header_at (body_loc
)
2494 || in_system_header_at (next_loc
))
2497 /* Find the actual tokens in the macro definition. BODY_LOC and
2498 NEXT_LOC have to come from the same spelling location, but they
2499 will resolve to different locations in the context of the macro
2501 location_t body_loc_exp
2502 = linemap_resolve_location (line_table
, body_loc
,
2503 LRK_MACRO_DEFINITION_LOCATION
, NULL
);
2504 location_t next_loc_exp
2505 = linemap_resolve_location (line_table
, next_loc
,
2506 LRK_MACRO_DEFINITION_LOCATION
, NULL
);
2507 location_t guard_loc_exp
2508 = linemap_resolve_location (line_table
, guard_loc
,
2509 LRK_MACRO_DEFINITION_LOCATION
, NULL
);
2511 /* These are some funky cases we don't want to warn about. */
2512 if (body_loc_exp
== guard_loc_exp
2513 || next_loc_exp
== guard_loc_exp
2514 || body_loc_exp
== next_loc_exp
)
2517 /* Find the macro maps for the macro expansions. */
2518 const line_map
*body_map
= linemap_lookup (line_table
, body_loc
);
2519 const line_map
*next_map
= linemap_lookup (line_table
, next_loc
);
2520 const line_map
*guard_map
= linemap_lookup (line_table
, guard_loc
);
2522 /* Now see if the following token (after the body) is coming from the
2523 same macro expansion. If it is, it might be a problem. */
2524 if (body_map
!= next_map
)
2527 /* The conditional itself must not come from the same expansion, because
2528 we don't want to warn about
2529 #define IF if (x) x++; y++
2531 if (guard_map
== body_map
)
2534 /* Handle the case where NEXT and BODY come from the same expansion while
2535 GUARD doesn't, yet we shouldn't warn. E.g.
2537 #define GUARD if (...)
2538 #define GUARD2 GUARD
2540 and in the definition of another macro:
2546 while (linemap_macro_expansion_map_p (guard_map
))
2548 const line_map_macro
*mm
= linemap_check_macro (guard_map
);
2549 guard_loc_exp
= MACRO_MAP_EXPANSION_POINT_LOCATION (mm
);
2550 guard_map
= linemap_lookup (line_table
, guard_loc_exp
);
2551 if (guard_map
== body_map
)
2555 if (warning_at (body_loc
, OPT_Wmultistatement_macros
,
2556 "macro expands to multiple statements"))
2557 inform (guard_loc
, "some parts of macro expansion are not guarded by "
2558 "this %qs clause", guard_tinfo_to_string (keyword
));