# Printf and Scanf in Picolibc

Embedded systems are often tightly constrained on code space, which
makes it important to be able to only include code and data actually
needed by the application. The format-string based interface to
printf and scanf makes it very difficult to determine which
conversion operations might be needed by the application.

Picolibc handles this by providing multiple printf and scanf
implementations in the library with varying levels of conversion
support. The application developer selects among these at compile and
link time based on knowledge of the requirements of the
application. The selection is done using compiler command line
options, `--printf` and `--scanf` which map the public printf and
scanf names to internal names in the linker. These both take one of
the available variants as the option value:
	
	cc --printf=i --scanf=i

The function name mapping happens in picolibc.specs file which uses
these options to add --defsym options when linking. These options also
set a preprocessor symbol which handles the 'f' variant, so you need
to pass these options during both compilation and linking.

Using the defsym approach, rather than renaming the functions with the
C preprocessor has a couple of benefits:

 * Printf uses within picolibc (which are all integer-only) now share
   whichever printf the application needs, avoiding including both
   integer-only and float versions

 * Printf optimizations in the compiler which map to puts or fputs now
   work even when using integer-only or float printf functions.

Make sure you use only the option associated with the desired function
as --defsym will force the underlying code to be included in the
output even if unused.

The defsym approach does not work with link-time optimization. In that
case, applications can only use the default. The library must be
compiled with the desired variant as the default (using the
`-Dformat-default` configuration option).

## Printf and Scanf levels in Picolibc

There are five levels of printf support provided by Picolibc that can
be selected when building applications. One of these is the default
used when no symbol definitions are applied; that is selected using
the picolibc built-time option, `-Dformat-default`, which defaults to
`double`. The picolibc specs for GCC includes support for --printf and
--scanf options which set both the preprocessor defines as well as
configuring the linker to alias vfprintf and vfscanf to the desired
function using the --defsym linker command line option. For instance,
if you use cc --printf=d --scanf=l, the compiler will see

	-D_PICOLIBC_PRINTF='d' -D_PICOLIBC_SCANF='l'

and the linker will see

	--defsym=vfprintf=__d_vfprintf --defsym=vfscanf=__l_vfscanf

A linker that supports -alias instead of --defsym would see

	-alias,__d_vfprintf,vfprintf -alias,__l_vfscanf,vfscanf

When not using the picolibc specs, you can manually specify these on
the compiler command line

These are listed in order of decreasing functionality and
size.

 * 'd' format (default when `-Dformat-default=d`). This offers full printf
   functionality, including both float and double conversions along
   with the C99 extensions and POSIX positional parameters. There is
   optional support for the C23 %b format specifier via the
   `io-percent-b` setting and optional support for long double values
   via the `io-long-double` setting.

 * 'f' format (default when `-Dformat-default=f`). This is the
   same as 'd' format except that it supports only float for scanf and
   supports float instead of double for printf. It also doesn't
   support long double conversions.

 * 'l' format (default when `-Dformat-default=l`). This
   removes support for all float and double conversions and makes
   support for C99 extensions and POSIX positional parameters optional
   via the `io-c99-formats` and `io-pos-args` settings.

 * 'i' format (default when `-Dformat-default=i`). This removes
   support for long long conversions where those values are larger
   than long values.

 * 'm' format (default when`-Dformat-default=m`). This removes support
   for width and precision, alternate presentation modes and alternate
   sign presentation. All of these are still parsed correctly, so
   applications needn't adjust format strings in most cases, but the
   output will not be the same. It also disables any support for
   positional arguments and %b formats that might be selected with
   `io-pos-args` or `io-percent-b`.

'f' format requires a special macro for float values:
`printf_float`. To make it easier to switch between that and the
default level, that macro is also correctly defined for the other two
levels.

Here's an example program to experiment with these options:

```c
#include <stdio.h>
#include <stdlib.h>

void main(void) {
	printf(" 2⁶¹ = %lld π ≃ %.17g\n", 1ll << 61, printf_float(3.141592653589793));
	_Exit(0);
}
```

Now we can build and run it with the double options:

	$ arm-none-eabi-gcc --oslib=semihost -march=armv7-m -Os -o printf.elf printf.c
	$ arm-none-eabi-size printf.elf
	   text	   data	    bss	    dec	    hex	filename
	   7544	     80	   4104	  11728	   2dd0	printf.elf
	$ qemu-system-arm -semihosting -machine mps2-an385 -nographic -kernel printf.elf
	 2⁶¹ = 2305843009213693952 π ≃ 3.141592653589793

Switching to float-only reduces the size but lets this still work,
although the floating point value has reduced precision:

	$ arm-none-eabi-gcc --oslib=semihost -march=armv7-m -Os --printf=f -o printf-float.elf printf.c
	$ arm-none-eabi-size printf-float.elf
	   text	   data	    bss	    dec	    hex	filename
	   6856	     80	   4104	  11040	   2b20	printf-float.elf
	$ qemu-system-arm -semihosting -machine mps2-an385 -nographic -kernel printf-float.elf
	 2⁶¹ = 2305843009213693952 π ≃ 3.1415927

