- A stack is a data structure with
two operation:
- void Push(int x): put the value "x" in the stack. The value "x" is put "at the top" of the stack.
- int Pop(): remove the top value off the stack. The value removed is returned.
Example:
(1) Initially: +----------+ (empty stack)
(2) After Push(4): +----------+ | 4 | +----------+
(3) After Push(9): +----------+ | 9 | (new value get put ON TOP) +----------+ | 4 | +----------+
(4) After Push(1): +----------+ | 1 | (new value get put ON TOP again) +----------+ | 9 | +----------+ | 4 | +----------+
Suppose we have 3 variables "a", "b" and "c" defined.... (5) After a = Pop(): +----------+ | 9 | (top value is REMOVED !) +----------+ | 4 | +----------+ and a = 1
(6) After b = Pop(): +----------+ | 4 | (top value is REMOVED again !) +----------+ and b = 9
(7) After c = Pop(): +----------+ (Stack is empty) and c = 4
- The stack data structure that
you learned in Java (CS171) is
implemented
using an array variable
Example: (CS171 material)
public class Stack { int[] A; int stacktop; // Points to the top of the stack public Stack(int size) { A = new int[size]; // Create the array to hold values in stack stacktop = -1; } public void push( int x ) { A[++stacktop] = x; // Move stack top and put x on the stack } public int pop( ) { return A[stacktop--]; } }due to the limitation of the programming language to store data:
- The only way to "create" a stack is to define a suitable type of variable in a Java program and use it to implement a stack
- We do not have this
limitation when
the computer system
executes
a computer program.
Recall from this lecture note ( click here ) that when a computer program is execute, the computer memory contains:
- When a program is
running, the
computer system will need to
store various
information items (variables)
in a stack:
In other words:
- The computer system maintains
(= manages) a
stack
to manage (= organize)
information
it needs during
program execution !!!
This particular stack data structure is called:
- The Program stack
Information stored in the program stack include:
- Function activation information
(created when a function is
called) that consists of:
- Parameters of the function call
- Return address to the caller
(These function activation information will be removed (popped) when a function returns (exits))
- Local variables used by the
called function
(These local variables will also be removed (popped) when a function returns (exits))
We will first study how to save the return address using the stack
Later, we will pass parameters using the stack and create local variables on the stack
(I.e., I will separate the discussion on these 3 items)
But first, we need to study how to implement the program stack.
- The computer system maintains
(= manages) a
stack
to manage (= organize)
information
it needs during
program execution !!!
- Just like a stack object in
Java, in order to
implement a stack, we need:
- An array (= a series (large number) of memory cells)
- A StackTop indicator (= a way to mark the location of the top of the stack)
- Unlike in a
programming language, the
computer system have
access to the
entire computer memory !!!
- We do not need to
"define" an array
- We just have to organize the memory (because we can access the entire computer memory)
Traditionally (for efficiency reasons), the program stack is located at the end of the memory area:
Explanation:
Memory: 0 +----------+ | | <--- this part contains the "code" | A | This part of the memory is "write protected" | | (can not - and should not - be modified) | | +----------+ | | <--- this part contains "static variables" | B | These variables exist at the start of the | | program (a.k.a.: compiled-time variables) +----------+ | | ^ | | | <--- this part grows when the program creates | | | new objects: reserve space for instance | C | | variables in the new object | | v | | v <--- Direction of growth is "downwards" | | v +==========+ | | <---- this part is "free" memory | | (Free means: unreserved !) | | | | +==========+ | | ^ | | ^ <--- Direction of growth is "upwards" | | ^ | D | | | | | <--- This part grows when the program invokes | Program | | a function/method, reserve space for: | stack | | (1) return address | | | (2) parameter variables | | v (1) local variables +----------+
- We do not need to
"define" an array
- Since we don't need to "create an array",
all that is left to do to implement the
Program Stack is:
- Define a stacktop indicator (= a way to mark the location of the top of the program stack)
- The program stack in
a computer system
(in every CPU processor) is
always implemented by:
- Using one of the registers in the CPU as stacktop index
Furthermore, the program stack always grows towards lower memory addresses.
That's because the beginning of the computer memory is used to store program instructions, so the program stack is located at the far end of the memory
Therefore, the grow direction of the program stack is always toward the top of the memory
Example:
- In ARM, the
stacktop index is:
- The register R13 (also known by the name SP for Stack Pointer)
You can see the stack pointer register SP in EGTAPI:
The SP register is near the bottom of the list of registers...
The stack area is displayed in the Program Stack window in EGTAPI - so you can easily see the values stored in the program stack
The top of the stack is highlighted in red color.
- In Intel's CPU (Pentium, Core Duo...),
the stacktop index is stored in:
- The special purpose register (named) sp (= stack pointer)
- So in ARM,
the program stack is
given as follows:
Memory: 0 +----------+ | | <--- this part contains the "code" | A | This part of the memory is "write protected" | | (can not - and should not - be modified) | | +----------+ | | <--- this part contains "static variables" | B | These variables exist at the start of the | | program (a.k.a.: compiled-time variables) +----------+ | | ^ | | | <--- this part grows when the program creates | | | new objects: reserve space for instance | C | | variables in the new object | | v | | v <--- Direction of growth is "downwards" | | v +==========+ | | <---- this part is "free" memory | | (Free means: unreserved !) | | | | SP -->+==========+ | | ^ | | ^ <--- Direction of growth is "upwards" | | ^ | D | | | | | <--- This part grows when the program invokes | Program | | a function/method, reserve space for: | stack | | (1) return address | | | (2) parameter variables | | v (1) local variables +----------+I will use the name SP (or sp to denote the stack pointer (register) -- it's easier to remember that R13...