This PR points out a problem with enum forward declarations (so C++ is out as
these are forbidden in C++). If we forward declare an enum, and later on
declare the enum with __attribute__ ((packed)), the attribute is ignored. The
reason is that when we first see the forward declaration, parser_xref_tag sets
up a forward-reference node, which has a default layout like unsigned int, so
among other things it does
TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
But then in finish_enum we were confused: the code thinks that the precision
was specified with the mode attribute so it uses wrong TYPE_PRECISION. After
playing with this a bit, I think easiest fix is to check for a mode attribute.
If we can't find it, we know that TYPE_PRECISION was set when processing the
forward declaration.
We also need to copy TYPE_ALIGN, otherwise subsequent layout_type won't DTRT.
While at it, I noticed that we don't test the "specified mode too small" error
at all, so I've added enum-mode-1.c test.
It's unclear what to do with a combination of "packed" and "mode" attributes; I
suppose that should be invalid, but I'm not changing it now.
Bootstrapped/regtested on x86_64-linux, ok for trunk?
2015-04-23 Marek Polacek <pola...@redhat.com>
PR c/52085
* c-decl.c (finish_enum): Copy over TYPE_ALIGN. Also check for "mode"
attribute.
* gcc.dg/enum-incomplete-2.c: New test.
* gcc.dg/enum-mode-1.c: New test.
diff --git gcc/c/c-decl.c gcc/c/c-decl.c
index 27ecd8b..4f6761d 100644
--- gcc/c/c-decl.c
+++ gcc/c/c-decl.c
@@ -8010,11 +8010,13 @@ finish_enum (tree enumtype, tree values, tree
attributes)
TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
+ TYPE_ALIGN (enumtype) = TYPE_ALIGN (tem);
TYPE_SIZE (enumtype) = 0;
- /* If the precision of the type was specific with an attribute and it
+ /* If the precision of the type was specified with an attribute and it
was too small, give an error. Otherwise, use it. */
- if (TYPE_PRECISION (enumtype))
+ if (TYPE_PRECISION (enumtype)
+ && lookup_attribute ("mode", attributes))
{
if (precision > TYPE_PRECISION (enumtype))
error ("specified mode too small for enumeral values");
diff --git gcc/testsuite/gcc.dg/enum-incomplete-2.c
gcc/testsuite/gcc.dg/enum-incomplete-2.c
index e69de29..5970551 100644
--- gcc/testsuite/gcc.dg/enum-incomplete-2.c
+++ gcc/testsuite/gcc.dg/enum-incomplete-2.c
@@ -0,0 +1,41 @@
+/* PR c/52085 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+#define SA(X) _Static_assert((X),#X)
+
+enum e1;
+enum e1 { A } __attribute__ ((__packed__));
+enum e2 { B } __attribute__ ((__packed__));
+SA (sizeof (enum e1) == sizeof (enum e2));
+SA (_Alignof (enum e1) == _Alignof (enum e2));
+
+enum e3;
+enum e3 { C = 256 } __attribute__ ((__packed__));
+enum e4 { D = 256 } __attribute__ ((__packed__));
+SA (sizeof (enum e3) == sizeof (enum e4));
+SA (_Alignof (enum e3) == _Alignof (enum e4));
+
+enum e5;
+enum e5 { E = __INT_MAX__ } __attribute__ ((__packed__));
+enum e6 { F = __INT_MAX__ } __attribute__ ((__packed__));
+SA (sizeof (enum e5) == sizeof (enum e6));
+SA (_Alignof (enum e5) == _Alignof (enum e6));
+
+enum e7;
+enum e7 { G } __attribute__ ((__mode__(__byte__)));
+enum e8 { H } __attribute__ ((__mode__(__byte__)));
+SA (sizeof (enum e7) == sizeof (enum e8));
+SA (_Alignof (enum e7) == _Alignof (enum e8));
+
+enum e9;
+enum e9 { I } __attribute__ ((__packed__, __mode__(__byte__)));
+enum e10 { J } __attribute__ ((__packed__, __mode__(__byte__)));
+SA (sizeof (enum e9) == sizeof (enum e10));
+SA (_Alignof (enum e9) == _Alignof (enum e10));
+
+enum e11;
+enum e11 { K } __attribute__ ((__mode__(__word__)));
+enum e12 { L } __attribute__ ((__mode__(__word__)));
+SA (sizeof (enum e11) == sizeof (enum e12));
+SA (_Alignof (enum e11) == _Alignof (enum e12));
diff --git gcc/testsuite/gcc.dg/enum-mode-1.c gcc/testsuite/gcc.dg/enum-mode-1.c
index e69de29..a701123 100644
--- gcc/testsuite/gcc.dg/enum-mode-1.c
+++ gcc/testsuite/gcc.dg/enum-mode-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+enum e1 { A = 256 } __attribute__((__mode__(__byte__))); /* { dg-error
"specified mode too small for enumeral values" } */
+enum e2 { B = 256 } __attribute__((__packed__, __mode__(__byte__))); /* {
dg-error "specified mode too small for enumeral values" } */
+
+enum e3 { C = __INT_MAX__ } __attribute__((__mode__(__QI__))); /* { dg-error
"specified mode too small for enumeral values" } */
+enum e4 { D = __INT_MAX__ } __attribute__((__packed__, __mode__(__QI__))); /*
{ dg-error "specified mode too small for enumeral values" } */
+
+enum e5 { E = __INT_MAX__ } __attribute__((__mode__(__HI__))); /* { dg-error
"specified mode too small for enumeral values" } */
+enum e6 { F = __INT_MAX__ } __attribute__((__packed__, __mode__(__HI__))); /*
{ dg-error "specified mode too small for enumeral values" } */
Marek
