stor-layout: Reject forming arrays with elt sizes not divisible by elt alignment...

As mentioned in the PR, since 2005 we reject if array elements are smaller
than their alignment (i.e. overaligned elements), because such arrays don't
make much sense, only their first element is guaranteed to be aligned as
user requested, but the next element can't be.
The following testcases show something we've been silent about but is
equally bad, the 2005 case is just the most common special case of that
the array element size is not divisible by the alignment.  In those arrays
too only the first element is guaranteed to be properly aligned and the
second one can't be.

This patch rejects those cases too, but keeps the existing wording for the
old common case.

Unfortunately, the patch breaks bootstrap, because libbid uses this mess
(forms arrays with 24 byte long elements with 16 byte element alignment).
I don't really see justification for that, so I've decreased the alignment
to 8 bytes instead.

2020-10-23  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/97164
gcc/
	* stor-layout.c (layout_type): Also reject arrays where element size
	is constant, but not a multiple of element alignment.
gcc/testsuite/
	* c-c++-common/pr97164.c: New test.
	* gcc.c-torture/execute/pr36093.c: Move ...
	* gcc.dg/pr36093.c: ... here.  Add dg-do compile and dg-error
	directives.
	* gcc.c-torture/execute/pr43783.c: Move ...
	* gcc.dg/pr43783.c: ... here.  Add dg-do compile, dg-options and
	dg-error directives.
libgcc/config/libbid/
	* bid_functions.h (UINT192): Decrease alignment to 8 bytes.

diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index bde6fa22b58ac6dd17643f2f5ed67e26724826ae..dff81d1c24f51435d717a42234dddfebbeed1d07 100644 (file)
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -2579,10 +2579,19 @@ layout_type (tree type)
            /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
               TYPE_ALIGN_UNIT.  */
            && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element))
-           && !integer_zerop (TYPE_SIZE_UNIT (element))
-           && compare_tree_int (TYPE_SIZE_UNIT (element),
-                                TYPE_ALIGN_UNIT (element)) < 0)
-         error ("alignment of array elements is greater than element size");
+           && !integer_zerop (TYPE_SIZE_UNIT (element)))
+         {
+           if (compare_tree_int (TYPE_SIZE_UNIT (element),
+                                 TYPE_ALIGN_UNIT (element)) < 0)
+             error ("alignment of array elements is greater than "
+                    "element size");
+           else if (TYPE_ALIGN_UNIT (element) > 1
+                    && (wi::zext (wi::to_wide (TYPE_SIZE_UNIT (element)),
+                                 ffs_hwi (TYPE_ALIGN_UNIT (element)) - 1)
+                        != 0))
+             error ("size of array element is not a multiple of its "
+                    "alignment");
+         }
        break;
       }
 

diff --git a/gcc/testsuite/c-c++-common/pr97164.c b/gcc/testsuite/c-c++-common/pr97164.c
new file mode 100644 (file)
index 0000000..8ffb928
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/pr97164.c
@@ -0,0 +1,15 @@
+/* PR tree-optimization/97164 */
+/* { dg-do compile } */
+
+typedef struct { int *a; char b[64]; } A __attribute__((aligned (64)));
+struct B { A d[4]; } b;        /* { dg-error "size of array element is not a multiple of its alignment" } */
+void foo (void);
+
+int *
+bar (void)
+{
+  struct B *h = &b;
+  if (h->d[1].a)
+    foo ();
+  return h->d[1].a;
+}

