Refer to C23 in place of C2X in glibc

WG14 decided to use the name C23 as the informal name of the next
revision of the C standard (notwithstanding the publication date in
2024).  Update references to C2X in glibc to use the C23 name.

This is intended to update everything *except* where it involves
renaming files (the changes involving renaming tests are intended to
be done separately).  In the case of the _ISOC2X_SOURCE feature test
macro - the only user-visible interface involved - support for that
macro is kept for backwards compatibility, while adding
_ISOC23_SOURCE.

Tested for x86_64.

6 files changed, 49 insertions, 49 deletions

diff --git a/math/bits/mathcalls.h b/math/bits/mathcalls.h
index 4916ffb..f46d300 100644
--- a/math/bits/mathcalls.h
+++ b/math/bits/mathcalls.h
@@ -109,7 +109,7 @@ __MATHCALL_VEC (log10,, (_Mdouble_ __x));
 /* Break VALUE into integral and fractional parts.  */
 __MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr)) __nonnull ((2));
 
-#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C23)
 /* Compute exponent to base ten.  */
 __MATHCALL_VEC (exp10,, (_Mdouble_ __x));
 #endif
@@ -264,7 +264,7 @@ __MATHCALL (nextafter,, (_Mdouble_ __x, _Mdouble_ __y));
 __MATHCALL (nexttoward,, (_Mdouble_ __x, long double __y));
 # endif
 
-# if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN
+# if __GLIBC_USE (IEC_60559_BFP_EXT_C23) || __MATH_DECLARING_FLOATN
 /* Return X - epsilon.  */
 __MATHCALL (nextdown,, (_Mdouble_ __x));
 /* Return X + epsilon.  */
@@ -283,7 +283,7 @@ __MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
 __MATHDECL (int,ilogb,, (_Mdouble_ __x));
 #endif
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23) || __MATH_DECLARING_FLOATN
 /* Like ilogb, but returning long int.  */
 __MATHDECL (long int, llogb,, (_Mdouble_ __x));
 #endif
@@ -328,7 +328,7 @@ __MATHDECL (long long int,llround,, (_Mdouble_ __x));
 /* Return positive difference between X and Y.  */
 __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
 
-# if !__MATH_DECLARING_FLOATN || defined __USE_GNU || !__GLIBC_USE (ISOC2X)
+# if !__MATH_DECLARING_FLOATN || defined __USE_GNU || !__GLIBC_USE (ISOC23)
 /* Return maximum numeric value from X and Y.  */
 __MATHCALLX (fmax,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
 
@@ -340,7 +340,7 @@ __MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
 __MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
 #endif /* Use ISO C99.  */
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23) || __MATH_DECLARING_FLOATN
 /* Round X to nearest integer value, rounding halfway cases to even.  */
 __MATHCALLX (roundeven,, (_Mdouble_ __x), (__const__));
 
