wbN: A suffix for specifying the width of a bit-precise integer literal

[alejandro-colomar]

Currently, we have no way of specifying the width of a bit-precise integer literal. We only have the wb suffix, which say "pick the smaller width possible".

That wb suffix is insufficient, as sometimes we need a type wider than the value we're using, if we're going to use for example shifts.

As an example, there's no good way (and by good, I mean something that doesn't involve casts) to create a value of width N (let's use 3 as a small example) where all bits are 1 except for the leftmost (or rightmost) one.

alx@debian:~/tmp$ cat bw.c 
int
main(void)
{
	unsigned _BitInt(3) i = ~0wb >> 1;

	return i;
}
alx@debian:~/tmp$ gcc -Wall -Wextra bw.c 
alx@debian:~/tmp$ ./a.out; echo $?
7
alx@debian:~/tmp$ clang -Weverything -Wno-c23-extensions -Wno-bit-int-extension bw.c 
bw.c:4:31: warning: implicit conversion changes signedness: '_BitInt(2)' to 'unsigned _BitInt(3)' [-Wsign-conversion]
    4 |         unsigned _BitInt(3) i = ~0wb >> 1;
      |                             ~   ~~~~~^~~~
1 warning generated.
alx@debian:~/tmp$ ./a.out; echo $?
7

It would make sense to be able to write it like this (IMO):

    unsigned _BitInt(3) i = ~0wb3u >> 1;  // stores the value 5 (0b011).

GCC bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119058
Cc: @AaronBallman

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Alejandro Colomar (alejandro-colomar)

Currently, we have no way of specifying the width of a bit-precise integer literal. We only have the wb suffix, which say "pick the smaller width possible".

That wb suffix is insufficient, as sometimes we need a type wider than the value we're using, if we're going to use for example shifts.

As an example, there's no good way (and by good, I mean something that doesn't involve casts) to create a value of width N (let's use 3 as a small example) where all bits are 1 except for the leftmost (or rightmost) one.

alx@<!-- -->debian:~/tmp$ cat bw.c 
int
main(void)
{
	unsigned _BitInt(3) i = ~0wb &gt;&gt; 1;

	return i;
}
alx@<!-- -->debian:~/tmp$ gcc -Wall -Wextra bw.c 
alx@<!-- -->debian:~/tmp$ ./a.out; echo $?
7
alx@<!-- -->debian:~/tmp$ clang -Weverything -Wno-c23-extensions -Wno-bit-int-extension bw.c 
bw.c:4:31: warning: implicit conversion changes signedness: '_BitInt(2)' to 'unsigned _BitInt(3)' [-Wsign-conversion]
    4 |         unsigned _BitInt(3) i = ~0wb &gt;&gt; 1;
      |                             ~   ~~~~~^~~~
1 warning generated.
alx@<!-- -->debian:~/tmp$ ./a.out; echo $?
7

It would make sense to be able to write it like this (IMO):

    unsigned _BitInt(3) i = ~0wb3u >> 1;  // stores the value 5 (0b011).

GCC bug: <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119058>
Cc: @AaronBallman

[frederick-vs-ja]

I'm tentatively treating this as extension request. But perhaps it can be a standard feature one day?

[alejandro-colomar]

I'm tentatively treating this as extension request. But perhaps it can be a standard feature one day?

Yep, my idea was precisely that. Start with an extension, and then request the C Committee to standardize it.

I can talk to the C Committee to make sure we don't implement it in a way that would be incompatible with an eventual standardized feature. I'll prepare a paper for the C Committee anyway, because GCC wants to see it.

[alejandro-colomar]

The example program I showed is not correct. Here's a more appropriate version, which uses an unsigned literal:

int
main(void)
{
	unsigned _BitInt(3)  i = ~0uwb >> 1;

	return i;
}

alx@debian:~/tmp$ gcc -Wall -Wextra uwb.c 
uwb.c: In function ‘main’:
uwb.c:4:40: warning: right shift count >= width of type [-Wshift-count-overflow]
    4 |         unsigned _BitInt(3)  i = ~0uwb >> 1;
      |                                        ^~
alx@debian:~/tmp$ ./a.out; echo $?
0

alx@debian:~/tmp$ clang -Weverything -Wno-c23-extensions -Wno-bit-int-extension uwb.c 
uwb.c:4:33: warning: shift count >= width of type [-Wshift-count-overflow]
    4 |         unsigned _BitInt(3)  i = ~0uwb >> 1;
      |                                        ^  ~
1 warning generated.
alx@debian:~/tmp$ ./a.out; echo $?
0

[alejandro-colomar]

I'm tentatively treating this as extension request. But perhaps it can be a standard feature one day?

Here's a paper I've presented unofficially today in the C Committee mailing list, and which I'll eventually submit officially.

Name
	alx-0034r0 - Add a bit-precise integer-literal suffix wbN

Category
	Add integer literal suffix.

Author
	Alejandro Colomar <alx@kernel.org>

History
	<https://www.alejandro-colomar.es/src/alx/alx/wg14/alx-0034.git/>

	r0 (2025-06-28):
	-  Initial draft.

Rationale
	It is currently impossible to generate a useful bit-precise
	integer literal to be used in bitwise operations.

	As an example, there's no good way (and by good, I mean
	something that doesn't involve casts) to create a value of
	width N (let's use 3 as a small example) where all bits are 1
	except for the leftmost (or rightmost) one.

		alx@debian:~/tmp$ cat uwb.c
		int
		main(void)
		{
			unsigned _BitInt(3)  i = ~0uwb >> 1;

			return i;
		}
		alx@debian:~/tmp$ gcc -Wall -Wextra uwb.c
		uwb.c: In function ‘main’:
		uwb.c:4:40: warning: right shift count >= width of type [-Wshift-count-overflow]
		    4 |         unsigned _BitInt(3)  i = ~0uwb >> 1;
		      |                                        ^~
		alx@debian:~/tmp$ ./a.out; echo $?
		0

	We'd need to be able to specify the width that we want the
	integer to have; in this case 3.  It could be done by appending
	a number of bits after 'wb':

		unsigned _BitInt(3)  i = ~0wb3 >> 1;

See also
	<https://github.com/llvm/llvm-project/issues/129256>
	<https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119058>

Proposed wording
	Based on N3550.

    6.4.5.2  Integer literals
	@@ Syntax, p1
	 integer-suffix:
		unsigned-suffix long-suffix(opt)
		unsigned-suffix long-long-suffix
		unsigned-suffix bit-precise-int-suffix
		long-suffix unsigned-suffix(opt)
		long-long-suffix unsigned-suffix(opt)
		bit-precise-int-suffix unsigned-suffix(opt)

	+bit-precise-int-suffix:
	+	narrow-bit-precise-int-suffix decimal-literal(opt)

	-bit-precise-int-suffix: one of
	+narrow-bit-precise-int-suffix: one of
		<b>wb</b> <b>WB</b>

	@@ Semantics, p7, Table 6.2 - Relationship between constants, suffixes, and types
	+---------------------------------------------------------------
	+	<b>wb</b><i>N</i>
	+	or
	+	<b>WB</b><i>N</i>
	+		|
	+		|	<b>_BitInt</b>(<i>N</i>)
	+		|		|
	+		|		|	<b>_BitInt</b>(<i>N</i>)
	+---------------------------------------------------------------
	+	Both
	+	<b>u</b> or <b>U</b>
	+	and
	+	<b>wb</b><i>N</i>
	+	or
	+	<b>WB</b><i>N</i>
	+		|
	+		|	<b>unsigned _BitInt</b>(<i>N</i>)
	+		|		|
	+		|		|	<b>unsigned _BitInt</b>(<i>N</i>)
	+---------------------------------------------------------------

	@@ p8
	 If an integer literal that does not have
	-suffixes wb, WB, uwb, or UWB
	+a bit-precise integer suffix
	 cannot be represented by any type in its list,
	...
	## We don't need to specify all combinations.
	## Just use the name that refers to all at once.

	@@ p9, EXAMPLE 2
	...
	+	3uwb7	/* Yields an unsigned _BitInt(7); */

    A.2.5  Constants
	## Update.