16.2.3. Basic Steps Involved

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 the CPU changes flow during program execution. They come in two types:

1. Unconditional Jump: This simply tells the CPU to jump to a specified memory address (e.g., jump to location 3030) without any conditions.
2. Conditional Jump: This requires a certain condition to be true (e.g., the zero flag is set). If the condition is met, the jump occurs; otherwise, the program continues with the next instruction.

Imagine a train on a track. An unconditional jump is like a switch that allows the train to move to a different track (jump to another memory location) without hesitation. A conditional jump is like a signal that only allows the train to switch tracks if there is a green light (i.e., the zero flag is set).

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, 𝑃𝐶 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.

In the first three steps to fetch an instruction, the following occurs:

1. Load PC into the Bus: The current value of the Program Counter (PC) is loaded into the CPU bus.
2. Memory Address Register (MAR): The PC value is transferred to the MAR to indicate which instruction to fetch.
3. Read Memory: The memory is set to read mode, and the instruction is loaded into the Memory Data Register (MDR).

Imagine a delivery person fetching a package from a warehouse. First, they check the delivery list (the PC) to see what needs to be collected, then they go to the specific shelf (MAR) where the package is located, and finally, they pick it up (loading it into the MDR) and are ready to deliver it.

But in this case we do a slightly separate step over here that what we do? We actually also stop the incrementing of the 𝑃𝐶 here, but also we store as we will see the requirement what is the necessity. We also put the temporary value of 𝑃𝐶 into a temporary register 𝑌. We will see that why it is required later because in the time at the same stage when you are trying to increment the 𝑃𝐶 as well as we will have to store the value of the 𝑃𝐶 to a temporary register.

In the case of jump instructions, there is a crucial difference in handling the Program Counter:

• Unlike regular instructions, the PC is not automatically incremented after fetching a jump instruction. Instead, its current value is saved into a temporary register (Y). This is necessary for later use when the program needs to return or jump to a specific address.

Think of it as a person stopping to take a picture at a scenic spot (storing the PC in Y) instead of just moving on to the next location (incrementing the PC). They stop their journey momentarily to remember where they were before continuing.

Now 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. Because when you want to execute some instruction which is the memory location 3030, what we have to do is to simply load the value of 𝑃𝐶 to 3030 and your job will be done.

For executing a jump instruction, the value of the program counter needs to be loaded with the target memory address (e.g., 3030). This means that after fetching the jump instruction, the system prepares to change the flow of execution directly to this address by updating the PC with 3030.

It's like setting your GPS to a new destination (3030) after previously marking your current location. You input the address, and the GPS is ready to guide you there.

--