2008-03-07 Paolo Bonzini <bonzini@gnu.org>
Revert:
2008-02-06 Douglas Gregor <doug.gregor@gmail.com>
PR c++/35049
PR c++/35096
* typeck.c (structural_comptypes): Call cp_comptypes.
(comptypes): New; called from the C/C++ common bits to perform
strict checks.
(cp_comptypes): Renamed from comptypes, which is already used,
with a different signature, by the C++ front end.
(build_reinterpret_cast_1): Call cp_comptypes.
(ptr_reasonably_similar): Ditto.
* decl.c (decls_match): Ditto.
* cvt.c (convert_to_reference): Ditto.
* cp-tree.h (same_type_p): Ditto.
(same_or_base_type_p): Ditto.
(comptypes): Rename to cp_comptypes.
* pt.c (canonical_type_parameter): Call cp_comptypes.
objcp:
2008-03-07 Paolo Bonzini <bonzini@gnu.org>
Revert:
2008-02-07 Andreas Tobler <andreast-list@fgznet.ch>
Douglas Gregor <doug.gregor@gmail.com>
PR bootstrap/35115
* objcp-decl.c (objcp_comptypes): Call cp_comptypes, not comptypes.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@133007
138bc75d-0d04-0410-961f-
82ee72b054a4
2008-03-07 Paolo Bonzini <bonzini@gnu.org>
+ Revert:
+
+ 2008-02-06 Douglas Gregor <doug.gregor@gmail.com>
+
+ PR c++/35049
+ PR c++/35096
+ * typeck.c (structural_comptypes): Call cp_comptypes.
+ (comptypes): New; called from the C/C++ common bits to perform
+ strict checks.
+ (cp_comptypes): Renamed from comptypes, which is already used,
+ with a different signature, by the C++ front end.
+ (build_reinterpret_cast_1): Call cp_comptypes.
+ (ptr_reasonably_similar): Ditto.
+ * decl.c (decls_match): Ditto.
+ * cvt.c (convert_to_reference): Ditto.
+ * cp-tree.h (same_type_p): Ditto.
+ (same_or_base_type_p): Ditto.
+ (comptypes): Rename to cp_comptypes.
+ * pt.c (canonical_type_parameter): Call cp_comptypes.
+
+2008-03-07 Paolo Bonzini <bonzini@gnu.org>
+
* cp-objcp-common.c (cxx_types_compatible_p): Remove obsolete
test for equivalence between pointer and references.
/* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual
sense of `same'. */
#define same_type_p(TYPE1, TYPE2) \
- cp_comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)
+ comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)
/* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
top-level qualifiers. */
#define WANT_VECTOR 32 /* vector types */
#define WANT_ARITH (WANT_INT | WANT_FLOAT | WANT_VECTOR)
-/* Used with cp_comptypes, and related functions, to guide type
+/* Used with comptypes, and related functions, to guide type
comparison. */
#define COMPARE_STRICT 0 /* Just check if the types are the
is derived from TYPE1, or if TYPE2 is a pointer (reference) to a
class derived from the type pointed to (referred to) by TYPE1. */
#define same_or_base_type_p(TYPE1, TYPE2) \
- cp_comptypes ((TYPE1), (TYPE2), COMPARE_BASE)
+ comptypes ((TYPE1), (TYPE2), COMPARE_BASE)
/* These macros are used to access a TEMPLATE_PARM_INDEX. */
#define TEMPLATE_PARM_INDEX_CAST(NODE) \
extern tree complete_type_or_else (tree, tree);
extern int type_unknown_p (const_tree);
extern bool comp_except_specs (const_tree, const_tree, bool);
-extern bool cp_comptypes (tree, tree, int);
+extern bool comptypes (tree, tree, int);
extern bool compparms (const_tree, const_tree);
extern int comp_cv_qualification (const_tree, const_tree);
extern int comp_cv_qual_signature (tree, tree);
/* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
meant. */
if (TREE_CODE (intype) == POINTER_TYPE
- && (cp_comptypes (TREE_TYPE (intype), type,
- COMPARE_BASE | COMPARE_DERIVED)))
+ && (comptypes (TREE_TYPE (intype), type,
+ COMPARE_BASE | COMPARE_DERIVED)))
warning (0, "casting %qT to %qT does not dereference pointer",
intype, reftype);
/* The call to fold will not always remove the NOP_EXPR as
might be expected, since if one of the types is a typedef;
the comparison in fold is just equality of pointers, not a
- call to cp_comptypes. We don't call fold in this case because
+ call to comptypes. We don't call fold in this case because
that can result in infinite recursion; fold will call
convert, which will call ocp_convert, etc. */
return e;
else if (TREE_TYPE (newdecl) == NULL_TREE)
types_match = 0;
else
- types_match = cp_comptypes (TREE_TYPE (newdecl),
- TREE_TYPE (olddecl),
- COMPARE_REDECLARATION);
+ types_match = comptypes (TREE_TYPE (newdecl),
+ TREE_TYPE (olddecl),
+ COMPARE_REDECLARATION);
}
return types_match;
VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
list = VEC_index (tree, canonical_template_parms, idx);
- while (list && !cp_comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
+ while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
list = TREE_CHAIN (list);
if (list)
\f
/* Return the common type of two parameter lists.
- We assume that cp_comptypes has already been done and returned 1;
+ We assume that comptypes has already been done and returned 1;
if that isn't so, this may crash.
As an optimization, free the space we allocate if the parameter
}
/* Return the merged type of two types.
- We assume that cp_comptypes has already been done and returned 1;
+ We assume that comptypes has already been done and returned 1;
if that isn't so, this may crash.
This just combines attributes and default arguments; any other
}
/* Return the common type of two types.
- We assume that cp_comptypes has already been done and returned 1;
+ We assume that comptypes has already been done and returned 1;
if that isn't so, this may crash.
This is the type for the result of most arithmetic operations
return true;
}
-/* Subroutine in cp_comptypes. */
+/* Subroutine in comptypes. */
static bool
structural_comptypes (tree t1, tree t2, int strict)
return false;
case OFFSET_TYPE:
- if (!cp_comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
- strict & ~COMPARE_REDECLARATION))
+ if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
+ strict & ~COMPARE_REDECLARATION))
return false;
if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
return false;
return targetm.comp_type_attributes (t1, t2);
}
-extern int comptypes (tree, tree);
-
-/* Type comparison function that matches the signature of comptypes
- from c-tree.h, which is used by the C front end and some of the
- C/C++ common bits. */
-int
-comptypes (tree t1, tree t2)
-{
- return cp_comptypes (t1, t2, COMPARE_STRICT);
-}
-
/* Return true if T1 and T2 are related as allowed by STRICT. STRICT
is a bitwise-or of the COMPARE_* flags. */
bool
-cp_comptypes (tree t1, tree t2, int strict)
+comptypes (tree t1, tree t2, int strict)
{
if (strict == COMPARE_STRICT)
{
return 0;
}
\f
-/* Subroutines of `cp_comptypes'. */
+/* Subroutines of `comptypes'. */
/* Return true if two parameter type lists PARMS1 and PARMS2 are
equivalent in the sense that functions with those parameter types
"B" are related class types; the reinterpret_cast does not
adjust the pointer. */
if (TYPE_PTR_P (intype)
- && (cp_comptypes (TREE_TYPE (intype), TREE_TYPE (type),
- COMPARE_BASE | COMPARE_DERIVED)))
+ && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
+ COMPARE_BASE | COMPARE_DERIVED)))
warning (0, "casting %qT to %qT does not dereference pointer",
intype, type);
return 0;
if (TREE_CODE (from) == OFFSET_TYPE
- && cp_comptypes (TYPE_OFFSET_BASETYPE (to),
- TYPE_OFFSET_BASETYPE (from),
- COMPARE_BASE | COMPARE_DERIVED))
+ && comptypes (TYPE_OFFSET_BASETYPE (to),
+ TYPE_OFFSET_BASETYPE (from),
+ COMPARE_BASE | COMPARE_DERIVED))
continue;
if (TREE_CODE (to) == VECTOR_TYPE
return 1;
if (TREE_CODE (to) != POINTER_TYPE)
- return cp_comptypes
+ return comptypes
(TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
COMPARE_BASE | COMPARE_DERIVED);
}
+2008-03-07 Paolo Bonzini <bonzini@gnu.org>
+
+ Revert:
+
+ 2008-02-07 Andreas Tobler <andreast-list@fgznet.ch>
+ Douglas Gregor <doug.gregor@gmail.com>
+
+ PR bootstrap/35115
+ * objcp-decl.c (objcp_comptypes): Call cp_comptypes, not comptypes.
+
2008-02-07 Andreas Tobler <andreast-list@fgznet.ch>
Douglas Gregor <doug.gregor@gmail.com>
int
objcp_comptypes (tree type1, tree type2)
{
- return cp_comptypes (type1, type2, COMPARE_STRICT);
+ return comptypes (type1, type2, COMPARE_STRICT);
}
tree
OSDN Git Service
