[C2x] Implement support for empty brace initialization (WG14 N2900 and WG14 N3011)

[aaron.ballman]

Summary

This implements support for allowing {} to consistently zero initialize objects. We already supported most of this work as a GNU extension, but the C2x feature goes beyond what the GNU extension allowed.

The changes in this patch are:

• Removed the -Wgnu-empty-initializer warning group. The extension is now a C2x extension warning instead. Note that use of -Wno-gnu-empty-initializer seems to be quite low in the wild (https://sourcegraph.com/search?q=context%3Aglobal+-file%3A.*test.*+%22-Wno-gnu-empty-initializer%22&patternType=standard&sm=1&groupBy=repo which currently only gives 8 hits total), so this is not expected to be an overly disruptive change. But I'm adding the clang vendors review group just in case this expectation is wrong.
• Reworded the diagnostic wording to be about a C2x extension, added a pre-C2x compat warning
• Allow {} to zero initialize a VLA

This functionality is exposed as an extension in all older C modes (same as the GNU extension was), but does *not* allow the extension for VLA initialization in C++ due to concern about handling non-trivially constructible types.

[aaron.ballman]

Oops, previous diff missed a change that was only locally staged. Fixed.

[aaron.ballman]

Fixed some test failures found by precommit CI.

[aaron.ballman]

Another round of fixing what post commit CI found.

[erichkeane]

So not necessary to this patch, but I suspect the non-trivially constructible types could just be solved the same way we do for zero-init of these types in fixed-size arrays, right? Its a bit more complicated, but the IR is probably just as do-able: https://godbolt.org/z/Gqf65xr8M
There, in the in it of %6 is the only place the length matters, since it looks like we do a 'begin/end' type emit for it. %2 is kept as the 'current element being processed', and %6 is the 'end', and %5 is the 'begin'.

That said, only a few small comments/questions.

clang/lib/CodeGen/CGExprAgg.cpp

1670

I'd probably prefer an assert for 'initializer is empty' here to confirm this, but else this seems fine.

clang/test/C/C2x/n2900_n3011_2.c

42

This is strange... why is this not an error? What is this supposed to mean?

56

These MEM# names are horrible to read :/ But the test is doing the right thing it appears.

97

A VLA of these things still works right? Is that worth a test?

[aaron.ballman]

In D147349#4240847, @erichkeane wrote:

So not necessary to this patch, but I suspect the non-trivially constructible types could just be solved the same way we do for zero-init of these types in fixed-size arrays, right? Its a bit more complicated, but the IR is probably just as do-able: https://godbolt.org/z/Gqf65xr8M
There, in the in it of %6 is the only place the length matters, since it looks like we do a 'begin/end' type emit for it. %2 is kept as the 'current element being processed', and %6 is the 'end', and %5 is the 'begin'.

That said, only a few small comments/questions.

It's possible, but I'm also not convinced extending C++'s already inscrutable initialization rules is a good idea, especially given that it relates to VLAs (which are already a bit questionable as an extension to C++ IMO).

clang/lib/CodeGen/CGExprAgg.cpp

1670

I can add that assert, sure.

clang/test/C/C2x/n2900_n3011_2.c

42

Heh, this one took me a few minutes to convince myself is correct. This creates a zero-length array, which we support as an extension. There's a corresponding Sema test on n2900_n3011.c:18 that shows the behavior of the extension diagnostics in this case.

56

If you have suggestions for better names, I'm happy to use them.

97

I can add a test for that, sure.

[erichkeane]

clang/test/C/C2x/n2900_n3011_2.c

52

so 'entry' isn't really a stable name AFAIK. So this might fail in test configs that do the 'erase names' thing. That said, a buildbot hasn't caught one of those in a long time, so *shrug*.

56

I: I_PTR
MEM0: I_VAL
MEM1: NUM_ELTS (or I_AS_64B?).
MEM3: COPY_BYTES

Though, this all becomes a bit easier with 'i' in code being named num_elts or something.
NUM_ELTS_PTR
NUM_ELTS
NUM_ELTS_EXT
BYTES_TO_COPY

[aaron.ballman]

Update based on review feedback:

• Added an assertion to codegen that a VLA with an initializer is an empty initializer
• Updated the codegen tests to use better identifiers
• Added a codegen test for empty initialization of VLA of structures

clang/docs/ReleaseNotes.rst

 
 - Removed the ``ATOMIC_VAR_INIT`` macro in C2x and later standards modes, which
   implements `WG14 N2886 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2886.htm>`_
 
 - Implemented `WG14 N2934 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2934.pdf>`_
   which introduces the ``bool``, ``static_assert``, ``alignas``, ``alignof``,
   and ``thread_local`` keywords in C2x.
 
+- Implemented `WG14 N2900 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2900.htm>`_
+  and `WG14 N3011 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3011.htm>`_
+  which allows for empty braced initialization in C.
+
+  .. code-block:: c
+
+    struct S { int x, y } s = {}; // Initializes s.x and s.y to 0
+
+  As part of this change, the ``-Wgnu-empty-initializer`` warning group was
+  removed, as this is no longer a GNU extension but a C2x extension. You can
+  use ``-Wno-c2x-extensions`` to silence the extension warning instead.
+
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 - Clang now saves the address of ABI-indirect function parameters on the stack,
   improving the debug information available in programs compiled without
   optimizations.
 - Clang now supports ``__builtin_nondeterministic_value`` that returns a
   nondeterministic value of the same type as the provided argument.
 - Clang now supports ``__builtin_FILE_NAME()`` which returns the same

clang/include/clang/Basic/DiagnosticCommonKinds.td

 def err_enum_template : Error<"enumeration cannot be a template">;
 
 def warn_cxx20_compat_consteval : Warning<
   "'consteval' specifier is incompatible with C++ standards before C++20">,
   InGroup<CXX20Compat>, DefaultIgnore;
 def warn_missing_type_specifier : Warning<
   "type specifier missing, defaults to 'int'">,
   InGroup<ImplicitInt>, DefaultIgnore;
+
+def ext_c_empty_initializer : Extension<
+  "use of an empty initializer is a C2x extension">, InGroup<C2x>;
+def warn_c2x_compat_empty_initializer : Warning<
+  "use of an empty initializer is incompatible with C standards before C2x">,
+  InGroup<CPre2xCompat>, DefaultIgnore;
 }
 
 let CategoryName = "Nullability Issue" in {
 
 def warn_nullability_duplicate : Warning<
   "duplicate nullability specifier %0">,
   InGroup<Nullability>;
 

clang/include/clang/Basic/DiagnosticGroups.td

 def Documentation : DiagGroup<"documentation",
                               [DocumentationHTML,
                                DocumentationDeprecatedSync]>;
 
 def EmptyBody : DiagGroup<"empty-body">;
 def Exceptions : DiagGroup<"exceptions">;
 def DeclarationAfterStatement : DiagGroup<"declaration-after-statement">;
 
-def GNUEmptyInitializer : DiagGroup<"gnu-empty-initializer">;
 def GNUEmptyStruct : DiagGroup<"gnu-empty-struct">;
 def ExtraTokens : DiagGroup<"extra-tokens">;
 def CXX98CompatExtraSemi : DiagGroup<"c++98-compat-extra-semi">;
 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,

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

clang/include/clang/Basic/DiagnosticParseKinds.td

def err_stmtexpr_file_scope : Error<
   "statement expression not allowed at file scope">;
 def ext_gnu_statement_expr : Extension<
   "use of GNU statement expression extension">, InGroup<GNUStatementExpression>;
 def ext_gnu_statement_expr_macro : Extension<
   "use of GNU statement expression extension from macro expansion">,
   InGroup<GNUStatementExpressionFromMacroExpansion>;
 def ext_gnu_conditional_expr : Extension<
   "use of GNU ?: conditional expression extension, omitting middle operand">, InGroup<GNUConditionalOmittedOperand>;
-def ext_gnu_empty_initializer : Extension<
-  "use of GNU empty initializer extension">, InGroup<GNUEmptyInitializer>;
 def ext_gnu_array_range : Extension<"use of GNU array range extension">,
   InGroup<GNUDesignator>;
 def ext_gnu_missing_equal_designator : ExtWarn<
   "use of GNU 'missing =' extension in designator">,
   InGroup<GNUDesignator>;
 def err_expected_equal_designator : Error<"expected '=' or another designator">;
 def ext_gnu_old_style_field_designator : ExtWarn<
   "use of GNU old-style field designator extension">,

clang/lib/CodeGen/CGExprAgg.cpp

#if 0
   }
 #endif
 
   AggValueSlot Dest = EnsureSlot(ExprToVisit->getType());
 
   LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), ExprToVisit->getType());
 
   // Handle initialization of an array.
