Saving and Restoring Registers on "The Stack"

CS 301 Lecture, Dr. Lawlor

"The Stack" is a frequently-used area of memory designed for functions to use as temporary storage. This is normally where you store values while calling another function: you can't store values in the scratch registers, because the function could change them.

The layout of the stack is very simple, and it's based around the stack pointer register rsp:

Memory above rsp (address>=rsp) is in use.
Memory below rsp (address<rsp) is not in use.

This convention is used by all functions, including other functions you call. It's a very common way for you or the compiler to allocate a few bytes of temporary space in a function, like for local variables.

So to claim 8 bytes of stack space, you just "sub rsp,8". You can then write data to your new space with "mov QWORD[rsp],<whatever>", and read it back at any later point in your function. Even if you call other functions, that part of the stack is now *yours*. To release your claim to that space, you just "add rsp,8" before you return.

WARNING!

If you do not move the stack pointer back *exactly* where you found it, when you return your program will crash.
Almost instantly.

So be careful with your stack manipulation!

Here's how we allocate some space on the stack, then read and write it.

sub rsp,16 ; I claim the next sixteen bytes in the name of... me!

mov QWORD [rsp],1492 ; store a long integer into our stack space
mov rax,QWORD [rsp] ; read our long from where we stored it

add rsp,16 ; Hand back the stack space
ret

(Try this in NetRun now!)

Yes, the QWORD is only 8 bytes, but I'm allocating 16 bytes. This is OK, but wastes 8 bytes. Of course, claiming 8 and using 16 would be disaster, so err on the side of too much allocation!

Here's how we'd allocate one hundred long integers on the stack, then use just one of them:

sub rsp,800 ; I claim the next eight hundred bytes

mov rdi,rsp ; points to the start of our 100-integer array
add rdi,320 ; jump down to integer 40 in the array
mov QWORD [rdi],1492 ; store an integer into our stack space
mov rax,QWORD [rdi] ; read our integer from where we stored it

add rsp,800 ; Hand back the stack space
ret

(Try this in NetRun now!)

Push and Pop

The easiest and most common way to use the stack is with the dedicated "push" and "pop" instructions.

"push" stores a constant or 64-bit register out onto the stack. So "push <stuff>" is equivalent to a "sub rsp, 8" and then "mov QWORD[rsp], <stuff>".
"pop" retrieves the last value pushed from the stack. Everything you push, you MUST pop again afterwards, or your code will crash almost immediately!

For example, this loads 23 into rax, and then 17 into rcx:

push 17
push 23
pop rax
pop rcx
ret

(Try this in NetRun now!)

After the first "push", the stack just has one value:
    17
After the second "push", the stack has two values:
    17 23
So the first "pop" picks up the 23, leaving the stack with one value:
    17
The second "pop" picks up that value, leaving the stack clean. If the stack is not clean, "ret" stops working. Let me say that again:

WARNING!

If you do not pop *exactly* the same number of times as you push, your program will crash.
Horribly.

So be careful with your pushes and pops!

Saving Registers with Push and Pop

You can use push and pop to save registers at the start and end of your function. For example, "rbp" is a preserved register, so you need to save its value before you can use it:

push rbp ; save old copy of this register

mov rbp,23
mov rax,rbp

pop rbp ; restore main's copy from the stack
ret

(Try this in NetRun now!)

Main might be storing something important in rbp, and will complain if you just change it, but as long as you put it back exactly how it was before you return, main is perfectly happy letting you use it!

If you have multiple registers to save and restore, be sure to pop them in the *opposite* order they were pushed:

push rbp ; save old copy of this register
push r15

mov rbp,23
mov rax,rbp

pop r15 ; restore main's copy from the stack
pop rbp
ret

(Try this in NetRun now!)

One big advantage to saved registers: you can call other functions, and know that they won't change their values. All the scratch registers, by contrast, are likely to get overwritten by any function you call.

You can save a scratch register by pushing it before calling a function, then popping it afterwards:

mov rax,17; say I want to keep this value while calling a function...
push rax; Just save rax to the stack

mov rdi,3 ; now call the function
extern print_long
call print_long

pop rax; And we can now restore rax afterwards, and safely return 17
ret

(Try this in NetRun now!)

Again, you can save as many registers as you want, but you need to pop them in the opposite order--otherwise you've flipped their values around!