From fcac32277c883bf28196af64b35ac92b9b8e4c96 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Wed, 10 Jun 2026 11:47:35 +0200 Subject: [PATCH v4 1/5] Replace __builtin_types_compatible_p with _Generic _Generic is the C11 standard equivalent (and superset) of __builtin_types_compatible_p, so by replacing the latter with the former, we can now rely on this working on all compilers, instead of previously just with GCC-compatible ones. And we can drop a configure test. This affects StaticAssertVariableIsOfType() and StaticAssertVariableIsOfTypeMacro() and indirectly unconstify() and unvolatize(). Neither _Generic nor __builtin_types_compatible_p works in C++, so this does not change that, but this adds an explicit code comment about that. There are some subtle behavior changes, but these do not affect cases that are in use or likely to be useful. _Generic does lvalue conversion on the controlling expression, which means it drops top-level qualifiers and converts arrays to pointers. __builtin_types_compatible_p on the other hand, supports arrays and just ignores qualifiers. So before, StaticAssertVariableIsOfType(x, const int) might have worked, but now it does not. (But note that it would previously have succeeded even if x was a non-const int, so this usage would always have been dubious.) Also, StaticAssertVariableIsOfType(y, char[]) would have worked, but now you need to write char *. (But this is not backward compatible, because char * would previously not have succeeded.) Similarly, unconstify of non-pointers, like unconstify(const int, x) would previously have worked, but this was just by accident and never useful (you can just assign directly, without a cast), and the C++ implementation rejects non-pointers anyway. Some comments are added to explain this a bit. There are no current uses affected by this. Note that even though we have required C11 since f5e0186f865, we have not made use of _Generic until now (except in an MSVC-specific case in commit 59c2f03d1ec). This now raises the effective compiler requirement on the trailing edge slightly from GCC 4.8 to GCC 4.9. This in turn means that we effectively drop support for RHEL 7. Discussion: https://www.postgresql.org/message-id/flat/CA+hUKGL7trhWiJ4qxpksBztMMTWDyPnP1QN+Lq341V7QL775DA@mail.gmail.com --- config/c-compiler.m4 | 19 ------------------- configure | 30 ------------------------------ configure.ac | 1 - meson.build | 15 --------------- src/include/c.h | 32 ++++++++++++++++---------------- src/include/pg_config.h.in | 3 --- 6 files changed, 16 insertions(+), 84 deletions(-) diff --git a/config/c-compiler.m4 b/config/c-compiler.m4 index 3eab0da9cb6..f05b744667c 100644 --- a/config/c-compiler.m4 +++ b/config/c-compiler.m4 @@ -267,25 +267,6 @@ fi])# PGAC_CXX_TYPEOF_UNQUAL -# PGAC_C_TYPES_COMPATIBLE -# ----------------------- -# Check if the C compiler understands __builtin_types_compatible_p, -# and define HAVE__BUILTIN_TYPES_COMPATIBLE_P if so. -# -# We check usage with __typeof__, though it's unlikely any compiler would -# have the former and not the latter. -AC_DEFUN([PGAC_C_TYPES_COMPATIBLE], -[AC_CACHE_CHECK(for __builtin_types_compatible_p, pgac_cv__types_compatible, -[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], -[[ int x; static int y[__builtin_types_compatible_p(__typeof__(x), int)]; ]])], -[pgac_cv__types_compatible=yes], -[pgac_cv__types_compatible=no])]) -if test x"$pgac_cv__types_compatible" = xyes ; then -AC_DEFINE(HAVE__BUILTIN_TYPES_COMPATIBLE_P, 1, - [Define to 1 if your compiler understands __builtin_types_compatible_p.]) -fi])# PGAC_C_TYPES_COMPATIBLE - - # PGAC_C_BUILTIN_CONSTANT_P # ------------------------- # Check if the C compiler understands __builtin_constant_p(), diff --git a/configure b/configure index 5f77f3cac29..abb53707581 100755 --- a/configure +++ b/configure @@ -15181,36 +15181,6 @@ cat >>confdefs.h <<_ACEOF _ACEOF fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for __builtin_types_compatible_p" >&5 -$as_echo_n "checking for __builtin_types_compatible_p... " >&6; } -if ${pgac_cv__types_compatible+:} false; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - int x; static int y[__builtin_types_compatible_p(__typeof__(x), int)]; - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - pgac_cv__types_compatible=yes -else - pgac_cv__types_compatible=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv__types_compatible" >&5 -$as_echo "$pgac_cv__types_compatible" >&6; } -if test x"$pgac_cv__types_compatible" = xyes ; then - -$as_echo "#define HAVE__BUILTIN_TYPES_COMPATIBLE_P 1" >>confdefs.h - fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __builtin_constant_p" >&5 $as_echo_n "checking for __builtin_constant_p... " >&6; } diff --git a/configure.ac b/configure.ac index 61cee42daa7..a9db28c22c1 100644 --- a/configure.ac +++ b/configure.ac @@ -1727,7 +1727,6 @@ PGAC_C_TYPEOF PGAC_CXX_TYPEOF PGAC_C_TYPEOF_UNQUAL PGAC_CXX_TYPEOF_UNQUAL -PGAC_C_TYPES_COMPATIBLE PGAC_C_BUILTIN_CONSTANT_P PGAC_C_BUILTIN_OP_OVERFLOW PGAC_C_BUILTIN_UNREACHABLE diff --git a/meson.build b/meson.build index 568e0e150bf..364809a394c 100644 --- a/meson.build +++ b/meson.build @@ -2062,21 +2062,6 @@ foreach builtin : builtins endforeach -# Check if the C compiler understands __builtin_types_compatible_p, -# and define HAVE__BUILTIN_TYPES_COMPATIBLE_P if so. -# -# We check usage with __typeof__, though it's unlikely any compiler would -# have the former and not the latter. -if cc.compiles(''' - static int x; - static int y[__builtin_types_compatible_p(__typeof__(x), int)]; - ''', - name: '__builtin_types_compatible_p', - args: test_c_args) - cdata.set('HAVE__BUILTIN_TYPES_COMPATIBLE_P', 1) -endif - - # Check if the C compiler understands __builtin_$op_overflow(), # and define HAVE__BUILTIN_OP_OVERFLOW if so. # diff --git a/src/include/c.h b/src/include/c.h index f32989a6331..dd90156eb3f 100644 --- a/src/include/c.h +++ b/src/include/c.h @@ -1049,29 +1049,24 @@ pg_noreturn extern void ExceptionalCondition(const char *conditionName, /* * Compile-time checks that a variable (or expression) has the specified type. * + * The type must not have top-level qualifiers (const, volatile) and must not + * be an array (use pointer instead). (This wouldn't work because _Generic + * does lvalue conversion on the controlling expression, which drops + * qualifiers and converts arrays to pointers.) Qualifiers inside pointers + * are allowed. + * * StaticAssertVariableIsOfType() can be used as a declaration. * StaticAssertVariableIsOfTypeMacro() is intended for use in macros, eg * #define foo(x) (StaticAssertVariableIsOfTypeMacro(x, int), bar(x)) * - * If we don't have __builtin_types_compatible_p, we can still assert that - * the types have the same size. This is far from ideal (especially on 32-bit - * platforms) but it provides at least some coverage. + * Note that these do not work in C++. */ -#ifdef HAVE__BUILTIN_TYPES_COMPATIBLE_P -#define StaticAssertVariableIsOfType(varname, typename) \ - StaticAssertDecl(__builtin_types_compatible_p(typeof(varname), typename), \ - CppAsString(varname) " does not have type " CppAsString(typename)) -#define StaticAssertVariableIsOfTypeMacro(varname, typename) \ - (StaticAssertExpr(__builtin_types_compatible_p(typeof(varname), typename), \ - CppAsString(varname) " does not have type " CppAsString(typename))) -#else /* !HAVE__BUILTIN_TYPES_COMPATIBLE_P */ #define StaticAssertVariableIsOfType(varname, typename) \ - StaticAssertDecl(sizeof(varname) == sizeof(typename), \ + StaticAssertDecl(_Generic((varname), typename: 1, default: 0), \ CppAsString(varname) " does not have type " CppAsString(typename)) #define StaticAssertVariableIsOfTypeMacro(varname, typename) \ - (StaticAssertExpr(sizeof(varname) == sizeof(typename), \ + (StaticAssertExpr(_Generic((varname), typename: 1, default: 0), \ CppAsString(varname) " does not have type " CppAsString(typename))) -#endif /* HAVE__BUILTIN_TYPES_COMPATIBLE_P */ /* ---------------------------------------------------------------- @@ -1308,8 +1303,13 @@ typedef struct PGAlignedXLogBlock PGAlignedXLogBlock; /* * Macro that allows to cast constness and volatile away from an expression, but doesn't - * allow changing the underlying type. Enforcement of the latter - * currently only works for gcc like compilers. + * allow changing the underlying type. + * + * This is only meant to work for qualifiers behind at least one level of + * pointer. (In the C implementation, the StaticAssertVariableIsOfTypeMacro + * will drop top-level qualifiers, so with a non-pointer, the static assertion + * will fail. In the C++ implementation, const_cast will error for + * non-pointers.) * * Please note IT IS NOT SAFE to cast constness away if the result will ever * be modified (it would be undefined behaviour). Doing so anyway can cause diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in index 4f8113c144b..661c4a9b168 100644 --- a/src/include/pg_config.h.in +++ b/src/include/pg_config.h.in @@ -544,9 +544,6 @@ /* Define to 1 if your compiler understands __builtin_$op_overflow. */ #undef HAVE__BUILTIN_OP_OVERFLOW -/* Define to 1 if your compiler understands __builtin_types_compatible_p. */ -#undef HAVE__BUILTIN_TYPES_COMPATIBLE_P - /* Define to 1 if your compiler understands __builtin_unreachable. */ #undef HAVE__BUILTIN_UNREACHABLE base-commit: e18b0cb7344cb4bd28468f6c0aeeb9b9241d30aa -- 2.54.0