commit 4d5074bd48669bf1215e231cd1ae4b39b36009a8
Author: Jason Merrill <jason@redhat.com>
Date: Wed May 19 16:59:19 2010 -0400
type_main_variant cleanup
@@ -240,7 +240,7 @@ check_dtor_name (tree basetype, tree name)
if (!name || name == error_mark_node)
return false;
- return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
+ return same_type_ignoring_top_level_qualifiers_p (basetype, name);
}
/* We want the address of a function or method. We avoid creating a
@@ -2361,7 +2361,7 @@ add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
(NULL_TREE, build_reference_type (argtypes[i]), types[i]);
types[i] = tree_cons
- (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
+ (NULL_TREE, cv_unqualified (argtypes[i]), types[i]);
}
else if (! convs)
@@ -2382,7 +2382,7 @@ add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
type = non_reference (type);
if (i != 0 || ! ref1)
{
- type = TYPE_MAIN_VARIANT (type_decays_to (type));
+ type = type_decays_to (type);
if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
types[i] = tree_cons (NULL_TREE, type, types[i]);
if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
@@ -2401,7 +2401,7 @@ add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
type = non_reference (argtypes[i]);
if (i != 0 || ! ref1)
{
- type = TYPE_MAIN_VARIANT (type_decays_to (type));
+ type = type_decays_to (type);
if (enum_p && UNSCOPED_ENUM_P (type))
types[i] = tree_cons (NULL_TREE, type, types[i]);
if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
@@ -2537,8 +2537,8 @@ add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
{
tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
- if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
- ctype))
+ if (arg_types && (same_type_ignoring_top_level_qualifiers_p
+ (TREE_VALUE (arg_types), ctype)))
goto fail;
}
@@ -3552,8 +3552,7 @@ conditional_conversion (tree e1, tree e2)
if (good_base && at_least_as_qualified_p (t2, t1))
{
conv = build_identity_conv (t1, e1);
- if (!same_type_p (TYPE_MAIN_VARIANT (t1),
- TYPE_MAIN_VARIANT (t2)))
+ if (!same_type_ignoring_top_level_qualifiers_p (t1, t2))
conv = build_conv (ck_base, t2, conv);
else
conv = build_conv (ck_rvalue, t2, conv);
@@ -4408,8 +4407,8 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
case NE_EXPR:
if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
&& TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
- && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
- != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
+ && !(same_type_ignoring_top_level_qualifiers_p
+ (TREE_TYPE (arg1), TREE_TYPE (arg2)))
&& (complain & tf_warning))
{
warning (OPT_Wenum_compare,
@@ -5422,7 +5422,7 @@ finish_struct_1 (tree t)
for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
&& TREE_TYPE (x) != error_mark_node
- && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
+ && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (x), t))
DECL_MODE (x) = TYPE_MODE (t);
/* Done with FIELDS...now decide whether to sort these for
@@ -1180,8 +1180,8 @@ cxx_omp_predetermined_sharing (tree decl)
if (outer)
for (var = BLOCK_VARS (outer); var; var = TREE_CHAIN (var))
if (DECL_NAME (decl) == DECL_NAME (var)
- && (TYPE_MAIN_VARIANT (type)
- == TYPE_MAIN_VARIANT (TREE_TYPE (var))))
+ && (same_type_ignoring_top_level_qualifiers_p
+ (type, TREE_TYPE (var))))
{
if (TYPE_READONLY (TREE_TYPE (var)))
type = TREE_TYPE (var);
@@ -293,7 +293,7 @@ typedef struct ptrmem_cst * ptrmem_cst_t;
/* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
top-level qualifiers. */
#define same_type_ignoring_top_level_qualifiers_p(TYPE1, TYPE2) \
- same_type_p (TYPE_MAIN_VARIANT (TYPE1), TYPE_MAIN_VARIANT (TYPE2))
+ same_type_p (cv_unqualified (TYPE1), cv_unqualified (TYPE2))
/* Nonzero if we are presently building a statement tree, rather
than expanding each statement as we encounter it. */
@@ -123,9 +123,7 @@ cp_convert_to_pointer (tree type, tree expr)
if (POINTER_TYPE_P (intype))
{
- intype = TYPE_MAIN_VARIANT (intype);
-
- if (TYPE_MAIN_VARIANT (type) != intype
+ if (!same_type_ignoring_top_level_qualifiers_p (type, intype)
&& TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
@@ -141,8 +139,9 @@ cp_convert_to_pointer (tree type, tree expr)
intype_class = TREE_TYPE (intype);
type_class = TREE_TYPE (type);
- same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class),
- TYPE_MAIN_VARIANT (type_class));
+ same_p = (same_type_ignoring_top_level_qualifiers_p
+ (intype_class, type_class));
+
binfo = NULL_TREE;
/* Try derived to base conversion. */
if (!same_p)
@@ -253,9 +252,7 @@ convert_to_pointer_force (tree type, tree expr)
if (form == POINTER_TYPE)
{
- intype = TYPE_MAIN_VARIANT (intype);
-
- if (TYPE_MAIN_VARIANT (type) != intype
+ if (!same_type_ignoring_top_level_qualifiers_p (type, intype)
&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
@@ -332,7 +329,7 @@ build_up_reference (tree type, tree arg, int flags, tree decl)
return error_mark_node;
if ((flags & LOOKUP_PROTECT)
- && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
+ && !same_type_ignoring_top_level_qualifiers_p (argtype, target_type)
&& MAYBE_CLASS_TYPE_P (argtype)
&& MAYBE_CLASS_TYPE_P (target_type))
{
@@ -395,7 +392,7 @@ tree
convert_to_reference (tree reftype, tree expr, int convtype,
int flags, tree decl)
{
- tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
+ tree type = cv_unqualified (TREE_TYPE (reftype));
tree intype;
tree rval = NULL_TREE;
tree rval_as_conversion = NULL_TREE;
@@ -415,7 +412,7 @@ convert_to_reference (tree reftype, tree expr, int convtype,
gcc_assert (TREE_CODE (intype) != REFERENCE_TYPE);
gcc_assert (TREE_CODE (reftype) == REFERENCE_TYPE);
- intype = TYPE_MAIN_VARIANT (intype);
+ intype = cv_unqualified (intype);
can_convert_intype_to_type = can_convert (type, intype);
if (!can_convert_intype_to_type
@@ -926,19 +926,12 @@ cp_build_qualified_type_real (tree type,
return result;
}
-/* Return TYPE with const and volatile removed. */
+/* Return TYPE with const, volatile and restrict removed. */
tree
cv_unqualified (tree type)
{
- int quals;
-
- if (type == error_mark_node)
- return type;
-
- quals = cp_type_quals (type);
- quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
- return cp_build_qualified_type (type, quals);
+ return cp_build_qualified_type (type, TYPE_UNQUALIFIED);
}
/* Builds a qualified variant of T that is not a typedef variant.
commit 1514f0d2849c03c7c10dbe42e5a9daac6a19008d
Author: Jason Merrill <jason@redhat.com>
Date: Fri May 28 11:05:32 2010 -0400
more type_main_variant
@@ -1110,6 +1110,7 @@ enum languages { lang_c, lang_cplusplus, lang_java };
/* The _DECL for this _TYPE. */
#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
+#define TYPE_MAIN_NAME(NODE) (TYPE_NAME (TYPE_MAIN_VARIANT (NODE)))
/* Nonzero if T is a class (or struct or union) type. Also nonzero
for template type parameters, typename types, and instantiated
@@ -5256,6 +5257,7 @@ extern bool type_has_nontrivial_copy_init (const_tree);
extern bool class_tmpl_impl_spec_p (const_tree);
extern int zero_init_p (const_tree);
extern tree strip_typedefs (tree);
+extern tree strip_top_typedef (tree);
extern bool typedef_variant_p (tree);
extern void cp_set_underlying_type (tree);
extern tree copy_binfo (tree, tree, tree,
@@ -1303,7 +1303,7 @@ type_promotes_to (tree type)
if (type == error_mark_node)
return error_mark_node;
- type = TYPE_MAIN_VARIANT (type);
+ type = cv_unqualified (type);
/* Check for promotions of target-defined types first. */
promoted_type = targetm.promoted_type (type);
@@ -5028,7 +5028,7 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
braces); a wchar_t array can be initialized by a wide
string-literal (optionally enclosed in braces). */
if (TREE_CODE (type) == ARRAY_TYPE
- && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
+ && char_type_p (cv_unqualified (TREE_TYPE (type))))
{
tree str_init = init;
@@ -6506,7 +6506,7 @@ cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
FIXME: this code is duplicated from reshape_init. Probably
we should just call reshape_init here? */
- if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
+ if (char_type_p (cv_unqualified (TREE_TYPE (*ptype)))
&& TREE_CODE (initial_value) == CONSTRUCTOR
&& !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
{
@@ -7203,7 +7203,7 @@ build_ptrmemfunc_type (tree type)
type first. */
if (cp_type_quals (type) != TYPE_UNQUALIFIED)
unqualified_variant
- = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
+ = build_ptrmemfunc_type (cv_unqualified (type));
t = make_class_type (RECORD_TYPE);
xref_basetypes (t, NULL_TREE);
@@ -8175,7 +8175,7 @@ grokdeclarator (const cp_declarator *declarator,
&& !(typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
&& TREE_CODE (type) == INTEGER_TYPE
- && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
+ && !same_type_p (cv_unqualified (type), wchar_type_node)))
{
if (explicit_int128)
type = int128_unsigned_type_node;
@@ -9158,7 +9158,7 @@ grokdeclarator (const cp_declarator *declarator,
"declare static member functions")
: G_("qualified function types cannot be used to "
"declare free functions"));
- type = TYPE_MAIN_VARIANT (type);
+ type = apply_memfn_quals (type, TYPE_UNQUALIFIED);
}
/* The qualifiers on the function type become the qualifiers on
@@ -547,17 +547,14 @@ dump_aggr_type (tree t, int flags)
if (name)
{
- typdef = !DECL_ARTIFICIAL (name);
-
- if ((typdef
- && ((flags & TFF_CHASE_TYPEDEF)
- || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
- && DECL_TEMPLATE_INFO (name))))
- || DECL_SELF_REFERENCE_P (name))
+ while (((typdef = !DECL_ARTIFICIAL (name))
+ && ((flags & TFF_CHASE_TYPEDEF)
+ || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
+ && DECL_TEMPLATE_INFO (name))))
+ || DECL_SELF_REFERENCE_P (name))
{
- t = TYPE_MAIN_VARIANT (t);
+ t = DECL_ORIGINAL_TYPE (name);
name = TYPE_NAME (t);
- typdef = 0;
}
tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
@@ -1183,7 +1180,7 @@ find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
else if (TREE_CODE (*tp) == TYPENAME_TYPE
|| TREE_CODE (*tp) == DECLTYPE_TYPE)
/* Add the typename without any cv-qualifiers. */
- mv = TYPE_MAIN_VARIANT (*tp);
+ mv = cv_unqualified (*tp);
if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
VEC_safe_push (tree, gc, d->typenames, mv);
@@ -102,7 +102,7 @@ prepare_eh_type (tree type)
type = non_reference (type);
/* Peel off cv qualifiers. */
- type = TYPE_MAIN_VARIANT (type);
+ type = cv_unqualified (type);
/* Functions and arrays decay to pointers. */
type = type_decays_to (type);
@@ -3130,7 +3130,7 @@ build_delete (tree type, tree addr, special_function_kind auto_delete,
if (type == error_mark_node)
return error_mark_node;
- type = TYPE_MAIN_VARIANT (type);
+ type = cv_unqualified (type);
addr = mark_rvalue_use (addr);
@@ -3138,7 +3138,7 @@ build_delete (tree type, tree addr, special_function_kind auto_delete,
{
bool complete_p = true;
- type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
+ type = cv_unqualified (TREE_TYPE (type));
if (TREE_CODE (type) == ARRAY_TYPE)
goto handle_array;
@@ -157,7 +157,6 @@ static int decl_is_template_id (const tree, tree* const);
/* Functions for handling substitutions. */
-static inline tree canonicalize_for_substitution (tree);
static void add_substitution (tree);
static inline int is_std_substitution (const tree,
const substitution_identifier_index_t);
@@ -330,49 +329,16 @@ dump_substitution_candidates (void)
}
}
-/* Both decls and types can be substitution candidates, but sometimes
- they refer to the same thing. For instance, a TYPE_DECL and
- RECORD_TYPE for the same class refer to the same thing, and should
- be treated accordingly in substitutions. This function returns a
- canonicalized tree node representing NODE that is used when adding
- and substitution candidates and finding matches. */
-
-static inline tree
-canonicalize_for_substitution (tree node)
-{
- /* For a TYPE_DECL, use the type instead. */
- if (TREE_CODE (node) == TYPE_DECL)
- node = TREE_TYPE (node);
- if (TYPE_P (node)
- && TYPE_CANONICAL (node) != node
- && TYPE_MAIN_VARIANT (node) != node)
- /* Here we want to strip the topmost typedef only.
- We need to do that so is_std_substitution can do proper
- name matching. */
- node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
- cp_type_quals (node));
- return node;
-}
-
/* Add NODE as a substitution candidate. NODE must not already be on
the list of candidates. */
static void
add_substitution (tree node)
{
- tree c;
-
if (DEBUG_MANGLE)
fprintf (stderr, " ++ add_substitution (%s at %10p)\n",
tree_code_name[TREE_CODE (node)], (void *) node);
- /* Get the canonicalized substitution candidate for NODE. */
- c = canonicalize_for_substitution (node);
- if (DEBUG_MANGLE && c != node)
- fprintf (stderr, " ++ using candidate (%s at %10p)\n",
- tree_code_name[TREE_CODE (node)], (void *) node);
- node = c;
-
#if ENABLE_CHECKING
/* Make sure NODE isn't already a candidate. */
{
@@ -414,7 +380,7 @@ is_std_substitution (const tree node,
else if (CLASS_TYPE_P (node))
{
type = node;
- decl = TYPE_NAME (node);
+ decl = TYPE_MAIN_NAME (node);
}
else
/* These are not the droids you're looking for. */
@@ -500,13 +466,9 @@ find_substitution (tree node)
fprintf (stderr, " ++ find_substitution (%s at %p)\n",
tree_code_name[TREE_CODE (node)], (void *) node);
- /* Obtain the canonicalized substitution representation for NODE.
- This is what we'll compare against. */
- node = canonicalize_for_substitution (node);
-
/* Check for builtin substitutions. */
- decl = TYPE_P (node) ? TYPE_NAME (node) : node;
+ decl = TYPE_P (node) ? TYPE_MAIN_NAME (node) : node;
type = TYPE_P (node) ? node : TREE_TYPE (node);
/* Check for std::allocator. */
@@ -773,7 +735,7 @@ write_name (tree decl, const int ignore_local_scope)
{
/* In case this is a typedef, fish out the corresponding
TYPE_DECL for the main variant. */
- decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
+ decl = TYPE_MAIN_NAME (TREE_TYPE (decl));
}
context = decl_mangling_context (decl);
@@ -1790,9 +1752,9 @@ write_type (tree type)
mangle the unqualified type. The recursive call is needed here
since both the qualified and unqualified types are substitution
candidates. */
- write_type (TYPE_MAIN_VARIANT (type));
+ write_type (cv_unqualified (type));
else if (TREE_CODE (type) == ARRAY_TYPE)
- /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
+ /* It is important not to use the cv_unqualified of TYPE here
so that the cv-qualification of the element type is available
in write_array_type. */
write_array_type (type);
@@ -1800,9 +1762,6 @@ write_type (tree type)
{
tree type_orig = type;
- /* See through any typedefs. */
- type = TYPE_MAIN_VARIANT (type);
-
if (TYPE_PTRMEM_P (type))
write_pointer_to_member_type (type);
else
@@ -1831,13 +1790,8 @@ write_type (tree type)
case INTEGER_TYPE: /* Includes wchar_t. */
case REAL_TYPE:
case FIXED_POINT_TYPE:
- {
- /* If this is a typedef, TYPE may not be one of
- the standard builtin type nodes, but an alias of one. Use
- TYPE_MAIN_VARIANT to get to the underlying builtin type. */
- write_builtin_type (TYPE_MAIN_VARIANT (type));
- ++is_builtin_type;
- }
+ write_builtin_type (type);
+ ++is_builtin_type;
break;
case COMPLEX_TYPE:
@@ -1865,7 +1819,7 @@ write_type (tree type)
case UNBOUND_CLASS_TEMPLATE:
/* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
ordinary nested names. */
- write_nested_name (TYPE_STUB_DECL (type));
+ write_nested_name (TYPE_MAIN_NAME (type));
break;
case POINTER_TYPE:
@@ -2329,7 +2283,7 @@ write_method_parms (tree parm_types, const int method_p, const tree decl)
static void
write_class_enum_type (const tree type)
{
- write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
+ write_name (TYPE_MAIN_NAME (type), /*ignore_local_scope=*/0);
}
/* Non-terminal <template-args>. ARGS is a TREE_VEC of template
@@ -3481,7 +3481,7 @@ process_template_parm (tree list, location_t parm_loc, tree parm, bool is_non_ty
The top-level cv-qualifiers on the template-parameter are
ignored when determining its type. */
- TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
+ TREE_TYPE (parm) = cv_unqualified (TREE_TYPE (parm));
if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
{
err_parm_list = build_tree_list (defval, parm);
@@ -9708,7 +9708,7 @@ tsubst_arg_types (tree arg_types,
/* Do array-to-pointer, function-to-pointer conversion, and ignore
top-level qualifiers as required. */
- type = TYPE_MAIN_VARIANT (type_decays_to (type));
+ type = cv_unqualified (type_decays_to (type));
/* We do not substitute into default arguments here. The standard
mandates that they be instantiated only when needed, which is
@@ -10166,7 +10166,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
case BOUND_TEMPLATE_TEMPLATE_PARM:
if (cp_type_quals (t))
{
- r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
+ r = tsubst (cv_unqualified (t), args, complain, in_decl);
r = cp_build_qualified_type_real
(r, cp_type_quals (t),
complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
@@ -252,7 +252,7 @@ get_tinfo_decl_dynamic (tree exp)
type = non_reference (TREE_TYPE (exp));
/* Peel off cv qualifiers. */
- type = TYPE_MAIN_VARIANT (type);
+ type = cv_unqualified (type);
/* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
if (CLASS_TYPE_P (type) || type == unknown_type_node
@@ -276,7 +276,7 @@ get_tinfo_decl_dynamic (tree exp)
}
else
/* Otherwise return the type_info for the static type of the expr. */
- t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
+ t = get_tinfo_ptr (type);
return cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);
}
@@ -300,7 +300,7 @@ typeid_ok_p (void)
pseudo_type_info
= VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE)->type;
- type_info_type = TYPE_MAIN_VARIANT (const_type_info_type_node);
+ type_info_type = cv_unqualified (const_type_info_type_node);
/* Make sure abi::__type_info_pseudo has the same alias set
as std::type_info. */
@@ -4967,7 +4967,7 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p)
else if (expr == current_class_ptr)
/* If the expression is just "this", we want the
cv-unqualified pointer for the "this" type. */
- type = TYPE_MAIN_VARIANT (type);
+ type = cv_unqualified (type);
else if (real_lvalue_p (expr))
{
if (TREE_CODE (type) != REFERENCE_TYPE)
@@ -5568,7 +5568,7 @@ apply_lambda_return_type (tree lambda, tree return_type)
Now we need to redo the work it and allocate_struct_function
did to reflect the new type. */
result = build_decl (input_location, RESULT_DECL, NULL_TREE,
- TYPE_MAIN_VARIANT (return_type));
+ cv_unqualified (return_type));
DECL_ARTIFICIAL (result) = 1;
DECL_IGNORED_P (result) = 1;
cp_apply_type_quals_to_decl (cp_type_quals (return_type),
@@ -531,7 +531,7 @@ convert_bitfield_to_declared_type (tree expr)
bitfield_type = is_bitfield_expr_with_lowered_type (expr);
if (bitfield_type)
- expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
+ expr = convert_to_integer (cv_unqualified (bitfield_type),
expr);
return expr;
}
@@ -662,6 +662,7 @@ build_cplus_array_type (tree elt_type, tree index_type)
else
t = build_array_type (elt_type, index_type);
+ /* FIXME do we still need this? */
/* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
element type as well, so fix it up if needed. */
if (elt_type != TYPE_MAIN_VARIANT (elt_type))
@@ -952,7 +953,7 @@ cv_unqualified (tree type)
* If T is a type that needs structural equality
its TYPE_CANONICAL (T) will be NULL.
* TYPE_CANONICAL (T) desn't carry type attributes
- and looses template parameter names. */
+ and loses template parameter names. */
tree
strip_typedefs (tree t)
@@ -1042,12 +1043,27 @@ strip_typedefs (tree t)
}
if (!result)
- result = TYPE_MAIN_VARIANT (t);
+ return strip_top_typedef (t);
if (TYPE_ATTRIBUTES (t))
result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
return cp_build_qualified_type (result, cp_type_quals (t));
}
+/* Strip just the topmost typedef from TYPE, don't recurse. */
+
+tree
+strip_top_typedef (tree type)
+{
+ tree t = type;
+ if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
+ return t;
+ while (typedef_variant_p (t))
+ t = DECL_ORIGINAL_TYPE (TYPE_NAME (t));
+ t = cp_build_type_attribute_variant (t, TYPE_ATTRIBUTES (type));
+ t = cp_build_qualified_type (t, cp_type_quals (type));
+ return type;
+}
+
/* Returns true iff TYPE is a type variant created for a typedef. */
bool
@@ -2311,7 +2327,7 @@ maybe_dummy_object (tree type, tree* binfop)
/* Kludge: Make sure that current_class_type is actually
correct. It might not be if we're in the middle of
tsubst_default_argument. */
- && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
+ && same_type_p (cv_unqualified (TREE_TYPE (current_class_ref)),
current_class_type))
decl = current_class_ref;
else if (current != current_class_type
@@ -2037,7 +2037,7 @@ string_conv_p (const_tree totype, const_tree exp, int warn)
if (TREE_CODE (exp) == STRING_CST)
{
/* Make sure that we don't try to convert between char and wide chars. */
- if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
+ if (!same_type_p (cv_unqualified (TREE_TYPE (TREE_TYPE (exp))), t))
return 0;
}
else
@@ -2430,7 +2430,7 @@ lookup_destructor (tree object, tree scope, tree dtor_name)
else if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
{
error ("the type being destroyed is %qT, but the destructor refers to %qT",
- TYPE_MAIN_VARIANT (object_type), dtor_type);
+ cv_unqualified (object_type), dtor_type);
return error_mark_node;
}
expr = lookup_member (dtor_type, complete_dtor_identifier,
@@ -5868,10 +5868,10 @@ build_static_cast_1 (tree type, tree expr, bool c_cast_p,
{
t1 = (build_ptrmem_type
(c1,
- TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
+ cv_unqualified (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
t2 = (build_ptrmem_type
(c2,
- TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
+ cv_unqualified (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
}
else
{
@@ -6414,10 +6414,10 @@ cp_build_c_cast (tree type, tree expr, tsubst_flags_t complain)
/* Non-class rvalues always have cv-unqualified type. */
if (!CLASS_TYPE_P (type))
- type = TYPE_MAIN_VARIANT (type);
+ type = cv_unqualified (type);
result_type = TREE_TYPE (result);
if (!CLASS_TYPE_P (result_type))
- result_type = TYPE_MAIN_VARIANT (result_type);
+ result_type = cv_unqualified (result_type);
/* If the type of RESULT does not match TYPE, perform a
const_cast to make it match. If the static_cast or
reinterpret_cast succeeded, we will differ by at most
@@ -6692,8 +6692,8 @@ cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
newrhs = digest_init (lhstype, newrhs);
}
- else if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
- TYPE_MAIN_VARIANT (TREE_TYPE (newrhs))))
+ else if (!same_or_base_type_p (cv_unqualified (lhstype),
+ cv_unqualified (TREE_TYPE (newrhs))))
{
if (complain & tf_error)
error ("incompatible types in assignment of %qT to %qT",
@@ -7625,8 +7625,8 @@ check_return_expr (tree retval, bool *no_warning)
/* The cv-unqualified type of the returned value must be the
same as the cv-unqualified return type of the
function. */
- && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
- (TYPE_MAIN_VARIANT
+ && same_type_p ((cv_unqualified (TREE_TYPE (retval))),
+ (cv_unqualified
(TREE_TYPE (TREE_TYPE (current_function_decl)))))
/* And the returned value must be non-volatile. */
&& ! TYPE_VOLATILE (TREE_TYPE (retval)));
@@ -7842,7 +7842,7 @@ ptr_reasonably_similar (const_tree to, const_tree from)
if (TREE_CODE (to) != POINTER_TYPE)
return comptypes
- (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
+ (cv_unqualified (to), cv_unqualified (from),
COMPARE_BASE | COMPARE_DERIVED);
}
}
@@ -8094,8 +8094,8 @@ casts_away_constness (tree t1, tree t2)
return false;
/* Top-level qualifiers don't matter. */
- t1 = TYPE_MAIN_VARIANT (t1);
- t2 = TYPE_MAIN_VARIANT (t2);
+ t1 = cv_unqualified (t1);
+ t2 = cv_unqualified (t2);
casts_away_constness_r (&t1, &t2);
if (!can_convert (t2, t1))
return true;
commit 324274d188ce37bd894619d2b4a27046f8d4ab78
Author: Jason Merrill <jason@redhat.com>
Date: Fri May 28 12:08:37 2010 -0400
still more
@@ -981,8 +981,8 @@ standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
bool
reference_related_p (tree t1, tree t2)
{
- t1 = TYPE_MAIN_VARIANT (t1);
- t2 = TYPE_MAIN_VARIANT (t2);
+ t1 = cv_unqualified (t1);
+ t2 = cv_unqualified (t2);
/* [dcl.init.ref]
@@ -4002,12 +4002,7 @@ static tree
prep_operand (tree operand)
{
if (operand)
- {
- if (CLASS_TYPE_P (TREE_TYPE (operand))
- && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
- /* Make sure the template type is instantiated now. */
- instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
- }
+ complete_type (TREE_TYPE (operand));
return operand;
}
@@ -4056,7 +4051,7 @@ add_candidates (tree fns, tree first_arg, const VEC(tree,gc) *args,
is considered to be a member of the class of the implicit
object argument for the purpose of defining the type of
the implicit object parameter. */
- ctype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (first_arg)));
+ ctype = TREE_TYPE (TREE_TYPE (first_arg));
}
else
{
@@ -5410,7 +5405,7 @@ convert_for_arg_passing (tree type, tree val)
bitfield_type = is_bitfield_expr_with_lowered_type (val);
if (bitfield_type
&& TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
- val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
+ val = convert_to_integer (cv_unqualified (bitfield_type), val);
if (val == error_mark_node)
;
@@ -6267,7 +6262,7 @@ build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
fn = get_first_fn (fns);
name = DECL_NAME (fn);
- basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
+ basetype = TREE_TYPE (instance);
gcc_assert (CLASS_TYPE_P (basetype));
if (processing_template_decl)
@@ -1111,6 +1111,7 @@ enum languages { lang_c, lang_cplusplus, lang_java };
/* The _DECL for this _TYPE. */
#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
#define TYPE_MAIN_NAME(NODE) (TYPE_NAME (TYPE_MAIN_VARIANT (NODE)))
+#define TYPE_MAIN_IDENTIFIER(NODE) (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
/* Nonzero if T is a class (or struct or union) type. Also nonzero
for template type parameters, typename types, and instantiated
@@ -747,8 +747,6 @@ ocp_convert (tree type, tree expr, int convtype, int flags)
tree dtype = TREE_TYPE (e);
tree ctor = NULL_TREE;
- dtype = TYPE_MAIN_VARIANT (dtype);
-
/* Conversion between aggregate types. New C++ semantics allow
objects of derived type to be cast to objects of base type.
Old semantics only allowed this between pointers.
@@ -4185,7 +4185,7 @@ start_decl (const cp_declarator *declarator,
(7.1.3p8), apply any attributes directly to the type. */
if (TREE_CODE (decl) == TYPE_DECL
&& TAGGED_TYPE_P (TREE_TYPE (decl))
- && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
+ && decl == TYPE_MAIN_NAME (TREE_TYPE (decl)))
flags = ATTR_FLAG_TYPE_IN_PLACE;
else
flags = 0;
@@ -8829,7 +8829,6 @@ grokdeclarator (const cp_declarator *declarator,
tree t;
ctype = declarator->u.id.qualifying_scope;
- ctype = TYPE_MAIN_VARIANT (ctype);
t = ctype;
while (t != NULL_TREE && CLASS_TYPE_P (t))
{
@@ -9212,7 +9211,7 @@ grokdeclarator (const cp_declarator *declarator,
{
/* A friendly class? */
if (current_class_type)
- make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
+ make_friend_class (current_class_type, type,
/*complain=*/true);
else
error ("trying to make class %qT a friend of global scope",
@@ -10162,7 +10161,7 @@ move_fn_p (const_tree d)
if (TREE_CODE (arg_type) == REFERENCE_TYPE
&& TYPE_REF_IS_RVALUE (arg_type)
- && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
+ && same_type_p (cv_unqualified (TREE_TYPE (arg_type)),
DECL_CONTEXT (d)))
result = true;
@@ -10471,9 +10470,9 @@ grok_op_properties (tree decl, bool complain)
int ref = (TREE_CODE (t) == REFERENCE_TYPE);
if (ref)
- t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
+ t = TREE_TYPE (t);
- if (TREE_CODE (t) == VOID_TYPE)
+ if (VOID_TYPE_P (t))
warning (OPT_Wconversion,
ref
? G_("conversion to a reference to void "
@@ -10482,7 +10481,7 @@ grok_op_properties (tree decl, bool complain)
"will never use a type conversion operator"));
else if (class_type)
{
- if (t == class_type)
+ if (same_type_p (t, class_type))
warning (OPT_Wconversion,
ref
? G_("conversion to a reference to the same type "
@@ -10590,19 +10589,17 @@ grok_op_properties (tree decl, bool complain)
tree ret = TREE_TYPE (TREE_TYPE (decl));
if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
arg = TREE_TYPE (arg);
- arg = TYPE_MAIN_VARIANT (arg);
if (operator_code == PREINCREMENT_EXPR
|| operator_code == PREDECREMENT_EXPR)
{
if (TREE_CODE (ret) != REFERENCE_TYPE
- || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
- arg))
+ || !same_type_p (TREE_TYPE (ret), arg))
warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
build_reference_type (arg));
}
else
{
- if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
+ if (!same_type_p (ret, arg))
warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
}
}
@@ -869,7 +869,7 @@ grokfield (const cp_declarator *declarator,
/* If this is a typedef that names the class for linkage purposes
(7.1.3p8), apply any attributes directly to the type. */
if (TAGGED_TYPE_P (TREE_TYPE (value))
- && value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))))
+ && value == TYPE_MAIN_NAME (TREE_TYPE (value)))
attrflags = ATTR_FLAG_TYPE_IN_PLACE;
cplus_decl_attributes (&value, attrlist, attrflags);
@@ -877,7 +877,7 @@ grokfield (const cp_declarator *declarator,
if (declspecs->specs[(int)ds_typedef]
&& TREE_TYPE (value) != error_mark_node
- && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value)
+ && TYPE_MAIN_NAME (TREE_TYPE (value)) != value)
cp_set_underlying_type (value);
return value;
@@ -256,6 +256,8 @@ make_friend_class (tree type, tree friend_type, bool complain)
return;
}
+ friend_type = TYPE_MAIN_VARIANT (friend_type);
+
/* [temp.friend]
A friend of a class or class template can be a function or
@@ -1038,8 +1038,6 @@ make_id_declarator (tree qualifying_scope, tree unqualified_name,
legal; as of 2002-09-15 the committee is considering that
question. EDG 3.0 allows that syntax. Therefore, we do as
well. */
- if (qualifying_scope && TYPE_P (qualifying_scope))
- qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
|| TREE_CODE (unqualified_name) == BIT_NOT_EXPR
@@ -4577,15 +4575,7 @@ cp_parser_nested_name_specifier_opt (cp_parser *parser,
&& !COMPLETE_TYPE_P (new_scope)
/* Do not try to complete dependent types. */
&& !dependent_type_p (new_scope))
- {
- new_scope = complete_type (new_scope);
- /* If it is a typedef to current class, use the current
- class instead, as the typedef won't have any names inside
- it yet. */
- if (!COMPLETE_TYPE_P (new_scope)
- && currently_open_class (new_scope))
- new_scope = TYPE_MAIN_VARIANT (new_scope);
- }
+ new_scope = complete_type (new_scope);
/* Make sure we look in the right scope the next time through
the loop. */
parser->scope = new_scope;
@@ -7699,6 +7699,8 @@ instantiate_class_template (tree type)
if (type == error_mark_node)
return error_mark_node;
+ type = TYPE_MAIN_VARIANT (type);
+
if (TYPE_BEING_DEFINED (type)
|| COMPLETE_TYPE_P (type)
|| uses_template_parms (type))
@@ -13391,7 +13393,7 @@ maybe_adjust_types_for_deduction (unification_kind_t strict,
else if (TREE_CODE (*arg) == FUNCTION_TYPE)
*arg = build_pointer_type (*arg);
else
- *arg = TYPE_MAIN_VARIANT (*arg);
+ *arg = cv_unqualified (*arg);
}
/* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
@@ -13410,7 +13412,7 @@ maybe_adjust_types_for_deduction (unification_kind_t strict,
of P's type are ignored for type deduction. If P is a
reference type, the type referred to by P is used for
type deduction. */
- *parm = TYPE_MAIN_VARIANT (*parm);
+ *parm = cv_unqualified (*parm);
if (TREE_CODE (*parm) == REFERENCE_TYPE)
{
*parm = TREE_TYPE (*parm);
@@ -15424,8 +15426,8 @@ more_specialized_fn (tree pat1, tree pat2, int len)
}
}
- arg1 = TYPE_MAIN_VARIANT (arg1);
- arg2 = TYPE_MAIN_VARIANT (arg2);
+ arg1 = cv_unqualified (arg1);
+ arg2 = cv_unqualified (arg2);
if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
{
@@ -17318,7 +17320,7 @@ dependent_type_p_r (tree type)
return true;
/* -- a cv-qualified type where the cv-unqualified type is
dependent. */
- type = TYPE_MAIN_VARIANT (type);
+ type = cv_unqualified (type);
/* -- a compound type constructed from any dependent type. */
if (TYPE_PTR_TO_MEMBER_P (type))
return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
@@ -18074,7 +18076,7 @@ resolve_typename_type (tree type, bool only_current_p)
So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
TYPENAME_TYPE instead, we avoid messing up with a possible
typedef variant case. */
- name = TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
+ name = TYPE_MAIN_IDENTIFIER (type);
/* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
it first before we can figure out what NAME refers to. */
@@ -394,6 +394,8 @@ get_tinfo_decl (tree type)
tree name;
tree d;
+ type = TYPE_MAIN_VARIANT (type);
+
if (variably_modified_type_p (type, /*fn=*/NULL_TREE))
{
error ("cannot create type information for type %qT because "
@@ -410,7 +412,7 @@ get_tinfo_decl (tree type)
itself. */
if (CLASS_TYPE_P (type))
{
- d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
+ d = CLASSTYPE_TYPEINFO_VAR (type);
if (d)
return d;
}
@@ -440,7 +442,7 @@ get_tinfo_decl (tree type)
d = pushdecl_top_level_and_finish (d, NULL_TREE);
if (CLASS_TYPE_P (type))
- CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
+ CLASSTYPE_TYPEINFO_VAR (type) = d;
/* Add decl to the global array of tinfo decls. */
VEC_safe_push (tree, gc, unemitted_tinfo_decls, d);
@@ -480,7 +482,7 @@ get_typeid (tree type)
/* The top-level cv-qualifiers of the lvalue expression or the type-id
that is the operand of typeid are always ignored. */
- type = TYPE_MAIN_VARIANT (type);
+ type = cv_unqualified (type);
/* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
if (CLASS_TYPE_P (type) || type == unknown_type_node
@@ -689,8 +691,8 @@ build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
return error_mark_node;
}
- target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
- static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
+ target_type = TREE_TYPE (type);
+ static_type = TREE_TYPE (exprtype);
td2 = get_tinfo_decl (target_type);
mark_used (td2);
td2 = cp_build_unary_op (ADDR_EXPR, td2, 0, complain);
@@ -971,8 +973,7 @@ ptr_initializer (tinfo_s *ti, tree target)
flags |= 8;
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags));
- CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
- get_tinfo_ptr (TYPE_MAIN_VARIANT (to)));
+ CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, get_tinfo_ptr (to));
init = build_constructor (init_list_type_node, v);
TREE_CONSTANT (init) = 1;
@@ -1001,8 +1002,7 @@ ptm_initializer (tinfo_s *ti, tree target)
flags |= 0x10;
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags));
- CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
- get_tinfo_ptr (TYPE_MAIN_VARIANT (to)));
+ CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, get_tinfo_ptr (to));
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, get_tinfo_ptr (klass));
init = build_constructor (init_list_type_node, v);
@@ -360,7 +360,9 @@ dcast_base_hint (tree subtype, tree target)
{
struct dcast_data_s data;
- data.subtype = subtype;
+ target = TYPE_MAIN_VARIANT (target);
+
+ data.subtype = TYPE_MAIN_VARIANT (subtype);
data.virt_depth = 0;
data.offset = NULL_TREE;
data.repeated_base = CLASSTYPE_REPEATED_BASE_P (target);
@@ -125,7 +125,7 @@ complete_type (tree type)
}
}
else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
- instantiate_class_template (TYPE_MAIN_VARIANT (type));
+ instantiate_class_template (type);
return type;
}
@@ -2124,7 +2124,7 @@ lookup_anon_field (tree t, tree type)
/* If we find it directly, return the field. */
if (DECL_NAME (field) == NULL_TREE
- && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
+ && type == TREE_TYPE (field))
{
return field;
}
@@ -2244,8 +2244,8 @@ build_class_member_access_expr (tree object, tree member,
&& integer_zerop (TREE_OPERAND (object, 0)));
/* Convert OBJECT to the type of MEMBER. */
- if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
- TYPE_MAIN_VARIANT (member_scope)))
+ if (!same_type_ignoring_top_level_qualifiers_p (object_type,
+ member_scope))
{
tree binfo;
base_kind kind;
@@ -2427,7 +2427,7 @@ lookup_destructor (tree object, tree scope, tree dtor_name)
}
}
- else if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
+ else if (!DERIVED_FROM_P (dtor_type, object_type))
{
error ("the type being destroyed is %qT, but the destructor refers to %qT",
cv_unqualified (object_type), dtor_type);
@@ -5070,7 +5070,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
contains an extra const qualifier. TYPE_MAIN_VARIANT
is used here to remove this const from the diagnostics
and the created OFFSET_REF. */
- tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
+ tree base = cv_unqualified (TREE_TYPE (TREE_OPERAND (arg, 0)));
tree fn = get_first_fn (TREE_OPERAND (arg, 1));
mark_used (fn);
@@ -5724,8 +5724,8 @@ build_static_cast_1 (tree type, tree expr, bool c_cast_p,
&& CLASS_TYPE_P (intype)
&& (TYPE_REF_IS_RVALUE (type) || real_lvalue_p (expr))
&& DERIVED_FROM_P (intype, TREE_TYPE (type))
- && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
- build_pointer_type (TYPE_MAIN_VARIANT
+ && can_convert (build_pointer_type (cv_unqualified (intype)),
+ build_pointer_type (cv_unqualified
(TREE_TYPE (type))))
&& (c_cast_p
|| at_least_as_qualified_p (TREE_TYPE (type), intype)))
@@ -5838,9 +5838,9 @@ build_static_cast_1 (tree type, tree expr, bool c_cast_p,
if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
&& CLASS_TYPE_P (TREE_TYPE (type))
&& CLASS_TYPE_P (TREE_TYPE (intype))
- && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
+ && can_convert (build_pointer_type (cv_unqualified
(TREE_TYPE (intype))),
- build_pointer_type (TYPE_MAIN_VARIANT
+ build_pointer_type (cv_unqualified
(TREE_TYPE (type)))))
{
tree base;
@@ -1493,7 +1493,7 @@ build_m_component_ref (tree datum, tree component)
return error_mark_node;
}
- objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
+ objtype = cv_unqualified (TREE_TYPE (datum));
if (! MAYBE_CLASS_TYPE_P (objtype))
{
error ("cannot apply member pointer %qE to %qE, which is of "
commit 123ca011e01b56ff3608d101fdb19100ced35d41
Author: Jason Merrill <jason@redhat.com>
Date: Fri May 28 15:59:39 2010 -0400
more yet
@@ -294,7 +294,6 @@ typedef struct ptrmem_cst * ptrmem_cst_t;
top-level qualifiers. */
#define same_type_ignoring_top_level_qualifiers_p(TYPE1, TYPE2) \
same_type_p (cv_unqualified (TYPE1), cv_unqualified (TYPE2))
-
/* Nonzero if we are presently building a statement tree, rather
than expanding each statement as we encounter it. */
#define building_stmt_tree() (cur_stmt_list != NULL_TREE)
@@ -8075,7 +8075,8 @@ grokdeclarator (const cp_declarator *declarator,
and check for invalid combinations. */
/* Long double is a special combination. */
- if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
+ if (long_p && !longlong
+ && same_type_ignoring_top_level_qualifiers_p (type, double_type_node))
{
long_p = false;
type = cp_build_qualified_type (long_double_type_node,
@@ -9120,9 +9121,8 @@ grokdeclarator (const cp_declarator *declarator,
We must copy the type, so that the array's domain can be
individually set by the object's initializer. */
- if (type && typedef_type
- && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
- && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
+ if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
+ && typedef_variant_p (type))
type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
/* Detect where we're using a typedef of function type to declare a
@@ -10099,14 +10099,15 @@ copy_fn_p (const_tree d)
if (arg_type == error_mark_node)
return 0;
- if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
+ if (same_type_ignoring_top_level_qualifiers_p (arg_type, DECL_CONTEXT (d)))
{
/* Pass by value copy assignment operator. */
result = -1;
}
else if (TREE_CODE (arg_type) == REFERENCE_TYPE
&& !TYPE_REF_IS_RVALUE (arg_type)
- && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
+ && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (arg_type),
+ DECL_CONTEXT (d)))
{
if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
result = 2;
@@ -256,8 +256,6 @@ make_friend_class (tree type, tree friend_type, bool complain)
return;
}
- friend_type = TYPE_MAIN_VARIANT (friend_type);
-
/* [temp.friend]
A friend of a class or class template can be a function or
@@ -353,6 +351,8 @@ make_friend_class (tree type, tree friend_type, bool complain)
if (friend_type == error_mark_node)
return;
+ friend_type = TYPE_MAIN_VARIANT (friend_type);
+
/* See if it is already a friend. */
for (classes = CLASSTYPE_FRIEND_CLASSES (type);
classes;
@@ -1801,7 +1801,7 @@ set_identifier_type_value (tree id, tree decl)
static inline tree
constructor_name_full (tree type)
{
- return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
+ return TYPE_MAIN_IDENTIFIER (type);
}
/* Return the name for the constructor (or destructor) for the
@@ -2582,7 +2582,7 @@ finish_base_specifier (tree base, tree access, bool virtual_p)
if (cp_type_quals (base) != 0)
{
error ("base class %qT has cv qualifiers", base);
- base = TYPE_MAIN_VARIANT (base);
+ base = cv_unqualified (base);
}
result = build_tree_list (access, base);
if (virtual_p)
@@ -5809,8 +5809,9 @@ lambda_expr_this_capture (tree lambda)
}
else
{
- /* To make sure that current_class_ref is for the lambda. */
- gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)) == TREE_TYPE (lambda));
+ /* Make sure that current_class_ref is for the lambda. */
+ gcc_assert (same_type_ignoring_top_level_qualifiers_p
+ (TREE_TYPE (current_class_ref), TREE_TYPE (lambda)));
result = finish_non_static_data_member (this_capture,
NULL_TREE,
@@ -2866,6 +2866,7 @@ special_function_p (const_tree decl)
int
char_type_p (tree type)
{
+ type = cv_unqualified (type);
return (same_type_p (type, char_type_node)
|| same_type_p (type, unsigned_char_type_node)
|| same_type_p (type, signed_char_type_node)
@@ -263,9 +263,12 @@ cp_common_type (tree t1, tree t2)
attributes. */
attributes = (*targetm.merge_type_attributes) (t1, t2);
+ gcc_assert (t1 == cv_unqualified (t1)
+ && t2 == cv_unqualified (t2));
+
if (SCOPED_ENUM_P (t1) || SCOPED_ENUM_P (t2))
{
- if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
+ if (same_type_p (t1, t2))
return build_type_attribute_variant (t1, attributes);
else
return NULL_TREE;
@@ -321,15 +324,15 @@ cp_common_type (tree t1, tree t2)
return build_type_attribute_variant (t2, attributes);
/* The types are the same; no need to do anything fancy. */
- if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
+ if (same_type_p (t1, t2))
return build_type_attribute_variant (t1, attributes);
if (code1 != REAL_TYPE)
{
/* If one is unsigned long long, then convert the other to unsigned
long long. */
- if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
- || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
+ if (same_type_p (t1, long_long_unsigned_type_node)
+ || same_type_p (t2, long_long_unsigned_type_node))
return build_type_attribute_variant (long_long_unsigned_type_node,
attributes);
/* If one is a long long, and the other is an unsigned long, and
@@ -342,8 +345,8 @@ cp_common_type (tree t1, tree t2)
therefore converting to long long cannot represent all the values
of an unsigned long, so we choose unsigned long long in that
case. */
- if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
- || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
+ if (same_type_p (t1, long_long_integer_type_node)
+ || same_type_p (t2, long_long_integer_type_node))
{
tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
? long_long_unsigned_type_node
@@ -351,10 +354,8 @@ cp_common_type (tree t1, tree t2)
return build_type_attribute_variant (t, attributes);
}
if (int128_integer_type_node != NULL_TREE
- && (same_type_p (TYPE_MAIN_VARIANT (t1),
- int128_integer_type_node)
- || same_type_p (TYPE_MAIN_VARIANT (t2),
- int128_integer_type_node)))
+ && (same_type_p (t1, int128_integer_type_node)
+ || same_type_p (t2, int128_integer_type_node)))
{
tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
? int128_unsigned_type_node
@@ -363,12 +364,12 @@ cp_common_type (tree t1, tree t2)
}
/* Go through the same procedure, but for longs. */
- if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
- || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
+ if (same_type_p (t1, long_unsigned_type_node)
+ || same_type_p (t2, long_unsigned_type_node))
return build_type_attribute_variant (long_unsigned_type_node,
attributes);
- if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
- || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
+ if (same_type_p (t1, long_integer_type_node)
+ || same_type_p (t2, long_integer_type_node))
{
tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
? long_unsigned_type_node : long_integer_type_node);
@@ -382,16 +383,16 @@ cp_common_type (tree t1, tree t2)
}
else
{
- if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
- || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
+ if (same_type_p (t1, long_double_type_node)
+ || same_type_p (t2, long_double_type_node))
return build_type_attribute_variant (long_double_type_node,
attributes);
- if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
- || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
+ if (same_type_p (t1, double_type_node)
+ || same_type_p (t2, double_type_node))
return build_type_attribute_variant (double_type_node,
attributes);
- if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
- || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
+ if (same_type_p (t1, float_type_node)
+ || same_type_p (t2, float_type_node))
return build_type_attribute_variant (float_type_node,
attributes);
@@ -1195,7 +1196,8 @@ incompatible_dependent_types_p (tree t1, tree t2)
At this point, if the main variant type of T1 and T2 are equal
it means the two types can't be incompatible, from the perspective
of this function. */
- if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
+ /* FIXME a4d2e70 typedef33.C? */
+ if (0 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
return false;
/* So if we reach this point, it means either T1 or T2 is a typedef variant.
@@ -1825,8 +1827,9 @@ is_bitfield_expr_with_lowered_type (const_tree exp)
}
CASE_CONVERT:
- if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp, 0)))
- == TYPE_MAIN_VARIANT (TREE_TYPE (exp)))
+ if (same_type_ignoring_top_level_qualifiers_p
+ (TREE_TYPE (TREE_OPERAND (exp, 0)),
+ TREE_TYPE (exp)))
return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
/* Fallthrough. */
@@ -3917,7 +3920,8 @@ cp_build_binary_op (location_t location,
}
/* Convert the shift-count to an integer, regardless of
size of value being shifted. */
- if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
+ if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (op1),
+ integer_type_node))
op1 = cp_convert (integer_type_node, op1);
/* Avoid converting op1 to result_type later. */
converted = 1;
@@ -3945,7 +3949,8 @@ cp_build_binary_op (location_t location,
}
/* Convert the shift-count to an integer, regardless of
size of value being shifted. */
- if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
+ if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (op1),
+ integer_type_node))
op1 = cp_convert (integer_type_node, op1);
/* Avoid converting op1 to result_type later. */
converted = 1;
@@ -3976,7 +3981,8 @@ cp_build_binary_op (location_t location,
}
/* Convert the shift-count to an integer, regardless of
size of value being shifted. */
- if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
+ if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (op1),
+ integer_type_node))
op1 = cp_convert (integer_type_node, op1);
}
break;
@@ -5067,7 +5073,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
a useful error here. */
/* Inside constant member functions, the `this' pointer
- contains an extra const qualifier. TYPE_MAIN_VARIANT
+ contains an extra const qualifier. cv_unqualified
is used here to remove this const from the diagnostics
and the created OFFSET_REF. */
tree base = cv_unqualified (TREE_TYPE (TREE_OPERAND (arg, 0)));
@@ -854,16 +854,16 @@ digest_init_r (tree type, tree init, bool nested, int flags)
them if they were present. */
if (code == ARRAY_TYPE)
{
- tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
+ tree typ1 = cv_unqualified (TREE_TYPE (type));
if (char_type_p (typ1)
/*&& init */
&& TREE_CODE (init) == STRING_CST)
{
- tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
+ tree char_type = cv_unqualified (TREE_TYPE (TREE_TYPE (init)));
if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
{
- if (char_type != char_type_node)
+ if (!same_type_p (char_type, char_type_node))
{
error ("char-array initialized from wide string");
return error_mark_node;
@@ -871,12 +871,12 @@ digest_init_r (tree type, tree init, bool nested, int flags)
}
else
{
- if (char_type == char_type_node)
+ if (same_type_p (char_type, char_type_node))
{
error ("int-array initialized from non-wide string");
return error_mark_node;
}
- else if (char_type != typ1)
+ else if (!same_type_p (char_type, typ1))
{
error ("int-array initialized from incompatible wide string");
return error_mark_node;
commit ba2ae527739acee7399c5caf573443e5a2283027
Author: Jason Merrill <jason@redhat.com>
Date: Fri May 28 16:06:05 2010 -0400
same_cv_unqual
@@ -240,7 +240,7 @@ check_dtor_name (tree basetype, tree name)
if (!name || name == error_mark_node)
return false;
- return same_type_ignoring_top_level_qualifiers_p (basetype, name);
+ return same_cv_unqualified_type_p (basetype, name);
}
/* We want the address of a function or method. We avoid creating a
@@ -807,8 +807,7 @@ standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
tree from_pointee;
if (tcode == POINTER_TYPE
- && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
- TREE_TYPE (to)))
+ && same_cv_unqualified_type_p (TREE_TYPE (from), TREE_TYPE (to)))
;
else if (VOID_TYPE_P (TREE_TYPE (to))
&& !TYPE_PTRMEM_P (from)
@@ -825,7 +824,7 @@ standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
if (DERIVED_FROM_P (fbase, tbase)
- && (same_type_ignoring_top_level_qualifiers_p
+ && (same_cv_unqualified_type_p
(TYPE_PTRMEM_POINTED_TO_TYPE (from),
TYPE_PTRMEM_POINTED_TO_TYPE (to))))
{
@@ -1169,7 +1168,7 @@ direct_reference_binding (tree type, conversion *conv)
either an identity conversion or, if the conversion function
returns an entity of a type that is a derived class of the
parameter type, a derived-to-base conversion. */
- if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
+ if (!same_cv_unqualified_type_p (t, conv->type))
{
/* Represent the derived-to-base conversion. */
conv = build_conv (ck_base, t, conv);
@@ -2537,8 +2536,8 @@ add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
{
tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
- if (arg_types && (same_type_ignoring_top_level_qualifiers_p
- (TREE_VALUE (arg_types), ctype)))
+ if (arg_types && same_cv_unqualified_type_p (TREE_VALUE (arg_types),
+ ctype))
goto fail;
}
@@ -2838,9 +2837,9 @@ build_user_type_conversion_1 (tree totype, tree expr, int flags)
if (MAYBE_CLASS_TYPE_P (fromtype))
{
tree to_nonref = non_reference (totype);
- if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
- (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
- && DERIVED_FROM_P (to_nonref, fromtype)))
+ if (same_cv_unqualified_type_p (to_nonref, fromtype)
+ || (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
+ && DERIVED_FROM_P (to_nonref, fromtype)))
{
/* [class.conv.fct] A conversion function is never used to
convert a (possibly cv-qualified) object to the (possibly
@@ -3552,7 +3551,7 @@ conditional_conversion (tree e1, tree e2)
if (good_base && at_least_as_qualified_p (t2, t1))
{
conv = build_identity_conv (t1, e1);
- if (!same_type_ignoring_top_level_qualifiers_p (t1, t2))
+ if (!same_cv_unqualified_type_p (t1, t2))
conv = build_conv (ck_base, t2, conv);
else
conv = build_conv (ck_rvalue, t2, conv);
@@ -4402,8 +4401,8 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
case NE_EXPR:
if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
&& TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
- && !(same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (arg1), TREE_TYPE (arg2)))
+ && !same_cv_unqualified_type_p (TREE_TYPE (arg1),
+ TREE_TYPE (arg2))
&& (complain & tf_warning))
{
warning (OPT_Wenum_compare,
@@ -5752,8 +5751,8 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
if (TREE_CODE (targ) == ADDR_EXPR)
{
targ = TREE_OPERAND (targ, 0);
- if (!same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
+ if (!same_cv_unqualified_type_p (TREE_TYPE (TREE_TYPE (arg)),
+ TREE_TYPE (targ)))
targ = NULL_TREE;
}
else
@@ -6083,8 +6082,8 @@ build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
gcc_assert (args == NULL || VEC_empty (tree, *args));
/* Convert to the base class, if necessary. */
- if (!same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (instance), BINFO_TYPE (binfo)))
+ if (!same_cv_unqualified_type_p (TREE_TYPE (instance),
+ BINFO_TYPE (binfo)))
{
if (name != ansi_assopname (NOP_EXPR))
/* For constructors and destructors, either the base is
@@ -6572,7 +6571,7 @@ is_properly_derived_from (tree derived, tree base)
/* We only allow proper derivation here. The DERIVED_FROM_P macro
considers every class derived from itself. */
- return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
+ return (!same_cv_unqualified_type_p (derived, base)
&& DERIVED_FROM_P (base, derived));
}
@@ -7007,7 +7006,7 @@ compare_ics (conversion *ics1, conversion *ics2)
return -1;
}
- if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
+ if (same_cv_unqualified_type_p (to_type1, to_type2))
return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
TREE_TYPE (ref_conv1->type));
}
@@ -578,7 +578,7 @@ build_vfield_ref (tree datum, tree type)
return error_mark_node;
/* First, convert to the requested type. */
- if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
+ if (!same_cv_unqualified_type_p (TREE_TYPE (datum), type))
datum = convert_to_base (datum, type, /*check_access=*/false,
/*nonnull=*/true, tf_warning_or_error);
@@ -590,7 +590,7 @@ build_vfield_ref (tree datum, tree type)
one step at a time via primary bases avoids the problem. */
vfield = TYPE_VFIELD (type);
vcontext = DECL_CONTEXT (vfield);
- while (!same_type_ignoring_top_level_qualifiers_p (vcontext, type))
+ while (!same_cv_unqualified_type_p (vcontext, type))
{
datum = build_simple_base_path (datum, CLASSTYPE_PRIMARY_BINFO (type));
type = TREE_TYPE (datum);
@@ -1327,8 +1327,7 @@ check_bases (tree t,
/* ...has no base classes of the same type as the first non-static
data member... */
if (field && DECL_CONTEXT (field) == t
- && (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (field), basetype)))
+ && (same_cv_unqualified_type_p (TREE_TYPE (field), basetype)))
CLASSTYPE_NON_STD_LAYOUT (t) = 1;
else
/* ...either has no non-static data members in the most-derived
@@ -2124,8 +2123,7 @@ update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
there. */
virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset),
over_return);
- else if (!same_type_ignoring_top_level_qualifiers_p
- (over_return, base_return))
+ else if (!same_cv_unqualified_type_p (over_return, base_return))
{
/* There was no existing virtual thunk (which takes
precedence). So find the binfo of the base function's
@@ -5422,7 +5420,7 @@ finish_struct_1 (tree t)
for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
&& TREE_TYPE (x) != error_mark_node
- && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (x), t))
+ && same_cv_unqualified_type_p (TREE_TYPE (x), t))
DECL_MODE (x) = TYPE_MODE (t);
/* Done with FIELDS...now decide whether to sort these for
@@ -5759,7 +5757,7 @@ resolves_to_fixed_type_p (tree instance, int* nonnull)
return 0;
if (POINTER_TYPE_P (t))
t = TREE_TYPE (t);
- if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
+ if (!same_cv_unqualified_type_p (t, fixed))
return 0;
return cdtorp ? -1 : 1;
}
@@ -1180,8 +1180,7 @@ cxx_omp_predetermined_sharing (tree decl)
if (outer)
for (var = BLOCK_VARS (outer); var; var = TREE_CHAIN (var))
if (DECL_NAME (decl) == DECL_NAME (var)
- && (same_type_ignoring_top_level_qualifiers_p
- (type, TREE_TYPE (var))))
+ && same_cv_unqualified_type_p (type, TREE_TYPE (var)))
{
if (TYPE_READONLY (TREE_TYPE (var)))
type = TREE_TYPE (var);
@@ -146,7 +146,7 @@ cxx_initialize_diagnostics (diagnostic_context *context)
int
cxx_types_compatible_p (tree x, tree y)
{
- return same_type_ignoring_top_level_qualifiers_p (x, y);
+ return same_cv_unqualified_type_p (x, y);
}
/* Return true if DECL is explicit member function. */
@@ -292,7 +292,7 @@ typedef struct ptrmem_cst * ptrmem_cst_t;
/* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
top-level qualifiers. */
-#define same_type_ignoring_top_level_qualifiers_p(TYPE1, TYPE2) \
+#define same_cv_unqualified_type_p(TYPE1,TYPE2) \
same_type_p (cv_unqualified (TYPE1), cv_unqualified (TYPE2))
/* Nonzero if we are presently building a statement tree, rather
than expanding each statement as we encounter it. */
@@ -3782,7 +3782,7 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
/* True if EXPR expresses direct-initialization of a TYPE. */
#define DIRECT_INIT_EXPR_P(TYPE,EXPR) \
(TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR) \
- && same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR)))
+ && same_cv_unqualified_type_p (TYPE, TREE_TYPE (EXPR)))
/* An enumeration of the kind of tags that C++ accepts. */
enum tag_types {
@@ -123,7 +123,7 @@ cp_convert_to_pointer (tree type, tree expr)
if (POINTER_TYPE_P (intype))
{
- if (!same_type_ignoring_top_level_qualifiers_p (type, intype)
+ if (!same_cv_unqualified_type_p (type, intype)
&& TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
@@ -139,8 +139,7 @@ cp_convert_to_pointer (tree type, tree expr)
intype_class = TREE_TYPE (intype);
type_class = TREE_TYPE (type);
- same_p = (same_type_ignoring_top_level_qualifiers_p
- (intype_class, type_class));
+ same_p = same_cv_unqualified_type_p (intype_class, type_class);
binfo = NULL_TREE;
/* Try derived to base conversion. */
@@ -252,7 +251,7 @@ convert_to_pointer_force (tree type, tree expr)
if (form == POINTER_TYPE)
{
- if (!same_type_ignoring_top_level_qualifiers_p (type, intype)
+ if (!same_cv_unqualified_type_p (type, intype)
&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
@@ -329,7 +328,7 @@ build_up_reference (tree type, tree arg, int flags, tree decl)
return error_mark_node;
if ((flags & LOOKUP_PROTECT)
- && !same_type_ignoring_top_level_qualifiers_p (argtype, target_type)
+ && !same_cv_unqualified_type_p (argtype, target_type)
&& MAYBE_CLASS_TYPE_P (argtype)
&& MAYBE_CLASS_TYPE_P (target_type))
{
@@ -612,7 +611,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags)
if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP))
/* We need a new temporary; don't take this shortcut. */;
- else if (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (e)))
+ else if (same_cv_unqualified_type_p (type, TREE_TYPE (e)))
{
if (same_type_p (type, TREE_TYPE (e)))
/* The call to fold will not always remove the NOP_EXPR as
@@ -5014,7 +5014,7 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
looking through the outermost braces; A a2 = { a1 }; is not a
valid aggregate initialization. */
&& !first_initializer_p
- && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init))
+ && (same_cv_unqualified_type_p (type, TREE_TYPE (init))
|| can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL)))
{
d->cur++;
@@ -5833,8 +5833,8 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
|| jclass == NULL_TREE
|| TREE_CODE (jclass) != TYPE_DECL
|| !POINTER_TYPE_P (TREE_TYPE (jclass))
- || !same_type_ignoring_top_level_qualifiers_p
- (type, TREE_TYPE (TREE_TYPE (jclass))))
+ || !(same_cv_unqualified_type_p
+ (type, TREE_TYPE (TREE_TYPE (jclass)))))
error ("Java object %qD not allocated with %<new%>", decl);
init = NULL_TREE;
}
@@ -8076,7 +8076,7 @@ grokdeclarator (const cp_declarator *declarator,
/* Long double is a special combination. */
if (long_p && !longlong
- && same_type_ignoring_top_level_qualifiers_p (type, double_type_node))
+ && same_cv_unqualified_type_p (type, double_type_node))
{
long_p = false;
type = cp_build_qualified_type (long_double_type_node,
@@ -10099,15 +10099,15 @@ copy_fn_p (const_tree d)
if (arg_type == error_mark_node)
return 0;
- if (same_type_ignoring_top_level_qualifiers_p (arg_type, DECL_CONTEXT (d)))
+ if (same_cv_unqualified_type_p (arg_type, DECL_CONTEXT (d)))
{
/* Pass by value copy assignment operator. */
result = -1;
}
else if (TREE_CODE (arg_type) == REFERENCE_TYPE
&& !TYPE_REF_IS_RVALUE (arg_type)
- && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (arg_type),
- DECL_CONTEXT (d)))
+ && same_cv_unqualified_type_p (TREE_TYPE (arg_type),
+ DECL_CONTEXT (d)))
{
if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
result = 2;
@@ -834,7 +834,7 @@ locate_copy (tree type, void *client_)
if (src_type == error_mark_node)
return NULL_TREE;
- if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
+ if (!same_cv_unqualified_type_p (src_type, type))
continue;
if (!sufficient_parms_p (TREE_CHAIN (parms)))
continue;
@@ -1070,7 +1070,7 @@ is_specialization_of (tree decl, tree tmpl)
t != NULL_TREE;
t = CLASSTYPE_USE_TEMPLATE (t)
? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
- if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
+ if (same_cv_unqualified_type_p (t, TREE_TYPE (tmpl)))
return 1;
}
@@ -4952,7 +4952,7 @@ convert_nontype_argument (tree type, tree expr)
gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
- gcc_assert (same_type_ignoring_top_level_qualifiers_p
+ gcc_assert (same_cv_unqualified_type_p
(TREE_TYPE (expr_type),
TREE_TYPE (TREE_TYPE (addr))));
@@ -5085,8 +5085,7 @@ convert_nontype_argument (tree type, tree expr)
template-argument, which must be an lvalue. */
else if (TYPE_REF_OBJ_P (type))
{
- if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
- expr_type))
+ if (!same_cv_unqualified_type_p (TREE_TYPE (type), expr_type))
return error_mark_node;
if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
@@ -14903,7 +14902,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
/* We have already checked cv-qualification at the top of the
function. */
- if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
+ if (!same_cv_unqualified_type_p (arg, parm))
return 1;
/* As far as unification is concerned, this wins. Later checks
@@ -14991,7 +14990,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
}
- else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
+ else if (!same_cv_unqualified_type_p (parm, arg))
return 1;
return 0;
@@ -2131,8 +2131,7 @@ finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
We implement the more generous second sentence, since that is
what most other compilers do. */
- if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
- destructor))
+ if (!same_cv_unqualified_type_p (TREE_TYPE (object), destructor))
{
error ("%qE is not of type %qT", object, destructor);
return error_mark_node;
@@ -5234,7 +5233,7 @@ finish_trait_expr (cp_trait_kind kind, tree type1, tree type2)
case CPTK_IS_BASE_OF:
if (NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
- && !same_type_ignoring_top_level_qualifiers_p (type1, type2)
+ && !same_cv_unqualified_type_p (type1, type2)
&& !COMPLETE_TYPE_P (type2))
{
error ("incomplete type %qT not allowed", type2);
@@ -5810,8 +5809,8 @@ lambda_expr_this_capture (tree lambda)
else
{
/* Make sure that current_class_ref is for the lambda. */
- gcc_assert (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (current_class_ref), TREE_TYPE (lambda)));
+ gcc_assert (same_cv_unqualified_type_p (TREE_TYPE (current_class_ref),
+ TREE_TYPE (lambda)));
result = finish_non_static_data_member (this_capture,
NULL_TREE,
@@ -462,7 +462,7 @@ composite_pointer_type_r (tree t1, tree t2,
with a cv-qualification signature (_conv.qual_) that is the
union of the cv-qualification signatures of the operand
types. */
- if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2))
+ if (same_cv_unqualified_type_p (pointee1, pointee2))
result_type = pointee1;
else if ((TREE_CODE (pointee1) == POINTER_TYPE
&& TREE_CODE (pointee2) == POINTER_TYPE)
@@ -634,8 +634,7 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
&& CLASS_TYPE_P (TREE_TYPE (t1))
&& CLASS_TYPE_P (TREE_TYPE (t2))
- && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1),
- TREE_TYPE (t2)))
+ && !same_cv_unqualified_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
{
class1 = TREE_TYPE (t1);
class2 = TREE_TYPE (t2);
@@ -1820,16 +1819,15 @@ is_bitfield_expr_with_lowered_type (const_tree exp)
field = TREE_OPERAND (exp, 1);
if (TREE_CODE (field) != FIELD_DECL || !DECL_BIT_FIELD_TYPE (field))
return NULL_TREE;
- if (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (exp), DECL_BIT_FIELD_TYPE (field)))
+ if (same_cv_unqualified_type_p (TREE_TYPE (exp),
+ DECL_BIT_FIELD_TYPE (field)))
return NULL_TREE;
return DECL_BIT_FIELD_TYPE (field);
}
CASE_CONVERT:
- if (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (TREE_OPERAND (exp, 0)),
- TREE_TYPE (exp)))
+ if (same_cv_unqualified_type_p (TREE_TYPE (TREE_OPERAND (exp, 0)),
+ TREE_TYPE (exp)))
return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
/* Fallthrough. */
@@ -2202,8 +2200,7 @@ build_class_member_access_expr (tree object, tree member,
presently be the anonymous union. Go outwards until we find a
type related to OBJECT_TYPE. */
while (ANON_AGGR_TYPE_P (member_scope)
- && !same_type_ignoring_top_level_qualifiers_p (member_scope,
- object_type))
+ && !same_cv_unqualified_type_p (member_scope, object_type))
member_scope = TYPE_CONTEXT (member_scope);
if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
{
@@ -2247,8 +2244,7 @@ build_class_member_access_expr (tree object, tree member,
&& integer_zerop (TREE_OPERAND (object, 0)));
/* Convert OBJECT to the type of MEMBER. */
- if (!same_type_ignoring_top_level_qualifiers_p (object_type,
- member_scope))
+ if (!same_cv_unqualified_type_p (object_type, member_scope))
{
tree binfo;
base_kind kind;
@@ -2313,8 +2309,8 @@ build_class_member_access_expr (tree object, tree member,
constructed, and was then disassembled before calling
build_field_call. After the function-call code is
cleaned up, this waste can be eliminated. */
- && (!same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (object), DECL_CONTEXT (member))))
+ && !same_cv_unqualified_type_p (TREE_TYPE (object),
+ DECL_CONTEXT (member)))
{
tree anonymous_union;
@@ -3132,8 +3128,8 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
lookup_base will fail in that case, because incomplete
classes do not have BINFOs. */
basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
- if (!same_type_ignoring_top_level_qualifiers_p
- (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
+ if (!same_cv_unqualified_type_p (basetype,
+ TREE_TYPE (TREE_TYPE (instance_ptr))))
{
basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
basetype, ba_check, NULL);
@@ -3783,8 +3779,7 @@ cp_build_binary_op (location_t location,
/* Subtraction of two similar pointers.
We must subtract them as integers, then divide by object size. */
if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
- && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
- TREE_TYPE (type1)))
+ && same_cv_unqualified_type_p (TREE_TYPE (type0), TREE_TYPE (type1)))
return pointer_diff (op0, op1, common_pointer_type (type0, type1));
/* In all other cases except pointer - int, the usual arithmetic
rules apply. */
@@ -3920,8 +3915,7 @@ cp_build_binary_op (location_t location,
}
/* Convert the shift-count to an integer, regardless of
size of value being shifted. */
- if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (op1),
- integer_type_node))
+ if (!same_cv_unqualified_type_p (TREE_TYPE (op1), integer_type_node))
op1 = cp_convert (integer_type_node, op1);
/* Avoid converting op1 to result_type later. */
converted = 1;
@@ -3949,8 +3943,7 @@ cp_build_binary_op (location_t location,
}
/* Convert the shift-count to an integer, regardless of
size of value being shifted. */
- if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (op1),
- integer_type_node))
+ if (!same_cv_unqualified_type_p (TREE_TYPE (op1), integer_type_node))
op1 = cp_convert (integer_type_node, op1);
/* Avoid converting op1 to result_type later. */
converted = 1;
@@ -3981,8 +3974,7 @@ cp_build_binary_op (location_t location,
}
/* Convert the shift-count to an integer, regardless of
size of value being shifted. */
- if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (op1),
- integer_type_node))
+ if (!same_cv_unqualified_type_p (TREE_TYPE (op1), integer_type_node))
op1 = cp_convert (integer_type_node, op1);
}
break;
@@ -5209,8 +5201,8 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
{
tree object = TREE_OPERAND (arg, 0);
tree field = TREE_OPERAND (arg, 1);
- gcc_assert (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (object), decl_type_context (field)));
+ gcc_assert (same_cv_unqualified_type_p (TREE_TYPE (object),
+ decl_type_context (field)));
val = build_address (arg);
}
@@ -6858,7 +6850,7 @@ get_delta_difference (tree from, tree to,
{
tree result;
- if (same_type_ignoring_top_level_qualifiers_p (from, to))
+ if (same_cv_unqualified_type_p (from, to))
/* Pointer to member of incomplete class is permitted*/
result = size_zero_node;
else
@@ -6994,8 +6986,8 @@ build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
}
/* Just adjust the DELTA field. */
- gcc_assert (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (delta), ptrdiff_type_node));
+ gcc_assert (same_cv_unqualified_type_p (TREE_TYPE (delta),
+ ptrdiff_type_node));
if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
n = cp_build_binary_op (input_location,
LSHIFT_EXPR, n, integer_one_node,
@@ -7583,8 +7575,8 @@ check_return_expr (tree retval, bool *no_warning)
/* The function return type must be a reference to the current
class. */
if (TREE_CODE (valtype) == REFERENCE_TYPE
- && same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
+ && same_cv_unqualified_type_p (TREE_TYPE (valtype),
+ TREE_TYPE (current_class_ref)))
{
/* Returning '*this' is obviously OK. */
if (retval == current_class_ref)
@@ -7760,7 +7752,7 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
return ((constp >= 0 || to_more_cv_qualified)
&& (is_opaque_pointer
- || same_type_ignoring_top_level_qualifiers_p (to, from)));
+ || same_cv_unqualified_type_p (to, from)));
}
}
@@ -7877,7 +7869,7 @@ comp_ptr_ttypes_const (tree to, tree from)
if (TREE_CODE (to) != POINTER_TYPE)
return (is_opaque_pointer
- || same_type_ignoring_top_level_qualifiers_p (to, from));
+ || same_cv_unqualified_type_p (to, from));
}
}
@@ -952,8 +952,7 @@ digest_init_r (tree type, tree init, bool nested, int flags)
build_value_init_noctor. */
if ((TREE_CODE (init) == TARGET_EXPR
|| TREE_CODE (init) == CONSTRUCTOR)
- && (same_type_ignoring_top_level_qualifiers_p
- (type, TREE_TYPE (init))))
+ && same_cv_unqualified_type_p (type, TREE_TYPE (init)))
return init;
error ("array must be initialized with a brace-enclosed"
@@ -1052,8 +1051,8 @@ process_init_constructor_array (tree type, tree init)
ce->value = digest_init_r (TREE_TYPE (type), ce->value, true, LOOKUP_IMPLICIT);
if (ce->value != error_mark_node)
- gcc_assert (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (type), TREE_TYPE (ce->value)));
+ gcc_assert (same_cv_unqualified_type_p (TREE_TYPE (type),
+ TREE_TYPE (ce->value)));
flags |= picflag_from_initializer (ce->value);
}
commit ca9e07ff0aad68ada0e4af1094624222e078f750
Author: Jason Merrill <jason@redhat.com>
Date: Fri May 28 16:20:47 2010 -0400
type_linkage_name
@@ -1098,19 +1098,18 @@ enum languages { lang_c, lang_cplusplus, lang_java };
/* Macros to make error reporting functions' lives easier. */
#define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE)))
-#define TYPE_LINKAGE_IDENTIFIER(NODE) \
- (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
#define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
#define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))
+#define TYPE_LINKAGE_NAME(NODE) (TYPE_NAME (TYPE_MAIN_VARIANT (NODE)))
+#define TYPE_LINKAGE_IDENTIFIER(NODE) (DECL_NAME (TYPE_LINKAGE_NAME (NODE)))
+
/* Nonzero if NODE has no name for linkage purposes. */
#define TYPE_ANONYMOUS_P(NODE) \
(TAGGED_TYPE_P (NODE) && ANON_AGGRNAME_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
/* The _DECL for this _TYPE. */
#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
-#define TYPE_MAIN_NAME(NODE) (TYPE_NAME (TYPE_MAIN_VARIANT (NODE)))
-#define TYPE_MAIN_IDENTIFIER(NODE) (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
/* Nonzero if T is a class (or struct or union) type. Also nonzero
for template type parameters, typename types, and instantiated
@@ -4185,7 +4185,7 @@ start_decl (const cp_declarator *declarator,
(7.1.3p8), apply any attributes directly to the type. */
if (TREE_CODE (decl) == TYPE_DECL
&& TAGGED_TYPE_P (TREE_TYPE (decl))
- && decl == TYPE_MAIN_NAME (TREE_TYPE (decl)))
+ && decl == TYPE_LINKAGE_NAME (TREE_TYPE (decl)))
flags = ATTR_FLAG_TYPE_IN_PLACE;
else
flags = 0;
@@ -869,7 +869,7 @@ grokfield (const cp_declarator *declarator,
/* If this is a typedef that names the class for linkage purposes
(7.1.3p8), apply any attributes directly to the type. */
if (TAGGED_TYPE_P (TREE_TYPE (value))
- && value == TYPE_MAIN_NAME (TREE_TYPE (value)))
+ && value == TYPE_LINKAGE_NAME (TREE_TYPE (value)))
attrflags = ATTR_FLAG_TYPE_IN_PLACE;
cplus_decl_attributes (&value, attrlist, attrflags);
@@ -877,7 +877,7 @@ grokfield (const cp_declarator *declarator,
if (declspecs->specs[(int)ds_typedef]
&& TREE_TYPE (value) != error_mark_node
- && TYPE_MAIN_NAME (TREE_TYPE (value)) != value)
+ && TYPE_LINKAGE_NAME (TREE_TYPE (value)) != value)
cp_set_underlying_type (value);
return value;
@@ -380,7 +380,7 @@ is_std_substitution (const tree node,
else if (CLASS_TYPE_P (node))
{
type = node;
- decl = TYPE_MAIN_NAME (node);
+ decl = TYPE_LINKAGE_NAME (node);
}
else
/* These are not the droids you're looking for. */
@@ -468,7 +468,7 @@ find_substitution (tree node)
/* Check for builtin substitutions. */
- decl = TYPE_P (node) ? TYPE_MAIN_NAME (node) : node;
+ decl = TYPE_P (node) ? TYPE_LINKAGE_NAME (node) : node;
type = TYPE_P (node) ? node : TREE_TYPE (node);
/* Check for std::allocator. */
@@ -735,7 +735,7 @@ write_name (tree decl, const int ignore_local_scope)
{
/* In case this is a typedef, fish out the corresponding
TYPE_DECL for the main variant. */
- decl = TYPE_MAIN_NAME (TREE_TYPE (decl));
+ decl = TYPE_LINKAGE_NAME (TREE_TYPE (decl));
}
context = decl_mangling_context (decl);
@@ -1819,7 +1819,7 @@ write_type (tree type)
case UNBOUND_CLASS_TEMPLATE:
/* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
ordinary nested names. */
- write_nested_name (TYPE_MAIN_NAME (type));
+ write_nested_name (TYPE_LINKAGE_NAME (type));
break;
case POINTER_TYPE:
@@ -2283,7 +2283,7 @@ write_method_parms (tree parm_types, const int method_p, const tree decl)
static void
write_class_enum_type (const tree type)
{
- write_name (TYPE_MAIN_NAME (type), /*ignore_local_scope=*/0);
+ write_name (TYPE_LINKAGE_NAME (type), /*ignore_local_scope=*/0);
}
/* Non-terminal <template-args>. ARGS is a TREE_VEC of template
@@ -1801,7 +1801,7 @@ set_identifier_type_value (tree id, tree decl)
static inline tree
constructor_name_full (tree type)
{
- return TYPE_MAIN_IDENTIFIER (type);
+ return DECL_NAME (TYPE_MAIN_DECL (type));
}
/* Return the name for the constructor (or destructor) for the
@@ -18075,7 +18075,7 @@ resolve_typename_type (tree type, bool only_current_p)
So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
TYPENAME_TYPE instead, we avoid messing up with a possible
typedef variant case. */
- name = TYPE_MAIN_IDENTIFIER (type);
+ name = TYPE_LINKAGE_IDENTIFIER (type);
/* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
it first before we can figure out what NAME refers to. */
@@ -662,7 +662,6 @@ build_cplus_array_type (tree elt_type, tree index_type)
else
t = build_array_type (elt_type, index_type);
- /* FIXME do we still need this? */
/* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
element type as well, so fix it up if needed. */
if (elt_type != TYPE_MAIN_VARIANT (elt_type))
@@ -396,7 +396,7 @@ cp_common_type (tree t1, tree t2)
return build_type_attribute_variant (float_type_node,
attributes);
- /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
+ /* Two floating-point types that are not variants of
the standard C++ floating-point types. Logic earlier in this
function has already eliminated the possibility that
TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
commit 6fa0787cc5cd7fdbbfa4e28a54f01aa6eed598b1
Author: Jason Merrill <jason@redhat.com>
Date: Fri May 28 16:23:18 2010 -0400
const
@@ -5409,7 +5409,7 @@ extern tree convert_for_initialization (tree, tree, tree, int,
extern int comp_ptr_ttypes (tree, tree);
extern bool comp_ptr_ttypes_const (tree, tree);
extern bool error_type_p (const_tree);
-extern int ptr_reasonably_similar (const_tree, const_tree);
+extern int ptr_reasonably_similar (tree, tree);
extern tree build_ptrmemfunc (tree, tree, int, bool);
extern int cp_type_quals (const_tree);
extern int type_memfn_quals (const_tree);
@@ -7808,7 +7808,7 @@ error_type_p (const_tree type)
type or inheritance-related types, regardless of cv-quals. */
int
-ptr_reasonably_similar (const_tree to, const_tree from)
+ptr_reasonably_similar (tree to, tree from)
{
for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
{
commit dbd99759dfddb32e499afba32b942586b684fc1f
Author: Jason Merrill <jason@redhat.com>
Date: Fri May 28 17:33:20 2010 -0400
fix tests
@@ -6326,7 +6326,7 @@ build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
if (DECL_DESTRUCTOR_P (fn)
|| DECL_CONSTRUCTOR_P (fn))
{
- tree type = build_pointer_type (basetype);
+ tree type = build_pointer_type (cv_unqualified (basetype));
if (!same_type_p (type, TREE_TYPE (instance_ptr)))
instance_ptr = build_nop (type, instance_ptr);
}
@@ -8857,7 +8857,7 @@ grokdeclarator (const cp_declarator *declarator,
t = DECL_CONTEXT (t);
}
- if (ctype == current_class_type)
+ if (current_class_type && same_type_p (ctype, current_class_type))
{
if (friendp)
{
@@ -9478,7 +9478,7 @@ grokdeclarator (const cp_declarator *declarator,
if (friendp)
{
/* Friends are treated specially. */
- if (ctype == current_class_type)
+ if (ctype && same_type_p (ctype, current_class_type))
; /* We already issued a permerror. */
else if (decl && DECL_NAME (decl))
{
@@ -351,7 +351,8 @@ make_friend_class (tree type, tree friend_type, bool complain)
if (friend_type == error_mark_node)
return;
- friend_type = TYPE_MAIN_VARIANT (friend_type);
+ if (TYPE_P (friend_type))
+ friend_type = TYPE_MAIN_VARIANT (friend_type);
/* See if it is already a friend. */
for (classes = CLASSTYPE_FRIEND_CLASSES (type);
@@ -263,8 +263,8 @@ cp_common_type (tree t1, tree t2)
attributes. */
attributes = (*targetm.merge_type_attributes) (t1, t2);
- gcc_assert (t1 == cv_unqualified (t1)
- && t2 == cv_unqualified (t2));
+ t1 = cv_unqualified (t1);
+ t2 = cv_unqualified (t2);
if (SCOPED_ENUM_P (t1) || SCOPED_ENUM_P (t2))
{
commit b4bf0d44d3b7bf7ae046ac89b7516393f5b06b85
Author: Jason Merrill <jason@redhat.com>
Date: Sat May 29 17:28:12 2010 -0400
move comment
@@ -1854,9 +1854,6 @@ set_nothrow_function_flags (void)
crtl->all_throwers_are_sibcalls = 1;
- /* If we don't know that this implementation of the function will
- actually be used, then we must not set TREE_NOTHROW, since
- callers must not assume that this function does not throw. */
if (TREE_NOTHROW (current_function_decl))
return 0;
@@ -1887,6 +1884,9 @@ set_nothrow_function_flags (void)
return 0;
}
}
+ /* If we don't know that this implementation of the function will
+ actually be used, then we must not set TREE_NOTHROW, since
+ callers must not assume that this function does not throw. */
if (crtl->nothrow
&& (cgraph_function_body_availability (cgraph_node
(current_function_decl))
commit 42c9024793456b2413eecc1f26ba47e8715a738b
Author: Jason Merrill <jason@redhat.com>
Date: Mon May 31 17:23:30 2010 -0400
nothrow
@@ -7643,12 +7643,30 @@ get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
struct attribute_spec.handler. */
static tree
-handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
+handle_nothrow_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
+ tree type = TREE_TYPE (*node);
+ bool ptr = false;
+
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_NOTHROW (*node) = 1;
- /* ??? TODO: Support types. */
+
+ if (TREE_CODE (type) == POINTER_TYPE)
+ {
+ ptr = true;
+ type = TREE_TYPE (type);
+ }
+
+ if (TREE_CODE (type) == FUNCTION_TYPE)
+ {
+ tree attrs = TYPE_ATTRIBUTES (type);
+ attrs = tree_cons (name, args, attrs);
+ type = build_type_attribute_variant (type, attrs);
+ if (ptr)
+ type = build_pointer_type (type);
+ TREE_TYPE (*node) = type;
+ }
else
{
warning (OPT_Wattributes, "%qE attribute ignored", name);
@@ -8978,21 +8996,8 @@ bool
check_missing_format_attribute (tree ltype, tree rtype)
{
tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
- tree ra;
-
- for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
- if (is_attribute_p ("format", TREE_PURPOSE (ra)))
- break;
- if (ra)
- {
- tree la;
- for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
- if (is_attribute_p ("format", TREE_PURPOSE (la)))
- break;
- return !la;
- }
- else
- return false;
+ return (lookup_attribute ("format", TYPE_ATTRIBUTES (ttr))
+ && !lookup_attribute ("format", TYPE_ATTRIBUTES (ttl)));
}
/* Subscripting with type char is likely to lose on a machine where
@@ -611,13 +611,27 @@ flags_from_decl_or_type (const_tree exp)
if (TREE_NOTHROW (exp))
flags |= ECF_NOTHROW;
+ if (TREE_THIS_VOLATILE (exp))
+ flags |= ECF_NORETURN;
+
flags = special_function_p (exp, flags);
- }
- else if (TYPE_P (exp) && TYPE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
- flags |= ECF_CONST;
- if (TREE_THIS_VOLATILE (exp))
- flags |= ECF_NORETURN;
+ flags |= flags_from_decl_or_type (TREE_TYPE (exp));
+ }
+ else
+ {
+ tree attrs = TYPE_ATTRIBUTES (exp);
+ bool const_p = (TYPE_READONLY (exp)
+ || lookup_attribute ("const", attrs));
+ bool volatile_p = (TYPE_VOLATILE (exp)
+ || lookup_attribute ("noreturn", attrs));
+ if (const_p && !volatile_p)
+ flags |= ECF_CONST;
+ if (volatile_p)
+ flags |= ECF_NORETURN;
+ if (lookup_attribute ("nothrow", attrs))
+ flags |= ECF_NOTHROW;
+ }
return flags;
}
@@ -641,6 +655,9 @@ call_expr_flags (const_tree t)
flags = 0;
}
+ if (TREE_NOTHROW (t))
+ flags |= ECF_NOTHROW;
+
return flags;
}
@@ -337,7 +337,8 @@ build_call_a (tree function, int n, tree *argarray)
/* We check both the decl and the type; a function may be known not to
throw without being declared throw(). */
nothrow = ((decl && TREE_NOTHROW (decl))
- || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
+ || lookup_attribute ("nothrow", TYPE_ATTRIBUTES (fntype))
+ || TYPE_NOTHROW_P (fntype));
if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain)
current_function_returns_abnormally = 1;
@@ -5909,13 +5910,13 @@ build_cxx_call (tree fn, int nargs, tree *argarray)
fn = build_call_a (fn, nargs, argarray);
/* If this call might throw an exception, note that fact. */
- fndecl = get_callee_fndecl (fn);
- if ((!fndecl || !TREE_NOTHROW (fndecl))
+ if (!TREE_NOTHROW (fn)
&& at_function_scope_p ()
&& cfun)
cp_function_chain->can_throw = 1;
/* Check that arguments to builtin functions match the expectations. */
+ fndecl = get_callee_fndecl (fn);
if (fndecl
&& DECL_BUILT_IN (fndecl)
&& DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
@@ -2654,6 +2654,7 @@ process_call_operands (tree t)
{
bool side_effects = TREE_SIDE_EFFECTS (t);
bool read_only = false;
+ bool nothrow = false;
int i = call_expr_flags (t);
/* Calls have side-effects, except those to const or pure functions. */
@@ -2662,6 +2663,8 @@ process_call_operands (tree t)
/* Propagate TREE_READONLY of arguments for const functions. */
if (i & ECF_CONST)
read_only = true;
+ if (i & ECF_NOTHROW)
+ nothrow = true;
if (!side_effects || read_only)
for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
@@ -2675,6 +2678,7 @@ process_call_operands (tree t)
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_READONLY (t) = read_only;
+ TREE_NOTHROW (t) = nothrow;
}
/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
commit 70399b338f583de79bba15e1c0015e3b87aca9a6
Author: Jason Merrill <jason@redhat.com>
Date: Mon May 31 17:30:15 2010 -0400
const, noreturn
@@ -5955,20 +5955,30 @@ handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
struct attribute_spec.handler. */
static tree
-handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
+handle_noreturn_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree type = TREE_TYPE (*node);
+ bool ptr = false;
- /* See FIXME comment in c_common_attribute_table. */
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_THIS_VOLATILE (*node) = 1;
- else if (TREE_CODE (type) == POINTER_TYPE
- && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
- TREE_TYPE (*node)
- = build_pointer_type
- (build_type_variant (TREE_TYPE (type),
- TYPE_READONLY (TREE_TYPE (type)), 1));
+
+ if (TREE_CODE (type) == POINTER_TYPE)
+ {
+ ptr = true;
+ type = TREE_TYPE (type);
+ }
+
+ if (TREE_CODE (type) == FUNCTION_TYPE)
+ {
+ tree attrs = TYPE_ATTRIBUTES (type);
+ attrs = tree_cons (get_identifier ("noreturn"), args, attrs);
+ type = build_type_attribute_variant (type, attrs);
+ if (ptr)
+ type = build_pointer_type (type);
+ TREE_TYPE (*node) = type;
+ }
else
{
warning (OPT_Wattributes, "%qE attribute ignored", name);
@@ -6277,20 +6287,29 @@ handle_externally_visible_attribute (tree *pnode, tree name,
struct attribute_spec.handler. */
static tree
-handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
+handle_const_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree type = TREE_TYPE (*node);
+ bool ptr = false;
- /* See FIXME comment on noreturn in c_common_attribute_table. */
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_READONLY (*node) = 1;
- else if (TREE_CODE (type) == POINTER_TYPE
- && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
- TREE_TYPE (*node)
- = build_pointer_type
- (build_type_variant (TREE_TYPE (type), 1,
- TREE_THIS_VOLATILE (TREE_TYPE (type))));
+
+ if (TREE_CODE (type) == POINTER_TYPE)
+ {
+ ptr = true;
+ type = TREE_TYPE (type);
+ }
+ if (TREE_CODE (type) == FUNCTION_TYPE)
+ {
+ tree attrs = TYPE_ATTRIBUTES (type);
+ attrs = tree_cons (name, args, attrs);
+ type = build_type_attribute_variant (type, attrs);
+ if (ptr)
+ type = build_pointer_type (type);
+ TREE_TYPE (*node) = type;
+ }
else
{
warning (OPT_Wattributes, "%qE attribute ignored", name);
commit daf769fbb986f16ce5be66ad254331d50c5d7c90
Author: Jason Merrill <jason@redhat.com>
Date: Tue Jun 1 11:10:05 2010 -0400
decl_noreturn accessor macros
@@ -1244,7 +1244,8 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
because eventually we may make that a different bit.
If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
-#define TREE_THIS_VOLATILE(NODE) ((NODE)->base.volatile_flag)
+#define TREE_THIS_VOLATILE(NODE) (NON_TYPE_CHECK (NODE)->base.volatile_flag)
+#define DECL_NORETURN(NODE) (TREE_THIS_VOLATILE (FUNCTION_DECL_CHECK (NODE)))
/* Nonzero means this node will not trap. In an INDIRECT_REF, means
accessing the memory pointed to won't generate a trap. However,
@@ -1263,6 +1264,7 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
Nonzero in a FUNCTION_DECL means this function should be treated
as "const" function (can only read its arguments). */
#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->base.readonly_flag)
+#define DECL_CONST_FUNCTION(NODE) (TREE_READONLY (FUNCTION_DECL_CHECK (NODE)))
/* Value of expression is constant. Always on in all ..._CST nodes. May
also appear in an expression or decl where the value is constant. */
commit 30edb13210d23b79f29cbef4ae3ecc0b5e242b34
Author: Jason Merrill <jason@redhat.com>
Date: Tue Jun 1 11:24:39 2010 -0400
strip_typedefs
@@ -1043,8 +1043,7 @@ strip_typedefs (tree t)
if (!result)
return strip_top_typedef (t);
- if (TYPE_ATTRIBUTES (t))
- result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
+ result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
return cp_build_qualified_type (result, cp_type_quals (t));
}