Difference between printf@plt and puts@plt

Question

I've been learning assembly language by disassembling some C code. When I disassemble this basic C code with GDB:

#include <stdio.h>
void main(void) {
    printf("Hello World\n");
}

Among assembly code, it gives this line:

0x08048424 <+25>:   call   0x80482e0 <puts@plt>

However, when I disassemble below code which has an integer in printf function:

#include <stdio.h>
void main(void) {
    int a = 1;
    printf("Hello Word %d\n", a);
}

It gives this line:

0x0804842e <+35>:   call   0x80482e0 <printf@plt>

What is the difference between printf@plt and puts@plt?

Why disassembler does not recognize printf function without an integer parameter?

Answer 1

In GCC printf and puts are built-in functions. Which means that the compiler has full knowledge of their semantics. In such cases the compiler is free to replace a call to one function with an equivalent call to another, if it thinks that it will produce better (faster and/or more compact) code.

puts is a generally more efficient function since it does not have to parse and interpret a format string.

This is exactly what happened in your case. Your first call to printf does not really need any printf-specific features. The format string you supplied to printf is trivial: it has no conversion specifiers in it. The compiler thought that your first call to printf is better served with an equivalent call to puts.

Meanwhile, your second call to printf makes non-trivial use of printf format string, i.e. it relies on printf-specific features.

(Some rather thorough research of this specific matter from 2005: http://www.ciselant.de/projects/gcc_printf/gcc_printf.html)

Answer 2

I don't know about the @plt part, but printf and puts are simply two different standard library functions. printf takes a format string and zero or more other parameters, possibly of different types. puts takes just a string and prints it, followed by a newline. Consult any C reference for more information, or type

man 3 printf
man 3 puts

assuming you're on a Unix-like system with man pages installed. (man printf without the 3 will show you the printf command; you want the printf function.)

Your compiler is able to optimize the call

printf("Hello, world\n");

to the equivalent of:

puts("Hello, world");

because it knows what both functions do, so it can determine that they do exactly the same thing.

It can't optimize

printf("Hello Word %d\n", a);

because the value of a is unknown at compile time, so it doesn't print a fixed string. (It might figure it out at higher optimization levels by observing that a is never modified after its initialization).

The disassembler is merely showing you the code generated by the compiler.

(Incidentally, void main(void) is incorrect; use int main(void).)

Answer 3

The puts and printf functions appear to have the same address because you are looking at stubs, and not the real functions. These stubs load an address from the procedure link table (what the @plt suffix refers to) and then call it.

I'm disassembling a program, and see that it has stubs for both printf and puts:

08048370 <printf@plt>:
 8048370:       ff 25 04 a0 04 08       jmp    *0x804a004
 8048376:       68 08 00 00 00          push   $0x8
 804837b:       e9 d0 ff ff ff          jmp    8048350 <_init+0x3c>

08048380 <puts@plt>:
 8048380:       ff 25 08 a0 04 08       jmp    *0x804a008
 8048386:       68 10 00 00 00          push   $0x10
 804838b:       e9 c0 ff ff ff          jmp    8048350 <_init+0x3c>

As you can see, the real functions are somewhere else, and these stubs are only generated for the functions that your program actually uses. If you have a program which calls only one function and then change it from printf to puts, it's not suprising that the one and only stub is at the same address. The program I just disassembled calls both printf and puts, and so has stubs for both, and consequently they have different addresses.