This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Last C++ bootstrap bits
- From: Bernardo Innocenti <bernie at develer dot com>
- To: GCC Patches <gcc-patches at gcc dot gnu dot org>
- Date: Mon, 26 Jul 2004 03:43:40 +0200
- Subject: Last C++ bootstrap bits
- Organization: Develer S.r.l.
Hello,
I still have 50KB-worth of C++ bootstrap patches, down from
250KB.
It's too late to finish splitting them up, applying, testing
and writing ChangeLog entries, so I'll leave it for tomorrow.
I'm posting them now just in case someone wants to comment
on how I addressed the remaining issues.
These bits address bool-correctness, enum-correctness and
resolve clashes between variables and typenames. I quite
dislike the "rtrtx" and "rtrtvec" member names, so I'm
looking for suggestions for improvement.
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, "<unknown>", MAX_MODE_CLASS,
- -1, -1, -1, -1,
+ -1U, -1U, -1U, -1U,
0, 0, 0, 0, 0,
"<unknown>", 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
--
// Bernardo Innocenti - Develer S.r.l., R&D dept.
\X/ http://www.develer.com/