@@ -372,7 +372,7 @@ __MATHDECL_1 (int, canonicalize,, (_Mdouble_ *__cx, const _Mdouble_ *__x));
 
 #if (__GLIBC_USE (IEC_60559_BFP_EXT)				\
      || (__MATH_DECLARING_FLOATN				\
-	 && (defined __USE_GNU || !__GLIBC_USE (ISOC2X))))
+	 && (defined __USE_GNU || !__GLIBC_USE (ISOC23))))
 /* Return value with maximum magnitude.  */
 __MATHCALLX (fmaxmag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
 
@@ -380,7 +380,7 @@ __MATHCALLX (fmaxmag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
 __MATHCALLX (fminmag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
 #endif
 
-#if __GLIBC_USE (ISOC2X)
+#if __GLIBC_USE (ISOC23)
 /* Return maximum value from X and Y.  */
 __MATHCALLX (fmaximum,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
 
diff --git a/math/fenv.h b/math/fenv.h
index 33548fa..72af93b 100644
--- a/math/fenv.h
+++ b/math/fenv.h
@@ -77,7 +77,7 @@ extern int fegetexceptflag (fexcept_t *__flagp, int __excepts) __THROW;
 /* Raise the supported exceptions represented by EXCEPTS.  */
 extern int feraiseexcept (int __excepts) __THROW;
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 /* Set the supported exception flags represented by EXCEPTS, without
    causing enabled traps to be taken.  */
 extern int fesetexcept (int __excepts) __THROW;
@@ -91,7 +91,7 @@ extern int fesetexceptflag (const fexcept_t *__flagp, int __excepts) __THROW;
    currently set.  */
 extern int fetestexcept (int __excepts) __THROW;
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 /* Determine which of subset of the exceptions specified by EXCEPTS
    are set in *FLAGP.  */
 extern int fetestexceptflag (const fexcept_t *__flagp, int __excepts) __THROW;
@@ -130,7 +130,7 @@ extern int feupdateenv (const fenv_t *__envp) __THROW;
 
 /* Control modes.  */
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 /* Store the current floating-point control modes in the object
    pointed to by MODEP.  */
 extern int fegetmode (femode_t *__modep) __THROW;
@@ -143,7 +143,7 @@ extern int fesetmode (const femode_t *__modep) __THROW;
 
 /* NaN support.  */
 
-#if (__GLIBC_USE (IEC_60559_BFP_EXT_C2X)		\
+#if (__GLIBC_USE (IEC_60559_BFP_EXT_C23)		\
      && defined FE_INVALID			\
      && defined __SUPPORT_SNAN__)
 # define FE_SNANS_ALWAYS_SIGNAL	1
diff --git a/math/gen-tgmath-tests.py b/math/gen-tgmath-tests.py
index f6f5c5a..216e464 100755
--- a/math/gen-tgmath-tests.py
+++ b/math/gen-tgmath-tests.py
@@ -25,7 +25,7 @@
 # complex integer types, which are a GNU extension, but are currently
 # disabled here because they do not work properly with tgmath.h).
 
-# C2x makes the <tgmath.h> rules for selecting a function to call
+# C23 makes the <tgmath.h> rules for selecting a function to call
 # correspond to the usual arithmetic conversions (applied successively
 # to the arguments for generic parameters in order), which choose the
 # type whose set of values contains that of the other type (undefined
@@ -743,7 +743,7 @@ class Tests(object):
                 self.add_tests(prefix + fn, ret, ['r'] * args)
         # TS 18661-4 functions.
         self.add_tests('exp10', 'r', ['r'])
-        # C2X functions.
+        # C23 functions.
         self.add_tests('fmaximum', 'r', ['r', 'r'])
         self.add_tests('fmaximum_mag', 'r', ['r', 'r'])
         self.add_tests('fmaximum_num', 'r', ['r', 'r'])
diff --git a/math/libm-test-pow.inc b/math/libm-test-pow.inc
index 314cd41..914cde0 100644
--- a/math/libm-test-pow.inc
+++ b/math/libm-test-pow.inc
@@ -249,7 +249,7 @@ static const struct test_ff_f_data pow_test_data[] =
     TEST_ff_f (pow, 0, plus_infty, 0, ERRNO_UNCHANGED),
     TEST_ff_f (pow, minus_zero, plus_infty, 0, ERRNO_UNCHANGED),
     /* C99 erroneously specified a divide-by-zero exception here,
-       which is not permitted in C2x (C11 specified it as optional).
+       which is not permitted in C23 (C11 specified it as optional).
        See <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1515.pdf>
        and
        <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2271.pdf>.  */
diff --git a/math/math.h b/math/math.h
index a1631a8..1e300c4 100644
--- a/math/math.h
+++ b/math/math.h
@@ -114,37 +114,37 @@ __BEGIN_DECLS
 #endif
 #if (__HAVE_FLOAT16					\
      && __GLIBC_USE (IEC_60559_TYPES_EXT)		\
-     && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
+     && (defined __USE_GNU || !__GLIBC_USE (ISOC23)))
 # define SNANF16 (__builtin_nansf16 (""))
 #endif
 #if (__HAVE_FLOAT32					\
      && __GLIBC_USE (IEC_60559_TYPES_EXT)		\
-     && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
+     && (defined __USE_GNU || !__GLIBC_USE (ISOC23)))
 # define SNANF32 (__builtin_nansf32 (""))
 #endif
 #if (__HAVE_FLOAT64					\
      && __GLIBC_USE (IEC_60559_TYPES_EXT)		\
-     && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
+     && (defined __USE_GNU || !__GLIBC_USE (ISOC23)))
 # define SNANF64 (__builtin_nansf64 (""))
 #endif
 #if (__HAVE_FLOAT128					\
      && __GLIBC_USE (IEC_60559_TYPES_EXT)		\
