[gentoo-commits] proj/gcc-patches:master commit in: 15.0.0/gentoo/

["Sam James" <sam@gentoo.org>]

commit:     c52e67271ce71be301691e491fd45d01b779e8fb
Author:     Sam James <sam <AT> gentoo <DOT> org>
AuthorDate: Mon Dec  9 03:04:45 2024 +0000
Commit:     Sam James <sam <AT> gentoo <DOT> org>
CommitDate: Mon Dec  9 03:04:45 2024 +0000
URL:        https://gitweb.gentoo.org/proj/gcc-patches.git/commit/?id=c52e6727

15.0.0: add patches for C FAM ICEs w/ C23

Signed-off-by: Sam James <sam <AT> gentoo.org>

 ...mpatibility-for-types-with-flexible-array.patch | 330 +++++++++++++++++++++
 ...724-testsuite-fix-LTO-flags-in-pr112716.c.patch |  27 ++
 15.0.0/gentoo/README.history                       |   5 +
 3 files changed, 362 insertions(+)

diff --git a/15.0.0/gentoo/74_all_PR117724-Fix-type-compatibility-for-types-with-flexible-array.patch b/15.0.0/gentoo/74_all_PR117724-Fix-type-compatibility-for-types-with-flexible-array.patch
new file mode 100644
index 0000000..3c20493
--- /dev/null
+++ b/15.0.0/gentoo/74_all_PR117724-Fix-type-compatibility-for-types-with-flexible-array.patch
@@ -0,0 +1,330 @@
+From e1d3dfa0936ca5b50c87f6ddf5347fa401a703f6 Mon Sep 17 00:00:00 2001
+Message-ID: <e1d3dfa0936ca5b50c87f6ddf5347fa401a703f6.1733713329.git.sam@gentoo.org>
+From: Martin Uecker <uecker@tugraz.at>
+Date: Mon, 9 Dec 2024 00:11:58 +0100
+Subject: [PATCH 1/2] Fix type compatibility for types with flexible array
+ member [PR113688,PR114014,PR117724]
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Hi Richard,
+
+this is another version.  It now adds an "ignore_size" flag
+to gimple_canonical_types_compatible_p and uses this instead
+of having the complicated special case for arrays at the
+end.  Also zero-sized members are now ignored again, except
+if they are arrays at the end where then only the size is
+ignored.  This can still be stricter than before for the 
+case where there are zero-sized arrays at the end (e.g.
+before element type could differ).
+
+Martin
+
+Bootstrapped and regression tested on x86_64.
+
+Fix type compatibility for types with flexible array member [PR113688,PR114014,PR117724]
+
+    verify_type checks the compatibility of TYPE_CANONICAL using
+    gimple_canonical_types_compatible_p.   But it is stricter than what the
+    C standard requires and therefor inconsistent with how TYPE_CANONICAL is set
+    in the C FE.  Here, the logic is changed to ignore the array size when it
+    is the last element of a structure or union.  To not get errors because of
+    an inconsistent number of members, zero-sized arrays which are the last
+    element are not ignored anymore when checking the fields of a struct (which
+    in this particular case is stricter than what was done before).  Finally,
+    exceptions are added that allow the TYPE_MODE of a type with an array as
+    last member and of such arrays to differ from another compatible type.
+
+            PR c/112716
+            PR c/113688
+            PR c/114014
+            PR c/117724
+
+    gcc/ChangeLog:
+            * tree.cc (gimple_canonical_types_compatible_p): Add
+              `ignore_size' parameter and revise logic.
+            (verify_type): Add exceptions.
+
+    gcc/lto/ChangeLog:
+            * lto-common.cc (hash_canonical_type): Add exceptions.
+
+    gcc/testsuite/ChangeLog:
+            * gcc.dg/pr112716.c: New test.
+            * gcc.dg/pr113688.c: New test.
+            * gcc.dg/pr114014.c: New test.
+            * gcc.dg/pr117724.c: New test.
+---
+ gcc/lto/lto-common.cc           |  9 ++++--
+ gcc/testsuite/gcc.dg/pr112716.c | 40 +++++++++++++++++++++++++
+ gcc/testsuite/gcc.dg/pr113688.c |  8 +++++
+ gcc/testsuite/gcc.dg/pr114014.c | 14 +++++++++
+ gcc/testsuite/gcc.dg/pr117724.c | 16 ++++++++++
+ gcc/tree.cc                     | 53 +++++++++++++++++++++++++--------
+ gcc/tree.h                      |  3 +-
+ 7 files changed, 127 insertions(+), 16 deletions(-)
+ create mode 100644 gcc/testsuite/gcc.dg/pr112716.c
+ create mode 100644 gcc/testsuite/gcc.dg/pr113688.c
+ create mode 100644 gcc/testsuite/gcc.dg/pr114014.c
+ create mode 100644 gcc/testsuite/gcc.dg/pr117724.c
+
+diff --git a/gcc/lto/lto-common.cc b/gcc/lto/lto-common.cc
+index 86a309f92b40..f65a9d1c7b6f 100644
+--- a/gcc/lto/lto-common.cc
++++ b/gcc/lto/lto-common.cc
+@@ -254,7 +254,8 @@ hash_canonical_type (tree type)
+      checked.  */
+   code = tree_code_for_canonical_type_merging (TREE_CODE (type));
+   hstate.add_int (code);
+-  hstate.add_int (TYPE_MODE (type));
++  if (!RECORD_OR_UNION_TYPE_P (type))
++    hstate.add_int (TYPE_MODE (type));
+ 
+   /* Incorporate common features of numerical types.  */
+   if (INTEGRAL_TYPE_P (type)
+@@ -332,7 +333,11 @@ hash_canonical_type (tree type)
+ 	    && (! DECL_SIZE (f)
+ 		|| ! integer_zerop (DECL_SIZE (f))))
+ 	  {
+-	    iterative_hash_canonical_type (TREE_TYPE (f), hstate);
++	    tree t = TREE_TYPE (f);
++	    if (!TREE_CHAIN (f)
++		&& TREE_CODE (t) == ARRAY_TYPE)
++	      t = TREE_TYPE  (t);
++	    iterative_hash_canonical_type (t, hstate);
+ 	    nf++;
+ 	  }
+ 
+diff --git a/gcc/testsuite/gcc.dg/pr112716.c b/gcc/testsuite/gcc.dg/pr112716.c
+new file mode 100644
+index 000000000000..109dd252f0d6
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/pr112716.c
+@@ -0,0 +1,40 @@
++/* { dg-do compile } */
++/* { dg-options "-lfto -O2" } */
++
++#define T1 int[n]
++#define T2 int[n]
++
++// TU 1
++void bar(void*);
++
++[[gnu::noinline,gnu::noipa]]
++int foo(void *p, void *q)
++{
++	int n = 5;
++	struct foo { int x; typeof(T1) y; } *p2 = p;
++	p2->x = 1;
++	bar(q);
++	return p2->x;
++}
++
++int main()
++{
++	int n = 5;
++	void *p = __builtin_malloc(sizeof(struct foo { int x; typeof(T1) y; }));
++
++	if (!p)
++		return 0;
++
++	if (2 != foo(p, p))
++		__builtin_abort();
++
++	return 0;
++}
++// TU 2
++void bar(void* q)
++{
++	int n = 5;
++	struct foo { int x; typeof(T2) y; } *q2 = q;
++	q2->x = 2;
++}
++
+diff --git a/gcc/testsuite/gcc.dg/pr113688.c b/gcc/testsuite/gcc.dg/pr113688.c
+new file mode 100644
+index 000000000000..8dee8c86f1bf
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/pr113688.c
+@@ -0,0 +1,8 @@
++/* { dg-do compile } */
++/* { dg-options "-g" } */
++
++struct S{int x,y[1];}*a;
++int main(void){
++	struct S{int x,y[];};
++}
++
+diff --git a/gcc/testsuite/gcc.dg/pr114014.c b/gcc/testsuite/gcc.dg/pr114014.c
+new file mode 100644
+index 000000000000..1531ffab1b75
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/pr114014.c
+@@ -0,0 +1,14 @@
++/* PR c/114014
++ * { dg-do compile }
++ * { dg-options "-std=gnu23 -g" } */
++
++struct r {
++  int a;
++  char b[];
++};
++struct r {
++  int a;
++  char b[0];
++};
++
++
+diff --git a/gcc/testsuite/gcc.dg/pr117724.c b/gcc/testsuite/gcc.dg/pr117724.c
+new file mode 100644
+index 000000000000..d631daeb644d
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/pr117724.c
+@@ -0,0 +1,16 @@
++/* { dg-do compile } */
++/* { dg-options "-g" } */
++
++struct {
++  unsigned long len;
++  unsigned long size;
++  char data[];
++};			/* { dg-warning "unnamed struct" } */
++struct {
++  struct {
++    unsigned long len;
++    unsigned long size;
++    char data[6];
++  };
++};			/* { dg-warning "unnamed struct" } */
++
+diff --git a/gcc/tree.cc b/gcc/tree.cc
+index 83a03374a325..da4b7f5daa8c 100644
+--- a/gcc/tree.cc
++++ b/gcc/tree.cc
+@@ -13837,11 +13837,13 @@ type_with_interoperable_signedness (const_tree type)
+    verifier.  If TRUST_TYPE_CANONICAL we do not look into structure of types
+    that have TYPE_CANONICAL defined and assume them equivalent.  This is useful
+    only for LTO because only in these cases TYPE_CANONICAL equivalence
+-   correspond to one defined by gimple_canonical_types_compatible_p.  */
+-
++   correspond to one defined by gimple_canonical_types_compatible_p.
++   If IGNORE_SIZE, we allow a mismatch of the mode and the number of
++   elements for arrays.  */
+ bool
+ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
+-				     bool trust_type_canonical)
++				     bool trust_type_canonical,
++				     bool ignore_size)
+ {
+   /* Type variants should be same as the main variant.  When not doing sanity
+      checking to verify this fact, go to main variants and save some work.  */
+@@ -13914,8 +13916,12 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
+       || TREE_CODE (t1) == NULLPTR_TYPE)
+     return true;
+ 
+-  /* Can't be the same type if they have different mode.  */
+-  if (TYPE_MODE (t1) != TYPE_MODE (t2))
++  /* Can't be compatible types if they have different mode.  Because of
++     flexible array members, we allow mismatching modes for structures or
++     unions and for arrays when we ignore the size.  */
++  if (!RECORD_OR_UNION_TYPE_P (t1)
++      && (!ignore_size || TREE_CODE (t1) != ARRAY_TYPE)
++      && (TYPE_MODE (t1) != TYPE_MODE (t2)))
+     return false;
+ 
+   /* Non-aggregate types can be handled cheaply.  */
+@@ -13966,15 +13972,19 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
+     {
+     case ARRAY_TYPE:
+       /* Array types are the same if the element types are the same and
+-	 the number of elements are the same.  */
++	 minimum and maximum index are the same.  */
+       if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
+-						trust_type_canonical)
++						trust_type_canonical,
++						ignore_size)
+ 	  || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
+ 	  || TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2)
+ 	  || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
+ 	return false;
+       else
+ 	{
++	  if (ignore_size)
++	    return true;
++
+ 	  tree i1 = TYPE_DOMAIN (t1);
+ 	  tree i2 = TYPE_DOMAIN (t2);
+ 
+@@ -14060,23 +14070,36 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
+ 	     f1 || f2;
+ 	     f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
+ 	  {
+-	    /* Skip non-fields and zero-sized fields.  */
++	    /* Skip non-fields and zero-sized fields, except zero-sized
++	       arrays at the end.  */
+ 	    while (f1 && (TREE_CODE (f1) != FIELD_DECL
+ 			  || (DECL_SIZE (f1)
+-			      && integer_zerop (DECL_SIZE (f1)))))
++			      && integer_zerop (DECL_SIZE (f1))
++			      && (TREE_CHAIN (f1)
++				  || TREE_CODE (TREE_TYPE (f1))
++				     != ARRAY_TYPE))))
+ 	      f1 = TREE_CHAIN (f1);
+ 	    while (f2 && (TREE_CODE (f2) != FIELD_DECL
+ 			  || (DECL_SIZE (f2)
+-			      && integer_zerop (DECL_SIZE (f2)))))
++			      && integer_zerop (DECL_SIZE (f2))
++			      && (TREE_CHAIN (f2)
++				  || TREE_CODE (TREE_TYPE (f2))
++				     != ARRAY_TYPE))))
+ 	      f2 = TREE_CHAIN (f2);
+ 	    if (!f1 || !f2)
+ 	      break;
+-	    /* The fields must have the same name, offset and type.  */
++
++	    tree t1 = TREE_TYPE (f1);
++	    tree t2 = TREE_TYPE (f2);
++
++	    /* If the last element is an array, we allow a mismatch in size. */
++	    bool ignore_size = (TREE_CHAIN (f1) == NULL_TREE
++				&& TREE_CODE (t1) == ARRAY_TYPE);
++
+ 	    if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
+ 		|| !gimple_compare_field_offset (f1, f2)
+ 		|| !gimple_canonical_types_compatible_p
+-		      (TREE_TYPE (f1), TREE_TYPE (f2),
+-		       trust_type_canonical))
++		      (t1, t2, trust_type_canonical, ignore_size))
+ 	      return false;
+ 	  }
+ 
+@@ -14220,6 +14243,10 @@ verify_type (const_tree t)
+     }
+ 
+   if (COMPLETE_TYPE_P (t) && TYPE_CANONICAL (t)
++      /* We allow a mismatch for structure or union because of
++	 flexible array members.  */
++      && !RECORD_OR_UNION_TYPE_P (t)
++      && !RECORD_OR_UNION_TYPE_P (TYPE_CANONICAL (t))
+       && TYPE_MODE (t) != TYPE_MODE (TYPE_CANONICAL (t)))
+     {
+       error ("%<TYPE_MODE%> of %<TYPE_CANONICAL%> is not compatible");
+diff --git a/gcc/tree.h b/gcc/tree.h
+index 75054839d9b6..6608754a3e20 100644
+--- a/gcc/tree.h
++++ b/gcc/tree.h
+@@ -5844,7 +5844,8 @@ extern unsigned int tree_map_base_hash (const void *);
+ extern bool 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);
++						 bool trust_type_canonical = true,
++						 bool ignore_size = false);
+ extern bool type_with_interoperable_signedness (const_tree);
+ extern bitmap get_nonnull_args (const_tree);
+ extern int get_range_pos_neg (tree);
+
+base-commit: 6205144d6b566f32a58c4fa4f5e7e2343ad07c62
+-- 
+2.47.1
+

diff --git a/15.0.0/gentoo/75_all_PR117724-testsuite-fix-LTO-flags-in-pr112716.c.patch b/15.0.0/gentoo/75_all_PR117724-testsuite-fix-LTO-flags-in-pr112716.c.patch
new file mode 100644
index 0000000..f36840e
--- /dev/null
+++ b/15.0.0/gentoo/75_all_PR117724-testsuite-fix-LTO-flags-in-pr112716.c.patch
@@ -0,0 +1,27 @@
+From 2f961c392ab359286ef1350d37e50e7841773d7b Mon Sep 17 00:00:00 2001
+Message-ID: <2f961c392ab359286ef1350d37e50e7841773d7b.1733713329.git.sam@gentoo.org>
+In-Reply-To: <e1d3dfa0936ca5b50c87f6ddf5347fa401a703f6.1733713329.git.sam@gentoo.org>
+References: <e1d3dfa0936ca5b50c87f6ddf5347fa401a703f6.1733713329.git.sam@gentoo.org>
+From: Sam James <sam@gentoo.org>
+Date: Mon, 9 Dec 2024 03:01:47 +0000
+Subject: [PATCH 2/2] testsuite: fix LTO flags in pr112716.c
+
+---
+ gcc/testsuite/gcc.dg/pr112716.c | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+diff --git a/gcc/testsuite/gcc.dg/pr112716.c b/gcc/testsuite/gcc.dg/pr112716.c
+index 109dd252f0d6..873eedaafd18 100644
+--- a/gcc/testsuite/gcc.dg/pr112716.c
++++ b/gcc/testsuite/gcc.dg/pr112716.c
+@@ -1,5 +1,6 @@
+ /* { dg-do compile } */
+-/* { dg-options "-lfto -O2" } */
++/* { dg-options "-flto -O2" } */
++/* { dg-require-effective-target lto } */
+ 
+ #define T1 int[n]
+ #define T2 int[n]
+-- 
+2.47.1
+

diff --git a/15.0.0/gentoo/README.history b/15.0.0/gentoo/README.history
index b42dfc7..048d96a 100644
--- a/15.0.0/gentoo/README.history
+++ b/15.0.0/gentoo/README.history
@@ -1,3 +1,8 @@
+31	???
+
+	+ 74_all_PR117724-Fix-type-compatibility-for-types-with-flexible-array.patch
+	+ 75_all_PR117724-testsuite-fix-LTO-flags-in-pr112716.c.patch
+
 30	8 December 2024
 
 	+ 73_all_PR117629-c-special-case-some-bool-errors-with-C23.patch