Re: [PATCH v4 next 22/23] tools/nolibc/printf: Add support for octal output

[Willy Tarreau <w@1wt.eu>]

On Mon, Mar 02, 2026 at 10:18:14AM +0000, david.laight.linux@gmail.com wrote:
> From: David Laight <david.laight.linux@gmail.com>
> 
> Octal output isn't often used, but adding it costs very little.
> 
> Supporting "%#o" is mildly annoying, it has to add a leading '0' if
> there isn't one present. In simple cases this is the same as adding a sign
> of '0' - but that adds an extra '0' in a few places.
> So you need 3 tests, %o, # and no leading '0' (which can only be checked
> after the zero pad for precision).
> If all the test are deferred until after zero padding then too many values
> are 'live' across the call to _nolibc_u64toa_base() and get spilled to stack.
> Hence the check that ignores the 'sign' if it is the same as the first
> character of the output string.

Looks good and can indeed be useful to display file modes or umasks.

> 
> Add tests for octal output.
> 
> Signed-off-by: David Laight <david.laight.linux@gmail.com>

Acked-by: Willy Tarreau <w@1wt.eu>

willy
> ---
> 
> v4:
> - Increase VFPRINTF_LEN to 25 to that 64bit octal output isn't truncated.
>   Change truncation tests to match.
>   (Was done earlier in v3.)
> 
> New patch for v3.
> Relies on the changes to u64toa_r() etc in stdlib.h (patch 2).
> 
>  tools/include/nolibc/stdio.h                 | 50 ++++++++++++++------
>  tools/testing/selftests/nolibc/nolibc-test.c |  9 ++--
>  2 files changed, 41 insertions(+), 18 deletions(-)
> 
> diff --git a/tools/include/nolibc/stdio.h b/tools/include/nolibc/stdio.h
> index 08011345275a..6036154be791 100644
> --- a/tools/include/nolibc/stdio.h
> +++ b/tools/include/nolibc/stdio.h
> @@ -292,7 +292,7 @@ int fseek(FILE *stream, long offset, int whence)
>  
>  
>  /* printf(). Supports most of the normal integer and string formats.
> - *  - %[#0-+ ][width|*[.precision|*}][{l,t,z,ll,L,j,q}]{c,d,i,u,x,X,p,s,m,%}
> + *  - %[#0-+ ][width|*[.precision|*}][{l,t,z,ll,L,j,q}]{c,d,i,u,o,x,X,p,s,m,%}
>   *  - %% generates a single %
>   *  - %m outputs strerror(errno).
>   *  - %X outputs a..f the same as %x.
> @@ -426,7 +426,7 @@ int __nolibc_printf(__nolibc_printf_cb cb, void *state, const char *fmt, va_list
>  		 */
>  		ch_flag = _NOLIBC_PF_FLAG(ch) | (flags & _NOLIBC_PF_FLAG('#')) >> 1;
>  		if (((ch >= 'a' && ch <= 'z') || ch == 'X') &&
> -		    _NOLIBC_PF_FLAGS_CONTAIN(ch_flag, 'c', 'd', 'i', 'u', 'x', 'p', 's')) {
> +		    _NOLIBC_PF_FLAGS_CONTAIN(ch_flag, 'c', 'd', 'i', 'u', 'o', 'x', 'p', 's')) {
>  			/* 'long' is needed for pointer/string conversions and ltz lengths.
>  			 * A single test can be used provided 'p' (the same bit as '0')
>  			 * is masked from flags.
> @@ -477,12 +477,19 @@ int __nolibc_printf(__nolibc_printf_cb cb, void *state, const char *fmt, va_list
>  				} else if (_NOLIBC_PF_FLAGS_CONTAIN(flags, ' ')) {
>  					sign_prefix = ' ';
>  				}
> +			} else {
> +				/* "#o" requires that the output always starts with a '0'.
> +				 * This needs another check after any zero padding to avoid
> +				 * adding an extra leading '0'.
> +				 */
> +				if (_NOLIBC_PF_FLAGS_CONTAIN(ch_flag, 'o') &&
> +						_NOLIBC_PF_FLAGS_CONTAIN(ch_flag, '#' - 1))
> +					sign_prefix = '0';
>  			}
>  
>  			/* The value is converted offset into the buffer so that
>  			 * 31 zero pad characters and the sign/prefix can be added in front.
> -			 * The longest digit string is 22 + 1 for octal conversions, the
> -			 * space is reserved even though octal isn't currently supported.
> +			 * The longest digit string is 22 + 1 for octal conversions.
>  			 */
>  			out = outbuf + 2 + 31;
>  
> @@ -495,7 +502,7 @@ int __nolibc_printf(__nolibc_printf_cb cb, void *state, const char *fmt, va_list
>  					goto do_output;
>  				}
>  				if (!precision) {
> -					/* Explicit %nn.0d, no digits output */
> +					/* Explicit %nn.0d, no digits output (except for %#.0o) */
>  					len = 0;
>  					goto prepend_sign;
>  				}
> @@ -504,17 +511,23 @@ int __nolibc_printf(__nolibc_printf_cb cb, void *state, const char *fmt, va_list
>  				len = 1;
>  			} else {
>  				/* Convert the number to ascii in the required base. */
> +				unsigned long long recip;
> +				unsigned int base;
>  				if (_NOLIBC_PF_FLAGS_CONTAIN(ch_flag, 'd', 'i', 'u')) {
> -					/* Base 10 */
> -					len = u64toa_r(v, out);
> +					base = 10;
> +					recip = _NOLIBC_U64TOA_RECIP(10);
> +				} else if (_NOLIBC_PF_FLAGS_CONTAIN(ch_flag, 'o')) {
> +					base = 8;
> +					recip = _NOLIBC_U64TOA_RECIP(8);
>  				} else {
> -					/* Base 16 */
> +					base = 16;
> +					recip = _NOLIBC_U64TOA_RECIP(16);
>  					if (_NOLIBC_PF_FLAGS_CONTAIN(ch_flag, 'p', '#' - 1)) {
>  						/* "%p" and "%#x" need "0x" prepending. */
>  						sign_prefix = 'x' | '0' << 8;
>  					}
> -					len = u64toh_r(v, out);
>  				}
> +				len = _nolibc_u64toa_base(v, out, base, recip);
>  			}
>  
>  			/* Add zero padding */
> @@ -545,13 +558,20 @@ int __nolibc_printf(__nolibc_printf_cb cb, void *state, const char *fmt, va_list
>  				}
>  			}
>  
> +			/* %#o has set sign_prefix to '0', but we don't want so add an extra
> +			 * leading zero here.
> +			 * Since the only other byte values of sign_prefix are ' ', '+' and '-'
> +			 * it is enough to check that out[] doesn't already start with sign_prefix.
> +			 */
> +			if (sign_prefix != *out) {
>  prepend_sign:
> -			/* Add the 0, 1 or 2 ("0x") sign/prefix characters at the front. */
> -			for (; sign_prefix; sign_prefix >>= 8) {
> -				/* Force gcc to increment len inside the loop. */
> -				_NOLIBC_OPTIMIZER_HIDE_VAR(len);
> -				len++;
> -				*--out = sign_prefix;
> +				/* Add the 0, 1 or 2 ("0x") sign/prefix characters at the front. */
> +				for (; sign_prefix; sign_prefix >>= 8) {
> +					/* Force gcc to increment len inside the loop. */
> +					_NOLIBC_OPTIMIZER_HIDE_VAR(len);
> +					len++;
> +					*--out = sign_prefix;
> +				}
>  			}
>  			outstr = out;
>  			goto do_output;
> diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
> index 7398827fa08b..29ad1207464f 100644
> --- a/tools/testing/selftests/nolibc/nolibc-test.c
> +++ b/tools/testing/selftests/nolibc/nolibc-test.c
> @@ -1663,7 +1663,7 @@ int run_stdlib(int min, int max)
>  #define EXPECT_VFPRINTF(cond, expected, fmt, ...)				\
>  	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_vfprintf(llen, expected, fmt, ##__VA_ARGS__); } while (0)
>  
> -#define VFPRINTF_LEN 20
> +#define VFPRINTF_LEN 25
>  static int expect_vfprintf(int llen, const char *expected, const char *fmt, ...)
>  {
>  	char buf[VFPRINTF_LEN + 80];
> @@ -1831,6 +1831,9 @@ static int run_printf(int min, int max)
>  		CASE_TEST(signed_min);   EXPECT_VFPRINTF(1, "-2147483648", "%i", (~0u >> 1) + 1); break;
>  		CASE_TEST(unsigned_max); EXPECT_VFPRINTF(1, "4294967295", "%u", ~0u); break;
>  		CASE_TEST(char);         EXPECT_VFPRINTF(1, "|c|d|   e|", "|%c|%.0c|%4c|", 'c', 'd', 'e'); break;
> +		CASE_TEST(octal);        EXPECT_VFPRINTF(1, "|17|  0033||", "|%o|%6.4o|%.0o|", 017, 033, 0); break;
> +		CASE_TEST(octal_max);    EXPECT_VFPRINTF(1, "1777777777777777777777", "%llo", ~0ULL); break;
> +		CASE_TEST(octal_alt);    EXPECT_VFPRINTF(1, "|0|01|02|034|0|", "|%#o|%#o|%#02o|%#02o|%#.0o|", 0, 1, 2, 034, 0); break;
>  		CASE_TEST(hex_nolibc);   EXPECT_VFPRINTF(is_nolibc, "|f|d|", "|%x|%X|", 0xf, 0xd); break;
>  		CASE_TEST(hex_libc);     EXPECT_VFPRINTF(!is_nolibc, "|f|D|", "|%x|%X|", 0xf, 0xd); break;
>  		CASE_TEST(hex_alt);      EXPECT_VFPRINTF(1, "|0x1|  0x2|    0|", "|%#x|%#5x|%#5x|", 1, 2, 0); break;
> @@ -1845,13 +1848,13 @@ static int run_printf(int min, int max)
>  		CASE_TEST(intmax_max);   EXPECT_VFPRINTF(1, "9223372036854775807", "%lld", ~0ULL >> 1); break;
>  		CASE_TEST(intmax_min);   EXPECT_VFPRINTF(1, "-9223372036854775808", "%Li", (~0ULL >> 1) + 1); break;
>  		CASE_TEST(uintmax_max);  EXPECT_VFPRINTF(1, "18446744073709551615", "%ju", ~0ULL); break;
> -		CASE_TEST(truncation);   EXPECT_VFPRINTF(1, "0123456789012345678901234", "%s", "0123456789012345678901234"); break;
> +		CASE_TEST(truncation);   EXPECT_VFPRINTF(1, "012345678901234567890123456789", "%s", "012345678901234567890123456789"); break;
>  		CASE_TEST(string_width); EXPECT_VFPRINTF(1, "         1", "%10s", "1"); break;
>  		CASE_TEST(string_trunc); EXPECT_VFPRINTF(1, "     12345", "%10.5s", "1234567890"); break;
>  		CASE_TEST(number_width); EXPECT_VFPRINTF(1, "         1", "%10d", 1); break;
>  		CASE_TEST(number_left);  EXPECT_VFPRINTF(1, "|-5      |", "|%-8d|", -5); break;
>  		CASE_TEST(string_align); EXPECT_VFPRINTF(1, "|foo     |", "|%-8s|", "foo"); break;
> -		CASE_TEST(width_trunc);  EXPECT_VFPRINTF(1, "                        1", "%25d", 1); break;
> +		CASE_TEST(width_trunc);  EXPECT_VFPRINTF(1, "                             1", "%30d", 1); break;
>  		CASE_TEST(width_tr_lft); EXPECT_VFPRINTF(1, "1                             ", "%-30d", 1); break;
>  		CASE_TEST(number_pad);   EXPECT_VFPRINTF(1, "0000000005", "%010d", 5); break;
>  		CASE_TEST(number_pad);   EXPECT_VFPRINTF(1, "|0000000005|0x1234|", "|%010d|%#01x|", 5, 0x1234); break;
> -- 
> 2.39.5