[clang] Reject flexible array member in a union in C++

[Fznamznon]

Summary

It was rejected in C, and in a strange way accepted in C++. However, the
support was never properly tested and fully implemented, so just reject
it in C++ mode as well.

This change also fixes crash on attempt to initialize union with flexible
array member. Due to missing check on union, there was a null expression
added to init list that caused crash later.

Fixes https://github.com/llvm/llvm-project/issues/61746

[Fznamznon]

clang/lib/Sema/SemaInit.cpp

808

Just for some context, numStructUnionElements checks that there is a flexible array member and returns number_of_initializable_fields-1 for structs. For unions it just returns 1 or 0, so flexible array member caused adding one more element to initlistexpr that was never properly handled.

Instead of doing this change, we could probably never enter initialization since the record (union) declaration is not valid, but that is not the case even for other types of errors in code, for example, I've tried declaring field of struct with a typo:

struct { cha x[]; } r = {1};

Initialization is still performed by clang.
Also, it seems MSVC considers flexible array member inside union as valid, so the test code is probably not always invalid.

[shafik]

Thank you for this fix.

clang/lib/Sema/SemaInit.cpp

808

I am not sure what to think here, looking at gcc documentation for this extension: https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html

and using the following code:

struct f1 {
  int x; int y[];
} f1 = { 1, { 2, 3, 4 } }; // #1

struct f2 {
  struct f1 f1; int data[3];
} f2 = { { 1 }, { 2, 3, 4 } }; // #2

struct { char x[]; } r = {1};  // #3

gcc rejects 2 and 3 even though 2 comes from their documentation. Clang warns on 2 and MSVC rejects 2

CC @aaron.ballman @rsmith

[Fznamznon]

clang/lib/Sema/SemaInit.cpp

808

Yes, I also had a feeling that we probably need to refine how these extensions are supported by clang, that is probably a bit out of scope of the fix though.

[aaron.ballman]

clang/lib/Sema/SemaInit.cpp

808

The GCC extension differs based on C vs C++: https://godbolt.org/z/E14Yz37To
As does the extension in Clang, but differently than GCC: https://godbolt.org/z/zYznaYPf5

So I agree that there's work to be done on this extension, but it's outside of the scope of the crash fix for this patch. For this patch, GCC rejects allowing a flexible array member in a union in both C and C++, but it looks like Clang rejects in C and perhaps accepts in C++: https://godbolt.org/z/bTsPn3G7b So how about we add a C++ test case for this as well -- if that still crashes, that should be fixed, but if the code is accepted, we should either decide we want to start rejecting it or we should ensure the codegen for it is correct.

[Fznamznon]

clang/lib/Sema/SemaInit.cpp

808

While experimenting with C++ test, I've noticed the following thing:

union { char x[]; } r = {0}; // when in global scope generates no IR (without my patch crashes)

void foo() {
  union { char x[]; } r = {0}; // fails with error "initialization of flexible array member is not allowed" in both C/C++, no crash even without my patch
}

union A {char x[]; };
A a = {0}; // crashes even with my patch but with different assertion when trying -emit-llvm
void foo() {
  A a = {0}; // fails with error "initialization of flexible array member is not allowed" in both C and C++, no crash even without my patch
}

It is not entirely clear to me why the behavior different for function and TU scope. gcc always gives an error about flexible array in union, no matter how it is used. Also, it is strange that I'm not seeing the same "initialization of flexible array member is not allowed" error message for structs, just for unions. I'm thinking that we don't really have proper codegen for the code that I'm trying to fix and we should reject the code like gcc does. MSVC is fine with all though - https://godbolt.org/z/aoarEzd56 .

WDYT?

[Fznamznon]

clang/lib/Sema/SemaInit.cpp

808

Ping?

[aaron.ballman]

clang/lib/Sema/SemaInit.cpp

808

Ouch, that's a rather confused situation, isn't it? I don't have the impression we actually support this extension and we do not document support for it in the language extensions page, so due to the crashing I'm leaning towards diagnosing this code as invalid per the standards. That doesn't mean someone can't come along and support this extension if they need it to work, but the current state of things is not production-ready. Any disagreement with that?

