+2005-06-28 DJ Delorie <dj@redhat.com>
+
+ * c-decl.c (pop_scope): Move warning control into warning call.
+ (diagnose_mismatched_decls): Likewise.
+ (pushdecl): Likewise.
+ (start_decl): Likewise.
+ (grokparms): Likewise.
+ (start_function): Likewise.
+ (store_parm_decls_newstyle): Likewise.
+ (store_parm_decls_oldstyle): Likewise.
+ (finish_function): Likewise.
+ (declspecs_add_scspec): Likewise.
+ * c-format.c (decode_format_attr): Likewise.
+ (maybe_read_dollar_number): Likewise.
+ (avoid_dollar_number): Likewise.
+ (finish_dollar_format_checking): Likewise.
+ (check_format_info): Likewise.
+ (check_format_info_main): Likewise.
+ (check_format_types): Likewise.
+ (format_type_warning): Likewise.
+ * c-typeck.c (function_types_compatible_p): Likewise.
+ (build_array_ref): Likewise.
+ (convert_arguments): Likewise.
+ (build_c_cast): Likewise.
+ (store_init_value): Likewise.
+ (process_init_element): Likewise.
+ (c_start_case): Likewise.
+ * stor-layout.c (finalize_record_size): Likewise.
+ * tree-cfg.c (execute_warn_function_noreturn): Likewise.
+ * tree-inline.c (expand_call_inline): Likewise.
+
2005-06-28 Uros Bizjak <uros@kss-loka.si>
PR target/22134
case VAR_DECL:
/* Warnings for unused variables. */
- if (warn_unused_variable
- && !TREE_USED (p)
+ if (!TREE_USED (p)
&& !DECL_IN_SYSTEM_HEADER (p)
&& DECL_NAME (p)
&& !DECL_ARTIFICIAL (p)
&& scope != file_scope
&& scope != external_scope)
- warning (0, "%Junused variable %qD", p, p);
+ warning (OPT_Wunused_variable, "%Junused variable %qD", p, p);
if (b->inner_comp)
{
}
else if (warn_traditional)
{
- warning (0, "%Jnon-static declaration of %qD follows "
- "static declaration", newdecl, newdecl);
+ warning (OPT_Wtraditional, "%Jnon-static declaration of %qD "
+ "follows static declaration", newdecl, newdecl);
warned = true;
}
}
}
else if (warn_traditional)
{
- warning (0, "%Jnon-static declaration of %qD follows "
- "static declaration", newdecl, newdecl);
+ warning (OPT_Wtraditional, "%Jnon-static declaration of %qD "
+ "follows static declaration", newdecl, newdecl);
warned = true;
}
}
&& !(TREE_CODE (newdecl) == PARM_DECL
&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl)))
{
- warning (0, "%Jredundant redeclaration of %qD", newdecl, newdecl);
+ warning (OPT_Wredundant_decls, "%Jredundant redeclaration of %qD",
+ newdecl, newdecl);
warned = true;
}
visdecl = b->decl;
vistype = TREE_TYPE (visdecl);
}
- if (warn_nested_externs
- && scope != file_scope
+ if (scope != file_scope
&& !DECL_IN_SYSTEM_HEADER (x))
- warning (0, "nested extern declaration of %qD", x);
+ warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
while (b && !B_IN_EXTERNAL_SCOPE (b))
{
if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl)))
- warning (0, "%J%qD is usually a function", decl, decl);
+ warning (OPT_Wmain, "%J%qD is usually a function", decl, decl);
if (initialized)
/* Is it valid for this decl to have an initializer at all?
{
tree arg_types = arg_info->types;
- if (warn_strict_prototypes && arg_types == 0 && !funcdef_flag
- && !in_system_header)
- warning (0, "function declaration isn%'t a prototype");
+ if (arg_types == 0 && !funcdef_flag && !in_system_header)
+ warning (OPT_Wstrict_prototypes,
+ "function declaration isn%'t a prototype");
if (arg_types == error_mark_node)
return 0; /* don't set TYPE_ARG_TYPES in this case */
&& old_decl != error_mark_node
&& TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
&& C_DECL_ISNT_PROTOTYPE (old_decl))
- warning (0, "function declaration isn%'t a prototype");
+ warning (OPT_Wstrict_prototypes,
+ "function declaration isn%'t a prototype");
/* Optionally warn of any global def with no previous prototype. */
else if (warn_missing_prototypes
&& old_decl != error_mark_node
&& TREE_PUBLIC (decl1)
&& !MAIN_NAME_P (DECL_NAME (decl1))
&& C_DECL_ISNT_PROTOTYPE (old_decl))
- warning (0, "%Jno previous prototype for %qD", decl1, decl1);
+ warning (OPT_Wmissing_prototypes, "%Jno previous prototype for %qD",
+ decl1, decl1);
/* Optionally warn of any def with no previous prototype
if the function has already been used. */
else if (warn_missing_prototypes
&& old_decl != error_mark_node
&& TREE_USED (old_decl)
&& TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
- warning (0, "%J%qD was used with no prototype before its definition",
+ warning (OPT_Wmissing_prototypes,
+ "%J%qD was used with no prototype before its definition",
decl1, decl1);
/* Optionally warn of any global def with no previous declaration. */
else if (warn_missing_declarations
&& TREE_PUBLIC (decl1)
&& old_decl == 0
&& !MAIN_NAME_P (DECL_NAME (decl1)))
- warning (0, "%Jno previous declaration for %qD", decl1, decl1);
+ warning (OPT_Wmissing_declarations, "%Jno previous declaration for %qD",
+ decl1, decl1);
/* Optionally warn of any def with no previous declaration
if the function has already been used. */
else if (warn_missing_declarations
&& old_decl != error_mark_node
&& TREE_USED (old_decl)
&& C_DECL_IMPLICIT (old_decl))
- warning (0, "%J%qD was used with no declaration before its definition",
+ warning (OPT_Wmissing_declarations,
+ "%J%qD was used with no declaration before its definition",
decl1, decl1);
/* This is a definition, not a reference.
warning if we got here because ARG_INFO_TYPES was error_mark_node
(this happens when a function definition has just an ellipsis in
its parameter list). */
- else if (warn_traditional && !in_system_header && !current_function_scope
+ else if (!in_system_header && !current_function_scope
&& arg_info->types != error_mark_node)
- warning (0, "%Jtraditional C rejects ISO C style function definitions",
+ warning (OPT_Wtraditional,
+ "%Jtraditional C rejects ISO C style function definitions",
fndecl);
/* Now make all the parameter declarations visible in the function body.
if (flag_isoc99)
pedwarn ("%Jtype of %qD defaults to %<int%>", decl, decl);
else if (extra_warnings)
- warning (0, "%Jtype of %qD defaults to %<int%>", decl, decl);
+ warning (OPT_Wextra, "%Jtype of %qD defaults to %<int%>",
+ decl, decl);
}
TREE_PURPOSE (parm) = decl;
inline function, as we might never be compiled separately. */
&& DECL_INLINE (fndecl))
{
- warning (0, "no return statement in function returning non-void");
+ warning (OPT_Wreturn_type,
+ "no return statement in function returning non-void");
TREE_NO_WARNING (fndecl) = 1;
}
if (extra_warnings
&& current_function_returns_value
&& current_function_returns_null)
- warning (0, "this function may return with or without a value");
+ warning (OPT_Wextra, "this function may return with or without a value");
/* Store the end of the function, so that we get good line number
info for the epilogue. */
&& C_IS_RESERVED_WORD (scspec));
i = C_RID_CODE (scspec);
if (extra_warnings && specs->non_sc_seen_p)
- warning (0, "%qE is not at beginning of declaration", scspec);
+ warning (OPT_Wextra, "%qE is not at beginning of declaration", scspec);
switch (i)
{
case RID_INLINE:
if (info->format_type == format_type_error)
{
gcc_assert (!validated_p);
- warning (0, "%qE is an unrecognized format function type",
+ warning (OPT_Wformat, "%qE is an unrecognized format function type",
format_type_id);
return false;
}
{
if (dollar_needed)
{
- warning (0, "missing $ operand number in format");
+ warning (OPT_Wformat, "missing $ operand number in format");
return -1;
}
else
{
if (dollar_needed)
{
- warning (0, "missing $ operand number in format");
+ warning (OPT_Wformat, "missing $ operand number in format");
return -1;
}
else
*format = fcp + 1;
if (pedantic && !dollar_format_warned)
{
- warning (0, "%s does not support %%n$ operand number formats",
+ warning (OPT_Wformat, "%s does not support %%n$ operand number formats",
C_STD_NAME (STD_EXT));
dollar_format_warned = 1;
}
if (overflow_flag || argnum == 0
|| (dollar_first_arg_num && argnum > dollar_arguments_count))
{
- warning (0, "operand number out of range in format");
+ warning (OPT_Wformat, "operand number out of range in format");
return -1;
}
if (argnum > dollar_max_arg_used)
&& dollar_arguments_used[argnum - 1] == 1)
{
dollar_arguments_used[argnum - 1] = 2;
- warning (0, "format argument %d used more than once in %s format",
+ warning (OPT_Wformat, "format argument %d used more than once in %s format",
argnum, fki->name);
}
else
format++;
if (*format == '$')
{
- warning (0, "$ operand number used after format without operand number");
+ warning (OPT_Wformat, "$ operand number used after format without operand number");
return true;
}
return false;
|| dollar_arguments_pointer_p[i]))
found_pointer_gap = true;
else
- warning (0, "format argument %d unused before used argument %d in $-style format",
+ warning (OPT_Wformat,
+ "format argument %d unused before used argument %d in $-style format",
i + 1, dollar_max_arg_used);
}
}
If the format is an empty string, this should be counted similarly to the
case of extra format arguments. */
if (res.number_extra_args > 0 && res.number_non_literal == 0
- && res.number_other == 0 && warn_format_extra_args)
- warning (0, "too many arguments for format");
+ && res.number_other == 0)
+ warning (OPT_Wformat_extra_args, "too many arguments for format");
if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
- && res.number_other == 0 && warn_format_extra_args)
- warning (0, "unused arguments in $-style format");
+ && res.number_other == 0)
+ warning (OPT_Wformat_extra_args, "unused arguments in $-style format");
if (res.number_empty > 0 && res.number_non_literal == 0
- && res.number_other == 0 && warn_format_zero_length)
- warning (0, "zero-length %s format string",
+ && res.number_other == 0)
+ warning (OPT_Wformat_zero_length, "zero-length %s format string",
format_types[info->format_type].name);
if (res.number_wide > 0)
- warning (0, "format is a wide character string");
+ warning (OPT_Wformat, "format is a wide character string");
if (res.number_unterminated > 0)
- warning (0, "unterminated format string");
+ warning (OPT_Wformat, "unterminated format string");
}
/* Callback from check_function_arguments_recurse to check a
if (*format_chars == 0)
{
if (format_chars - orig_format_chars != format_length)
- warning (0, "embedded %<\\0%> in format");
+ warning (OPT_Wformat, "embedded %<\\0%> in format");
if (info->first_arg_num != 0 && params != 0
&& has_operand_number <= 0)
{
continue;
if (*format_chars == 0)
{
- warning (0, "spurious trailing %<%%%> in format");
+ warning (OPT_Wformat, "spurious trailing %<%%%> in format");
continue;
}
if (*format_chars == '%')
*format_chars, NULL);
if (strchr (flag_chars, *format_chars) != 0)
{
- warning (0, "repeated %s in format", _(s->name));
+ warning (OPT_Wformat, "repeated %s in format", _(s->name));
}
else
{
++format_chars;
if (*format_chars == 0)
{
- warning (0, "missing fill character at end of strfmon format");
+ warning (OPT_Wformat, "missing fill character at end of strfmon format");
return;
}
}
{
if (params == 0)
{
- warning (0, "too few arguments for format");
+ warning (OPT_Wformat, "too few arguments for format");
return;
}
cur_param = TREE_VALUE (params);
}
if (found_width && !non_zero_width_char &&
(fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
- warning (0, "zero width in %s format", fki->name);
+ warning (OPT_Wformat, "zero width in %s format", fki->name);
if (found_width)
{
i = strlen (flag_chars);
flag_chars[i++] = fki->left_precision_char;
flag_chars[i] = 0;
if (!ISDIGIT (*format_chars))
- warning (0, "empty left precision in %s format", fki->name);
+ warning (OPT_Wformat, "empty left precision in %s format", fki->name);
while (ISDIGIT (*format_chars))
++format_chars;
}
{
if (params == 0)
{
- warning (0, "too few arguments for format");
+ warning (OPT_Wformat, "too few arguments for format");
return;
}
cur_param = TREE_VALUE (params);
{
if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
&& !ISDIGIT (*format_chars))
- warning (0, "empty precision in %s format", fki->name);
+ warning (OPT_Wformat, "empty precision in %s format", fki->name);
while (ISDIGIT (*format_chars))
++format_chars;
}
{
/* Warn if the length modifier is non-standard. */
if (ADJ_STD (length_chars_std) > C_STD_VER)
- warning (0, "%s does not support the %qs %s length modifier",
+ warning (OPT_Wformat,
+ "%s does not support the %qs %s length modifier",
C_STD_NAME (length_chars_std), length_chars,
fki->name);
}
{
const format_flag_spec *s = get_flag_spec (flag_specs,
*format_chars, NULL);
- warning (0, "repeated %s in format", _(s->name));
+ warning (OPT_Wformat, "repeated %s in format", _(s->name));
}
else
{
|| (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
&& format_char == '%'))
{
- warning (0, "conversion lacks type at end of format");
+ warning (OPT_Wformat, "conversion lacks type at end of format");
continue;
}
format_chars++;
if (fci->format_chars == 0)
{
if (ISGRAPH (format_char))
- warning (0, "unknown conversion type character %qc in format",
+ warning (OPT_Wformat, "unknown conversion type character %qc in format",
format_char);
else
- warning (0, "unknown conversion type character 0x%x in format",
+ warning (OPT_Wformat, "unknown conversion type character 0x%x in format",
format_char);
continue;
}
if (pedantic)
{
if (ADJ_STD (fci->std) > C_STD_VER)
- warning (0, "%s does not support the %<%%%c%> %s format",
+ warning (OPT_Wformat, "%s does not support the %<%%%c%> %s format",
C_STD_NAME (fci->std), format_char, fki->name);
}
continue;
if (strchr (fci->flag_chars, flag_chars[i]) == 0)
{
- warning (0, "%s used with %<%%%c%> %s format",
+ warning (OPT_Wformat, "%s used with %<%%%c%> %s format",
_(s->name), format_char, fki->name);
d++;
continue;
{
const format_flag_spec *t;
if (ADJ_STD (s->std) > C_STD_VER)
- warning (0, "%s does not support %s",
+ warning (OPT_Wformat, "%s does not support %s",
C_STD_NAME (s->std), _(s->long_name));
t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
? t->long_name
: s->long_name);
if (ADJ_STD (t->std) > C_STD_VER)
- warning (0, "%s does not support %s with the %<%%%c%> %s format",
+ warning (OPT_Wformat,
+ "%s does not support %s with the %<%%%c%> %s format",
C_STD_NAME (t->std), _(long_name),
format_char, fki->name);
}
if (bad_flag_pairs[i].ignored)
{
if (bad_flag_pairs[i].predicate != 0)
- warning (0, "%s ignored with %s and %<%%%c%> %s format",
+ warning (OPT_Wformat,
+ "%s ignored with %s and %<%%%c%> %s format",
_(s->name), _(t->name), format_char,
fki->name);
else
- warning (0, "%s ignored with %s in %s format",
+ warning (OPT_Wformat, "%s ignored with %s in %s format",
_(s->name), _(t->name), fki->name);
}
else
{
if (bad_flag_pairs[i].predicate != 0)
- warning (0, "use of %s and %s together with %<%%%c%> %s format",
+ warning (OPT_Wformat,
+ "use of %s and %s together with %<%%%c%> %s format",
_(s->name), _(t->name), format_char,
fki->name);
else
- warning (0, "use of %s and %s together in %s format",
+ warning (OPT_Wformat, "use of %s and %s together in %s format",
_(s->name), _(t->name), fki->name);
}
}
else if (strchr (fci->flags2, '2') != 0)
y2k_level = 2;
if (y2k_level == 3)
- warning (0, "%<%%%c%> yields only last 2 digits of year in some locales",
- format_char);
+ warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of "
+ "year in some locales", format_char);
else if (y2k_level == 2)
- warning (0, "%<%%%c%> yields only last 2 digits of year", format_char);
+ warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of "
+ "year", format_char);
}
if (strchr (fci->flags2, '[') != 0)
++format_chars;
if (*format_chars != ']')
/* The end of the format string was reached. */
- warning (0, "no closing %<]%> for %<%%[%> format");
+ warning (OPT_Wformat, "no closing %<]%> for %<%%[%> format");
}
wanted_type = 0;
wanted_type_std = fci->types[length_chars_val].std;
if (wanted_type == 0)
{
- warning (0, "use of %qs length modifier with %qc type character",
+ warning (OPT_Wformat,
+ "use of %qs length modifier with %qc type character",
length_chars, format_char);
/* Heuristic: skip one argument when an invalid length/type
combination is encountered. */
arg_num++;
if (params == 0)
{
- warning (0, "too few arguments for format");
+ warning (OPT_Wformat, "too few arguments for format");
return;
}
params = TREE_CHAIN (params);
&& ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
{
if (ADJ_STD (wanted_type_std) > C_STD_VER)
- warning (0, "%s does not support the %<%%%s%c%> %s format",
+ warning (OPT_Wformat,
+ "%s does not support the %<%%%s%c%> %s format",
C_STD_NAME (wanted_type_std), length_chars,
format_char, fki->name);
}
if (main_arg_num != 0)
{
if (suppressed)
- warning (0, "operand number specified with suppressed assignment");
+ warning (OPT_Wformat, "operand number specified with "
+ "suppressed assignment");
else
- warning (0, "operand number specified for format taking no argument");
+ warning (OPT_Wformat, "operand number specified for format "
+ "taking no argument");
}
}
else
++arg_num;
if (has_operand_number > 0)
{
- warning (0, "missing $ operand number in format");
+ warning (OPT_Wformat, "missing $ operand number in format");
return;
}
else
{
if (params == 0)
{
- warning (0, "too few arguments for format");
+ warning (OPT_Wformat, "too few arguments for format");
return;
}
&& i == 0
&& cur_param != 0
&& integer_zerop (cur_param))
- warning (0, "writing through null pointer (argument %d)",
- arg_num);
+ warning (OPT_Wformat, "writing through null pointer "
+ "(argument %d)", arg_num);
/* Check for reading through a NULL pointer. */
if (types->reading_from_flag
&& i == 0
&& cur_param != 0
&& integer_zerop (cur_param))
- warning (0, "reading through null pointer (argument %d)",
- arg_num);
+ warning (OPT_Wformat, "reading through null pointer "
+ "(argument %d)", arg_num);
if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
cur_param = TREE_OPERAND (cur_param, 0);
&& (CONSTANT_CLASS_P (cur_param)
|| (DECL_P (cur_param)
&& TREE_READONLY (cur_param))))))
- warning (0, "writing into constant object (argument %d)",
- arg_num);
+ warning (OPT_Wformat, "writing into constant object "
+ "(argument %d)", arg_num);
/* If there are extra type qualifiers beyond the first
indirection, then this makes the types technically
&& (TYPE_READONLY (cur_type)
|| TYPE_VOLATILE (cur_type)
|| TYPE_RESTRICT (cur_type)))
- warning (0, "extra type qualifiers in format argument "
- "(argument %d)",
+ warning (OPT_Wformat, "extra type qualifiers in format "
+ "argument (argument %d)",
arg_num);
}
if (wanted_type_name)
{
if (descr)
- warning (0, "%s should have type %<%s%s%>, but argument %d has type %qT",
+ warning (OPT_Wformat, "%s should have type %<%s%s%>, "
+ "but argument %d has type %qT",
descr, wanted_type_name, p, arg_num, arg_type);
else
- warning (0, "format %q.*s expects type %<%s%s%>, but argument %d has type %qT",
+ warning (OPT_Wformat, "format %q.*s expects type %<%s%s%>, "
+ "but argument %d has type %qT",
format_length, format_start, wanted_type_name, p,
arg_num, arg_type);
}
else
{
if (descr)
- warning (0, "%s should have type %<%T%s%>, but argument %d has type %qT",
+ warning (OPT_Wformat, "%s should have type %<%T%s%>, "
+ "but argument %d has type %qT",
descr, wanted_type, p, arg_num, arg_type);
else
- warning (0, "format %q.*s expects type %<%T%s%>, but argument %d has type %qT",
+ warning (OPT_Wformat, "format %q.*s expects type %<%T%s%>, "
+ "but argument %d has type %qT",
format_length, format_start, wanted_type, p, arg_num, arg_type);
}
}
return 0;
/* If one of these types comes from a non-prototype fn definition,
compare that with the other type's arglist.
- If they don't match, ask for a warning (0, but no error). */
+ If they don't match, ask for a warning (but no error). */
if (TYPE_ACTUAL_ARG_TYPES (f1)
&& 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
val = 2;
deliberately. ??? Existing practice has also been to warn only
when the char index is syntactically the index, not for
char[array]. */
- if (warn_char_subscripts && !swapped
+ if (!swapped
&& TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
- warning (0, "array subscript has type %<char%>");
+ warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
/* Apply default promotions *after* noticing character types. */
index = default_conversion (index);
and the actual arg is that enum type. */
;
else if (formal_prec != TYPE_PRECISION (type1))
- warning (0, "passing argument %d of %qE with different "
- "width due to prototype", argnum, rname);
+ warning (OPT_Wconversion, "passing argument %d of %qE "
+ "with different width due to prototype",
+ argnum, rname);
else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
;
/* Don't complain if the formal parameter type
&& TYPE_UNSIGNED (TREE_TYPE (val)))
;
else if (TYPE_UNSIGNED (type))
- warning (0, "passing argument %d of %qE as unsigned "
- "due to prototype", argnum, rname);
+ warning (OPT_Wconversion, "passing argument %d of %qE "
+ "as unsigned due to prototype",
+ argnum, rname);
else
- warning (0, "passing argument %d of %qE as signed "
- "due to prototype", argnum, rname);
+ warning (OPT_Wconversion, "passing argument %d of %qE "
+ "as signed due to prototype", argnum, rname);
}
}
}
/* Warn about possible alignment problems. */
- if (STRICT_ALIGNMENT && warn_cast_align
+ if (STRICT_ALIGNMENT
&& TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (otype) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
|| TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
&& TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
&& TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
- warning (0, "cast increases required alignment of target type");
+ warning (OPT_Wcast_align,
+ "cast increases required alignment of target type");
- if (warn_pointer_to_int_cast
- && TREE_CODE (type) == INTEGER_TYPE
+ if (TREE_CODE (type) == INTEGER_TYPE
&& TREE_CODE (otype) == POINTER_TYPE
&& TYPE_PRECISION (type) != TYPE_PRECISION (otype)
&& !TREE_CONSTANT (value))
- warning (0, "cast from pointer to integer of different size");
+ warning (OPT_Wpointer_to_int_cast,
+ "cast from pointer to integer of different size");
- if (warn_bad_function_cast
- && TREE_CODE (value) == CALL_EXPR
+ if (TREE_CODE (value) == CALL_EXPR
&& TREE_CODE (type) != TREE_CODE (otype))
- warning (0, "cast from function call of type %qT to non-matching "
- "type %qT", otype, type);
+ warning (OPT_Wbad_function_cast, "cast from function call of type %qT "
+ "to non-matching type %qT", otype, type);
- if (warn_int_to_pointer_cast
- && TREE_CODE (type) == POINTER_TYPE
+ if (TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (otype) == INTEGER_TYPE
&& TYPE_PRECISION (type) != TYPE_PRECISION (otype)
/* Don't warn about converting any constant. */
&& !TREE_CONSTANT (value))
- warning (0, "cast to pointer from integer of different size");
+ warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer "
+ "of different size");
if (flag_strict_aliasing && warn_strict_aliasing
&& TREE_CODE (type) == POINTER_TYPE
/* Casting the address of an object to non void pointer. Warn
if the cast breaks type based aliasing. */
if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
- warning (0, "type-punning to incomplete type might break strict-aliasing rules");
+ warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
+ "might break strict-aliasing rules");
else
{
HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
if (!alias_sets_conflict_p (set1, set2))
- warning (0, "dereferencing type-punned pointer will break strict-aliasing rules");
+ warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
+ "pointer will break strict-aliasing rules");
else if (warn_strict_aliasing > 1
&& !alias_sets_might_conflict_p (set1, set2))
- warning (0, "dereferencing type-punned pointer might break strict-aliasing rules");
+ warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
+ "pointer might break strict-aliasing rules");
}
}
/* Store the expression if valid; else report error. */
- if (warn_traditional && !in_system_header
+ if (!in_system_header
&& AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
- warning (0, "traditional C rejects automatic aggregate initialization");
+ warning (OPT_Wtraditional, "traditional C rejects automatic "
+ "aggregate initialization");
DECL_INITIAL (decl) = value;
again on the assumption that this must be conditional on
__STDC__ anyway (and we've already complained about the
member-designator already). */
- if (warn_traditional && !in_system_header && !constructor_designated
+ if (!in_system_header && !constructor_designated
&& !(value.value && (integer_zerop (value.value)
|| real_zerop (value.value))))
- warning (0, "traditional C rejects initialization of unions");
+ warning (OPT_Wtraditional, "traditional C rejects initialization "
+ "of unions");
/* Accept a string constant to initialize a subarray. */
if (value.value != 0
{
type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
- if (warn_traditional && !in_system_header
+ if (!in_system_header
&& (type == long_integer_type_node
|| type == long_unsigned_type_node))
- warning (0, "%<long%> switch expression not converted to "
- "%<int%> in ISO C");
+ warning (OPT_Wtraditional, "%<long%> switch expression not "
+ "converted to %<int%> in ISO C");
exp = default_conversion (exp);
type = TREE_TYPE (exp);
TYPE_SIZE_UNIT (rli->t)
= round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t));
- if (warn_padded && TREE_CONSTANT (unpadded_size)
+ if (TREE_CONSTANT (unpadded_size)
&& simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
- warning (0, "padding struct size to alignment boundary");
+ warning (OPT_Wpadded, "padding struct size to alignment boundary");
if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
&& TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
if (STRICT_ALIGNMENT)
- warning (OPT_Wattributes, "packed attribute causes inefficient "
+ warning (OPT_Wpacked, "packed attribute causes inefficient "
"alignment for %qs", name);
else
- warning (OPT_Wattributes,
+ warning (OPT_Wpacked,
"packed attribute is unnecessary for %qs", name);
}
else
{
if (STRICT_ALIGNMENT)
- warning (OPT_Wattributes,
+ warning (OPT_Wpacked,
"packed attribute causes inefficient alignment");
else
- warning (OPT_Wattributes, "packed attribute is unnecessary");
+ warning (OPT_Wpacked, "packed attribute is unnecessary");
}
}
}
&& !TREE_THIS_VOLATILE (cfun->decl)
&& EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 0
&& !lang_hooks.function.missing_noreturn_ok_p (cfun->decl))
- warning (0, "%Jfunction might be possible candidate for "
- "attribute %<noreturn%>",
+ warning (OPT_Wmissing_noreturn, "%Jfunction might be possible candidate "
+ "for attribute %<noreturn%>",
cfun->decl);
}
/* Avoid warnings during early inline pass. */
&& (!flag_unit_at_a_time || cgraph_global_info_ready))
{
- warning (0, "%Jinlining failed in call to %qF: %s", fn, fn, reason);
- warning (0, "called from here");
+ warning (OPT_Winline, "%Jinlining failed in call to %qF: %s",
+ fn, fn, reason);
+ warning (OPT_Winline, "called from here");
}
goto egress;
}
OSDN Git Service