-  if (ExprToVisit->getType()->isArrayType()) {
+  if (ExprToVisit->getType()->isConstantArrayType()) {
     auto AType = cast<llvm::ArrayType>(Dest.getAddress().getElementType());
     EmitArrayInit(Dest.getAddress(), AType, ExprToVisit->getType(), ExprToVisit,
                   InitExprs, ArrayFiller);
     return;
+  } else if (ExprToVisit->getType()->isVariableArrayType()) {
+    // A variable array type that has an initializer can only do empty
+    // initialization. And because this feature is not exposed as an extension
+    // in C++, we can safely memset the array memory to zero.
+    assert(InitExprs.size() == 0 &&
+           "you can only use an empty initializer with VLAs");
+    CGF.EmitNullInitialization(Dest.getAddress(), ExprToVisit->getType());
+    return;
   }
 
   assert(ExprToVisit->getType()->isRecordType() &&
          "Only support structs/unions here!");
 
   // Do struct initialization; this code just sets each individual member
   // to the approprate value.  This makes bitfield support automatic;
   // the disadvantage is that the generated code is more difficult for

clang/lib/Parse/ParseInit.cpp

 }
 
 /// ParseBraceInitializer - Called when parsing an initializer that has a
 /// leading open brace.
 ///
 ///       initializer: [C99 6.7.8]
 ///         '{' initializer-list '}'
 ///         '{' initializer-list ',' '}'
