__builtin_offsetof is not entered in strict mode, so offsetof from gcc's <stddef.h> fails under -A

[thinkoid]

Issue Summary

src/fe_init.c enters the __builtin_offsetof keyword only in GNU 4.0+, Microsoft 1910+ or clang emulation. On Linux, glibc ships no <stddef.h>; the freestanding headers come from gcc, and gcc's <stddef.h> unconditionally defines offsetof as __builtin_offsetof. In strict mode (-A), where GNU emulation is excluded, every use of offsetof therefore fails.

Strict mode can provide __builtin_offsetof without giving up conformance. The name is reserved to the implementation (C17 7.1.3p1; C++03 17.4.3.1.2p1), so no strictly conforming program can use it, and an extension no such program can reach is permitted (C17 4p6; C++03 1.4p8). A program that uses offsetof uses only the standard macro; the reserved name appears in the implementation's own header. Strict mode already enters three names of this kind in every mode: __ALIGNOF__, __alignof__ and __INTADDR__ (fe_init.c:1079-1081).

Observed Behavior

cpfe built from the linux-gcc-release preset, run with the repository's own base. A strictly conforming program that uses offsetof, with gcc's include directory and /usr/include as the system include directories:

$ export EDG_BASE=$PWD/bases/docker/dev-env/gcc
$ cat off.c
#include <stddef.h>
struct s { char c; double d; };
int a[offsetof (struct s, d)];
$ cpfe -A --sys_include=$(gcc -print-file-name=include) --sys_include=/usr/include off.c
"off.c", line 3: error: function call is not allowed in a constant expression
  int a[offsetof (struct s, d)];
        ^

"off.c", line 3: error: expected an expression
  int a[offsetof (struct s, d)];
        ^

"off.c", line 3: error: identifier "d" is undefined
  int a[offsetof (struct s, d)];
        ^

3 errors detected in the compilation of "off.c".

cpfe --c++03 -A with the same options gives the same three errors.

The cause, reduced to the keyword. This program is not strictly conforming; it only shows that __builtin_offsetof is missing under -A and present under --g++:

$ cat off2.c
struct s { char c; double d; };
int a[__builtin_offsetof (struct s, d)];
$ cpfe -A off2.c
"off2.c", line 2: error: function call is not allowed in a constant expression
  int a[__builtin_offsetof (struct s, d)];
        ^

"off2.c", line 2: error: expected an expression
  int a[__builtin_offsetof (struct s, d)];
                            ^

"off2.c", line 2: error: identifier "d" is undefined
  int a[__builtin_offsetof (struct s, d)];
                                      ^

3 errors detected in the compilation of "off2.c".
$ cpfe --g++ off2.c
$

Expected Behavior

__builtin_offsetof is available under -A, so offsetof from gcc's <stddef.h> works there, as a constant expression. Entering the keyword wherever __INTADDR__ is entered would do it.

A workaround that works today:

-D'__builtin_offsetof(T,M)=((__SIZE_TYPE__)__INTADDR__(&((T*)0)->M))'

Additional Details

• EDG 7.0, edgcpp/compiler at ca5890bab8, x86_64 Linux.

Configuration: cpfe --dump_configuration output attached (dump_configuration.txt).

[thinkoid]

I forgot to add the
dump_configuration.txt

[thinkoid]

A correction to the report. cpfe compiles C++ unless given a C option; the .c suffix does not select C. So the first run above, cpfe -A off.c, compiled C++03, the same as the --c++03 run. The report showed no C run.

The C runs give the same three errors:

$ cpfe --c89 -A --sys_include=$(gcc -print-file-name=include) --sys_include=/usr/include off.c
"off.c", line 3: error: function call is not allowed in a constant expression
  int a[offsetof (struct s, d)];
        ^

"off.c", line 3: error: expected an expression
  int a[offsetof (struct s, d)];
        ^

"off.c", line 3: error: identifier "d" is undefined
  int a[offsetof (struct s, d)];
        ^

3 errors detected in the compilation of "off.c".

--c99 -A gives the same output. So does the reduced off2.c under --c89 -A and --c99 -A.

The issue therefore covers C89, C99 and C++03 strict modes.