From 24a769d909357fb8b94d4184ac726d3740ef7703 Mon Sep 17 00:00:00 2001 From: hubicka Date: Sat, 23 May 2015 18:25:41 +0000 Subject: [PATCH] * lto.c (hash_canonical_type): Be sure we hash only types that need alias set. (gimple_register_canonical_type_1): Do not produce canonical types for types that do not need alias sets. * tree.c (gimple_canonical_types_compatible_p): Sanity check that we do not try to compute canonical type for type that does not need alias set. (verify_type): Drop FIXME for METHOD_TYPE, update FIXME for FUNCITON_TYPE. * tree.h (type_with_alias_set_p): New. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@223608 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 9 +++++++++ gcc/lto/ChangeLog | 7 +++++++ gcc/lto/lto.c | 8 +++++++- gcc/tree.c | 17 +++++++++++++++++ gcc/tree.h | 20 ++++++++++++++++++++ 5 files changed, 60 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 82f635d5f0c..92bb91e44c4 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,14 @@ 2015-05-22 Jan Hubicka + * tree.c (gimple_canonical_types_compatible_p): Sanity check that + we do not try to compute canonical type for type that does not need + alias set. + (verify_type): Drop FIXME for METHOD_TYPE, update FIXME for + FUNCITON_TYPE. + * tree.h (type_with_alias_set_p): New. + +2015-05-22 Jan Hubicka + * tree.c (gimple_canonical_types_compatible_p): Do not compare function attributes. (verify_type): Remove METHOD_TYPE FIXME; update FUNCTION_TYPE. diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index 45d05850a7a..5fda10033a8 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,5 +1,12 @@ 2015-05-22 Jan Hubicka + * lto.c (hash_canonical_type): Be sure we hash only types that + need alias set. + (gimple_register_canonical_type_1): Do not produce canonical + types for types that do not need alias sets. + +2015-05-22 Jan Hubicka + * lto.c (hash_canonical_type): Drop hashing of METHOD_BASETYPE. 2015-05-19 Jan Hubicka diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c index 29059eb30db..169b025eda5 100644 --- a/gcc/lto/lto.c +++ b/gcc/lto/lto.c @@ -309,6 +309,12 @@ hash_canonical_type (tree type) { inchash::hash hstate; + /* We compute alias sets only for types that needs them. + Be sure we do not recurse to something else as we can not hash incomplete + types in a way they would have same hash value as compatible complete + types. */ + gcc_checking_assert (type_with_alias_set_p (type)); + /* Combine a few common features of types so that types are grouped into smaller sets; when searching for existing matching types to merge, only existing types having the same features as the new type will be @@ -489,7 +495,7 @@ gimple_register_canonical_type_1 (tree t, hashval_t hash) static void gimple_register_canonical_type (tree t) { - if (TYPE_CANONICAL (t)) + if (TYPE_CANONICAL (t) || !type_with_alias_set_p (t)) return; gimple_register_canonical_type_1 (t, hash_canonical_type (t)); diff --git a/gcc/tree.c b/gcc/tree.c index accab4dd554..8b0344697f0 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -12720,6 +12720,23 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2, if (t1 == NULL_TREE || t2 == NULL_TREE) return false; + /* We consider complete types always compatible with incomplete type. + This does not make sense for canonical type calculation and thus we + need to ensure that we are never called on it. + + FIXME: For more correctness the function probably should have three modes + 1) mode assuming that types are complete mathcing their structure + 2) mode allowing incomplete types but producing equivalence classes + and thus ignoring all info from complete types + 3) mode allowing incomplete types to match complete but checking + compatibility between complete types. + + 1 and 2 can be used for canonical type calculation. 3 is the real + definition of type compatibility that can be used i.e. for warnings during + declaration merging. */ + + gcc_assert (!trust_type_canonical + || (type_with_alias_set_p (t1) && type_with_alias_set_p (t2))); /* If the types have been previously registered and found equal they still are. */ if (TYPE_CANONICAL (t1) && TYPE_CANONICAL (t2) diff --git a/gcc/tree.h b/gcc/tree.h index 2bac6988bcf..0b7b5239380 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -5090,6 +5090,26 @@ int_bit_position (const_tree field) + wi::to_offset (DECL_FIELD_BIT_OFFSET (field))).to_shwi (); } +/* Return true if it makes sense to consider alias set for a type T. */ + +inline bool +type_with_alias_set_p (const_tree t) +{ + /* Function and method types are never accessed as memory locations. */ + if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE) + return false; + + if (COMPLETE_TYPE_P (t)) + return true; + + /* Incomplete types can not be accessed in general except for arrays + where we can fetch its element despite we have no array bounds. */ + if (TREE_CODE (t) == ARRAY_TYPE && COMPLETE_TYPE_P (TREE_TYPE (t))) + return true; + + return false; +} + extern void gt_ggc_mx (tree &); extern void gt_pch_nx (tree &); extern void gt_pch_nx (tree &, gt_pointer_operator, void *); -- 2.11.4.GIT