(If we go that route, we should definitely follow the potentially breaking changes policy (https://llvm.org/docs/DeveloperPolicy.html#making-potentially-breaking-changes) because this could be disruptive depending on how much this is used in the wild.)

[Fznamznon]

clang/lib/Sema/SemaInit.cpp

808

I don't have any objections to start diagnosing the code as invalid. Flexible array members in unions don't seem to work properly. This is claimed as some GCC extension around the clang code, the thing is that GCC rejects it.

[shafik]

clang/lib/Sema/SemaInit.cpp

808

Diagnosing this sounds like the right thing to do. If someone is using this, it might be good to flush that and try and see what their actual use case is.

[Fznamznon]

Reject flexible array members in unions in C++ as well.

[shafik]

LGTM

[Fznamznon]

Ping.

[aaron.ballman]

clang/docs/ReleaseNotes.rst

58

clang/include/clang/Basic/DiagnosticSemaKinds.td

6251–6254

Should this be updated to remove the union case?

6262

Same question here

6265

This was the last use of this diagnostic group, so we can remove it from DiagnosticGroups.td as well.

[Fznamznon]

clang/include/clang/Basic/DiagnosticSemaKinds.td

6251–6254

Sounds reasonable, but what is unfortunate is that this diagnostic exactly matches TagTypeKind enum, so now it can be emitted with Diag(...) << ... << SomeTagDecl->getTagKind(). Once I remove union from there, this neat thing fails.

[Fznamznon]

Apply some of the comments, rebase

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

6251–6254

Oh, that might be worth leaving alone then, but put a comment next to the diagnostic definition to explain the relationship to TagTypeKind.

[Fznamznon]

Rebase, add a comment

[Fznamznon]

clang/include/clang/Basic/DiagnosticSemaKinds.td

6251–6254

Sure, added a comment above the first diagnostic that uses the same structure.

[aaron.ballman]

LGTM!

[aaron.ballman]

clang/test/SemaObjCXX/flexible-array.mm

7

CC @rjmccall -- this is changing Objective-C++ behavior, which I assume you're fine with because it's following the same changes in C++ behavior, but wanted to call out explicitly in case you had concerns.

[rjmccall]

I have no specific objections. I do worry about removing support for something that's apparently been accepted for a long time, just on general source-compatibility grounds, but I don't think there's an ObjC-specific problem with it.

[Fznamznon]

I've got an error from buildbot on Windows:

C:\Program Files (x86)\Windows Kits\10\include\10.0.19041.0\um\winioctl.h:13404:51: error: flexible array member 'Lev1Depends' in a union is not allowed

        STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY Lev1Depends[];

It feels like Windows headers contain flexible array members in unions. We probably can't just always reject them on Windows.

[aaron.ballman]

In D147626#4315283, @Fznamznon wrote:

I've got an error from buildbot on Windows:

C:\Program Files (x86)\Windows Kits\10\include\10.0.19041.0\um\winioctl.h:13404:51: error: flexible array member 'Lev1Depends' in a union is not allowed

        STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY Lev1Depends[];

It feels like Windows headers contain flexible array members in unions. We probably can't just always reject them on Windows.

Thank you for the quick revert -- yeah, this means we have to make this work for MSVC compatibility, unfortunately. Any indication we're going to hit something similar with GCC compatibility in a glibc (or other system) header?

I think we'll have to back off the hard stance of always rejecting this because I think we'll need this to work in -fms-compatibility mode. If there's not indications of this being disruptive on non-MSVC-compatible targets, then we may still be able to get away with rejecting the extension there.

[efriedma]

If there's not indications of this being disruptive on non-MSVC-compatible targets, then we may still be able to get away with rejecting the extension there.

If we need to have the codepath anyway, there isn't much harm in allowing it on all targets, I think. There's really only one possible interpretation for the construct.

[aaron.ballman]

In D147626#4316190, @efriedma wrote:

If there's not indications of this being disruptive on non-MSVC-compatible targets, then we may still be able to get away with rejecting the extension there.

If we need to have the codepath anyway, there isn't much harm in allowing it on all targets, I think. There's really only one possible interpretation for the construct.

You would think, except the GCC extension differs based on C vs C++: https://godbolt.org/z/E14Yz37To as does the extension in Clang, but differently than GCC: https://godbolt.org/z/zYznaYPf5 and so we'd also have to dig into solving that if we wanted to keep GCC compatibility behavior.

[efriedma]

In D147626#4316212, @aaron.ballman wrote:

In D147626#4316190, @efriedma wrote:

If there's not indications of this being disruptive on non-MSVC-compatible targets, then we may still be able to get away with rejecting the extension there.

If we need to have the codepath anyway, there isn't much harm in allowing it on all targets, I think. There's really only one possible interpretation for the construct.

You would think, except the GCC extension differs based on C vs C++: https://godbolt.org/z/E14Yz37To as does the extension in Clang, but differently than GCC: https://godbolt.org/z/zYznaYPf5 and so we'd also have to dig into solving that if we wanted to keep GCC compatibility behavior.

I don't see any unions there? Declaring a flexible array is separate from flexible array initialization.

Actually, despite my saying the interpretation for unions is "obvious", it's actually a little more weird than I thought: union x { short x[]; }; static_assert(sizeof(x)==2); compiles with msvc.

[aaron.ballman]

In D147626#4316535, @efriedma wrote:

In D147626#4316212, @aaron.ballman wrote:

In D147626#4316190, @efriedma wrote:

If there's not indications of this being disruptive on non-MSVC-compatible targets, then we may still be able to get away with rejecting the extension there.

If we need to have the codepath anyway, there isn't much harm in allowing it on all targets, I think. There's really only one possible interpretation for the construct.

You would think, except the GCC extension differs based on C vs C++: https://godbolt.org/z/E14Yz37To as does the extension in Clang, but differently than GCC: https://godbolt.org/z/zYznaYPf5 and so we'd also have to dig into solving that if we wanted to keep GCC compatibility behavior.

I don't see any unions there? Declaring a flexible array is separate from flexible array initialization.

Sorry, that was a rather bad think-o -- those examples came from GCC's documentation of FAM extensions (https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html), but you're right, that example is not about declarations but initialization. @Fznamznon had an example: https://godbolt.org/z/jsWjv7svr

Actually, despite my saying the interpretation for unions is "obvious", it's actually a little more weird than I thought: union x { short x[]; }; static_assert(sizeof(x)==2); compiles with msvc.

Well that's... a bit shorter... than I would have expected that union to be. (I'm not apologizing for the pun.)

[Fznamznon]

Any indication we're going to hit something similar with GCC compatibility in a glibc (or other system) header?

I haven't seen non-Windows problems. Though I agree that if we somehow are going to support this for MSVC compatibility, there is no harm in allowing this for all targets.

[Fznamznon]

Well that's... a bit shorter... than I would have expected that union to be. (I'm not apologizing for the pun.)

