From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2100) id A87AD385802E; Thu, 14 Oct 2021 13:01:10 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org A87AD385802E Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Giuliano Belinassi To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/users/giulianob/heads/pfe_backport_dirty)] Backport Canonicalize canonical type hashing X-Act-Checkin: gcc X-Git-Author: Nathan Sidwell X-Git-Refname: refs/users/giulianob/heads/pfe_backport_dirty X-Git-Oldrev: 678444b35f863dde6d3eb17cfa0766e8e16ba177 X-Git-Newrev: 1e13eb60b3dd4cce87ee83fc01bf3d39cdac5349 Message-Id: <20211014130110.A87AD385802E@sourceware.org> Date: Thu, 14 Oct 2021 13:01:10 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 14 Oct 2021 13:01:10 -0000 https://gcc.gnu.org/g:1e13eb60b3dd4cce87ee83fc01bf3d39cdac5349 commit 1e13eb60b3dd4cce87ee83fc01bf3d39cdac5349 Author: Nathan Sidwell Date: Wed May 3 12:15:05 2017 +0000 Backport Canonicalize canonical type hashing Canonicalize canonical type hashing gcc/ * tree.h (type_hash_canon_hash): Declare. * tree.c (type_hash_list, attribute_hash_list): Move into type_hash_canon_hash. (build_type_attribute_qual_variant): Break out hash code calc into type_hash_canon_hash. (type_hash_canon_hash): New. Generic type hash computation. (build_range_type_1, build_array_type_1, build_function_type) build_method_type_directly, build_offset_type, build_complex_type, make_vector_type): Call it. gcc/c-family/ * c-common.c (complete_array_type): Use type_hash_canon. (--This line, and those below, will be ignored-- M gcc/tree.c M gcc/tree.h M gcc/c-family/ChangeLog M gcc/c-family/c-common.c M gcc/ChangeLog Diff: --- gcc/ChangeLog | 79 +++++++++++++++++++++ gcc/c-family/ChangeLog | 11 +++ gcc/c-family/c-common.c | 8 +-- gcc/tree.c | 180 +++++++++++++++++++++++------------------------- gcc/tree.h | 1 + 5 files changed, 180 insertions(+), 99 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index b993e85d2dc..9d3a9a2fe18 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,19 @@ +2021-10-13 Giuliano Belinassi + + Backport from mainline + 2017-05-03 Nathan Sidwell + + Canonicalize canonical type hashing + * tree.h (type_hash_canon_hash): Declare. + * tree.c (type_hash_list, attribute_hash_list): Move into + type_hash_canon_hash. + (build_type_attribute_qual_variant): Break out hash code calc into + type_hash_canon_hash. + (type_hash_canon_hash): New. Generic type hash computation. + (build_range_type_1, build_array_type_1, build_function_type, + build_method_type_directly, build_offset_type, build_complex_type, + make_vector_type): Call it. + 2021-10-07 Giuliano Belinassi Backport from mainline @@ -8320,6 +8336,69 @@ (aarch64_gimplify_va_arg_expr): Adjust aarch64_function_arg_alignment caller. +<<<<<<< HEAD +======= +2017-04-26 Nathan Sidwell + + * tree.h (crc32_unsigned_n): Declare. + (crc32_unsigned, crc32_unsigned): Make inline. + * tree.c (crc32_unsigned_bits): Replace with ... + (crc32_unsigned_n): ... this. + (crc32_unsigned, crc32_byte): Remove. + (crc32_string): Remove unnecessary braces. + +2017-04-25 Jan Hubicka + + * ipa-cp.c (estimate_local_effects): Convert sreal to int. + * ipa-inline-analysis.c (MAX_TIME): Remove. + (account_size_time): Use sreal for time. + (dump_inline_summary): Update. + (estimate_function_body_sizes): Update. + (estimate_edge_size_and_time): Update. + (estimate_calls_size_and_time): Update. + (estimate_node_size_and_time): Update. + (inline_merge_summary): Update. + (inline_update_overall_summary): Update. + (estimate_time_after_inlining): Update. + (inline_read_section): Update. + (inline_write_summary): Update. + * ipa-inline.c (compute_uninlined_call_time): Update. + (compute_inlined_call_time): Update. + (recursive_inlining): Update. + (inline_small_functions): Update. + (dump_overall_stats): Update. + * ipa-inline.h: Include sreal.h. + (size_time_entry): Turn time to sreal. + (inline_summary): Turn self_time nad time to sreal. + +2017-04-25 Jan Hubicka + + * sreal.c: Include backend.h, tree.h, gimple.h, cgraph.h and + data-streamer.h + (sreal::stream_out, sreal::stream_in): New. + * sreal.h (sreal::stream_out, sreal::stream_in): Declare. + +2017-04-25 Jakub Jelinek + + * Makefile.in (s-options): Invoke opt-gather.awk with LC_ALL=C in the + environment. + +2017-04-25 Uros Bizjak + + PR target/70799 + * config/i386/i386.c (dimode_scalar_to_vector_candidate_p): + Handle ASHIFTRT. + (dimode_scalar_chain::compute_convert_gain): Ditto. + (dimode_scalar_chain::make_vector_copies): Ditto. + (dimode_scalar_chain::convert_reg): Ditto. + (dimode_scalar_chain::convert_insn): Ditto. + * config/i386/sse.md (VI24_AVX512BW_1): Remove mode iterator. + (VI248_AVX512BW_1): New mode iterator. + (ashr3): Merge insn pattern with + ashrv2di3 insn using VI248_AVX512BW_1 + mode iterator. + +>>>>>>> 6fe63fb43f5 (Canonicalize canonical type hashing) 2017-04-25 Martin Sebor PR tree-optimization/80497 diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 7cbe62a8ac9..fa00b7510fd 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,4 +1,15 @@ + +2021-10-13 Giuliano Belinassi + + Backport from mainline + 2017-05-03 Nathan Sidwell + + Canonicalize canonical type hashing + * c-common.c (complete_array_type): Use type_hash_canon. + 2021-10-07 Giuliano Belinassi + + Backport from mainline 2020-05-01 H.J. Lu PR target/93492 diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index c3fb3b671cb..cfab492ba4a 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -6475,12 +6475,8 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default) layout_type (main_type); /* Make sure we have the canonical MAIN_TYPE. */ - inchash::hash hstate; - hstate.add_object (TYPE_HASH (unqual_elt)); - hstate.add_object (TYPE_HASH (TYPE_DOMAIN (main_type))); - if (!AGGREGATE_TYPE_P (unqual_elt)) - hstate.add_flag (TYPE_TYPELESS_STORAGE (main_type)); - main_type = type_hash_canon (hstate.end (), main_type); + hashval_t hashcode = type_hash_canon_hash (main_type); + main_type = type_hash_canon (hashcode, main_type); /* Fix the canonical type. */ if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type)) diff --git a/gcc/tree.c b/gcc/tree.c index 4b9cecb3593..be20303de16 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -248,8 +248,6 @@ static void set_type_quals (tree, int); static void print_type_hash_statistics (void); static void print_debug_expr_statistics (void); static void print_value_expr_statistics (void); -static void type_hash_list (const_tree, inchash::hash &); -static void attribute_hash_list (const_tree, inchash::hash &); tree global_trees[TI_MAX]; tree integer_types[itk_none]; @@ -4815,11 +4813,7 @@ build_type_attribute_qual_variant (tree otype, tree attribute, int quals) tree ttype = otype; if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute)) { - inchash::hash hstate; tree ntype; - int i; - tree t; - enum tree_code code = TREE_CODE (ttype); /* Building a distinct copy of a tagged type is inappropriate; it causes breakage in code that expects there to be a one-to-one @@ -4848,37 +4842,8 @@ build_type_attribute_qual_variant (tree otype, tree attribute, int quals) TYPE_ATTRIBUTES (ntype) = attribute; - hstate.add_int (code); - if (TREE_TYPE (ntype)) - hstate.add_object (TYPE_HASH (TREE_TYPE (ntype))); - attribute_hash_list (attribute, hstate); - - switch (TREE_CODE (ntype)) - { - case FUNCTION_TYPE: - type_hash_list (TYPE_ARG_TYPES (ntype), hstate); - break; - case ARRAY_TYPE: - if (TYPE_DOMAIN (ntype)) - hstate.add_object (TYPE_HASH (TYPE_DOMAIN (ntype))); - break; - case INTEGER_TYPE: - t = TYPE_MAX_VALUE (ntype); - for (i = 0; i < TREE_INT_CST_NUNITS (t); i++) - hstate.add_object (TREE_INT_CST_ELT (t, i)); - break; - case REAL_TYPE: - case FIXED_POINT_TYPE: - { - unsigned int precision = TYPE_PRECISION (ntype); - hstate.add_object (precision); - } - break; - default: - break; - } - - ntype = type_hash_canon (hstate.end(), ntype); + hashval_t hash = type_hash_canon_hash (ntype); + ntype = type_hash_canon (hash, ntype); /* If the target-dependent attributes make NTYPE different from its canonical type, we will need to use structural equality @@ -6995,18 +6960,80 @@ decl_debug_args_insert (tree from) /* Hashing of types so that we don't make duplicates. The entry point is `type_hash_canon'. */ -/* Compute a hash code for a list of types (chain of TREE_LIST nodes - with types in the TREE_VALUE slots), by adding the hash codes - of the individual types. */ +/* Generate the default hash code for TYPE. This is designed for + speed, rather than maximum entropy. */ -static void -type_hash_list (const_tree list, inchash::hash &hstate) +hashval_t +type_hash_canon_hash (tree type) { - const_tree tail; + inchash::hash hstate; - for (tail = list; tail; tail = TREE_CHAIN (tail)) - if (TREE_VALUE (tail) != error_mark_node) - hstate.add_object (TYPE_HASH (TREE_VALUE (tail))); + hstate.add_int (TREE_CODE (type)); + + if (TREE_TYPE (type)) + hstate.add_object (TYPE_HASH (TREE_TYPE (type))); + + for (tree t = TYPE_ATTRIBUTES (type); t; t = TREE_CHAIN (t)) + /* Just the identifier is adequate to distinguish. */ + hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (t))); + + switch (TREE_CODE (type)) + { + case METHOD_TYPE: + hstate.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type))); + /* FALLTHROUGH. */ + case FUNCTION_TYPE: + for (tree t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t)) + if (TREE_VALUE (t) != error_mark_node) + hstate.add_object (TYPE_HASH (TREE_VALUE (t))); + break; + + case OFFSET_TYPE: + hstate.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type))); + break; + + case ARRAY_TYPE: + { + if (TYPE_DOMAIN (type)) + hstate.add_object (TYPE_HASH (TYPE_DOMAIN (type))); + if (!AGGREGATE_TYPE_P (TREE_TYPE (type))) + { + unsigned typeless = TYPE_TYPELESS_STORAGE (type); + hstate.add_object (typeless); + } + } + break; + + case INTEGER_TYPE: + { + tree t = TYPE_MAX_VALUE (type); + if (!t) + t = TYPE_MIN_VALUE (type); + for (int i = 0; i < TREE_INT_CST_NUNITS (t); i++) + hstate.add_object (TREE_INT_CST_ELT (t, i)); + break; + } + + case REAL_TYPE: + case FIXED_POINT_TYPE: + { + unsigned prec = TYPE_PRECISION (type); + hstate.add_object (prec); + break; + } + + case VECTOR_TYPE: + { + unsigned nunits = TYPE_VECTOR_SUBPARTS (type); + hstate.add_object (nunits); + break; + } + + default: + break; + } + + return hstate.end (); } /* These are the Hashtable callback functions. */ @@ -7187,20 +7214,6 @@ print_type_hash_statistics (void) type_hash_table->collisions ()); } -/* Compute a hash code for a list of attributes (chain of TREE_LIST nodes - with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots), - by adding the hash codes of the individual attributes. */ - -static void -attribute_hash_list (const_tree list, inchash::hash &hstate) -{ - const_tree tail; - - for (tail = list; tail; tail = TREE_CHAIN (tail)) - /* ??? Do we want to add in TREE_VALUE too? */ - hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (tail))); -} - /* Given two lists of attributes, return true if list l2 is equivalent to l1. */ @@ -8268,7 +8281,6 @@ static tree build_range_type_1 (tree type, tree lowval, tree highval, bool shared) { tree itype = make_node (INTEGER_TYPE); - inchash::hash hstate; TREE_TYPE (itype) = type; @@ -8296,10 +8308,8 @@ build_range_type_1 (tree type, tree lowval, tree highval, bool shared) return itype; } - inchash::add_expr (TYPE_MIN_VALUE (itype), hstate); - inchash::add_expr (TYPE_MAX_VALUE (itype), hstate); - hstate.merge_hash (TYPE_HASH (type)); - itype = type_hash_canon (hstate.end (), itype); + hashval_t hash = type_hash_canon_hash (itype); + itype = type_hash_canon (hash, itype); return itype; } @@ -8407,13 +8417,8 @@ build_array_type_1 (tree elt_type, tree index_type, bool typeless_storage, if (shared) { - inchash::hash hstate; - hstate.add_object (TYPE_HASH (elt_type)); - if (index_type) - hstate.add_object (TYPE_HASH (index_type)); - if (!AGGREGATE_TYPE_P (elt_type)) - hstate.add_flag (TYPE_TYPELESS_STORAGE (t)); - t = type_hash_canon (hstate.end (), t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); } if (TYPE_CANONICAL (t) == t) @@ -8570,9 +8575,8 @@ build_function_type (tree value_type, tree arg_types) TYPE_ARG_TYPES (t) = arg_types; /* If we already have such a type, use the old one. */ - hstate.add_object (TYPE_HASH (value_type)); - type_hash_list (arg_types, hstate); - t = type_hash_canon (hstate.end (), t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); /* Set up the canonical type. */ any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type); @@ -8709,7 +8713,6 @@ build_method_type_directly (tree basetype, { tree t; tree ptype; - inchash::hash hstate; bool any_structural_p, any_noncanonical_p; tree canon_argtypes; @@ -8726,10 +8729,8 @@ build_method_type_directly (tree basetype, TYPE_ARG_TYPES (t) = argtypes; /* If we already have such a type, use the old one. */ - hstate.add_object (TYPE_HASH (basetype)); - hstate.add_object (TYPE_HASH (rettype)); - type_hash_list (argtypes, hstate); - t = type_hash_canon (hstate.end (), t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); /* Set up the canonical type. */ any_structural_p @@ -8777,7 +8778,6 @@ tree build_offset_type (tree basetype, tree type) { tree t; - inchash::hash hstate; /* Make a node of the sort we want. */ t = make_node (OFFSET_TYPE); @@ -8786,9 +8786,8 @@ build_offset_type (tree basetype, tree type) TREE_TYPE (t) = type; /* If we already have such a type, use the old one. */ - hstate.add_object (TYPE_HASH (basetype)); - hstate.add_object (TYPE_HASH (type)); - t = type_hash_canon (hstate.end (), t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); if (!COMPLETE_TYPE_P (t)) layout_type (t); @@ -8819,7 +8818,6 @@ tree build_complex_type (tree component_type, bool named) { tree t; - inchash::hash hstate; gcc_assert (INTEGRAL_TYPE_P (component_type) || SCALAR_FLOAT_TYPE_P (component_type) @@ -8831,8 +8829,8 @@ build_complex_type (tree component_type, bool named) TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type); /* If we already have such a type, use the old one. */ - hstate.add_object (TYPE_HASH (component_type)); - t = type_hash_canon (hstate.end (), t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); if (!COMPLETE_TYPE_P (t)) layout_type (t); @@ -10093,7 +10091,6 @@ static tree make_vector_type (tree innertype, int nunits, machine_mode mode) { tree t; - inchash::hash hstate; tree mv_innertype = TYPE_MAIN_VARIANT (innertype); t = make_node (VECTOR_TYPE); @@ -10111,11 +10108,8 @@ make_vector_type (tree innertype, int nunits, machine_mode mode) layout_type (t); - hstate.add_wide_int (VECTOR_TYPE); - hstate.add_wide_int (nunits); - hstate.add_wide_int (mode); - hstate.add_object (TYPE_HASH (TREE_TYPE (t))); - t = type_hash_canon (hstate.end (), t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); /* We have built a main variant, based on the main variant of the inner type. Use it to build the variant we return. */ diff --git a/gcc/tree.h b/gcc/tree.h index a49ccf6d076..88b8d65893a 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4305,6 +4305,7 @@ extern tree build_variant_type_copy (tree); How the hash code is computed is up to the caller, as long as any two callers that could hash identical-looking type nodes agree. */ +extern hashval_t type_hash_canon_hash (tree); extern tree type_hash_canon (unsigned int, tree); extern tree convert (tree, tree);