file-scoped variably modified type erroneously supported in C as a GNU extension (GCC provides the extension only for C++)

[DesWurstes]

Bugzilla Link	44406
Resolution	FIXED
Resolved on	Oct 28, 2021 20:57
Version	unspecified
OS	All
CC	@pascal-cuoq,@dwblaikie,@DougGregor,@efriedma-quic,@nickdesaulniers,@zygoloid
Fixed by commit(s)	552c6c2

Extended Description

const int a = 32;

typedef struct {
char c[a];
} d;

GCC: error: variably modified 'c' at file scope
CompCert: error: size of array is not a compile-time constant

Clang -Wextra: compiles
Clang -pedantic: warning: variable length array folded to constant array as an extension [-Wgnu-folding-constant]

The problem? This is not a GNU extension. Either the warning is wrong or the code that shouldn't compile compiles.

Weirdly, MSVC has the same behavior as Clang but does not issue a warning.

Once it is confirmed, I'll file an Apple bug report, because an Xcode header, Security.framework/Headers/Authorization.h suffers from this issue and can only be compiled with Clang (so when this bug is patched don't tell me that I broke Apple's code :) )

[dwblaikie]

Ah - looks like this is, perhaps, a GCC extension in C++ ( https://godbolt.org/z/dioCbn ) but not in C ( https://godbolt.org/z/cqqAz8 ).

It's possible clang could start reporting this as an error in C, but I suspect that wouldn't be acceptable - since now there's a backwards compatibility with clang itself given the extension behavior. So I'm guessing at best this could be a warning in Clang? But I'm not sure.

[efriedma-quic]

In C++ a constant variable counts as an integer constant expression, so you'd need a different testcase. Not sure what expressions clang can fold that don't count as C++ constants, off the top of my head.

This extension is designed to handle cases like bug 3663, which were silently accepted in gcc 4.2. It looks like gcc has become more strict since then; clang should probably follow suit.

[zygoloid]

GCC does still constant-fold non-constant-expression array bounds as an extension (https://godbolt.org/z/j3b8At). GCC has warned on this by default since version 4.5; we should enable -Wgnu-folding-constant by default to match that behavior.

Clang's constant folding is never going to exactly match GCC's, and trying to make them match better seems futile except as necessary for practical source compatibility, so beyond warning on this by default, I don't think there's anything else that it's reasonable for us to change here.

[efriedma-quic]

I don't think
there's anything else that it's reasonable for us to change here.

There's actually one other significant change in this area to gcc: it looks like gcc only does this folding at file scope in newer versions. In the body of a function, array bounds aren't implicitly folded. For example:

void f() { goto L; int z[(int)(1.0*2)]; L:; }

gcc 4.4 accepts, gcc 4.5 rejects.

[zygoloid]

Interesting. That makes a lot of sense, though; GCC's extension miscompiles this example prior to GCC 4.5:

const int a = 32;

int f() {
int n = 0;
char c[1][(a - a) + 1];
sizeof(c[n = 1]);
return n; // required to return 1
}

Clang trunk follows GCC < 4.5 and miscompiles this example =( We should only be converting VLAs to non-VLAs when the VLA would be ill-formed.

[zygoloid]

The issues in comment#3 and comment#4 are fixed; we now follow GCC's behavior in most regards.

Contrary to comment#0, we still do fold VLAs to constant arrays in struct members where GCC does not. However, that seems justifiable: GCC supports VLAs as struct members and Clang does not, and folding VLAs to constant arrays allows us to accept at least some of the cases that GCC accepts here.

[zygoloid]

*** Bug llvm/llvm-bugzilla-archive#48735 has been marked as a duplicate of this bug. ***

[nickdesaulniers]

FWIW, it looks like https://reviews.llvm.org/D89523 causes:

void foo(char*);

void bar(void){
const long maxsz = sizeof(int) * 3 + 1;
char s[maxsz];
foo(s);
}

to now warn with Clang:
$ clang -std=gnu89 -O2 -Wvla -Wvla-extension
warning: variable length arrays are a C99 feature [-Wvla-extension]

GCC warns:
$ gcc -std=gnu89 -O2 -Wvla
warning: ISO C90 forbids array 's' whose size cannot be evaluated [-Wvla]

(I think that's the intent of D89523, but wanted to double check, see also internal bug b/180726924)

[zygoloid]

(I think that's the intent of D89523, but wanted to double check, see also internal bug b/180726924)

Yes. The array bound is not an ICE, so this case gets diagnosed as introducing a VLA now, per the C language rules, even though we are able to constant-fold the array bound.

[zygoloid]

mentioned in issue llvm/llvm-bugzilla-archive#48735