From mboxrd@z Thu Jan 1 00:00:00 1970
Return-Path: <gentoo-commits+bounces-1698382-garchives=archives.gentoo.org@lists.gentoo.org>
Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80])
(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)
key-exchange X25519 server-signature RSA-PSS (4096 bits))
(No client certificate requested)
by finch.gentoo.org (Postfix) with ESMTPS id 5A4D2158232
for <garchives@archives.gentoo.org>; Mon, 9 Dec 2024 03:05:05 +0000 (UTC)
Received: from pigeon.gentoo.org (localhost [127.0.0.1])
by pigeon.gentoo.org (Postfix) with SMTP id 89B5BE0D21;
Mon, 9 Dec 2024 03:05:04 +0000 (UTC)
Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183])
(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)
key-exchange X25519 server-signature RSA-PSS (4096 bits))
(No client certificate requested)
by pigeon.gentoo.org (Postfix) with ESMTPS id 318E7E0D21
for <gentoo-commits@lists.gentoo.org>; Mon, 9 Dec 2024 03:05:03 +0000 (UTC)
Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52])
(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)
key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256)
(No client certificate requested)
by smtp.gentoo.org (Postfix) with ESMTPS id 2F3BF33BDFF
for <gentoo-commits@lists.gentoo.org>; Mon, 9 Dec 2024 03:05:02 +0000 (UTC)
Received: from localhost.localdomain (localhost [IPv6:::1])
by oystercatcher.gentoo.org (Postfix) with ESMTP id 4F37511DF
for <gentoo-commits@lists.gentoo.org>; Mon, 9 Dec 2024 03:05:00 +0000 (UTC)
From: "Sam James" <sam@gentoo.org>
To: gentoo-commits@lists.gentoo.org
Content-Transfer-Encoding: 8bit
Content-type: text/plain; charset=UTF-8
Reply-To: gentoo-dev@lists.gentoo.org, "Sam James" <sam@gentoo.org>
Message-ID: <1733713485.c52e67271ce71be301691e491fd45d01b779e8fb.sam@gentoo>
Subject: [gentoo-commits] proj/gcc-patches:master commit in: 15.0.0/gentoo/
X-VCS-Repository: proj/gcc-patches
X-VCS-Files: 15.0.0/gentoo/74_all_PR117724-Fix-type-compatibility-for-types-with-flexible-array.patch 15.0.0/gentoo/75_all_PR117724-testsuite-fix-LTO-flags-in-pr112716.c.patch 15.0.0/gentoo/README.history
X-VCS-Directories: 15.0.0/gentoo/
X-VCS-Committer: sam
X-VCS-Committer-Name: Sam James
X-VCS-Revision: c52e67271ce71be301691e491fd45d01b779e8fb
X-VCS-Branch: master
Date: Mon, 9 Dec 2024 03:05:00 +0000 (UTC)
Precedence: bulk
List-Post: <mailto:gentoo-commits@lists.gentoo.org>
List-Help: <mailto:gentoo-commits+help@lists.gentoo.org>
List-Unsubscribe: <mailto:gentoo-commits+unsubscribe@lists.gentoo.org>
List-Subscribe: <mailto:gentoo-commits+subscribe@lists.gentoo.org>
List-Id: Gentoo Linux mail <gentoo-commits.gentoo.org>
X-BeenThere: gentoo-commits@lists.gentoo.org
X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply
X-Archives-Salt: c7e024ef-47fa-4579-bad4-cecee26fc1ce
X-Archives-Hash: 974bcf5cf330885ea1dfc0709cc3a0f0
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