ipa-utils.h (type_with_linkage_p): Verify that type is CXX_ODR_P.

	* ipa-utils.h (type_with_linkage_p): Verify that type is
	CXX_ODR_P.
	(odr_type_p): Remove extra return.
	* lto-streamer-out.c (hash_tree): Hash TYPE_CXX_ODR_P;
	hash STRING_FLAG only for arrays and integers.
	* tree-stremaer-in.c (unpack_ts_type_common_value_fields):
	Update analogously.
	* tree-streamer-out.c (pack_ts_type_common_value_fields):
	Likewise.
	* print-tree.c (print_node): Print cxx-odr-p
	and string-flag.
	* tree.c (need_assembler_name_p): Also check that type
	is CXX_ODR_TYPE_P
	(verify_type_variant): Update verification of SRING_FLAG;
	also check CXX_ODR_P.
	* tree.h (ARRAY_OR_INTEGER_TYPE_CHECK): New macro.
	(TYPE_STRING_FLAG): Use it.
	(TYPE_CXX_ODR_P): New macro.

	* lto-common.c (compare_tree_sccs_1): Compare CXX_ODR_P;
	compare STRING_FLAG only for arrays and integers.

	* gcc-interface/decl.c (gnat_to_gnu_entity): Check that
	type is array or integer prior checking string flag.
	* gcc-interface/gigi.h (gnat_signed_type_for,
	maybe_character_value): Likewise.

	* c-common.c (braced_lists_to_strings): Check that
	type is array or integer prior checking string flag.

	* lex.c (cxx_make_type): Set TYPE_CXX_ODR_P.

	* dwarf2out.c (gen_array_type_die): First check that type
	is an array and then test string flag.

	* trans-expr.c (gfc_conv_substring): Check that
	type is array or integer prior checking string flag.
	(gfc_conv_string_parameter): Likewise.
	* trans-openmp.c (gfc_omp_scalar_p): Likewise.
	* trans.c (gfc_build_array_ref): Likewise.

From-SVN: r272628

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index ad978fd8d79f3010efdb4e381f1a9483fdec0286..b18833b4367ea2534a5229c5bd14ba438e3b1607 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,26 @@
+2019-06-24  Jan Hubicka  <jh@suse.cz>
+
+       * ipa-utils.h (type_with_linkage_p): Verify that type is
+       CXX_ODR_P.
+       (odr_type_p): Remove extra return.
+       * lto-streamer-out.c (hash_tree): Hash TYPE_CXX_ODR_P;
+       hash STRING_FLAG only for arrays and integers.
+       * tree-stremaer-in.c (unpack_ts_type_common_value_fields):
+       Update analogously.
+       * tree-streamer-out.c (pack_ts_type_common_value_fields):
+       Likewise.
+       * print-tree.c (print_node): Print cxx-odr-p
+       and string-flag.
+       * tree.c (need_assembler_name_p): Also check that type
+       is CXX_ODR_TYPE_P
+       (verify_type_variant): Update verification of SRING_FLAG;
+       also check CXX_ODR_P.
+       * tree.h (ARRAY_OR_INTEGER_TYPE_CHECK): New macro.
+       (TYPE_STRING_FLAG): Use it.
+       (TYPE_CXX_ODR_P): New macro.
+       * dwarf2out.c (gen_array_type_die): First check that type
+       is an array and then test string flag.
+
 2019-06-24  Richard Biener  <rguenther@suse.de>
 
        PR tree-optimization/90972

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index c85a4f707c69f6ce3e37b024a3fac0b4cb292686..7237daca90b8ca0afe8f108664ba7a72243041d0 100644 (file)
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,10 @@
+2019-06-24  Jan Hubicka  <jh@suse.cz>
+
+       * gcc-interface/decl.c (gnat_to_gnu_entity): Check that
+       type is array or integer prior checking string flag.
+       * gcc-interface/gigi.h (gnat_signed_type_for,
+       maybe_character_value): Likewise.
+
 2019-06-24  Martin Sebor  <msebor@redhat.com>
 
        * gcc-interface/utils.c (handle_nonnull_attribute): Quote attribute

diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index 4dfd76bfbcf9b5931e31372fcd55fff331a90d06..df405434b5c88b334019f2f3f429ddff529ec28e 100644 (file)
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -1855,7 +1855,9 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition)
          = Has_Biased_Representation (gnat_entity);
 
       /* Do the same processing for Character subtypes as for types.  */
-      if (TYPE_STRING_FLAG (TREE_TYPE (gnu_type)))
+      if ((TREE_CODE (TREE_TYPE (gnu_type)) == INTEGER_TYPE
+          || TREE_CODE (TREE_TYPE (gnu_type)) == ARRAY_TYPE)
+         && TYPE_STRING_FLAG (TREE_TYPE (gnu_type)))
        {
          TYPE_NAME (gnu_type) = gnu_entity_name;
          TYPE_STRING_FLAG (gnu_type) = 1;

diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h
index 191a017f6068e35714d93335c5404118e5d3271d..7254a161c7bb770a8e789395ef54f3bb92aadacd 100644 (file)
--- a/gcc/ada/gcc-interface/gigi.h
+++ b/gcc/ada/gcc-interface/gigi.h
@@ -1138,7 +1138,8 @@ gnat_signed_type_for (tree type_node)
 static inline tree
 maybe_character_type (tree type)
 {
-  if (TYPE_STRING_FLAG (type) && !TYPE_UNSIGNED (type))
+  if (TREE_CODE (type) == INTEGER_TYPE
+      && TYPE_STRING_FLAG (type) && !TYPE_UNSIGNED (type))
     type = gnat_unsigned_type_for (type);
 
   return type;
@@ -1151,7 +1152,8 @@ maybe_character_value (tree expr)
 {
   tree type = TREE_TYPE (expr);
 
-  if (TYPE_STRING_FLAG (type) && !TYPE_UNSIGNED (type))
+  if (TREE_CODE (type) == INTEGER_TYPE
+      && TYPE_STRING_FLAG (type) && !TYPE_UNSIGNED (type))
     {
       type = gnat_unsigned_type_for (type);
       expr = convert (type, expr);

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index fec706ae94ce2507eaa4b61d23c3c528808e04c7..d093e203ffbd4cf12905ad3d5cd3bf2026ee4d22 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,8 @@
+2019-06-24  Jan Hubicka  <jh@suse.cz>
+
+       * c-common.c (braced_lists_to_strings): Check that
+       type is array or integer prior checking string flag.
+
 2019-06-21  Matthew Beliveau  <mbelivea@redhat.com>
 
        PR c++/90875 - added -Wswitch-outside-range option

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index f562704006734a261e5d6137780916ebed06265e..6013fcaa280e08f826801bd5ff7cb22624092eec 100644 (file)
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -8847,7 +8847,8 @@ braced_lists_to_strings (tree type, tree ctor)
   else
     return ctor;
 
-  if (TYPE_STRING_FLAG (ttp))
+  if ((TREE_CODE (ttp) == ARRAY_TYPE || TREE_CODE (ttp) == INTEGER_TYPE)
+      && TYPE_STRING_FLAG (ttp))
     return braced_list_to_string (type, ctor);
 
   code = TREE_CODE (ttp);

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index efb6c3dd7b141dca0382013cb2dfe29865c0a7b6..3459ad7718b276175cd337dce1449d3e080af38f 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,7 @@
+2019-06-24  Jan Hubicka  <jh@suse.cz>
+
+       * lex.c (cxx_make_type): Set TYPE_CXX_ODR_P.
+
 2019-06-24  Jason Merrill  <jason@redhat.com>
 
        * class.c (layout_class_type): Don't use a separate

diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c
index 20965e49fe471db47791311169b18e784b8868ec..4a4325f13cf37903e590d152b831d46171611104 100644 (file)
--- a/gcc/cp/lex.c
+++ b/gcc/cp/lex.c
@@ -884,6 +884,9 @@ cxx_make_type (enum tree_code code MEM_STAT_DECL)
       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
     }
 
+  if (code == RECORD_TYPE || code == UNION_TYPE)
+    TYPE_CXX_ODR_P (t) = 1;
+
   return t;
 }
 

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 6a85c12fb761390200580c47a4aaac738a716484..7fa8b05fe5cdf724fcd6d6f4d49712375ea8417c 100644 (file)
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -21850,8 +21850,8 @@ gen_array_type_die (tree type, dw_die_ref context_die)
 
   /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
      DW_TAG_string_type doesn't have DW_AT_type attribute).  */
-  if (TYPE_STRING_FLAG (type)
-      && TREE_CODE (type) == ARRAY_TYPE
+  if (TREE_CODE (type) == ARRAY_TYPE
+      && TYPE_STRING_FLAG (type)
       && is_fortran ()
       && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
     {

diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index 6489a047280dfd49f94e875dc433aa3f3be6fa38..f70aaa61040227830bc2c914ec71b07fb46e89aa 100644 (file)
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,11 @@
+2019-06-24  Jan Hubicka  <jh@suse.cz>
+
+       * trans-expr.c (gfc_conv_substring): Check that
+       type is array or integer prior checking string flag.
+       (gfc_conv_string_parameter): Likewise.
+       * trans-openmp.c (gfc_omp_scalar_p): Likewise.
+       * trans.c (gfc_build_array_ref): Likewise.
+
 2019-06-22  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
 
        PR fortran/89782

diff --git a/gcc/fortran/trans-expr.c b/gcc/fortran/trans-expr.c
index dc173a00b11f91c939cb388dfb56ba36af5c117a..074568ab596d181b10bc16fd753e20d94b312d31 100644 (file)
--- a/gcc/fortran/trans-expr.c
+++ b/gcc/fortran/trans-expr.c
@@ -2309,7 +2309,9 @@ gfc_conv_substring (gfc_se * se, gfc_ref * ref, int kind,
        start.expr = gfc_evaluate_now (start.expr, &se->pre);
 
       /* Change the start of the string.  */
-      if (TYPE_STRING_FLAG (TREE_TYPE (se->expr)))
+      if ((TREE_CODE (TREE_TYPE (se->expr)) == ARRAY_TYPE
+          || TREE_CODE (TREE_TYPE (se->expr)) == INTEGER_TYPE)
+         && TYPE_STRING_FLAG (TREE_TYPE (se->expr)))
        tmp = se->expr;
       else
        tmp = build_fold_indirect_ref_loc (input_location,
@@ -9479,7 +9481,9 @@ gfc_conv_string_parameter (gfc_se * se)
       return;
     }
 
-  if (TYPE_STRING_FLAG (TREE_TYPE (se->expr)))
+  if ((TREE_CODE (TREE_TYPE (se->expr)) == ARRAY_TYPE
+       || TREE_CODE (TREE_TYPE (se->expr)) == INTEGER_TYPE)
+      && TYPE_STRING_FLAG (TREE_TYPE (se->expr)))
     {
       if (TREE_CODE (se->expr) != INDIRECT_REF)
        {

diff --git a/gcc/fortran/trans-openmp.c b/gcc/fortran/trans-openmp.c
index 0eb5956cc5313b97a17ebdbddec3d85b0a2148d9..394cbc2a929a8ee9cde0620de2584fe5051a8ba6 100644 (file)
--- a/gcc/fortran/trans-openmp.c
+++ b/gcc/fortran/trans-openmp.c
@@ -1222,7 +1222,8 @@ gfc_omp_scalar_p (tree decl)
          || GFC_CLASS_TYPE_P (type))
        return false;
     }
-  if (TYPE_STRING_FLAG (type))
+  if ((TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == INTEGER_TYPE)
+      && TYPE_STRING_FLAG (type))
     return false;
   if (INTEGRAL_TYPE_P (type)
       || SCALAR_FLOAT_TYPE_P (type)

diff --git a/gcc/fortran/trans.c b/gcc/fortran/trans.c
index e7844c9bf1f92fcd47630a553f4dc18ceb6d334a..0d786d9cf99f5d83fbf99362305d7cd89ef4a372 100644 (file)
--- a/gcc/fortran/trans.c
+++ b/gcc/fortran/trans.c
@@ -418,7 +418,8 @@ gfc_build_array_ref (tree base, tree offset, tree decl, tree vptr)
       tmp = gfc_build_addr_expr (pvoid_type_node, base);
       tmp = fold_build_pointer_plus_loc (input_location, tmp, offset);
       tmp = fold_convert (build_pointer_type (type), tmp);
-      if (!TYPE_STRING_FLAG (type))
+      if ((TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != ARRAY_TYPE)
+         || !TYPE_STRING_FLAG (type))
        tmp = build_fold_indirect_ref_loc (input_location, tmp);
       return tmp;
     }

diff --git a/gcc/ipa-utils.h b/gcc/ipa-utils.h
index 3e582f45283114d81828c4f4dd8a864a1379f015..64974beb6d4040fd492b313afca65682cd092536 100644 (file)
--- a/gcc/ipa-utils.h
+++ b/gcc/ipa-utils.h
@@ -205,6 +205,8 @@ type_with_linkage_p (const_tree t)
   if (!TYPE_CONTEXT (t))
     return false;
 
+  gcc_checking_assert (TREE_CODE (t) == ENUMERAL_TYPE || TYPE_CXX_ODR_P (t));
+
   return true;
 }
 

diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
index b1084f4d3c5598c44b3674728f3c389ab6f63d4e..294771d4ba82249e26b632545b1682b734640c91 100644 (file)
--- a/gcc/lto-streamer-out.c
+++ b/gcc/lto-streamer-out.c
@@ -1143,7 +1143,6 @@ hash_tree (struct streamer_tree_cache_d *cache, hash_map<tree, hashval_t> *map,
   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
     {
       hstate.add_hwi (TYPE_MODE (t));
-      hstate.add_flag (TYPE_STRING_FLAG (t));
       /* TYPE_NO_FORCE_BLK is private to stor-layout and need
         no streaming.  */
       hstate.add_flag (TYPE_PACKED (t));
@@ -1154,9 +1153,12 @@ hash_tree (struct streamer_tree_cache_d *cache, hash_map<tree, hashval_t> *map,
        {
          hstate.add_flag (TYPE_TRANSPARENT_AGGR (t));
          hstate.add_flag (TYPE_FINAL_P (t));
+          hstate.add_flag (TYPE_CXX_ODR_P (t));
        }
       else if (code == ARRAY_TYPE)
        hstate.add_flag (TYPE_NONALIASED_COMPONENT (t));
+      if (code == ARRAY_TYPE || code == INTEGER_TYPE)
+        hstate.add_flag (TYPE_STRING_FLAG (t));
       if (AGGREGATE_TYPE_P (t))
        hstate.add_flag (TYPE_TYPELESS_STORAGE (t));
       hstate.commit_flag ();

diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog
index 71a849b2e1de38c3588275506ba8332e48ce5934..95b98ab86643ac938d200c7307ece833661430fb 100644 (file)
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,8 @@
+2019-06-24  Jan Hubicka  <jh@suse.cz>
+
+       * lto-common.c (compare_tree_sccs_1): Compare CXX_ODR_P;
+       compare STRING_FLAG only for arrays and integers.
+
 2019-06-05  Martin Sebor  <msebor@redhat.com>
 
        * lto-common.c (lto_file_finalize): Adjust quoting and hyphenation.

diff --git a/gcc/lto/lto-common.c b/gcc/lto/lto-common.c
index 9d2f9c57780a2ac18edd4aa56622f87d76a3d76a..0d38ee6b57b31f367a0cd29ff80bdba0c4f4048c 100644 (file)
--- a/gcc/lto/lto-common.c
+++ b/gcc/lto/lto-common.c
@@ -1124,15 +1124,17 @@ compare_tree_sccs_1 (tree t1, tree t2, tree **map)
   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
     {
       compare_values (TYPE_MODE);
-      compare_values (TYPE_STRING_FLAG);
       compare_values (TYPE_NEEDS_CONSTRUCTING);
       if (RECORD_OR_UNION_TYPE_P (t1))
        {
          compare_values (TYPE_TRANSPARENT_AGGR);
          compare_values (TYPE_FINAL_P);
+          compare_values (TYPE_CXX_ODR_P);
        }
       else if (code == ARRAY_TYPE)
        compare_values (TYPE_NONALIASED_COMPONENT);
+      if (code == ARRAY_TYPE || code == INTEGER_TYPE)
+        compare_values (TYPE_STRING_FLAG);
       if (AGGREGATE_TYPE_P (t1))
        compare_values (TYPE_TYPELESS_STORAGE);
       compare_values (TYPE_EMPTY_P);

diff --git a/gcc/print-tree.c b/gcc/print-tree.c
index f69a2c2667998c3649cb3b38af482611b63d4197..debea2b739da8d229998cbf125b61a9fff6a2f8d 100644 (file)
--- a/gcc/print-tree.c
+++ b/gcc/print-tree.c
@@ -601,7 +601,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent,
       if (TYPE_NO_FORCE_BLK (node))
        fputs (" no-force-blk", file);
 
-      if (TYPE_STRING_FLAG (node))
+      if (code == ARRAY_TYPE && TYPE_STRING_FLAG (node))
        fputs (" string-flag", file);
 
       if (TYPE_NEEDS_CONSTRUCTING (node))
@@ -614,6 +614,11 @@ print_node (FILE *file, const char *prefix, tree node, int indent,
          && TYPE_REVERSE_STORAGE_ORDER (node))
        fputs (" reverse-storage-order", file);
 
+      if ((code == RECORD_TYPE
+          || code == UNION_TYPE)
+         && TYPE_CXX_ODR_P (node))
+       fputs (" cxx-odr-p", file);
+
       /* The transparent-union flag is used for different things in
         different nodes.  */
       if ((code == UNION_TYPE || code == RECORD_TYPE)

diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index 977b768128ed0870ddc8041c220cda2f11fe4327..23f8f01317e68f11aad55e3759df5d7f2176a2c8 100644 (file)
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -1574,6 +1574,8 @@ struct GTY(()) tree_type_common {
 
   ENUM_BITFIELD(machine_mode) mode : 8;
 
+  /* TYPE_STRING_FLAG for INTEGER_TYPE and ARRAY_TYPE.
+     TYPE_CXX_ODR_P for RECORD_TYPE and UNION_TYPE.  */
   unsigned string_flag : 1;
   unsigned lang_flag_0 : 1;
   unsigned lang_flag_1 : 1;

diff --git a/gcc/tree-streamer-in.c b/gcc/tree-streamer-in.c
index f6d137316ac5634b23fb5e8ad10abd32c295b4e4..35b3e9874d597116c4429077274b00aa4259b5c8 100644 (file)
--- a/gcc/tree-streamer-in.c
+++ b/gcc/tree-streamer-in.c
@@ -372,7 +372,6 @@ unpack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
 
   mode = bp_unpack_machine_mode (bp);
   SET_TYPE_MODE (expr, mode);
-  TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
   /* TYPE_NO_FORCE_BLK is private to stor-layout and need
      no streaming.  */
   TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
@@ -383,9 +382,12 @@ unpack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
     {
       TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
       TYPE_FINAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
+      TYPE_CXX_ODR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     }
   else if (TREE_CODE (expr) == ARRAY_TYPE)
     TYPE_NONALIASED_COMPONENT (expr) = (unsigned) bp_unpack_value (bp, 1);
+  if (TREE_CODE (expr) == ARRAY_TYPE || TREE_CODE (expr) == INTEGER_TYPE)
+    TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
   if (AGGREGATE_TYPE_P (expr))
     TYPE_TYPELESS_STORAGE (expr) = (unsigned) bp_unpack_value (bp, 1);
   TYPE_EMPTY_P (expr) = (unsigned) bp_unpack_value (bp, 1);

diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c
index b89cb6547dbc3168fd01371e95f582e75ecb2a2b..a83057ec277acad2bd7a10ea563be3a48f54f398 100644 (file)
--- a/gcc/tree-streamer-out.c
+++ b/gcc/tree-streamer-out.c
@@ -319,7 +319,6 @@ pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
      not necessary valid in a global context.
      Use the raw value previously set by layout_type.  */
   bp_pack_machine_mode (bp, TYPE_MODE_RAW (expr));
-  bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
   /* TYPE_NO_FORCE_BLK is private to stor-layout and need
      no streaming.  */
   bp_pack_value (bp, TYPE_PACKED (expr), 1);
@@ -333,9 +332,12 @@ pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
     {
       bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
       bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
+      bp_pack_value (bp, TYPE_CXX_ODR_P (expr), 1);
     }
   else if (TREE_CODE (expr) == ARRAY_TYPE)
     bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
+  if (TREE_CODE (expr) == ARRAY_TYPE || TREE_CODE (expr) == INTEGER_TYPE)
+    bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
   if (AGGREGATE_TYPE_P (expr))
     bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), 1);
   bp_pack_value (bp, TYPE_EMPTY_P (expr), 1);

diff --git a/gcc/tree.c b/gcc/tree.c
index f65025f10895959209639c2cc7786a2255af78c5..7ecf407e5face3472e6e725ee53f0d81809981c7 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -5598,6 +5598,9 @@ need_assembler_name_p (tree decl)
          && decl == TYPE_NAME (TREE_TYPE (decl))
          && TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TREE_TYPE (decl)
          && !TYPE_ARTIFICIAL (TREE_TYPE (decl))
+         && ((TREE_CODE (TREE_TYPE (decl)) != RECORD_TYPE
+              && TREE_CODE (TREE_TYPE (decl)) != UNION_TYPE)
+             || TYPE_CXX_ODR_P (TREE_TYPE (decl)))
          && (type_with_linkage_p (TREE_TYPE (decl))
              || TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE)
          && !variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
@@ -13881,7 +13884,10 @@ verify_type_variant (const_tree t, tree tv)
      Ada also builds variants of types with different TYPE_CONTEXT.   */
   if ((!in_lto_p || !TYPE_FILE_SCOPE_P (t)) && 0)
     verify_variant_match (TYPE_CONTEXT);
-  verify_variant_match (TYPE_STRING_FLAG);
+  if (TREE_CODE (t) == ARRAY_TYPE || TREE_CODE (t) == INTEGER_TYPE)
+    verify_variant_match (TYPE_STRING_FLAG);
+  if (TREE_CODE (t) == RECORD_TYPE || TREE_CODE (t) == UNION_TYPE)
+    verify_variant_match (TYPE_CXX_ODR_P);
   if (TYPE_ALIAS_SET_KNOWN_P (t))
     {
       error ("type variant with %<TYPE_ALIAS_SET_KNOWN_P%>");
@@ -14627,12 +14633,6 @@ verify_type (const_tree t)
       error ("%<TYPE_CACHED_VALUES_P%> is set while it should not be");
       error_found = true;
     }
-  if (TYPE_STRING_FLAG (t)
-      && TREE_CODE (t) != ARRAY_TYPE && TREE_CODE (t) != INTEGER_TYPE)
-    {
-      error ("%<TYPE_STRING_FLAG%> is set on wrong type code");
-      error_found = true;
-    }
   
   /* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always
      TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns

diff --git a/gcc/tree.h b/gcc/tree.h
index 23ac9b1ff5ea3170dd572ad7707994420d58575b..1a43e6b7ff8516199acbd0f57816f9d211ae8788 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -439,6 +439,8 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
   TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
 #define NOT_RECORD_OR_UNION_CHECK(T) \
   TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
+#define ARRAY_OR_INTEGER_TYPE_CHECK(T) \
+  TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)
 
 #define NUMERICAL_TYPE_CHECK(T)                                        \
   TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE,        \
@@ -2118,7 +2120,14 @@ extern machine_mode vector_type_mode (const_tree);
 /* If set in an ARRAY_TYPE, indicates a string type (for languages
    that distinguish string from array of char).
    If set in a INTEGER_TYPE, indicates a character type.  */
-#define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type_common.string_flag)
+#define TYPE_STRING_FLAG(NODE) \
+       (ARRAY_OR_INTEGER_TYPE_CHECK (NODE)->type_common.string_flag)
+
+/* If set for RECORD_TYPE or UNION_TYPE it indicates that the type conforms
+   to the C++ one definition rule.  This is used for LTO canonical type
+   computation.  */
+#define TYPE_CXX_ODR_P(NODE) \
+       (RECORD_OR_UNION_CHECK (NODE)->type_common.string_flag)
 
 /* Nonzero in a VECTOR_TYPE if the frontends should not emit warnings
    about missing conversions to other vector types of the same size.  */