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>
* 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;
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 (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
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",
newdecl, newdecl, i);
@ -1090,7 +1090,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
return false;
}
if (!comptypes (oldtype, newtype, COMPARE_STRICT))
if (!comptypes (oldtype, newtype))
{
if (TREE_CODE (olddecl) == FUNCTION_DECL
&& 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. */
tree trytype = match_builtin_function_types (newtype, oldtype);
if (trytype && comptypes (newtype, trytype, COMPARE_STRICT))
if (trytype && comptypes (newtype, trytype))
*oldtypep = oldtype = trytype;
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
type for parameters declared with qualified type. */
if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
TYPE_MAIN_VARIANT (TREE_VALUE (type)),
COMPARE_STRICT))
TYPE_MAIN_VARIANT (TREE_VALUE (type))))
{
if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
== TYPE_MAIN_VARIANT (TREE_VALUE (type)))

2
gcc/c-lang.c
View File

@ -216,7 +216,7 @@ finish_file (void)
int
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
c_initialize_diagnostics (diagnostic_context *context)

2
gcc/c-parse.in
View File

@ -700,7 +700,7 @@ primary:
e1 = TYPE_MAIN_VARIANT (groktypename ($3));
e2 = TYPE_MAIN_VARIANT (groktypename ($5));
$$ = comptypes (e1, e2, COMPARE_STRICT)
$$ = comptypes (e1, e2)
? build_int_2 (1, 0) : build_int_2 (0, 0);
}
| 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 */
/* For use with comptypes. */
enum {
COMPARE_STRICT = 0
};
extern tree require_complete_type (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 bool c_mark_addressable (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 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 function_types_compatible_p (tree, tree, int);
static int type_lists_compatible_p (tree, tree, int);
static int function_types_compatible_p (tree, tree);
static int type_lists_compatible_p (tree, tree);
static tree decl_constant_value_for_broken_optimization (tree);
static tree default_function_array_conversion (tree);
static tree lookup_field (tree, tree);
@ -338,8 +338,7 @@ composite_type (tree t1, tree t2)
tree memb;
for (memb = TYPE_FIELDS (TREE_VALUE (p1));
memb; memb = TREE_CHAIN (memb))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2),
COMPARE_STRICT))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
{
TREE_VALUE (n) = TREE_VALUE (p2);
if (pedantic)
@ -353,8 +352,7 @@ composite_type (tree t1, tree t2)
tree memb;
for (memb = TYPE_FIELDS (TREE_VALUE (p2));
memb; memb = TREE_CHAIN (memb))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1),
COMPARE_STRICT))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
{
TREE_VALUE (n) = TREE_VALUE (p1);
if (pedantic)
@ -558,7 +556,7 @@ common_type (tree t1, tree t2)
but a warning may be needed if you use them together. */
int
comptypes (tree type1, tree type2, int flags)
comptypes (tree type1, tree type2)
{
tree t1 = type1;
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)
break;
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;
case FUNCTION_TYPE:
val = function_types_compatible_p (t1, t2, flags);
val = function_types_compatible_p (t1, t2);
break;
case ARRAY_TYPE:
@ -642,8 +640,7 @@ comptypes (tree type1, tree type2, int flags)
/* Target types must match incl. qualifiers. */
if (TREE_TYPE (t1) != TREE_TYPE (t2)
&& 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2),
flags)))
&& 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
return 0;
/* Sizes must match unless one is missing or variable. */
@ -681,12 +678,12 @@ comptypes (tree type1, tree type2, int flags)
case ENUMERAL_TYPE:
case UNION_TYPE:
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;
case VECTOR_TYPE:
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;
default:
@ -712,7 +709,7 @@ comp_target_types (tree ttl, tree ttr, int reflexive)
return val;
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)
pedwarn ("types are not quite compatible");
@ -772,7 +769,7 @@ static const struct tagged_tu_seen * tagged_tu_seen_base;
rules. */
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;
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))
{
int result;
result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2), flags);
result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
if (result == 0)
break;
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)
|| DECL_NAME (s1) != DECL_NAME (s2))
break;
result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2), flags);
result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
if (result == 0)
break;
if (result == 2)
@ -937,7 +934,7 @@ tagged_types_tu_compatible_p (tree t1, tree t2, int flags)
Otherwise, the argument types must match. */
static int
function_types_compatible_p (tree f1, tree f2, int flags)
function_types_compatible_p (tree f1, tree f2)
{
tree args1, args2;
/* 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))
ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
val = comptypes (ret1, ret2, flags);
val = comptypes (ret1, ret2);
if (val == 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.
If they don't match, ask for a warning (but no error). */
if (TYPE_ACTUAL_ARG_TYPES (f1)
&& 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
flags))
&& 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
val = 2;
return val;
}
@ -986,14 +982,13 @@ function_types_compatible_p (tree f1, tree f2, int flags)
if (!self_promoting_args_p (args1))
return 0;
if (TYPE_ACTUAL_ARG_TYPES (f2)
&& 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
flags))
&& 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
val = 2;
return val;
}
/* 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;
}
@ -1002,7 +997,7 @@ function_types_compatible_p (tree f1, tree f2, int flags)
or 2 for compatible with warning. */
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. */
int val = 1;
@ -1035,8 +1030,7 @@ type_lists_compatible_p (tree args1, tree args2, int flags)
|| TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
;
else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
TYPE_MAIN_VARIANT (TREE_VALUE (args2)),
flags)))
TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
{
/* Allow wait (union {union wait *u; int *i} *)
and wait (union wait *) to be compatible. */
@ -1050,8 +1044,7 @@ type_lists_compatible_p (tree args1, tree args2, int flags)
tree memb;
for (memb = TYPE_FIELDS (TREE_VALUE (args1));
memb; memb = TREE_CHAIN (memb))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2),
flags))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
break;
if (memb == 0)
return 0;
@ -1066,8 +1059,7 @@ type_lists_compatible_p (tree args1, tree args2, int flags)
tree memb;
for (memb = TYPE_FIELDS (TREE_VALUE (args2));
memb; memb = TREE_CHAIN (memb))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1),
flags))
if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
break;
if (memb == 0)
return 0;
@ -1837,7 +1829,7 @@ build_function_call (tree function, tree params)
&& TREE_CODE (function) == NOP_EXPR
&& TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
&& 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 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))
if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
TYPE_MAIN_VARIANT (TREE_TYPE (value)), COMPARE_STRICT))
TYPE_MAIN_VARIANT (TREE_TYPE (value))))
break;
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
special case of va_start and va_copy. */
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))
{
@ -3409,7 +3401,7 @@ convert_for_assignment (tree type, tree rhs, const char *errtype,
tree memb_type = TREE_TYPE (memb_types);
if (comptypes (TYPE_MAIN_VARIANT (memb_type),
TYPE_MAIN_VARIANT (rhstype), COMPARE_STRICT))
TYPE_MAIN_VARIANT (rhstype)))
break;
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)))
{
if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
TYPE_MAIN_VARIANT (type), COMPARE_STRICT))
TYPE_MAIN_VARIANT (type)))
return 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
&& comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
TYPE_MAIN_VARIANT (type),
COMPARE_STRICT))
TYPE_MAIN_VARIANT (type)))
return inside_init;
else
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
&& (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
TYPE_MAIN_VARIANT (type), COMPARE_STRICT)
TYPE_MAIN_VARIANT (type))
|| (code == ARRAY_TYPE
&& comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
&& comptypes (TREE_TYPE (inside_init), type))
|| (code == VECTOR_TYPE
&& comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
&& comptypes (TREE_TYPE (inside_init), type))
|| (code == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
&& comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
TREE_TYPE (type), COMPARE_STRICT))
TREE_TYPE (type)))
|| (code == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
&& comptypes (TREE_TYPE (inside_init),
TREE_TYPE (type), COMPARE_STRICT))))
TREE_TYPE (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 (TREE_TYPE (type)) == INTEGER_TYPE)
&& !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
TYPE_MAIN_VARIANT (type), COMPARE_STRICT)))
TYPE_MAIN_VARIANT (type))))
value = default_conversion (value);
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.
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.
This file is part of GCC.
@ -4257,7 +4257,7 @@ check_ivars (tree inter, tree imp)
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_VALUE (TREE_VALUE (rawimpdecls))))
{
@ -7612,8 +7612,7 @@ comp_method_with_proto (tree method, tree proto)
/* install return type */
TREE_TYPE (function1_template) = groktypename (TREE_TYPE (proto));
return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function1_template,
false);
return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function1_template);
}
/* Return 1 if TYPE1 is equivalent to TYPE2. */