5.2.2. Context Saving During Procedure Call

Now, we have talked enough theory and this is actually a nutshell what I have told you completes the theory of a procedure call it is basically only 3 very simple steps, you call a procedure, before calling a procedure place everything in this stack, call the procedure, jump to the instruction where the first instruction of the procedure is there jump to that memory location, after completing the procedure return back to the main program from where the procedure is called and at the same time before jumping back to the main place where we have started; where the procedure is called if you regain back the values of program status word, the program counter, variables which you have saved before going to this one.

In a procedure call, there are three simple steps to follow:

1. Save Context: Before calling the procedure, save important information like the program status word and program counter to the stack. This step preserves the state of the main program.
2. Call Procedure: Execute the call, which transfers control to the procedure's first instruction at a specific memory address.
3. Return from Procedure: Once the procedure finishes executing, control returns to the main program, retrieving the saved context to restore its state.

Think of a procedure call like a teacher stepping out of the classroom. Before leaving, the teacher writes down important notes for the students (saving context). The students then continue with their work (calling the procedure). Once the teacher finishes their task (procedure execution), they return to the classroom, check their notes to see where they left off, and continue teaching (returning from the procedure).

So, we have a processor whose memory address range is 000 to FFF. So, it is a address bus will be 12 bits the memory contains and as I told you. So, this is your main memory. So, it will have 000 to say FFF and a part of this is reserved for the stack. So, what is reserved for the stack if you see FF0 to FFF maybe some from here. So, this part of the program memory is allocated for a stack when your stack will be saved.

In computers, every procedure operates within a predefined memory structure. For instance, a processor may have a memory range from address 000 to FFF (4095 in decimal). This range is divided so that part of it, specifically from FF0 to FFF, is dedicated to the stack. The stack is a special area where temporary data, such as return addresses and local variables, is stored during procedure calls.

Imagine a large filing cabinet (the computer's memory) with labeled drawers (memory addresses). One drawer (the stack) is reserved for urgent documents (temporary data) that need to be accessed quickly while working on a project (executing procedures). Just like you'd quickly store and retrieve documents from that special drawer while managing your tasks.

So, now we will see how the stack is implemented or how the stack is modified when such a code is executed using jump instructions.

The stack pointer is a crucial register that keeps track of the top of the stack in memory. As procedures are called, the stack pointer is adjusted up or down, depending on the stack's management strategy (growing upwards or downwards). It allows the processor to know where new data should be pushed (saved) and ensures data integrity when returning from procedures by maintaining the correct order of saved contexts.

Think of the stack pointer as a librarian managing books stacked on a shelf. As new books (data) are added to the top, the librarian notes the current top book (updates the stack pointer). When someone needs to return a borrowed book (return from procedure), the librarian knows exactly where to find the most recent one, ensuring everything stays organized.

So, when I am executing procedure A then this instruction which is in place of 37A as a part of procedure A it will call procedure B. That is when I mean executing the main program it will call procedure A at memory location 1CD that is the call A instruction is located in memory location 1CD when I am executing procedure A at memory location 37A the instruction call B is there.

Nested procedures occur when one procedure calls another. For example, 'Procedure A' may call 'Procedure B' while executing. In this context, when moving through instructions, the program saves the current location in the stack before jumping to Procedure B, following the same process of saving the program counter and other registers so the system can return to the correct spot after execution.

Consider a family dinner where a parent (Procedure A) steps into the kitchen to prepare dessert (Procedure B). The parent tells the children (the main program) to continue without them (saves the current situation). Once dessert is done, the parent comes back to the dining table (returns to the original procedure) ready to finish dinner.

So, now whenever from A to you will be calling procedure B. So, it will start filling up from here so now look at here.

When a procedure finishes executing, it returns control to the calling procedure. The stack pointer now points to the saved context of Procedure A, which includes where to resume execution. This process involves taking values from the stack to restore the program counter and other necessary registers, allowing the system to neatly resume operations without losing track of previous steps.

Returning from a procedure is like finishing a call to a friend while organizing your room. You pick up your last note (the saved context) that reminds you of where to continue organizing (where to return in the code) and then proceed from exactly where you paused, ensuring nothing is forgotten.

--