5.1.1. Basic Steps in a Procedure Call

The process of a procedure call generally involves three basic steps: (1) save the context, (2) call the procedure, and (3) return to the main program.

When a procedure (or function) is called in programming, the CPU must first save the current state of the program. This includes saving the Program Counter (PC), which points to the next instruction, any relevant variables, and the Program Status Word (PSW), which keeps track of the CPU's status. Next, the CPU jumps to the starting address of the procedure to execute its code. Once the procedure has finished executing, the CPU returns to the main program, restoring all saved values so that the program can continue seamlessly.

Think of this like a chef who is preparing a dish. Before trying a new recipe (calling a procedure), the chef writes down the current dish's details (saving context) and then starts cooking (calling the procedure). Once the new recipe is done, they return back to the original dish, ensuring all previous ingredients and cooking steps are intact (return to the main program).

The stack memory is used to store the context when a procedure is called, and its organization is critical for nested calls.

The stack is essentially a last-in, first-out (LIFO) data structure that stores various pieces of information needed for procedure calls. When a procedure is called, values such as the Program Counter and the registers are pushed onto the stack. For nested procedure calls (when one procedure calls another), each procedure saves its context on top of the previous one. The stack pointer helps track where the top of the stack is at any moment.

Imagine a stack of plates in a cafeteria. When a worker wants to add a plate, they place it on top of the one already there. If they need to retrieve a plate, they take the top plate off first. This is exactly how the stack structure works in a computer, keeping track of each procedure's context as plates represent different states in your program.

In a sample processor with a specific memory address range, the main program and procedures are located at defined memory spaces.

For a processor with a memory range of 000 to FFF, specific portions of memory are allocated for the main program and various procedures. For example, the main program might reside from memory address 110 to 2CF, procedure A might be at addresses 300 to 3B0, and procedure B might reside between 3C1 to 3EF. It’s important as these defined spaces help the processor know where to find the code for each part of the program.

Consider a library where books are stored in specific sections. Each section has its own genre, like fiction, non-fiction, or reference. When you look for a book, you go to the right section (memory address), which makes it quicker to find what you need, just like the CPU accessing specific addresses for procedures.

An example where the main program calls procedure A, which in turn calls procedure B, illustrates how the stack is used.

In a nested call example, the main program calls procedure A at a specific address, say 1CD. As procedure A runs, it may call another procedure, procedure B, at an address like 37A. Each time a procedure is called, the stack saves the context allowing the program to return to the correct position. When each procedure completes, control is returned in the reverse order of the calls, restoring the context from the stack.

Think of a relay race. The runner (main program) passes the baton (control) to the next runner (procedure A), who might pass it to a third runner (procedure B). When the last runner finishes, they hand the baton back to the previous runner, ensuring each runner knows where they need to continue the race, just like restoring the context with the stack.

The stack pointer is crucial in managing where the next context should be saved or retrieved from within the stack.

The stack pointer (SP) points to the current top of the stack. When a value is pushed onto the stack, the SP is decremented (assuming a downward growing stack) to account for the new top. Conversely, when a value is popped off the stack, the SP is incremented, allowing access to the previous values. This management is fundamental for ensuring the correct context is maintained throughout nested procedure calls.

Think of a parking garage where each floor is packed with cars. The stack pointer is like the elevator that tells you which floor is the last available parking spot. As cars are parked (pushed), the elevator indicates the next available space. When cars leave (popped), it updates to show which floor is now the last used. This helps maintain an organized flow of cars (contexts) waiting or needing space.

--