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?
>
>
>> 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
