The patch below introduces simple accessors for getting at the class or
the type of the `this' parameter. It hides a couple of TYPE_ARG_TYPES
usages and makes the code slightly more obvious, I think.
Tested on x86_64-unknown-linux-gnu. OK to commit?
-Nathan
gcc/cp/
* cp-tree.h (type_of_this, class_of_this): New functions.
* call.c (standard_conversion): Call class_of_this.
* cxx-pretty-print.c (pp_cxx_implicit_parameter_type): Likewise.
(pp_cxx_direct_abstract_declarator): Likewise.
* decl2.c (change_return_type): Likewise.
(cp_reconstruct_complex_type): Likewise.
* error.c (dump_type_suffix, dump_function_decl): Likewise.
* mangle.c (write_function_type): Likewise.
* pt.c (unify): Likewise.
* typeck.c (merge_types, type_memfn_quals): Likewise.
* decl.c (build_this_parm): Call type_of_this.
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index f5bd521..7ad9279 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -1146,8 +1146,8 @@ standard_conversion (tree to, tree from, tree expr, bool
c_cast_p,
{
tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
- tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
- tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
+ tree fbase = class_of_this (fromfn);
+ tree tbase = class_of_this (tofn);
if (!DERIVED_FROM_P (fbase, tbase)
|| !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 9d13393..d410e02 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4616,6 +4616,24 @@ struct GTY(()) tinst_level {
bool in_system_header_p;
};
+/* Return the type of the `this' parameter of FNTYPE. */
+
+static inline tree
+type_of_this (const_tree fntype)
+{
+ function_args_iterator iter;
+ function_args_iter_init (&iter, fntype);
+ return function_args_iter_cond (&iter);
+}
+
+/* Return the class of the `this' parameter of FNTYPE. */
+
+static inline tree
+class_of_this (const_tree fntype)
+{
+ return TREE_TYPE (type_of_this (fntype));
+}
+
/* A parameter list indicating for a function with no parameters,
e.g "int f(void)". */
extern cp_parameter_declarator *no_parameters;
diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c
index bd0381b..eeb6d07 100644
--- a/gcc/cp/cxx-pretty-print.c
+++ b/gcc/cp/cxx-pretty-print.c
@@ -1363,7 +1363,7 @@ pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
static inline tree
pp_cxx_implicit_parameter_type (tree mf)
{
- return TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (mf))));
+ return class_of_this (TREE_TYPE (mf));
}
/*
@@ -1652,8 +1652,7 @@ pp_cxx_direct_abstract_declarator (cxx_pretty_printer
*pp, tree t)
if (TREE_CODE (t) == METHOD_TYPE)
{
pp_base (pp)->padding = pp_before;
- pp_cxx_cv_qualifier_seq
- (pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
+ pp_cxx_cv_qualifier_seq (pp, class_of_this (t));
}
pp_cxx_exception_specification (pp, t);
break;
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 3622c2c..962dd22 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -6924,7 +6924,7 @@ build_this_parm (tree type, cp_cv_quals quals)
tree parm;
cp_cv_quals this_quals;
- this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
+ this_type = type_of_this (type);
/* The `this' parameter is implicitly `const'; it cannot be
assigned to. */
this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index ef8de31..02d9fd9 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -161,8 +161,7 @@ change_return_type (tree new_ret, tree fntype)
}
else
newtype = build_method_type_directly
- (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
- new_ret, TREE_CHAIN (args));
+ (class_of_this (fntype), new_ret, TREE_CHAIN (args));
if (raises)
newtype = build_exception_variant (newtype, raises);
if (attrs)
@@ -1249,8 +1248,7 @@ cp_reconstruct_complex_type (tree type, tree bottom)
so we must compensate by getting rid of it. */
outer
= build_method_type_directly
- (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
- inner,
+ (class_of_this (type), inner,
TREE_CHAIN (TYPE_ARG_TYPES (type)));
}
else if (TREE_CODE (type) == OFFSET_TYPE)
diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index fce7403..b364824 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -794,8 +794,7 @@ dump_type_suffix (tree t, int flags)
dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
if (TREE_CODE (t) == METHOD_TYPE)
- pp_cxx_cv_qualifier_seq
- (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
+ pp_cxx_cv_qualifier_seq (cxx_pp, class_of_this (t));
else
pp_cxx_cv_qualifier_seq (cxx_pp, t);
dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
@@ -1360,8 +1359,7 @@ dump_function_decl (tree t, int flags)
if (TREE_CODE (fntype) == METHOD_TYPE)
{
pp_base (cxx_pp)->padding = pp_before;
- pp_cxx_cv_qualifier_seq
- (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
+ pp_cxx_cv_qualifier_seq (cxx_pp, class_of_this (fntype));
}
if (flags & TFF_EXCEPTION_SPECIFICATION)
diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c
index 3dbc3b7..98bc900 100644
--- a/gcc/cp/mangle.c
+++ b/gcc/cp/mangle.c
@@ -2247,7 +2247,7 @@ write_function_type (const tree type)
{
/* The first parameter must be a POINTER_TYPE pointing to the
`this' parameter. */
- tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
+ tree this_type = class_of_this (type);
write_CV_qualifiers_for_type (this_type);
}
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index d109e1b..46679cd 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -15600,8 +15600,8 @@ unify (tree tparms, tree targs, tree parm, tree arg,
int strict)
if (TREE_CODE (parm) == METHOD_TYPE
&& (!check_cv_quals_for_unify
(UNIFY_ALLOW_NONE,
- TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
- TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
+ class_of_this (arg),
+ class_of_this (parm))))
return 1;
if (unify (tparms, targs, TREE_TYPE (parm),
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index afe0dbc..aa0de85 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -834,7 +834,7 @@ merge_types (tree t1, tree t2)
{
/* Get this value the long way, since TYPE_METHOD_BASETYPE
is just the main variant of this. */
- tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
+ tree basetype = class_of_this (t2);
tree raises = merge_exception_specifiers (TYPE_RAISES_EXCEPTIONS (t1),
TYPE_RAISES_EXCEPTIONS (t2));
tree t3;
@@ -8034,7 +8034,7 @@ type_memfn_quals (const_tree type)
if (TREE_CODE (type) == FUNCTION_TYPE)
return TYPE_QUALS (type);
else if (TREE_CODE (type) == METHOD_TYPE)
- return cp_type_quals (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))));
+ return cp_type_quals (class_of_this (type));
else
gcc_unreachable ();
}
