lto.c (hash_canonical_type): Be sure we hash only types that need alias set.

	* 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.

From-SVN: r223608

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 82f635d5f0c74019f87220b95407b50b842e708b..92bb91e44c4d9d8a8e399cde185dcd21fb72af52 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2015-05-22  Jan Hubicka  <hubicka@ucw.cz>
+
+       * 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  <hubicka@ucw.cz>
 
        * tree.c (gimple_canonical_types_compatible_p):  Do not compare

diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog
index 45d05850a7ac63de7bc4554232288dbe649a8434..5fda10033a8a85fc079d8ccad9b35ab8ea34e6b1 100644 (file)
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,10 @@
+2015-05-22  Jan Hubicka  <hubicka@ucw.cz>
+
+       * 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  <hubicka@ucw.cz>
 
        * lto.c (hash_canonical_type): Drop hashing of METHOD_BASETYPE.

diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
index 29059eb30db484f73e31efc08082b3cfcbbd6dad..169b025eda5fb5a6f6b40e572bca82a98423e4d0 100644 (file)
--- 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 accab4dd554d7ed75e418283c8388b4e86262009..8b0344697f07f7b951548ea3bfcec2130a979aa6 100644 (file)
--- 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 2bac6988bcf8aa6e8ad5c125988199ad6d32c8fb..0b7b5239380bae2a76c097a4c01fe70228eea094 100644 (file)
--- 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 *);