5.2.3. Returning Values from Procedures

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 the stack pointer is a register which plays a very special role over here. It’s 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, after completing the procedure return back to the main program from where the procedure is called.

In a procedure call, there are three main steps. First, before calling a procedure, you must save certain values in a stack. This stack is a special temporary storage area in memory. Second, you execute the procedure itself by jumping to the memory location where the procedure code starts. Finally, after the procedure has completed, you must return to the original point in the main program where you made the call, ensuring that all relevant saved values (like the program counter and any required variables) are restored.

Think of calling a friend to discuss a project. Before you call, you jot down notes and reminders (saving values). When you call, you go through your points (execute the procedure). Once done, you hang up and look at your notes again to pick up where you left off (returning to the main program).

So, we have a processor whose memory address range is 000 to FFF. The memory contains a part reserved for the stack. This part of the program memory is allocated for a stack when your stack will be saved and it is assumed that the stack goes downwards. The main program is located from 1100 to 2CF, procedure A is loaded between 300 to 3B0, and procedure B is at 3C1 to 3EF.

In the memory layout of our processor, different sections are assigned specific ranges. The addresses run from 000 to FFF, and part of this range is strictly designated for the stack, which stores return addresses and other temporary data. The main program and procedures A and B have their individual places within this memory layout. Understanding where each component is located helps in managing calls and returns effectively because it ensures that the CPU knows where to save data and where to jump during executions.

Imagine a filing cabinet with labeled drawers for each project you're working on. Each drawer represents a memory segment: one for the main documents, one for Project A's files, and another for Project B. When you need to find information or add notes to a project, you know exactly which drawer to open, making the organization efficient.

The stack pointer at present is F20, that is the top of the stack it is assumed. The stack points to a certain part of the memory. As you execute a procedure, the stack pointer will decrement as you save the necessary context such as program counter and general-purpose registers before jumping to the procedure's starting address.

The stack pointer indicates the current top of the stack memory. When a procedure call occurs, the CPU saves the program counter (address of the next instruction to execute in the main program) and other important values to the stack by decrementing the stack pointer. This ensures when the procedure is finished, the CPU can retrieve and restore the original context to continue executing the main program from where it left off.

Consider a stack of plates. Each time you need to set the table for a meal (call a procedure), you take a plate off the top (decreasing the stack pointer) and save it somewhere else (store the context). Once the meal is done (the procedure is completed), you retrieve the plates in reverse order (returning values from the stack) to put them back on the table for the next meal.

When executing the main program, the procedure call will push the return address to the stack, save the necessary status and registers, then jump to the procedure's memory address. Afterwards, upon completion of the procedure, the stack is unwound to retrieve the original context and resume execution.

The execution flow involves several steps. Initially, the program saves its state to the stack (return address, current status, and variable values). It then jumps to the procedure where the desired computations or operations are performed. After completing the procedure, the CPU pops the saved state from the stack to restore the original execution context, ensuring that it can continue from the exact point where it was interrupted.

Imagine planning a vacation (the main program). Before you start, you list everything you’ll need (push to stack). You then go on your trip (execute the procedure) and when you return, you unpack your bags (retrieve from stack) and resume your life where you left off.

--