unnecessary constraint enforcement within static_assert() within structure definition

[alejandro-colomar]

Here's a small reproducer:

alx@devuan:~/tmp$ cat cnt.c

#include <stdlib.h>
#include <assert.h>


#define must_be(e)                                                    \
(                                                                     \
        0 * (int) sizeof(                                             \
                struct {                                              \
                        static_assert(e, "");                         \
                        int ISO_C_forbids_a_struct_with_no_members_;  \
                }                                                     \
        )                                                             \
)

#define is_same_type(a, b)                                            \
(                                                                     \
        __builtin_types_compatible_p(a, b)                            \
)

#define is_same_typeof(a, b)                                          \
(                                                                     \
        is_same_type(typeof(a), typeof(b))                            \
)

#define is_array(a)                                                   \
(                                                                     \
        !is_same_typeof(a, &(a)[0])                                   \
)


int
main(void)
{
	return must_be(is_array(((int []) {rand(), rand()})));
}

alx@devuan:~/tmp$ gcc -Wall -Wextra -S cnt.c 
alx@devuan:~/tmp$

alx@devuan:~/tmp$ clang -Wall -Wextra -S cnt.c 
cnt.c:34:37: error: initializer element is not a compile-time constant
   34 |         return must_be(is_array(((int []) {rand(), rand()})));
      |                                            ^~~~~~
cnt.c:27:25: note: expanded from macro 'is_array'
   27 |         !is_same_typeof(a, &(a)[0])                                   \
      |                         ^
cnt.c:22:29: note: expanded from macro 'is_same_typeof'
   22 |         is_same_type(typeof(a), typeof(b))                            \
      |                             ^
cnt.c:17:38: note: expanded from macro 'is_same_type'
   17 |         __builtin_types_compatible_p(a, b)                            \
      |                                      ^
cnt.c:9:39: note: expanded from macro 'must_be'
    9 |                         static_assert(e, "");                         \
      |                                       ^
1 error generated.

Please include the following in an eventual fix:

Reported-by: "Basil L. Contovounesios" <basil@contovou.net>
Reported-by: Alejandro Colomar <alx@kernel.org>

[alejandro-colomar]

Here's a smaller reproducer using _Generic(3) instead of the builtin:

alx@devuan:~/tmp$ cat cnt2.c

#include <stdlib.h>
#include <assert.h>


#define must_be(e)                                                    \
(                                                                     \
        0 * (int) sizeof(                                             \
                struct {                                              \
                        static_assert(e, "");                         \
                        int ISO_C_forbids_a_struct_with_no_members_;  \
                }                                                     \
        )                                                             \
)

#define is_array(a)                                                   \
(                                                                     \
	_Generic(&(a), typeof(*a) (*)[]: 1, default: 0)               \
)


int
main(void)
{
	return must_be(is_array(((int []) {rand(), rand()})));
}

alx@devuan:~/tmp$ gcc -Wall -Wextra cnt2.c 
alx@devuan:~/tmp$ clang -Wall -Wextra cnt2.c 
cnt2.c:24:37: error: initializer element is not a compile-time constant
   24 |         return must_be(is_array(((int []) {rand(), rand()})));
      |                                            ^~~~~~
cnt2.c:17:13: note: expanded from macro 'is_array'
   17 |         _Generic(&(a), typeof(*a) (*)[]: 1, default: 0)               \
      |                    ^
cnt2.c:9:39: note: expanded from macro 'must_be'
    9 |                         static_assert(e, "");                         \
      |                                       ^
1 error generated.

[alejandro-colomar]

Cc: @basil-conto

[alejandro-colomar]

Cc: @AaronBallman

[alejandro-colomar]

Here's an even smaller reproducer without _Generic(3):

alx@devuan:~/tmp$ cat cnt3.c

#include <stdlib.h>
#include <assert.h>


#define must_be(e)                                                    \
(                                                                     \
        0 * (int) sizeof(                                             \
                struct {                                              \
                        static_assert(e, "");                         \
                        int ISO_C_forbids_a_struct_with_no_members_;  \
                }                                                     \
        )                                                             \
)


int
main(void)
{
	return must_be(sizeof(((int []) {rand(), rand()})) > 0);
}

alx@devuan:~/tmp$ gcc -Wall -Wextra cnt3.c 
alx@devuan:~/tmp$ clang -Wall -Wextra cnt3.c 
cnt3.c:19:35: error: initializer element is not a compile-time constant
   19 |         return must_be(sizeof(((int []) {rand(), rand()})) > 0);
      |                                          ^~~~~~
cnt3.c:9:39: note: expanded from macro 'must_be'
    9 |                         static_assert(e, "");                         \
      |                                       ^
1 error generated.

[alejandro-colomar]

Here's an even smaller reproducer:

