5.1. Procedure Call Overview

So, this is overall the basic comp, CPU components which are involved in a procedure call all the components are quite similar to all other functions and all other instructions we have discussed till now, but stack pointer is a register which plays a very special role over here.

In a procedure call, the CPU uses several components that work together. Most of these components are similar to those used in other functions or instructions previously discussed. However, the stack pointer stands out because it has a unique and critical role. The stack pointer keeps track of the top of the stack, an area of memory used to store temporary data, particularly during function calls.

Think of a stack pointer like a crane operator who lifts boxes to a certain height. The crane recalls where it last placed a box to avoid dropping new ones on top of old ones. Similarly, the stack pointer remembers where data is pushed onto the memory stack, ensuring that it retrieves the right data when needed.

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, regain back the values of the program status word, the program counter, variables which you have saved before going to this one.

The process of making a procedure call involves three key steps: First, you prepare the data by saving all necessary information onto the stack. This information includes variables, program counters, and status words needed for the procedure's execution. Second, you actually call the procedure by transferring the control to the instruction at the start of that procedure. Third, once the procedure is finished executing, control returns to the original program, ensuring all previously saved values are restored. This three-step procedure ensures that the program can continue running seamlessly after the procedure's execution.

Consider calling a friend for advice. First, you jot down your questions (saving data to the stack). Then, you call your friend (jumping to the procedure). After talking, you hang up and continue with your previous activity, now armed with new insights (returning to the main program with restored state).

We have a processor whose memory address range is 000 to FFF. This part of the program memory is allocated for a stack, starting from FF0 to FFF. The main program is located from 110 to 2CF, and it has procedures A and B located at specific memory addresses.

Every processor has an organized memory structure, where specific addresses are reserved for various functions. For instance, this processor's memory range is from 000 to FFF. A section of this range (FF0 to FFF) is specifically allocated for the stack, which grows downwards. Meanwhile, other segments of this memory range house the main program and specific procedures A and B. This structured memory allocation is crucial for managing tasks like procedure calls since it ensures that areas of memory do not overlap and conflict during execution.

Imagine a library where each section is designated for different genres of books. The children’s section is at one end, while the adult fiction is in the middle, and a spare area holds returned books that need to be shelved. Each classification helps keep order so that when someone needs a book, they can easily find it without interrupting others.

When calling a procedure, the stack pointer saves the current instruction location and the program status word, along with the values of the four general-purpose registers before jumping to the procedure's first instruction.

Before transferring execution to a procedure, it's essential to save the current state of the program. This involves storing the current instruction location (where the program should resume after the procedure), the program status word, and the values of general-purpose registers, which typically hold necessary temporary data. By saving this context, the program can seamlessly retrieve it after the procedure finishes without any loss of information.

Think of a teacher leaving the classroom to attend a meeting. Before leaving, the teacher writes down where they stopped teaching (current instruction), notes any specific student concerns (program status), and leaves materials (registers) for the substitute. This way, when the teacher returns, they can pick up right where they left off smoothly.

While executing procedure A, it may call procedure B, which similarly needs to save its context before jumping to its specific instruction. After procedure B completes, control returns to procedure A and then back to the main program.

In more complex programming, procedures can call other procedures, called nested procedure calls. When procedure A calls procedure B, it needs to save its state in a similar manner as described for simple calls. This means storing the values of registers and the instruction location before control shifts to procedure B. After procedure B finishes, the control returns to procedure A, which must still remember its previous context, before finally returning to the main program. This layered saving and restoring ensure that every procedure can execute without disrupting others.

It's like a family gathering where a parent leaves to help a child with homework. Before leaving the dinner table (procedure A), they note where they left off talking (current instruction) and help the child (calling procedure B). After assisting, they return to the table to pick up the conversation right where they left off.

After completing a procedure, the stack pops off its saved context and restores the registers and the program status word to continue executing from where it left off.

When a procedure finishes executing, the next step involves restoring the context saved earlier. This process is done by popping values off the stack – effectively removing values from the stack top and placing them back into the appropriate registers. This includes resetting the program counter to the location where the procedure was initially called. This action ensures that the program can continue executing without any interruption, maintaining a fluid workflow throughout all the calls.

Similar to putting away tools after a home repair job. After fixing a leak (completing a procedure), you put the tools back in their boxes (context values in stack) and return to what you were doing previously without losing track of your work.

--