[gcc-6] 241/401: * Reapply fix for PR c++/71912, apply proposed fix for PR c++/78039. Closes: #841292.

Ximin Luo infinity0 at debian.org
Wed Apr 5 15:49:49 UTC 2017


This is an automated email from the git hooks/post-receive script.

infinity0 pushed a commit to branch pu/reproducible_builds
in repository gcc-6.

commit d35c720e6d2b094e3b4dbe9bae5f332d37cc58aa
Author: doko <doko at 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca>
Date:   Thu Oct 27 12:25:42 2016 +0000

      * Reapply fix for PR c++/71912, apply proposed fix for PR c++/78039.
        Closes: #841292.
    
    
    git-svn-id: svn://anonscm.debian.org/gcccvs/branches/sid/gcc-6@9016 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca
---
 debian/changelog                   |   2 +
 debian/patches/pr71912-revert.diff | 767 -------------------------------------
 debian/patches/pr78039.diff        | 605 +++++++++++++++++++++++++++++
 debian/rules.patch                 |   2 +-
 4 files changed, 608 insertions(+), 768 deletions(-)

diff --git a/debian/changelog b/debian/changelog
index 4e02611..1851537 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -7,6 +7,8 @@ gcc-6 (6.2.0-10) UNRELEASED; urgency=medium
       PR fortran/78021, PR fortran/72832.
   * Include go-relocation-test-gcc620-sparc64.obj.uue to fix libgo's
     debug/elf TestDWARFRelocations test case (James Clark).
+  * Reapply fix for PR c++/71912, apply proposed fix for PR c++/78039.
+    Closes: #841292.
 
  -- Matthias Klose <doko at debian.org>  Wed, 26 Oct 2016 11:19:44 +0200
 
