16.4. Program Counter and Instruction Fetching

So, basically in the units what is in the unit summary, we will first discuss about the unit summary before going into the depth of the unit. Basically as you already know the control transfer instructions are of two type conditional and unconditional sorry unconditional and conditional as we shown in the cases in the slide. So, what is the unconditional jump instruction, an unconditional jump instruction is very simple like jump go to that memory location where the corresponding instruction is there, maybe you call a function so that is an unconditional jump. And what is the conditional jump, when you look at these flags and decide what to do like jump on zero to some memory location 3030 where the next instruction is there. It will jump only if the zero flag is set, so that way we can differentiate the means control transfer instruction as conditional and unconditional.

Control transfer instructions dictate how control flows through a program. These can be conditional, meaning they only execute if a specified condition is met (like a zero flag being set), or unconditional, which always executes the instruction. For example, an unconditional jump simply tells the program to go to a specified memory location regardless of any flags, while a conditional jump checks certain flags before proceeding.

Think of it like a traffic signal. An unconditional jump is akin to a driver proceeding through a green light without stopping, while a conditional jump is like a driver only proceeding if the light is green (checking for the condition).

As we have already discussed in the last three units that basically the three steps that is the first three steps basically involve fetching of the instruction. So, in this case what happens in the step one basically we load the program into the bus, PC into the bus and we give it to the memory address register, so that the corresponding instruction can be fetched. We make the main memory in read mode and we get the value of the program or the instruction in the memory data register in this third stage basically.

The process of fetching an instruction involves several steps: First, the current value of the Program Counter (PC) is loaded into the bus and then into the Memory Address Register (MAR). This allows the instruction at that address to be read from memory. The memory is set to read mode so it can provide the instruction to the Memory Data Register (MDR), which temporarily holds the instruction until it is ready for use.

Imagine a librarian fetching a book for you. First, the librarian checks the catalog (the PC) to find the book's location in the library (the MAR), then retrieves the book from the shelf (main memory) and keeps it on a desk temporarily (MDR) until you are ready to read it.

So, basically that is what is the thing and then we say that but here there are slight difference in case of a jump instruction or transfer instructions. In general type of instructions, we take the value of the program counter to the bus, put it in the address register, and then wait for the corresponding instruction to be obtained in the memory data register. And also what we do, we also try to increment the value of PC to the next value to point to the next instruction. But in this case we do a slightly separate step over here that what we do? We actually also stop the incrementing of the PC here, but also we store as we will see the requirement what is the necessity. We also put the temporary value of PC into a temporary register Y.

When executing jump instructions, there are additional steps compared to regular instructions. Specifically, the incrementing of the Program Counter (PC) is paused to store its current value in a temporary register (Y). This step is crucial because it preserves the address of the next instruction after the jump, which may be needed later for conditional jumps or function returns.

Consider a person using a bookmark while reading a book with multiple branches in the storyline (like a 'choose your own adventure' book). They pause to mark the next page (temp register Y) so they can easily find their way back after exploring a different path (jump).

Now, in this case, see previous case we have seen how to add, how to store from memory to the registers, but here actually it is something going to a jumps space. For example, let us take the instruction called jump unconditional to say 3030, then we want to jump to that memory location that is what is the execution part here. So, in this case, what we have to do, we have to somehow load the value of program counter in the next stage to 3030 that is what is the execution to be done.

For an unconditional jump instruction, such as 'jump to address 3030,' the process involves updating the Program Counter (PC) to that specific address. This means that the program will begin executing the instruction found at memory location 3030 after the jump is completed.

Think of it like having a GPS system. If you enter a new destination, the GPS reroutes you directly to that address (3030), ignoring the current route you're on. When you arrive at the new address, the navigation system takes over from there as if it had always been the planned destination.

The offset basically is a part of the instruction register, which actually goes to the CPU, CPU bus basically. So, what is an offset, offset is present value of PC − M and you take the general the positive value out of it. So, if you assume that the present value of the PC is equal to 10 for the time being let us assume that is equal to 10, so your offset will be 3030 this 10 − 3030 the positive you are going to take it.

The offset is calculated based on the current value of the Program Counter (PC) and the target memory address (M) that the jump instruction points to. It helps in determining how far to jump in terms of address. This offset is important for navigating memory relative to the current PC value, ensuring jumps are executed correctly, especially in relocating code.

Consider a treasure map where you are currently at point A but want to jump to point B. The offset is like the distance you need to travel from A to B. If you know you are at point A (10) and need to get to point B (3030), the map will help calculate that distance so you know how far to walk.

Now, what do you do the offset is set the offset value is this one and it is saying the input value of the CPU bus is the offset which is the second operand to the ALU. That means, what we are going to generate the jump address, and we are going to load it to the PC, that is what is the job of the fourth step.

In this step, the calculated offset is used as the second operand for the Arithmetic Logic Unit (ALU) to generate the final jump address. This address is then loaded into the Program Counter (PC). Essentially, this combines the current position and the calculated offset to determine where to jump next.

Think of this like a postal worker preparing a new letter for delivery. The workshop (ALU) uses both the sender's address (current PC value) and the distance information (offset) to accurately produce the final delivery address (new PC).

So, after that is already told that is nothing but value of PC − M this gets cancelled and you get the M. And basically this one you will now update Z will update to program counter, so you are now jumping to that instruction and you are actually executing it.

After performing the arithmetic with the offset, the ALU calculates the final memory location corresponding to the jump instruction. This value is then assigned back to the Program Counter (PC), effectively redirecting execution to the new code location specified by the jump.

This is like a person finally reaching their destination on a journey. After calculating the necessary turns and distance (offset), they arrive at the new location (PC update) and start their new task (executing the instruction at the new memory location).

--