Can a compiler generate useless assembly code?

Question

I am trying to find the meaning of assembly code generated from a c program. Here is the program in C:

int* a = &argc;
int b = 8;
a = &b;

Here is the assembly code generated with explanations. There is one part that I do not understand:

Prologue of the main:

leal    4(%esp), %ecx
andl    $-16, %esp
pushl   -4(%ecx)
pushl   %ebp
movl    %esp, %ebp
pushl   %ecx
subl    $36, %esp

Load the address of argc in %eax:

movl    %ecx, %eax

The part I do not get:

movl    4(%eax), %edx
movl    %edx, -28(%ebp)

Stack-Smashing Protector code (setup):

movl    %gs:20, %ecx
movl    %ecx, -12(%ebp)
xorl    %ecx, %ecx

Load values in a and b (see in main.c):

movl    %eax, -16(%ebp)
movl    $8, -20(%ebp)

Modify the value of a (a = &b):

leal    -20(%ebp), %eax
movl    %eax, -16(%ebp)

Stack-Smashing Protector code (verify the stack is ok):

movl    $0, %eax
movl    -12(%ebp), %edx
xorl    %gs:20, %edx
je  .L7
call    __stack_chk_fail

If the stack is Ok:

.L7:
    addl    $36, %esp
    popl    %ecx
    popl    %ebp
    leal    -4(%ecx), %esp
    ret

So the part I do not uinderstand is modifying the value in -28(%ebp), an address never used. Does someone knows why is this part generated?

Answer 1

The good way to see what the compiler does. I assume you have a file called main.c:

int main(int argc, char **argv) 
{
    int* a = &argc;
    int b = 8;
    a = &b;
}

Compile with debug info to an object file:

$ gcc -c -g main.c

View the assembly:

$ objdump -S main.o

main.o:     file format elf64-x86-64


Disassembly of section .text:

0000000000000000 <main>:
int main(int argc, char **argv)
{
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   89 7d ec                mov    %edi,-0x14(%rbp)
   7:   48 89 75 e0             mov    %rsi,-0x20(%rbp)
    int* a = &argc;
   b:   48 8d 45 ec             lea    -0x14(%rbp),%rax
   f:   48 89 45 f8             mov    %rax,-0x8(%rbp)
    int b = 8;
  13:   c7 45 f4 08 00 00 00    movl   $0x8,-0xc(%rbp)
    a = &b;
  1a:   48 8d 45 f4             lea    -0xc(%rbp),%rax
  1e:   48 89 45 f8             mov    %rax,-0x8(%rbp)
  22:   b8 00 00 00 00          mov    $0x0,%eax
}
  27:   5d                      pop    %rbp
  28:   c3                      retq   

Then do the same with full optimization:

$ gcc -c -g -O3 main.c 

And view the assembly again:

$ objdump -S main.o

main.o:     file format elf64-x86-64


Disassembly of section .text.startup:

0000000000000000 <main>:
int main(int argc, char **argv)
{
    int* a = &argc;
    int b = 8;
    a = &b;
}
   0:   31 c0                   xor    %eax,%eax
   2:   c3                      retq   

So the answer is yes. The compiler can produce instructions not needed. That's why you turn on optimizations. When they are turned off, the compiler does its job in a very generic way without thinking at all. For example, it reserves space for variables that are not used.