The Stack & Changes

• THE STACK GROWS DOWNWARDS

<aside> 💡 THINGS THAT ADD TO THE STACK:

• sub $0x8, %rsp → add unused spaced to the back (goes down)
• add $0x8 %rsp → reduce the stack (goes up)
• callq <400569> → add the location of the instruction AFTER the call in the stack
• push %RBX → add OLD RBX into the
• pop %RBX → removes the value closest to the top of the stack
• Moving things into %RSP, have to account for both the displacement and the number movq $33 08(RSP) is SUBQ 16 bytes into the stack
• addq %rax, 8(%rsp) // 8 above rsp in the stack (changes the value)
• pushq - fetches an operand at src and decrements %rsp by 8 bytes
• popq - read value at address given by %rsp and increments by 8 bytes

Things that dont do shit to the stack:

• movq 20(%rsp), %rax
• movq %rax, (%rbp)
• addq $8, %rsp </aside>

Writing the Prologue and the Epilogue

Function A calls function B → A is the caller function → B is the Callee

Before & After The Call: The Stack

%rdi, %rsi, %rdx, %rcx, %r8, %r9 inputs in orders (might be diff)
%r10, %r11 //caller saved (values might be different after call)
rbx, %rbp, %r12, %r13, %r14, %r15 // values same after call calee guarentee

Stack Frames

Managing Local Data and the Stack

• the reason that we have a stack in the first place is because we want to support recursion which calls simultaneous functions which needs a place to store the argument of the function and each of the return addresses for each of the function calls
  • this is called the stack discipline
• The stack is allocated in frames, so when a new function is called, each of the functions will separate in frames
  • these can include the storage of local variables, saved registers, and the return address
• whenever we use temporary space on the stack for a function call, sometimes we will use subq to allocate some unused extraspace

Examples

0000000000400b5d <func>:
  400b5d:       83 ff 01                cmp    $0x1,%edi
  400b60:       7f 06                   jg     400b68 <func+0xb>
  400b62:       b8 01 00 00 00          mov    $0x1,%eax
  400b67:       c3                      retq
  400b68:       53                      push   %rbx // push old rbx
  400b69:       89 fb                   mov    %edi,%ebx
  400b6b:       8d 7f ff                lea    -0x1(%rdi),%edi
  400b6e:       e8 ea ff ff ff          callq  400b5d <func> 
  400b73:       0f af c3                imul   %ebx,%eax // push to stack
  400b76:       5b                      pop    %rbx
  400b77:       c3                      retq

• Does factorial calculation of X

Suppose you call the recursive function func(3).  Draw the stack when func(1) is entered.  If you don’t know a value, write “old” and then the value name.  (eg. old %rax).  (5pts)