-/// [GNU]   '{' '}'
+/// [C2x]   '{' '}'
 ///
 ///       initializer-list:
 ///         designation[opt] initializer ...[opt]
 ///         initializer-list ',' designation[opt] initializer ...[opt]
 ///
 ExprResult Parser::ParseBraceInitializer() {
   InMessageExpressionRAIIObject InMessage(*this, false);
 
   BalancedDelimiterTracker T(*this, tok::l_brace);
   T.consumeOpen();
   SourceLocation LBraceLoc = T.getOpenLocation();
 
   /// InitExprs - This is the actual list of expressions contained in the
   /// initializer.
   ExprVector InitExprs;
 
   if (Tok.is(tok::r_brace)) {
-    // Empty initializers are a C++ feature and a GNU extension to C.
-    if (!getLangOpts().CPlusPlus)
-      Diag(LBraceLoc, diag::ext_gnu_empty_initializer);
+    // Empty initializers are a C++ feature and a GNU extension to C before C2x.
+    if (!getLangOpts().CPlusPlus) {
+      Diag(LBraceLoc, getLangOpts().C2x
+                          ? diag::warn_c2x_compat_empty_initializer
+                          : diag::ext_c_empty_initializer);
+    }
     // Match the '}'.
     return Actions.ActOnInitList(LBraceLoc, std::nullopt, ConsumeBrace());
   }
 
   // Enter an appropriate expression evaluation context for an initializer list.
   EnterExpressionEvaluationContext EnterContext(
       Actions, EnterExpressionEvaluationContext::InitList);
 

clang/lib/Sema/SemaExpr.cpp

Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
 
   if (literalType->isArrayType()) {
     if (RequireCompleteSizedType(
             LParenLoc, Context.getBaseElementType(literalType),
             diag::err_array_incomplete_or_sizeless_type,
             SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
       return ExprError();
     if (literalType->isVariableArrayType()) {
-      if (!tryToFixVariablyModifiedVarType(TInfo, literalType, LParenLoc,
-                                           diag::err_variable_object_no_init)) {
+      // C2x 6.7.9p4: An entity of variable length array type shall not be
+      // initialized except by an empty initializer.
+      //
+      // The C extension warnings are issued from ParseBraceInitializer() and
+      // do not need to be issued here. However, we continue to issue an error
+      // in the case there are initializers or we are compiling C++. We allow
+      // use of VLAs in C++, but it's not clear we want to allow {} to zero
+      // init a VLA in C++ in all cases (such as with non-trivial constructors).
+      // FIXME: should we allow this construct in C++ when it makes sense to do
+      // so?
+      std::optional<unsigned> NumInits;
+      if (const auto *ILE = dyn_cast<InitListExpr>(LiteralExpr))
+        NumInits = ILE->getNumInits();
+      if ((LangOpts.CPlusPlus || NumInits.value_or(0)) &&
+          !tryToFixVariablyModifiedVarType(TInfo, literalType, LParenLoc,
+                                           diag::err_variable_object_no_init))
         return ExprError();
-      }
-    }
   } else if (!literalType->isDependentType() &&
              RequireCompleteType(LParenLoc, literalType,
                diag::err_typecheck_decl_incomplete_type,
                SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
     return ExprError();
 
   InitializedEntity Entity
     = InitializedEntity::InitializeCompoundLiteralInit(TInfo);

clang/lib/Sema/SemaInit.cpp

 
 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
                                       InitListExpr *IList, QualType DeclType,
                                       unsigned &Index,
                                       InitListExpr *StructuredList,
                                       unsigned &StructuredIndex) {
   if (Index >= IList->getNumInits()) {
     if (!VerifyOnly) {
+      if (SemaRef.getLangOpts().CPlusPlus) {
         if (DeclType->isSizelessBuiltinType())
           SemaRef.Diag(IList->getBeginLoc(),
                        SemaRef.getLangOpts().CPlusPlus11
                            ? diag::warn_cxx98_compat_empty_sizeless_initializer
                            : diag::err_empty_sizeless_initializer)
               << DeclType << IList->getSourceRange();
         else
           SemaRef.Diag(IList->getBeginLoc(),
                        SemaRef.getLangOpts().CPlusPlus11
                            ? diag::warn_cxx98_compat_empty_scalar_initializer
                            : diag::err_empty_scalar_initializer)
               << IList->getSourceRange();
       }
-    hadError = !SemaRef.getLangOpts().CPlusPlus11;
+    }
+    hadError =
+        SemaRef.getLangOpts().CPlusPlus && !SemaRef.getLangOpts().CPlusPlus11;
     ++Index;
     ++StructuredIndex;
     return;
   }
 
   Expr *expr = IList->getInit(Index);
   if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
     // FIXME: This is invalid, and accepting it causes overload resolution
if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
       ++Index;
       return;
     }
   }
   if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
     // Check for VLAs; in standard C it would be possible to check this
     // earlier, but I don't know where clang accepts VLAs (gcc accepts
     // them in all sorts of strange places).
-    if (!VerifyOnly)
+    bool HasErr = IList->getNumInits() != 0 || SemaRef.getLangOpts().CPlusPlus;
+    if (!VerifyOnly) {
+      // C2x 6.7.9p4: An entity of variable length array type shall not be
+      // initialized except by an empty initializer.
+      //
+      // The C extension warnings are issued from ParseBraceInitializer() and
+      // do not need to be issued here. However, we continue to issue an error
+      // in the case there are initializers or we are compiling C++. We allow
+      // use of VLAs in C++, but it's not clear we want to allow {} to zero
+      // init a VLA in C++ in all cases (such as with non-trivial constructors).
+      // FIXME: should we allow this construct in C++ when it makes sense to do
+      // so?
+      if (HasErr)
         SemaRef.Diag(VAT->getSizeExpr()->getBeginLoc(),
                      diag::err_variable_object_no_init)
             << VAT->getSizeExpr()->getSourceRange();
-    hadError = true;
+    }
+    hadError = HasErr;
     ++Index;
     ++StructuredIndex;
     return;
   }
 
   // We might know the maximum number of elements in advance.
   llvm::APSInt maxElements(elementIndex.getBitWidth(),
                            elementIndex.isUnsigned());

clang/test/C/C2x/n2900_n3011.c

+// RUN: %clang_cc1 -std=c2x -fsyntax-only -Wpre-c2x-compat -verify=compat %s
+// RUN: %clang_cc1 -std=c17 -fsyntax-only -pedantic -Wno-comment -verify=pedantic %s
+
+/* WG14 N2900: yes
+ * Consistent, Warningless, and Intuitive Initialization with {}
+ */
+
+/* WG14 N3011: yes
+ * Consistent, Warningless, and Intuitive Initialization with {}
+ */
+void test(void) {
+  struct S { int x, y; } s = {}; // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+                                    pedantic-warning {{use of an empty initializer is a C2x extension}}
+  int i = {}; // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+                                  pedantic-warning {{use of an empty initializer is a C2x extension}}
+  int j = (int){}; // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+                      pedantic-warning {{use of an empty initializer is a C2x extension}}
+  int unknown_size[] = {}; // pedantic-warning {{zero size arrays are an extension}} \
+                              pedantic-warning {{use of an empty initializer is a C2x extension}} \
+                              compat-warning {{use of an empty initializer is incompatible with C standards before C2x}}
+  int vla[i] = {}; // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+                      pedantic-warning {{use of an empty initializer is a C2x extension}}
+  int *compound_literal_vla = (int[i]){}; // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+                                             pedantic-warning {{use of an empty initializer is a C2x extension}}
+
+  struct T {
+  int i;
+    struct S s;
+  } t1 = { 1, {} }; // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+                       pedantic-warning {{use of an empty initializer is a C2x extension}}
+
+  struct T t2 = {
+    1, {
+      2, {} // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+               pedantic-warning {{use of an empty initializer is a C2x extension}}
+    }
+  };
+
+  struct T t3 = {
+    (int){}, // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+                pedantic-warning {{use of an empty initializer is a C2x extension}}
+    {} // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+          pedantic-warning {{use of an empty initializer is a C2x extension}}
+  };
+
+  // Ensure that zero initialization does what you'd expect in a constant expr.
+  // FIXME: the "not an ICE" warning is incorrect for C2x, but we don't yet
+  // implement WG14 N3038.
+  _Static_assert((int){} == 0, "what?");  // compat-warning {{use of an empty initializer is incompatible with C standards before C2x}} \
+                                             pedantic-warning {{use of an empty initializer is a C2x extension}} \
+                                             pedantic-warning {{expression is not an integer constant expression; folding it to a constant is a GNU extension}}
+}
+

clang/test/C/C2x/n2900_n3011_2.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c2x -verify -emit-llvm %s -o - | FileCheck %s
+// expected-no-diagnostics
+
+struct S { int x, y; };
+struct T {
+  int i;
+  struct S s;
+};
+
+// CHECK: @[[CONST_T1:.+]] = private unnamed_addr constant %struct.T { i32 1, %struct.S zeroinitializer }
+// CHECK: @[[CONST_T2:.+]] = private unnamed_addr constant %struct.T { i32 1, %struct.S { i32 2, i32 0 } }
+
+void test_struct() {
+  struct S s = {};
+  // CHECK: define {{.*}} void @test_struct
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[S:.+]] = alloca %struct.S
+  // CHECK-NEXT: call void @llvm.memset.p0.i64({{.*}}%[[S]], i8 0, i64 8, i1 false)
+}
+
+void test_var() {
+  int i = {};
+  // CHECK: define {{.*}} void @test_var
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[I:.+]] = alloca i32
+  // CHECK-NEXT: store i32 0, ptr %[[I]]
+}
+
+void test_simple_compound_literal() {
+  int j = (int){};
+  // CHECK: define {{.*}} void @test_simple_compound_literal
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[J:.+]] = alloca i32
+  // CHECK-NEXT: %[[COMPOUND:.+]] = alloca i32
+  // CHECK-NEXT: store i32 0, ptr %[[COMPOUND]]
+  // CHECK-NEXT: %[[MEM:.+]] = load i32, ptr %[[COMPOUND]]
+  // CHECK-NEXT: store i32 %[[MEM]], ptr %[[J]]
+}
+
+void test_zero_size_array() {
+  int unknown_size[] = {};
+  // CHECK: define {{.*}} void @test_zero_size_array
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[UNKNOWN:.+]] = alloca [0 x i32]
+}
+
+void test_vla() {
+  int num_elts = 12;
+  int vla[num_elts] = {};
+  // CHECK: define {{.*}} void @test_vla
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[NUM_ELTS_PTR:.+]] = alloca i32
+  // CHECK: %[[VLA_EXPR:.+]] = alloca i64
+  // CHECK-NEXT: store i32 12, ptr %[[NUM_ELTS_PTR]]
+  // CHECK-NEXT: %[[NUM_ELTS:.+]] = load i32, ptr %[[NUM_ELTS_PTR]]
+  // CHECK-NEXT: %[[NUM_ELTS_EXT:.+]] = zext i32 %[[NUM_ELTS]] to i64
+  // CHECK: %[[VLA:.+]] = alloca i32, i64 %[[NUM_ELTS_EXT]]
+  // CHECK-NEXT: store i64 %[[NUM_ELTS_EXT]], ptr %[[VLA_EXPR]]
+  // CHECK-NEXT: %[[BYTES_TO_COPY:.+]] = mul nuw i64 %[[NUM_ELTS_EXT]], 4
+  // CHECK-NEXT: call void @llvm.memset.p0.i64(ptr {{.*}} %[[VLA]], i8 0, i64 %[[BYTES_TO_COPY]], i1 false)
+}
+
+void test_zero_size_vla() {
+  int num_elts = 0;
+  int vla[num_elts] = {};
+  // CHECK: define {{.*}} void @test_zero_size_vla
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[NUM_ELTS_PTR:.+]] = alloca i32
+  // CHECK: %[[VLA_EXPR:.+]] = alloca i64
+  // CHECK-NEXT: store i32 0, ptr %[[NUM_ELTS_PTR]]
+  // CHECK-NEXT: %[[NUM_ELTS:.+]] = load i32, ptr %[[NUM_ELTS_PTR]]
+  // CHECK-NEXT: %[[NUM_ELTS_EXT:.+]] = zext i32 %[[NUM_ELTS]] to i64
+  // CHECK: %[[VLA:.+]] = alloca i32, i64 %[[NUM_ELTS_EXT]]
+  // CHECK-NEXT: store i64 %[[NUM_ELTS_EXT]], ptr %[[VLA_EXPR]]
+  // CHECK-NEXT: %[[BYTES_TO_COPY:.+]] = mul nuw i64 %[[NUM_ELTS_EXT]], 4
+  // CHECK-NEXT: call void @llvm.memset.p0.i64(ptr {{.*}} %[[VLA]], i8 0, i64 %[[BYTES_TO_COPY]], i1 false)
+}
+
+void test_compound_literal_vla() {
+  int num_elts = 12;
+  int *compound_literal_vla = (int[num_elts]){};
+  // CHECK: define {{.*}} void @test_compound_literal_vla
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[NUM_ELTS_PTR:.+]] = alloca i32
+  // CHECK-NEXT: %[[COMP_LIT_VLA:.+]] = alloca ptr
+  // CHECK-NEXT: %[[COMP_LIT:.+]] = alloca i32
+  // CHECK-NEXT: store i32 12, ptr %[[NUM_ELTS_PTR]]
+  // CHECK-NEXT: %[[NUM_ELTS:.+]] = load i32, ptr %[[NUM_ELTS_PTR]]
+  // CHECK-NEXT: %[[NUM_ELTS_EXT:.+]] = zext i32 %[[NUM_ELTS]] to i64
+  // CHECK-NEXT: %[[BYTES_TO_COPY:.+]] = mul nuw i64 %[[NUM_ELTS_EXT]], 4
+  // CHECK-NEXT: call void @llvm.memset.p0.i64(ptr {{.*}} %[[COMP_LIT]], i8 0, i64 %[[BYTES_TO_COPY]], i1 false)
+  // CHECK-NEXT: store ptr %[[COMP_LIT]], ptr %[[COMP_LIT_VLA]]
+}
+
+void test_nested_structs() {
+  struct T t1 = { 1, {} };
+  struct T t2 = { 1, { 2, {} } };
+  struct T t3 = { (int){}, {} };
+  // CHECK: define {{.*}} void @test_nested_structs
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[T1:.+]] = alloca %struct.T
+  // CHECK-NEXT: %[[T2:.+]] = alloca %struct.T
+  // CHECK-NEXT: %[[T3:.+]] = alloca %struct.T
+  // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}} %[[T1]], ptr {{.*}} @[[CONST_T1]], i64 12, i1 false)
+  // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}} %[[T2]], ptr {{.*}} @[[CONST_T2]], i64 12, i1 false)
+  // CHECK-NEXT: call void @llvm.memset.p0.i64(ptr {{.*}} %[[T3]], i8 0, i64 12, i1 false)
+}
+
+void test_vla_of_nested_structs(int num_elts) {
+  struct T t3[num_elts] = {};
+  // CHECK: define {{.*}} void @test_vla_of_nested_structs(i32 noundef %[[NUM_ELTS_PARAM:.+]])
+  // CHECK-NEXT: entry:
+  // CHECK-NEXT: %[[NUM_ELTS_PTR:.+]] = alloca i32
+  // CHECK: %[[VLA_EXPR:.+]] = alloca i64
+  // CHECK-NEXT: store i32 %[[NUM_ELTS_PARAM]], ptr %[[NUM_ELTS_PTR]]
+  // CHECK-NEXT: %[[NUM_ELTS_LOCAL:.+]] = load i32, ptr %[[NUM_ELTS_PTR]]
+  // CHECK-NEXT: %[[NUM_ELTS_EXT:.+]] = zext i32 %[[NUM_ELTS_LOCAL]] to i64
+  // CHECK: %[[VLA:.+]] = alloca %struct.T, i64 %[[NUM_ELTS_EXT]]
+  // CHECK-NEXT: store i64 %[[NUM_ELTS_EXT]], ptr %[[VLA_EXPR]]
+  // CHECK-NEXT: %[[COPY_BYTES:.+]] = mul nuw i64 %[[NUM_ELTS_EXT]], 12
+  // CHECK-NEXT: call void @llvm.memset.p0.i64(ptr {{.*}} %[[VLA]], i8 0, i64 %[[COPY_BYTES]], i1 false)
+}

