15.3.1. Types of Addressing Modes

Now, we will go to another mode, which is more complex in nature, which is the indirect mode. By indirect mode we mean that whenever it’s the indirect mode of 𝑀; that means, we say this is the memory here is 𝑀, at the address of 𝑀 here there may be some addresses called x that are some content over here, then again you have to look at the content in x and basically this is your operand.

Indirect addressing mode involves a level of indirection in the way addresses are handled. In this mode, the actual address of the operand is not specified directly. Instead, it is stored in another memory location. For instance, if you want to access an operand through indirect addressing, the instruction first references a memory location (let's call it M) that contains an address (let's call it x). You then look up the address stored in M to access the data you need (the operand). This extra step is what makes indirect addressing more complex than direct addressing.

Think of indirect addressing like using a library catalog. Instead of directly picking a book from the shelf, you first locate the book's catalog entry (the indirect reference). The catalog tells you the shelf number (the address stored in M) where the book is located (the operand). You then go to that shelf to find the book itself.

If you now look at basically your first 3 stages; as I already discussing like 𝑃𝐶 𝑜𝑢𝑡, 𝑀𝐴𝑅, and this is control stage basically are only for fetching the instruction.

To fetch an instruction using the indirect addressing mode, the system undergoes a series of steps. The first three stages involve: 1) Outputting the Program Counter (𝑃𝐶) to retrieve the address of the instruction. 2) Loading that address into the Memory Address Register (𝑀𝐴𝑅), which is responsible for holding the address from where the data will be read. 3) Entering the control stage, where signals are generated to read the instruction from memory. This is crucial because these initial stages are dedicated to ensuring that the correct instruction is fetched for execution.

Imagine you are at a restaurant. The first step is to check the menu (Program Counter) to decide what meal you want. Next, you tell the waiter (Memory Address Register) your order (the address). Finally, the waiter goes to the kitchen (control stage) to fetch your meal. Each step is important to ensure you get the correct dish.

In the fourth stage what I am going to do is take the value of 𝑀 and feed it into the memory address register.

Once the instruction has been fetched successfully, the next vital step is to load the operand. In the fourth stage of execution, the system takes the value of M (the address of the operand location) and loads it into the Memory Address Register (𝑀𝐴𝑅). This operation allows the system to locate where the actual data corresponds to the address contained in M is stored. Therefore, the memory management becomes essential for the performance and efficiency of operations.

Using the earlier library analogy, once you've identified the correct shelf number for your book, you go and point it out to the staff (loading into the memory address register). This action tells them exactly where to look to find your book on the shelf.

Now, the content of memory location that is, x will be given into the memory data register after you have to wait for MFC.

After the address has been loaded into the Memory Address Register, the system must wait for the Memory Function Complete (MFC) signal, indicating that the data has been successfully retrieved from memory. Once the memory location x is accessed, the content stored there is transferred into the Memory Data Register (MDR). This step is crucial, as it holds the actual operand that will be used in the execution of the instruction.

Returning to our restaurant analogy, after you tell the waiter which meal you want (loading the address into the memory address register), they then go to the kitchen and retrieve your meal (waiting for MFC). Once they have it, they bring your meal to your table where you can finally enjoy it (loading content into the memory data register).

Now you can load it to your 𝑅 or wherever by a simple signal sequence that is 𝑀𝐷𝑅 register 𝑅.

After the operand has been loaded into the Memory Data Register, the final task is to transfer this operand into the designated register (𝑅). This process involves a sequence of control signals that move the data from the Memory Data Register to the Register. This step completes the instruction by moving the operand into a location where it can be utilized for processing.

Finally, think of having your dish placed onto your table (the operand loaded into the register). Now, you can eat your meal (execute the instruction) at your convenience. The dish has arrived, and the process is complete.

So, now again another mode we are taking which is called register indirect. In this case it was a memory indirect; it is a register indirect that you have to go to the register, and the content of the register will also contain the location of a memory.

In register indirect addressing, instead of referring to a memory address directly, the instruction specifies a register whose content is the address of the operand in memory. This mode simplifies the fetching process because it avoids the need for an additional memory access to retrieve the address. For instance, if we have an instruction to load data from a memory location specified in a register, it leads to a more streamlined process.

Using our previous examples, imagine you’ve not only used the library catalog, but also have a book nearby that lists the shelf locations (register). Now you simply look at your list to find out where to go instead of checking the catalog again. This makes finding your desired book faster and more efficient.

In this case, if you see so, your instruction 𝑅 is a register where the exact address of the data is present.

Register indirect addressing is typically faster than memory indirect addressing because it only requires one memory access to retrieve the data. The address to access the operand is stored directly in a register, allowing the CPU to fetch the operand with fewer steps. This reduction in required steps enhances the overall efficiency and speed of executing instructions within the CPU.

Imagine needing a book from the library. If you recall directly where it’s located without looking it up (like having the address in a register), it saves you a lot of time compared to having to first check the catalog (like looking it up in memory). This directness helps improve efficiency.

--