diff --git a/gcc/testsuite/gcc.c-torture/execute/pr36093.c b/gcc/testsuite/gcc.c-torture/execute/pr36093.c
deleted file mode 100644 (file)
index dac5720..0000000
--- a/gcc/testsuite/gcc.c-torture/execute/pr36093.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/* { dg-skip-if "small alignment" { pdp11-*-* } } */
-
-extern void abort (void);
-
-typedef struct Bar {
-      char c[129];
-} Bar __attribute__((__aligned__(128)));
-
-typedef struct Foo {
-      Bar bar[4];
-} Foo;
-
-Foo foo[4];
-
-int main()
-{
-   int i, j;
-   Foo *foop = &foo[0];
-
-   for (i=0; i < 4; i++) {
-      Bar *bar = &foop->bar[i];
-      for (j=0; j < 129; j++) {
-         bar->c[j] = 'a' + i;
-      }
-   }
-
-   if (foo[0].bar[3].c[128] != 'd')
-     abort ();
-   return 0;
-}

diff --git a/gcc/testsuite/gcc.c-torture/execute/pr43783.c b/gcc/testsuite/gcc.c-torture/execute/pr43783.c
deleted file mode 100644 (file)
index 1eff2b9..0000000
--- a/gcc/testsuite/gcc.c-torture/execute/pr43783.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* { dg-skip-if "small alignment" { pdp11-*-* } } */
-
-typedef __attribute__((aligned(16)))
-struct {
-  unsigned long long w[3];
-} UINT192;
-
-UINT192 bid_Kx192[32];
-
-extern void abort (void);
-
-int main()
-{
-  int i = 0;
-  unsigned long x = 0;
-  for (i = 0; i < 32; ++i)
-    bid_Kx192[i].w[1] = i == 1;
-  for (i = 0; i < 32; ++i)
-    x += bid_Kx192[1].w[1];
-  if (x != 32)
-    abort ();
-  return 0;
-}

diff --git a/gcc/testsuite/gcc.dg/pr36093.c b/gcc/testsuite/gcc.dg/pr36093.c
new file mode 100644 (file)
index 0000000..8474641
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr36093.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-skip-if "small alignment" { pdp11-*-* } } */
+
+extern void abort (void);
+
+typedef struct Bar {
+      char c[129];
+} Bar __attribute__((__aligned__(128)));
+
+typedef struct Foo {
+      Bar bar[4];      /* { dg-error "size of array element is not a multiple of its alignment" } */
+} Foo;
+
+Foo foo[4];
+
+int main()
+{
+   int i, j;
+   Foo *foop = &foo[0];
+
+   for (i=0; i < 4; i++) {
+      Bar *bar = &foop->bar[i];
+      for (j=0; j < 129; j++) {
+         bar->c[j] = 'a' + i;
+      }
+   }
+
+   if (foo[0].bar[3].c[128] != 'd')
+     abort ();
+   return 0;
+}

diff --git a/gcc/testsuite/gcc.dg/pr43783.c b/gcc/testsuite/gcc.dg/pr43783.c
new file mode 100644 (file)
index 0000000..196735b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr43783.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+/* { dg-skip-if "small alignment" { pdp11-*-* } } */
+
+typedef __attribute__((aligned(16)))
+struct {
+  unsigned long long w[3];
+} UINT192;
+
+UINT192 bid_Kx192[32]; /* { dg-error "size of array element is not a multiple of its alignment" } */
+
+extern void abort (void);
+
+int main()
+{
+  int i = 0;
+  unsigned long x = 0;
+  for (i = 0; i < 32; ++i)
+    bid_Kx192[i].w[1] = i == 1;
+  for (i = 0; i < 32; ++i)
+    x += bid_Kx192[1].w[1];
+  if (x != 32)
+    abort ();
+  return 0;
+}

diff --git a/libgcc/config/libbid/bid_functions.h b/libgcc/config/libbid/bid_functions.h
index 05f9566e27d8260ca5002817c55456f11655bbce..d0f0cb2914e208602a92e8f913af53ab55b34dfe 100644 (file)
--- a/libgcc/config/libbid/bid_functions.h
+++ b/libgcc/config/libbid/bid_functions.h
@@ -81,7 +81,7 @@ ALIGN (16)
 #define SQRT80 sqrtw
 #endif
 
-     typedef ALIGN (16)
+     typedef ALIGN (8)
      struct {
        UINT64 w[3];
      } UINT192;