clang/test/Sema/array-init.c

-// RUN: %clang_cc1 -std=gnu99 -fsyntax-only -pedantic -verify %s
+// RUN: %clang_cc1 -std=gnu99 -fsyntax-only -pedantic -verify=expected,pedantic %s
 // RUN: %clang_cc1 -std=gnu99 -fsyntax-only -Wgnu -Wc11-extensions -verify %s
 // REQUIRES: LP64
 
 extern int foof(void) = 1; // expected-error{{illegal initializer (only variables can be initialized)}}
 
 static int x, y, z;
 
 static int ary[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}}
void test(void) {
   int y1[3] = {
     { 1, 2, 3 } // expected-warning{{excess elements in scalar initializer}}
   };
   int y3[4][3] = {
     { 1, 3, 5 },
     { 2, 4, 6 },
     { 3, 5, 7 },
     { 4, 6, 8 },
-    {  }, // expected-warning{{use of GNU empty initializer extension}} expected-warning{{excess elements in array initializer}}
+    {  }, // pedantic-warning{{use of an empty initializer is a C2x extension}} expected-warning{{excess elements in array initializer}}
   };
   int y4[4][3] = {
     { 1, 3, 5, 2 }, // expected-warning{{excess elements in array initializer}}
     { 4, 6 },
     { 3, 5, 7 },
     { 4, 6, 8 },
   };
 }
