4.1.7. Implementation of Stack in Main Memory

So, basically as we have told that procedure is a self-contained computer program which is a part of a larger program. So, whenever a procedure is called basically it invokes a jump to the memory location or where the first instruction of the procedure is placed. So, it is some form of an unconditional jump.

But sometimes you can also have a procedure whose call may be depending on some condition. In that case you have to call the procedure based on some conditional instruction. But in a very general sense we generally have an unconditional jump or unconditional call to the procedure.

A procedure is like a mini-program that performs a specific task within a larger program. When you want to use this mini-program, you call it, and the computer needs to know where to find it in memory. This is typically an unconditional jump because you're directly going there without conditions. There can also be cases where calling the procedure may depend on certain conditions (like if a variable meets a certain requirement), making it a conditional jump.

Think of a procedure as a recipe in a cookbook. When you want to bake a cake (your main program), you may need to check if you have eggs and flour before you decide to follow the cake recipe (conditional jump). But if you have all ingredients, you just do go straight to that recipe (unconditional jump).

So, in other words the whole context of the program has to be saved in a stack. So, very, very important components of the stack are basically we call it as the program status word which will have all the values of the flags, which will have the value of the program counter or in other words the context of the current program has to be stored in a stack when you are calling a procedure.

When we execute a procedure, we can't just forget where we came from; we need to remember the current context of the program. This means storing information like the program counter (which tells us where we are in the main program) and the program status word (which holds flag values that indicate certain conditions). This data is kept in a stack until we finish the procedure and return to the main program.

Imagine you're stepping out of a room (the main program) to check on something in another room (the procedure). Before you leave the room, you write down your current location (program counter) and what you were doing (status word). When you return, you refer back to your notes to remember what you need to continue doing.

And if they are nested procedures as we will see in an example, so procedure A will call procedure B, procedure B will call procedure C and at every call the context of the calling procedure will be stored in a stack and when you are returning unwinding the procedure calls you are going to get back one context after the other from the stack that we are going to see.

In programming, procedures can call other procedures. For instance, Procedure A can call Procedure B, which can then call Procedure C. Each time a procedure is called, the computer saves the context of the calling procedure on the stack. Then, as each procedure finishes executing, it retrieves its context from the stack in reverse order, allowing the program to resume where it left off each time.

Think of going on a trip where each destination is a procedure. When you leave a location (finish a procedure), you jot down where you need to go back to after your visit (saving context). As you hop from place to place (nested calls), you have to keep track of your original location and each stop to return in the right order once you are done exploring.

As I told you that program counter, program status word, and register variables are very very important components which are stored in a stack which defines the current context of a code. In fact, the flag registers also saved basically because when you are running a current set of instructions the flags are set or reset which are also used for some conditional statement when you go to a subroutine the same program that is their flag registers will be used, but now it will be used in the context of that procedure.

Components like the program counter (PC), program status word (PSW), and any registers that hold variables are important to keep track of the program's context. When entering a new procedure, the current state of these components is saved in the stack. This allows the program to function properly when the procedure runs and when it returns back to the main program. The flag registers, which express conditions of computation, are useful within both the main program and its procedures.

Consider flag registers as signals at a traffic intersection. They inform drivers whether they can proceed or need to stop. Just like these signals need to be observed during driving, the flag registers indicate different states of the procedure. If a truck leaves the intersection (procedure), the signal details (the PC and PSW) must be remembered for when it returns.

Now, where is the stack implemented? So, the group of main memory is used to implement the stack that is very important you can save a particular part of the main memory to implement the stack and there is a special stack pointer which will actually locate that where the top element of the stack is.

A stack is a data structure used to manage temporary data in programming, and it resides in the main memory. A specific area of this memory is set aside to act as the stack. To know where the stack's top element is located, a stack pointer (SP) registers that address. This organization is crucial for efficient memory management during procedure calls.

Think of a stack like a stack of plates in your kitchen. You store plates (data) in a specific cabinet (main memory). To find out how many plates are in the stack (top element), you have a note that tells you where the top plate is (stack pointer). When you need a plate, you just refer to your note to find out where to look.

--