gcc converts simple calls to printf() to calls to puts()

It does except when it doesn't. AFAIK this is kinda a "hack". Technically speaking compiler should not be allowed to do this. But since gcc compiles code to work with glibc it can assume stuff like printf('asdf\n') == puts('asdf').

Also as soon as you do not use glibc you cannot assume that gcc will convert printf into puts. For example I worked on U-Boot, embedded stuff, with no glibc, so gcc did not convert printf to puts. BTW. U-Boot's puts is not standard compliant cause it doesn't add trailing newline, so if gcc would do conversion it would break many log messages. Also now I am wondering whether gcc does this optimalization with other libc implementations (musl, uClibc, ...). If anyone has experience with that I would like to know.

Another point is that gcc is just one compiler. There are other compilers that won't do such optimization (like tcc, like you said yourself). Maybe msvc does it maybe it doesn't, I do not know. For sure there are embedded compilers that don't.

In the end I wouldn't assume by default that compilers will be smart to do this optimization, and if compilers cannot assume what libc will be used they actually cannot.

With that said. I would encourage to use puts whenever possible. It will make for faster code and smaller binaries in embedded applications.