From patchwork Fri May 6 11:49:16 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nathan Froyd X-Patchwork-Id: 94364 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 87F4FB6FDE for ; Fri, 6 May 2011 21:49:36 +1000 (EST) Received: (qmail 6081 invoked by alias); 6 May 2011 11:49:34 -0000 Received: (qmail 6069 invoked by uid 22791); 6 May 2011 11:49:31 -0000 X-SWARE-Spam-Status: No, hits=-1.7 required=5.0 tests=AWL, BAYES_00, TW_CX, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (38.113.113.100) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 06 May 2011 11:49:17 +0000 Received: (qmail 5306 invoked from network); 6 May 2011 11:49:16 -0000 Received: from unknown (HELO localhost) (froydnj@127.0.0.2) by mail.codesourcery.com with ESMTPA; 6 May 2011 11:49:16 -0000 Date: Fri, 6 May 2011 04:49:16 -0700 From: Nathan Froyd To: gcc-patches@gcc.gnu.org Cc: jason@redhat.com Subject: [PATCH,c++] introduce {class,type}_of_this functions Message-ID: <20110506114915.GS23480@codesourcery.com> MIME-Version: 1.0 Content-Disposition: inline User-Agent: Mutt/1.5.17+20080114 (2008-01-14) X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org 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 (); }