-     && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
+     && (defined __USE_GNU || !__GLIBC_USE (ISOC23)))
 # define SNANF128 (__builtin_nansf128 (""))
 #endif
 #if (__HAVE_FLOAT32X					\
      && __GLIBC_USE (IEC_60559_TYPES_EXT)		\
-     && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
+     && (defined __USE_GNU || !__GLIBC_USE (ISOC23)))
 # define SNANF32X (__builtin_nansf32x (""))
 #endif
 #if (__HAVE_FLOAT64X					\
      && __GLIBC_USE (IEC_60559_TYPES_EXT)		\
-     && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
+     && (defined __USE_GNU || !__GLIBC_USE (ISOC23)))
 # define SNANF64X (__builtin_nansf64x (""))
 #endif
 #if (__HAVE_FLOAT128X					\
      && __GLIBC_USE (IEC_60559_TYPES_EXT)		\
-     && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
+     && (defined __USE_GNU || !__GLIBC_USE (ISOC23)))
 # define SNANF128X (__builtin_nansf128x (""))
 #endif
 
@@ -214,7 +214,7 @@ typedef _Float128x double_t;
 #  define FP_ILOGBNAN	2147483647
 # endif
 #endif
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 # if __WORDSIZE == 32
 #  define __FP_LONG_MAX 0x7fffffffL
 # else
@@ -246,7 +246,7 @@ typedef _Float128x double_t;
 
 #include <bits/fp-fast.h>
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 /* Rounding direction macros for fromfp functions.  */
 enum
   {
@@ -558,7 +558,7 @@ extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
 #define __MATHCALL_NARROW(func, redir, nargs)	\
   __MATHCALL_NARROW_NORMAL (func, nargs)
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 
 # define _Mret_ float
 # define _Marg_ double
@@ -1051,7 +1051,7 @@ enum
 
 #endif /* Use ISO C99.  */
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 # include <bits/iscanonical.h>
 
 /* Return nonzero value if X is a signaling NaN.  */
@@ -1332,7 +1332,7 @@ iszero (__T __val)
 # endif
 #endif
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 /* An expression whose type has the widest of the evaluation formats
    of X and Y (which are of floating-point types).  */
 # if __FLT_EVAL_METHOD__ == 2 || __FLT_EVAL_METHOD__ > 64
diff --git a/math/tgmath.h b/math/tgmath.h
index d3654e8..dbfa92d 100644
--- a/math/tgmath.h
+++ b/math/tgmath.h
@@ -42,12 +42,12 @@
    versions before GCC 13 have __builtin_tgmath semantics that, when
    integer arguments are passed to narrowing macros returning
    _Float32x, or non-narrowing macros with at least two generic
-   arguments, do not always correspond to the C2X semantics, so more
+   arguments, do not always correspond to the C23 semantics, so more
    complicated macro definitions are also used in some cases for
    versions from GCC 8 to GCC 12.  */
 
 #define __HAVE_BUILTIN_TGMATH __GNUC_PREREQ (8, 0)
-#define __HAVE_BUILTIN_TGMATH_C2X __GNUC_PREREQ (13, 0)
+#define __HAVE_BUILTIN_TGMATH_C23 __GNUC_PREREQ (13, 0)
 
 #if __GNUC_PREREQ (2, 7)
 
@@ -171,7 +171,7 @@
   __builtin_tgmath (__TGMATH_NARROW_FUNCS_F64 (F) (X), (Y))
 #  define __TGMATH_3_NARROW_F64(F, X, Y, Z)				\
   __builtin_tgmath (__TGMATH_NARROW_FUNCS_F64 (F) (X), (Y), (Z))
-#  if __HAVE_FLOAT128 && __HAVE_BUILTIN_TGMATH_C2X
+#  if __HAVE_FLOAT128 && __HAVE_BUILTIN_TGMATH_C23
 #   define __TGMATH_1_NARROW_F32X(F, X)				\
   __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32X (F) (X))
 #   define __TGMATH_2_NARROW_F32X(F, X, Y)			\
