From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id BF10C3893670 for ; Mon, 5 Dec 2022 04:21:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org BF10C3893670 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1670214067; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=FVEuSVIV9PB6kJA46DtY7iu8iGwQUvf54IFT2gDCLcw=; b=ItoYWrQSkx6OEfy+GcX0gNmfeWxbmE0AoJESFTqxd2YLuEczd5NHA0ml3yKGd7xbMFFJvp 5HpTnvS7KTkwVDh78DyEq9NknxtLwR60FXxRkDxWrwtb+a9w/Bekww+6Gpj2emdryqx+b0 UVIuOvV/fR2YqIuZ/8w6XcJNVCrvg0U= Received: from mail-qv1-f72.google.com (mail-qv1-f72.google.com [209.85.219.72]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-265-dxKTP__UPSm4-E-cKU-dTg-1; Sun, 04 Dec 2022 23:21:05 -0500 X-MC-Unique: dxKTP__UPSm4-E-cKU-dTg-1 Received: by mail-qv1-f72.google.com with SMTP id ns11-20020a056214380b00b004c64784249eso28428733qvb.7 for ; Sun, 04 Dec 2022 20:21:05 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=FVEuSVIV9PB6kJA46DtY7iu8iGwQUvf54IFT2gDCLcw=; b=dlM5dMb9C1aIc5CKW9NSYi/l5od7lRienEv5vd1TL/l+DWuXCR0tI+i/yU2Qg2j8Xp hv+xHoDM9v82C0K41/i+aAyKJOSXBOO3pNhxonx5VLHY4ORbK4EGyLwr6O0mp8liGvnO FsE4DCBtMzCMs+SQmqEv7XC/EDj6kXIoJRyjl4AIa3kj1fCFx1WlapMuKaolSPuAAEeo 5+IUl3ltXYjy2WF8/pVIfp1GnmEH8df0NQQNJNTxGpHeKmjUUgZLMTLxsQsylT9Jp4Sp zdsvlXZY49ouuZsxqsLis6J1HIu/zPcSCr/47ocletJnVxoE3XMCuSJ5d9+5wWx7HGWL lnhA== X-Gm-Message-State: ANoB5pk98dBRXJc0O7Yk3SZjEAwdUKlXUz7Xo5B2WXFKuii5tdXynA0k a91r8bcrmhd97CEhHfWVRJ3B1QYXG3FmTmVZAuW2Ckgb+ydHt85LPOxZRErDQpsuc9/hH3IjkZK UAo8QE8ntSn0AvJB8FZeCPJ+vXOvoSWqoLEZUVJl0r7cuVfhatv/Fuw0hgKNplSH5V08= X-Received: by 2002:a05:620a:16b5:b0:6fa:b796:18ad with SMTP id s21-20020a05620a16b500b006fab79618admr59694467qkj.634.1670214064474; Sun, 04 Dec 2022 20:21:04 -0800 (PST) X-Google-Smtp-Source: AA0mqf5E01xOnko4xiUGdND4YEnJIAOSfimSHPBumC6v6k4rgb1tke1uIqDia7rjR6HizxJPb91jmw== X-Received: by 2002:a05:620a:16b5:b0:6fa:b796:18ad with SMTP id s21-20020a05620a16b500b006fab79618admr59694451qkj.634.1670214063986; Sun, 04 Dec 2022 20:21:03 -0800 (PST) Received: from localhost.localdomain (ool-457670bb.dyn.optonline.net. [69.118.112.187]) by smtp.gmail.com with ESMTPSA id x10-20020a05620a258a00b006fc92cf4703sm11459312qko.132.2022.12.04.20.21.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 04 Dec 2022 20:21:03 -0800 (PST) From: Patrick Palka To: gcc-patches@gcc.gnu.org Cc: jason@redhat.com, Patrick Palka Subject: [PATCH] tree, c++: declare some basic functions inline Date: Sun, 4 Dec 2022 23:21:01 -0500 Message-Id: <20221205042101.4144757-1-ppalka@redhat.com> X-Mailer: git-send-email 2.39.0.rc0.49.g083e01275b MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII"; x-default=true X-Spam-Status: No, score=-13.7 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_NONE,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: The functions strip_array_types, is_typedef_decl, typedef_variant_p, cp_type_quals and cp_expr_location are used throughout the C++ frontend including in some fairly hot parts (e.g. in the tsubst routines and cp_walk_subtree) and they're small enough that the overhead of calling them out-of-line is relatively significant. This patch moves their definitions into the appropriate headers to enable inlining them. This speeds up the C++ frontend by ~1% according to my experiments. In passing this also downgrades the assert in cp_type_quals to a checking assert. Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for trunk stage3 or perhaps for stage1? gcc/cp/ChangeLog: * cp-tree.h (cp_type_quals): Define here. Downgrade assert into a checking assert. (cp_expr_location): Define here. * tree.cc (cp_expr_location): Don't define here. * typeck.cc (cp_type_quals): Don't define here. gcc/ChangeLog: * tree.cc (strip_array_types): Don't define here. (is_typedef_decl): Don't define here. (typedef_variant_p): Don't define here. * tree.h (strip_array_types): Define here. (is_typedef_decl): Define here. (typedef_variant_p): Define here. --- gcc/cp/cp-tree.h | 50 ++++++++++++++++++++++++++++++++++++++++++++++-- gcc/cp/tree.cc | 24 ----------------------- gcc/cp/typeck.cc | 23 ---------------------- gcc/tree.cc | 29 ---------------------------- gcc/tree.h | 32 ++++++++++++++++++++++++++++--- 5 files changed, 77 insertions(+), 81 deletions(-) diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index addd26ea077..19914d08a03 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -49,7 +49,7 @@ c-common.h, not after. but not all node kinds do (e.g. constants, and references to params, locals, etc), so we stash a copy here. */ -extern location_t cp_expr_location (const_tree); +inline location_t cp_expr_location (const_tree); class cp_expr { @@ -8100,7 +8100,6 @@ extern bool error_type_p (const_tree); extern bool ptr_reasonably_similar (const_tree, const_tree); extern tree build_ptrmemfunc (tree, tree, int, bool, tsubst_flags_t); -extern int cp_type_quals (const_tree); extern int type_memfn_quals (const_tree); extern cp_ref_qualifier type_memfn_rqual (const_tree); extern tree apply_memfn_quals (tree, cp_cv_quals, @@ -8151,6 +8150,29 @@ extern void maybe_warn_about_useless_cast (location_t, tree, tree, tsubst_flags_t); extern tree cp_perform_integral_promotions (tree, tsubst_flags_t); +/* Returns the type qualifiers for this type, including the qualifiers on the + elements for an array type. */ + +inline int +cp_type_quals (const_tree type) +{ + int quals; + /* This CONST_CAST is okay because strip_array_types returns its + argument unmodified and we assign it to a const_tree. */ + type = strip_array_types (CONST_CAST_TREE (type)); + if (type == error_mark_node + /* Quals on a FUNCTION_TYPE are memfn quals. */ + || TREE_CODE (type) == FUNCTION_TYPE) + return TYPE_UNQUALIFIED; + quals = TYPE_QUALS (type); + /* METHOD and REFERENCE_TYPEs should never have quals. */ + gcc_checking_assert ((TREE_CODE (type) != METHOD_TYPE + && !TYPE_REF_P (type)) + || ((quals & (TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE)) + == TYPE_UNQUALIFIED)); + return quals; +} + extern tree finish_left_unary_fold_expr (tree, int); extern tree finish_right_unary_fold_expr (tree, int); extern tree finish_binary_fold_expr (tree, tree, int); @@ -8168,6 +8190,30 @@ loc_or_input_loc (location_t loc) return loc == UNKNOWN_LOCATION ? input_location : loc; } +/* Like EXPR_LOCATION, but also handle some tcc_exceptional that have + locations. */ + +inline location_t +cp_expr_location (const_tree t_) +{ + tree t = CONST_CAST_TREE (t_); + if (t == NULL_TREE) + return UNKNOWN_LOCATION; + switch (TREE_CODE (t)) + { + case LAMBDA_EXPR: + return LAMBDA_EXPR_LOCATION (t); + case STATIC_ASSERT: + return STATIC_ASSERT_SOURCE_LOCATION (t); + case TRAIT_EXPR: + return TRAIT_EXPR_LOCATION (t); + case PTRMEM_CST: + return PTRMEM_CST_LOCATION (t); + default: + return EXPR_LOCATION (t); + } +} + inline location_t cp_expr_loc_or_loc (const_tree t, location_t or_loc) { diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc index 1487f4975c5..4066b014f6e 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -6214,30 +6214,6 @@ cp_tree_code_length (enum tree_code code) } } -/* Like EXPR_LOCATION, but also handle some tcc_exceptional that have - locations. */ - -location_t -cp_expr_location (const_tree t_) -{ - tree t = CONST_CAST_TREE (t_); - if (t == NULL_TREE) - return UNKNOWN_LOCATION; - switch (TREE_CODE (t)) - { - case LAMBDA_EXPR: - return LAMBDA_EXPR_LOCATION (t); - case STATIC_ASSERT: - return STATIC_ASSERT_SOURCE_LOCATION (t); - case TRAIT_EXPR: - return TRAIT_EXPR_LOCATION (t); - case PTRMEM_CST: - return PTRMEM_CST_LOCATION (t); - default: - return EXPR_LOCATION (t); - } -} - /* Implement -Wzero_as_null_pointer_constant. Return true if the conditions for the warning hold, false otherwise. */ bool diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc index 7dfe5acc67e..10b7ed020f7 100644 --- a/gcc/cp/typeck.cc +++ b/gcc/cp/typeck.cc @@ -11460,29 +11460,6 @@ comp_ptr_ttypes_const (tree to, tree from, compare_bounds_t cb) } } -/* Returns the type qualifiers for this type, including the qualifiers on the - elements for an array type. */ - -int -cp_type_quals (const_tree type) -{ - int quals; - /* This CONST_CAST is okay because strip_array_types returns its - argument unmodified and we assign it to a const_tree. */ - type = strip_array_types (CONST_CAST_TREE (type)); - if (type == error_mark_node - /* Quals on a FUNCTION_TYPE are memfn quals. */ - || TREE_CODE (type) == FUNCTION_TYPE) - return TYPE_UNQUALIFIED; - quals = TYPE_QUALS (type); - /* METHOD and REFERENCE_TYPEs should never have quals. */ - gcc_assert ((TREE_CODE (type) != METHOD_TYPE - && !TYPE_REF_P (type)) - || ((quals & (TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE)) - == TYPE_UNQUALIFIED)); - return quals; -} - /* Returns the function-ref-qualifier for TYPE */ cp_ref_qualifier diff --git a/gcc/tree.cc b/gcc/tree.cc index 254b2373dcf..5eb6a49da31 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -7253,18 +7253,6 @@ build_array_type_nelts (tree elt_type, poly_uint64 nelts) return build_array_type (elt_type, build_index_type (size_int (nelts - 1))); } -/* Recursively examines the array elements of TYPE, until a non-array - element type is found. */ - -tree -strip_array_types (tree type) -{ - while (TREE_CODE (type) == ARRAY_TYPE) - type = TREE_TYPE (type); - - return type; -} - /* Computes the canonical argument types from the argument type list ARGTYPES. @@ -12132,23 +12120,6 @@ get_binfo_at_offset (tree binfo, poly_int64 offset, tree expected_type) } } -/* Returns true if X is a typedef decl. */ - -bool -is_typedef_decl (const_tree x) -{ - return (x && TREE_CODE (x) == TYPE_DECL - && DECL_ORIGINAL_TYPE (x) != NULL_TREE); -} - -/* Returns true iff TYPE is a type variant created for a typedef. */ - -bool -typedef_variant_p (const_tree type) -{ - return is_typedef_decl (TYPE_NAME (type)); -} - /* PR 84195: Replace control characters in "unescaped" with their escaped equivalents. Allow newlines if -fmessage-length has been set to a non-zero value. This is done here, rather than diff --git a/gcc/tree.h b/gcc/tree.h index 4a19de1c94d..27001a4dfda 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4807,9 +4807,20 @@ tree_to_poly_uint64 (const_tree t) extern int tree_int_cst_sgn (const_tree); extern int tree_int_cst_sign_bit (const_tree); extern unsigned int tree_int_cst_min_precision (tree, signop); -extern tree strip_array_types (tree); extern tree excess_precision_type (tree); +/* Recursively examines the array elements of TYPE, until a non-array + element type is found. */ + +inline tree +strip_array_types (tree type) +{ + while (TREE_CODE (type) == ARRAY_TYPE) + type = TREE_TYPE (type); + + return type; +} + /* Desription of the reason why the argument of valid_constant_size_p is not a valid size. */ enum cst_size_error { @@ -5360,8 +5371,6 @@ extern tree create_artificial_label (location_t); extern const char *get_name (tree); extern bool stdarg_p (const_tree); extern bool prototype_p (const_tree); -extern bool is_typedef_decl (const_tree x); -extern bool typedef_variant_p (const_tree); extern bool auto_var_p (const_tree); extern bool auto_var_in_fn_p (const_tree, const_tree); extern tree build_low_bits_mask (tree, unsigned); @@ -5376,6 +5385,23 @@ extern void error_unavailable_use (tree, tree); extern tree cache_integer_cst (tree, bool might_duplicate = false); extern const char *combined_fn_name (combined_fn); +/* Returns true if X is a typedef decl. */ + +inline bool +is_typedef_decl (const_tree x) +{ + return (x && TREE_CODE (x) == TYPE_DECL + && DECL_ORIGINAL_TYPE (x) != NULL_TREE); +} + +/* Returns true iff TYPE is a type variant created for a typedef. */ + +inline bool +typedef_variant_p (const_tree type) +{ + return is_typedef_decl (TYPE_NAME (type)); +} + /* Compare and hash for any structure which begins with a canonical pointer. Assumes all pointers are interchangeable, which is sort of already assumed by gcc elsewhere IIRC. */ -- 2.39.0.rc0.49.g083e01275b