From: Jason Merrill Date: Tue, 25 Aug 1998 17:17:51 +0000 (+0000) Subject: typeck.c (comp_cv_target_types): Split out... X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=a5d1cd099af2649bc92ba666eef17bbe68b03653;p=gcc.git typeck.c (comp_cv_target_types): Split out... * typeck.c (comp_cv_target_types): Split out... (comp_target_types): From here. Don't allow cv-qual changes under a pointer if nptrs == 0. Fix OFFSET_TYPE handling. (build_ptrmemfunc): Pass 1 to nptrs. * cvt.c (perform_qualification_conversions): Use comp_ptr_ttypes. From-SVN: r21974 --- diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 0af040726e7..dfb6e518be7 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,11 @@ +1998-08-25 Jason Merrill + + * typeck.c (comp_cv_target_types): Split out... + (comp_target_types): From here. Don't allow cv-qual changes under + a pointer if nptrs == 0. Fix OFFSET_TYPE handling. + (build_ptrmemfunc): Pass 1 to nptrs. + * cvt.c (perform_qualification_conversions): Use comp_ptr_ttypes. + 1998-08-25 Mark Mitchell * search.c (dependent_base_p): Don't compare a binfo to diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c index 99289e824e3..ff69fbfabaf 100644 --- a/gcc/cp/cvt.c +++ b/gcc/cp/cvt.c @@ -1094,7 +1094,6 @@ type_promotes_to (type) return cp_build_type_variant (type, constp, volatilep); } - /* The routines below this point are carefully written to conform to the standard. They use the same terminology, and follow the rules closely. Although they are used only in pt.c at the moment, they @@ -1109,7 +1108,9 @@ perform_qualification_conversions (type, expr) tree type; tree expr; { - if (comp_target_types (type, TREE_TYPE (expr), 0) == 1) + if (TREE_CODE (type) == POINTER_TYPE + && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE + && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr)))) return build1 (NOP_EXPR, type, expr); else return error_mark_node; diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index c7530f06d7b..7859c041401 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -912,6 +912,31 @@ comptypes (type1, type2, strict) return attrval == 2 && val == 1 ? 2 : val; } +/* Subroutine of comp_target-types. Make sure that the cv-quals change + only in the same direction as the target type. */ + +static int +comp_cv_target_types (ttl, ttr, nptrs) + tree ttl, ttr; + int nptrs; +{ + int t; + int c = TYPE_READONLY (ttl) - TYPE_READONLY (ttr); + int v = TYPE_VOLATILE (ttl) - TYPE_VOLATILE (ttr); + + if ((c > 0 && v < 0) || (c < 0 && v > 0)) + return 0; + + if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr)) + return (c + v < 0) ? -1 : 1; + + t = comp_target_types (ttl, ttr, nptrs); + if ((t == 1 && c + v >= 0) || (t == -1 && c + v <= 0)) + return t; + + return 0; +} + /* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent, ignoring their qualifiers, 0 if not. Return 1 means that TTR can be converted to TTL. Return -1 means that TTL can be converted to TTR but @@ -937,15 +962,20 @@ comp_target_types (ttl, ttr, nptrs) if (TREE_CODE (ttr) != TREE_CODE (ttl)) return 0; - if (TREE_CODE (ttr) == POINTER_TYPE - || (TREE_CODE (ttr) == REFERENCE_TYPE)) + if ((TREE_CODE (ttr) == POINTER_TYPE + || TREE_CODE (ttr) == REFERENCE_TYPE) + /* If we get a pointer with nptrs == 0, we don't allow any tweaking + of the type pointed to. This is necessary for reference init + semantics. We won't get here from a previous call with nptrs == 1; + for multi-level pointers we end up in comp_ptr_ttypes. */ + && nptrs > 0) { int is_ptr = TREE_CODE (ttr) == POINTER_TYPE; ttl = TREE_TYPE (ttl); ttr = TREE_TYPE (ttr); - if (nptrs > 0 && is_ptr) + if (is_ptr) { if (TREE_CODE (ttl) == UNKNOWN_TYPE || TREE_CODE (ttr) == UNKNOWN_TYPE) @@ -976,25 +1006,7 @@ comp_target_types (ttl, ttr, nptrs) if (TREE_CODE (ttl) == FUNCTION_TYPE || TREE_CODE (ttl) == METHOD_TYPE) return comp_target_types (ttl, ttr, nptrs - 1); - /* Make sure that the cv-quals change only in the same direction as - the target type. */ - { - int t; - int c = TYPE_READONLY (ttl) - TYPE_READONLY (ttr); - int v = TYPE_VOLATILE (ttl) - TYPE_VOLATILE (ttr); - - if ((c > 0 && v < 0) || (c < 0 && v > 0)) - return 0; - - if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr)) - return (c + v < 0) ? -1 : 1; - - t = comp_target_types (ttl, ttr, nptrs - 1); - if ((t == 1 && c + v >= 0) || (t == -1 && c + v <= 0)) - return t; - - return 0; - } + return comp_cv_target_types (ttl, ttr, nptrs - 1); } if (TREE_CODE (ttr) == ARRAY_TYPE) @@ -1054,16 +1066,42 @@ comp_target_types (ttl, ttr, nptrs) /* for C++ */ else if (TREE_CODE (ttr) == OFFSET_TYPE) { + int base; + tree tmp; + /* Contravariance: we can assign a pointer to base member to a pointer to derived member. Note difference from simple pointer case, where we can pass a pointer to derived to a pointer to base. */ if (comptypes (TYPE_OFFSET_BASETYPE (ttr), TYPE_OFFSET_BASETYPE (ttl), 0)) - return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs); + base = 1; else if (comptypes (TYPE_OFFSET_BASETYPE (ttl), - TYPE_OFFSET_BASETYPE (ttr), 0) - && comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs)) - return -1; + TYPE_OFFSET_BASETYPE (ttr), 0)) + { + tree tmp = ttl; + ttl = ttr; + ttr = tmp; + base = -1; + } + else + return 0; + + ttl = TREE_TYPE (ttl); + ttr = TREE_TYPE (ttr); + + if (TREE_CODE (ttl) == POINTER_TYPE + || TREE_CODE (ttl) == ARRAY_TYPE) + { + if (comp_ptr_ttypes (ttl, ttr)) + return base; + return 0; + } + else + { + if (comp_cv_target_types (ttl, ttr, nptrs) == 1) + return base; + return 0; + } } else if (IS_AGGR_TYPE (ttl)) { @@ -6515,7 +6553,7 @@ build_ptrmemfunc (type, pfn, force) pfn_type = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn)); if (!force - && comp_target_types (type, pfn_type, 0) != 1) + && comp_target_types (type, pfn_type, 1) != 1) cp_error ("conversion to `%T' from `%T'", type, pfn_type); ndelta = cp_convert (ptrdiff_type_node, build_component_ref (pfn, delta_identifier, NULL_TREE, 0));