diff -u -p -r1.525 c-common.c --- gcc/c-common.c 30 Jun 2004 22:27:59 -0000 1.525 +++ gcc/c-common.c 11 Jul 2004 23:57:01 -0000 @@ -1439,7 +1439,7 @@ check_case_value (tree value) that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ tree -c_common_type_for_size (unsigned int bits, int unsignedp) +c_common_type_for_size (unsigned int bits, bool unsignedp) { if (bits == TYPE_PRECISION (integer_type_node)) return unsignedp ? unsigned_type_node : integer_type_node; @@ -1485,7 +1485,7 @@ static GTY(()) tree registered_builtin_t then UNSIGNEDP selects between signed and unsigned types. */ tree -c_common_type_for_mode (enum machine_mode mode, int unsignedp) +c_common_type_for_mode (enum machine_mode mode, bool unsignedp) { tree t; @@ -1588,7 +1588,7 @@ c_common_unsigned_type (tree type) if (type1 == intQI_type_node) return unsigned_intQI_type_node; - return c_common_signed_or_unsigned_type (1, type); + return c_common_signed_or_unsigned_type (true, type); } /* Return a signed type the same as TYPE in other respects. */ @@ -1622,14 +1622,14 @@ c_common_signed_type (tree type) if (type1 == unsigned_intQI_type_node) return intQI_type_node; - return c_common_signed_or_unsigned_type (0, type); + return c_common_signed_or_unsigned_type (false, type); } /* Return a type the same as TYPE except unsigned or signed according to UNSIGNEDP. */ tree -c_common_signed_or_unsigned_type (int unsignedp, tree type) +c_common_signed_or_unsigned_type (bool unsignedp, tree type) { if (! INTEGRAL_TYPE_P (type) || TYPE_UNSIGNED (type) == unsignedp) @@ -1692,7 +1692,7 @@ c_register_builtin_type (tree type, cons signed or unsigned type, UNSIGNEDP says which. */ unsigned int -min_precision (tree value, int unsignedp) +min_precision (tree value, bool unsignedp) { int log; @@ -1802,7 +1802,7 @@ shorten_compare (tree *op0_ptr, tree *op tree type; tree op0 = *op0_ptr; tree op1 = *op1_ptr; - int unsignedp0, unsignedp1; + bool unsignedp0, unsignedp1; int real1, real2; tree primop0, primop1; enum tree_code code = *rescode_ptr; @@ -1833,7 +1833,7 @@ shorten_compare (tree *op0_ptr, tree *op && ! integer_zerop (primop1) && ! real_zerop (primop1)) { tree tem = primop0; - int temi = unsignedp0; + bool temi = unsignedp0; primop0 = primop1; primop1 = tem; tem = op0; @@ -1890,8 +1890,8 @@ shorten_compare (tree *op0_ptr, tree *op { int min_gt, max_gt, min_lt, max_lt; tree maxval, minval; - /* 1 if comparison is nominally unsigned. */ - int unsignedp = TYPE_UNSIGNED (*restype_ptr); + /* true if comparison is nominally unsigned. */ + bool unsignedp = TYPE_UNSIGNED (*restype_ptr); tree val; type = c_common_signed_or_unsigned_type (unsignedp0, @@ -2633,18 +2636,19 @@ c_common_get_alias_set (tree t) flag controls whether we should diagnose possibly ill-formed constructs or not. */ tree -c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain) +c_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain) { const char *op_name; tree value = NULL; enum tree_code type_code = TREE_CODE (type); - my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720); - op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__"; + my_friendly_assert (op == (enum tree_code) SIZEOF_EXPR + || op == (enum tree_code) ALIGNOF_EXPR, 20020720); + op_name = (op == (enum tree_code) SIZEOF_EXPR) ? "sizeof" : "__alignof__"; if (type_code == FUNCTION_TYPE) { - if (op == SIZEOF_EXPR) + if (op == (enum tree_code) SIZEOF_EXPR) { if (complain && (pedantic || warn_pointer_arith)) pedwarn ("invalid application of `sizeof' to a function type"); @@ -3717,7 +3722,8 @@ c_expand_expr (tree exp, rtx target, enu literal, then return the variable. */ tree decl = COMPOUND_LITERAL_EXPR_DECL (exp); emit_local_var (decl); - return expand_expr_real (decl, target, tmode, modifier, alt_rtl); + return expand_expr_real (decl, target, tmode, + (enum expand_modifier) modifier, alt_rtl); } default: @@ -3732,8 +3738,8 @@ c_common_unsafe_for_reeval (tree exp) { /* Statement expressions may not be reevaluated, likewise compound literals. */ - if (TREE_CODE (exp) == STMT_EXPR - || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR) + if (TREE_CODE (exp) == (enum tree_code) STMT_EXPR + || TREE_CODE (exp) == (enum tree_code) COMPOUND_LITERAL_EXPR) return 2; /* Walk all other expressions. */ diff -u -p -r1.248 c-common.h --- gcc/c-common.h 30 Jun 2004 22:27:59 -0000 1.248 +++ gcc/c-common.h 11 Jul 2004 23:57:01 -0000 @@ -633,14 +633,14 @@ extern tree handle_format_attribute (tre extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *); extern int c_common_handle_option (size_t code, const char *arg, int value); extern bool c_common_missing_argument (const char *opt, size_t code); -extern tree c_common_type_for_mode (enum machine_mode, int); -extern tree c_common_type_for_size (unsigned int, int); +extern tree c_common_type_for_mode (enum machine_mode mode, bool unsignedp); +extern tree c_common_type_for_size (unsigned int bits, bool unsignedp); extern tree c_common_unsigned_type (tree); extern tree c_common_signed_type (tree); -extern tree c_common_signed_or_unsigned_type (int, tree); +extern tree c_common_signed_or_unsigned_type (bool unsignedp, tree type); extern tree c_common_truthvalue_conversion (tree); extern void c_apply_type_quals_to_decl (int, tree); -extern tree c_sizeof_or_alignof_type (tree, enum tree_code, int); +extern tree c_sizeof_or_alignof_type (tree, enum tree_code, bool complain); extern tree c_alignof_expr (tree); /* Print an error message for invalid operands to arith operation CODE. NOP_EXPR is used as a special case (see truthvalue_conversion). */ @@ -657,8 +657,10 @@ extern tree convert_and_check (tree, tre extern void overflow_warning (tree); extern void unsigned_conversion_warning (tree, tree); -#define c_sizeof(T) c_sizeof_or_alignof_type (T, SIZEOF_EXPR, 1) -#define c_alignof(T) c_sizeof_or_alignof_type (T, ALIGNOF_EXPR, 1) +#define c_sizeof(T) \ + c_sizeof_or_alignof_type (T, (enum tree_code) SIZEOF_EXPR, true) +#define c_alignof(T) \ + c_sizeof_or_alignof_type (T, (enum tree_code) ALIGNOF_EXPR, true) /* Subroutine of build_binary_op, used for comparison operations. See if the operands have both been converted from subword integer types @@ -666,7 +668,7 @@ extern void unsigned_conversion_warning extern tree shorten_compare (tree *, tree *, tree *, enum tree_code *); extern tree pointer_int_sum (enum tree_code, tree, tree); -extern unsigned int min_precision (tree, int); +extern unsigned int min_precision (tree value, bool unsignedp); /* Add qualifiers to a type, in the fashion for C. */ extern tree c_build_qualified_type (tree, int); diff -u -p -r1.523 c-decl.c --- gcc/c-decl.c 1 Jul 2004 01:12:11 -0000 1.523 +++ gcc/c-decl.c 11 Jul 2004 23:57:04 -0000 @@ -3094,7 +3096,8 @@ build_compound_literal (tree type, tree return error_mark_node; stmt = build_stmt (DECL_EXPR, decl); - complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt); + complit = build1 ((enum tree_code) COMPOUND_LITERAL_EXPR, + TREE_TYPE (decl), stmt); TREE_SIDE_EFFECTS (complit) = 1; layout_decl (decl, 0); @@ -5375,7 +5379,8 @@ finish_enum (tree enumtype, tree values, { tree pair, tem; tree minnode = 0, maxnode = 0; - int precision, unsign; + bool unsign; + unsigned int precision; bool toplevel = (file_scope == current_scope); struct lang_type *lt; Index: gcc/c-format.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/c-format.c,v retrieving revision 1.58 diff -u -p -r1.58 c-format.c --- gcc/c-format.c 30 Jun 2004 22:27:59 -0000 1.58 +++ gcc/c-format.c 11 Jul 2004 23:57:04 -0000 @@ -345,7 +345,7 @@ typedef struct /* Macros to fill out tables of these. */ #define NOARGUMENTS { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN } -#define BADLEN { 0, NULL, NULL } +#define BADLEN { STD_C89, NULL, NULL } #define NOLENGTHS { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN } @@ -508,29 +508,29 @@ static const format_length_info printf_l { { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 }, { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L }, - { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 }, - { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 }, - { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 }, - { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 }, - { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 }, - { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 }, - { NULL, 0, 0, NULL, 0, 0 } + { "q", FMT_LEN_ll, STD_EXT, NULL, FMT_LEN_none, STD_C89 }, + { "L", FMT_LEN_L, STD_C89, NULL, FMT_LEN_none, STD_C89 }, + { "z", FMT_LEN_z, STD_C99, NULL, FMT_LEN_none, STD_C89 }, + { "Z", FMT_LEN_z, STD_EXT, NULL, FMT_LEN_none, STD_C89 }, + { "t", FMT_LEN_t, STD_C99, NULL, FMT_LEN_none, STD_C89 }, + { "j", FMT_LEN_j, STD_C99, NULL, FMT_LEN_none, STD_C89 }, + { NULL, FMT_LEN_none, STD_C89, NULL, FMT_LEN_none, STD_C89 } }; /* Length specifiers valid for asm_fprintf. */ static const format_length_info asm_fprintf_length_specs[] = { { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 }, - { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 }, - { NULL, 0, 0, NULL, 0, 0 } + { "w", FMT_LEN_none, STD_C89, NULL, FMT_LEN_none, STD_C89 }, + { NULL, FMT_LEN_none, STD_C89, NULL, FMT_LEN_none, STD_C89 } }; /* Length specifiers valid for GCC diagnostics. */ static const format_length_info gcc_diag_length_specs[] = { { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 }, - { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 }, - { NULL, 0, 0, NULL, 0, 0 } + { "w", FMT_LEN_none, STD_C89, NULL, FMT_LEN_none, STD_C89 }, + { NULL, FMT_LEN_none, STD_C89, NULL, FMT_LEN_none, STD_C89 } }; /* The custom diagnostics all accept the same length specifiers. */ @@ -542,12 +542,12 @@ static const format_length_info scanf_le { { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 }, { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L }, - { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 }, - { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 }, - { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 }, - { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 }, - { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 }, - { NULL, 0, 0, NULL, 0, 0 } + { "q", FMT_LEN_ll, STD_EXT, NULL, FMT_LEN_none, STD_C89 }, + { "L", FMT_LEN_L, STD_C89, NULL, FMT_LEN_none, STD_C89 }, + { "z", FMT_LEN_z, STD_C99, NULL, FMT_LEN_none, STD_C89 }, + { "t", FMT_LEN_t, STD_C99, NULL, FMT_LEN_none, STD_C89 }, + { "j", FMT_LEN_j, STD_C99, NULL, FMT_LEN_none, STD_C89 }, + { NULL, FMT_LEN_none, STD_C89, NULL, FMT_LEN_none, STD_C89 } }; @@ -556,8 +556,8 @@ static const format_length_info scanf_le static const format_length_info strfmon_length_specs[] = { /* A GNU extension. */ - { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 }, - { NULL, 0, 0, NULL, 0, 0 } + { "L", FMT_LEN_L, STD_C89, NULL, FMT_LEN_none, STD_C89 }, + { NULL, FMT_LEN_none, STD_C89, NULL, FMT_LEN_none, STD_C89 } }; static const format_flag_spec printf_flag_specs[] = @@ -572,7 +572,7 @@ static const format_flag_spec printf_fla { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89 }, { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 }, - { 0, 0, 0, NULL, NULL, 0 } + { 0, 0, 0, NULL, NULL, STD_C89 } }; @@ -594,7 +594,7 @@ static const format_flag_spec asm_fprint { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89 }, { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 }, - { 0, 0, 0, NULL, NULL, 0 } + { 0, 0, 0, NULL, NULL, STD_C89 } }; static const format_flag_pair asm_fprintf_flag_pairs[] = @@ -618,7 +618,7 @@ static const format_flag_spec gcc_diag_f { 'q', 0, 0, N_("`q' flag"), N_("the `q' diagnostic flag"), STD_C89 }, { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 }, - { 0, 0, 0, NULL, NULL, 0 } + { 0, 0, 0, NULL, NULL, STD_C89 } }; #define gcc_cdiag_flag_specs gcc_diag_flag_specs @@ -630,7 +630,7 @@ static const format_flag_spec gcc_cxxdia { 'q', 0, 0, N_("`q' flag"), N_("the `q' diagnostic flag"), STD_C89 }, { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 }, - { 0, 0, 0, NULL, NULL, 0 } + { 0, 0, 0, NULL, NULL, STD_C89 } }; static const format_flag_spec scanf_flag_specs[] = @@ -641,7 +641,7 @@ static const format_flag_spec scanf_flag { 'L', 0, 0, N_("length modifier"), N_("length modifier in scanf format"), STD_C89 }, { '\'', 0, 0, N_("`'' flag"), N_("the `'' scanf flag"), STD_EXT }, { 'I', 0, 0, N_("`I' flag"), N_("the `I' scanf flag"), STD_EXT }, - { 0, 0, 0, NULL, NULL, 0 } + { 0, 0, 0, NULL, NULL, STD_C89 } }; @@ -663,7 +663,7 @@ static const format_flag_spec strftime_f { 'E', 0, 0, N_("`E' modifier"), N_("the `E' strftime modifier"), STD_C99 }, { 'O', 0, 0, N_("`O' modifier"), N_("the `O' strftime modifier"), STD_C99 }, { 'O', 'o', 0, NULL, N_("the `O' modifier"), STD_EXT }, - { 0, 0, 0, NULL, NULL, 0 } + { 0, 0, 0, NULL, NULL, STD_C89 } }; @@ -690,7 +690,7 @@ static const format_flag_spec strfmon_fl { '#', 0, 0, N_("left precision"), N_("left precision in strfmon format"), STD_C89 }, { 'p', 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 }, - { 0, 0, 0, NULL, NULL, 0 } + { 0, 0, 0, NULL, NULL, STD_C89 } }; static const format_flag_pair strfmon_flag_pairs[] = @@ -774,7 +774,7 @@ static const format_char_info print_char { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "R" }, /* GNU conversion specifiers. */ { "m", 0, STD_EXT, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL } }; static const format_char_info asm_fprintf_char_table[] = @@ -794,7 +794,7 @@ static const format_char_info asm_fprint { "U", 0, STD_C89, NOARGUMENTS, "", "" }, { "r", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, { "@", 0, STD_C89, NOARGUMENTS, "", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL } }; static const format_char_info gcc_diag_char_table[] = @@ -817,7 +817,7 @@ static const format_char_info gcc_diag_c { "<>'", 0, STD_C89, NOARGUMENTS, "", "" }, { "m", 0, STD_C89, NOARGUMENTS, "q", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL } }; static const format_char_info gcc_cdiag_char_table[] = @@ -840,7 +840,7 @@ static const format_char_info gcc_cdiag_ { "<>'", 0, STD_C89, NOARGUMENTS, "", "" }, { "m", 0, STD_C89, NOARGUMENTS, "q", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL } }; static const format_char_info gcc_cxxdiag_char_table[] = @@ -866,7 +866,7 @@ static const format_char_info gcc_cxxdia { "<>'", 0, STD_C89, NOARGUMENTS, "", "" }, { "m", 0, STD_C89, NOARGUMENTS, "q", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL } }; static const format_char_info scan_char_table[] = @@ -886,7 +886,7 @@ static const format_char_info scan_char_ /* X/Open conversion specifiers. */ { "C", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W" }, { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "W" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL } }; static const format_char_info time_char_table[] = @@ -913,13 +913,13 @@ static const format_char_info time_char_ /* GNU conversion specifiers. */ { "kls", 0, STD_EXT, NOLENGTHS, "-_0Ow", "" }, { "P", 0, STD_EXT, NOLENGTHS, "", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL } }; static const format_char_info monetary_char_table[] = { { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL } }; @@ -2404,16 +2405,16 @@ check_format_types (format_wanted_type * continue; /* Now we have a type mismatch. */ { - const char *this; - const char *that; + const char *this_arg; + const char *that_arg; tree tmp; tmp = TYPE_NAME (wanted_type); if (TREE_CODE (tmp) == TYPE_DECL) tmp = DECL_NAME (tmp); - this = IDENTIFIER_POINTER (tmp); + this_arg = IDENTIFIER_POINTER (tmp); - that = 0; + that_arg = 0; if (TYPE_NAME (orig_cur_type) != 0 && TREE_CODE (orig_cur_type) != INTEGER_TYPE && !(TREE_CODE (orig_cur_type) == POINTER_TYPE @@ -2423,18 +2424,18 @@ check_format_types (format_wanted_type * if (TREE_CODE (tmp) == TYPE_DECL) tmp = DECL_NAME (tmp); if (tmp) - that = IDENTIFIER_POINTER (tmp); + that_arg = IDENTIFIER_POINTER (tmp); } /* A nameless type can't possibly match what the format wants. So there will be a warning for it. Make up a string to describe vaguely what it is. */ - if (that == 0) + if (that_arg == 0) { if (TREE_CODE (orig_cur_type) == POINTER_TYPE) - that = _("pointer"); + that_arg = _("pointer"); else - that = _("different type"); + that_arg = _("different type"); } /* Make the warning better in case of mismatch of int vs long. */ @@ -2443,22 +2444,23 @@ check_format_types (format_wanted_type * && TYPE_PRECISION (orig_cur_type) == TYPE_PRECISION (wanted_type) && TYPE_NAME (orig_cur_type) != 0 && TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL) - that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type))); + that_arg = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type))); - if (strcmp (this, that) != 0) + if (strcmp (this_arg, that_arg) != 0) { /* There may be a better name for the format, e.g. size_t, but we should allow for programs with a perverse typedef making size_t something other than what the compiler thinks. */ if (types->wanted_type_name != 0 - && strcmp (types->wanted_type_name, that) != 0) - this = types->wanted_type_name; + && strcmp (types->wanted_type_name, that_arg) != 0) + this_arg = types->wanted_type_name; if (types->name != 0) - warning ("%s is not type %s (arg %d)", types->name, this, - arg_num); + warning ("%s is not type %s (arg %d)", + types->name, this_arg, arg_num); else - warning ("%s format, %s arg (arg %d)", this, that, arg_num); + warning ("%s format, %s arg (arg %d)", + this_arg, that_arg, arg_num); } } } diff -u -p -r1.223 c-lex.c --- gcc/c-lex.c 30 Jun 2004 18:05:03 -0000 1.223 +++ gcc/c-lex.c 11 Jul 2004 23:57:05 -0000 @@ -172,9 +172,9 @@ dump_time_statistics (void) } static void -cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED, - unsigned int line ATTRIBUTE_UNUSED, - const cpp_string *str ATTRIBUTE_UNUSED) +cb_ident (ATTRIBUTE_UNUSED cpp_reader *pfile, + ATTRIBUTE_UNUSED unsigned int line, + ATTRIBUTE_UNUSED const cpp_string *str) { #ifdef ASM_OUTPUT_IDENT if (! flag_no_ident) @@ -466,7 +466,7 @@ c_lex (tree *value) static enum integer_type_kind narrowest_unsigned_type (tree value, unsigned int flags) { - enum integer_type_kind itk; + int itk; if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) itk = itk_unsigned_int; @@ -481,7 +481,7 @@ narrowest_unsigned_type (tree value, uns for (; itk < itk_none; itk += 2 /* skip unsigned types */) if (int_fits_type_p (value, integer_types[itk])) - return itk; + return (enum integer_type_kind) itk; return itk_none; } @@ -490,7 +490,7 @@ narrowest_unsigned_type (tree value, uns static enum integer_type_kind narrowest_signed_type (tree value, unsigned int flags) { - enum integer_type_kind itk; + int itk; if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) itk = itk_int; @@ -505,7 +505,7 @@ narrowest_signed_type (tree value, unsig for (; itk < itk_none; itk += 2 /* skip signed types */) if (int_fits_type_p (value, integer_types[itk])) - return itk; + return (enum integer_type_kind) itk; return itk_none; } Index: gcc/c-tree.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/c-tree.h,v retrieving revision 1.157 diff -u -p -r1.157 c-tree.h --- gcc/c-tree.h 24 Jun 2004 23:12:28 -0000 1.157 +++ gcc/c-tree.h 11 Jul 2004 23:57:07 -0000 @@ -210,7 +210,8 @@ extern bool c_warn_unused_global_decl (t ((CONST_P) ? TYPE_QUAL_CONST : 0) | \ ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0)) -#define c_sizeof_nowarn(T) c_sizeof_or_alignof_type (T, SIZEOF_EXPR, 0) +#define c_sizeof_nowarn(T) \ + c_sizeof_or_alignof_type (T, (enum tree_code) SIZEOF_EXPR, false) /* in c-typeck.c */ extern struct c_switch *c_switch_stack; diff -u -p -r1.333 c-typeck.c --- gcc/c-typeck.c 30 Jun 2004 18:11:13 -0000 1.333 +++ gcc/c-typeck.c 11 Jul 2004 23:57:09 -0000 @@ -1978,7 +1978,7 @@ convert_arguments (tree typelist, tree v differ from the default conversions. */ if (warn_conversion || warn_traditional) { - int formal_prec = TYPE_PRECISION (type); + unsigned int formal_prec = TYPE_PRECISION (type); if (INTEGRAL_TYPE_P (type) && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) @@ -2564,7 +2564,7 @@ build_unary_op (enum tree_code code, tre else addr = build1 (code, argtype, arg); - if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR) + if (TREE_CODE (arg) == (enum tree_code) COMPOUND_LITERAL_EXPR) TREE_INVARIANT (addr) = TREE_CONSTANT (addr) = 1; return addr; @@ -3740,7 +3740,7 @@ store_init_value (tree decl, tree init) inside_init = TREE_OPERAND (init, 0); inside_init = fold (inside_init); - if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) + if (TREE_CODE (inside_init) == (enum tree_code) COMPOUND_LITERAL_EXPR) { tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); @@ -4053,7 +4053,7 @@ digest_init (tree type, tree init, int r inside_init = convert (type, inside_init); if (require_constant && !flag_isoc99 - && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) + && TREE_CODE (inside_init) == (enum tree_code) COMPOUND_LITERAL_EXPR) { /* As an extension, allow initializing objects with static storage duration with compound literals (which are then treated just as @@ -5478,7 +5478,7 @@ output_init_element (tree value, tree ty TYPE_MAIN_VARIANT (type)))) value = default_conversion (value); - if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR + if (TREE_CODE (value) == (enum tree_code) COMPOUND_LITERAL_EXPR && require_constant_value && !flag_isoc99 && pending) { /* As an extension, allow initializing objects with static storage @@ -5814,7 +5814,7 @@ process_init_element (tree value) { /* If value is a compound literal and we'll be just using its content, don't put it into a SAVE_EXPR. */ - if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR + if (TREE_CODE (value) != (enum tree_code) COMPOUND_LITERAL_EXPR || !require_constant_value || flag_isoc99) value = save_expr (value); @@ -7326,11 +7327,11 @@ build_binary_op (enum tree_code code, tr if (shorten && none_complex) { - int unsigned0, unsigned1; + bool unsigned0, unsigned1; tree arg0 = get_narrower (op0, &unsigned0); tree arg1 = get_narrower (op1, &unsigned1); /* UNS is 1 if the operation to be done is an unsigned one. */ - int uns = TYPE_UNSIGNED (result_type); + bool uns = TYPE_UNSIGNED (result_type); tree type; final_type = result_type; @@ -7394,7 +7395,7 @@ build_binary_op (enum tree_code code, tr if (short_shift) { - int unsigned_arg; + bool unsigned_arg; tree arg0 = get_narrower (op0, &unsigned_arg); final_type = result_type; @@ -7445,7 +7446,7 @@ build_binary_op (enum tree_code code, tr { int op0_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op0)); int op1_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op1)); - int unsignedp0, unsignedp1; + bool unsignedp0, unsignedp1; tree primop0 = get_narrower (op0, &unsignedp0); tree primop1 = get_narrower (op1, &unsignedp1); @@ -7527,7 +7528,8 @@ build_binary_op (enum tree_code code, tr { tree primop; HOST_WIDE_INT constant, mask; - int unsignedp, bits; + bool unsignedp; + unsigned int bits; if (host_integerp (primop0, 0)) { diff -u -p -r1.414 fold-const.c --- gcc/fold-const.c 28 Jun 2004 22:26:22 -0000 1.414 +++ gcc/fold-const.c 11 Jul 2004 23:57:49 -0000 @@ -2593,7 +2593,7 @@ operand_equal_p (tree arg0, tree arg1, u static int operand_equal_for_comparison_p (tree arg0, tree arg1, tree other) { - int unsignedp1, unsignedpo; + bool unsignedp1, unsignedpo; tree primarg0, primarg1, primother; unsigned int correct_width; diff -u -p -r1.53 gengtype.c --- gcc/gengtype.c 30 Jun 2004 18:21:53 -0000 1.53 +++ gcc/gengtype.c 11 Jul 2004 23:58:03 -0000 @@ -461,7 +461,7 @@ adjust_field_rtx_def (type_p t, options_ case NOTE_INSN_EXPECTED_VALUE: case NOTE_INSN_VAR_LOCATION: - note_flds->name = "rtx"; + note_flds->name = "rtrtx"; note_flds->type = rtx_tp; break; @@ -504,14 +504,14 @@ adjust_field_rtx_def (type_p t, options_ if (i == MEM && aindex == 1) t = mem_attrs_tp, subname = "rtmem"; else if (i == JUMP_INSN && aindex == 9) - t = rtx_tp, subname = "rtx"; + t = rtx_tp, subname = "rtrtx"; else if (i == CODE_LABEL && aindex == 4) t = scalar_tp, subname = "rtint"; else if (i == CODE_LABEL && aindex == 5) - t = rtx_tp, subname = "rtx"; + t = rtx_tp, subname = "rtrtx"; else if (i == LABEL_REF && (aindex == 1 || aindex == 2)) - t = rtx_tp, subname = "rtx"; + t = rtx_tp, subname = "rtrtx"; else if (i == NOTE && aindex == 4) t = note_union_tp, subname = ""; else if (i == NOTE && aindex >= 7) @@ -552,13 +552,13 @@ adjust_field_rtx_def (type_p t, options_ case 'e': case 'u': t = rtx_tp; - subname = "rtx"; + subname = "rtrtx"; break; case 'E': case 'V': t = rtvec_tp; - subname = "rtvec"; + subname = "rtrtvec"; break; case 't': @@ -838,7 +838,8 @@ note_yacc_type (options_p o, pair_p fiel for (pp = typeinfo; pp; pp = pp->next) if (pp->type != (type_p) 1 - && strcmp (pp->opt->info, p->opt->info) == 0) + && strcmp ((const char *) pp->opt->info, + (const char *) p->opt->info) == 0) { ok = 1; break; @@ -2282,7 +2283,10 @@ write_local_func_for_structure (type_p o oprintf (d.of, "void\n"); oprintf (d.of, "gt_pch_p_"); output_mangled_typename (d.of, orig_s); - oprintf (d.of, " (void *this_obj ATTRIBUTE_UNUSED,\n\tvoid *x_p,\n\tgt_pointer_operator op ATTRIBUTE_UNUSED,\n\tvoid *cookie ATTRIBUTE_UNUSED)\n"); + oprintf (d.of, " (ATTRIBUTE_UNUSED void *this_obj,\n" + "\tvoid *x_p,\n" + "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n" + "\tATTRIBUTE_UNUSED void *cookie)\n"); oprintf (d.of, "{\n"); oprintf (d.of, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n", s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag, @@ -2697,11 +2701,12 @@ write_array (outf_p f, pair_p v, const s oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name); oprintf (f, " (void *, void *, gt_pointer_operator, void *);\n"); - oprintf (f, "static void gt_%sa_%s (void *this_obj ATTRIBUTE_UNUSED,\n", + oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n", wtd->param_prefix, v->name); - oprintf (d.of, " void *x_p ATTRIBUTE_UNUSED,\n"); - oprintf (d.of, " gt_pointer_operator op ATTRIBUTE_UNUSED,\n"); - oprintf (d.of, " void *cookie ATTRIBUTE_UNUSED)\n"); + oprintf (d.of, + " ATTRIBUTE_UNUSED void *x_p,\n" + " ATTRIBUTE_UNUSED gt_pointer_operator op,\n" + " ATTRIBUTE_UNUSED void * cookie)\n"); oprintf (d.of, "{\n"); d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name; d.process_field = write_types_local_process_field; @@ -2712,7 +2717,7 @@ write_array (outf_p f, pair_p v, const s d.opt = v->opt; oprintf (f, "static void gt_%sa_%s (void *);\n", wtd->prefix, v->name); - oprintf (f, "static void\ngt_%sa_%s (void *x_p ATTRIBUTE_UNUSED)\n", + oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n", wtd->prefix, v->name); oprintf (f, "{\n"); d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name; diff -u -p -r1.11 gengtype.h --- gcc/gengtype.h 30 May 2004 00:49:06 -0000 1.11 +++ gcc/gengtype.h 11 Jul 2004 23:58:03 -0000 @@ -66,17 +66,19 @@ struct pair { #define NUM_PARAM 10 +enum gc_used_enum { + GC_UNUSED = 0, + GC_USED, + GC_MAYBE_POINTED_TO, + GC_POINTED_TO +}; + /* A description of a type. */ struct type { enum typekind kind; type_p next; type_p pointer_to; - enum gc_used_enum { - GC_UNUSED = 0, - GC_USED, - GC_MAYBE_POINTED_TO, - GC_POINTED_TO - } gc_used; + enum gc_used_enum gc_used; union { type_p p; struct { diff -u -p -r1.9 genmodes.c --- gcc/genmodes.c 6 Nov 2003 08:38:50 -0000 1.9 +++ gcc/genmodes.c 11 Jul 2004 23:58:03 -0000 @@ -79,7 +79,7 @@ static struct mode_data *void_mode; static const struct mode_data blank_mode = { 0, "", MAX_MODE_CLASS, - -1, -1, -1, -1, + -1U, -1U, -1U, -1U, 0, 0, 0, 0, 0, "", 0 }; @@ -523,7 +523,7 @@ make_int_mode (const char *name, m->precision = precision; } -#define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1, Y, F) +#define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1U, Y, F) #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \ make_float_mode (#N, B, Y, #F, __FILE__, __LINE__) @@ -562,7 +562,7 @@ reset_float_format (const char *name, co /* Partial integer modes are specified by relation to a full integer mode. For now, we do not attempt to narrow down their bit sizes. */ #define PARTIAL_INT_MODE(M) \ - make_partial_integer_mode (#M, "P" #M, -1, __FILE__, __LINE__) + make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__) static void ATTRIBUTE_UNUSED make_partial_integer_mode (const char *base, const char *name, unsigned int precision, diff -u -p -r1.259 integrate.c --- gcc/integrate.c 30 Jun 2004 18:17:58 -0000 1.259 +++ gcc/integrate.c 11 Jul 2004 23:58:11 -0000 @@ -561,7 +561,7 @@ copy_rtx_and_substitute (rtx orig, struc copy_rtx_and_substitute (SET_DEST (orig), map, for_lhs); equiv_reg = map->reg_map[REGNO (SET_DEST (orig))]; equiv_loc = VARRAY_CONST_EQUIV (map->const_equiv_varray, - REGNO (equiv_reg)).rtx; + REGNO (equiv_reg)).const_rtx; loc_offset = REG_P (equiv_loc) ? 0 : INTVAL (XEXP (equiv_loc, 1)); @@ -701,11 +701,11 @@ try_constants (rtx insn, struct inline_r int regno = REGNO (map->equiv_sets[i].dest); MAYBE_EXTEND_CONST_EQUIV_VARRAY (map, regno); - if (VARRAY_CONST_EQUIV (map->const_equiv_varray, regno).rtx == 0 + if (VARRAY_CONST_EQUIV (map->const_equiv_varray, regno).const_rtx == 0 /* Following clause is a hack to make case work where GNU C++ reassigns a variable to make cse work right. */ || ! rtx_equal_p (VARRAY_CONST_EQUIV (map->const_equiv_varray, - regno).rtx, + regno).const_rtx, map->equiv_sets[i].equiv)) SET_CONST_EQUIV_DATA (map, map->equiv_sets[i].dest, map->equiv_sets[i].equiv, map->const_age); @@ -785,9 +785,9 @@ subst_constants (rtx *loc, rtx insn, str if (! (regno < FIRST_PSEUDO_REGISTER && REG_USERVAR_P (x)) && (size_t) regno < VARRAY_SIZE (map->const_equiv_varray) && (p = &VARRAY_CONST_EQUIV (map->const_equiv_varray, regno), - p->rtx != 0) + p->const_rtx != 0) && p->age >= map->const_age) - validate_change (insn, loc, p->rtx, 1); + validate_change (insn, loc, p->const_rtx, 1); } return; @@ -1093,7 +1093,7 @@ mark_stores (rtx dest, rtx x ATTRIBUTE_U && uregno != VIRTUAL_STACK_VARS_REGNUM) for (i = uregno; i <= last_reg; i++) if ((size_t) i < VARRAY_SIZE (global_const_equiv_varray)) - VARRAY_CONST_EQUIV (global_const_equiv_varray, i).rtx = 0; + VARRAY_CONST_EQUIV (global_const_equiv_varray, i).const_rtx = 0; } } Index: gcc/integrate.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/integrate.h,v retrieving revision 1.29 diff -u -p -r1.29 integrate.h --- gcc/integrate.h 13 May 2004 06:39:43 -0000 1.29 +++ gcc/integrate.h 11 Jul 2004 23:58:11 -0000 @@ -173,6 +173,6 @@ extern varray_type global_const_equiv_va struct const_equiv_data *p; \ MAYBE_EXTEND_CONST_EQUIV_VARRAY ((MAP), REGNO (REG)); \ p = &VARRAY_CONST_EQUIV ((MAP)->const_equiv_varray, REGNO (REG)); \ - p->rtx = (RTX); \ + p->const_rtx = (RTX); \ p->age = (AGE); \ } Index: gcc/langhooks.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/langhooks.h,v retrieving revision 1.85 diff -u -p -r1.85 langhooks.h --- gcc/langhooks.h 23 Jun 2004 00:25:54 -0000 1.85 +++ gcc/langhooks.h 11 Jul 2004 23:58:12 -0000 @@ -102,11 +102,11 @@ struct lang_hooks_for_types /* Given MODE and UNSIGNEDP, return a suitable type-tree with that mode. */ - tree (*type_for_mode) (enum machine_mode, int); + tree (*type_for_mode) (enum machine_mode, bool); /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an integer type with at least that precision. */ - tree (*type_for_size) (unsigned, int); + tree (*type_for_size) (unsigned, bool); /* Given an integer type T, return a type like T but unsigned. If T is unsigned, the value is T. */ @@ -118,7 +118,7 @@ struct lang_hooks_for_types /* Return a type the same as TYPE except unsigned or signed according to UNSIGNEDP. */ - tree (*signed_or_unsigned_type) (int, tree); + tree (*signed_or_unsigned_type) (bool, tree); /* Given a type, apply default promotions to unnamed function arguments and return the new type. Return the same type if no Index: gcc/machmode.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/machmode.h,v retrieving revision 1.38 diff -u -p -r1.38 machmode.h --- gcc/machmode.h 6 Nov 2003 08:38:50 -0000 1.38 +++ gcc/machmode.h 11 Jul 2004 23:58:19 -0000 @@ -1,6 +1,6 @@ /* Machine mode definitions for GCC; included by rtl.h and tree.h. - Copyright (C) 1991, 1993, 1994, 1996, 1998, 1999, 2000, 2001, 2003 - Free Software Foundation, Inc. + Copyright (C) 1991, 1993, 1994, 1996, 1998, 1999, 2000, 2001, 2003, + 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -96,7 +96,7 @@ extern const unsigned HOST_WIDE_INT mode /* Return the mode of the inner elements in a vector. */ extern const unsigned char mode_inner[NUM_MACHINE_MODES]; -#define GET_MODE_INNER(MODE) mode_inner[MODE] +#define GET_MODE_INNER(MODE) ((enum machine_mode) mode_inner[MODE]) /* Get the size in bytes of the basic parts of an object of mode MODE. */ @@ -113,7 +113,7 @@ extern const unsigned char mode_nunits[N /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */ extern const unsigned char mode_wider[NUM_MACHINE_MODES]; -#define GET_MODE_WIDER_MODE(MODE) mode_wider[MODE] +#define GET_MODE_WIDER_MODE(MODE) ((enum machine_mode) mode_wider[MODE]) /* Return the mode for data of a given size SIZE and mode class CLASS. If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE. @@ -148,7 +148,8 @@ extern unsigned get_mode_alignment (enum /* For each class, get the narrowest mode in that class. */ extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS]; -#define GET_CLASS_NARROWEST_MODE(CLASS) class_narrowest_mode[CLASS] +#define GET_CLASS_NARROWEST_MODE(CLASS) \ + (enum machine_mode) class_narrowest_mode[CLASS] /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD and the mode whose class is Pmode and whose size is POINTER_SIZE. */ Index: gcc/rtl.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/rtl.h,v retrieving revision 1.483 diff -u -p -r1.483 rtl.h --- gcc/rtl.h 30 Jun 2004 22:30:30 -0000 1.483 +++ gcc/rtl.h 11 Jul 2004 23:58:44 -0000 @@ -164,8 +164,8 @@ union rtunion_def int rtint; unsigned int rtuint; const char *rtstr; - rtx rtx; - rtvec rtvec; + rtx rtrtx; + rtvec rtrtvec; enum machine_mode rttype; addr_diff_vec_flags rt_addr_diff_vec_flags; struct cselib_val_struct *rt_cselib; @@ -609,8 +609,8 @@ do { \ #define XINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rtint) #define XSTR(RTX, N) (RTL_CHECK2 (RTX, N, 's', 'S').rtstr) -#define XEXP(RTX, N) (RTL_CHECK2 (RTX, N, 'e', 'u').rtx) -#define XVEC(RTX, N) (RTL_CHECK2 (RTX, N, 'E', 'V').rtvec) +#define XEXP(RTX, N) (RTL_CHECK2 (RTX, N, 'e', 'u').rtrtx) +#define XVEC(RTX, N) (RTL_CHECK2 (RTX, N, 'E', 'V').rtrtvec) #define XMODE(RTX, N) (RTL_CHECK1 (RTX, N, 'M').rttype) #define XBITMAP(RTX, N) (RTL_CHECK1 (RTX, N, 'b').rtbit) #define XTREE(RTX, N) (RTL_CHECK1 (RTX, N, 't').rttree) @@ -626,8 +626,8 @@ do { \ #define X0INT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtint) #define X0UINT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtuint) #define X0STR(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtstr) -#define X0EXP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtx) -#define X0VEC(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtvec) +#define X0EXP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtrtx) +#define X0VEC(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtrtvec) #define X0MODE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rttype) #define X0BITMAP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtbit) #define X0TREE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rttree) @@ -643,8 +643,8 @@ do { \ #define XCINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtint) #define XCUINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtuint) #define XCSTR(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtstr) -#define XCEXP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtx) -#define XCVEC(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtvec) +#define XCEXP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtrtx) +#define XCVEC(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtrtvec) #define XCMODE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rttype) #define XCBITMAP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtbit) #define XCTREE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rttree) @@ -655,7 +655,7 @@ do { \ #define XCVECEXP(RTX, N, M, C) RTVEC_ELT (XCVEC (RTX, N, C), M) #define XCVECLEN(RTX, N, C) GET_NUM_ELEM (XCVEC (RTX, N, C)) -#define XC2EXP(RTX, N, C1, C2) (RTL_CHECKC2 (RTX, N, C1, C2).rtx) +#define XC2EXP(RTX, N, C1, C2) (RTL_CHECKC2 (RTX, N, C1, C2).rtrtx) /* ACCESS MACROS for particular fields of insns. */ Index: gcc/rtlanal.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/rtlanal.c,v retrieving revision 1.191 diff -u -p -r1.191 rtlanal.c --- gcc/rtlanal.c 21 Jun 2004 12:51:36 -0000 1.191 +++ gcc/rtlanal.c 11 Jul 2004 23:58:45 -0000 @@ -3178,7 +3178,7 @@ loc_mentioned_in_p (rtx *loc, rtx in) for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) { - if (loc == &in->u.fld[i].rtx) + if (loc == &in->u.fld[i].rtrtx) return 1; if (fmt[i] == 'e') { diff -u -p -r1.383 tree.c --- gcc/tree.c 30 Jun 2004 17:58:20 -0000 1.383 +++ gcc/tree.c 11 Jul 2004 23:59:08 -0000 @@ -4529,13 +4529,13 @@ get_unwidened (tree op, tree for_type) /* Return OP or a simpler expression for a narrower value which can be sign-extended or zero-extended to give back OP. - Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended - or 0 if the value should be sign-extended. */ + Store in *UNSIGNEDP_PTR either true if the value should be zero-extended + or false if the value should be sign-extended. */ tree -get_narrower (tree op, int *unsignedp_ptr) +get_narrower (tree op, bool *unsignedp_ptr) { - int uns = 0; + bool uns = false; int first = 1; tree win = op; Index: gcc/tree.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/tree.h,v retrieving revision 1.535 diff -u -p -r1.535 tree.h --- gcc/tree.h 1 Jul 2004 00:38:37 -0000 1.535 +++ gcc/tree.h 11 Jul 2004 23:59:10 -0000 @@ -341,7 +341,7 @@ struct tree_common GTY(()) #define TREE_CHECK(T, CODE) __extension__ \ ({ const tree __t = (T); \ - if (TREE_CODE (__t) != (CODE)) \ + if (TREE_CODE (__t) != (enum tree_code) (CODE)) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ (CODE), 0); \ __t; }) @@ -3241,10 +3241,10 @@ extern tree get_unwidened (tree, tree); /* Return OP or a simpler expression for a narrower value which can be sign-extended or zero-extended to give back OP. - Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended - or 0 if the value should be sign-extended. */ + Store in *UNSIGNEDP_PTR either true if the value should be zero-extended + or false if the value should be sign-extended. */ -extern tree get_narrower (tree, int *); +extern tree get_narrower (tree, bool *); /* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF, look for nested component-refs or array-refs at constant positions Index: gcc/unroll.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/unroll.c,v retrieving revision 1.209 diff -u -p -r1.209 unroll.c --- gcc/unroll.c 15 Jun 2004 18:02:39 -0000 1.209 +++ gcc/unroll.c 11 Jul 2004 23:59:11 -0000 @@ -2201,7 +2201,7 @@ copy_loop_body (struct loop *loop, rtx c /* Be lazy and assume CALL_INSNs clobber all hard registers. */ for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - VARRAY_CONST_EQUIV (map->const_equiv_varray, i).rtx = 0; + VARRAY_CONST_EQUIV (map->const_equiv_varray, i).const_rtx = 0; break; case CODE_LABEL: Index: gcc/varray.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/varray.h,v retrieving revision 1.37 diff -u -p -r1.37 varray.h --- gcc/varray.h 13 May 2004 06:39:52 -0000 1.37 +++ gcc/varray.h 11 Jul 2004 23:59:14 -0000 @@ -50,7 +50,7 @@ struct const_equiv_data GTY(()) { pseudos that contain pointers into the replacement area allocated for this inline instance. These pseudos are then marked as being equivalent to the appropriate address and substituted if valid. */ - rtx rtx; + rtx const_rtx; /* Record the valid age for each entry. The entry is invalid if its age is less than const_age. */ @@ -116,11 +116,11 @@ typedef union varray_data_tag GTY (()) { char *GTY ((length ("%0.num_elements"), tag ("VARRAY_DATA_CPTR"))) cptr[1]; rtx GTY ((length ("%0.num_elements"), - tag ("VARRAY_DATA_RTX"))) rtx[1]; + tag ("VARRAY_DATA_RTX"))) vartx[1]; rtvec GTY ((length ("%0.num_elements"), - tag ("VARRAY_DATA_RTVEC"))) rtvec[1]; + tag ("VARRAY_DATA_RTVEC"))) vartvec[1]; tree GTY ((length ("%0.num_elements"), - tag ("VARRAY_DATA_TREE"))) tree[1]; + tag ("VARRAY_DATA_TREE"))) vatree[1]; struct bitmap_head_def *GTY ((length ("%0.num_elements"), tag ("VARRAY_DATA_BITMAP"))) bitmap[1]; struct reg_info_def *GTY ((length ("%0.num_elements"), skip, @@ -295,9 +295,9 @@ extern void varray_underflow (varray_typ #define VARRAY_GENERIC_PTR(VA,N) VARRAY_CHECK (VA, N, generic) #define VARRAY_GENERIC_PTR_NOGC(VA,N) VARRAY_CHECK (VA, N, generic_nogc) #define VARRAY_CHAR_PTR(VA,N) VARRAY_CHECK (VA, N, cptr) -#define VARRAY_RTX(VA, N) VARRAY_CHECK (VA, N, rtx) -#define VARRAY_RTVEC(VA, N) VARRAY_CHECK (VA, N, rtvec) -#define VARRAY_TREE(VA, N) VARRAY_CHECK (VA, N, tree) +#define VARRAY_RTX(VA, N) VARRAY_CHECK (VA, N, vartx) +#define VARRAY_RTVEC(VA, N) VARRAY_CHECK (VA, N, vartvec) +#define VARRAY_TREE(VA, N) VARRAY_CHECK (VA, N, vatree) #define VARRAY_BITMAP(VA, N) VARRAY_CHECK (VA, N, bitmap) #define VARRAY_REG(VA, N) VARRAY_CHECK (VA, N, reg) #define VARRAY_CONST_EQUIV(VA, N) VARRAY_CHECK (VA, N, const_equiv) @@ -320,9 +320,9 @@ extern void varray_underflow (varray_typ #define VARRAY_PUSH_GENERIC_PTR(VA, X) VARRAY_PUSH (VA, generic, X) #define VARRAY_PUSH_GENERIC_PTR_NOGC(VA, X) VARRAY_PUSH (VA, generic_nogc, X) #define VARRAY_PUSH_CHAR_PTR(VA, X) VARRAY_PUSH (VA, cptr, X) -#define VARRAY_PUSH_RTX(VA, X) VARRAY_PUSH (VA, rtx, X) -#define VARRAY_PUSH_RTVEC(VA, X) VARRAY_PUSH (VA, rtvec, X) -#define VARRAY_PUSH_TREE(VA, X) VARRAY_PUSH (VA, tree, X) +#define VARRAY_PUSH_RTX(VA, X) VARRAY_PUSH (VA, vartx, X) +#define VARRAY_PUSH_RTVEC(VA, X) VARRAY_PUSH (VA, vartvec, X) +#define VARRAY_PUSH_TREE(VA, X) VARRAY_PUSH (VA, vatree, X) #define VARRAY_PUSH_BITMAP(VA, X) VARRAY_PUSH (VA, bitmap, X) #define VARRAY_PUSH_REG(VA, X) VARRAY_PUSH (VA, reg, X) #define VARRAY_PUSH_CONST_EQUIV(VA, X) VARRAY_PUSH (VA, const_equiv, X) @@ -346,9 +346,9 @@ extern void varray_underflow (varray_typ #define VARRAY_TOP_GENERIC_PTR(VA) VARRAY_TOP (VA, generic) #define VARRAY_TOP_GENERIC_PTR_NOGC(VA) VARRAY_TOP (VA, generic_nogc) #define VARRAY_TOP_CHAR_PTR(VA) VARRAY_TOP (VA, cptr) -#define VARRAY_TOP_RTX(VA) VARRAY_TOP (VA, rtx) -#define VARRAY_TOP_RTVEC(VA) VARRAY_TOP (VA, rtvec) -#define VARRAY_TOP_TREE(VA) VARRAY_TOP (VA, tree) +#define VARRAY_TOP_RTX(VA) VARRAY_TOP (VA, vartx) +#define VARRAY_TOP_RTVEC(VA) VARRAY_TOP (VA, vartvec) +#define VARRAY_TOP_TREE(VA) VARRAY_TOP (VA, vatree) #define VARRAY_TOP_BITMAP(VA) VARRAY_TOP (VA, bitmap) #define VARRAY_TOP_REG(VA) VARRAY_TOP (VA, reg) #define VARRAY_TOP_CONST_EQUIV(VA) VARRAY_TOP (VA, const_equiv) Index: gcc/config/rs6000/rs6000.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/config/rs6000/rs6000.h,v retrieving revision 1.326 diff -u -p -r1.326 rs6000.h --- gcc/config/rs6000/rs6000.h 14 Jun 2004 10:05:07 -0000 1.326 +++ gcc/config/rs6000/rs6000.h 12 Jul 2004 00:04:25 -0000 @@ -2147,7 +2147,7 @@ do { \ ((VALUE) = ((MODE) == SImode ? 32 : 64)) /* The CTZ patterns return -1 for input of zero. */ -#define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = -1) +#define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = -1U) /* Specify the machine mode that pointers have. After generation of rtl, the compiler makes no further distinction Index: gcc/cp/cvt.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/cp/cvt.c,v retrieving revision 1.157 diff -u -p -r1.157 cvt.c --- gcc/cp/cvt.c 31 May 2004 21:24:29 -0000 1.157 +++ gcc/cp/cvt.c 12 Jul 2004 00:05:17 -0000 @@ -281,7 +281,7 @@ cp_convert_to_pointer (tree type, tree e { if (TYPE_PRECISION (intype) == POINTER_SIZE) return build1 (CONVERT_EXPR, type, expr); - expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr); + expr = cp_convert (c_common_type_for_size (POINTER_SIZE, false), expr); /* Modes may be different but sizes should be the same. */ if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))) != GET_MODE_SIZE (TYPE_MODE (type))) @@ -1118,10 +1118,10 @@ type_promotes_to (tree type) { int precision = MAX (TYPE_PRECISION (type), TYPE_PRECISION (integer_type_node)); - tree totype = c_common_type_for_size (precision, 0); + tree totype = c_common_type_for_size (precision, false); if (TYPE_UNSIGNED (type) && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype)) - type = c_common_type_for_size (precision, 1); + type = c_common_type_for_size (precision, true); else type = totype; } Index: gcc/cp/lex.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/cp/lex.c,v retrieving revision 1.333 diff -u -p -r1.333 lex.c --- gcc/cp/lex.c 30 Jun 2004 18:23:34 -0000 1.333 +++ gcc/cp/lex.c 12 Jul 2004 00:05:24 -0000 @@ -357,7 +357,7 @@ cxx_init (void) /* Create the built-in __null node. */ null_node = build_int_2 (0, 0); - TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); + TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, false); ridpointers[RID_NULL] = null_node; interface_unknown = 1; Index: gcc/cp/mangle.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/cp/mangle.c,v retrieving revision 1.101 diff -u -p -r1.101 mangle.c --- gcc/cp/mangle.c 1 Apr 2004 03:50:39 -0000 1.101 +++ gcc/cp/mangle.c 12 Jul 2004 00:05:25 -0000 @@ -1182,7 +1182,7 @@ write_integer_cst (const tree cst) chunk *= chunk; } - type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst)); + type = c_common_signed_or_unsigned_type (true, TREE_TYPE (cst)); base = build_int_2 (chunk, 0); n = build_int_2 (TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst)); TREE_TYPE (n) = TREE_TYPE (base) = type; Index: gcc/cp/typeck.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/cp/typeck.c,v retrieving revision 1.555 diff -u -p -r1.555 typeck.c --- gcc/cp/typeck.c 30 Jun 2004 22:30:32 -0000 1.555 +++ gcc/cp/typeck.c 12 Jul 2004 00:05:39 -0000 @@ -3168,11 +3168,11 @@ build_binary_op (enum tree_code code, tr if (shorten && none_complex) { - int unsigned0, unsigned1; + bool unsigned0, unsigned1; tree arg0 = get_narrower (op0, &unsigned0); tree arg1 = get_narrower (op1, &unsigned1); - /* UNS is 1 if the operation to be done is an unsigned one. */ - int uns = TYPE_UNSIGNED (result_type); + /* UNS is true if the operation to be done is an unsigned one. */ + bool uns = TYPE_UNSIGNED (result_type); tree type; final_type = result_type; @@ -3229,7 +3229,7 @@ build_binary_op (enum tree_code code, tr if (short_shift) { - int unsigned_arg; + bool unsigned_arg; tree arg0 = get_narrower (op0, &unsigned_arg); final_type = result_type; @@ -3293,7 +3293,7 @@ build_binary_op (enum tree_code code, tr int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); - int unsignedp0, unsignedp1; + bool unsignedp0, unsignedp1; tree primop0 = get_narrower (op0, &unsignedp0); tree primop1 = get_narrower (op1, &unsignedp1); @@ -3361,7 +3361,7 @@ build_binary_op (enum tree_code code, tr { tree primop; HOST_WIDE_INT constant, mask; - int unsignedp; + bool unsignedp; unsigned int bits; if (host_integerp (primop0, 0)) Index: gcc/java/java-tree.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/java/java-tree.h,v retrieving revision 1.203 diff -u -p -r1.203 java-tree.h --- gcc/java/java-tree.h 29 Jun 2004 17:58:44 -0000 1.203 +++ gcc/java/java-tree.h 12 Jul 2004 00:06:39 -0000 @@ -1122,11 +1122,11 @@ struct eh_range; extern void java_parse_file (int); extern bool java_mark_addressable (tree); -extern tree java_type_for_mode (enum machine_mode, int); -extern tree java_type_for_size (unsigned int, int); +extern tree java_type_for_mode (enum machine_mode, bool); +extern tree java_type_for_size (unsigned int, bool); extern tree java_unsigned_type (tree); extern tree java_signed_type (tree); -extern tree java_signed_or_unsigned_type (int, tree); +extern tree java_signed_or_unsigned_type (bool, tree); extern tree java_truthvalue_conversion (tree); extern void add_assume_compiled (const char *, int); extern void add_enable_assert (const char *, int); diff -u -p -r1.64 typeck.c --- gcc/java/typeck.c 27 Jun 2004 18:16:49 -0000 1.64 +++ gcc/java/typeck.c 12 Jul 2004 00:06:48 -0000 @@ -174,7 +174,7 @@ convert_to_boolean (tree type, tree expr then UNSIGNEDP selects between signed and unsigned types. */ tree -java_type_for_mode (enum machine_mode mode, int unsignedp) +java_type_for_mode (enum machine_mode mode, bool unsignedp) { if (mode == TYPE_MODE (int_type_node)) return unsignedp ? unsigned_int_type_node : int_type_node; @@ -196,7 +196,7 @@ java_type_for_mode (enum machine_mode mo that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ tree -java_type_for_size (unsigned bits, int unsignedp) +java_type_for_size (unsigned bits, bool unsignedp) { if (bits <= TYPE_PRECISION (byte_type_node)) return unsignedp ? unsigned_byte_type_node : byte_type_node; @@ -213,7 +213,7 @@ java_type_for_size (unsigned bits, int u signed according to UNSIGNEDP. */ tree -java_signed_or_unsigned_type (int unsignedp, tree type) +java_signed_or_unsigned_type (bool unsignedp, tree type) { if (! INTEGRAL_TYPE_P (type)) return type; @@ -233,7 +233,7 @@ java_signed_or_unsigned_type (int unsign tree java_signed_type (tree type) { - return java_signed_or_unsigned_type (0, type); + return java_signed_or_unsigned_type (false, type); } /* Return an unsigned type the same as TYPE in other respects. */ @@ -241,7 +241,7 @@ java_signed_type (tree type) tree java_unsigned_type (tree type) { - return java_signed_or_unsigned_type (1, type); + return java_signed_or_unsigned_type (true, type); } /* Mark EXP saying that we need to be able to take the