In clang union x { short x[]; }; static_assert(sizeof(x)==2); evaluates to '0 == 2'. That is even shorter, I guess? This is also the reason why

union A {char x[]; };
A a = {0};

keeps crashing even after my fix. It feels like we're not even close to be compatible with msvc. I would probably prefer submitting the original fix and submitting an issue to clean up the mess with this extension. At least this way it won't crash in C after issuing an error, like this https://godbolt.org/z/5oxYTq5fq

[Fznamznon]

I posted a pure crash fix here - https://reviews.llvm.org/D150435 .

clang/docs/ReleaseNotes.rst

- Indirect edges of asm goto statements under certain circumstances may now be
   .. code-block:: c
 
     foo: asm goto ("# %0 %1"::"i"(&&foo)::foo);
 
 C++ Specific Potentially Breaking Changes
 -----------------------------------------
 - Clang won't search for coroutine_traits in std::experimental namespace any more.
   Clang will only search for std::coroutine_traits for coroutines then.
+- Clang now rejects unions containing a flexible array member.
 
 ABI Changes in This Version
 ---------------------------
 - ``__is_trivial`` has changed for a small category of classes with constrained default constructors (`#60697 <https://github.com/llvm/llvm-project/issues/60697>`_).
   *FIXME: Remove this note if we've backported this change to the Clang 16 branch.*
 
 What's New in Clang |release|?
 ==============================

