On Thu, 9 Jul 2026, Jakub Jelinek wrote:
> On Wed, Jul 08, 2026 at 11:54:31AM +0200, Jakub Jelinek wrote:
> > On Wed, Jul 08, 2026 at 10:25:30AM +0200, Jakub Jelinek wrote:
> > > I'm afraid this approach is incorrect.
> > >
> > > The problem is that in GIMPLE pointer casts are useless, so what exact
> > > pointee you get is quite random, and it can be completely unrelated type.
> > > If one e.g. does
> > > void
> > > foo (unsigned _BitInt(17) *p, bool x)
> > > {
> > > if (x)
> > > __atomic_add_fetch (p, 0x0fff0, 0);
> > > else
> > > __atomic_add_fetch ((unsigned long *) p, 0x0fff0, 0);
> > > }
> > > you can get unsigned _BitInt(17) "incorrectly" in both cases, while
> > > void
> > > bar (unsigned long *p, bool x)
> > > {
> > > if (x)
> > > __atomic_add_fetch ((unsigned _BitInt(17) *) p, 0x0fff0, 0);
> > > else
> > > __atomic_add_fetch (p, 0x0fff0, 0);
> > > }
> > > in neither, etc.
> > > IMNSHO, if unsigned _BitInt(17) * pointer makes it to say
> > > __atomic_add_fetch_4,
> > > then it should be irrelevant, the required operation is still to load
> > > full 32 bits from the pointer, add another 32 bit value to it and store
> > > full 32 bits.
> > >
> > > IMNSHO this is solely about some of the type-generic atomic/sync builtins
> > > (those documented to take TYPE * arguments) and needs to be handled in the
> > > FE, likely in gcc/c-family/c-common.cc (resolve_overloaded_builtin).
> > > There already is code to transform various type-generic builtins into a
> > > CAS
> > > loop for say unsigned _BitInt(253), so I think it should be used also for
> > > the case where the type is BITINT_TYPE with any padding bits in the
> > > extend other than bitint_ext_undef mode.
> >
> > Here is a completely untested patch for that, but guess the test
> > I've posted in the last mail needs to be turned into a proper executable
> > testcase and verify (e.g. using bitintext.h macros) whether the extension
> > was right.
>
> I've added a testcase and that revealed a bug in the patch, in the
> __sync_fetch_and_* cases the patch returned the new value anyway like
> in the __sync_*_and_fetch case.
>
> The following patch fixes that.
>
> So far tested with a cross to riscv64-linux and running the test on cfarm94.
>
> Ok for trunk if this passes bootstrap/regtest on x86_64-linux and
> i686-linux?
LGTM.
Thanks,
Richard.
> 2026-07-09 Jakub Jelinek <[email protected]>
>
> PR target/124948
> * c-common.cc (sync_resolve_size): Return -1 for fetch ops
> on _BitInt types with padding bits where the target requires
> extension into the padding bits.
> (atomic_bitint_fetch_using_cas_loop): Handle also __sync_*
> fetch builtins.
>
> * gcc.dg/torture/bitint-100.c: New test.
>
> --- gcc/c-family/c-common.cc.jj 2026-07-08 11:09:58.407725160 +0200
> +++ gcc/c-family/c-common.cc 2026-07-09 09:48:53.446148261 +0200
> @@ -7746,7 +7746,23 @@ sync_resolve_size (tree function, vec<tr
> }
>
> if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
> - return size;
> + {
> + /* For _BitInt with padding bits where the ABI mandates sign or
> + zero extension into the padding bits, force a CAS loop so that
> + the extension is properly performed. */
> + if (fetch
> + && BITINT_TYPE_P (type)
> + && (TYPE_PRECISION (type)
> + != GET_MODE_PRECISION (SCALAR_TYPE_MODE (type))))
> + {
> + struct bitint_info info;
> + bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
> + gcc_assert (ok);
> + if (info.extended != bitint_ext_undef)
> + return -1;
> + }
> + return size;
> + }
>
> if (fetch && !orig_format && BITINT_TYPE_P (type))
> return -1;
> @@ -8405,7 +8421,8 @@ resolve_overloaded_atomic_store (locatio
> }
>
> /* Emit __atomic*fetch* on _BitInt which doesn't have a size of
> - 1, 2, 4, 8 or 16 bytes using __atomic_compare_exchange loop.
> + 1, 2, 4, 8 or 16 bytes (or if it has padding bits and they
> + need to be extended) using __atomic_compare_exchange loop.
> ORIG_CODE is the DECL_FUNCTION_CODE of ORIG_FUNCTION and
> ORIG_PARAMS arguments of the call. */
>
> @@ -8417,6 +8434,7 @@ atomic_bitint_fetch_using_cas_loop (loca
> {
> enum tree_code code = ERROR_MARK;
> bool return_old_p = false;
> + bool sync_p = false;
> switch (orig_code)
> {
> case BUILT_IN_ATOMIC_ADD_FETCH_N:
> @@ -8459,13 +8477,65 @@ atomic_bitint_fetch_using_cas_loop (loca
> code = BIT_IOR_EXPR;
> return_old_p = true;
> break;
> + case BUILT_IN_SYNC_ADD_AND_FETCH_N:
> + code = PLUS_EXPR;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_SUB_AND_FETCH_N:
> + code = MINUS_EXPR;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_OR_AND_FETCH_N:
> + code = BIT_IOR_EXPR;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_AND_AND_FETCH_N:
> + code = BIT_AND_EXPR;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_XOR_AND_FETCH_N:
> + code = BIT_XOR_EXPR;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_NAND_AND_FETCH_N:
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_FETCH_AND_ADD_N:
> + code = PLUS_EXPR;
> + return_old_p = true;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_FETCH_AND_SUB_N:
> + code = MINUS_EXPR;
> + return_old_p = true;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_FETCH_AND_OR_N:
> + code = BIT_IOR_EXPR;
> + return_old_p = true;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_FETCH_AND_AND_N:
> + code = BIT_AND_EXPR;
> + return_old_p = true;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_FETCH_AND_XOR_N:
> + code = BIT_XOR_EXPR;
> + return_old_p = true;
> + sync_p = true;
> + break;
> + case BUILT_IN_SYNC_FETCH_AND_NAND_N:
> + return_old_p = true;
> + sync_p = true;
> + break;
> default:
> gcc_unreachable ();
> }
>
> - if (orig_params->length () != 3)
> + if (orig_params->length () != (sync_p ? 2 : 3))
> {
> - if (orig_params->length () < 3)
> + if (orig_params->length () < (sync_p ? 2 : 3))
> error_at (loc, "too few arguments to function %qE", orig_function);
> else
> error_at (loc, "too many arguments to function %qE", orig_function);
> @@ -8480,12 +8550,14 @@ atomic_bitint_fetch_using_cas_loop (loca
>
> tree lhs_addr = (*orig_params)[0];
> tree val = convert (nonatomic_lhs_type, (*orig_params)[1]);
> - tree model = convert (integer_type_node, (*orig_params)[2]);
> + tree model
> + = sync_p ? NULL_TREE : convert (integer_type_node, (*orig_params)[2]);
> if (!c_dialect_cxx ())
> {
> lhs_addr = c_fully_fold (lhs_addr, false, NULL);
> val = c_fully_fold (val, false, NULL);
> - model = c_fully_fold (model, false, NULL);
> + if (model)
> + model = c_fully_fold (model, false, NULL);
> }
> if (TREE_SIDE_EFFECTS (lhs_addr))
> {
> @@ -8501,7 +8573,7 @@ atomic_bitint_fetch_using_cas_loop (loca
> NULL_TREE);
> add_stmt (val);
> }
> - if (TREE_SIDE_EFFECTS (model))
> + if (model && TREE_SIDE_EFFECTS (model))
> {
> tree var = create_tmp_var_raw (integer_type_node);
> model = build4 (TARGET_EXPR, integer_type_node, var, model, NULL_TREE,
> @@ -8519,6 +8591,8 @@ atomic_bitint_fetch_using_cas_loop (loca
> TREE_ADDRESSABLE (newval) = 1;
> suppress_warning (newval);
>
> + tree retval = NULL_TREE;
> +
> tree loop_decl = create_artificial_label (loc);
> tree loop_label = build1 (LABEL_EXPR, void_type_node, loop_decl);
>
> @@ -8582,21 +8656,43 @@ atomic_bitint_fetch_using_cas_loop (loca
>
> /* if (__atomic_compare_exchange (addr, &old, &new, false, model, model))
> goto done; */
> - fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_COMPARE_EXCHANGE);
> + if (sync_p)
> + fndecl = builtin_decl_explicit (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N);
> + else
> + fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_COMPARE_EXCHANGE);
> params->quick_push (lhs_addr);
> - params->quick_push (old_addr);
> - params->quick_push (newval_addr);
> - params->quick_push (integer_zero_node);
> - params->quick_push (model);
> - if (tree_fits_uhwi_p (model)
> - && (tree_to_uhwi (model) == MEMMODEL_RELEASE
> - || tree_to_uhwi (model) == MEMMODEL_ACQ_REL))
> - params->quick_push (build_int_cst (integer_type_node, MEMMODEL_RELAXED));
> + if (sync_p)
> + {
> + params->quick_push (old);
> + params->quick_push (newval);
> + }
> else
> - params->quick_push (model);
> + {
> + params->quick_push (old_addr);
> + params->quick_push (newval_addr);
> + params->quick_push (integer_zero_node);
> + params->quick_push (model);
> + if (tree_fits_uhwi_p (model)
> + && (tree_to_uhwi (model) == MEMMODEL_RELEASE
> + || tree_to_uhwi (model) == MEMMODEL_ACQ_REL))
> + params->quick_push (build_int_cst (integer_type_node,
> + MEMMODEL_RELAXED));
> + else
> + params->quick_push (model);
> + }
> func_call = resolve_overloaded_builtin (loc, fndecl, params);
> if (func_call == NULL_TREE)
> func_call = build_function_call_vec (loc, vNULL, fndecl, params, NULL);
> + if (sync_p)
> + {
> + if (return_old_p)
> + retval = create_tmp_var_raw (nonatomic_lhs_type);
> + else
> + retval = old;
> + func_call = build2 (MODIFY_EXPR, void_type_node, retval, func_call);
> + tree cmp = build2 (EQ_EXPR, boolean_type_node, retval, newval);
> + func_call = build2 (COMPOUND_EXPR, boolean_type_node, func_call, cmp);
> + }
>
> tree goto_stmt = build1 (GOTO_EXPR, void_type_node, done_decl);
> SET_EXPR_LOCATION (goto_stmt, loc);
> @@ -8606,6 +8702,12 @@ atomic_bitint_fetch_using_cas_loop (loca
> SET_EXPR_LOCATION (stmt, loc);
> add_stmt (stmt);
>
> + if (sync_p && return_old_p)
> + {
> + stmt = build2_loc (loc, MODIFY_EXPR, void_type_node, old, retval);
> + add_stmt (stmt);
> + }
> +
> /* goto loop; */
> goto_stmt = build1 (GOTO_EXPR, void_type_node, loop_decl);
> SET_EXPR_LOCATION (goto_stmt, loc);
> --- gcc/testsuite/gcc.dg/torture/bitint-100.c.jj 2026-07-09
> 08:25:06.764615958 +0200
> +++ gcc/testsuite/gcc.dg/torture/bitint-100.c 2026-07-09 09:19:20.063962240
> +0200
> @@ -0,0 +1,197 @@
> +/* PR target/124948 */
> +/* { dg-do run { target bitint } } */
> +/* { dg-options "-std=c23 -pedantic-errors" } */
> +/* { dg-skip-if "" { ! run_expensive_tests } { "*" } { "-O0" "-O2" } } */
> +/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
> +
> +_BitInt(17) a;
> +unsigned _BitInt(17) b;
> +
> +#include "../bitintext.h"
> +
> +[[gnu::noipa]] _BitInt(17)
> +f1 (_BitInt(17) *p, _BitInt(32) q)
> +{
> + return __atomic_add_fetch (p, q, __ATOMIC_RELAXED);
> +}
> +
> +[[gnu::noipa]] _BitInt(17)
> +f2 (_BitInt(17) *p, _BitInt(32) q)
> +{
> + return __atomic_sub_fetch (p, q, __ATOMIC_RELAXED);
> +}
> +
> +[[gnu::noipa]] _BitInt(17)
> +f3 (_BitInt(17) *p, _BitInt(32) q)
> +{
> + return __atomic_fetch_add (p, q, __ATOMIC_RELAXED);
> +}
> +
> +[[gnu::noipa]] _BitInt(17)
> +f4 (_BitInt(17) *p, _BitInt(32) q)
> +{
> + return __atomic_fetch_sub (p, q, __ATOMIC_RELAXED);
> +}
> +
> +[[gnu::noipa]] _BitInt(17)
> +f5 (_BitInt(17) *p, _BitInt(32) q)
> +{
> + return __sync_add_and_fetch (p, q);
> +}
> +
> +[[gnu::noipa]] _BitInt(17)
> +f6 (_BitInt(17) *p, _BitInt(32) q)
> +{
> + return __sync_sub_and_fetch (p, q);
> +}
> +
> +[[gnu::noipa]] _BitInt(17)
> +f7 (_BitInt(17) *p, _BitInt(32) q)
> +{
> + return __sync_fetch_and_add (p, q);
> +}
> +
> +[[gnu::noipa]] _BitInt(17)
> +f8 (_BitInt(17) *p, _BitInt(32) q)
> +{
> + return __sync_fetch_and_sub (p, q);
> +}
> +
> +[[gnu::noipa]] unsigned _BitInt(17)
> +f9 (unsigned _BitInt(17) *p, unsigned _BitInt(32) q)
> +{
> + return __atomic_add_fetch (p, q, __ATOMIC_RELAXED);
> +}
> +
> +[[gnu::noipa]] unsigned _BitInt(17)
> +f10 (unsigned _BitInt(17) *p, unsigned _BitInt(32) q)
> +{
> + return __atomic_sub_fetch (p, q, __ATOMIC_RELAXED);
> +}
> +
> +[[gnu::noipa]] unsigned _BitInt(17)
> +f11 (unsigned _BitInt(17) *p, unsigned _BitInt(32) q)
> +{
> + return __atomic_fetch_add (p, q, __ATOMIC_RELAXED);
> +}
> +
> +[[gnu::noipa]] unsigned _BitInt(17)
> +f12 (unsigned _BitInt(17) *p, unsigned _BitInt(32) q)
> +{
> + return __atomic_fetch_sub (p, q, __ATOMIC_RELAXED);
> +}
> +
> +[[gnu::noipa]] unsigned _BitInt(17)
> +f13 (unsigned _BitInt(17) *p, unsigned _BitInt(32) q)
> +{
> + return __sync_add_and_fetch (p, q);
> +}
> +
> +[[gnu::noipa]] unsigned _BitInt(17)
> +f14 (unsigned _BitInt(17) *p, unsigned _BitInt(32) q)
> +{
> + return __sync_sub_and_fetch (p, q);
> +}
> +
> +[[gnu::noipa]] unsigned _BitInt(17)
> +f15 (unsigned _BitInt(17) *p, unsigned _BitInt(32) q)
> +{
> + return __sync_fetch_and_add (p, q);
> +}
> +
> +[[gnu::noipa]] unsigned _BitInt(17)
> +f16 (unsigned _BitInt(17) *p, unsigned _BitInt(32) q)
> +{
> + return __sync_fetch_and_sub (p, q);
> +}
> +
> +int
> +main ()
> +{
> + _BitInt(17) c;
> + unsigned _BitInt(17) d;
> + a = 64295wb;
> + BEXTC (a);
> + c = f1 (&a, 187040987wb);
> + BEXTC (a);
> + BEXTC (c);
> + if (a != -65534wb || c != a)
> + __builtin_abort ();
> + c = f2 (&a, 394264674wb);
> + BEXTC (a);
> + BEXTC (c);
> + if (a != 65440wb || c != a)
> + __builtin_abort ();
> + c = f3 (&a, 840434595wb);
> + BEXTC (a);
> + BEXTC (c);
> + if (a != -64701wb || c != 65440wb)
> + __builtin_abort ();
> + c = f4 (&a, 591403122wb);
> + BEXTC (a);
> + BEXTC (c);
> + if (a != 60113wb || c != -64701wb)
> + __builtin_abort ();
> + c = f5 (&a, 1215571163wb);
> + BEXTC (a);
> + BEXTC (c);
> + if (a != -61524wb || c != a)
> + __builtin_abort ();
> + c = f6 (&a, 1913664021wb);
> + BEXTC (a);
> + BEXTC (c);
> + if (a != 56727wb || c != a)
> + __builtin_abort ();
> + c = f7 (&a, 858931586wb);
> + BEXTC (a);
> + BEXTC (c);
> + if (a != -57575wb || c != 56727wb)
> + __builtin_abort ();
> + c = f8 (&a, 286413601wb);
> + BEXTC (a);
> + BEXTC (c);
> + if (a != 52216wb || c != -57575wb)
> + __builtin_abort ();
> + b = 77593uwb;
> + BEXTC (b);
> + d = f9 (&b, 858861337uwb);
> + BEXTC (b);
> + BEXTC (d);
> + if (b != 24114uwb || d != b)
> + __builtin_abort ();
> + d = f10 (&b, 1431383831uwb);
> + BEXTC (b);
> + BEXTC (d);
> + if (b != 77595uwb || d != b)
> + __builtin_abort ();
> + d = f11 (&b, 305231735uwb);
> + BEXTC (b);
> + BEXTC (d);
> + if (b != 42642uwb || d != 77595uwb)
> + __builtin_abort ();
> + d = f12 (&b, 591497352uwb);
> + BEXTC (b);
> + BEXTC (d);
> + if (b != 73226uwb || d != 42642uwb)
> + __builtin_abort ();
> + d = f13 (&b, 1985058934uwb);
> + BEXTC (b);
> + BEXTC (d);
> + if (b != 46720uwb || d != b)
> + __builtin_abort ();
> + d = f14 (&b, 840018893uwb);
> + BEXTC (b);
> + BEXTC (d);
> + if (b != 68275uwb || d != b)
> + __builtin_abort ();
> + d = f15 (&b, 1698807006uwb);
> + BEXTC (b);
> + BEXTC (d);
> + if (b != 51089uwb || d != 68275uwb)
> + __builtin_abort ();
> + d = f16 (&b, 877788892uwb);
> + BEXTC (b);
> + BEXTC (d);
> + if (b != 51381uwb || d != 51089uwb)
> + __builtin_abort ();
> +}
>
>
> Jakub
>
>
--
Richard Biener <[email protected]>
SUSE Software Solutions Germany GmbH,
Frankenstrasse 146, 90461 Nuernberg, Germany;
GF: Jochen Jaser, Andrew McDonald; (HRB 36809, AG Nuernberg)
