Thanks!
Maybe the diag text for this case could be a bit friendlier :)
On Thu, Oct 29, 2020 at 10:41 PM Richard Smith <rich...@metafoo.co.uk>
wrote:
> On Thu, 29 Oct 2020 at 19:32, Nico Weber <tha...@chromium.org> wrote:
>
>> On Thu, Oct 29, 2020 at 6:10 PM Richard Smith <rich...@metafoo.co.uk>
>> wrote:
>>
>>> On Thu, 29 Oct 2020 at 08:07, Nico Weber <tha...@chromium.org> wrote:
>>>
>>>> Hi Richard,
>>>>
>>>> this fires on
>>>>
>>>> thakis@thakis:~/src/llvm-project$ cat foo.m
>>>> static const int gSignals[] = { 0, 1, 2, 3, 4 };
>>>> static const int kNumSignals = sizeof(gSignals) / sizeof(gSignals[0]);
>>>> static int gPreviousSignalHandlers[kNumSignals];
>>>>
>>>> thakis@thakis:~/src/llvm-project$ out/gn/bin/clang -c foo.m
>>>> foo.m:3:12: warning: variable length array folded to constant array as
>>>> an extension [-Wgnu-folding-constant]
>>>> static int gPreviousSignalHandlers[kNumSignals];
>>>> ^
>>>> 1 warning generated.
>>>>
>>>>
>>>> Is that intentional? I don't see the VLA there.
>>>>
>>>
>>> gPreviousSignalHandlers is a VLA. Unlike C++, C doesn't permit the use
>>> of a 'const int' variable in a constant expression.
>>>
>>
>> What's the suggested alternative?
>>
>
> This should work reliably:
>
> -static const int kNumSignals = sizeof(gSignals) / sizeof(gSignals[0]);
> +enum { kNumSignals = sizeof(gSignals) / sizeof(gSignals[0]) };
>
>
>> On Fri, Oct 16, 2020 at 5:34 PM Richard Smith via cfe-commits <
>>>> cfe-commits@lists.llvm.org> wrote:
>>>>
>>>>>
>>>>> Author: Richard Smith
>>>>> Date: 2020-10-16T14:34:35-07:00
>>>>> New Revision: 552c6c2328723a248c2b4d2765f75d49129dff20
>>>>>
>>>>> URL:
>>>>> https://github.com/llvm/llvm-project/commit/552c6c2328723a248c2b4d2765f75d49129dff20
>>>>> DIFF:
>>>>> https://github.com/llvm/llvm-project/commit/552c6c2328723a248c2b4d2765f75d49129dff20.diff
>>>>>
>>>>> LOG: PR44406: Follow behavior of array bound constant folding in more
>>>>> recent versions of GCC.
>>>>>
>>>>> Old GCC used to aggressively fold VLAs to constant-bound arrays at
>>>>> block
>>>>> scope in GNU mode. That's non-conforming, and more modern versions of
>>>>> GCC only do this at file scope. Update Clang to do the same.
>>>>>
>>>>> Also promote the warning for this from off-by-default to on-by-default
>>>>> in all cases; more recent versions of GCC likewise warn on this by
>>>>> default.
>>>>>
>>>>> This is still slightly more permissive than GCC, as pointed out in
>>>>> PR44406, as we still fold VLAs to constant arrays in structs, but that
>>>>> seems justifiable given that we don't support VLA-in-struct (and don't
>>>>> intend to ever support it), but GCC does.
>>>>>
>>>>> Differential Revision: https://reviews.llvm.org/D89523
>>>>>
>>>>> Added:
>>>>>
>>>>>
>>>>> Modified:
>>>>> clang/docs/UsersManual.rst
>>>>> clang/include/clang/Basic/DiagnosticSemaKinds.td
>>>>> clang/lib/Sema/SemaDecl.cpp
>>>>> clang/lib/Sema/SemaType.cpp
>>>>> clang/test/CXX/basic/basic.types/p10.cpp
>>>>> clang/test/CXX/drs/dr3xx.cpp
>>>>> clang/test/CodeGen/vla.c
>>>>> clang/test/Misc/warning-flags.c
>>>>> clang/test/PCH/cxx-constexpr.cpp
>>>>> clang/test/Profile/misexpect-switch-default.c
>>>>> clang/test/Profile/misexpect-switch-nonconst.c
>>>>> clang/test/Profile/misexpect-switch-only-default-case.c
>>>>> clang/test/Profile/misexpect-switch.c
>>>>> clang/test/Sema/builtin-assume.c
>>>>> clang/test/Sema/builtins.c
>>>>> clang/test/Sema/complex-int.c
>>>>> clang/test/Sema/const-eval-64.c
>>>>> clang/test/Sema/const-eval.c
>>>>> clang/test/Sema/darwin-align-cast.c
>>>>> clang/test/Sema/decl-in-prototype.c
>>>>> clang/test/Sema/gnu-flags.c
>>>>> clang/test/Sema/i-c-e.c
>>>>> clang/test/Sema/offsetof-64.c
>>>>> clang/test/Sema/rounding-math.c
>>>>> clang/test/Sema/struct-decl.c
>>>>> clang/test/Sema/typedef-variable-type.c
>>>>> clang/test/Sema/vla.c
>>>>> clang/test/SemaCXX/anonymous-struct.cpp
>>>>> clang/test/SemaCXX/constant-expression.cpp
>>>>> clang/test/SemaCXX/cxx1z-noexcept-function-type.cpp
>>>>> clang/test/SemaCXX/i-c-e-cxx.cpp
>>>>> clang/test/SemaObjC/gcc-cast-ext.m
>>>>>
>>>>> Removed:
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> ################################################################################
>>>>> diff --git a/clang/docs/UsersManual.rst b/clang/docs/UsersManual.rst
>>>>> index 473fbb6d8d04..9726a25f7f63 100644
>>>>> --- a/clang/docs/UsersManual.rst
>>>>> +++ b/clang/docs/UsersManual.rst
>>>>> @@ -2502,10 +2502,6 @@ Differences between all ``c*`` and ``gnu*``
>>>>> modes:
>>>>> - The Apple "blocks" extension is recognized by default in ``gnu*``
>>>>> modes
>>>>> on some platforms; it can be enabled in any mode with the
>>>>> ``-fblocks``
>>>>> option.
>>>>> -- Arrays that are VLA's according to the standard, but which can be
>>>>> - constant folded by the frontend are treated as fixed size arrays.
>>>>> - This occurs for things like "int X[(1, 2)];", which is technically
>>>>> a
>>>>> - VLA. ``c*`` modes are strictly compliant and treat these as VLAs.
>>>>>
>>>>> Differences between ``*89`` and ``*94`` modes:
>>>>>
>>>>> @@ -2594,10 +2590,12 @@ Intentionally unsupported GCC extensions
>>>>> the extension appears to be rarely used. Note that clang *does*
>>>>> support flexible array members (arrays with a zero or unspecified
>>>>> size at the end of a structure).
>>>>> -- clang does not have an equivalent to gcc's "fold"; this means that
>>>>> - clang doesn't accept some constructs gcc might accept in contexts
>>>>> - where a constant expression is required, like "x-x" where x is a
>>>>> - variable.
>>>>> +- GCC accepts many expression forms that are not valid integer
>>>>> constant
>>>>> + expressions in bit-field widths, enumerator constants, case labels,
>>>>> + and in array bounds at global scope. Clang also accepts additional
>>>>> + expression forms in these contexts, but constructs that GCC
>>>>> accepts due to
>>>>> + simplifications GCC performs while parsing, such as ``x - x``
>>>>> (where ``x`` is a
>>>>> + variable) will likely never be accepted by Clang.
>>>>> - clang does not support ``__builtin_apply`` and friends; this
>>>>> extension
>>>>> is extremely obscure and
>>>>> diff icult to implement reliably.
>>>>>
>>>>>
>>>>> diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td
>>>>> b/clang/include/clang/Basic/DiagnosticSemaKinds.td
>>>>> index b3b3bc723863..90a48ad7e93c 100644
>>>>> --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
>>>>> +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
>>>>> @@ -137,8 +137,9 @@ def err_vla_decl_has_static_storage : Error<
>>>>> "variable length array declaration cannot have 'static' storage
>>>>> duration">;
>>>>> def err_vla_decl_has_extern_linkage : Error<
>>>>> "variable length array declaration cannot have 'extern' linkage">;
>>>>> -def ext_vla_folded_to_constant : Extension<
>>>>> - "variable length array folded to constant array as an extension">,
>>>>> InGroup<GNUFoldingConstant>;
>>>>> +def ext_vla_folded_to_constant : ExtWarn<
>>>>> + "variable length array folded to constant array as an extension">,
>>>>> + InGroup<GNUFoldingConstant>;
>>>>> def err_vla_unsupported : Error<
>>>>> "variable length arrays are not supported for the current target">;
>>>>> def note_vla_unsupported : Note<
>>>>> @@ -5474,8 +5475,6 @@ def warn_flag_enum_constant_out_of_range :
>>>>> Warning<
>>>>> "enumeration value %0 is out of range of flags in enumeration type
>>>>> %1">,
>>>>> InGroup<FlagEnum>;
>>>>>
>>>>> -def warn_illegal_constant_array_size : Extension<
>>>>> - "size of static array must be an integer constant expression">;
>>>>> def err_vm_decl_in_file_scope : Error<
>>>>> "variably modified type declaration not allowed at file scope">;
>>>>> def err_vm_decl_has_extern_linkage : Error<
>>>>>
>>>>> diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
>>>>> index 8542c20ec069..5a38a9585d30 100644
>>>>> --- a/clang/lib/Sema/SemaDecl.cpp
>>>>> +++ b/clang/lib/Sema/SemaDecl.cpp
>>>>> @@ -5932,9 +5932,14 @@ static QualType
>>>>> TryToFixInvalidVariablyModifiedType(QualType T,
>>>>> const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
>>>>> if (!VLATy)
>>>>> return QualType();
>>>>> - // FIXME: We should probably handle this case
>>>>> - if (VLATy->getElementType()->isVariablyModifiedType())
>>>>> - return QualType();
>>>>> +
>>>>> + QualType ElemTy = VLATy->getElementType();
>>>>> + if (ElemTy->isVariablyModifiedType()) {
>>>>> + ElemTy = TryToFixInvalidVariablyModifiedType(ElemTy, Context,
>>>>> + SizeIsNegative,
>>>>> Oversized);
>>>>> + if (ElemTy.isNull())
>>>>> + return QualType();
>>>>> + }
>>>>>
>>>>> Expr::EvalResult Result;
>>>>> if (!VLATy->getSizeExpr() ||
>>>>> @@ -5950,16 +5955,18 @@ static QualType
>>>>> TryToFixInvalidVariablyModifiedType(QualType T,
>>>>> }
>>>>>
>>>>> // Check whether the array is too large to be addressed.
>>>>> - unsigned ActiveSizeBits
>>>>> - = ConstantArrayType::getNumAddressingBits(Context,
>>>>> VLATy->getElementType(),
>>>>> - Res);
>>>>> + unsigned ActiveSizeBits =
>>>>> + (!ElemTy->isDependentType() &&
>>>>> !ElemTy->isVariablyModifiedType() &&
>>>>> + !ElemTy->isIncompleteType() && !ElemTy->isUndeducedType())
>>>>> + ? ConstantArrayType::getNumAddressingBits(Context, ElemTy,
>>>>> Res)
>>>>> + : Res.getActiveBits();
>>>>> if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
>>>>> Oversized = Res;
>>>>> return QualType();
>>>>> }
>>>>>
>>>>> - return Context.getConstantArrayType(
>>>>> - VLATy->getElementType(), Res, VLATy->getSizeExpr(),
>>>>> ArrayType::Normal, 0);
>>>>> + return Context.getConstantArrayType(ElemTy, Res,
>>>>> VLATy->getSizeExpr(),
>>>>> + ArrayType::Normal, 0);
>>>>> }
>>>>>
>>>>> static void
>>>>> @@ -5985,7 +5992,13 @@ FixInvalidVariablyModifiedTypeLoc(TypeLoc
>>>>> SrcTL, TypeLoc DstTL) {
>>>>> ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
>>>>> TypeLoc SrcElemTL = SrcATL.getElementLoc();
>>>>> TypeLoc DstElemTL = DstATL.getElementLoc();
>>>>> - DstElemTL.initializeFullCopy(SrcElemTL);
>>>>> + if (VariableArrayTypeLoc SrcElemATL =
>>>>> + SrcElemTL.getAs<VariableArrayTypeLoc>()) {
>>>>> + ConstantArrayTypeLoc DstElemATL =
>>>>> DstElemTL.castAs<ConstantArrayTypeLoc>();
>>>>> + FixInvalidVariablyModifiedTypeLoc(SrcElemATL, DstElemATL);
>>>>> + } else {
>>>>> + DstElemTL.initializeFullCopy(SrcElemTL);
>>>>> + }
>>>>> DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
>>>>> DstATL.setSizeExpr(SrcATL.getSizeExpr());
>>>>> DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
>>>>> @@ -6115,7 +6128,7 @@ Sema::CheckTypedefForVariablyModifiedType(Scope
>>>>> *S, TypedefNameDecl *NewTD) {
>>>>> SizeIsNegative,
>>>>> Oversized);
>>>>> if (FixedTInfo) {
>>>>> - Diag(NewTD->getLocation(),
>>>>> diag::warn_illegal_constant_array_size);
>>>>> + Diag(NewTD->getLocation(), diag::ext_vla_folded_to_constant);
>>>>> NewTD->setTypeSourceInfo(FixedTInfo);
>>>>> } else {
>>>>> if (SizeIsNegative)
>>>>> @@ -7984,7 +7997,7 @@ void Sema::CheckVariableDeclarationType(VarDecl
>>>>> *NewVD) {
>>>>> return;
>>>>> }
>>>>>
>>>>> - Diag(NewVD->getLocation(),
>>>>> diag::warn_illegal_constant_array_size);
>>>>> + Diag(NewVD->getLocation(), diag::ext_vla_folded_to_constant);
>>>>> NewVD->setType(FixedT);
>>>>> NewVD->setTypeSourceInfo(FixedTInfo);
>>>>> }
>>>>> @@ -16675,7 +16688,7 @@ FieldDecl
>>>>> *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
>>>>> SizeIsNegative,
>>>>> Oversized);
>>>>> if (FixedTInfo) {
>>>>> - Diag(Loc, diag::warn_illegal_constant_array_size);
>>>>> + Diag(Loc, diag::ext_vla_folded_to_constant);
>>>>> TInfo = FixedTInfo;
>>>>> T = FixedTInfo->getType();
>>>>> } else {
>>>>>
>>>>> diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
>>>>> index 5eb05bfcaee3..390b457792fe 100644
>>>>> --- a/clang/lib/Sema/SemaType.cpp
>>>>> +++ b/clang/lib/Sema/SemaType.cpp
>>>>> @@ -2273,13 +2273,9 @@ static ExprResult checkArraySize(Sema &S, Expr
>>>>> *&ArraySize,
>>>>> }
>>>>> } Diagnoser(VLADiag, VLAIsError);
>>>>>
>>>>> - // FIXME: GCC does *not* allow folding here in general; see PR44406.
>>>>> - // For GCC compatibility, we should remove this folding and leave
>>>>> it to
>>>>> - // TryFixVariablyModifiedType to convert VLAs to constant array
>>>>> types.
>>>>> ExprResult R = S.VerifyIntegerConstantExpression(
>>>>> ArraySize, &SizeVal, Diagnoser,
>>>>> - (S.LangOpts.GNUMode || S.LangOpts.OpenCL) ? Sema::AllowFold
>>>>> - : Sema::NoFold);
>>>>> + S.LangOpts.OpenCL ? Sema::AllowFold : Sema::NoFold);
>>>>> if (Diagnoser.IsVLA)
>>>>> return ExprResult();
>>>>> return R;
>>>>>
>>>>> diff --git a/clang/test/CXX/basic/basic.types/p10.cpp
>>>>> b/clang/test/CXX/basic/basic.types/p10.cpp
>>>>> index 31ef6b62cead..124a489dfebe 100644
>>>>> --- a/clang/test/CXX/basic/basic.types/p10.cpp
>>>>> +++ b/clang/test/CXX/basic/basic.types/p10.cpp
>>>>> @@ -139,6 +139,7 @@ constexpr int f(ArrBad) { return 0; } //
>>>>> expected-error {{1st parameter type 'Ar
>>>>> constexpr int arb(int n) {
>>>>> int a[n]; // expected-error {{variable of non-literal type 'int
>>>>> [n]' cannot be defined in a constexpr function}}
>>>>> }
>>>>> +// expected-warning@+1 {{variable length array folded to constant
>>>>> array as an extension}}
>>>>> constexpr long Overflow[ // expected-error {{constexpr variable
>>>>> cannot have non-literal type 'long const[(1 << 30) << 2]'}}
>>>>> (1 << 30) << 2]{}; // expected-warning {{requires 34 bits to
>>>>> represent}}
>>>>>
>>>>>
>>>>> diff --git a/clang/test/CXX/drs/dr3xx.cpp
>>>>> b/clang/test/CXX/drs/dr3xx.cpp
>>>>> index f297d5e930d0..be3169ceab76 100644
>>>>> --- a/clang/test/CXX/drs/dr3xx.cpp
>>>>> +++ b/clang/test/CXX/drs/dr3xx.cpp
>>>>> @@ -898,8 +898,8 @@ namespace dr367 { // dr367: yes
>>>>> int c[true ? *new int : 4]; // expected-error 2{{variable length
>>>>> array}} expected-note {{read of uninitialized}}
>>>>> int d[true ? 4 : *new int];
>>>>> #if __cplusplus < 201103L
>>>>> - // expected-error@-4 {{variable length array}} expected-error@-4
>>>>> {{constant expression}}
>>>>> - // expected-error@-3 {{variable length array}} expected-error@-3
>>>>> {{constant expression}}
>>>>> + // expected-error@-4 2{{variable length array}}
>>>>> + // expected-error@-3 2{{variable length array}}
>>>>> #endif
>>>>> }
>>>>>
>>>>>
>>>>> diff --git a/clang/test/CodeGen/vla.c b/clang/test/CodeGen/vla.c
>>>>> index 3142050149aa..ab7dac67d8d2 100644
>>>>> --- a/clang/test/CodeGen/vla.c
>>>>> +++ b/clang/test/CodeGen/vla.c
>>>>> @@ -210,3 +210,15 @@ void test9(int n, int a[static n]) { }
>>>>> void test10(int a[static 0]) {}
>>>>> // NULL-INVALID: define void @test10(i32* nonnull align 4 %a)
>>>>> // NULL-VALID: define void @test10(i32* align 4 %a)
>>>>> +
>>>>> +const int constant = 32;
>>>>> +// CHECK: define {{.*}}pr44406(
>>>>> +int pr44406() {
>>>>> + int n = 0;
>>>>> + // Do not fold this VLA to an array of constant bound; that would
>>>>> miscompile
>>>>> + // this testcase.
>>>>> + char c[1][(constant - constant) + 3];
>>>>> + // CHECK: store i32 1,
>>>>> + sizeof(c[n = 1]);
>>>>> + return n;
>>>>> +}
>>>>>
>>>>> diff --git a/clang/test/Misc/warning-flags.c
>>>>> b/clang/test/Misc/warning-flags.c
>>>>> index e4f9069b88c8..54e36e1e0884 100644
>>>>> --- a/clang/test/Misc/warning-flags.c
>>>>> +++ b/clang/test/Misc/warning-flags.c
>>>>> @@ -91,4 +91,4 @@ CHECK-NEXT: warn_weak_import
>>>>>
>>>>> The list of warnings in -Wpedantic should NEVER grow.
>>>>>
>>>>> -CHECK: Number in -Wpedantic (not covered by other -W flags): 27
>>>>> +CHECK: Number in -Wpedantic (not covered by other -W flags): 26
>>>>>
>>>>> diff --git a/clang/test/PCH/cxx-constexpr.cpp
>>>>> b/clang/test/PCH/cxx-constexpr.cpp
>>>>> index cce3fd851217..6ec1c8467e07 100644
>>>>> --- a/clang/test/PCH/cxx-constexpr.cpp
>>>>> +++ b/clang/test/PCH/cxx-constexpr.cpp
>>>>> @@ -16,7 +16,7 @@ const int b = a;
>>>>> #else
>>>>>
>>>>> const int a = 5;
>>>>> -typedef int T[b]; // expected-error {{variable length array}}
>>>>> expected-error {{must be an integer constant expression}} expected-note
>>>>> {{initializer of 'b'}}
>>>>> +typedef int T[b]; // expected-error 2{{variable length array}}
>>>>> expected-note {{initializer of 'b'}}
>>>>> // expected-note@14 {{here}}
>>>>> typedef int T[5];
>>>>>
>>>>>
>>>>> diff --git a/clang/test/Profile/misexpect-switch-default.c
>>>>> b/clang/test/Profile/misexpect-switch-default.c
>>>>> index 3d1079d79f96..900c0a5df31f 100644
>>>>> --- a/clang/test/Profile/misexpect-switch-default.c
>>>>> +++ b/clang/test/Profile/misexpect-switch-default.c
>>>>> @@ -10,7 +10,7 @@ void init_arry();
>>>>>
>>>>> const int inner_loop = 1000;
>>>>> const int outer_loop = 20;
>>>>> -const int arry_size = 25;
>>>>> +enum { arry_size = 25 };
>>>>>
>>>>> int arry[arry_size] = {0};
>>>>>
>>>>>
>>>>> diff --git a/clang/test/Profile/misexpect-switch-nonconst.c
>>>>> b/clang/test/Profile/misexpect-switch-nonconst.c
>>>>> index fb719c5a2d1d..1573df538ac2 100644
>>>>> --- a/clang/test/Profile/misexpect-switch-nonconst.c
>>>>> +++ b/clang/test/Profile/misexpect-switch-nonconst.c
>>>>> @@ -11,7 +11,7 @@ void init_arry();
>>>>>
>>>>> const int inner_loop = 1000;
>>>>> const int outer_loop = 20;
>>>>> -const int arry_size = 25;
>>>>> +enum { arry_size = 25 };
>>>>>
>>>>> int arry[arry_size] = {0};
>>>>>
>>>>>
>>>>> diff --git a/clang/test/Profile/misexpect-switch-only-default-case.c
>>>>> b/clang/test/Profile/misexpect-switch-only-default-case.c
>>>>> index 3886472e2b45..d6c68f07d092 100644
>>>>> --- a/clang/test/Profile/misexpect-switch-only-default-case.c
>>>>> +++ b/clang/test/Profile/misexpect-switch-only-default-case.c
>>>>> @@ -11,7 +11,7 @@ void init_arry();
>>>>>
>>>>> const int inner_loop = 1000;
>>>>> const int outer_loop = 20;
>>>>> -const int arry_size = 25;
>>>>> +enum { arry_size = 25 };
>>>>>
>>>>> int arry[arry_size] = {0};
>>>>>
>>>>>
>>>>> diff --git a/clang/test/Profile/misexpect-switch.c
>>>>> b/clang/test/Profile/misexpect-switch.c
>>>>> index a7f01bcc9986..c4fa5f90d440 100644
>>>>> --- a/clang/test/Profile/misexpect-switch.c
>>>>> +++ b/clang/test/Profile/misexpect-switch.c
>>>>> @@ -10,7 +10,7 @@ void init_arry();
>>>>>
>>>>> const int inner_loop = 1000;
>>>>> const int outer_loop = 20;
>>>>> -const int arry_size = 25;
>>>>> +enum { arry_size = 25 };
>>>>>
>>>>> int arry[arry_size] = {0};
>>>>>
>>>>>
>>>>> diff --git a/clang/test/Sema/builtin-assume.c
>>>>> b/clang/test/Sema/builtin-assume.c
>>>>> index 43b31375f200..932fb5c973eb 100644
>>>>> --- a/clang/test/Sema/builtin-assume.c
>>>>> +++ b/clang/test/Sema/builtin-assume.c
>>>>> @@ -23,7 +23,7 @@ int foo(int *a, int i) {
>>>>> __builtin_assume(ispure(i) > 2);
>>>>> __builtin_assume(ispure(++i) > 2); //expected-warning {{the
>>>>> argument to '__builtin_assume' has side effects that will be discarded}}
>>>>>
>>>>> - int test = sizeof(struct{char qq[(__builtin_assume(i != 5), 7)];});
>>>>> + int test = sizeof(struct{char qq[(__builtin_assume(i != 5), 7)];});
>>>>> // expected-warning {{variable length array}}
>>>>> #endif
>>>>> return a[i];
>>>>> }
>>>>>
>>>>> diff --git a/clang/test/Sema/builtins.c b/clang/test/Sema/builtins.c
>>>>> index e4093edb5f00..e534f4727252 100644
>>>>> --- a/clang/test/Sema/builtins.c
>>>>> +++ b/clang/test/Sema/builtins.c
>>>>> @@ -141,7 +141,7 @@ typedef __typeof(sizeof(int)) size_t;
>>>>> size_t strlen(const char *);
>>>>>
>>>>> void test17() {
>>>>> -#define ASSERT(...) { int arr[(__VA_ARGS__) ? 1 : -1]; }
>>>>> +#define ASSERT(...) { enum { folded = (__VA_ARGS__) }; int arr[folded
>>>>> ? 1 : -1]; }
>>>>> #define T(...) ASSERT(__builtin_constant_p(__VA_ARGS__))
>>>>> #define F(...) ASSERT(!__builtin_constant_p(__VA_ARGS__))
>>>>>
>>>>> @@ -179,12 +179,12 @@ void test17() {
>>>>> ASSERT(!OPT("abcd"));
>>>>> // In these cases, the strlen is non-constant, but the
>>>>> __builtin_constant_p
>>>>> // is 0: the array size is not an ICE but is foldable.
>>>>> - ASSERT(!OPT(test17_c)); // expected-warning {{folded}}
>>>>> - ASSERT(!OPT(&test17_c[0])); // expected-warning {{folded}}
>>>>> - ASSERT(!OPT((char*)test17_c)); // expected-warning {{folded}}
>>>>> - ASSERT(!OPT(test17_d)); // expected-warning {{folded}}
>>>>> - ASSERT(!OPT(&test17_d[0])); // expected-warning {{folded}}
>>>>> - ASSERT(!OPT((char*)test17_d)); // expected-warning {{folded}}
>>>>> + ASSERT(!OPT(test17_c)); // expected-warning {{folding}}
>>>>> + ASSERT(!OPT(&test17_c[0])); // expected-warning {{folding}}
>>>>> + ASSERT(!OPT((char*)test17_c)); // expected-warning {{folding}}
>>>>> + ASSERT(!OPT(test17_d)); // expected-warning {{folding}}
>>>>> + ASSERT(!OPT(&test17_d[0])); // expected-warning {{folding}}
>>>>> + ASSERT(!OPT((char*)test17_d)); // expected-warning {{folding}}
>>>>>
>>>>> #undef OPT
>>>>> #undef T
>>>>>
>>>>> diff --git a/clang/test/Sema/complex-int.c
>>>>> b/clang/test/Sema/complex-int.c
>>>>> index f73b338c4010..4f7093256db5 100644
>>>>> --- a/clang/test/Sema/complex-int.c
>>>>> +++ b/clang/test/Sema/complex-int.c
>>>>> @@ -60,14 +60,16 @@ void test5(_Complex int *x) {
>>>>> (*x)++;
>>>>> }
>>>>>
>>>>> -int i1[(2+3i)*(5+7i) == 29i-11 ? 1 : -1];
>>>>> -int i2[(29i-11)/(5+7i) == 2+3i ? 1 : -1];
>>>>> -int i3[-(2+3i) == +(-3i-2) ? 1 : -1];
>>>>> -int i4[~(2+3i) == 2-3i ? 1 : -1];
>>>>> -int i5[(3i == -(-3i) ? ((void)3, 1i - 1) : 0) == 1i - 1 ? 1 : -1];
>>>>> +// None of these array bounds is an ICE due to the use of literals of
>>>>> +// non-integer type. But we can constant-fold all of them.
>>>>> +int i1[(2+3i)*(5+7i) == 29i-11 ? 1 : -1]; // expected-warning {{fold}}
>>>>> +int i2[(29i-11)/(5+7i) == 2+3i ? 1 : -1]; // expected-warning {{fold}}
>>>>> +int i3[-(2+3i) == +(-3i-2) ? 1 : -1]; // expected-warning {{fold}}
>>>>> +int i4[~(2+3i) == 2-3i ? 1 : -1]; // expected-warning {{fold}}
>>>>> +int i5[(3i == -(-3i) ? ((void)3, 1i - 1) : 0) == 1i - 1 ? 1 : -1]; //
>>>>> expected-warning {{fold}}
>>>>>
>>>>> -int f1[(2.0+3.0i)*(5.0+7.0i) == 29.0i-11.0 ? 1 : -1];
>>>>> -int f2[(29.0i-11.0)/(5.0+7.0i) == 2.0+3.0i ? 1 : -1];
>>>>> -int f3[-(2.0+3.0i) == +(-3.0i-2.0) ? 1 : -1];
>>>>> -int f4[~(2.0+3.0i) == 2.0-3.0i ? 1 : -1];
>>>>> -int f5[(3.0i == -(-3.0i) ? ((void)3.0, __extension__ (1.0i - 1.0)) :
>>>>> 0) == 1.0i - 1.0 ? 1 : -1];
>>>>> +int f1[(2.0+3.0i)*(5.0+7.0i) == 29.0i-11.0 ? 1 : -1]; //
>>>>> expected-warning {{fold}}
>>>>> +int f2[(29.0i-11.0)/(5.0+7.0i) == 2.0+3.0i ? 1 : -1]; //
>>>>> expected-warning {{fold}}
>>>>> +int f3[-(2.0+3.0i) == +(-3.0i-2.0) ? 1 : -1]; // expected-warning
>>>>> {{fold}}
>>>>> +int f4[~(2.0+3.0i) == 2.0-3.0i ? 1 : -1]; // expected-warning {{fold}}
>>>>> +int f5[(3.0i == -(-3.0i) ? ((void)3.0, __extension__ (1.0i - 1.0)) :
>>>>> 0) == 1.0i - 1.0 ? 1 : -1]; // expected-warning {{fold}}
>>>>>
>>>>> diff --git a/clang/test/Sema/const-eval-64.c
>>>>> b/clang/test/Sema/const-eval-64.c
>>>>> index 1290bf4dd85d..f198b8bf5d14 100644
>>>>> --- a/clang/test/Sema/const-eval-64.c
>>>>> +++ b/clang/test/Sema/const-eval-64.c
>>>>> @@ -1,8 +1,7 @@
>>>>> // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux %s
>>>>> -// expected-no-diagnostics
>>>>>
>>>>> #define EVAL_EXPR(testno, expr) int test##testno = sizeof(struct{char
>>>>> qq[expr];});
>>>>>
>>>>> // <rdar://problem/10962435>
>>>>> -EVAL_EXPR(1, ((char*)-1LL) + 1 == 0 ? 1 : -1)
>>>>> -EVAL_EXPR(2, ((char*)-1LL) + 1 < (char*) -1 ? 1 : -1)
>>>>> +EVAL_EXPR(1, ((char*)-1LL) + 1 == 0 ? 1 : -1) // expected-warning
>>>>> {{folded}}
>>>>> +EVAL_EXPR(2, ((char*)-1LL) + 1 < (char*) -1 ? 1 : -1) //
>>>>> expected-warning {{folded}}
>>>>>
>>>>> diff --git a/clang/test/Sema/const-eval.c
>>>>> b/clang/test/Sema/const-eval.c
>>>>> index bbcbb0e25237..c3cecc06cfcd 100644
>>>>> --- a/clang/test/Sema/const-eval.c
>>>>> +++ b/clang/test/Sema/const-eval.c
>>>>> @@ -1,6 +1,6 @@
>>>>> // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux %s
>>>>> -Wno-tautological-pointer-compare -Wno-pointer-to-int-cast
>>>>>
>>>>> -#define EVAL_EXPR(testno, expr) int test##testno = sizeof(struct{char
>>>>> qq[expr];});
>>>>> +#define EVAL_EXPR(testno, expr) enum { test##testno = (expr) };
>>>>> struct check_positive##testno { int a[test##testno]; };
>>>>> int x;
>>>>> EVAL_EXPR(1, (_Bool)&x)
>>>>> EVAL_EXPR(2, (int)(1.0+(double)4))
>>>>> @@ -14,12 +14,12 @@ EVAL_EXPR(8, (_Bool)"asdf")
>>>>> EVAL_EXPR(9, !!&x)
>>>>> EVAL_EXPR(10, ((void)1, 12))
>>>>> void g0(void);
>>>>> -EVAL_EXPR(11, (g0(), 12)) // expected-error {{must have a constant
>>>>> size}}
>>>>> +EVAL_EXPR(11, (g0(), 12)) // expected-error {{not an integer constant
>>>>> expression}}
>>>>> EVAL_EXPR(12, 1.0&&2.0)
>>>>> -EVAL_EXPR(13, x || 3.0) // expected-error {{must have a constant
>>>>> size}}
>>>>> +EVAL_EXPR(13, x || 3.0) // expected-error {{not an integer constant
>>>>> expression}}
>>>>>
>>>>> unsigned int l_19 = 1;
>>>>> -EVAL_EXPR(14, (1 ^ l_19) && 1); // expected-error {{fields must have
>>>>> a constant size}}
>>>>> +EVAL_EXPR(14, (1 ^ l_19) && 1); // expected-error {{not an integer
>>>>> constant expression}}
>>>>>
>>>>> void f()
>>>>> {
>>>>> @@ -36,7 +36,7 @@ int g17[(3?:1) - 2];
>>>>> EVAL_EXPR(18, ((int)((void*)10 + 10)) == 20 ? 1 : -1);
>>>>>
>>>>> struct s {
>>>>> - int a[(int)-1.0f]; // expected-error {{'a' declared as an array
>>>>> with a negative size}}
>>>>> + int a[(int)-1.0f]; // expected-error {{array size is negative}}
>>>>> };
>>>>>
>>>>> EVAL_EXPR(19, ((int)&*(char*)10 == 10 ? 1 : -1));
>>>>> @@ -47,9 +47,9 @@ EVAL_EXPR(21, (__imag__ 2i) == 2 ? 1 : -1);
>>>>>
>>>>> EVAL_EXPR(22, (__real__ (2i+3)) == 3 ? 1 : -1);
>>>>>
>>>>> -int g23[(int)(1.0 / 1.0)] = { 1 };
>>>>> -int g24[(int)(1.0 / 1.0)] = { 1 , 2 }; // expected-warning {{excess
>>>>> elements in array initializer}}
>>>>> -int g25[(int)(1.0 + 1.0)], g26 = sizeof(g25);
>>>>> +int g23[(int)(1.0 / 1.0)] = { 1 }; // expected-warning {{folded to
>>>>> constant array}}
>>>>> +int g24[(int)(1.0 / 1.0)] = { 1 , 2 }; // expected-warning {{folded
>>>>> to constant array}} expected-warning {{excess elements in array
>>>>> initializer}}
>>>>> +int g25[(int)(1.0 + 1.0)], g26 = sizeof(g25); // expected-warning
>>>>> {{folded to constant array}}
>>>>>
>>>>> EVAL_EXPR(26, (_Complex double)0 ? -1 : 1)
>>>>> EVAL_EXPR(27, (_Complex int)0 ? -1 : 1)
>>>>> @@ -116,17 +116,17 @@ EVAL_EXPR(42, __builtin_constant_p(pr11391.f =
>>>>> 1))
>>>>> // PR12043
>>>>> float varfloat;
>>>>> const float constfloat = 0;
>>>>> -EVAL_EXPR(43, varfloat && constfloat) // expected-error {{must have a
>>>>> constant size}}
>>>>> +EVAL_EXPR(43, varfloat && constfloat) // expected-error {{not an
>>>>> integer constant expression}}
>>>>>
>>>>> // <rdar://problem/10962435>
>>>>> EVAL_EXPR(45, ((char*)-1) + 1 == 0 ? 1 : -1)
>>>>> EVAL_EXPR(46, ((char*)-1) + 1 < (char*) -1 ? 1 : -1)
>>>>> EVAL_EXPR(47, &x < &x + 1 ? 1 : -1)
>>>>> EVAL_EXPR(48, &x != &x - 1 ? 1 : -1)
>>>>> -EVAL_EXPR(49, &x < &x - 100 ? 1 : -1) // expected-error {{must have a
>>>>> constant size}}
>>>>> +EVAL_EXPR(49, &x < &x - 100 ? 1 : -1) // expected-error {{not an
>>>>> integer constant expression}}
>>>>>
>>>>> extern struct Test50S Test50;
>>>>> -EVAL_EXPR(50, &Test50 < (struct Test50S*)((unsigned long)&Test50 +
>>>>> 10)) // expected-error {{must have a constant size}}
>>>>> +EVAL_EXPR(50, &Test50 < (struct Test50S*)((unsigned long)&Test50 +
>>>>> 10)) // expected-error {{not an integer constant expression}}
>>>>>
>>>>> // <rdar://problem/11874571>
>>>>> EVAL_EXPR(51, 0 != (float)1e99)
>>>>> @@ -136,7 +136,7 @@ void PR21945() { int i = (({}), 0l); }
>>>>>
>>>>> void PR24622();
>>>>> struct PR24622 {} pr24622;
>>>>> -EVAL_EXPR(52, &pr24622 == (void *)&PR24622); // expected-error {{must
>>>>> have a constant size}}
>>>>> +EVAL_EXPR(52, &pr24622 == (void *)&PR24622); // expected-error {{not
>>>>> an integer constant expression}}
>>>>>
>>>>> // We evaluate these by providing 2s' complement semantics in constant
>>>>> // expressions, like we do for integers.
>>>>>
>>>>> diff --git a/clang/test/Sema/darwin-align-cast.c
>>>>> b/clang/test/Sema/darwin-align-cast.c
>>>>> index 3a1824901277..114a1d9672c2 100644
>>>>> --- a/clang/test/Sema/darwin-align-cast.c
>>>>> +++ b/clang/test/Sema/darwin-align-cast.c
>>>>> @@ -1,5 +1,4 @@
>>>>> // RUN: %clang_cc1 -fsyntax-only -Wno-pointer-to-int-cast -verify %s
>>>>> -// expected-no-diagnostics
>>>>> typedef long unsigned int __darwin_size_t;
>>>>> typedef long __darwin_ssize_t;
>>>>> typedef __darwin_size_t size_t;
>>>>> @@ -18,6 +17,7 @@ i386/_param.h:#define __DARWIN_ALIGN(p)
>>>>> ((__darwin_size_t)((char *)(p)
>>>>>
>>>>> ssize_t sendFileDescriptor(int fd, void *data, size_t nbytes, int
>>>>> sendfd) {
>>>>> union {
>>>>> + // expected-warning@+1 {{folded to constant array}}
>>>>> char control[(((__darwin_size_t)((char *)(sizeof(struct cmsghdr))
>>>>> + (sizeof(__darwin_size_t) - 1)) &~ (sizeof(__darwin_size_t) - 1)) +
>>>>> ((__darwin_size_t)((char *)(sizeof(int)) + (sizeof(__darwin_size_t) - 1))
>>>>> &~ (sizeof(__darwin_size_t) - 1)))];
>>>>> } control_un;
>>>>> return 0;
>>>>>
>>>>> diff --git a/clang/test/Sema/decl-in-prototype.c
>>>>> b/clang/test/Sema/decl-in-prototype.c
>>>>> index 64caea6a38a8..83e35a673390 100644
>>>>> --- a/clang/test/Sema/decl-in-prototype.c
>>>>> +++ b/clang/test/Sema/decl-in-prototype.c
>>>>> @@ -49,7 +49,7 @@ void f(struct q *, struct
>>>>> __attribute__((aligned(4))) q *); // expected-warning
>>>>> // function.
>>>>> enum { BB = 0 };
>>>>> void enum_in_fun_in_fun(void (*fp)(enum { AA, BB } e)) { //
>>>>> expected-warning {{will not be visible}}
>>>>> - SA(1, AA == 5);
>>>>> + SA(1, AA == 5); // expected-error {{variable-sized object may not
>>>>> be initialized}}
>>>>> SA(2, BB == 0);
>>>>> }
>>>>>
>>>>>
>>>>> diff --git a/clang/test/Sema/gnu-flags.c b/clang/test/Sema/gnu-flags.c
>>>>> index e7588b7b371e..e53e5fdf11df 100644
>>>>> --- a/clang/test/Sema/gnu-flags.c
>>>>> +++ b/clang/test/Sema/gnu-flags.c
>>>>> @@ -124,7 +124,9 @@ enum {
>>>>> fic = (int)(0.75 * 1000 * 1000)
>>>>> };
>>>>> static const int size = 100;
>>>>> -void foo(void) { int data[size]; }
>>>>> +int data[size];
>>>>> +
>>>>> +void foo(void) { int data[size]; } // OK, always a VLA
>>>>>
>>>>> #if ALL || REDECLAREDENUM
>>>>> // expected-note@+4 {{previous definition is here}}
>>>>>
>>>>> diff --git a/clang/test/Sema/i-c-e.c b/clang/test/Sema/i-c-e.c
>>>>> index e2d921b8ffd6..120f4b5f4889 100644
>>>>> --- a/clang/test/Sema/i-c-e.c
>>>>> +++ b/clang/test/Sema/i-c-e.c
>>>>> @@ -12,7 +12,7 @@ char w[__builtin_constant_p(expr) ? expr : 1];
>>>>> char v[sizeof(__builtin_constant_p(0)) == sizeof(int) ? 1 : -1];
>>>>>
>>>>> int implicitConversion = 1.0;
>>>>> -char floatArith[(int)(1.0+2.0)]; // expected-warning {{must be an
>>>>> integer constant expression}}
>>>>> +char floatArith[(int)(1.0+2.0)]; // expected-warning {{variable
>>>>> length array folded to constant array as an extension}}
>>>>>
>>>>> // __builtin_constant_p as the condition of ?: allows arbitrary
>>>>> foldable
>>>>> // constants to be transmogrified into i-c-e's.
>>>>> @@ -57,7 +57,7 @@ char z[__builtin_constant_p(4) ? 1 : -1];
>>>>> int comma1[0?1,2:3];
>>>>> int comma2[1||(1,2)]; // expected-warning {{use of logical '||' with
>>>>> constant operand}} \
>>>>> // expected-note {{use '|' for a bitwise
>>>>> operation}}
>>>>> -int comma3[(1,2)]; // expected-warning {{size of static array must be
>>>>> an integer constant expression}}
>>>>> +int comma3[(1,2)]; // expected-warning {{variable length array folded
>>>>> to constant array as an extension}}
>>>>>
>>>>> // Pointer + __builtin_constant_p
>>>>> char pbcp[__builtin_constant_p(4) ? (intptr_t)&expr : 0]; //
>>>>> expected-error {{variable length array declaration not allowed at file
>>>>> scope}}
>>>>>
>>>>> diff --git a/clang/test/Sema/offsetof-64.c
>>>>> b/clang/test/Sema/offsetof-64.c
>>>>> index 4a80dee2fc2f..8ffc3af98588 100644
>>>>> --- a/clang/test/Sema/offsetof-64.c
>>>>> +++ b/clang/test/Sema/offsetof-64.c
>>>>> @@ -5,15 +5,15 @@
>>>>> const unsigned long Size = (1l << 60);
>>>>>
>>>>> struct Chunk1 {
>>>>> - char padding[Size];
>>>>> - char more_padding[1][Size];
>>>>> + char padding[Size]; // expected-warning {{folded to constant}}
>>>>> + char more_padding[1][Size]; // expected-warning {{folded to
>>>>> constant}}
>>>>> char data;
>>>>> };
>>>>>
>>>>> int test1 = __builtin_offsetof(struct Chunk1, data);
>>>>>
>>>>> struct Chunk2 {
>>>>> - char padding[Size][Size][Size]; // expected-error 2{{array is too
>>>>> large}}
>>>>> + char padding[Size][Size][Size]; // expected-error {{array is too
>>>>> large}}
>>>>> char data;
>>>>> };
>>>>>
>>>>>
>>>>> diff --git a/clang/test/Sema/rounding-math.c
>>>>> b/clang/test/Sema/rounding-math.c
>>>>> index 3cb5d034b143..89951b1726db 100644
>>>>> --- a/clang/test/Sema/rounding-math.c
>>>>> +++ b/clang/test/Sema/rounding-math.c
>>>>> @@ -1,6 +1,7 @@
>>>>> -// RUN: %clang_cc1 -triple x86_64-linux -verify=norounding %s
>>>>> -// RUN: %clang_cc1 -triple x86_64-linux -std=c17 -verify=rounding-std
>>>>> %s -frounding-math
>>>>> -// RUN: %clang_cc1 -triple x86_64-linux -std=gnu17
>>>>> -verify=rounding-gnu %s -frounding-math
>>>>> +// RUN: %clang_cc1 -triple x86_64-linux -std=c17
>>>>> -verify=expected,norounding %s
>>>>> +// RUN: %clang_cc1 -triple x86_64-linux -std=gnu17
>>>>> -verify=expected,norounding %s
>>>>> +// RUN: %clang_cc1 -triple x86_64-linux -std=c17
>>>>> -verify=expected,rounding %s -frounding-math
>>>>> +// RUN: %clang_cc1 -triple x86_64-linux -std=gnu17
>>>>> -verify=expected,rounding %s -frounding-math
>>>>>
>>>>> #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
>>>>>
>>>>> @@ -24,8 +25,11 @@ void bitfield(struct Bitfield *b) {
>>>>> }
>>>>>
>>>>> void vlas() {
>>>>> - // Under -frounding-math, this is a VLA.
>>>>> - // FIXME: Due to PR44406, in GNU mode we constant-fold the
>>>>> initializer resulting in a non-VLA.
>>>>> - typedef int vla[(int)(-3 * (1.0 / 3.0))]; // norounding-error
>>>>> {{negative size}} rounding-gnu-error {{negative size}}
>>>>> - struct X { vla v; }; // rounding-std-error {{fields must have a
>>>>> constant size}}
>>>>> + // This is always a VLA due to its syntactic form.
>>>>> + typedef int vla1[(int)(-3 * (1.0 / 3.0))];
>>>>> + struct X1 { vla1 v; }; // expected-error {{fields must have a
>>>>> constant size}}
>>>>> +
>>>>> + // This is always folded to a constant.
>>>>> + typedef int vla2[fold((int)(-3 * (1.0 / 3.0)))]; // expected-error
>>>>> {{negative size}}
>>>>> + struct X2 { vla2 v; };
>>>>> }
>>>>>
>>>>> diff --git a/clang/test/Sema/struct-decl.c
>>>>> b/clang/test/Sema/struct-decl.c
>>>>> index ee3e79182eaa..a119e59eab93 100644
>>>>> --- a/clang/test/Sema/struct-decl.c
>>>>> +++ b/clang/test/Sema/struct-decl.c
>>>>> @@ -5,8 +5,8 @@ struct bar {
>>>>> };
>>>>>
>>>>> struct foo {
>>>>> - char name[(int)&((struct bar *)0)->n];
>>>>> - char name2[(int)&((struct bar *)0)->n - 1];
>>>>> //expected-error{{'name2' declared as an array with a negative size}}
>>>>> + char name[(int)&((struct bar *)0)->n]; // expected-warning {{folded
>>>>> to constant}}
>>>>> + char name2[(int)&((struct bar *)0)->n - 1]; // expected-error
>>>>> {{array size is negative}}
>>>>> };
>>>>>
>>>>> // PR3430
>>>>>
>>>>> diff --git a/clang/test/Sema/typedef-variable-type.c
>>>>> b/clang/test/Sema/typedef-variable-type.c
>>>>> index 8a7ee8b911c0..da1c241eea3d 100644
>>>>> --- a/clang/test/Sema/typedef-variable-type.c
>>>>> +++ b/clang/test/Sema/typedef-variable-type.c
>>>>> @@ -1,8 +1,8 @@
>>>>> // RUN: %clang_cc1 %s -verify -fsyntax-only -pedantic
>>>>> -Wno-typedef-redefinition -std=c99
>>>>>
>>>>> // Make sure we accept a single typedef
>>>>> -typedef int (*a)[!.0]; // expected-warning{{size of static array must
>>>>> be an integer constant expression}}
>>>>> +typedef int (*a)[!.0]; // expected-warning{{folded to constant array}}
>>>>>
>>>>> // And make sure we accept identical redefinitions in system headers
>>>>> // (The test uses -Wno-typedef-redefinition to simulate this.)
>>>>> -typedef int (*a)[!.0]; // expected-warning{{size of static array must
>>>>> be an integer constant expression}}
>>>>> +typedef int (*a)[!.0]; // expected-warning{{folded to constant array}}
>>>>>
>>>>> diff --git a/clang/test/Sema/vla.c b/clang/test/Sema/vla.c
>>>>> index 8d83100b9d68..f49e8bbf5f7b 100644
>>>>> --- a/clang/test/Sema/vla.c
>>>>> +++ b/clang/test/Sema/vla.c
>>>>> @@ -53,7 +53,7 @@ int pr2044b;
>>>>> int (*pr2044c(void))[pr2044b]; // expected-error {{variably modified
>>>>> type}}
>>>>>
>>>>> const int f5_ci = 1;
>>>>> -void f5() { char a[][f5_ci] = {""}; } // expected-warning {{variable
>>>>> length array folded to constant array as an extension}}
>>>>> +void f5() { char a[][f5_ci] = {""}; } // expected-error
>>>>> {{variable-sized object may not be initialized}}
>>>>>
>>>>> // PR5185
>>>>> void pr5185(int a[*]);
>>>>> @@ -89,3 +89,14 @@ void VLAPtrAssign(int size) {
>>>>> // Not illegal in C, program _might_ be well formed if size == 3.
>>>>> int (*p4)[2][size][3][4][5] = array;
>>>>> }
>>>>> +
>>>>> +void pr44406() {
>>>>> + goto L; // expected-error {{cannot jump}}
>>>>> + int z[(int)(1.0 * 2)]; // expected-note {{bypasses initialization
>>>>> of variable length array}}
>>>>> +L:;
>>>>> +}
>>>>> +
>>>>> +const int pr44406_a = 32;
>>>>> +typedef struct {
>>>>> + char c[pr44406_a]; // expected-warning {{folded to constant array
>>>>> as an extension}}
>>>>> +} pr44406_s;
>>>>>
>>>>> diff --git a/clang/test/SemaCXX/anonymous-struct.cpp
>>>>> b/clang/test/SemaCXX/anonymous-struct.cpp
>>>>> index f85b00bc8bce..1b6207d19e44 100644
>>>>> --- a/clang/test/SemaCXX/anonymous-struct.cpp
>>>>> +++ b/clang/test/SemaCXX/anonymous-struct.cpp
>>>>> @@ -131,6 +131,9 @@ namespace ValidButUnsupported {
>>>>> typedef struct { // expected-error {{unsupported}}
>>>>> enum X {};
>>>>> int arr[&f<X> ? 1 : 2];
>>>>> +#if __cplusplus < 201103L
>>>>> + // expected-warning@-2 {{folded to constant}}
>>>>> +#endif
>>>>> } C; // expected-note {{by this typedef}}
>>>>> }
>>>>>
>>>>>
>>>>> diff --git a/clang/test/SemaCXX/constant-expression.cpp
>>>>> b/clang/test/SemaCXX/constant-expression.cpp
>>>>> index 82f9657d84f6..2bec62f46b66 100644
>>>>> --- a/clang/test/SemaCXX/constant-expression.cpp
>>>>> +++ b/clang/test/SemaCXX/constant-expression.cpp
>>>>> @@ -110,7 +110,7 @@ extern const int recurse1;
>>>>> const int recurse2 = recurse1; // expected-note {{here}}
>>>>> const int recurse1 = 1;
>>>>> int array1[recurse1]; // ok
>>>>> -int array2[recurse2]; // expected-warning {{variable length array}}
>>>>> expected-warning {{integer constant expression}} expected-note
>>>>> {{initializer of 'recurse2' is not a constant expression}}
>>>>> +int array2[recurse2]; // expected-warning 2{{variable length array}}
>>>>> expected-note {{initializer of 'recurse2' is not a constant expression}}
>>>>>
>>>>> namespace FloatConvert {
>>>>> typedef int a[(int)42.3];
>>>>>
>>>>> diff --git a/clang/test/SemaCXX/cxx1z-noexcept-function-type.cpp
>>>>> b/clang/test/SemaCXX/cxx1z-noexcept-function-type.cpp
>>>>> index 82ed724e1bd9..6cbc6b69e82f 100644
>>>>> --- a/clang/test/SemaCXX/cxx1z-noexcept-function-type.cpp
>>>>> +++ b/clang/test/SemaCXX/cxx1z-noexcept-function-type.cpp
>>>>> @@ -120,7 +120,7 @@ namespace Builtins {
>>>>> extern "C" int strncmp(const char *, const char *,
>>>>> decltype(sizeof(0))) noexcept;
>>>>>
>>>>> // Check we recognized both as builtins.
>>>>> - typedef int arr[strcmp("bar", "foo") + 4 * strncmp("foo", "bar",
>>>>> 4)];
>>>>> + typedef int arr[strcmp("bar", "foo") + 4 * strncmp("foo", "bar",
>>>>> 4)]; // expected-warning {{variable length array}}
>>>>> typedef int arr[3];
>>>>> }
>>>>>
>>>>>
>>>>> diff --git a/clang/test/SemaCXX/i-c-e-cxx.cpp
>>>>> b/clang/test/SemaCXX/i-c-e-cxx.cpp
>>>>> index 2bfb67ffdf5b..a09ff5ac8d9f 100644
>>>>> --- a/clang/test/SemaCXX/i-c-e-cxx.cpp
>>>>> +++ b/clang/test/SemaCXX/i-c-e-cxx.cpp
>>>>> @@ -80,7 +80,7 @@ struct PR8836 { char _; long long a; };
>>>>> #endif
>>>>>
>>>>> int PR8836test[(__typeof(sizeof(int)))&reinterpret_cast<const
>>>>> volatile char&>((((PR8836*)0)->a))];
>>>>> -// expected-warning@-1 {{folded to constant array as an extension}}
>>>>> +// expected-warning@-1 0-1{{C99 feature}} expected-warning@-1
>>>>> {{folded to constant array as an extension}}
>>>>> // expected-note@-2 {{cast that performs the conversions of a
>>>>> reinterpret_cast is not allowed in a constant expression}}
>>>>>
>>>>> const int nonconst = 1.0;
>>>>> @@ -89,7 +89,7 @@ const int nonconst = 1.0;
>>>>> #endif
>>>>> int arr[nonconst];
>>>>> #if __cplusplus <= 199711L
>>>>> -// expected-warning@-2 {{folded to constant array as an extension}}
>>>>> +// expected-warning@-2 0-1{{C99 feature}} expected-warning@-2
>>>>> {{folded to constant array as an extension}}
>>>>> // expected-note@-3 {{initializer of 'nonconst' is not a constant
>>>>> expression}}
>>>>> #endif
>>>>>
>>>>>
>>>>> diff --git a/clang/test/SemaObjC/gcc-cast-ext.m
>>>>> b/clang/test/SemaObjC/gcc-cast-ext.m
>>>>> index 9e9186070ffe..2eb707065d9f 100644
>>>>> --- a/clang/test/SemaObjC/gcc-cast-ext.m
>>>>> +++ b/clang/test/SemaObjC/gcc-cast-ext.m
>>>>> @@ -11,7 +11,7 @@ @interface PBXDocBookmark
>>>>>
>>>>> // GCC allows pointer expressions in integer constant expressions.
>>>>> struct {
>>>>> - char control[((int)(char *)2)];
>>>>> + char control[((int)(char *)2)]; // expected-warning {{extension}}
>>>>> } xx;
>>>>>
>>>>> @implementation PBXDocBookmark // expected-warning {{method
>>>>> definition for 'autorelease' not found}}\
>>>>>
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> cfe-commits mailing list
>>>>> cfe-commits@lists.llvm.org
>>>>> https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>
>>>>
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
