From ac9a30aeb23c1848a8dccda3dc0f4db6c4dcc6a4 Mon Sep 17 00:00:00 2001 From: Kai Tietz Date: Fri, 25 Mar 2011 11:28:12 +0100 Subject: [PATCH] ChangeLog gcc/ 2011-03-25 Kai Tietz * c-typeck.c (comptypes_internal): Replace target hook call of comp_type_attributes by version in tree.c file. * gimple.c (gimple_types_compatible_p_1): Likewise. * tree-ssa.c (useless_type_conversion_p): Likewise. * tree.c (build_type_attribute_qual_variant): Likewise. (attribute_value_equal): New static helper function. (comp_type_attributes): New function. (merge_attributes): Use attribute_value_equal for comparison. (attribute_list_contained): Likewise. * tree.h (comp_type_attributes): New prototype. ChangeLog cp/ 2011-03-25 Kai Tietz * decl.c (decls_match): Replace target hook call of comp_type_attributes by version in tree.c file. * search.c (check_final_overrider): Likewise. * typeck.c (structural_comptypes): Likewise. From-SVN: r171445 --- gcc/ChangeLog | 13 ++++++ gcc/c-typeck.c | 2 +- gcc/cp/ChangeLog | 7 ++++ gcc/cp/decl.c | 4 +- gcc/cp/search.c | 2 +- gcc/cp/typeck.c | 2 +- gcc/gimple.c | 2 +- gcc/tree-ssa.c | 2 +- gcc/tree.c | 106 +++++++++++++++++++++++++++++++++-------------- gcc/tree.h | 5 +++ 10 files changed, 107 insertions(+), 38 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 5fdfec9e362..ee9130e663b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2011-03-25 Kai Tietz + + * c-typeck.c (comptypes_internal): Replace target + hook call of comp_type_attributes by version in tree.c file. + * gimple.c (gimple_types_compatible_p_1): Likewise. + * tree-ssa.c (useless_type_conversion_p): Likewise. + * tree.c (build_type_attribute_qual_variant): Likewise. + (attribute_value_equal): New static helper function. + (comp_type_attributes): New function. + (merge_attributes): Use attribute_value_equal for comparison. + (attribute_list_contained): Likewise. + * tree.h (comp_type_attributes): New prototype. + 2011-03-25 Richard Guenther * tree-cfg.c (verify_gimple_assign_unary): Drop special casing diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index a22bb737533..049a8af8330 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -1079,7 +1079,7 @@ comptypes_internal (const_tree type1, const_tree type2, bool *enum_and_int_p, return 1; /* 1 if no need for warning yet, 2 if warning cause has been seen. */ - if (!(attrval = targetm.comp_type_attributes (t1, t2))) + if (!(attrval = comp_type_attributes (t1, t2))) return 0; /* 1 if no need for warning yet, 2 if warning cause has been seen. */ diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index b8069a81ce7..8bf29c7a457 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,10 @@ +2011-03-25 Kai Tietz + + * decl.c (decls_match): Replace target hook + call of comp_type_attributes by version in tree.c file. + * search.c (check_final_overrider): Likewise. + * typeck.c (structural_comptypes): Likewise. + 2011-03-21 Kai Tietz PR target/12171 diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 0985749f32a..895527c2c3e 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -1012,8 +1012,8 @@ decls_match (tree newdecl, tree olddecl) types_match = compparms (p1, p2) && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE - || targetm.comp_type_attributes (TREE_TYPE (newdecl), - TREE_TYPE (olddecl)) != 0); + || comp_type_attributes (TREE_TYPE (newdecl), + TREE_TYPE (olddecl)) != 0); } else types_match = 0; diff --git a/gcc/cp/search.c b/gcc/cp/search.c index 07ec9efd336..9ec6fc31963 100644 --- a/gcc/cp/search.c +++ b/gcc/cp/search.c @@ -1897,7 +1897,7 @@ check_final_overrider (tree overrider, tree basefn) } /* Check for conflicting type attributes. */ - if (!targetm.comp_type_attributes (over_type, base_type)) + if (!comp_type_attributes (over_type, base_type)) { error ("conflicting type attributes specified for %q+#D", overrider); error (" overriding %q+#D", basefn); diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 955ff578f11..a45ed2d7f04 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -1338,7 +1338,7 @@ structural_comptypes (tree t1, tree t2, int strict) /* If we get here, we know that from a target independent POV the types are the same. Make sure the target attributes are also the same. */ - return targetm.comp_type_attributes (t1, t2); + return comp_type_attributes (t1, t2); } /* Return true if T1 and T2 are related as allowed by STRICT. STRICT diff --git a/gcc/gimple.c b/gcc/gimple.c index 5af3cd463a1..7f29bd01e40 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -3615,7 +3615,7 @@ gimple_types_compatible_p_1 (tree t1, tree t2, enum gtc_mode mode, state, sccstack, sccstate, sccstate_obstack)) goto different_types; - if (!targetm.comp_type_attributes (t1, t2)) + if (!comp_type_attributes (t1, t2)) goto different_types; if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2)) diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c index d542e0a253a..05eb2a22e2e 100644 --- a/gcc/tree-ssa.c +++ b/gcc/tree-ssa.c @@ -1438,7 +1438,7 @@ useless_type_conversion_p (tree outer_type, tree inner_type) /* Defer to the target if necessary. */ if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type)) - return targetm.comp_type_attributes (outer_type, inner_type) != 0; + return comp_type_attributes (outer_type, inner_type) != 0; return true; } diff --git a/gcc/tree.c b/gcc/tree.c index 6f22be4992a..ef6a812ddf0 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -4287,7 +4287,7 @@ build_type_attribute_qual_variant (tree ttype, tree attribute, int quals) its canonical type, we will need to use structural equality checks for this type. */ if (TYPE_STRUCTURAL_EQUALITY_P (ttype) - || !targetm.comp_type_attributes (ntype, ttype)) + || !comp_type_attributes (ntype, ttype)) SET_TYPE_STRUCTURAL_EQUALITY (ntype); else if (TYPE_CANONICAL (ntype) == ntype) TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype); @@ -4300,6 +4300,75 @@ build_type_attribute_qual_variant (tree ttype, tree attribute, int quals) return ttype; } +/* Compare two attributes for their value identity. Return true if the + attribute values are known to be equal; otherwise return false. +*/ + +static bool +attribute_value_equal (const_tree attr1, const_tree attr2) +{ + if (TREE_VALUE (attr1) == TREE_VALUE (attr2)) + return true; + + if (TREE_VALUE (attr1) != NULL_TREE + && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST + && TREE_VALUE (attr2) != NULL + && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST) + return (simple_cst_list_equal (TREE_VALUE (attr1), + TREE_VALUE (attr2)) == 1); + + return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1); +} + +/* Return 0 if the attributes for two types are incompatible, 1 if they + are compatible, and 2 if they are nearly compatible (which causes a + warning to be generated). */ +int +comp_type_attributes (const_tree type1, const_tree type2) +{ + const_tree a1 = TYPE_ATTRIBUTES (type1); + const_tree a2 = TYPE_ATTRIBUTES (type2); + const_tree a; + + if (a1 == a2) + return 1; + for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a)) + { + const struct attribute_spec *as; + const_tree attr; + + as = lookup_attribute_spec (TREE_PURPOSE (a)); + if (!as || as->affects_type_identity == false) + continue; + + attr = lookup_attribute (as->name, CONST_CAST_TREE (a2)); + if (!attr || !attribute_value_equal (a, attr)) + break; + } + if (!a) + { + for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a)) + { + const struct attribute_spec *as; + + as = lookup_attribute_spec (TREE_PURPOSE (a)); + if (!as || as->affects_type_identity == false) + continue; + + if (!lookup_attribute (as->name, CONST_CAST_TREE (a1))) + break; + /* We don't need to compare trees again, as we did this + already in first loop. */ + } + /* All types - affecting identity - are equal, so + there is no need to call target hook for comparison. */ + if (!a) + return 1; + } + /* As some type combinations - like default calling-convention - might + be compatible, we have to call the target hook to get the final result. */ + return targetm.comp_type_attributes (type1, type2); +} /* Return a type like TTYPE except that its TYPE_ATTRIBUTE is ATTRIBUTE. @@ -5300,23 +5369,10 @@ merge_attributes (tree a1, tree a2) tree a; for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)), attributes); - a != NULL_TREE; + a != NULL_TREE && !attribute_value_equal (a, a2); a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)), TREE_CHAIN (a))) - { - if (TREE_VALUE (a) != NULL - && TREE_CODE (TREE_VALUE (a)) == TREE_LIST - && TREE_VALUE (a2) != NULL - && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST) - { - if (simple_cst_list_equal (TREE_VALUE (a), - TREE_VALUE (a2)) == 1) - break; - } - else if (simple_cst_equal (TREE_VALUE (a), - TREE_VALUE (a2)) == 1) - break; - } + ; if (a == NULL_TREE) { a1 = copy_node (a2); @@ -6254,24 +6310,12 @@ attribute_list_contained (const_tree l1, const_tree l2) const_tree. */ for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), CONST_CAST_TREE(l1)); - attr != NULL_TREE; + attr != NULL_TREE && !attribute_value_equal (t2, attr); attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), TREE_CHAIN (attr))) - { - if (TREE_VALUE (t2) != NULL - && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST - && TREE_VALUE (attr) != NULL - && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST) - { - if (simple_cst_list_equal (TREE_VALUE (t2), - TREE_VALUE (attr)) == 1) - break; - } - else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1) - break; - } + ; - if (attr == 0) + if (attr == NULL_TREE) return 0; } diff --git a/gcc/tree.h b/gcc/tree.h index 454d3287b48..9a288cb69ac 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4286,6 +4286,11 @@ extern tree build_type_attribute_variant (tree, tree); extern tree build_decl_attribute_variant (tree, tree); extern tree build_type_attribute_qual_variant (tree, tree, int); +/* Return 0 if the attributes for two types are incompatible, 1 if they + are compatible, and 2 if they are nearly compatible (which causes a + warning to be generated). */ +extern int comp_type_attributes (const_tree, const_tree); + /* Structure describing an attribute and a function to handle it. */ struct attribute_spec { -- 2.30.2