diff --git a/debian/patches/pr71912-revert.diff b/debian/patches/pr71912-revert.diff
deleted file mode 100644
index 2d32556..0000000
--- a/debian/patches/pr71912-revert.diff
+++ /dev/null
@@ -1,767 +0,0 @@
-# DP: Revert fix for PR c++/71912, causing PR c++/78039.
-
-Index: b/src/gcc/testsuite/ChangeLog
-===================================================================
---- a/src/gcc/testsuite/ChangeLog
-+++ b/src/gcc/testsuite/ChangeLog
-@@ -41,19 +41,6 @@
- 	* gcc.target/sparc/bmaskbshuf-1.c: ...this.
- 	* gcc.target/sparc/bmaskbshuf-2.c: New test.
- 
--2016-10-14  Martin Sebor  <msebor at redhat.com>
--
--	PR c++/71912
--	* g++.dg/ext/flexary4.C: Adjust.
--	* g++.dg/ext/flexary5.C: Same.
--	* g++.dg/ext/flexary9.C: Same.
--	* g++.dg/ext/flexary19.C: New test.
--	* g++.dg/ext/flexary18.C: New test.
--	* g++.dg/torture/pr64312.C: Add a dg-error directive to an ill-formed
--	regression test.
--        * g++.dg/compat/struct-layout-1_generate.c (subfield): Add argument.
--        Avoid generating a flexible array member in an array.
--
- 2016-10-13  Andrew Senkevich  <andrew.senkevich at intel.com>
- 
- 	Backport from trunk
-Index: b/src/gcc/testsuite/g++.dg/torture/pr64312.C
-===================================================================
---- a/src/gcc/testsuite/g++.dg/torture/pr64312.C
-+++ b/src/gcc/testsuite/g++.dg/torture/pr64312.C
-@@ -44,7 +44,7 @@ class F
- {
- public:
-   int nelems;
--  int elems[];   // { dg-error "not at end" }
-+  int elems[];
-   int *
-   m_fn1 ()
-   {
-@@ -88,7 +88,7 @@ public:
-       m_impl->~any_incrementable_iterator_interface ();
-   }
-   G m_buffer;
--  any_incrementable_iterator_interface *m_impl;   // { dg-message "next member" }
-+  any_incrementable_iterator_interface *m_impl;
- };
- template <class Reference> class K : public I<any_iterator<Reference> >
- {
-Index: b/src/gcc/testsuite/g++.dg/ext/flexary4.C
-===================================================================
---- a/src/gcc/testsuite/g++.dg/ext/flexary4.C
-+++ b/src/gcc/testsuite/g++.dg/ext/flexary4.C
-@@ -102,28 +102,31 @@ struct Sx17 {
-   int a_0 [0];
- };
- 
--// An empty struct is treated as if it had a single member of type
--// char but the member cannot be accessed.  Therefore, a struct
-+// Empty structs are a GCC extension that (in C++ only) is treated
-+// as if it had a single member of type char.  Therefore, a struct
- // containing a flexible array member followed by an empty struct
- // is diagnosed to prevent the former subobject from sharing space
- // with the latter.
- struct Sx18 {
-   int a_x [];               // { dg-error "flexible array member" }
--  struct { /* empty */ } s;
-+  struct S { };
- };
- 
--// Anonymous structs are a G++ extension.  Members of anonymous structs
--// are treated as if they were declared in the enclosing class.
-+// Anonymous structs and unions are another GCC extension.  Since
-+// they cannot be named and thus used to store the size of a flexible
-+// array member, a struct containing both is diagnosed as if
-+// the flexible array member appeared alone.
- struct Sx19 {
--  struct { int i; };        // anonymous struct
--  int a_x [];
-+  struct S { };
-+  union U { };
-+  int a_x [];               // { dg-error "in an otherwise empty" }
- };
- 
--// Unlike in the case above, a named struct is not anonymous and
--// so doesn't contribute its member to that of the enclosing struct.
-+// Unlike in the case above, a named member of an anonymous struct
-+// prevents a subsequent flexible array member from being diagnosed.
- struct Sx20 {
--  struct S { int i; };
--  int a_x [];               // { dg-error "in an otherwise empty" }
-+  struct S { } s;
-+  int a_x [];
- };
- 
- struct Sx21 {
-@@ -295,15 +298,6 @@ struct Anon1 {
- 
- ASSERT_AT_END (Anon1, good);
- 
--struct NotAnon1 {
--  int n;
--  // The following is not an anonymous struct -- the type is unnamed
--  // but the object has a name.
--  struct {
--    int bad[];              // { dg-error "otherwise empty" }
--  } name;
--};
--
- struct Anon2 {
-   struct {
-     int n;
-@@ -358,6 +352,7 @@ struct Anon7 {
-   int n;
- };
- 
-+
- struct Six {
-   int i;
-   int a[];
-Index: b/src/gcc/testsuite/g++.dg/ext/flexary5.C
-===================================================================
---- a/src/gcc/testsuite/g++.dg/ext/flexary5.C
-+++ b/src/gcc/testsuite/g++.dg/ext/flexary5.C
-@@ -64,29 +64,19 @@ struct D5: E1, E2, NE { char a[]; };
- 
- ASSERT_AT_END (D5, a);   // { dg-warning "offsetof within non-standard-layout" }
- 
--struct A2x_1 {
-+struct A2x {
-   size_t n;
--  size_t a[];   // { dg-error "not at end of .struct D6." }
--};
--
--struct A2x_2 {
--  size_t n;
--  size_t a[];   // { dg-error "not at end of .struct D7." }
--};
--
--struct A2x_3 {
--  size_t n;
--  size_t a[];   // { dg-error "not at end of .struct D8." }
-+  size_t a[];   // { dg-error "not at end of .struct D6.| D7.| D8." }
- };
- 
- // Verify that the flexible array member in A2x above is diagnosed
- // for each of the three struct defintions below which also derive
- // from another struct with a flexible array member.
--struct D6: A2x_1, E1, A1x { };
--struct D7: E1, A2x_2, E2, A1x { };
--struct D8: E1, E2, A2x_3, A1x { };
-+struct D6: A2x, E1, A1x { };
-+struct D7: E1, A2x, E2, A1x { };
-+struct D8: E1, E2, A2x, A1x { };
- 
--struct DA2x: A2x_1 { };
-+struct DA2x: A2x { };
- 
- struct D9: DA2x, E1, E2 { };
- 
-@@ -204,27 +194,16 @@ struct NE2: NE { };
- struct D28: NE1, AA6x { };
- struct D29: AA6x, NE1 { };
- 
-+// Verify that a flexible array member in a virtual base class is not
-+// diagnosed.
- struct A7x {
-   size_t n;
--  size_t a[];               // { dg-error "flexible array member .A7x::a. not at end of .struct D33." }
-+  size_t a[];
- };
- 
--// Verify that a flexible array member in a virtual base class is not
--// diagnosed.
- struct DA7xV1: virtual A7x { };
- struct DA7xV2: virtual A7x { };
- 
- struct D30: DA7xV1, DA7xV2 { };
- struct D31: DA7xV1, DA7xV2 { };
- struct D32: D30, D31 { };
--
--// Verify the diagnostic when the flexible array is in an anonymous struct.
--struct A8x {
--  struct {                  // { dg-message "next member .A8x::<anonymous struct> A8x::<anonymous>. declared here" }
--    size_t n;
--    size_t a[];
--  };
--};
--
--struct D33:                 // { dg-message "in the definition of .struct D33." }
--  A7x, A8x { };
-Index: b/src/gcc/testsuite/g++.dg/ext/flexary9.C
-===================================================================
---- a/src/gcc/testsuite/g++.dg/ext/flexary9.C
-+++ b/src/gcc/testsuite/g++.dg/ext/flexary9.C
-@@ -281,15 +281,15 @@ struct S_S_S_x {
- 
- struct Anon1 {
-   int n;
--  struct {                  // { dg-warning "invalid use \[^\n\r\]* with a zero-size array" }
--    int good[0];            // { dg-warning "forbids zero-size array" }
-+  struct {
-+    int good[0];            // { dg-warning "zero-size array" }
-   };                        // { dg-warning "anonymous struct" }
- };
- 
- ASSERT_AT_END (Anon1, good);
- 
- struct Anon2 {
--  struct {                  // { dg-warning "invalid use" }
-+  struct {
-     int n;
-     struct {
-       int good[0];          // { dg-warning "zero-size array" }
-@@ -300,7 +300,7 @@ struct Anon2 {
- ASSERT_AT_END (Anon2, good);
- 
- struct Anon3 {
--  struct {                  // { dg-warning "invalid use" }
-+  struct {
-     struct {
-       int n;
-       int good[0];          // { dg-warning "zero-size array" }
-Index: b/src/gcc/testsuite/g++.dg/compat/struct-layout-1_generate.c
-===================================================================
---- a/src/gcc/testsuite/g++.dg/compat/struct-layout-1_generate.c
-+++ b/src/gcc/testsuite/g++.dg/compat/struct-layout-1_generate.c
-@@ -495,16 +495,7 @@ struct types attrib_array_types[] = {
- #define HASH_SIZE 32749
- static struct entry *hash_table[HASH_SIZE];
- 
--/* The index of the current type being output.  */
--static int idx;
--
--/* The maximum index of the type(s) to output.  */
--static int limidx;
--
--/* Set to non-zero to output a single type in response to the -i option
--   (which sets LIMIDX to the index of the type to output.  */
--static int output_one;
--static int short_enums;
-+static int idx, limidx, output_one, short_enums;
- static const char *destdir;
- static const char *srcdir;
- static const char *srcdir_safe;
-@@ -544,7 +535,6 @@ switchfiles (int fields)
-       fputs ("failed to create test files\n", stderr);
-       exit (1);
-     }
--
-   for (i = 0; i < NDG_OPTIONS; i++)
-     fprintf (outfile, dg_options[i], "", srcdir_safe);
-   fprintf (outfile, "\n\
-@@ -617,14 +607,9 @@ getrandll (void)
- 
- /* Generate a subfield.  The object pointed to by FLEX is set to a non-zero
-    value when the generated field is a flexible array member.  When set, it
--   prevents subsequent fields from being generated (a flexible array member
--   must be the last member of the struct it's defined in).  ARRAY is non-
--   zero when the enclosing structure is part of an array.  In that case,
--   avoid generating a flexible array member as a subfield (such a member
--   would be invalid).  */
--
-+   prevents subsequent fields from being generated (a flexible array mem*/
- int
--subfield (struct entry *e, char *letter, int *flex, int array)
-+subfield (struct entry *e, char *letter, int *flex)
- {
-   int i, type;
-   char buf[20];
-@@ -679,14 +664,7 @@ subfield (struct entry *e, char *letter,
- 	}
- 
-       for (i = 1; !*flex && i <= e[0].len; )
--	{
--	  /* Avoid generating flexible array members if the enclosing
--	     type is an array.  */
--	  int array
--	    = (e[0].etype == ETYPE_STRUCT_ARRAY
--	       || e[0].etype == ETYPE_UNION_ARRAY);
--	    i += subfield (e + i, letter, flex, array);
--	}
-+	i += subfield (e + i, letter, flex);
- 
-       switch (type)
- 	{
-@@ -707,7 +685,7 @@ subfield (struct entry *e, char *letter,
-     case ETYPE_ARRAY:
-       if (e[0].etype == ETYPE_ARRAY)
- 	{
--	  if (!array && e[0].arr_len == 255)
-+	  if (e[0].arr_len == 255)
- 	    {
- 	      *flex = 1;
-  	      snprintf (buf, 20, "%c[]", *letter);
-@@ -1163,7 +1141,6 @@ e_insert (struct entry *e)
-   hash_table[hval % HASH_SIZE] = e;
- }
- 
--/* Output a single type.  */
- void
- output (struct entry *e)
- {
-@@ -1192,7 +1169,7 @@ output (struct entry *e)
- 
-   int flex = 0;
-   for (i = 1; i <= e[0].len; )
--    i += subfield (e + i, &c, &flex, 0);
-+    i += subfield (e + i, &c, &flex);
-   
-   fputs (",", outfile);
-   c = 'a';
-Index: b/src/gcc/cp/class.c
-===================================================================
---- a/src/gcc/cp/class.c
-+++ b/src/gcc/cp/class.c
-@@ -147,12 +147,11 @@ static void check_methods (tree);
- static void remove_zero_width_bit_fields (tree);
- static bool accessible_nvdtor_p (tree);
- 
--/* Used by find_flexarrays and related functions.  */
-+/* Used by find_flexarrays and related.  */
- struct flexmems_t;
-+static void find_flexarrays (tree, flexmems_t *);
- static void diagnose_flexarrays (tree, const flexmems_t *);
--static void find_flexarrays (tree, flexmems_t *, bool = false,
--			     tree = NULL_TREE, tree = NULL_TREE);
--static void check_flexarrays (tree, flexmems_t * = NULL, bool = false);
-+static void check_flexarrays (tree, flexmems_t * = NULL);
- static void check_bases (tree, int *, int *);
- static void check_bases_and_members (tree);
- static tree create_vtable_ptr (tree, tree *);
-@@ -6688,147 +6687,52 @@ field_nonempty_p (const_tree fld)
-   return false;
- }
- 
--/* Used by find_flexarrays and related functions.  */
--
--struct flexmems_t
--{
-+/* Used by find_flexarrays and related.  */
-+struct flexmems_t {
-   /* The first flexible array member or non-zero array member found
--     in the order of layout.  */
-+     in order of layout.  */
-   tree array;
-   /* First non-static non-empty data member in the class or its bases.  */
-   tree first;
--  /* The first non-static non-empty data member following either
--     the flexible array member, if found, or the zero-length array member
--     otherwise.  AFTER[1] refers to the first such data member of a union
--     of which the struct containing the flexible array member or zero-length
--     array is a member, or NULL when no such union exists.  This element is
--     only used during searching, not for diagnosing problems.  AFTER[0]
--     refers to the first such data member that is not a member of such
--     a union.  */
--  tree after[2];
--
--  /* Refers to a struct (not union) in which the struct of which the flexible
--     array is member is defined.  Used to diagnose strictly (according to C)
--     invalid uses of the latter structs.  */
--  tree enclosing;
-+  /* First non-static non-empty data member following either the flexible
-+     array member, if found, or the zero-length array member.  */
-+  tree after;
- };
- 
- /* Find either the first flexible array member or the first zero-length
--   array, in that order of preference, among members of class T (but not
--   its base classes), and set members of FMEM accordingly.
--   BASE_P is true if T is a base class of another class.
--   PUN is set to the outermost union in which the flexible array member
--   (or zero-length array) is defined if one such union exists, otherwise
--   to NULL.
--   Similarly, PSTR is set to a data member of the outermost struct of
--   which the flexible array is a member if one such struct exists,
--   otherwise to NULL.  */
--
--static void
--find_flexarrays (tree t, flexmems_t *fmem, bool base_p,
--		 tree pun /* = NULL_TREE */,
--		 tree pstr /* = NULL_TREE */)
--{
--  /* Set the "pointer" to the outermost enclosing union if not set
--     yet and maintain it for the remainder of the recursion.   */
--  if (!pun && TREE_CODE (t) == UNION_TYPE)
--    pun = t;
-+   array, in that order or preference, among members of class T (but not
-+   its base classes), and set members of FMEM accordingly.  */
- 
--  for (tree fld = TYPE_FIELDS (t); fld; fld = DECL_CHAIN (fld))
-+static void
-+find_flexarrays (tree t, flexmems_t *fmem)
-+{
-+  for (tree fld = TYPE_FIELDS (t), next; fld; fld = next)
-     {
--      if (fld == error_mark_node)
--	return;
--
--      /* Is FLD a typedef for an anonymous struct?  */
-+      /* Find the next non-static data member if it exists.  */
-+      for (next = fld;
-+	   (next = DECL_CHAIN (next))
-+	     && TREE_CODE (next) != FIELD_DECL; );
- 
--      /* FIXME: Note that typedefs (as well as arrays) need to be fully
--	 handled elsewhere so that errors like the following are detected
--	 as well:
--	   typedef struct { int i, a[], j; } S;   // bug c++/72753
--	   S s [2];                               // bug c++/68489
--      */
--      if (TREE_CODE (fld) == TYPE_DECL
--	  && DECL_IMPLICIT_TYPEDEF_P (fld)
--	  && CLASS_TYPE_P (TREE_TYPE (fld))
--	  && anon_aggrname_p (DECL_NAME (fld)))
--	{
--	  /* Check the nested unnamed type referenced via a typedef
--	     independently of FMEM (since it's not a data member of
--	     the enclosing class).  */
--	  check_flexarrays (TREE_TYPE (fld));
-+      tree fldtype = TREE_TYPE (fld);
-+      if (TREE_CODE (fld) != TYPE_DECL
-+	  && RECORD_OR_UNION_TYPE_P (fldtype)
-+	  && TYPE_ANONYMOUS_P (fldtype))
-+	{
-+	  /* Members of anonymous structs and unions are treated as if
-+	     they were members of the containing class.  Descend into
-+	     the anonymous struct or union and find a flexible array
-+	     member or zero-length array among its fields.  */
-+	  find_flexarrays (fldtype, fmem);
- 	  continue;
- 	}
- 
--      /* Skip anything that's GCC-generated or not a (non-static) data
--	 member.  */
--      if (DECL_ARTIFICIAL (fld) || TREE_CODE (fld) != FIELD_DECL)
-+      /* Skip anything that's not a (non-static) data member.  */
-+      if (TREE_CODE (fld) != FIELD_DECL)
- 	continue;
- 
--      /* Type of the member.  */
--      tree fldtype = TREE_TYPE (fld);
--      if (fldtype == error_mark_node)
--	return;
--
--      /* Determine the type of the array element or object referenced
--	 by the member so that it can be checked for flexible array
--	 members if it hasn't been yet.  */
--      tree eltype = fldtype;
--      while (TREE_CODE (eltype) == ARRAY_TYPE
--	     || TREE_CODE (eltype) == POINTER_TYPE
--	     || TREE_CODE (eltype) == REFERENCE_TYPE)
--	eltype = TREE_TYPE (eltype);
--
--      if (RECORD_OR_UNION_TYPE_P (eltype))
--	{
--	  if (fmem->array && !fmem->after[bool (pun)])
--	    {
--	      /* Once the member after the flexible array has been found
--		 we're done.  */
--	      fmem->after[bool (pun)] = fld;
--	      break;
--	    }
--
--	  if (eltype == fldtype || TYPE_ANONYMOUS_P (eltype))
--	    {
--	      /* Descend into the non-static member struct or union and try
--		 to find a flexible array member or zero-length array among
--		 its members.  This is only necessary for anonymous types
--		 and types in whose context the current type T has not been
--		 defined (the latter must not be checked again because they
--		 are already in the process of being checked by one of the
--		 recursive calls).  */
--
--	      tree first = fmem->first;
--	      tree array = fmem->array;
--
--	      /* If this member isn't anonymous and a prior non-flexible array
--		 member has been seen in one of the enclosing structs, clear
--		 the FIRST member since it doesn't contribute to the flexible
--		 array struct's members.  */
--	      if (first && !array && !ANON_AGGR_TYPE_P (eltype))
--		fmem->first = NULL_TREE;
--
--	      find_flexarrays (eltype, fmem, false, pun,
--			       !pstr && TREE_CODE (t) == RECORD_TYPE ? fld : pstr);
--
--	      if (fmem->array != array)
--		continue;
--
--	      if (first && !array && !ANON_AGGR_TYPE_P (eltype))
--		{
--		  /* Restore the FIRST member reset above if no flexible
--		     array member has been found in this member's struct.  */
--		  fmem->first = first;
--		}
--
--	      /* If the member struct contains the first flexible array
--		 member, or if this member is a base class, continue to
--		 the next member and avoid setting the FMEM->NEXT pointer
--		 to point to it.  */
--	      if (base_p)
--		continue;
--	    }
--	}
-+      /* Skip virtual table pointers.  */
-+      if (DECL_ARTIFICIAL (fld))
-+	continue;
- 
-       if (field_nonempty_p (fld))
- 	{
-@@ -6839,8 +6743,8 @@ find_flexarrays (tree t, flexmems_t *fme
- 	  /* Remember the first non-static data member after the flexible
- 	     array member, if one has been found, or the zero-length array
- 	     if it has been found.  */
--	  if (fmem->array && !fmem->after[bool (pun)])
--	    fmem->after[bool (pun)] = fld;
-+	  if (!fmem->after && fmem->array)
-+	    fmem->after = fld;
- 	}
- 
-       /* Skip non-arrays.  */
-@@ -6856,16 +6760,13 @@ find_flexarrays (tree t, flexmems_t *fme
- 		 such field or a flexible array member has been seen to
- 		 handle the pathological and unlikely case of multiple
- 		 such members.  */
--	      if (!fmem->after[bool (pun)])
--		fmem->after[bool (pun)] = fld;
-+	      if (!fmem->after)
-+		fmem->after = fld;
- 	    }
- 	  else if (integer_all_onesp (TYPE_MAX_VALUE (TYPE_DOMAIN (fldtype))))
--	    {
--	      /* Remember the first zero-length array unless a flexible array
--		 member has already been seen.  */
--	      fmem->array = fld;
--	      fmem->enclosing = pstr;
--	    }
-+	    /* Remember the first zero-length array unless a flexible array
-+	       member has already been seen.  */
-+	    fmem->array = fld;
- 	}
-       else
- 	{
-@@ -6876,39 +6777,16 @@ find_flexarrays (tree t, flexmems_t *fme
- 		 reset the after pointer.  */
- 	      if (TYPE_DOMAIN (TREE_TYPE (fmem->array)))
- 		{
--		  fmem->after[bool (pun)] = NULL_TREE;
- 		  fmem->array = fld;
--		  fmem->enclosing = pstr;
-+		  fmem->after = NULL_TREE;
- 		}
- 	    }
- 	  else
--	    {
--	      fmem->array = fld;
--	      fmem->enclosing = pstr;
--	    }
-+	    fmem->array = fld;
- 	}
-     }
- }
- 
--/* Diagnose a strictly (by the C standard) invalid use of a struct with
--   a flexible array member (or the zero-length array extension).  */
--
--static void
--diagnose_invalid_flexarray (const flexmems_t *fmem)
--{
--  if (fmem->array && fmem->enclosing
--      && pedwarn (location_of (fmem->enclosing), OPT_Wpedantic,
--		  TYPE_DOMAIN (TREE_TYPE (fmem->array))
--		  ? G_("invalid use of %q#T with a zero-size array "
--		       "in %q#D")
--		  : G_("invalid use of %q#T with a flexible array member "
--		       "in %q#T"),
--		  DECL_CONTEXT (fmem->array),
--		  DECL_CONTEXT (fmem->enclosing)))
--    inform (DECL_SOURCE_LOCATION (fmem->array),
--	    "array member %q#D declared here", fmem->array);
--}
--
- /* Issue diagnostics for invalid flexible array members or zero-length
-    arrays that are not the last elements of the containing class or its
-    base classes or that are its sole members.  */
-@@ -6916,70 +6794,49 @@ diagnose_invalid_flexarray (const flexme
- static void
- diagnose_flexarrays (tree t, const flexmems_t *fmem)
- {
--  if (!fmem->array)
-+  /* Members of anonymous structs and unions are considered to be members
-+     of the containing struct or union.  */
-+  if (TYPE_ANONYMOUS_P (t) || !fmem->array)
-     return;
- 
--  if (fmem->first && !fmem->after[0])
--    {
--      diagnose_invalid_flexarray (fmem);
--      return;
--    }
--
--  /* Has a diagnostic been issued?  */
--  bool diagd = false;
--
-   const char *msg = 0;
- 
-   if (TYPE_DOMAIN (TREE_TYPE (fmem->array)))
-     {
--      if (fmem->after[0])
-+      if (fmem->after)
- 	msg = G_("zero-size array member %qD not at end of %q#T");
-       else if (!fmem->first)
- 	msg = G_("zero-size array member %qD in an otherwise empty %q#T");
- 
--      if (msg)
--	{
--	  location_t loc = DECL_SOURCE_LOCATION (fmem->array);
-+      if (msg && pedwarn (DECL_SOURCE_LOCATION (fmem->array),
-+			  OPT_Wpedantic, msg, fmem->array, t))
- 
--	  if (pedwarn (loc, OPT_Wpedantic, msg, fmem->array, t))
--	    {
--	      inform (location_of (t), "in the definition of %q#T", t);
--	      diagd = true;
--	    }
--	}
-+	inform (location_of (t), "in the definition of %q#T", t);
-     }
-   else
-     {
--      if (fmem->after[0])
-+      if (fmem->after)
- 	msg = G_("flexible array member %qD not at end of %q#T");
-       else if (!fmem->first)
- 	msg = G_("flexible array member %qD in an otherwise empty %q#T");
- 
-       if (msg)
- 	{
--	  location_t loc = DECL_SOURCE_LOCATION (fmem->array);
--	  diagd = true;
--
--	  error_at (loc, msg, fmem->array, t);
-+	  error_at (DECL_SOURCE_LOCATION (fmem->array), msg,
-+		    fmem->array, t);
- 
- 	  /* In the unlikely event that the member following the flexible
--	     array member is declared in a different class, or the member
--	     overlaps another member of a common union, point to it.
-+	     array member is declared in a different class, point to it.
- 	     Otherwise it should be obvious.  */
--	  if (fmem->after[0]
--	      && ((DECL_CONTEXT (fmem->after[0])
--		   != DECL_CONTEXT (fmem->array))))
--	    {
--	      inform (DECL_SOURCE_LOCATION (fmem->after[0]),
-+	  if (fmem->after
-+	      && (DECL_CONTEXT (fmem->after) != DECL_CONTEXT (fmem->array)))
-+	      inform (DECL_SOURCE_LOCATION (fmem->after),
- 		      "next member %q#D declared here",
--		      fmem->after[0]);
--	      inform (location_of (t), "in the definition of %q#T", t);
--	    }
-+		      fmem->after);
-+
-+	  inform (location_of (t), "in the definition of %q#T", t);
- 	}
-     }
--
--  if (!diagd && fmem->array && fmem->enclosing)
--    diagnose_invalid_flexarray (fmem);
- }
- 
- 
-@@ -6992,8 +6849,7 @@ diagnose_flexarrays (tree t, const flexm
-    that fails the checks.  */
- 
- static void
--check_flexarrays (tree t, flexmems_t *fmem /* = NULL */,
--		  bool base_p /* = false */)
-+check_flexarrays (tree t, flexmems_t *fmem /* = NULL */)
- {
-   /* Initialize the result of a search for flexible array and zero-length
-      array members.  Avoid doing any work if the most interesting FMEM data
-@@ -7001,20 +6857,18 @@ check_flexarrays (tree t, flexmems_t *fm
-   flexmems_t flexmems = flexmems_t ();
-   if (!fmem)
-     fmem = &flexmems;
--  else if (fmem->array && fmem->first && fmem->after[0])
-+  else if (fmem->array && fmem->first && fmem->after)
-     return;
- 
--  tree fam = fmem->array;
--
-   /* Recursively check the primary base class first.  */
-   if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
-     {
-       tree basetype = BINFO_TYPE (CLASSTYPE_PRIMARY_BINFO (t));
--      check_flexarrays (basetype, fmem, true);
-+      check_flexarrays (basetype, fmem);
-     }
- 
-   /* Recursively check the base classes.  */
--  int nbases = TYPE_BINFO (t) ? BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) : 0;
-+  int nbases = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
-   for (int i = 0; i < nbases; ++i)
-     {
-       tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
-@@ -7028,7 +6882,7 @@ check_flexarrays (tree t, flexmems_t *fm
- 	continue;
- 
-       /* Check the base class.  */
--      check_flexarrays (BINFO_TYPE (base_binfo), fmem, /*base_p=*/true);
-+      check_flexarrays (BINFO_TYPE (base_binfo), fmem);
-     }
- 
-   if (fmem == &flexmems)
-@@ -7045,26 +6899,17 @@ check_flexarrays (tree t, flexmems_t *fm
- 	  /* Check the virtual base class.  */
- 	  tree basetype = TREE_TYPE (base_binfo);
- 
--	  check_flexarrays (basetype, fmem, /*base_p=*/true);
-+	  check_flexarrays (basetype, fmem);
- 	}
-     }
- 
--  /* Is the type unnamed (and therefore a member of it potentially
--     an anonymous struct or union)?  */
--  bool maybe_anon_p = TYPE_ANONYMOUS_P (t);
--
--  /* Search the members of the current (possibly derived) class, skipping
--     unnamed structs and unions since those could be anonymous.  */
--  if (fmem != &flexmems || !maybe_anon_p)
--    find_flexarrays (t, fmem, base_p || fam != fmem->array);
-+  /* Search the members of the current (derived) class.  */
-+  find_flexarrays (t, fmem);
- 
--  if (fmem == &flexmems && !maybe_anon_p)
-+  if (fmem == &flexmems)
-     {
--      /* Issue diagnostics for invalid flexible and zero-length array
--	 members found in base classes or among the members of the current
--	 class.  Ignore anonymous structs and unions whose members are
--	 considered to be members of the enclosing class and thus will
--	 be diagnosed when checking it.  */
-+      /* Issue diagnostics for invalid flexible and zero-length array members
-+	 found in base classes or among the members of the current class.  */
-       diagnose_flexarrays (t, fmem);
-     }
- }
-Index: b/src/gcc/cp/ChangeLog
-===================================================================
---- a/src/gcc/cp/ChangeLog
-+++ b/src/gcc/cp/ChangeLog
-@@ -1,13 +1,3 @@
--2016-10-14  Martin Sebor  <msebor at redhat.com>
--
--	PR c++/71912
--	* class.c (struct flexmems_t):  Add members.
--	(find_flexarrays): Add arguments.  Correct handling of anonymous
--	structs.
--	(diagnose_flexarrays): Adjust to issue warnings in addition to errors.
--	(check_flexarrays): Add argument.
--	(diagnose_invalid_flexarray): New functions.
--
- 2016-10-04  Martin Sebor  <msebor at redhat.com>
- 
- 	PR c++/77804
diff --git a/debian/patches/pr78039.diff b/debian/patches/pr78039.diff
new file mode 100644
index 0000000..603084e
--- /dev/null
+++ b/debian/patches/pr78039.diff
@@ -0,0 +1,605 @@
+# DP: Fix PR c++/78039 - fails to compile glibc tests (proposed patch)
+
+gcc/cp/
+
+2016-10-21  Martin Sebor  <msebor at redhat.com>
+
+	PR c++/78039
+	* class.c (diagnose_flexarrays): Avoid rejecting an invalid flexible
+	array member with a hard error when it is followed by anbother member
+	in a different struct, and instead issue just a pedantic warning.
+
+gcc/testsuite/
+
+2016-10-21  Martin Sebor  <msebor at redhat.com>
+
+	PR c++/78039
+	* g++.dg/ext/flexary18.C: New test.
+	* g++.dg/ext/flexary19.C: New test.
+
+--- a/src/gcc/cp/class.c
++++ b/src/gcc/cp/class.c
+@@ -6960,7 +6960,20 @@ diagnose_flexarrays (tree t, const flexmems_t *fme
+ 	  location_t loc = DECL_SOURCE_LOCATION (fmem->array);
+ 	  diagd = true;
+ 
+-	  error_at (loc, msg, fmem->array, t);
++	  /* For compatibility with GCC 6.2 and 6.1 reject with an error
++	     a flexible array member of a plain struct that's followed
++	     by another member only if they are both members of the same
++	     struct.  Otherwise, issue just a pedantic warning.  See bug
++	     71375 for details.  */
++	  if (fmem->after[0]
++	      && (!TYPE_BINFO (t)
++		  || 0 == BINFO_N_BASE_BINFOS (TYPE_BINFO (t)))
++	      && DECL_CONTEXT (fmem->array) != DECL_CONTEXT (fmem->after[0])
++	      && !ANON_AGGR_TYPE_P (DECL_CONTEXT (fmem->array))
++	      && !ANON_AGGR_TYPE_P (DECL_CONTEXT (fmem->after[0])))
++	    pedwarn (loc, OPT_Wpedantic, msg, fmem->array, t);
++	  else
++	    error_at (loc, msg, fmem->array, t);
+ 
+ 	  /* In the unlikely event that the member following the flexible
+ 	     array member is declared in a different class, or the member
+--- a/src/gcc/testsuite/g++.dg/ext/flexary18.C
++++ b/src/gcc/testsuite/g++.dg/ext/flexary18.C
+@@ -0,0 +1,213 @@
++// PR c++/71912 - [6/7 regression] flexible array in struct in union rejected
++// { dg-do compile }
++// { dg-additional-options "-Wpedantic -Wno-error=pedantic" }
++
++#if __cplusplus
++
++namespace pr71912 {
++
++#endif
++
++struct foo {
++  int a;
++  char s[];                             // { dg-message "array member .char pr71912::foo::s \\\[\\\]. declared here" }
++};
++
++struct bar {
++  double d;
++  char t[];
++};
++
++struct baz {
++  union {
++    struct foo f;
++    struct bar b;
++  }
++  // The definition of struct foo is fine but the use of struct foo
++  // in the definition of u below is what's invalid and must be clearly
++  // diagnosed.
++    u;                                  // { dg-warning "invalid use of .struct pr71912::foo. with a flexible array member in .struct pr71912::baz." }
++};
++
++struct xyyzy {
++  union {
++    struct {
++      int a;
++      char s[];                         // { dg-message "declared here" }
++    } f;
++    struct {
++      double d;
++      char t[];
++    } b;
++  } u;                                  // { dg-warning "invalid use" }
++};
++
++struct baz b;
++struct xyyzy x;
++
++#if __cplusplus
++
++}
++
++#endif
++
++// The following definitions aren't strictly valid but, like those above,
++// are accepted for compatibility with GCC (in C mode).  They are benign
++// in that the flexible array member is at the highest offset within
++// the outermost type and doesn't overlap with other members except for
++// those of the union.
++union UnionStruct1 {
++  struct { int n1, a[]; } s;
++  int n2;
++};
++
++union UnionStruct2 {
++  struct { int n1, a1[]; } s1;
++  struct { int n2, a2[]; } s2;
++  int n3;
++};
++
++union UnionStruct3 {
++  struct { int n1, a1[]; } s1;
++  struct { double n2, a2[]; } s2;
++  char n3;
++};
++
++union UnionStruct4 {
++  struct { int n1, a1[]; } s1;
++  struct { struct { int n2, a2[]; } s2; } s3;
++  char n3;
++};
++
++union UnionStruct5 {
++  struct { struct { int n1, a1[]; } s1; } s2;   // { dg-warning "invalid use" }
++  struct { double n2, a2[]; } s3;
++  char n3;
++};
++
++union UnionStruct6 {
++  struct { struct { int n1, a1[]; } s1; } s2;   // { dg-warning "invalid use" }
++  struct { struct { int n2, a2[]; } s3; } s4;
++  char n3;
++};
++
++union UnionStruct7 {
++  struct { int n1, a1[]; } s1;
++  struct { double n2, a2[]; } s2;
++  struct { struct { int n3, a3[]; } s3; } s4;
++};
++
++union UnionStruct8 {
++  struct { int n1, a1[]; } s1;
++  struct { struct { int n2, a2[]; } s2; } s3;
++  struct { struct { int n3, a3[]; } s4; } s5;
++};
++
++union UnionStruct9 {
++  struct { struct { int n1, a1[]; } s1; } s2;   // { dg-warning "invalid use" }
++  struct { struct { int n2, a2[]; } s3; } s4;
++  struct { struct { int n3, a3[]; } s5; } s6;
++};
++
++struct StructUnion1 {
++  union {
++    struct { int n1, a1[]; } s1;        // { dg-message "declared here" }
++    struct { double n2, a2[]; } s2;
++    char n3;
++  } u;                                  // { dg-warning "invalid use" }
++};
++
++// The following are invalid and rejected.
++struct StructUnion2 {
++  union {
++    struct { int n1, a1[]; } s1;        // { dg-warning "not at end" }
++  } u;
++  char n3;                              // { dg-message "next member" }
++};
++
++struct StructUnion3 {
++  union {
++    struct { int n1, a1[]; } s1;        // { dg-warning "not at end" }
++    struct { double n2, a2[]; } s2;
++  } u;
++  char n3;                              // { dg-message "next member" }
++};
++
++struct StructUnion4 {
++  union {
++    struct { int n1, a1[]; } s1;        // { dg-warning "not at end" }
++  } u1;
++  union {
++    struct { double n2, a2[]; } s2;
++  } u2;                                 // { dg-message "next member" }
++};
++
++struct StructUnion5 {
++  union {
++    union {
++      struct { int n1, a1[]; } s1;      // { dg-message "declared here" }
++    } u1;
++    union { struct { int n2, a2[]; } s2; } u2;
++  } u;                                  // { dg-warning "invalid use" }
++};
++
++struct StructUnion6 {
++  union {
++    struct { int n1, a1[]; } s1;        // { dg-message "declared here" }
++    union { struct { int n2, a2[]; } s2; } u2;
++  } u;                                  // { dg-warning "invalid use" }
++};
++
++struct StructUnion7 {
++  union {
++    union {
++      struct { double n2, a2[]; } s2;   // { dg-message "declared here" }
++    } u2;
++    struct { int n1, a1[]; } s1;
++  } u;                                  // { dg-warning "invalid use" }
++};
++
++struct StructUnion8 {
++  struct {
++    union {
++      union {
++	struct { int n1, a1[]; } s1;    // { dg-warning "not at end" }
++      } u1;
++      union {
++	struct { double n2, a2[]; } s2;
++      } u2;
++    } u;
++  } s1;
++
++  struct {
++    union {
++      union {
++	struct { int n1, a1[]; } s1;
++      } u1;
++      union {
++	struct { double n2, a2[]; } s2;
++      } u2;
++    } u; } s2;                              // { dg-message "next member" }
++};
++
++struct StructUnion9 {                       // { dg-message "in the definition" }
++  struct A1 {
++    union B1 {
++      union C1 {
++	struct Sx1 { int n1, a1[]; } sx1;   // { dg-warning "not at end" }
++      } c1;
++      union D1 {
++	struct Sx2 { double n2, a2[]; } sx2;
++      } d1;
++    } b1;                                   // { dg-warning "invalid use" }
++  } a1;
++
++  struct A2 {
++    union B2 {
++      union C2 {
++	struct Sx3 { int n3, a3[]; } sx3;   // { dg-message "declared here" }
++      } c2;
++      union D2 { struct Sx4 { double n4, a4[]; } sx4; } d2;
++    } b2;                                   // { dg-warning "invalid use" }
++  } a2;                                     // { dg-message "next member" }
++};
+--- a/src/gcc/testsuite/g++.dg/ext/flexary19.C
++++ b/src/gcc/testsuite/g++.dg/ext/flexary19.C
+@@ -0,0 +1,343 @@
++// { dg-do compile }
++// { dg-additional-options "-Wpedantic -Wno-error=pedantic" }
++
++// Verify that flexible array members are recognized as either valid
++// or invalid in anonymous structs (a G++ extension) and C++ anonymous
++// unions as well as in structs and unions that look anonymous but
++// aren't.
++struct S1
++{
++  int i;
++
++  // The following declares a named data member of an unnamed struct
++  // (i.e., it is not an anonymous struct).
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s;
++};
++
++struct S2
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s[1];
++};
++
++struct S3
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s[];
++};
++
++struct S4
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s[2];
++};
++
++struct S5
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s[1][2];
++};
++
++struct S6
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s[][2];
++};
++
++struct S7
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } *s;
++};
++
++struct S8
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } **s;
++};
++
++struct S9
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } *s[1];
++};
++
++struct S10
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } *s[];
++};
++
++struct S11
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } **s[1];
++};
++
++struct S12
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } **s[];
++};
++
++struct S13
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } **s[2];
++};
++
++struct S14
++{
++  int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } &s;
++};
++
++struct S15
++{
++  int i;
++
++  typedef struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } T15;
++};
++
++struct S16
++{
++  int i;
++
++  struct {          // { dg-warning "invalid use" }
++    // A flexible array as a sole member of an anonymous struct is
++    // rejected with an error in C mode but emits just a pedantic
++    // warning in C++.  Other than excessive pedantry there is no
++    // reason to reject it.
++    int a[];
++  };                // { dg-warning "anonymous struct" }
++};
++
++struct S17
++{
++  int i;
++
++  union {           // anonymous union
++    int a[];        // { dg-error "flexible array member in union" }
++  };
++};
++
++struct S18
++{
++  int i;
++
++  struct {
++    int j, a[];     // { dg-message "declared here" }
++  } s;              // { dg-warning "invalid use" }
++};
++
++struct S19
++{
++  int i;
++
++  struct {          // { dg-warning "invalid use" }
++    int j, a[];     // { dg-message "declared here" }
++  };                // { dg-warning "anonymous struct" }
++};
++
++struct S20
++{
++  static int i;
++  typedef int A[];
++
++  struct {
++    int j;
++    A a;            // { dg-message "declared here" }
++  } s;              // { dg-warning "invalid use" }
++};
++
++struct S21
++{
++  static int i;
++  typedef int A[];
++
++  struct {          // { dg-warning "invalid use" }
++    int j;
++    A a;            // { dg-message "declared here" }
++  };                // { dg-warning "anonymous struct" }
++};
++
++struct S22
++{
++  struct S22S {
++    static int i;
++
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s;
++};
++
++struct S23
++{
++  struct {
++    static int i;   // { dg-error "static data member" }
++
++    int a[];        // { dg-error "in an otherwise empty" }
++  };                // { dg-warning "anonymous struct" }
++};
++
++struct S24
++{
++  static int i;
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s;
++};
++
++struct S25
++{
++  int i;
++
++  struct {
++    int j, a[];     // { dg-message "declared here" }
++  } s;              // { dg-warning "invalid use" }
++
++  // Verify that a static data member of the enclosing class doesn't
++  // cause infinite recursion or some such badness.
++  static S25 s2;
++};
++
++struct S26
++{
++  template <class>
++  struct S26S {
++    static int a;
++  };
++
++  struct {
++    int a[];        // { dg-error "in an otherwise empty" }
++  } s;
++};
++
++struct S27
++{
++  S27 *p;
++  int a[];
++};
++
++struct S28
++{
++  struct A {
++    struct B {
++      S28 *ps28;
++      A   *pa;
++      B   *pb;
++    } b, *pb;
++    A *pa;
++  } a, *pa;
++
++  S28::A *pa2;
++  S28::A::B *pb;
++
++  int flexarray[];
++};
++
++// Verify that the notes printed along with the warnings point to the types
++// or members they should point to and mention the correct relationships
++// with the flexible array members.
++namespace Notes
++{
++union A
++{
++  struct {
++    struct {
++      int i, a[];   // { dg-message "declared here" }
++    } c;            // { dg-warning "invalid use" }
++  } d;
++  int j;
++};
++
++union B
++{
++  struct {
++    struct {        // { dg-warning "invalid use" }
++      int i, a[];   // { dg-message "declared here" }
++    };              // { dg-warning "anonymous struct" }
++  };                // { dg-warning "anonymous struct" }
++  int j;
++};
++
++}
++
++typedef struct Opaque* P29;
++struct S30 { P29 p; };
++struct S31 { S30 s; };
++
++typedef struct { } S32;
++typedef struct { S32 *ps32; } S33;
++typedef struct
++{
++  S33 *ps33;
++} S34;
++
++struct S35
++{
++  struct A {
++    int i1, a1[];
++  };
++
++  struct B {
++    int i2, a2[];
++  };
++
++  typedef struct {
++    int i3, a3[];
++  } C;
++
++  typedef struct {
++    int i4, a4[];
++  } D;
++
++  typedef A A2;
++  typedef B B2;
++  typedef C C2;
++  typedef D D2;
++};
++
diff --git a/debian/rules.patch b/debian/rules.patch
index f263001..df1d1b0 100644
--- a/debian/rules.patch
+++ b/debian/rules.patch
@@ -99,7 +99,7 @@ debian_patches += \
 	libgo-rawClone-no_split_stack \
 	libgo-rawClone-no-pt_regs \
 	libgo-elf-relocations-sparc64 \
-	pr71912-revert \
+	pr78039 \
 
 
 # this is still needed on powerpc, e.g. firefox and insighttoolkit4 will ftbfs.

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/reproducible/gcc-6.git



More information about the Reproducible-commits mailing list