Section 4: Assembly and the Stack #

The return type is a 4-byte value (unsigned int, int, etc.), since the last mention of a register in the %rax family is %eax.

A loop, since there is a jump back to a label that is above the jump instruction.

The C code that generated the program is below (one of multiple possible programs that result in this assembly code):

#include <stdio.h>

int func() {
  int a = 42;
  int b = 0;
  for (int i = 0; i < a; i++) {
    b += i;
  }

  return b;
}

int main() {
  return func();
} 

When main begins executing, but before add is called, main allocates some space on the stack for local variables. Since the compiler can re-arrange the order that local variables are pushed onto the stack, we need to look at the assembly code to determine precisely in what order and where these local variables get pushed onto the stack.

In the assembly code, main first allocates 24 bytes of local variables by subtracting from %rsp in the sub $24, %rsp instruction. Then, two local variables are allocated. One of 8 bytes (assembly quad) which contains the value 7, moved into address 8(%rsp), and one of 2 bytes (assembly word) which contains the value 12, moved into address 6(%rsp).

When these local variables are moved onto the stack, the stack diagram will look like this:

When add is called, some additional values are pushed onto the stack! The first value added is the return address to main, which indicates where control should return to after add is done executing. This 8 byte value is pushed onto the stack and %rsp is decreased by 8.

However, there are still more values moved onto the stack when calling a function! These additional values are add's parameters, which get loaded from registers onto the stack (this occurs immeadiately after calling) add. The first parameter to add, a, is stored in the %edi register. The second parameter to add, b, is stored in the %esi register.

When add is finally called, it copies the parameters from the registers onto the stack. It first copies the parameter a in register %edi to the address -20(%rsp). It then copies the parameter b in register %esi to a lower address, address -24(%rsp).

add also has its own local variable, the variable result, so it needs to allocate space for result. In the corresponding assembly code, add moves the value in %eax (the result of the addition) onto the stack into address -4(%rsp). This value is then moved from the stack into %eax when it is returned. Therefore result must be stored on the stack at -4(%rsp).

When these return address, parameters and local variables are moved onto the stack, the stack will look like this:

After executing line C, the program has returned from add. Any stack data allocated for add is now recycled and can be reused for the program. The return value from add (located in register %eax) is moved into the local variable result in main's stack frame.

Since result in main was previously uninitialized, we did not know where it was located on the stack. Now we know that main is located right at %rsp. However, this value of %rsp is not the same as it was when calling add! This is because when we return from add, we pop the saved return address of the stack and increase %rsp.

When we return from add and move result onto the stack, the stack will look like this:

After executing printf, main has no more instructions to execute, so it begins to recycle its own stack frame. In the assembly code, main resets %rsp to its initial value by adding 24 to it. All the local variables on main's stack frame are recycled and can no longer be used. %rsp is reset to its original value before main was called.

This results in our stack looking identical to how it was when main initially began execution! The stack has cleaned itself up so it looks like main was never called!

Right before we are about to return from main, the stack will look like this: