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

c-typeck.c (comptypes, [...]): Remove flags parameter. 

* c-typeck.c (comptypes, tagged_types_tu_compatible_p,
	function_types_compatible_p, type_lists_compatible_p): Remove
	flags parameter.
	* c-tree.h (comptypes): Likewise.
	(COMPARE_STRICT): Remove.
	* c-decl.c, c-lang.c, c-parse.in, c-typeck.c, objc/objc-act.c: All
	callers changed.

From-SVN: r83061
This commit is contained in:
Joseph Myers 2004-06-13 18:14:09 +01:00 committed by Joseph Myers
parent 118a3a8ba8
commit 132da1a5aa
7 changed files with 57 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gcc/ChangeLog
View File

@ -1,3 +1,13 @@
2004-06-13 Joseph S. Myers <jsm@polyomino.org.uk>
* c-typeck.c (comptypes, tagged_types_tu_compatible_p,
function_types_compatible_p, type_lists_compatible_p): Remove
flags parameter.
* c-tree.h (comptypes): Likewise.
(COMPARE_STRICT): Remove.
* c-decl.c, c-lang.c, c-parse.in, c-typeck.c, objc/objc-act.c: All
callers changed.
2004-06-13 Eric Christopher <echristo@redhat.com> 2004-06-13 Eric Christopher <echristo@redhat.com>
* c-decl.c (diagnose_mismatched_decls): Improve error message. * c-decl.c (diagnose_mismatched_decls): Improve error message.

11
gcc/c-decl.c
View File

@ -936,7 +936,7 @@ diagnose_arglist_conflict (tree newdecl, tree olddecl,
tree t; tree t;
if (TREE_CODE (olddecl) != FUNCTION_DECL if (TREE_CODE (olddecl) != FUNCTION_DECL
|| !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype), COMPARE_STRICT) || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
|| !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0) || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
|| ||
(TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0))) (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
@ -1008,7 +1008,7 @@ validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
/* Type for passing arg must be consistent with that declared /* Type for passing arg must be consistent with that declared
for the arg. */ for the arg. */
else if (! comptypes (oldargtype, newargtype, COMPARE_STRICT)) else if (! comptypes (oldargtype, newargtype))
{ {
error ("%Jprototype for '%D' declares arg %d with incompatible type", error ("%Jprototype for '%D' declares arg %d with incompatible type",
newdecl, newdecl, i); newdecl, newdecl, i);
@ -1090,7 +1090,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
return false; return false;
} }
if (!comptypes (oldtype, newtype, COMPARE_STRICT)) if (!comptypes (oldtype, newtype))
{ {
if (TREE_CODE (olddecl) == FUNCTION_DECL if (TREE_CODE (olddecl) == FUNCTION_DECL
&& DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl)) && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
@ -1099,7 +1099,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
This is for the ffs and fprintf builtins. */ This is for the ffs and fprintf builtins. */
tree trytype = match_builtin_function_types (newtype, oldtype); tree trytype = match_builtin_function_types (newtype, oldtype);
if (trytype && comptypes (newtype, trytype, COMPARE_STRICT)) if (trytype && comptypes (newtype, trytype))
*oldtypep = oldtype = trytype; *oldtypep = oldtype = trytype;
else else
{ {
@ -6008,8 +6008,7 @@ store_parm_decls_oldstyle (tree fndecl, tree arg_info)
declared for the arg. ISO C says we take the unqualified declared for the arg. ISO C says we take the unqualified
type for parameters declared with qualified type. */ type for parameters declared with qualified type. */
if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)), if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
TYPE_MAIN_VARIANT (TREE_VALUE (type)), TYPE_MAIN_VARIANT (TREE_VALUE (type))))
COMPARE_STRICT))
{ {
if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
== TYPE_MAIN_VARIANT (TREE_VALUE (type))) == TYPE_MAIN_VARIANT (TREE_VALUE (type)))

2
gcc/c-lang.c
View File

@ -216,7 +216,7 @@ finish_file (void)
int int
c_types_compatible_p (tree x, tree y) c_types_compatible_p (tree x, tree y)
{ {
return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y), 0); return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y));
} }
static void static void
c_initialize_diagnostics (diagnostic_context *context) c_initialize_diagnostics (diagnostic_context *context)

2
gcc/c-parse.in
View File

@ -700,7 +700,7 @@ primary:
e1 = TYPE_MAIN_VARIANT (groktypename ($3)); e1 = TYPE_MAIN_VARIANT (groktypename ($3));
e2 = TYPE_MAIN_VARIANT (groktypename ($5)); e2 = TYPE_MAIN_VARIANT (groktypename ($5));
$$ = comptypes (e1, e2, COMPARE_STRICT) $$ = comptypes (e1, e2)
? build_int_2 (1, 0) : build_int_2 (0, 0); ? build_int_2 (1, 0) : build_int_2 (0, 0);
} }
| TYPES_COMPATIBLE_P '(' error ')' | TYPES_COMPATIBLE_P '(' error ')'

7
gcc/c-tree.h
View File

@ -214,14 +214,9 @@ extern bool c_warn_unused_global_decl (tree);
/* in c-typeck.c */ /* in c-typeck.c */
/* For use with comptypes. */
enum {
COMPARE_STRICT = 0
};
extern tree require_complete_type (tree); extern tree require_complete_type (tree);
extern int same_translation_unit_p (tree, tree); extern int same_translation_unit_p (tree, tree);
extern int comptypes (tree, tree, int); extern int comptypes (tree, tree);
extern tree c_size_in_bytes (tree); extern tree c_size_in_bytes (tree);
extern bool c_mark_addressable (tree); extern bool c_mark_addressable (tree);
extern void c_incomplete_type_error (tree, tree); extern void c_incomplete_type_error (tree, tree);

81
gcc/c-typeck.c
View File