#pragma clang diagnostic pop
 
   int i[] = { "Hello "}; // expected-error{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char[7]'}}
   char c2[] = { "Hello", "Good bye" }; //expected-warning{{excess elements in char array initializer}}
 
   int i2[1] = { "Hello" }; //expected-error{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char[6]'}}
   char c3[5] = { "Hello" };
   char c4[4] = { "Hello" }; //expected-warning{{initializer-string for char array is too long}}
 
-  int i3[] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}}
+  int i3[] = {}; //expected-warning{{zero size arrays are an extension}} pedantic-warning{{use of an empty initializer is a C2x extension}}
 }
 
 void variableArrayInit(void) {
   int a = 4;
   char strlit[a] = "foo"; //expected-error{{variable-sized object may not be initialized}}
   int b[a] = { 1, 2, 4 }; //expected-error{{variable-sized object may not be initialized}}
 }
 
 // Pure array tests
 float r1[10] = {{7}}; //expected-warning{{braces around scalar initializer}}
 float r2[] = {{8}}; //expected-warning{{braces around scalar initializer}}
 char r3[][5] = {1,2,3,4,5,6};
 int r3_sizecheck[(sizeof(r3) / sizeof(char[5])) == 2? 1 : -1];
 char r3_2[sizeof r3 == 10 ? 1 : -1];
 float r4[1][2] = {1,{2},3,4}; //expected-warning{{braces around scalar initializer}} expected-warning{{excess elements in array initializer}}
 char r5[][5] = {"aa", "bbb", "ccccc"};
 char r6[sizeof r5 == 15 ? 1 : -1];
 const char r7[] = "zxcv";
 char r8[5] = "5char";
 char r9[5] = "6chars"; //expected-warning{{initializer-string for char array is too long}}
 unsigned char r10[] = __extension__ (_Generic(0, int: (__extension__ "foo" )));
-int r11[0] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}}
+int r11[0] = {}; //expected-warning{{zero size arrays are an extension}} pedantic-warning{{use of an empty initializer is a C2x extension}}
 
 // Some struct tests
 void autoStructTest(void) {
 struct s1 {char a; char b;} t1;
 struct s2 {struct s1 c;} t2 = { t1 };
 // The following is a less than great diagnostic (though it's on par with EDG).
 struct s1 t3[] = {t1, t1, "abc", 0}; //expected-error{{incompatible pointer to integer conversion initializing 'char' with an expression of type 'char[4]'}}
 int t4[sizeof t3 == 6 ? 1 : -1];
 }
 struct foo { int z; } w;
 int bar (void) {
   struct foo z = { w }; //expected-error{{initializing 'int' with an expression of incompatible type 'struct foo'}}
   return z.z;
 }
 struct s3 {void (*a)(void);} t5 = {autoStructTest};
 struct {int a; int b[];} t6 = {1, {1, 2, 3}}; // expected-warning{{flexible array initialization is a GNU extension}} \
 // expected-note{{initialized flexible array member 'b' is here}}
 union {char a; int b;} t7[] = {1, 2, 3};
 int t8[sizeof t7 == (3*sizeof(int)) ? 1 : -1];
 
 struct bittest{int : 31, a, :21, :12, b;};
 struct bittest bittestvar = {1, 2, 3, 4}; //expected-warning{{excess elements in struct initializer}}
 
-// Not completely sure what should happen here...
-int u1 = {}; //expected-warning{{use of GNU empty initializer extension}} expected-error{{scalar initializer cannot be empty}}
+int u1 = {}; //pedantic-warning{{use of an empty initializer is a C2x extension}}
 int u2 = {{3}}; //expected-warning{{too many braces around scalar initializer}}
 
 // PR2362
 void varArray(void) {
   int c[][x] = { 0 }; //expected-error{{variable-sized object may not be initialized}}
 }
 
 // PR2151

