The Stack

UMBC CMSC 211

The Stack

The hardware stack and stack pointer sp are necessary to get subprograms to work properly. Actually early CPUs did not have them, and as a result, they were more limited than what we have today. For instance, recursion was not possible.

A stack is a data structure like a queue, but data can only be added or removed at one end, so it is Last-In, First-Out (LIFO) There are special instructions built into the CPU to work with the stack. The sp register points to the newest 16-bit (or 32-bit double word when using the extended registers in the later models) value that is on the stack, which is the next item to be removed. You determine the size of the stack with the .stack directive. The assembler builds a program by putting the .code segment first, followed by the .data segment, and finally, the .stack segment. When putting an item on the stack, it starts at the highest address and grows down.

The instructions are:

push (16-bit)
pushw (16-bit)
pushd (32-bit, 80386 and later)
pusha (16-bit, pushs AX, CX, DX, BX, SP, BP, SI, DI, 80186 and later)
pushd (32-bit, 80386 and later)
pushf (16-bit, pushs the flag register)
pushfd (32-bit, 80386 and later)
pop (16- or 32-bit, based on the register specified, can not be sp register!)
popa (16-bit, 80186 and later, pops in reverse order of pusha)
popad (32-bit, 80386 and later)
popf (16-bit)
popfd (32-bit, 80386 and later)

Either a memory location (word or double word only, as appropriate), constant, or a register can be specified. If we have set up the code segment as:

X	DW	1111
Y	DW	2222
Z	DW	?

We can have a stack that looks like:

?
?
?

In this case, the SP register really points to what is above the first location. If we execute:

push

We now have a stack that looks like:

1111	<- SP
?
?

If we then execute:

push

We now have a stack that looks like:

1111
2222	<- SP
?

If we finally execute:

pop

We now have a stack that looks like:

1111	<- SP
2222
?

The location for the variable Z is set to 2222 and the SP register points to the previous entry. Note that stack location holding 2222 is considered unused and will be overwritten by the next push instruction. You can not count on items popped from the stack remaining in unused stack memory because the operating system also uses the stack.)

The hardware stack is implemented as a normal block of memory of the size you specified in the .STACK pseudo-op.

If you do push X followed by pop X, nothing is changed.

Saving and restoring registers is particularly important when using subprograms. You have the responsibility to save and restore important data in the registers before you call a subprogram and then you are responsible for restoring those registers afterwards.

Subprograms should save and restore any registers that they use, unless they are returning values in certain registers! This means you have to write the instructions to do it!

UMBC | CSEE