5.4.2. Upcoming Topics in CPU Execution

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 within a CPU, all components involved operate in a manner similar to other functions and instructions. However, the stack pointer is particularly crucial because it denotes where the CPU should read from or write to within the stack during the operation of storing and retrieving data related to function calls.

Think of the CPU components like a team of chefs in a kitchen. While every chef has their specific role, the head chef (stack pointer) directs which ingredients (data) go into which dishes (functions) at any moment. If the head chef doesn’t do their job well, the kitchen gets chaotic.

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.

The process of calling a procedure in a CPU involves three fundamental steps: 1. Calling the procedure involves placing relevant information into a stack (a temporary storage area). 2. The CPU then jumps to the starting address of the procedure in memory to execute it. 3. After execution, the CPU must return to the original call point, restoring any saved data, such as the program counter and status variables, to ensure that the program continues where it left off without losing context.

Imagine a library where each book represents a procedure. When you want to read a book (call a procedure), you note down your current page (store context, like the program counter) on a bookmark (stack) and then find the book’s location (trigger the jump to the memory location of the procedure). After reading, you go back to the exact page where you left off by referring to the bookmark.

So, we have a processor whose memory address range is 000 to FFF. So, it is an 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.

In a CPU, the memory layout consists of designated ranges for different purposes. A processor with a 12-bit address bus can address memory locations from 000 to FFF in hexadecimal format. A portion of this range is set aside specifically for the stack, which is critical for managing procedure calls by temporarily holding variables and return addresses.

Think of a large office building with multiple floors: each range (000 to FFF) represents a floor and each office within that floor is a memory address. Some floors (like the top one) are designated for storage (stack) where employees keep temporary files while they work on tasks in their specific offices (procedures).

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 in a nested procedure with the example is given below.

When a procedure is called, its execution often leads to modifications in the stack, especially in nested scenarios where procedures call other procedures. The stack grows downwards as new data is pushed onto it, and each time a new procedure is called, the relevant data (like return addresses and status registers) is saved on the stack. This ensures that after each call completes, the CPU can properly resume execution in the correct context.

Imagine you’re stacking plates in a cafeteria. When a new customer places their plate on the stack (calling a new procedure), you need to remember the last plate placed down to ensure that the next customer knows what the last order was (the contexts that must be restored). After they leave, the stack diminishes, allowing previous customers to pick up where they left off.

The stack pointer value is there we are having 4 general purpose registers which will hold the values, that is your scratch pad kind of a thing which are the general purpose registers which are given to you to basically for user programming.

The stack pointer indicates the current location in the stack. As different procedures are called and data is pushed or popped, the value of the stack pointer changes, pointing to the new 'top' of the stack. The CPU also utilizes general-purpose registers for intermediate calculations, allowing the processor to maintain the flow of data efficiently as different instructions are executed.

Consider a chef using different bowls for mixing ingredients (general-purpose registers). As the chef prepares multiple dishes (nested procedures), they stack the bowls in a specific order (stack). Each time a new dish requires mixing, the chef adds another bowl (pushes data to the stack), and when a dish is completed, they take away the bowl from the top (popping the stack).

So, now we have built our context and now let us go ahead with the implementation. So, our stack was at 20 if you remember our stack was pointing over here. Now main program is calling the procedure A.

The example illustrates how the stack is manipulated during the calling of nested procedures. Initially, the stack is at a specific pointer (e.g., 20), and when the main program calls Procedure A, relevant values such as program counter and status registers are saved into the stack. The stack pointer is then updated to reflect the new top of the stack, ensuring all necessary context is preserved for later retrieval.

Think of a relay race where each runner (procedure) has to memorize their starting point (stack pointer) and hand off a baton (data) to the next runner. When a runner starts (calling a procedure), they pass their current position and baton to the next runner (stack update) to continue the race without any form of confusion on how the race began.

Similarly, while 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.

During the execution of Procedure A, it might need to call another procedure (Procedure B). This again requires saving the current context (like the instruction pointer and any local variables) on the stack before jumping to Procedure B. When Procedure B completes, the execution flow must return back correctly to where it left off in Procedure A, which means the stack needs to handle these layers of calls effectively.

Think of a multi-step recipe where you are jumping back and forth between instructions (procedures) and keeping track of where you’re at in the recipe (context). Each time you step away to prepare a different ingredient (calling another procedure), you must note down your current location in the recipe so that you can come back to it without losing your place.

So, after procedure B is completed what do you have to do? You have to start executing procedure A from the point which we have left.

Once Procedure B finishes execution, it needs to correctly return to Procedure A by retrieving all the necessary information stored in the stack. The stack pointer helps in adjusting back to the previous state by popping the saved values from the stack, ensuring that the CPU resumes operations at the correct location within Procedure A, maintaining continuity and context.

It's like a teacher coming back to their classroom after a fire drill. Before they left, they noted where they stopped in their lesson plan (popping data from the stack). Once back, they review that point to begin teaching seamlessly from where they paused, ensuring the class continues without confusion.

--