On 1/7/19 1:08 AM, Martin Sebor wrote:
> On 1/5/19 9:04 AM, Bernd Edlinger wrote:
>> On 1/4/19 10:22 PM, Jason Merrill wrote:
>>> Hmm, I'm uncomfortable with starting to pass in the decl just for the sake
>>> of deciding whether this diagnostic should be a pedwarn or error. In
>>> general, because of copy elision, we can't know at this point what we're
>>> initializing, so I'd rather not pretend we can. Instead, maybe add a
>>> LOOKUP_ALLOW_FLEXARY_INIT flag that you can add to the flags argument in
>>> the call from store_init_value?
>>>
>>
>> Okay, I reworked the patch, to pass a bit in the flags, it was a bit more
>> complicated
>> than anticipated, because it is necessary to pass the flag thru
>> process_init_constructor
>> and friends to the recursive invocation of digest_init_r. It turned out that
>> digest_nsdmi_init did not need to change, since it is always wrong to use
>> flexarray init
>> there. I added a new test case (flexary32.C) to exercises a few cases where
>> non static
>> direct member intializers are allowed to use flexarrays (in static members)
>> and where that
>> would be wrong (in automatic members). So that seems to work.
>
> If that resolves pr69338 can you please also reference the bug in
> the test and in the ChangeLog? (Ditto for pr69697.)
>
Yes, those appear to be fixed as well.
Added pr69338 + pr69697 to the ChangeLog,
and also added test cases from both PRs.
Attached the otherwise unchanged v3 of my patch.
Is to OK for trunk?
Thanks
Bernd.
gcc/cp:
2019-01-05 Bernd Edlinger <bernd.edlin...@hotmail.de>
PR c++/88261
PR c++/69338
PR c++/69696
PR c++/69697
* cp-tree.h (LOOKUP_ALLOW_FLEXARRAY_INIT): New flag value.
* typeck2.c (digest_init_r): Raise an error for non-static
initialization of a flexible array member.
(process_init_constructor, massage_init_elt,
process_init_constructor_array, process_init_constructor_record,
process_init_constructor_union, process_init_constructor): Add the
flags parameter and pass it thru.
(store_init_value): Pass LOOKUP_ALLOW_FLEXARRAY_INIT parameter to
digest_init_flags for static decls.
gcc/testsuite:
2019-01-05 Bernd Edlinger <bernd.edlin...@hotmail.de>
PR c++/88261
PR c++/69338
PR c++/69696
PR c++/69697
* gcc.dg/array-6.c: Move from here ...
* c-c++-common/array-6.c: ... to here and add some more test coverage.
* g++.dg/pr69338.C: New test.
* g++.dg/pr69697.C: Likewise.
* g++.dg/ext/flexary32.C: Likewise.
* g++.dg/ext/flexary3.C: Adjust test.
* g++.dg/ext/flexary12.C: Likewise.
* g++.dg/ext/flexary13.C: Likewise.
* g++.dg/ext/flexary15.C: Likewise.
* g++.dg/warn/Wplacement-new-size-1.C: Likewise.
* g++.dg/warn/Wplacement-new-size-2.C: Likewise.
* g++.dg/warn/Wplacement-new-size-6.C: Likewise.
Index: gcc/cp/cp-tree.h
===================================================================
--- gcc/cp/cp-tree.h (revision 267569)
+++ gcc/cp/cp-tree.h (working copy)
@@ -5454,6 +5454,8 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, T
#define LOOKUP_NO_NON_INTEGRAL (LOOKUP_NO_RVAL_BIND << 1)
/* Used for delegating constructors in order to diagnose self-delegation. */
#define LOOKUP_DELEGATING_CONS (LOOKUP_NO_NON_INTEGRAL << 1)
+/* Allow initialization of a flexible array members. */
+#define LOOKUP_ALLOW_FLEXARRAY_INIT (LOOKUP_DELEGATING_CONS << 1)
#define LOOKUP_NAMESPACES_ONLY(F) \
(((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES))
Index: gcc/cp/typeck2.c
===================================================================
--- gcc/cp/typeck2.c (revision 267569)
+++ gcc/cp/typeck2.c (working copy)
@@ -35,7 +35,7 @@ along with GCC; see the file COPYING3. If not see
#include "gcc-rich-location.h"
static tree
-process_init_constructor (tree type, tree init, int nested,
+process_init_constructor (tree type, tree init, int nested, int flags,
tsubst_flags_t complain);
@@ -817,8 +817,12 @@ store_init_value (tree decl, tree init, vec<tree,
if (flags & LOOKUP_ALREADY_DIGESTED)
value = init;
else
- /* Digest the specified initializer into an expression. */
- value = digest_init_flags (type, init, flags, tf_warning_or_error);
+ {
+ if (TREE_STATIC (decl))
+ flags |= LOOKUP_ALLOW_FLEXARRAY_INIT;
+ /* Digest the specified initializer into an expression. */
+ value = digest_init_flags (type, init, flags, tf_warning_or_error);
+ }
if (TREE_CODE (type) == ARRAY_TYPE
&& TYPE_STRING_FLAG (TREE_TYPE (type))
@@ -1068,8 +1072,18 @@ digest_init_r (tree type, tree init, int nested, i
{
if (nested && !TYPE_DOMAIN (type))
/* C++ flexible array members have a null domain. */
- pedwarn (loc, OPT_Wpedantic,
- "initialization of a flexible array member");
+ {
+ if (flags & LOOKUP_ALLOW_FLEXARRAY_INIT)
+ pedwarn (loc, OPT_Wpedantic,
+ "initialization of a flexible array member");
+ else
+ {
+ if (complain & tf_error)
+ error_at (loc, "non-static initialization of"
+ " a flexible array member");
+ return error_mark_node;
+ }
+ }
tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
if (char_type_p (typ1)
@@ -1193,7 +1207,8 @@ digest_init_r (tree type, tree init, int nested, i
if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init)
&& !TYPE_NON_AGGREGATE_CLASS (type))
- return process_init_constructor (type, stripped_init, nested, complain);
+ return process_init_constructor (type, stripped_init, nested, flags,
+ complain);
else
{
if (COMPOUND_LITERAL_P (stripped_init) && code == ARRAY_TYPE)
@@ -1291,9 +1306,12 @@ picflag_from_initializer (tree init)
/* Adjust INIT for going into a CONSTRUCTOR. */
static tree
-massage_init_elt (tree type, tree init, int nested, tsubst_flags_t complain)
+massage_init_elt (tree type, tree init, int nested, int flags,
+ tsubst_flags_t complain)
{
- init = digest_init_r (type, init, nested ? 2 : 1, LOOKUP_IMPLICIT, complain);
+ flags &= LOOKUP_ALLOW_FLEXARRAY_INIT;
+ flags |= LOOKUP_IMPLICIT;
+ init = digest_init_r (type, init, nested ? 2 : 1, flags, complain);
/* Strip a simple TARGET_EXPR when we know this is an initializer. */
if (SIMPLE_TARGET_EXPR_P (init))
init = TARGET_EXPR_INITIAL (init);
@@ -1311,11 +1329,11 @@ static tree
which describe the initializers. */
static int
-process_init_constructor_array (tree type, tree init, int nested,
+process_init_constructor_array (tree type, tree init, int nested, int flags,
tsubst_flags_t complain)
{
unsigned HOST_WIDE_INT i, len = 0;
- int flags = 0;
+ int picflags = 0;
bool unbounded = false;
constructor_elt *ce;
vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (init);
@@ -1365,7 +1383,8 @@ static int
ce->index = error_mark_node;
gcc_assert (ce->value);
ce->value
- = massage_init_elt (TREE_TYPE (type), ce->value, nested, complain);
+ = massage_init_elt (TREE_TYPE (type), ce->value, nested, flags,
+ complain);
gcc_checking_assert
(ce->value == error_mark_node
@@ -1373,7 +1392,7 @@ static int
(strip_array_types (TREE_TYPE (type)),
strip_array_types (TREE_TYPE (ce->value)))));
- flags |= picflag_from_initializer (ce->value);
+ picflags |= picflag_from_initializer (ce->value);
}
/* No more initializers. If the array is unbounded, we are done. Otherwise,
@@ -1389,7 +1408,8 @@ static int
we can't rely on the back end to do it for us, so make the
initialization explicit by list-initializing from T{}. */
next = build_constructor (init_list_type_node, NULL);
- next = massage_init_elt (TREE_TYPE (type), next, nested, complain);
+ next = massage_init_elt (TREE_TYPE (type), next, nested, flags,
+ complain);
if (initializer_zerop (next))
/* The default zero-initialization is fine for us; don't
add anything to the CONSTRUCTOR. */
@@ -1406,7 +1426,7 @@ static int
if (next)
{
- flags |= picflag_from_initializer (next);
+ picflags |= picflag_from_initializer (next);
if (len > i+1
&& (initializer_constant_valid_p (next, TREE_TYPE (next))
== null_pointer_node))
@@ -1426,7 +1446,7 @@ static int
}
CONSTRUCTOR_ELTS (init) = v;
- return flags;
+ return picflags;
}
/* Subroutine of process_init_constructor, which will process an initializer
@@ -1434,7 +1454,7 @@ static int
the initializers. */
static int
-process_init_constructor_record (tree type, tree init, int nested,
+process_init_constructor_record (tree type, tree init, int nested, int flags,
tsubst_flags_t complain)
{
vec<constructor_elt, va_gc> *v = NULL;
@@ -1449,7 +1469,7 @@ static int
gcc_assert (!TYPE_POLYMORPHIC_P (type));
restart:
- int flags = 0;
+ int picflags = 0;
unsigned HOST_WIDE_INT idx = 0;
int designator_skip = -1;
/* Generally, we will always have an index for each initializer (which is
@@ -1517,7 +1537,7 @@ static int
if (ce)
{
gcc_assert (ce->value);
- next = massage_init_elt (type, next, nested, complain);
+ next = massage_init_elt (type, next, nested, flags, complain);
++idx;
}
}
@@ -1546,7 +1566,8 @@ static int
for us, so build up TARGET_EXPRs. If the type in question is
a class, just build one up; if it's an array, recurse. */
next = build_constructor (init_list_type_node, NULL);
- next = massage_init_elt (TREE_TYPE (field), next, nested, complain);
+ next = massage_init_elt (TREE_TYPE (field), next, nested, flags,
+ complain);
/* Warn when some struct elements are implicitly initialized. */
if ((complain & tf_warning)
@@ -1597,7 +1618,7 @@ static int
/* If this is a bitfield, now convert to the lowered type. */
if (type != TREE_TYPE (field))
next = cp_convert_and_check (TREE_TYPE (field), next, complain);
- flags |= picflag_from_initializer (next);
+ picflags |= picflag_from_initializer (next);
CONSTRUCTOR_APPEND_ELT (v, field, next);
}
@@ -1653,7 +1674,7 @@ static int
}
CONSTRUCTOR_ELTS (init) = v;
- return flags;
+ return picflags;
}
/* Subroutine of process_init_constructor, which will process a single
@@ -1661,7 +1682,7 @@ static int
which describe the initializer. */
static int
-process_init_constructor_union (tree type, tree init, int nested,
+process_init_constructor_union (tree type, tree init, int nested, int flags,
tsubst_flags_t complain)
{
constructor_elt *ce;
@@ -1749,7 +1770,7 @@ static int
if (ce->value && ce->value != error_mark_node)
ce->value = massage_init_elt (TREE_TYPE (ce->index), ce->value, nested,
- complain);
+ flags, complain);
return picflag_from_initializer (ce->value);
}
@@ -1769,40 +1790,43 @@ static int
of error. */
static tree
-process_init_constructor (tree type, tree init, int nested,
+process_init_constructor (tree type, tree init, int nested, int flags,
tsubst_flags_t complain)
{
- int flags;
+ int picflags;
gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
if (TREE_CODE (type) == ARRAY_TYPE || VECTOR_TYPE_P (type))
- flags = process_init_constructor_array (type, init, nested, complain);
+ picflags = process_init_constructor_array (type, init, nested, flags,
+ complain);
else if (TREE_CODE (type) == RECORD_TYPE)
- flags = process_init_constructor_record (type, init, nested, complain);
+ picflags = process_init_constructor_record (type, init, nested, flags,
+ complain);
else if (TREE_CODE (type) == UNION_TYPE)
- flags = process_init_constructor_union (type, init, nested, complain);
+ picflags = process_init_constructor_union (type, init, nested, flags,
+ complain);
else
gcc_unreachable ();
- if (flags & PICFLAG_ERRONEOUS)
+ if (picflags & PICFLAG_ERRONEOUS)
return error_mark_node;
TREE_TYPE (init) = type;
if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
- if (flags & PICFLAG_SIDE_EFFECTS)
+ if (picflags & PICFLAG_SIDE_EFFECTS)
{
TREE_CONSTANT (init) = false;
TREE_SIDE_EFFECTS (init) = true;
}
- else if (flags & PICFLAG_NOT_ALL_CONSTANT)
+ else if (picflags & PICFLAG_NOT_ALL_CONSTANT)
/* Make sure TREE_CONSTANT isn't set from build_constructor. */
TREE_CONSTANT (init) = false;
else
{
TREE_CONSTANT (init) = 1;
- if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
+ if (!(picflags & PICFLAG_NOT_ALL_SIMPLE))
TREE_STATIC (init) = 1;
}
return init;
Index: gcc/testsuite/c-c++-common/array-6.c
===================================================================
--- gcc/testsuite/c-c++-common/array-6.c (revision 267569)
+++ gcc/testsuite/c-c++-common/array-6.c (working copy)
@@ -16,3 +16,32 @@ void foo()
struct str d = (struct str) { 2, "d" }; /* { dg-error "(non-static)|(near initialization)" } */
struct str e = (struct str) { d.len, "e" }; /* { dg-error "(non-static)|(initialization)" } */
}
+
+struct str f = { 0, {} };
+
+void bar()
+{
+ static struct str g = { 0, {} };
+ struct str h = { 0, {} }; /* { dg-error "(non-static)|(near initialization)" } */
+ struct str i = (struct str) { 0, {} }; /* { dg-error "(non-static)|(near initialization)" } */
+ struct str j = (struct str) { i.len, {} }; /* { dg-error "(non-static)|(initialization)" } */
+}
+
+struct str k = { 0 };
+
+void baz()
+{
+ static struct str l = { 0 };
+ struct str m = { 0 };
+ struct str n = (struct str) { 0 };
+ struct str o = (struct str) { n.len };
+}
+
+struct str p = {};
+
+void qux()
+{
+ static struct str q = {};
+ struct str r = {};
+ struct str s = (struct str) {};
+}
Index: gcc/testsuite/g++.dg/ext/flexary12.C
===================================================================
--- gcc/testsuite/g++.dg/ext/flexary12.C (revision 267569)
+++ gcc/testsuite/g++.dg/ext/flexary12.C (working copy)
@@ -12,7 +12,7 @@ struct A {
void f1 ()
{
// This is the meat of the test from c++/69290:
- struct A a
+ static struct A a
= { "c" }; // { dg-error "invalid conversion from .const char\\*. to .int." }
(void)&a;
@@ -27,13 +27,13 @@ struct B {
void f2 ()
{
- struct B b1
+ static struct B b1
= { 0, "c" }; // { dg-error "invalid conversion from .const char\\*. to .int." }
(void)&b1;
const char s[] = "c";
- struct B b2
+ static struct B b2
= { 0, s }; // { dg-error "invalid conversion from .const char\\*. to .int." }
(void)&b2;
@@ -57,7 +57,7 @@ struct C {
void f3 ()
{
- struct C<double> cd
+ static struct C<double> cd
= { "c" }; // { dg-error "cannot convert .const char\\*. to .double." }
(void)&cd;
Index: gcc/testsuite/g++.dg/ext/flexary13.C
===================================================================
--- gcc/testsuite/g++.dg/ext/flexary13.C (revision 267569)
+++ gcc/testsuite/g++.dg/ext/flexary13.C (working copy)
@@ -19,33 +19,33 @@ int main ()
ASSERT (s.n == 0);
}
{
- Ax s =
+ static Ax s =
{ 0, { } }; // dg-warning "initialization of a flexible array member" }
ASSERT (s.n == 0);
}
{
- Ax s =
+ static Ax s =
{ 1, { 2 } }; // dg-warning "initialization of a flexible array member" }
ASSERT (s.n == 1 && s.a [0] == 2);
}
{
- Ax s =
+ static Ax s =
{ 2, { 3, 4 } }; // dg-warning "initialization of a flexible array member" }
ASSERT (s.n = 2 && s.a [0] == 3 && s.a [1] == 4);
}
{
- Ax s =
+ static Ax s =
{ 123, i }; // dg-warning "initialization of a flexible array member" }
ASSERT (s.n == 123 && s.a [0] == i);
}
{
- Ax s =
+ static Ax s =
{ 456, { i } }; // dg-warning "initialization of a flexible array member" }
ASSERT (s.n == 456 && s.a [0] == i);
}
{
int j = i + 1, k = j + 1;
- Ax s =
+ static Ax s =
{ 3, { i, j, k } }; // dg-warning "initialization of a flexible array member" }
ASSERT (s.n == 3 && s.a [0] == i && s.a [1] == j && s.a [2] == k);
}
Index: gcc/testsuite/g++.dg/ext/flexary15.C
===================================================================
--- gcc/testsuite/g++.dg/ext/flexary15.C (revision 267569)
+++ gcc/testsuite/g++.dg/ext/flexary15.C (working copy)
@@ -10,5 +10,5 @@ struct S {
void foo (const char *a)
{
- const S s = { 1, { a, "b" } }; // { dg-warning "invalid conversion" }
+ static const S s = { 1, { a, "b" } }; // { dg-warning "invalid conversion" }
}
Index: gcc/testsuite/g++.dg/ext/flexary3.C
===================================================================
--- gcc/testsuite/g++.dg/ext/flexary3.C (revision 267569)
+++ gcc/testsuite/g++.dg/ext/flexary3.C (working copy)
@@ -17,5 +17,6 @@ struct s {
int main()
{
struct s s = { .c = 0 }; // { dg-error "initializer" }
+ // { dg-error "non-static initialization of a flexible array member" "" { target *-*-* } .-1 }
return 0;
}
Index: gcc/testsuite/g++.dg/ext/flexary32.C
===================================================================
--- gcc/testsuite/g++.dg/ext/flexary32.C (revision 0)
+++ gcc/testsuite/g++.dg/ext/flexary32.C (working copy)
@@ -0,0 +1,19 @@
+/* { dg-do compile { target c++11 } } */
+/* { dg-options -Wno-pedantic } */
+
+struct str { int len; char s[]; };
+
+struct foo {
+ str x = {3, {1,2,3}}; /* { dg-error "(non-static)|(initialization)" } */
+ foo() {}
+};
+
+struct bar {
+ static constexpr str x = {3, {1,2,3}};
+ bar() {}
+};
+
+struct baz {
+ str x = {3};
+ baz() {}
+};
Index: gcc/testsuite/g++.dg/pr69338.C
===================================================================
--- gcc/testsuite/g++.dg/pr69338.C (revision 0)
+++ gcc/testsuite/g++.dg/pr69338.C (working copy)
@@ -0,0 +1,23 @@
+/* { dg-do compile { target c++11 } } */
+/* { dg-additional-options "-Wno-pedantic" } */
+
+struct A { char i, a[]; };
+
+void foo()
+{
+ struct A a0 = { 3, "AB" }; /* { dg-error "(non-static)|(initialization)" } */
+}
+
+struct A a1 = { 3, "AB" }; /* { dg-bogus "(non-static)|(initialization)" } */
+
+struct A a2 = (struct A){ 3, "AB" }; /* { dg-error "(non-static)|(initialization)" } */
+
+struct B1 {
+ A a3;
+ B1 (): a3 { 3, "AB" } { } /* { dg-error "(non-static)|(initialization)" } */
+} b1;
+
+struct B2 {
+ A a4;
+ B2 (): a4 ((struct A){ 3, "AB" }) { } /* { dg-error "(non-static)|(initialization)" } */
+} b2;
Index: gcc/testsuite/g++.dg/pr69697.C
===================================================================
--- gcc/testsuite/g++.dg/pr69697.C (revision 0)
+++ gcc/testsuite/g++.dg/pr69697.C (working copy)
@@ -0,0 +1,7 @@
+/* { dg-do compile { target c++11 } } */
+/* { dg-additional-options "-Wno-pedantic" } */
+
+int i;
+struct A { int n, a[]; }
+ a = i ? A({ 1, { 2 } }) /* { dg-error "(non-static)|(initialization)" } */
+ : A({ 2, { 3, 4 } }); /* { dg-error "(non-static)|(initialization)" } */
Index: gcc/testsuite/g++.dg/warn/Wplacement-new-size-1.C
===================================================================
--- gcc/testsuite/g++.dg/warn/Wplacement-new-size-1.C (revision 267569)
+++ gcc/testsuite/g++.dg/warn/Wplacement-new-size-1.C (working copy)
@@ -28,7 +28,7 @@ void fAx (Ax *px, Ax &rx)
void fAx2 ()
{
- Ax ax2 = { 1, { 2, 3 } };
+ static Ax ax2 = { 1, { 2, 3 } };
new (ax2.a) Int16;
new (ax2.a) Int32; // { dg-warning "placement" }
@@ -82,7 +82,7 @@ void fBx (BAx *pbx, BAx &rbx)
void fBx1 ()
{
- BAx bax1 = { 1, /* Ax = */ { 2, /* a[] = */ {} } };
+ static BAx bax1 = { 1, /* Ax = */ { 2, /* a[] = */ {} } };
new (bax1.ax.a) char; // { dg-warning "placement" }
new (bax1.ax.a) char[2]; // { dg-warning "placement" }
Index: gcc/testsuite/g++.dg/warn/Wplacement-new-size-2.C
===================================================================
--- gcc/testsuite/g++.dg/warn/Wplacement-new-size-2.C (revision 267569)
+++ gcc/testsuite/g++.dg/warn/Wplacement-new-size-2.C (working copy)
@@ -33,13 +33,13 @@ void fAx (Ax *px, Ax &rx)
void fAx2 ()
{
// Initialization of non-static objects with flexible array members
- // isn't allowed in C and should perhaps be disallowed in C++ as
+ // isn't allowed in C and had to be be disallowed in C++ as
// well to avoid c++/69696 - incorrect initialization of block-scope
// flexible array members.
- Ax ax2 = { 1, { 2, 3 } };
+ Ax ax2 = { 1, { 2, 3 } }; // { dg-error "non-static initialization of a flexible array member" }
- new (ax2.a) Int16;
- new (ax2.a) Int16[1];
+ new (ax2.a) Int16; // { dg-warning "placement" }
+ new (ax2.a) Int16[1]; // { dg-warning "placement" }
new (ax2.a) Int16[2]; // { dg-warning "placement" }
new (ax2.a) Int32; // { dg-warning "placement" }
new (ax2.a) Int32[2]; // { dg-warning "placement" }
@@ -140,7 +140,7 @@ void fBx (BAx *pbx, BAx &rbx)
void fBx1 ()
{
- BAx bax1 = { 1, /* Ax = */ { 2, /* a[] = */ {} } };
+ static BAx bax1 = { 1, /* Ax = */ { 2, /* a[] = */ {} } };
new (bax1.ax.a) char; // { dg-warning "placement" }
new (bax1.ax.a) char[2]; // { dg-warning "placement" }
Index: gcc/testsuite/g++.dg/warn/Wplacement-new-size-6.C
===================================================================
--- gcc/testsuite/g++.dg/warn/Wplacement-new-size-6.C (revision 267569)
+++ gcc/testsuite/g++.dg/warn/Wplacement-new-size-6.C (working copy)
@@ -15,7 +15,7 @@ struct BAx { int i; Ax ax; };
void fBx1 ()
{
- BAx bax1 = { 1, /* Ax = */ { 2, /* a[] = */ { 3 } } }; // { dg-error "initialization of flexible array member in a nested context" }
+ static BAx bax1 = { 1, /* Ax = */ { 2, /* a[] = */ { 3 } } }; // { dg-error "initialization of flexible array member in a nested context" }
new (bax1.ax.a) char; // { dg-warning "placement" }
new (bax1.ax.a) char[2]; // { dg-warning "placement" }
@@ -25,7 +25,7 @@ void fBx1 ()
void fBx2 ()
{
- BAx bax2 = { 1, /* Ax = */ { 2, /* a[] = */ { 3, 4 } } }; // { dg-error "initialization of flexible array member in a nested context" }
+ static BAx bax2 = { 1, /* Ax = */ { 2, /* a[] = */ { 3, 4 } } }; // { dg-error "initialization of flexible array member in a nested context" }
new (bax2.ax.a) char; // { dg-warning "placement" }
new (bax2.ax.a) char[2]; // { dg-warning "placement" }
@@ -37,7 +37,7 @@ void fBx2 ()
void fBx3 ()
{
- BAx bax2 = { 1, /* Ax = */ { 3, /* a[] = */ { 4, 5, 6 } } }; // { dg-error "initialization of flexible array member in a nested context" }
+ static BAx bax2 = { 1, /* Ax = */ { 3, /* a[] = */ { 4, 5, 6 } } }; // { dg-error "initialization of flexible array member in a nested context" }
new (bax2.ax.a) char; // { dg-warning "placement" }
new (bax2.ax.a) char[2]; // { dg-warning "placement" }
Index: gcc/testsuite/gcc.dg/array-6.c
===================================================================
--- gcc/testsuite/gcc.dg/array-6.c (revision 267569)
+++ gcc/testsuite/gcc.dg/array-6.c (working copy)
@@ -1,18 +0,0 @@
-/* PR c/5597 */
-/* { dg-do compile } */
-/* { dg-options "" } */
-
-/* Verify that GCC forbids non-static initialization of
- flexible array members. */
-
-struct str { int len; char s[]; };
-
-struct str a = { 2, "a" };
-
-void foo()
-{
- static struct str b = { 2, "b" };
- struct str c = { 2, "c" }; /* { dg-error "(non-static)|(near initialization)" } */
- struct str d = (struct str) { 2, "d" }; /* { dg-error "(non-static)|(near initialization)" } */
- struct str e = (struct str) { d.len, "e" }; /* { dg-error "(non-static)|(initialization)" } */
-}
