lto.c (hash_canonical_type): Use tree_code_for_canonical_type_merging.

	* lto.c (hash_canonical_type): Use tree_code_for_canonical_type_merging.

	* tree.h (tree_code_for_canonical_type_merging): New function.
	* tree.c (gimple_canonical_types_compatible_p): Use
	tree_code_for_canonical_type_merging..
	* gcc.dg/lto/c-compatible-types_0.c: New testcase.
	* gcc.dg/lto/c-compatible-types_1.c: New testcase.

From-SVN: r224135

gcc/ChangeLog

+2015-06-04  Jan Hubicka  <hubicka@ucw.cz>
+
+	* tree.h (tree_code_for_canonical_type_merging): New function.
+	* tree.c (gimple_canonical_types_compatible_p): Use
+	tree_code_for_canonical_type_merging..
+
 2015-06-04  Ramana Radhakrishnan  <ramana.radhakrishnan@arm.com>
 
 	PR c++/66192

gcc/lto/ChangeLog

+2015-06-04  Jan Hubicka  <hubicka@ucw.cz>
+
+	* lto.c (hash_canonical_type): Use tree_code_for_canonical_type_merging.
+
 2015-06-03  Jan Hubicka  <hubicka@ucw.cz>
 
 	* lto.c (iterative_hash_canonical_type,

gcc/lto/lto.c

@@ -319,7 +319,7 @@ hash_canonical_type (tree type)
      smaller sets; when searching for existing matching types to merge,
      only existing types having the same features as the new type will be
      checked.  */
-  hstate.add_int (TREE_CODE (type));
+  hstate.add_int (tree_code_for_canonical_type_merging (TREE_CODE (type)));
   hstate.add_int (TYPE_MODE (type));
 
   /* Incorporate common features of numerical types.  */

gcc/testsuite/ChangeLog

+2015-06-04  Jan Hubicka  <hubicka@ucw.cz>
+
+	* gcc.dg/lto/c-compatible-types_0.c: New testcase.
+	* gcc.dg/lto/c-compatible-types_1.c: New testcase.
+
+2015-06-03  Jan Hubicka  <hubicka@ucw.cz>
+
+	* lto.c (iterative_hash_canonical_type,
+	gimple_register_canonical_type): only hash main variants of types
+
 2015-06-04  Sandra Loosemore  <sandra@codesourcery.com>
 
 	* gcc.target/aarch64/advsimd-intrinsics/advsimd-intrinsics.exp:

gcc/testsuite/gcc.dg/lto/c-compatible-types_0.c

+/* { dg-do run } */
+/* { dg-options "-O3" } */
+/* { dg-skip-if "require -fno-short-enums to work" {target short_enums} } */
+
+/* By C standard Each enumerated type shall be compatible with char, a  signed
+   integer, type, or an unsigned integer type. The choice of type is
+   implementation-defined.  Check that enum and unsigned int match.  */
+unsigned int a;
+unsigned int *b;
+void t();
+
+void reset ()
+{
+  asm("":"=r"(a):"0"(0));
+}
+int
+main()
+{
+  asm("":"=r"(a):"0"(1));
+  asm("":"=r"(b):"0"(&a));
+  t();
+  return 0;
+}

gcc/testsuite/gcc.dg/lto/c-compatible-types_1.c

+enum a {test1, test2};
+enum a a;
+enum a *b;
+
+void reset (void);
+
+void
+t()
+{
+  if (a != test2)
+    __builtin_abort ();
+  if (*b != test2)
+    __builtin_abort ();
+  reset ();
+  if (a != test1)
+    __builtin_abort ();
+  if (*b != test1)
+    __builtin_abort ();
+}

gcc/tree.c

@@ -12930,7 +12930,8 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
     return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
 
   /* Can't be the same type if the types don't have the same code.  */
-  if (TREE_CODE (t1) != TREE_CODE (t2))
+  if (tree_code_for_canonical_type_merging (TREE_CODE (t1))
+      != tree_code_for_canonical_type_merging (TREE_CODE (t2)))
     return false;
 
   /* Qualifiers do not matter for canonical type comparison purposes.  */

gcc/tree.h

@@ -4598,6 +4598,27 @@ extern int tree_map_base_marked_p (const void *);
 extern void DEBUG_FUNCTION verify_type (const_tree t);
 extern bool gimple_canonical_types_compatible_p (const_tree, const_tree,
 						 bool trust_type_canonical = true);
+/* Return simplified tree code of type that is used for canonical type merging.  */
+inline enum tree_code
+tree_code_for_canonical_type_merging (enum tree_code code)
+{
+  /* By C standard, each enumerated type shall be compatible with char,
+     a signed integer, or an unsigned integer.  The choice of type is
+     implementation defined (in our case it depends on -fshort-enum).
+
+     For this reason we make no distinction between ENUMERAL_TYPE and INTEGER
+     type and compare only by their signedness and precision.  */
+  if (code == ENUMERAL_TYPE)
+    return INTEGER_TYPE;
+  /* To allow inter-operability between languages having references and
+     C, we consider reference types and pointers alike.  Note that this is
+     not strictly necessary for C-Fortran 2008 interoperability because
+     Fortran define C_PTR type that needs to be compatible with C pointers
+     and we handle this one as ptr_type_node.  */
+  if (code == REFERENCE_TYPE)
+    return POINTER_TYPE;
+  return code;
+}
 
 #define tree_map_eq tree_map_base_eq
 extern unsigned int tree_map_hash (const void *);