On Thu, 28 May 2026, Peter Damianov wrote:
> C23 adds a memalignment function to determine the alignment of a pointer.
> Given how simple it is (convert pointer to an integer then return (p & -p)),
> GCC should support expanding it inline.
>
> This patch implements __builtin_memalignment which expands to p & -p
>
> gcc/ChangeLog:
>
> PR middle-end/122117
> * builtin-types.def (BT_FN_SIZE_CONST_PTR): New function type.
> * builtins.def (BUILT_IN_MEMALIGNMENT): New C23 builtin.
> * builtins.cc (fold_builtin_memalignment): New function to fold
> __builtin_memalignment to (size_t)ptr & -(size_t)ptr.
> (fold_builtin_1): Handle BUILT_IN_MEMALIGNMENT.
> (is_inexpensive_builtin): Add BUILT_IN_MEMALIGNMENT.
>
> gcc/testsuite/ChangeLog:
>
> * gcc.dg/builtin-memalignment.c: New test.
> * gcc.dg/builtin-memalignment-1.c: New test.
>
> Signed-off-by: Peter Damianov <[email protected]>
> ---
> gcc/builtin-types.def | 1 +
> gcc/builtins.cc | 32 +++++
> gcc/builtins.def | 1 +
> gcc/testsuite/gcc.dg/builtin-memalignment-1.c | 30 ++++
> gcc/testsuite/gcc.dg/builtin-memalignment.c | 134 ++++++++++++++++++
> 5 files changed, 198 insertions(+)
> create mode 100644 gcc/testsuite/gcc.dg/builtin-memalignment-1.c
> create mode 100644 gcc/testsuite/gcc.dg/builtin-memalignment.c
>
> diff --git a/gcc/builtin-types.def b/gcc/builtin-types.def
> index ab0cbc65cfc..08f1c29785c 100644
> --- a/gcc/builtin-types.def
> +++ b/gcc/builtin-types.def
> @@ -360,6 +360,7 @@ DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_FLOAT32X,
> BT_LONGLONG, BT_FLOAT32X)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_FLOAT64X, BT_LONGLONG, BT_FLOAT64X)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_FLOAT128X, BT_LONGLONG, BT_FLOAT128X)
> DEF_FUNCTION_TYPE_1 (BT_FN_VOID_PTR, BT_VOID, BT_PTR)
> +DEF_FUNCTION_TYPE_1 (BT_FN_SIZE_CONST_PTR, BT_SIZE, BT_CONST_PTR)
> DEF_FUNCTION_TYPE_1 (BT_FN_SIZE_CONST_STRING, BT_SIZE, BT_CONST_STRING)
> DEF_FUNCTION_TYPE_1 (BT_FN_INT_CONST_STRING, BT_INT, BT_CONST_STRING)
> DEF_FUNCTION_TYPE_1 (BT_FN_PTR_PTR, BT_PTR, BT_PTR)
> diff --git a/gcc/builtins.cc b/gcc/builtins.cc
> index 692e20088c2..c9c19e2f955 100644
> --- a/gcc/builtins.cc
> +++ b/gcc/builtins.cc
> @@ -172,6 +172,7 @@ static tree fold_builtin_abs (location_t, tree, tree);
> static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum
> tree_code,
> enum tree_code);
> static tree fold_builtin_iseqsig (location_t, tree, tree);
> +static tree fold_builtin_memalignment (location_t, tree);
> static tree fold_builtin_varargs (location_t, tree, tree*, int);
>
> static tree fold_builtin_strpbrk (location_t, tree, tree, tree, tree);
> @@ -10119,6 +10120,33 @@ fold_builtin_iseqsig (location_t loc, tree arg0,
> tree arg1)
> return fold_build2_loc (loc, TRUTH_AND_EXPR, integer_type_node, cmp1,
> cmp2);
> }
>
> +/* Fold a call to __builtin_memalignment(). ARG is the pointer argument.
> + The code is folded to: (size_t)ARG & -(size_t)ARG */
> +
> +static tree
> +fold_builtin_memalignment (location_t loc, tree arg)
> +{
> + tree ptr_as_size, negated, result;
> +
> + if (!validate_arg (arg, POINTER_TYPE))
> + return NULL_TREE;
> +
> + /* Save ARG to ensure side effects occur only once. */
> + arg = builtin_save_expr (arg);
> +
> + /* Convert pointer to size_t. */
> + ptr_as_size = fold_convert_loc (loc, size_type_node, arg);
I think using size_t is wrong here, you need to use an integer
type of the same precision as the pointer argument.
tree utype = unsigned_type_for (TREE_TYPE (arg));
> +
> + /* Negate: -(size_t)ARG */
> + negated = fold_build1_loc (loc, NEGATE_EXPR, size_type_node, ptr_as_size);
> +
> + /* Compute: (size_t)ARG & -(size_t)ARG */
> + result = fold_build2_loc (loc, BIT_AND_EXPR, size_type_node,
> + ptr_as_size, negated);
And convert the result to size_t if the API requires that.
> +
> + return result;
> +}
> +
> /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
> arithmetics if it can never overflow, or into internal functions that
> return both result of arithmetics and overflowed boolean flag in
> @@ -10788,6 +10816,9 @@ fold_builtin_1 (location_t loc, tree expr, tree
> fndecl, tree arg0)
> case BUILT_IN_POPCOUNTG:
> return fold_builtin_bit_query (loc, fcode, arg0, NULL_TREE);
>
> + case BUILT_IN_MEMALIGNMENT:
> + return fold_builtin_memalignment (loc, arg0);
> +
> default:
> break;
> }
> @@ -12399,6 +12430,7 @@ is_inexpensive_builtin (tree decl)
> case BUILT_IN_PARITYLL:
> case BUILT_IN_PARITYIMAX:
> case BUILT_IN_PARITY:
> + case BUILT_IN_MEMALIGNMENT:
> case BUILT_IN_LABS:
> case BUILT_IN_LLABS:
> case BUILT_IN_PREFETCH:
> diff --git a/gcc/builtins.def b/gcc/builtins.def
> index 8ab0599b17f..f6bc7082112 100644
> --- a/gcc/builtins.def
> +++ b/gcc/builtins.def
> @@ -1024,6 +1024,7 @@ DEF_GCC_BUILTIN (BUILT_IN_BSWAP16, "bswap16",
> BT_FN_UINT16_UINT16, ATTR_C
> DEF_GCC_BUILTIN (BUILT_IN_BSWAP32, "bswap32", BT_FN_UINT32_UINT32,
> ATTR_CONST_NOTHROW_LEAF_LIST)
> DEF_GCC_BUILTIN (BUILT_IN_BSWAP64, "bswap64", BT_FN_UINT64_UINT64,
> ATTR_CONST_NOTHROW_LEAF_LIST)
> DEF_GCC_BUILTIN (BUILT_IN_BSWAP128, "bswap128",
> BT_FN_UINT128_UINT128, ATTR_CONST_NOTHROW_LEAF_LIST)
> +DEF_C23_BUILTIN (BUILT_IN_MEMALIGNMENT, "memalignment",
> BT_FN_SIZE_CONST_PTR, ATTR_CONST_NOTHROW_LEAF_LIST)
>
> DEF_EXT_LIB_BUILTIN (BUILT_IN_CLEAR_CACHE, "__clear_cache",
> BT_FN_VOID_PTR_PTR, ATTR_NOTHROW_LEAF_LIST)
> /* [trans-mem]: Adjust BUILT_IN_TM_CALLOC if BUILT_IN_CALLOC is changed. */
> diff --git a/gcc/testsuite/gcc.dg/builtin-memalignment-1.c
> b/gcc/testsuite/gcc.dg/builtin-memalignment-1.c
> new file mode 100644
> index 00000000000..09d81f6ee3a
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/builtin-memalignment-1.c
> @@ -0,0 +1,30 @@
> +/* Compile-time constant folding test for __builtin_memalignment */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized" } */
> +
> +/* Test that constant expressions fold to constants */
> +__SIZE_TYPE__ test_const_16 (void)
> +{
> + return __builtin_memalignment ((void *)16);
What's the header for 'memalignment'? Shouldn't we have tests
covering the non-__builtin use with C23?
Richard.
> +}
> +
> +__SIZE_TYPE__ test_const_24 (void)
> +{
> + return __builtin_memalignment ((void *)24);
> +}
> +
> +__SIZE_TYPE__ test_const_0 (void)
> +{
> + return __builtin_memalignment ((void *)0);
> +}
> +
> +__SIZE_TYPE__ test_const_48 (void)
> +{
> + return __builtin_memalignment ((void *)48);
> +}
> +
> +/* Verify that all calls are folded to constants and the builtin is
> eliminated */
> +/* { dg-final { scan-tree-dump-not "__builtin_memalignment" "optimized" } }
> */
> +/* { dg-final { scan-tree-dump-times "return 16;" 2 "optimized" } } */
> +/* { dg-final { scan-tree-dump "return 8;" "optimized" } } */
> +/* { dg-final { scan-tree-dump "return 0;" "optimized" } } */
> diff --git a/gcc/testsuite/gcc.dg/builtin-memalignment.c
> b/gcc/testsuite/gcc.dg/builtin-memalignment.c
> new file mode 100644
> index 00000000000..5557abdbfb4
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/builtin-memalignment.c
> @@ -0,0 +1,134 @@
> +/* { dg-do run } */
> +/* { dg-options "-O2 -fdump-tree-optimized" } */
> +
> +extern void abort (void);
> +
> +static int call_count = 0;
> +static int side_effect_var;
> +
> +static int *get_ptr_with_side_effect (void)
> +{
> + call_count++;
> + return &side_effect_var;
> +}
> +
> +void test_alignment (void *ptr, __SIZE_TYPE__ expected)
> +{
> + __SIZE_TYPE__ result = __builtin_memalignment (ptr);
> + if (result != expected)
> + abort ();
> +}
> +
> +/* Verify that constant folding happens */
> +void test_constant_p (void)
> +{
> + /* These should be compile-time constants */
> + if (!__builtin_constant_p (__builtin_memalignment ((void *)16)))
> + abort ();
> + if (!__builtin_constant_p (__builtin_memalignment ((void *)24)))
> + abort ();
> + if (!__builtin_constant_p (__builtin_memalignment ((void *)0)))
> + abort ();
> +}
> +
> +int main (void)
> +{
> + /* Test with null pointer - alignment should be 0 */
> + test_alignment ((void *)0, 0);
> +
> + /* Test powers of 2 alignments */
> + test_alignment ((void *)1, 1);
> + test_alignment ((void *)2, 2);
> + test_alignment ((void *)4, 4);
> + test_alignment ((void *)8, 8);
> + test_alignment ((void *)16, 16);
> + test_alignment ((void *)32, 32);
> + test_alignment ((void *)64, 64);
> + test_alignment ((void *)128, 128);
> + test_alignment ((void *)256, 256);
> +
> + /* Test non-power-of-2 addresses */
> + test_alignment ((void *)3, 1); /* 0b11 -> alignment 1 */
> + test_alignment ((void *)5, 1); /* 0b101 -> alignment 1 */
> + test_alignment ((void *)6, 2); /* 0b110 -> alignment 2 */
> + test_alignment ((void *)12, 4); /* 0b1100 -> alignment 4 */
> + test_alignment ((void *)24, 8); /* 0b11000 -> alignment 8 */
> + test_alignment ((void *)48, 16); /* 0b110000 -> alignment 16 */
> +
> + /* Verify constant folding happens */
> + test_constant_p ();
> +
> + /* Test with variables having different alignments */
> + char c __attribute__((aligned(1)));
> + short s __attribute__((aligned(2)));
> + int i __attribute__((aligned(4)));
> + long long ll __attribute__((aligned(8)));
> + char a16 __attribute__((aligned(16)));
> + char a32 __attribute__((aligned(32)));
> + char a64 __attribute__((aligned(64)));
> +
> + __SIZE_TYPE__ align_c = __builtin_memalignment(&c);
> + __SIZE_TYPE__ align_s = __builtin_memalignment(&s);
> + __SIZE_TYPE__ align_i = __builtin_memalignment(&i);
> + __SIZE_TYPE__ align_ll = __builtin_memalignment(&ll);
> + __SIZE_TYPE__ align_a16 = __builtin_memalignment(&a16);
> + __SIZE_TYPE__ align_a32 = __builtin_memalignment(&a32);
> + __SIZE_TYPE__ align_a64 = __builtin_memalignment(&a64);
> +
> + /* The alignment should be at least what we requested */
> + if (align_c < 1)
> + abort();
> + if (align_s < 2)
> + abort();
> + if (align_i < 4)
> + abort();
> + if (align_ll < 8)
> + abort();
> + if (align_a16 < 16)
> + abort();
> + if (align_a32 < 32)
> + abort();
> + if (align_a64 < 64)
> + abort();
> +
> + /* Test array elements */
> + int array[16] __attribute__((aligned(64)));
> +
> + /* First element should have the array's alignment */
> + if (__builtin_memalignment(&array[0]) < 64)
> + abort();
> +
> + /* Other elements depend on their offset */
> + /* array[1] is at offset 4, so alignment is 4 */
> + if (__builtin_memalignment(&array[1]) != 4)
> + abort();
> +
> + /* array[2] is at offset 8, so alignment is 8 */
> + if (__builtin_memalignment(&array[2]) != 8)
> + abort();
> +
> + /* array[4] is at offset 16, so alignment is 16 */
> + if (__builtin_memalignment(&array[4]) != 16)
> + abort();
> +
> + /* Test that side effects occur exactly once */
> + call_count = 0;
> + __SIZE_TYPE__ align = __builtin_memalignment(get_ptr_with_side_effect());
> + if (call_count != 1)
> + abort(); /* Side effect should happen exactly once */
> + if (align < 4)
> + abort();
> +
> + /* Test with post-increment */
> + int *p = &array[0];
> + align = __builtin_memalignment(p++);
> + if (p != &array[1])
> + abort(); /* Post-increment should happen */
> + if (align < 64)
> + abort();
> +
> + return 0;
> +}
> +
> +/* Verify that the builtin is eliminated and replaced with the inline
> computation */
> +/* { dg-final { scan-tree-dump-not "__builtin_memalignment" "optimized" } }
> */
>
--
Richard Biener <[email protected]>
SUSE Software Solutions Germany GmbH,
Frankenstrasse 146, 90461 Nuernberg, Germany;
GF: Jochen Jaser, Andrew McDonald, Werner Knoblich; (HRB 36809, AG Nuernberg)