@@ -182,7 +182,7 @@
 
 # endif
 
-# if !__HAVE_BUILTIN_TGMATH_C2X
+# if !__HAVE_BUILTIN_TGMATH_C23
 #  ifdef __NO_LONG_DOUBLE_MATH
 #   define __tgml(fct) fct
 #  else
@@ -261,20 +261,20 @@
 			     __complex_integer_type (__typeof__ (+(expr))))
 
 /* The tgmath real type of EXPR1 combined with EXPR2, without handling
-   the C2X rule of interpreting integer arguments as _Float32x if any
+   the C23 rule of interpreting integer arguments as _Float32x if any
    argument is _FloatNx.  */
 #  define __tgmath_real_type2_base(expr1, expr2)			\
   __typeof ((__tgmath_real_type (expr1)) 0 + (__tgmath_real_type (expr2)) 0)
 
 /* The tgmath complex type of EXPR1 combined with EXPR2, without
-   handling the C2X rule of interpreting integer arguments as
+   handling the C23 rule of interpreting integer arguments as
    _Float32x if any argument is _FloatNx.  */
 #  define __tgmath_complex_type2_base(expr1, expr2)	\
   __typeof ((__tgmath_complex_type (expr1)) 0		\
 	    + (__tgmath_complex_type (expr2)) 0)
 
 /* The tgmath real type of EXPR1 combined with EXPR2 and EXPR3,
-   without handling the C2X rule of interpreting integer arguments as
+   without handling the C23 rule of interpreting integer arguments as
    _Float32x if any argument is _FloatNx.  */
 #  define __tgmath_real_type3_base(expr1, expr2, expr3)	\
   __typeof ((__tgmath_real_type (expr1)) 0		\
@@ -361,7 +361,7 @@
 #   define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) /* Nothing.  */
 #  endif
 
-# endif /* !__HAVE_BUILTIN_TGMATH_C2X.  */
+# endif /* !__HAVE_BUILTIN_TGMATH_C23.  */
 
 /* We have two kinds of generic macros: to support functions which are
    only defined on real valued parameters and those which are defined
@@ -374,13 +374,13 @@
   __TGMATH_2 (Fct, (Val1), (Val2))
 #  define __TGMATH_BINARY_FIRST_REAL_STD_ONLY(Val1, Val2, Fct)	\
   __TGMATH_2STD (Fct, (Val1), (Val2))
-#  if __HAVE_BUILTIN_TGMATH_C2X
+#  if __HAVE_BUILTIN_TGMATH_C23
 #   define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct)	\
   __TGMATH_2 (Fct, (Val1), (Val2))
 #  endif
 #  define __TGMATH_BINARY_REAL_STD_ONLY(Val1, Val2, Fct)	\
   __TGMATH_2STD (Fct, (Val1), (Val2))
-#  if __HAVE_BUILTIN_TGMATH_C2X
+#  if __HAVE_BUILTIN_TGMATH_C23
 #   define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \
   __TGMATH_3 (Fct, (Val1), (Val2), (Val3))
 #   define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct)	\
@@ -395,7 +395,7 @@
   __TGMATH_1C (Fct, Cfct, (Val))
 #  define __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME(Val, Cfct)	\
   __TGMATH_1 (Cfct, (Val))
-#  if __HAVE_BUILTIN_TGMATH_C2X
+#  if __HAVE_BUILTIN_TGMATH_C23
 #   define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct)	\
   __TGMATH_2C (Fct, Cfct, (Val1), (Val2))
 #  endif
@@ -441,7 +441,7 @@
 		     : (__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2)))
 # endif
 
-# if !__HAVE_BUILTIN_TGMATH_C2X
+# if !__HAVE_BUILTIN_TGMATH_C23
 #  define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \
      (__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double)	      \
 		      && __builtin_classify_type ((Val1) + (Val2)) == 8)      \
@@ -479,7 +479,7 @@
 		       Fct##f (Val1, Val2)))
 # endif
 
-# if !__HAVE_BUILTIN_TGMATH_C2X
+# if !__HAVE_BUILTIN_TGMATH_C23
 #  define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \
      (__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double)	      \
 		      && __builtin_classify_type ((Val1) + (Val2)) == 8)      \
@@ -597,7 +597,7 @@
   __TGMATH_UNARY_REAL_IMAG_RET_REAL ((Val), Cfct, Cfct)
 # endif
 
-# if !__HAVE_BUILTIN_TGMATH_C2X
+# if !__HAVE_BUILTIN_TGMATH_C23
 /* XXX This definition has to be changed as soon as the compiler understands
    the imaginary keyword.  */
 #  define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \
@@ -664,7 +664,7 @@
    distinguished using sizeof (or at all if the types are typedefs
    rather than different types, in which case we err on the side of
    using the wider type if unsure).  */
-# if !__HAVE_BUILTIN_TGMATH_C2X
+# if !__HAVE_BUILTIN_TGMATH_C23
 #  if __HAVE_FLOATN_NOT_TYPEDEF
 #   define __TGMATH_NARROW_F32X_USE_F64X(X)			\
   !__builtin_types_compatible_p (__typeof (+(X)), _Float64)
@@ -714,7 +714,7 @@
 		  F ## f64x (X, Y, Z)					\
 		  : F ## f128 (X, Y, Z)))
 #  endif
-#  if !__HAVE_BUILTIN_TGMATH_C2X
+#  if !__HAVE_BUILTIN_TGMATH_C23
 #   define __TGMATH_1_NARROW_F32X(F, X)					\
   (__extension__ (sizeof ((__tgmath_real_type (X)) 0) > sizeof (_Float64) \
 		  || __TGMATH_NARROW_F32X_USE_F64X (X)			\
@@ -761,7 +761,7 @@
 #   define __TGMATH_3_NARROW_F64(F, X, Y, Z)	\
   (F ## f128 (X, Y, Z))
 #  endif
-#  if !__HAVE_BUILTIN_TGMATH_C2X
+#  if !__HAVE_BUILTIN_TGMATH_C23
 #   define __TGMATH_1_NARROW_F32X(F, X)					\
   (__extension__ (sizeof ((__tgmath_real_type (X)) 0) > sizeof (_Float32x) \
 		  || __TGMATH_NARROW_F32X_USE_F64X (X)			\
@@ -871,7 +871,7 @@
 /* Compute base-2 logarithm of X.  */
 #define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2)
 
-#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C23)
 /* Compute exponent to base ten.  */
 #define exp10(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp10)
 #endif
@@ -949,7 +949,7 @@
    prevailing rounding mode.  */
 #define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint)
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 /* Return X - epsilon.  */
 # define nextdown(Val) __TGMATH_UNARY_REAL_ONLY (Val, nextdown)
 /* Return X + epsilon.  */
@@ -983,7 +983,7 @@
 /* Return positive difference between X and Y.  */
 #define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim)
 
-#if __GLIBC_USE (ISOC2X) && !defined __USE_GNU
+#if __GLIBC_USE (ISOC23) && !defined __USE_GNU
 /* Return maximum numeric value from X and Y.  */
 # define fmax(Val1, Val2) __TGMATH_BINARY_REAL_STD_ONLY (Val1, Val2, fmax)
 
@@ -1002,7 +1002,7 @@
 #define fma(Val1, Val2, Val3) \
      __TGMATH_TERNARY_REAL_ONLY (Val1, Val2, Val3, fma)
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 /* Round X to nearest integer value, rounding halfway cases to even.  */
 # define roundeven(Val) __TGMATH_UNARY_REAL_ONLY (Val, roundeven)
 
@@ -1030,7 +1030,7 @@
 # define fminmag(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminmag)
 #endif
 
-#if __GLIBC_USE (ISOC2X)
+#if __GLIBC_USE (ISOC23)
 /* Return maximum value from X and Y.  */
 # define fmaximum(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum)
 
@@ -1086,7 +1086,7 @@
 
 /* Narrowing functions.  */
 
-#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
 
 /* Add.  */
 # define fadd(Val1, Val2) __TGMATH_2_NARROW_F (fadd, Val1, Val2)