alx@devuan:~/tmp$ cat cnt4.c

#include <stdlib.h>
#include <assert.h>


int
main(void)
{
	struct s {
		static_assert(sizeof(((int []) {rand(), rand()})) > 0, "");
		int ISO_C_forbids_a_struct_with_no_members_;
	};
}

alx@devuan:~/tmp$ gcc -Wall -Wextra cnt4.c 
alx@devuan:~/tmp$ clang -Wall -Wextra cnt4.c 
cnt4.c:9:35: error: initializer element is not a compile-time constant
    9 |                 static_assert(sizeof(((int []) {rand(), rand()})) > 0, "");
      |                                                 ^~~~~~
1 error generated.

[alejandro-colomar]

Here's an even smaller reproducer, without function calls or arrays:

alx@devuan:~/tmp$ cat cnt5.c

#include <assert.h>

int i;

int
main(void)
{
	struct s {
		static_assert(sizeof((int) {i}) == sizeof(int), "");
		int ISO_C_forbids_a_struct_with_no_members_;
	};
}

alx@devuan:~/tmp$ gcc -Wall -Wextra cnt5.c 
alx@devuan:~/tmp$ clang -Wall -Wextra cnt5.c 
cnt5.c:9:30: error: initializer element is not a compile-time constant
    9 |                 static_assert(sizeof((int) {i}) == sizeof(int), "");
      |                                            ^~~
1 error generated.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Alejandro Colomar (alejandro-colomar)

Here's a small reproducer:

alx@<!-- -->devuan:~/tmp$ cat cnt.c 
#include &lt;stdlib.h&gt;
#include &lt;assert.h&gt;


#define must_be(e)                                                    \
(                                                                     \
        0 * (int) sizeof(                                             \
                struct {                                              \
                        static_assert(e, "");                         \
                        int ISO_C_forbids_a_struct_with_no_members_;  \
                }                                                     \
        )                                                             \
)

#define is_same_type(a, b)                                            \
(                                                                     \
        __builtin_types_compatible_p(a, b)                            \
)

#define is_same_typeof(a, b)                                          \
(                                                                     \
        is_same_type(typeof(a), typeof(b))                            \
)

#define is_array(a)                                                   \
(                                                                     \
        !is_same_typeof(a, &amp;(a)[0])                                   \
)


int
main(void)
{
	return must_be(is_array(((int []) {rand(), rand()})));
}

alx@<!-- -->devuan:~/tmp$ gcc -Wall -Wextra -S cnt.c 
alx@<!-- -->devuan:~/tmp$

alx@<!-- -->devuan:~/tmp$ clang -Wall -Wextra -S cnt.c 
cnt.c:34:37: error: initializer element is not a compile-time constant
   34 |         return must_be(is_array(((int []) {rand(), rand()})));
      |                                            ^~~~~~
cnt.c:27:25: note: expanded from macro 'is_array'
   27 |         !is_same_typeof(a, &amp;(a)[0])                                   \
      |                         ^
cnt.c:22:29: note: expanded from macro 'is_same_typeof'
   22 |         is_same_type(typeof(a), typeof(b))                            \
      |                             ^
cnt.c:17:38: note: expanded from macro 'is_same_type'
   17 |         __builtin_types_compatible_p(a, b)                            \
      |                                      ^
cnt.c:9:39: note: expanded from macro 'must_be'
    9 |                         static_assert(e, "");                         \
      |                                       ^
1 error generated.

Please include the following in an eventual fix:

Reported-by: "Basil L. Contovounesios" &lt;basil@<!-- -->contovou.net&gt;
Reported-by: Alejandro Colomar &lt;alx@<!-- -->kernel.org&gt;

[shafik]

Please, edit your code blocks to only include code, otherwise it makes copying and pasting a lot less convenient.

[bhaible]

A different test case, without static_assert:

extern int a;
int
main ()
{
  enum { e = __builtin_types_compatible_p (typeof (((int[]) { a })), int[]) };
  struct { unsigned int z : __builtin_types_compatible_p (typeof (((int[]) { a })), int[]) ? -1 : 1; } x;
}

produces (with clang 20):

foo.c:5:63: error: initializer element is not a compile-time constant
    5 |   enum { e = __builtin_types_compatible_p (typeof (((int[]) { a })), int[]) };
      |                                                               ^
foo.c:6:78: error: initializer element is not a compile-time constant
    6 |   struct { unsigned int z : __builtin_types_compatible_p (typeof (((int[]) { a })), int[]) ? -1 : 1; } x;
      |                                                                              ^
2 errors generated.

[tbaederr]

They get rejected here:

llvm-project/clang/lib/AST/ExprConstant.cpp

Line 4456 in 897ccdd

Info.FFDiag(E);