tools/nolibc/printf: Add support for octal output

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.

Add tests for octal output.

Signed-off-by: David Laight <david.laight.linux@gmail.com>
Acked-by: Willy Tarreau <w@1wt.eu>
Link: https://patch.msgid.link/20260308113742.12649-17-david.laight.linux@gmail.com
[Thomas: avoid a -Wsign-compare]
Signed-off-by: Thomas Weißschuh <linux@weissschuh.net>

diff --git a/tools/include/nolibc/stdio.h b/tools/include/nolibc/stdio.h
index 1294004afb300da176514a31516e0ff84d80b8be..8f7e1948a651e0c604f3bb226880d8d1746debb3 100644 (file)
--- 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.
@@ -479,12 +479,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;
 
@@ -497,7 +504,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;
                                }
@@ -506,17 +513,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 = '0' << 8 | 'x';
                                        }
-                                       len = u64toh_r(v, out);
                                }
+                               len = _nolibc_u64toa_base(v, out, base, recip);
                        }
 
                        /* Add zero padding */
@@ -547,13 +560,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 9695d9b359cd3825471a9297cce617c9e3809827..7836162dcd2f0a09a258df0f22fbd28f112d7649 100644 (file)
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -1671,7 +1671,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];
@@ -1839,6 +1839,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;
@@ -1853,13 +1856,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(is_nolibc || is_glibc, "-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;