@ -54,10 +54,10 @@ static int require_constant_value;
static int require_constant_elements; static int require_constant_elements;
static tree qualify_type (tree, tree); static tree qualify_type (tree, tree);
static int tagged_types_tu_compatible_p (tree, tree, int); static int tagged_types_tu_compatible_p (tree, tree);
static int comp_target_types (tree, tree, int); static int comp_target_types (tree, tree, int);
static int function_types_compatible_p (tree, tree, int); static int function_types_compatible_p (tree, tree);
static int type_lists_compatible_p (tree, tree, int); static int type_lists_compatible_p (tree, tree);
static tree decl_constant_value_for_broken_optimization (tree); static tree decl_constant_value_for_broken_optimization (tree);
static tree default_function_array_conversion (tree); static tree default_function_array_conversion (tree);
static tree lookup_field (tree, tree); static tree lookup_field (tree, tree);
@ -338,8 +338,7 @@ composite_type (tree t1, tree t2)
tree memb; tree memb;
for (memb = TYPE_FIELDS (TREE_VALUE (p1)); for (memb = TYPE_FIELDS (TREE_VALUE (p1));
memb; memb = TREE_CHAIN (memb)) memb; memb = TREE_CHAIN (memb))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2), if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
COMPARE_STRICT))
{ {
TREE_VALUE (n) = TREE_VALUE (p2); TREE_VALUE (n) = TREE_VALUE (p2);
if (pedantic) if (pedantic)
@ -353,8 +352,7 @@ composite_type (tree t1, tree t2)
tree memb; tree memb;
for (memb = TYPE_FIELDS (TREE_VALUE (p2)); for (memb = TYPE_FIELDS (TREE_VALUE (p2));
memb; memb = TREE_CHAIN (memb)) memb; memb = TREE_CHAIN (memb))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1), if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
COMPARE_STRICT))
{ {
TREE_VALUE (n) = TREE_VALUE (p1); TREE_VALUE (n) = TREE_VALUE (p1);
if (pedantic) if (pedantic)
@ -558,7 +556,7 @@ common_type (tree t1, tree t2)
but a warning may be needed if you use them together. */ but a warning may be needed if you use them together. */
int int
comptypes (tree type1, tree type2, int flags) comptypes (tree type1, tree type2)
{ {
tree t1 = type1; tree t1 = type1;
tree t2 = type2; tree t2 = type2;
@ -625,11 +623,11 @@ comptypes (tree type1, tree type2, int flags)
if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0) if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0)
break; break;
val = (TREE_TYPE (t1) == TREE_TYPE (t2) val = (TREE_TYPE (t1) == TREE_TYPE (t2)
? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2), flags)); ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
break; break;
case FUNCTION_TYPE: case FUNCTION_TYPE:
val = function_types_compatible_p (t1, t2, flags); val = function_types_compatible_p (t1, t2);
break; break;
case ARRAY_TYPE: case ARRAY_TYPE:
@ -642,8 +640,7 @@ comptypes (tree type1, tree type2, int flags)
/* Target types must match incl. qualifiers. */ /* Target types must match incl. qualifiers. */
if (TREE_TYPE (t1) != TREE_TYPE (t2) if (TREE_TYPE (t1) != TREE_TYPE (t2)
&& 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2), && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
flags)))
return 0; return 0;
/* Sizes must match unless one is missing or variable. */ /* Sizes must match unless one is missing or variable. */
@ -681,12 +678,12 @@ comptypes (tree type1, tree type2, int flags)
case ENUMERAL_TYPE: case ENUMERAL_TYPE:
case UNION_TYPE: case UNION_TYPE:
if (val != 1 && !same_translation_unit_p (t1, t2)) if (val != 1 && !same_translation_unit_p (t1, t2))
val = tagged_types_tu_compatible_p (t1, t2, flags); val = tagged_types_tu_compatible_p (t1, t2);
break; break;
case VECTOR_TYPE: case VECTOR_TYPE:
val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2) val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
&& comptypes (TREE_TYPE (t1), TREE_TYPE (t2), 0); && comptypes (TREE_TYPE (t1), TREE_TYPE (t2));
break; break;
default: default:
@ -712,7 +709,7 @@ comp_target_types (tree ttl, tree ttr, int reflexive)
return val; return val;
val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)), val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
TYPE_MAIN_VARIANT (TREE_TYPE (ttr)), COMPARE_STRICT); TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
if (val == 2 && pedantic) if (val == 2 && pedantic)
pedwarn ("types are not quite compatible"); pedwarn ("types are not quite compatible");
@ -772,7 +769,7 @@ static const struct tagged_tu_seen * tagged_tu_seen_base;
rules. */ rules. */
static int static int
tagged_types_tu_compatible_p (tree t1, tree t2, int flags) tagged_types_tu_compatible_p (tree t1, tree t2)
{ {
tree s1, s2; tree s1, s2;
bool needs_warning = false; bool needs_warning = false;
@ -869,7 +866,7 @@ tagged_types_tu_compatible_p (tree t1, tree t2, int flags)
if (DECL_NAME (s1) == DECL_NAME (s2)) if (DECL_NAME (s1) == DECL_NAME (s2))
{ {
int result; int result;
result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2), flags); result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
if (result == 0) if (result == 0)
break; break;
if (result == 2) if (result == 2)
@ -907,7 +904,7 @@ tagged_types_tu_compatible_p (tree t1, tree t2, int flags)
if (TREE_CODE (s1) != TREE_CODE (s2) if (TREE_CODE (s1) != TREE_CODE (s2)
|| DECL_NAME (s1) != DECL_NAME (s2)) || DECL_NAME (s1) != DECL_NAME (s2))
break; break;
result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2), flags); result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
if (result == 0) if (result == 0)
break; break;
if (result == 2) if (result == 2)
@ -937,7 +934,7 @@ tagged_types_tu_compatible_p (tree t1, tree t2, int flags)
Otherwise, the argument types must match. */ Otherwise, the argument types must match. */
static int static int
function_types_compatible_p (tree f1, tree f2, int flags) function_types_compatible_p (tree f1, tree f2)
{ {
tree args1, args2; tree args1, args2;
/* 1 if no need for warning yet, 2 if warning cause has been seen. */ /* 1 if no need for warning yet, 2 if warning cause has been seen. */
@ -958,7 +955,7 @@ function_types_compatible_p (tree f1, tree f2, int flags)
if (TYPE_VOLATILE (ret2)) if (TYPE_VOLATILE (ret2))
ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2), ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE); TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
val = comptypes (ret1, ret2, flags); val = comptypes (ret1, ret2);
if (val == 0) if (val == 0)
return 0; return 0;
@ -976,8 +973,7 @@ function_types_compatible_p (tree f1, tree f2, int flags)
compare that with the other type's arglist. compare that with the other type's arglist.
If they don't match, ask for a warning (but no error). */ If they don't match, ask for a warning (but no error). */
if (TYPE_ACTUAL_ARG_TYPES (f1) if (TYPE_ACTUAL_ARG_TYPES (f1)
&& 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1), && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
flags))
val = 2; val = 2;
return val; return val;
} }
@ -986,14 +982,13 @@ function_types_compatible_p (tree f1, tree f2, int flags)
if (!self_promoting_args_p (args1)) if (!self_promoting_args_p (args1))
return 0; return 0;
if (TYPE_ACTUAL_ARG_TYPES (f2) if (TYPE_ACTUAL_ARG_TYPES (f2)
&& 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2), && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
flags))
val = 2; val = 2;
return val; return val;
} }
/* Both types have argument lists: compare them and propagate results. */ /* Both types have argument lists: compare them and propagate results. */
val1 = type_lists_compatible_p (args1, args2, flags); val1 = type_lists_compatible_p (args1, args2);
return val1 != 1 ? val1 : val; return val1 != 1 ? val1 : val;
} }
@ -1002,7 +997,7 @@ function_types_compatible_p (tree f1, tree f2, int flags)
or 2 for compatible with warning. */ or 2 for compatible with warning. */
static int static int
type_lists_compatible_p (tree args1, tree args2, int flags) type_lists_compatible_p (tree args1, tree args2)
{ {
/* 1 if no need for warning yet, 2 if warning cause has been seen. */ /* 1 if no need for warning yet, 2 if warning cause has been seen. */
int val = 1; int val = 1;
@ -1035,8 +1030,7 @@ type_lists_compatible_p (tree args1, tree args2, int flags)
|| TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK) || TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
; ;
else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)), else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
TYPE_MAIN_VARIANT (TREE_VALUE (args2)), TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
flags)))
{ {
/* Allow wait (union {union wait *u; int *i} *) /* Allow wait (union {union wait *u; int *i} *)
and wait (union wait *) to be compatible. */ and wait (union wait *) to be compatible. */
@ -1050,8 +1044,7 @@ type_lists_compatible_p (tree args1, tree args2, int flags)
tree memb; tree memb;
for (memb = TYPE_FIELDS (TREE_VALUE (args1)); for (memb = TYPE_FIELDS (TREE_VALUE (args1));
memb; memb = TREE_CHAIN (memb)) memb; memb = TREE_CHAIN (memb))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2), if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
flags))
break; break;
if (memb == 0) if (memb == 0)
return 0; return 0;
@ -1066,8 +1059,7 @@ type_lists_compatible_p (tree args1, tree args2, int flags)
tree memb; tree memb;
for (memb = TYPE_FIELDS (TREE_VALUE (args2)); for (memb = TYPE_FIELDS (TREE_VALUE (args2));
memb; memb = TREE_CHAIN (memb)) memb; memb = TREE_CHAIN (memb))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1), if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
flags))
break; break;
if (memb == 0) if (memb == 0)
return 0; return 0;
@ -1837,7 +1829,7 @@ build_function_call (tree function, tree params)
&& TREE_CODE (function) == NOP_EXPR && TREE_CODE (function) == NOP_EXPR
&& TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
&& TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
&& ! comptypes (fntype, TREE_TYPE (tem), COMPARE_STRICT)) && ! comptypes (fntype, TREE_TYPE (tem)))
{ {
tree return_type = TREE_TYPE (fntype); tree return_type = TREE_TYPE (fntype);
tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP], tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
@ -3013,7 +3005,7 @@ build_c_cast (tree type, tree expr)
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
TYPE_MAIN_VARIANT (TREE_TYPE (value)), COMPARE_STRICT)) TYPE_MAIN_VARIANT (TREE_TYPE (value))))
break; break;
if (field) if (field)
@ -3361,7 +3353,7 @@ convert_for_assignment (tree type, tree rhs, const char *errtype,
This code doesn't fully support references, it's just for the This code doesn't fully support references, it's just for the
special case of va_start and va_copy. */ special case of va_start and va_copy. */
if (codel == REFERENCE_TYPE if (codel == REFERENCE_TYPE
&& comptypes (TREE_TYPE (type), TREE_TYPE (rhs), COMPARE_STRICT) == 1) && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
{ {
if (!lvalue_p (rhs)) if (!lvalue_p (rhs))
{ {
@ -3409,7 +3401,7 @@ convert_for_assignment (tree type, tree rhs, const char *errtype,
tree memb_type = TREE_TYPE (memb_types); tree memb_type = TREE_TYPE (memb_types);
if (comptypes (TYPE_MAIN_VARIANT (memb_type), if (comptypes (TYPE_MAIN_VARIANT (memb_type),
TYPE_MAIN_VARIANT (rhstype), COMPARE_STRICT)) TYPE_MAIN_VARIANT (rhstype)))
break; break;
if (TREE_CODE (memb_type) != POINTER_TYPE) if (TREE_CODE (memb_type) != POINTER_TYPE)
@ -3988,7 +3980,7 @@ digest_init (tree type, tree init, int require_constant)
&& ((inside_init && TREE_CODE (inside_init) == STRING_CST))) && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
{ {
if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
TYPE_MAIN_VARIANT (type), COMPARE_STRICT)) TYPE_MAIN_VARIANT (type)))
return inside_init; return inside_init;
if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
@ -4035,8 +4027,7 @@ digest_init (tree type, tree init, int require_constant)
{ {
if (TREE_CODE (inside_init) == VECTOR_CST if (TREE_CODE (inside_init) == VECTOR_CST
&& comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
TYPE_MAIN_VARIANT (type), TYPE_MAIN_VARIANT (type)))
COMPARE_STRICT))
return inside_init; return inside_init;
else else
return build_vector (type, CONSTRUCTOR_ELTS (inside_init)); return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
@ -4047,19 +4038,19 @@ digest_init (tree type, tree init, int require_constant)
if (inside_init && TREE_TYPE (inside_init) != 0 if (inside_init && TREE_TYPE (inside_init) != 0
&& (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
TYPE_MAIN_VARIANT (type), COMPARE_STRICT) TYPE_MAIN_VARIANT (type))
|| (code == ARRAY_TYPE || (code == ARRAY_TYPE
&& comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT)) && comptypes (TREE_TYPE (inside_init), type))
|| (code == VECTOR_TYPE || (code == VECTOR_TYPE
&& comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT)) && comptypes (TREE_TYPE (inside_init), type))
|| (code == POINTER_TYPE || (code == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
&& comptypes (TREE_TYPE (TREE_TYPE (inside_init)), && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
TREE_TYPE (type), COMPARE_STRICT)) TREE_TYPE (type)))
|| (code == POINTER_TYPE || (code == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
&& comptypes (TREE_TYPE (inside_init), && comptypes (TREE_TYPE (inside_init),
TREE_TYPE (type), COMPARE_STRICT)))) TREE_TYPE (type)))))
{ {
if (code == POINTER_TYPE) if (code == POINTER_TYPE)
{ {
@ -5500,7 +5491,7 @@ output_init_element (tree value, tree type, tree field, int pending)
&& TREE_CODE (type) == ARRAY_TYPE && TREE_CODE (type) == ARRAY_TYPE
&& TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE) && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
&& !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
TYPE_MAIN_VARIANT (type), COMPARE_STRICT))) TYPE_MAIN_VARIANT (type))))
value = default_conversion (value); value = default_conversion (value);
if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR

