Understanding the uart_printf behaviour when printing a uint64_t variable.

[Sam-Vervaeck]

I have been figuring out how to use the uart_printf function for a bit now to print uint64_t variables. I have a couple hypotheses on what behaviour is happening, but I would like them see confirmed. I have looked into the datasheet and user guide, but I don't see any specific description of this function yet. I believe this behaviour is thus undefined, especially since the code comments of this printf implementation only mention 32 bit values.

Hypo 1) When you pass a 64 bit variable to the printf function through the %u placeholder, it only takes the 32 LSBs. However, the 32 MSBs do not get discarded IF!!! there is another placeholder %u further along in the string to be printed. I concluded this based on the behaviour that I wanted to print two uint64_t variables of which the value did not exceed the 32 LSBs. Instead of seeing the second variable printed by the second %u, it was always 0. This 0 seems to come from the 32 MSBs of the first variable which get passed to the second %u placeholder.

Hypo 2) The best solution to solve the Hypo 1) problem is to cast the variables to uint32_t.

Hypo 3) The behaviour described in Hypo 1) does NOT happen when there is only a singular %u placeholder in the printf function. Then the 32 MSBs which did not get printed yet get discarded. I concluded this by having two sequential printf statements in my code, both loaded with a uint64_t variable. In this case both the 32 LSBs of the variables were printed. The 32 MSBs of the first variable which were 0's, were not propegated to the next printf call.

Is anything wrongly described?

[stnolting]

but I don't see any specific description of this function yet.

That's right - unfortunately. The only documentation here is the code itself. 🙈

The neorv32_uart_printf function(s) only provides a minimal set of formatting options:

neorv32/sw/lib/source/neorv32_uart.c

Lines 305 to 315 in 371b177

	/**********************************************************************//**
	* Custom version of 'vprintf' printing to UART.
	*
	* @warning: This functions only provides a minimal subset of the 'vprintf' formating features!
	* @note This function is blocking.
	*
	* @param[in,out] UARTx Hardware handle to UART register struct, #neorv32_uart_t.
	* @param[in] format Pointer to format string.
	* @param[in] args A value identifying a variable arguments list.
	**************************************************************************/
	void neorv32_uart_vprintf(neorv32_uart_t *UARTx, const char *format, va_list args) {

• %s print zero-terminated ASCII string (char*)
• %c print single character (char)
• %i, %d print 32-bit signed integer (int, int32_t)
• %u print 32-bit unsigned integer (unsigned int, uint32_t)
• %x, %p print 32-bit hexadecimal value (e.g. uint32_t); upper-case letters when using %X

When you pass a 64 bit variable to the printf function [...]

The compiler will put high and low parts of that variable on the stack, but neorv32_uart_printf will only consume a single 32-bit value from the stack which will cause problems for all other arguments (which are also placed on the stack).

The best solution to solve the Hypo 1) problem is to cast the variables to uint32_t.

Right, you can pass high and low word individually and print them one by one (as hexadecimal only).
However, this won't work with decimal representation.

uint64_t tmp = 0xABCD1234CAFE5678;
neorv32_uart0_printf("tmp = 0x%x%x\n", (uint32_t)(tmp>>32), (uint32_t)(tmp));

If you need the full printf features you can try to include <stdio.h> and use that (note that stdio's printf will always print to UART0). But beware, the newlib's stdio printf port is tricky sometimes... Furthermore, stdio's printf is quite huge!

Therefore, I highly recommend a more embedded-friendly port:

• https://github.com/mpaland/printf 👍
• https://github.com/eyalroz/printf (an up-to-date fork of the previous one) 👍 👍

[Sam-Vervaeck]

However, this won't work with decimal representation.

You mean when you want to print the decimal numbers behind the comma (dot) right? In that case I will look into these embedded ports, but for now I only needed a workaround for uint64_t printing :)

[stnolting]

You mean when you want to print the decimal numbers behind the comma (dot) right? In that case I will look into these embedded ports, but for now I only needed a workaround for uint64_t printing :)

I meant inter numbers exceeding 32-bit. Fractional numbers, i.e. floating-point numbers, are a different issue. 😅