lc0 | The rewritten engine, originally for tensorflow Now all other backends have been ported here | Game Engine library

Answer is:

2) The compilation process / usage of the toolchain is wrong.

You may have several problems, an important one being that the use of the -kernel option requires the start address of your program to be 0x00010000. And you don't have a startup file, nor a linker script.

The following example should work fine, and is just adapted from a seminal article from Francesco Balducci on his blog.

startup.s:

Some very specific situations are optimized, like the one you showed, but it's very superficial, if you add something to your format string, even a space, it immediately discards the puts and goes back to printf.

I guess that there would be nothing to stop a more broad optimization, my speculation is that, since the performance gains are not that great, further adding more special cases was deemed as not being worth it.

In my speculation, the lack of fputs optimization would fall in that not being worth it category.

This old gcc printf optimization document sheds some light on these optimizations, I doubt that it would much different today.

Specifically:

2.3 %s\n

A printf call with the format string %s\n [line 4679-4687] is converted to a puts() call.

The bug is movl %eax, 36(%rdi) at line 38 of calibrate.s. This is apparently supposed to write to the avg member of the relevant Device, but it's a 32-bit store and Device::avg is a 16-bit short. So it should be movw %ax, 36(%rdi).

Hopefully this will provide some information about what gdb can do and how to use it effectively.

I set a breakpoint at the second printf in inventory, at which point I did x/s $rdx to see what string %rdx points to:

Output is different, for the simple reason that compiler does not 'think' like human but follows standard.

movq instruction will copy 8 bytes, so the data of entire struct foo is copied here:

The value that's printed has nothing at all to do with the value you pass in the printf call, since integer and floating point arguments are passed in separate areas (at least, this is a common convention, and I assume that you're operating on a machine where it's true). When you ask to printf %d without passing any integer argument, you get whatever happened to be previously sitting in the space reserved for the first integer argument, which could be anything. It might be deterministic between different runs of the same compiled program (as a result of some C runtime initialization leaving a predictable value in a register, for instance) or it might be dependent on the execution environment or the phase of the moon. You really don't know, and to be honest, this isn't a case where it's worthwhile to figure out exactly how that value got there. It's junk, and that's that.

In your example

For whatever reason -O3 doesn't turn on the -fomit-frame-pointer option when compiling with GCC for ARM64 targets (including GNU Fortran). You'll need to enable this option explicitly for the compiler to optimize away the use of the frame pointer in non-leaf functions:

-O2 turns on many options in addition to O1, for example -falign-functions -falign-jumps -falign-labels -falign-loops. Each of them seemed to have a negative performance impact on top of -O1. I have i7-8550U and GCC 9.3.0-17ubuntu1~20.04.

I believe the branch prediction failures make this hard on the processor.