clang/test/Sema/complex-init-list.c

 _Complex float valid5 = {1.0f, 1.0fi}; // expected-warning {{imaginary constants}} \
                                        // expected-warning {{specifying real and imaginary components is an extension}}
 
 
 // Random invalid stuff
 struct teststruct invalid1 = { 1, 2 }; // expected-warning {{excess elements}}
 _Complex float invalid2 = { 1, 2, 3 }; // expected-warning {{specifying real and imaginary components is an extension}} \
                                        // expected-warning {{excess elements in scalar initializer}}
-_Complex float invalid3 = {}; // expected-error {{scalar initializer cannot be empty}} \
-                             //  expected-warning {{GNU empty initializer}}
+_Complex float invalid3 = {}; // expected-warning {{use of an empty initializer is a C2x extension}}
 
 
 // Check incomplete array sizing
 _Complex float sizetest1[] = { {1.0f, 1.0f}, {1.0f, 1.0f} }; // expected-warning 2 {{specifying real and imaginary components is an extension}}
 _Complex float sizecheck1[(sizeof(sizetest1) == sizeof(*sizetest1)*2) ? 1 : -1];
 _Complex float sizetest2[] = { 1.0f, 1.0f, {1.0f, 1.0f} };  // expected-warning {{specifying real and imaginary components is an extension}}
 _Complex float sizecheck2[(sizeof(sizetest2) == sizeof(*sizetest2)*3) ? 1 : -1];
 
 // Constant-folding with init list.
 _Complex float x = 2 + (_Complex float) { 1, 2 };  // expected-warning {{specifying real and imaginary components is an extension}}
 
 // initialization list
 _Complex double cd = {1.0, 2.0, 3.0}; // expected-warning {{specifying real and imaginary components is an extension}} \
                                      //  expected-warning {{excess elements in scalar initializer}}
 _Complex float cf = {1.1f, 2.2f, 3.3f, 4.4f}; // expected-warning {{specifying real and imaginary components is an extension}} \
                                              //  expected-warning {{excess elements in scalar initializer}}

clang/test/Sema/compound-literal.c

 // RUN: %clang_cc1 -fsyntax-only -verify -fblocks -pedantic %s
 // REQUIRES: LP64
 
 struct foo { int a, b; };
 
 static struct foo t = (struct foo){0,0};
 static struct foo t1 = __builtin_choose_expr(0, (struct foo){0,0}, (struct foo){0,0});
 static struct foo t2 = {0,0};
 static struct foo t3 = t2; // expected-error {{initializer element is not a compile-time constant}}
 static int *p = (int []){2,4};
 static int x = (int){1};
 
 static int *p2 = (int []){2,x}; // expected-error {{initializer element is not a compile-time constant}}
 static long *p3 = (long []){2,"x"}; // expected-error {{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char[2]'}}
 
 typedef struct { } cache_t; // expected-warning{{empty struct is a GNU extension}}
