Why %esp gets changed imexplitcitly? - c

Question

The title is actually my second problem.
2 problems arose when I was learning the CSAPP 2nd edition, chapter 3. There're 2 relative simple files. Here's the first one:
// code.c
int accum = 0;
int sum(int x, int y)
{
int t = x + y;
accum += t;
return t;
}
The second one:
// main.c
int main() {
return sum(1, 3);
}
I used gcc to compile them, following the book. In order to get a 32-bit program, I added an -m32 option(Mine is 64-bit Ubuntu):
$ gcc -m32 -O1 -O prog code.c main.c
Things were good up to this far. But when I disassembled it using GDB, it really confused me. I got the following result that conflicted with what the book says:
(gdb) disas sum
Dump of assembler code for function sum:
0x080483ed <+0>: mov 0x8(%esp),%eax
0x080483f1 <+4>: add 0x4(%esp),%eax
0x080483f5 <+8>: add %eax,0x804a020
0x080483fb <+14>: ret
End of assembler dump.
(gdb) disas main
Dump of assembler code for function main:
0x080483fc <+0>: push %ebp
0x080483fd <+1>: mov %esp,%ebp
0x080483ff <+3>: and $0xfffffff0,%esp
0x08048402 <+6>: sub $0x10,%esp
0x08048405 <+9>: movl $0x3,0x4(%esp)
0x0804840d <+17>: movl $0x1,(%esp)
0x08048414 <+24>: call 0x80483ed <sum>
0x08048419 <+29>: leave
0x0804841a <+30>: ret
End of assembler dump.
Now here are my problems:
Why isn't there any saving %ebp or moving %esp when calling the function sum as the book describes? Or is sum inlined by the compiler?
The value 3 & 1 were already stored in the M[%esp + 4] & M[%esp], respectively. And after calling the sum, there's no instruction that alters the value stored in %esp. But inside the sum, the first instruction retrieves M[%esp + 8], which is actually 3(I set the breakpoint using GDB &checked the value), while the M[%esp + 4] stores the value 1. How come? Later I set 2 breakpoints:
(gdb) break *0x08048414
(gdb) break sum
Then I found the value stored in %esp was different at these 2 breakpoints:
Breakpoint 6, 0x08048414 in main ()
(gdb) print $esp
$8 = (void *) 0xffffd020
(gdb) continue
Continuing.
Breakpoint 5, 0x080483ed in sum ()
(gdb) print $esp
$9 = (void *) 0xffffd01c
Why would this occur?

Answer 1

Why isn't there any saving %ebp or moving %esp when calling the function sum as the book describes?
You might have enabled option to omit frame pointer, most probably with -Ox compiler option. You can force GCC to still keep it with -fno-omit-frame-pointer GCC command line argument:
https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#index-O
But inside the sum, the first instruction retrieves M[%esp + 8], which is actually 3, while the M[%esp + 4] stores the value 1. How come?
Call instruction pushes eip register to the stack and moves esp. You compiled it in 32 bit mode, so the offset is 4 bytes.