clang/include/clang/Basic/DiagnosticGroups.td

 def CXX11ExtraSemi : DiagGroup<"c++11-extra-semi">;
 def EmptyInitStatement : DiagGroup<"empty-init-stmt">;
 def ExportUnnamed : DiagGroup<"export-unnamed">;
 def ExtraSemiStmt : DiagGroup<"extra-semi-stmt", [EmptyInitStatement]>;
 def ExtraSemi : DiagGroup<"extra-semi", [CXX98CompatExtraSemi,
                                          CXX11ExtraSemi]>;
 
 def GNUFlexibleArrayInitializer : DiagGroup<"gnu-flexible-array-initializer">;
-def GNUFlexibleArrayUnionMember : DiagGroup<"gnu-flexible-array-union-member">;
 def GNUFoldingConstant : DiagGroup<"gnu-folding-constant">;
 def FormatInsufficientArgs : DiagGroup<"format-insufficient-args">;
 def FormatExtraArgs : DiagGroup<"format-extra-args">;
 def FormatZeroLength : DiagGroup<"format-zero-length">;
 
 def InvalidIOSDeploymentTarget : DiagGroup<"invalid-ios-deployment-target">;
 
 def CXX17CompatMangling : DiagGroup<"c++17-compat-mangling">;

 // A warning group for warnings about GCC extensions.
 def GNU : DiagGroup<"gnu", [GNUAlignofExpression, GNUAnonymousStruct,
                             GNUAutoType,
                             GNUBinaryLiteral, GNUCaseRange,
                             GNUComplexInteger, GNUCompoundLiteralInitializer,
                             GNUConditionalOmittedOperand, GNUDesignator,
                             GNUEmptyStruct,
                             VLAExtension, GNUFlexibleArrayInitializer,
-                            GNUFlexibleArrayUnionMember, GNUFoldingConstant,
+                            GNUFoldingConstant,
                             GNUImaginaryConstant, GNUIncludeNext,
                             GNULabelsAsValue, GNULineMarker, GNUNullPointerArithmetic,
                             GNUOffsetofExtensions, GNUPointerArith,
                             RedeclaredClassMember, GNURedeclaredEnum,
                             GNUStatementExpression, GNUStaticFloatInit,
                             GNUStringLiteralOperatorTemplate, GNUUnionCast,
                             GNUVariableSizedTypeNotAtEnd, ZeroLengthArray,
                             GNUZeroLineDirective,

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_field_incomplete_or_sizeless : Error<
   "field has %select{incomplete|sizeless}0 type %1">;
 def ext_variable_sized_type_in_struct : ExtWarn<
   "field %0 with variable sized type %1 not at the end of a struct or class is"
   " a GNU extension">, InGroup<GNUVariableSizedTypeNotAtEnd>;
 
 def ext_c99_flexible_array_member : Extension<
   "flexible array members are a C99 feature">, InGroup<C99>;
+// Flexible array members in unions are not supported, but union case is still
+// present in the diagnostic so it matches TagTypeKind enum and can be emitted
+// with Diag(...) << ... << SomeTagDecl->getTagKind().
 def err_flexible_array_virtual_base : Error<
   "flexible array member %0 not allowed in "
   "%select{struct|interface|union|class|enum}1 which has a virtual base class">;
 def err_flexible_array_empty_aggregate : Error<
   "flexible array member %0 not allowed in otherwise empty "
   "%select{struct|interface|union|class|enum}1">;
 def err_flexible_array_has_nontrivial_dtor : Error<
   "flexible array member %0 of type %1 with non-trivial destruction">;
 def ext_flexible_array_in_struct : Extension<
   "%0 may not be nested in a struct due to flexible array member">,
   InGroup<FlexibleArrayExtensions>;
 def ext_flexible_array_in_array : Extension<
   "%0 may not be used as an array element due to flexible array member">,
   InGroup<FlexibleArrayExtensions>;
 def err_flexible_array_init : Error<
   "initialization of flexible array member is not allowed">;
 def ext_flexible_array_empty_aggregate_ms : Extension<
   "flexible array member %0 in otherwise empty "
   "%select{struct|interface|union|class|enum}1 is a Microsoft extension">,
   InGroup<MicrosoftFlexibleArray>;
 def err_flexible_array_union : Error<
   "flexible array member %0 in a union is not allowed">;
-def ext_flexible_array_union_ms : Extension<
-  "flexible array member %0 in a union is a Microsoft extension">,
-  InGroup<MicrosoftFlexibleArray>;
 def ext_flexible_array_empty_aggregate_gnu : Extension<
   "flexible array member %0 in otherwise empty "
   "%select{struct|interface|union|class|enum}1 is a GNU extension">,
   InGroup<GNUEmptyStruct>;
-def ext_flexible_array_union_gnu : Extension<
-  "flexible array member %0 in a union is a GNU extension">, InGroup<GNUFlexibleArrayUnionMember>;
 
 def err_flexible_array_not_at_end : Error<
   "flexible array member %0 with type %1 is not at the end of"
   " %select{struct|interface|union|class|enum}2">;
 def err_objc_variable_sized_type_not_at_end : Error<
   "field %0 with variable sized type %1 is not at the end of class">;
 def note_next_field_declaration : Note<
   "next field declaration is here">;

clang/lib/Sema/SemaDecl.cpp

if (FDTy->isFunctionType()) {
       FD->setInvalidDecl();
       EnclosingDecl->setInvalidDecl();
       continue;
     } else if (FDTy->isIncompleteArrayType() &&
                (Record || isa<ObjCContainerDecl>(EnclosingDecl))) {
       if (Record) {
         // Flexible array member.
         // Microsoft and g++ is more permissive regarding flexible array.
-        // It will accept flexible array in union and also
-        // as the sole element of a struct/class.
+        // It will accept flexible array as the sole element of a struct/class.
         unsigned DiagID = 0;
         if (!Record->isUnion() && !IsLastField) {
           Diag(FD->getLocation(), diag::err_flexible_array_not_at_end)
             << FD->getDeclName() << FD->getType() << Record->getTagKind();
           Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
           FD->setInvalidDecl();
           EnclosingDecl->setInvalidDecl();
           continue;
         } else if (Record->isUnion())
-          DiagID = getLangOpts().MicrosoftExt
-                       ? diag::ext_flexible_array_union_ms
-                       : getLangOpts().CPlusPlus
-                             ? diag::ext_flexible_array_union_gnu
-                             : diag::err_flexible_array_union;
+          DiagID = diag::err_flexible_array_union;
         else if (NumNamedMembers < 1)
           DiagID = getLangOpts().MicrosoftExt
                        ? diag::ext_flexible_array_empty_aggregate_ms
                        : getLangOpts().CPlusPlus
                              ? diag::ext_flexible_array_empty_aggregate_gnu
                              : diag::err_flexible_array_empty_aggregate;
 
         if (DiagID)

clang/lib/Sema/SemaInit.cpp

else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
           break;
         }
       }
     } else {
       // The fields beyond ILE->getNumInits() are default initialized, so in
       // order to leave them uninitialized, the ILE is expanded and the extra
       // fields are then filled with NoInitExpr.
       unsigned NumElems = numStructUnionElements(ILE->getType());
-      if (RDecl->hasFlexibleArrayMember())
+      if (!RDecl->isUnion() && RDecl->hasFlexibleArrayMember())
         ++NumElems;
       if (!VerifyOnly && ILE->getNumInits() < NumElems)
         ILE->resizeInits(SemaRef.Context, NumElems);
 
       unsigned Init = 0;
 
       if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
         for (auto &Base : CXXRD->bases()) {

clang/test/Layout/aix-power-alignment-typedef.cpp

 
 // CHECK:          0 | struct test1::A
 // CHECK-NEXT:     0 |   Dbl x
 // CHECK-NEXT:       | [sizeof=8, dsize=8, align=2, preferredalign=2,
 // CHECK-NEXT:       |  nvsize=8, nvalign=2, preferrednvalign=2]
 
 } // namespace test1
 
-namespace test2 {
-typedef double Dbl __attribute__((__aligned__(2)));
-typedef Dbl DblArr[];
-
-union U {
-  DblArr da;
-  char x;
-};
-
-int x = sizeof(U);
-
-// CHECK:          0 | union test2::U
-// CHECK-NEXT:     0 |   DblArr da
-// CHECK-NEXT:     0 |   char x
-// CHECK-NEXT:       | [sizeof=2, dsize=2, align=2, preferredalign=2,
-// CHECK-NEXT:       |  nvsize=2, nvalign=2, preferrednvalign=2]
-
-} // namespace test2
-
-namespace test3 {
-typedef double DblArr[] __attribute__((__aligned__(2)));
-
-union U {
-  DblArr da;
-  char x;
-};
-
-int x = sizeof(U);
-
-// CHECK:          0 | union test3::U
-// CHECK-NEXT:     0 |   DblArr da
-// CHECK-NEXT:     0 |   char x
-// CHECK-NEXT:       | [sizeof=2, dsize=2, align=2, preferredalign=2,
-// CHECK-NEXT:       |  nvsize=2, nvalign=2, preferrednvalign=2]
-
-} // namespace test3
-
-namespace test4 {
-typedef double Dbl __attribute__((__aligned__(2)));
-
-union U {
-  Dbl DblArr[];
-  char x;
-};
-
-int x = sizeof(U);
-
-// CHECK:          0 | union test4::U
-// CHECK-NEXT:     0 |   Dbl[] DblArr
-// CHECK-NEXT:     0 |   char x
-// CHECK-NEXT:       | [sizeof=2, dsize=2, align=2, preferredalign=2,
-// CHECK-NEXT:       |  nvsize=2, nvalign=2, preferrednvalign=2]
-
-} // namespace test4

clang/test/Sema/MicrosoftExtensions.c

 // RUN: %clang_cc1 -triple i686-windows %s -fsyntax-only -Wno-unused-value -Wno-pointer-to-int-cast -Wmicrosoft -verify -fms-extensions
 
 struct A
 {
    int a[];  /* expected-warning {{flexible array member 'a' in otherwise empty struct is a Microsoft extension}} */
 };
 
 struct PR28407
 {
   int : 1;
   int a[]; /* expected-warning {{flexible array member 'a' in otherwise empty struct is a Microsoft extension}} */
 };
 
 struct C {
    int l;
    union {
-       int c1[];   /* expected-warning {{flexible array member 'c1' in a union is a Microsoft extension}}  */
-       char c2[];  /* expected-warning {{flexible array member 'c2' in a union is a Microsoft extension}} */
+       int c1[];   /* expected-error {{flexible array member 'c1' in a union is not allowed}} */
+       char c2[];  /* expected-error {{flexible array member 'c2' in a union is not allowed}} */
    };
 };
 
 
 struct D {
    int l;
    int D[];
 };

clang/test/Sema/init.c

 
 // <rdar://problem/10185490> (derived from SPEC vortex benchmark)
 typedef char strty[10];
 struct vortexstruct { strty s; };
 struct vortexstruct vortexvar = { "asdf" };
 
 typedef struct { uintptr_t x : 2; } StructWithBitfield;
 StructWithBitfield bitfieldvar = { (uintptr_t)&bitfieldvar }; // expected-error {{initializer element is not a compile-time constant}}
+
+// GH61746
+union { char x[]; } r = {0}; // expected-error {{flexible array member 'x' in a union is not allowed}}

clang/test/SemaCXX/flexible-array-test.cpp

 template <class Key, class T>
 void QMap<Key, T>::insert(const Key &, const T &avalue)
 {
   v = avalue;
 }
 
 struct Rec {
   union { // expected-warning-re {{variable sized type '{{.*}}' not at the end of a struct or class is a GNU extension}}
-    int u0[];
+    int u0[]; // expected-error {{flexible array member 'u0' in a union is not allowed}}
   };
   int x;
 } rec;
 
 struct inotify_event
 {
   int wd;
  

 
 class A {
   int s;
   char c[];
 };
 
 union B {
   int s;
-  char c[];
+  char c[]; // expected-error {{flexible array member 'c' in a union is not allowed}}
 };
 
 class C {
   char c[]; // expected-error {{flexible array member 'c' with type 'char[]' is not at the end of class}}
   int s; // expected-note {{next field declaration is here}}
 };
 
 namespace rdar9065507 {

clang/test/SemaCXX/gnu-flags.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -DNONE -Wno-gnu
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -DNONE -Wno-gnu
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -DNONE -Wno-gnu
 
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DALL -Wgnu 
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -DALL -Wgnu 
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -DALL -Wgnu 
 
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DALL -Wno-gnu \
 // RUN:   -Wgnu-anonymous-struct -Wredeclared-class-member \
-// RUN:   -Wgnu-flexible-array-union-member -Wgnu-folding-constant \
-// RUN:   -Wgnu-empty-struct
+// RUN:   -Wgnu-folding-constant -Wgnu-empty-struct
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -DALL -Wno-gnu \
 // RUN:   -Wgnu-anonymous-struct -Wredeclared-class-member \
-// RUN:   -Wgnu-flexible-array-union-member -Wgnu-folding-constant \
-// RUN:   -Wgnu-empty-struct
+// RUN:   -Wgnu-folding-constant -Wgnu-empty-struct
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -DALL -Wno-gnu \
 // RUN:   -Wgnu-anonymous-struct -Wredeclared-class-member \
-// RUN:   -Wgnu-flexible-array-union-member -Wgnu-folding-constant \
-// RUN:   -Wgnu-empty-struct
+// RUN:   -Wgnu-folding-constant -Wgnu-empty-struct
 
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DNONE -Wgnu \
 // RUN:   -Wno-gnu-anonymous-struct -Wno-redeclared-class-member \
-// RUN:   -Wno-gnu-flexible-array-union-member -Wno-gnu-folding-constant \
-// RUN:   -Wno-gnu-empty-struct
+// RUN:   -Wno-gnu-folding-constant -Wno-gnu-empty-struct
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -DNONE -Wgnu \
 // RUN:   -Wno-gnu-anonymous-struct -Wno-redeclared-class-member \
-// RUN:   -Wno-gnu-flexible-array-union-member -Wno-gnu-folding-constant \
-// RUN:   -Wno-gnu-empty-struct
+// RUN:   -Wno-gnu-folding-constant -Wno-gnu-empty-struct
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -DNONE -Wgnu \
 // RUN:   -Wno-gnu-anonymous-struct -Wno-redeclared-class-member \
-// RUN:   -Wno-gnu-flexible-array-union-member -Wno-gnu-folding-constant \
-// RUN:   -Wno-gnu-empty-struct
+// RUN:   -Wno-gnu-folding-constant -Wno-gnu-empty-struct
 
 // Additional disabled tests:
 // %clang_cc1 -fsyntax-only -verify %s -DANONYMOUSSTRUCT -Wno-gnu -Wgnu-anonymous-struct
 // %clang_cc1 -fsyntax-only -verify %s -DREDECLAREDCLASSMEMBER -Wno-gnu -Wredeclared-class-member
-// %clang_cc1 -fsyntax-only -verify %s -DFLEXIBLEARRAYUNIONMEMBER -Wno-gnu -Wgnu-flexible-array-union-member
 // %clang_cc1 -fsyntax-only -verify %s -DFOLDINGCONSTANT -Wno-gnu -Wgnu-folding-constant
 // %clang_cc1 -fsyntax-only -verify %s -DEMPTYSTRUCT -Wno-gnu -Wgnu-empty-struct
 
 #if NONE
 // expected-no-diagnostics
 #endif
 
 

 namespace rcm {
   class A {
     class X;
     class X;
     class X {};
   };
 }
 
-
-#if ALL || FLEXIBLEARRAYUNIONMEMBER
-// expected-warning@+6 {{flexible array member 'c1' in a union is a GNU extension}}
-#endif
-
-struct faum {
-   int l;
-   union {
-       int c1[];
-   };
-};
-
-
 #if (ALL || FOLDINGCONSTANT) && (__cplusplus <= 199711L) // C++03 or earlier modes
 // expected-warning@+4 {{in-class initializer for static data member is not a constant expression; folding it to a constant is a GNU extension}}
 #endif
 
 struct fic {
   static const int B = int(0.75 * 1000 * 1000);
 };
 
 
 #if ALL || EMPTYSTRUCT
 // expected-warning@+3 {{flexible array member 'a' in otherwise empty struct is a GNU extension}}
 #endif
 
 struct ofam {int a[];};
 

clang/test/SemaObjCXX/flexible-array.mm

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
 
 // Test only flexible array member functionality specific to C++.
 
 union VariableSizeUnion {
   int s;
-  char c[];
+  char c[]; //expected-error {{flexible array member 'c' in a union is not allowed}}
 };
 
 @interface LastUnionIvar {
   VariableSizeUnion flexible;
 }
 @end
 
 @interface NotLastUnionIvar {