Follow @Openwall on Twitter for new release announcements and other news
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Date: Sun, 11 Mar 2018 12:05:43 +0100
From: Ingo Molnar <>
To: Linus Torvalds <>
Cc: Miguel Ojeda <>,
	Kees Cook <>,
	Randy Dunlap <>,
	Andrew Morton <>,
	linux-kernel <>,
	Josh Poimboeuf <>,
	Rasmus Villemoes <>,
	"Gustavo A. R. Silva" <>,
	"Tobin C. Harding" <>,
	Steven Rostedt <>,
	Jonathan Corbet <>, Chris Mason <>,
	Josef Bacik <>, David Sterba <>,
	"David S. Miller" <>,
	Alexey Kuznetsov <>,
	Hideaki YOSHIFUJI <>,
	Peter Zijlstra <>,
	Thomas Gleixner <>,
	Masahiro Yamada <>,
	Borislav Petkov <>, Ian Abbott <>,
	Sergey Senozhatsky <>,
	Petr Mladek <>,
	Andy Shevchenko <>,
	Pantelis Antoniou <>,
	Linux Btrfs <>,
	Network Development <>,
	Kernel Hardening <>
Subject: Re: [PATCH v3] kernel.h: Skip single-eval logic on literals in

* Linus Torvalds <> wrote:

> So an error message like
>    warning: ISO C90 requires array sizes to be constant-expressions
> would be technically correct and useful from a portability angle. It
> tells you when you're doing something non-portable, and should be
> automatically enabled with "-ansi -pedantic", for example.
> So what's misleading is actually the name of the warning and the
> message, not that it happens. The warning isn't about "variable
> length", it's literally about the rules for what a
> "constant-expression" is.
> And in C, the expression (2,3) has a constant _value_ (namely 3), but
> it isn't a constant-expression as specified by the language.
> Now, the thing is that once you actually do variable length arrays,
> those old front-end rules make no sense any more (outside of the "give
> portability warnings" thing).
> Because once you do variable length arrays, you obviously _parse_
> everything just fine, and you're doing to evaluate much more complex
> expressions than some limited constant-expression rule.

BTW., while I fully agree with everything you said, it's not entirely correct to 
claim that if a C compiler can generate VLA code it is necessarily able to parse 
and evaluate constant array sizes "just fine".

Constant expressions are typically parsed very early on, at the preprocessing 
stage. They can be used with some preprocessor directives as well, such as '#if' 
(with some further limitations on their syntax).

If VLA support is implemented in a later stage, and results in heavy-handed code 
generation that will technically work for constant value expressions as well but 
results in suboptimal code, then a warning should probably be emitted - and it 
wouldn't be pedantic.

The existing warning is still very misleading:

  warning: ISO C90 forbids variable length array ‘array’ [-Wvla]

... and if my above theory is correct then I think a better warning would be 
something like:

  warning: Array declaration is not a C90 constant expression, resulting in VLA code generation

... and note that in this specific case it's not misleading to talk about VLAs in 
the warning text, because the array size, even if it's constant value, results in 
VLA code generation.

I don't know whether GCC has such a limitation, but a quick experiment with GCC 
7.2 suggests that a (2,3) array size expression results in a lot more code being 
generated than with a constant expression.



Powered by blists - more mailing lists

Confused about mailing lists and their use? Read about mailing lists on Wikipedia and check out these guidelines on proper formatting of your messages.