7
gcc/objc/objc-act.c
View File

@ -1,6 +1,6 @@
/* Implement classes and message passing for Objective C. /* Implement classes and message passing for Objective C.
Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000, Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
2001, 2002, 2003 Free Software Foundation, Inc. 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
Contributed by Steve Naroff. Contributed by Steve Naroff.
This file is part of GCC. This file is part of GCC.
@ -4257,7 +4257,7 @@ check_ivars (tree inter, tree imp)
t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls); t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
if (!comptypes (t1, t2, false) if (!comptypes (t1, t2)
|| !tree_int_cst_equal (TREE_VALUE (TREE_VALUE (rawintdecls)), || !tree_int_cst_equal (TREE_VALUE (TREE_VALUE (rawintdecls)),
TREE_VALUE (TREE_VALUE (rawimpdecls)))) TREE_VALUE (TREE_VALUE (rawimpdecls))))
{ {
@ -7612,8 +7612,7 @@ comp_method_with_proto (tree method, tree proto)
/* install return type */ /* install return type */
TREE_TYPE (function1_template) = groktypename (TREE_TYPE (proto)); TREE_TYPE (function1_template) = groktypename (TREE_TYPE (proto));
return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function1_template, return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function1_template);
false);
} }
/* Return 1 if TYPE1 is equivalent to TYPE2. */ /* Return 1 if TYPE1 is equivalent to TYPE2. */