-static cache_t clo_I1_cache = ((cache_t) { } ); // expected-warning{{use of GNU empty initializer extension}}
+static cache_t clo_I1_cache = ((cache_t) { } ); // expected-warning{{use of an empty initializer is a C2x extension}}
 
 typedef struct Test {int a;int b;} Test;
 static Test* ll = &(Test) {0,0};
 
 extern void fooFunc(struct foo *pfoo);
 
 int main(int argc, char **argv) {
  int *l = (int []){x, *p, *p2};

clang/test/Sema/flexible-array-init.c

 // RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
 struct one {
   int a;
   int values[]; // expected-note 4{{initialized flexible array member 'values' is here}}
 } x = {5, {1, 2, 3}}; // expected-warning{{flexible array initialization is a GNU extension}}
 
 struct one x2 = { 5, 1, 2, 3 }; // expected-warning{{flexible array initialization is a GNU extension}}
 
 void test(void) {
   struct one x3 = {5, {1, 2, 3}}; // expected-error{{initialization of flexible array member is not allowed}}
   struct one x3a = { 5 };
   struct one x3b = { .a = 5 };
-  struct one x3c = { 5, {} }; // expected-warning{{use of GNU empty initializer extension}} \
+  struct one x3c = { 5, {} }; // expected-warning{{use of an empty initializer is a C2x extension}} \
   // expected-warning{{flexible array initialization is a GNU extension}} \
   // expected-warning{{zero size arrays are an extension}}
 }
 
 struct foo { 
   int x; 
   int y[]; // expected-note 8 {{initialized flexible array member 'y' is here}}
 }; 
 struct bar { struct foo z; }; // expected-warning {{'z' may not be nested in a struct due to flexible array member}}
      
 struct foo a = { 1, { 2, 3, 4 } };        // expected-warning{{flexible array initialization is a GNU extension}}
 struct bar b = { { 1, { 2, 3, 4 } } };    // expected-error{{initialization of flexible array member is not allowed}}
 struct bar c = { { 1, { } } };            // // expected-warning{{flexible array initialization is a GNU extension}} \
-              // expected-warning{{use of GNU empty initializer extension}} \
+              // expected-warning{{use of an empty initializer is a C2x extension}} \
               // expected-warning{{zero size arrays are an extension}}
 struct foo d[1] = { { 1, { 2, 3, 4 } } };  // expected-warning{{'struct foo' may not be used as an array element due to flexible array member}} \
               // expected-error{{initialization of flexible array member is not allowed}}
 
 struct foo desig_foo = { .y = {2, 3, 4} }; // expected-warning{{flexible array initialization is a GNU extension}}
-struct bar desig_bar = { .z.y = { } }; // expected-warning{{use of GNU empty initializer extension}} \
+struct bar desig_bar = { .z.y = { } }; // expected-warning{{use of an empty initializer is a C2x extension}} \
   // expected-warning{{zero size arrays are an extension}} \
   // expected-warning{{flexible array initialization is a GNU extension}}
 struct bar desig_bar2 = { .z.y = { 2, 3, 4} }; // expected-error{{initialization of flexible array member is not allowed}}
 struct foo design_foo2 = { .y = 2 }; // expected-error{{flexible array requires brace-enclosed initializer}}
 
 struct point {
   int x, y;
 };

clang/test/Sema/gnu-flags.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s -DNONE -Wno-gnu
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DALL -Wgnu
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DALL -Wno-gnu \
 // RUN:   -Wgnu-alignof-expression -Wgnu-case-range -Wgnu-complex-integer -Wgnu-conditional-omitted-operand \
-// RUN:   -Wgnu-empty-initializer -Wgnu-label-as-value -Wgnu-statement-expression \
+// RUN:   -Wgnu-label-as-value -Wgnu-statement-expression \
 // RUN:   -Wgnu-compound-literal-initializer -Wgnu-flexible-array-initializer \
 // RUN:   -Wgnu-redeclared-enum  -Wgnu-folding-constant -Wgnu-empty-struct \
 // RUN:   -Wgnu-union-cast -Wgnu-variable-sized-type-not-at-end
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DNONE -Wgnu \
 // RUN:   -Wno-gnu-alignof-expression -Wno-gnu-case-range -Wno-gnu-complex-integer -Wno-gnu-conditional-omitted-operand \
-// RUN:   -Wno-gnu-empty-initializer -Wno-gnu-label-as-value -Wno-gnu-statement-expression \
+// RUN:   -Wno-gnu-label-as-value -Wno-gnu-statement-expression \
 // RUN:   -Wno-gnu-compound-literal-initializer -Wno-gnu-flexible-array-initializer \
 // RUN:   -Wno-gnu-redeclared-enum -Wno-gnu-folding-constant -Wno-gnu-empty-struct \
 // RUN:   -Wno-gnu-union-cast -Wno-gnu-variable-sized-type-not-at-end
 // Additional disabled tests:
 // %clang_cc1 -fsyntax-only -verify %s -DALIGNOF -Wno-gnu -Wgnu-alignof-expression
 // %clang_cc1 -fsyntax-only -verify %s -DCASERANGE -Wno-gnu -Wgnu-case-range
 // %clang_cc1 -fsyntax-only -verify %s -DCOMPLEXINT -Wno-gnu -Wgnu-complex-integer
 // %clang_cc1 -fsyntax-only -verify %s -DOMITTEDOPERAND -Wno-gnu -Wgnu-conditional-omitted-operand
-// %clang_cc1 -fsyntax-only -verify %s -DEMPTYINIT -Wno-gnu -Wgnu-empty-initializer
 // %clang_cc1 -fsyntax-only -verify %s -DLABELVALUE -Wno-gnu -Wgnu-label-as-value
 // %clang_cc1 -fsyntax-only -verify %s -DSTATEMENTEXP -Wno-gnu -Wgnu-statement-expression
 // %clang_cc1 -fsyntax-only -verify %s -DSTATEMENTEXPMACRO -Wno-gnu -Wgnu-statement-expression-from-macro-expansion
 // %clang_cc1 -fsyntax-only -verify %s -DCOMPOUNDLITERALINITIALIZER -Wno-gnu -Wgnu-compound-literal-initializer
 // %clang_cc1 -fsyntax-only -verify %s -DFLEXIBLEARRAYINITIALIZER -Wno-gnu -Wgnu-flexible-array-initializer
 // %clang_cc1 -fsyntax-only -verify %s -DREDECLAREDENUM -Wno-gnu -Wgnu-redeclared-enum
 // %clang_cc1 -fsyntax-only -verify %s -DUNIONCAST -Wno-gnu -Wgnu-union-cast
 // %clang_cc1 -fsyntax-only -verify %s -DVARIABLESIZEDTYPENOTATEND -Wno-gnu -Wgnu-variable-sized-type-not-at-end

 
 #if ALL || OMITTEDOPERAND
 // expected-warning@+3 {{use of GNU ?: conditional expression extension, omitting middle operand}}
 #endif
 
 static const char* omittedoperand = (const char*)0 ?: "Null";
 
 
-#if ALL || EMPTYINIT
-// expected-warning@+3 {{use of GNU empty initializer extension}}
-#endif
-
-struct { int x; } emptyinit = {};
-
-
 #if ALL || LABELVALUE
 // expected-warning@+6 {{use of GNU address-of-label extension}}
 // expected-warning@+7 {{use of GNU indirect-goto extension}}
 #endif
 
 void labelvalue(void) {
   void *ptr;
   ptr = &&foo;

clang/test/Sema/sizeless-1.c

void func(int sel) {
 
   local_int8, 0; // expected-warning {{left operand of comma operator has no effect}}
 
   0, local_int8; // expected-warning {{left operand of comma operator has no effect}} expected-warning {{expression result unused}}
 
   svint8_t init_int8 = local_int8;
   svint8_t bad_init_int8 = for; // expected-error {{expected expression}}
 
-  int empty_brace_init_int = {}; // expected-error {{scalar initializer cannot be empty}}
-  svint8_t empty_brace_init_int8 = {}; // expected-error {{initializer for sizeless type 'svint8_t' (aka '__SVInt8_t') cannot be empty}}
+  int empty_brace_init_int = {};
+  svint8_t empty_brace_init_int8 = {};
   svint8_t brace_init_int8 = {local_int8};
   svint8_t bad_brace_init_int8_1 = {local_int8, 0};    // expected-warning {{excess elements in initializer for indivisible sizeless type 'svint8_t'}}
   svint8_t bad_brace_init_int8_2 = {0};                // expected-error {{incompatible type 'int'}}
   svint8_t bad_brace_init_int8_3 = {local_int16};      // expected-error {{incompatible type 'svint16_t'}}
   svint8_t bad_brace_init_int8_4 = {[0] = local_int8}; // expected-error {{designator in initializer for indivisible sizeless type 'svint8_t'}}
   svint8_t bad_brace_init_int8_5 = {{local_int8}};     // expected-warning {{too many braces around initializer}}
   svint8_t bad_brace_init_int8_6 = {{local_int8, 0}};  // expected-warning {{too many braces around initializer}}
 

clang/test/Sema/vla.c

void test_fold_to_constant_array(void) {
   char a1[ksize]; // expected-note{{variable length array}}
  jump_over_a1:;
 
   goto jump_over_a2;
   char a2[ksize] = "foo"; // expected-warning{{variable length array folded to constant array as an extension}}
  jump_over_a2:;
 
   goto jump_over_a3;
-  char a3[ksize] = {}; // expected-warning {{variable length array folded to constant array as an extension}} expected-warning{{use of GNU empty initializer}}
+  char a3[ksize] = {}; // expected-warning {{variable length array folded to constant array as an extension}} expected-warning{{use of an empty initializer is a C2x extension}}
  jump_over_a3:;
 
   goto jump_over_a4; // expected-error{{cannot jump from this goto statement to its label}}
   char a4[ksize][2]; // expected-note{{variable length array}}
  jump_over_a4:;
 
-  char a5[ksize][2] = {}; // expected-warning {{variable length array folded to constant array as an extension}} expected-warning{{use of GNU empty initializer}}
+  char a5[ksize][2] = {}; // expected-warning {{variable length array folded to constant array as an extension}} expected-warning{{use of an empty initializer is a C2x extension}}
 
   int a6[ksize] = {1,2,3,4}; // expected-warning{{variable length array folded to constant array as an extension}}
 
   // expected-warning@+1{{variable length array folded to constant array as an extension}}
   int a7[ksize] __attribute__((annotate("foo"))) = {1,2,3,4};
 
   // expected-warning@+1{{variable length array folded to constant array as an extension}}
   char a8[2][ksize] = {{1,2,3,4},{4,3,2,1}};
 
   // expected-warning@+1{{variable length array folded to constant array as an extension}}
   char (*a9)[] = (char[2][ksize]) {{1,2,3,4},{4,3,2,1}};
 
   char (*a10)[ksize] = 0;
 }

clang/test/SemaObjC/property.m

 + (float) globalValue { return 5.0f; }
 + (float) gv { return test6_getClass().globalValue; }
 @end
 
 @interface Test7
 @property unsigned length;
 @end
 void test7(Test7 *t) {
-  char data[t.length] = {}; // expected-error {{variable-sized object may not be initialized}}
+  char data[t.length] = {};
 }

clang/test/SemaOpenCL/intel-subgroup-avc-ext-types.cl

void foo(char c, float f, void* v, struct st ss) {
   intel_sub_group_avc_ref_payload_t payload_ref = f;
   intel_sub_group_avc_sic_payload_t payload_sic = ss;
   intel_sub_group_avc_mce_result_t result_mce = 0; // No zero initializer for mce types
   intel_sub_group_avc_ime_result_t result_ime = 1; // No literal initializer for *result_t types
   intel_sub_group_avc_ref_result_t result_ref = f;
   intel_sub_group_avc_sic_result_t result_sic = ss;
   intel_sub_group_avc_ime_result_single_reference_streamout_t sstreamout = v;
   intel_sub_group_avc_ime_result_dual_reference_streamout_t dstreamin_list = {0x0, 0x1};
-  intel_sub_group_avc_ime_dual_reference_streamin_t dstreamin_list2 = {};
   intel_sub_group_avc_ime_single_reference_streamin_t dstreamin_list3 = {c};
   intel_sub_group_avc_ime_dual_reference_streamin_t dstreamin_list4 = {1};
 #ifdef EXT
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_mce_payload_t' with an expression of incompatible type 'int'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_ime_payload_t' with an expression of incompatible type 'int'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_ref_payload_t' with an expression of incompatible type '__private float'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_sic_payload_t' with an expression of incompatible type '__private struct st'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_mce_result_t' with an expression of incompatible type 'int'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_ime_result_t' with an expression of incompatible type 'int'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_ref_result_t' with an expression of incompatible type '__private float'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_sic_result_t' with an expression of incompatible type '__private struct st'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_ime_result_single_reference_streamout_t' with an expression of incompatible type '__private void *__private'}}
-// expected-warning@-14 {{excess elements in struct initializer}}
-// expected-error@-14 {{scalar initializer cannot be empty}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_ime_single_reference_streamin_t' with an expression of incompatible type '__private char'}}
-// expected-error@-14 {{initializing '__private intel_sub_group_avc_ime_dual_reference_streamin_t' with an expression of incompatible type 'int'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_mce_payload_t' with an expression of incompatible type 'int'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_ime_payload_t' with an expression of incompatible type 'int'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_ref_payload_t' with an expression of incompatible type '__private float'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_sic_payload_t' with an expression of incompatible type '__private struct st'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_mce_result_t' with an expression of incompatible type 'int'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_ime_result_t' with an expression of incompatible type 'int'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_ref_result_t' with an expression of incompatible type '__private float'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_sic_result_t' with an expression of incompatible type '__private struct st'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_ime_result_single_reference_streamout_t' with an expression of incompatible type '__private void *__private'}}
+// expected-warning@-13 {{excess elements in struct initializer}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_ime_single_reference_streamin_t' with an expression of incompatible type '__private char'}}
+// expected-error@-13 {{initializing '__private intel_sub_group_avc_ime_dual_reference_streamin_t' with an expression of incompatible type 'int'}}
 #else
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_mce_payload_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_payload_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ref_payload_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_sic_payload_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_mce_result_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ref_result_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_sic_result_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_single_reference_streamout_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_dual_reference_streamout_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_dual_reference_streamin_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_single_reference_streamin_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_dual_reference_streamin_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_mce_payload_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_ime_payload_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_ref_payload_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_sic_payload_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_mce_result_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_ref_result_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_sic_result_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_single_reference_streamout_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_dual_reference_streamout_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_ime_single_reference_streamin_t'}}
+// expected-error@-26 {{use of undeclared identifier 'intel_sub_group_avc_ime_dual_reference_streamin_t'}}
 #endif
 }
 
 // negative tests for initializers and assignment
 void far() {
   intel_sub_group_avc_mce_payload_t payload_mce;
   intel_sub_group_avc_mce_payload_t payload_mce2 = payload_mce;
   intel_sub_group_avc_ime_payload_t payload_ime;

clang/www/c_status.html

<tr>
       <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2882.pdf">N2882</a></td>
       <td class="unknown" align="center">Unknown</td>
     </tr>
     <tr id="InitializationWithCurlyBraces">
       <td rowspan="3">Consistent, Warningless, and Intuitive Initialization with {}</td>
     </tr>
       <tr> <!-- Feb 2022 -->
         <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2900.htm">N2900</a></td>
-        <td class="unknown" align="center">Unknown</td>
+        <td class="unreleased" align="center">Clang 17</td>
       </tr>
       <tr> <!-- Jul 2022 -->
         <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3011.htm">N3011</a></td>
-        <td class="unknown" align="center">Unknown</td>
+        <td class="unreleased" align="center">Clang 17</td>
       </tr>
     <tr id="typeof">
       <td rowspan="3">Not-so-magic: typeof</td>
     </tr>
       <tr> <!-- Feb 2022 -->
         <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2927.htm">N2927</a></td>
         <td class="unreleased" align="center">Clang 16</td>
       </tr>