Selecting the long-long variant reduces the size further, but now the
floating point value is not displayed correctly:

	$ arm-none-eabi-gcc --oslib=semihost -march=armv7-m -Os --printf=l -o printf-long.elf printf.c
	$ arm-none-eabi-size printf-long.elf
	   text	   data	    bss	    dec	    hex	filename
	   2100	     80	   4104	   6284	   188c	printf-long.elf
	$ qemu-system-arm -semihosting -machine mps2-an385 -nographic -kernel printf-long.elf
	 2⁶¹ = 2305843009213693952 π ≃ *float*

Going to integer-only reduces the size even further, but now it
doesn't output the long long value correctly:

	$ arm-none-eabi-gcc --oslib=semihost -march=armv7-m -Os --printf=i -o printf-int.elf printf.c
	$ arm-none-eabi-size printf-int.elf
	   text	   data	    bss	    dec	    hex	filename
	   1924	     80	   4104	   6108	   17dc	printf-int.elf
	$ qemu-system-arm -semihosting -machine mps2-an385 -nographic -kernel printf-int.elf
	 2⁶¹ = 0 π ≃ *float*

To shrink things still further, use the 'minimal' variant. This
doesn't even look at the %g formatting instruction, so that value
displays as '%g'.

	$ arm-none-eabi-gcc --oslib=semihost -march=armv7-m -Os --printf=m -o printf-min.elf printf.c
	$ arm-none-eabi-size printf-min.elf
	   text	   data	    bss	    dec	    hex	filename
	   1420	     80	   4104	   5604	   15e4	printf-min.elf
	$ qemu-system-arm -semihosting -machine mps2-an385 -nographic -kernel printf-min.elf
	 2⁶¹ = 0 π ≃ %g

## Picolibc build options for stdio

In addition to the application build-time options, picolibc includes a
number of picolibc build-time options to control the feature set (and
hence the size) of the library:

 * `-Dio-c99-formats=true` This option controls whether support for
   the C99 type-specific format modifiers 'j', 'z' and 't' and the hex
   float format 'a' are included in the long-long, integer and minimal
   printf and scanf variants. Support for the C99 format specifiers
   like PRId8 is always provided.  This option is enabled by default.

 * `-Dio-long-long=true` This deprecated option controls whether
   support for long long types is included in the integer variant of
   printf and scanf. Instead of using this option, applications should
   select the long long printf and scanf variants. This option is
   disabled by default.

 * `-Dio-pos-args=true` This option add support for C99 positional
   arguments to the long long and integer printf and scanf variant
   (e.g. "%1$"). Positional arguments are always supported in the
   double and float variants and never supported in the minimal
   variant. This option is disabled by default.

 * `-Dio-long-double=true` This option add support for long double
   parameters. That is limited to systems using 80- and 128- bit long
   doubles, or systems for which long double is the same as
   double. This option is disabled by default

 * `-Dio-float-exact=true` This option, which is enabled by default,
   controls whether the stdio code uses exact algorithms for printf
   and scanf. When enabled, printing at least 9 digits (e.g. "%.9g")
   for 32-bit floats and 17 digits (e.g. "%.17g") for 64-bit floats
   ensures that passing the output back to scanf will exactly
   re-create the original value.

 * `-Datomic-ungetc=true` This option, which is enabled by default,
   controls whether getc/ungetc use atomic instruction sequences to
   make them re-entrant. Without this option, multiple threads using
   getc and ungetc may corrupt the state of the input buffer.

 * `-Dposix-console=true` This option provides stdin/stdout/stderr
   support using the picolibc POSIX I/O support.

 * `-Dformat-default={d,f,l,i,m}` Selects which printf and scanf
   variant is used by default.

 * `-Dprintf-aliases=true` This option, which is enabled by default,
   provides for linker alias support for the --printf and --scanf
   compiler options.

 * `-Dio-percent-b=true` This option, which is disabled by default,
   supports the C23 %b format specifier.

 * `-Dprintf-small-ultoa=true` This option, which is enabled by
   default, switches printf's binary-to-decimal conversion code to a
   version which avoids soft division for values larger than the
   machine registers as those functions are often quite large and
   slow. Applications using soft division on large values elsewhere
   will save space by disabling this option as that avoids including
   custom divide-and-modulus-by-ten implementations.

 * `-Dprintf-percent-n=true` This option, which is disabled by default,
   provides support for the dangerous %n printf format specifier.

 * `-Dminimal-io-long-long=true` This option controls whether support
   for long long types is included in the minimal variant of printf
   and scanf. This option is disabled by default.

 * `-Dfast-bufio=true` This option directly calls the read and write
   hooks from fread and fwrite when interacting with buffered streams.

 * `-Dio-wchar=true` This option enables wide character input and
   output even when picolibc is built without multi-byte character
   support.

Picolibc also allows use of the legacy newlib stdio library, but that
is outside the scope of this documentation.
