17.4.1. Save Program Counter on Function Call

Now, let us see what happens... at this point, we say that the offset value of 𝐼𝑅 equal to out.

In this section, we learn about the mechanism of updating the Program Counter (PC) when a function is called. Instead of directly setting the PC to a target address (like 3200), we use an offset value that is calculated based on the current value of the PC. The formula used is offset + PC = target address. This allows greater flexibility, especially in systems that use relocatable programs, where the actual memory addresses might change when the program is loaded.

Imagine you are using a map app to navigate to various locations within a city. Instead of providing explicit street addresses (like 3200 Main St.), the app calculates the directions based on your current location, which constantly changes. This way, the app can guide you to your destination efficiently without needing to know the exact address beforehand.

In this case, the 𝐼𝑅 register is slightly multifunctional... here you are getting the offset.

The Instruction Register (IR) acts not just as a placeholder for the instruction to be executed but also helps in calculating the offset needed to set the next address for the Program Counter. When the IR is loaded with an instruction that includes an offset, the computer can first determine where to jump next and then calculate the exact memory location to jump to based on the current PC value.

Think of a recipe that provides instructions for cooking a dish. Rather than specifying an exact pan to use, it might say, 'Use the medium-sized frying pan you just used for the omelette.' In this example, you rely on your memory of what you previously used, similar to how the IR computes the required memory address based on current information.

So, basically, this tells that five microinstructions are required... we will not go in as details as I have told you.

After calculating the offset and obtaining the target address, a sequence of microinstructions is executed to update the Program Counter. In a typical jump instruction scenario, five microinstructions are carried out, which involve transferring data, setting control signals, and updating registers to effectively redirect program execution to the new address specified.

Switching between tasks can be likened to changing gears in a manual car. Just as you need to correctly execute a sequence (press the clutch, shift gears, release the clutch) to move smoothly from one speed to another, the processor needs to perform a series of precise operations (microinstructions) to change the flow of execution without running into issues.

Let’s slightly change the instruction mode that is jump on zero... and we will just give a direction which will be more and more or less similar.

The explanation then transitions to conditional jumps, such as the 'jump on zero' instruction. This highlights how conditional checks (e.g., evaluating a flag) alter the flow of execution based on whether certain conditions are met. This brings attention to the distinction between unconditional jumps and those dependent on certain program states.

This scenario is much like a traffic light guiding vehicles. A green light instructs cars to move forward without hesitation (unconditional), while a red light requires them to stop and wait for the condition of the light to change before proceeding (conditional).

First, very important is that we save the 𝑃𝐶... to the instruction which is calling the microinstruction.

During function calls, it is crucial to save the current Program Counter value (the address following the call). Typically, this is done using a stack, where the next instruction’s address is stored temporarily. When the function execution completes, this saved address can be retrieved to resume execution seamlessly.

Think of a bookmark placed in a book. When you pause your reading to go do something else, you place the bookmark at your current page so that you can easily pick up where you left off. In computing, saving the PC before jumping to a function is similar to placing a bookmark in a book.

Return is as important as call... but where it will go basically let this be the stack.

The return process is critical because it pulls the saved Program Counter value from the stack, allowing the program to resume at the correct point after the function execution is complete. This ensures that the flow of execution can continue correctly after temporarily diverting to another function.

Imagine working on a sports team playbook, where each play might have many variations. Each time a play is used, a coach scribbles down the next play on a notepad (saving the current position) and then shifts focus to executing the new play. When the new play is over, the coach can simply refer back to the notepad to know exactly where to resume.

--