14.5.2.2. Operational Steps for ADD Instruction

The first 3 steps are similar for all types of instructions because they correspond to instruction fetch. In step 1, the program counter value is loaded into the bus. The program counter is read into the memory address register. Memory is set to read mode, and the ALU adds the program counter value, which is now in the bus, with a constant value, which is the next memory location. This is then waited to be loaded into the program counter in the next iteration. In the second step, we wait until the memory indicates that it has dumped the values or the instruction into the memory data register. In step 3, the memory signals readiness, and the memory data register transfers the instruction to the instruction register via the bus. The instruction register now has the instruction to be executed.

The first three steps in executing any instruction are crucial as they are consistent across instruction types. First, the program counter (PC) points to the location of the next instruction in memory. This value is transferred to the memory address register so that the memory can fetch the instruction. Next, we read from memory, enabling the ALU to prepare the PC for the next instruction by incrementing its value. This process is standardized before any actual instruction is executed. Once the memory indicates it is ready (i.e., the instruction has been fetched), this instruction is loaded into the instruction register where it can be accessed for execution.

Think of the instruction fetch process like ordering food at a restaurant. The program counter is like your order number; it tells the chefs (memory) which meal (instruction) to prepare next. When you place your order (load the address), you are waiting for the kitchen to finish preparing your meal. Once they let you know your meal is ready, they bring it to your table (instruction register) so you can start eating (executing the instruction).

Starting from the fourth step and onwards, instructions change depending on the addressing mode. In the case of a direct instruction, you take the value of M from the instruction register, indicating a specific memory location from which to read data. This value M is loaded into the memory address register. The memory is then set to read mode, and the instruction waits for memory to respond. Once the response is ready, the operand at memory location M is transferred into the memory data register. Finally, in the last step, the operand is moved to the appropriate register.

In the direct addressing mode, starting from step four, we specify the memory location directly in the instruction itself. The instruction stored in the instruction register provides this address. After moving this address to the memory address register, we set the memory to read mode to access the data at the specified address. Once the memory completes the read operation, it transfers the value to the memory data register. Finally, we execute the instruction by moving the operand from the memory data register to the designated register where it can be utilized in further computations.

Consider this like you having a grocery list (the instruction) that specifies exactly which ingredients (data) to buy from a specific aisle in the store (memory location). Once you get to the aisle (reading mode activated), you take the listed items (operand) off the shelf (memory data register) and place them in your cart (the register). The journey from the list itself to the cart symbolizes fetching the instruction and then the data needed for your recipe.

In an indirect addressing mode, the memory location M points to another memory location that contains the actual operand. After the first three common steps, in step 4, the value of M is loaded into the memory address register. In the fifth step, the algorithm waits for the memory to indicate readiness, transferring the intermediary address value of M to the memory data register. Step 6 requires us to load this intermediary value into the memory address register again, which then points to the actual operand. Finally, in step 7, the ALU retrieves the operand from the second memory location to execute the instruction.

Indirect addressing means that instead of directly working with the final data, we first retrieve an address that points to the actual data. In the indirect mode, after fetching the instruction and determining the first address (M), we load that into the memory address register. When we read the data at that address, it might not be the final operand, but another address. Hence, we need to load this new address into memory address register to access the real operand. The process is a chain of operations that ultimately leads us to the data we need for execution.

This can be compared to a postal delivery process. Instead of receiving a package (the operand) directly, you first receive a letter (address) which tells you where to pick up the actual package. You read the address from the letter, head to that location (first memory access), retrieve another letter (new address) from there, and then finally go to the new address to collect your package (the operand), illustrating how complex addressing modes can be.

In immediate addressing mode, the operand is directly included in the instruction itself. After the first three fetching steps, the fourth step is straightforward: the value (for example, 32) is transferred directly from the instruction register to the designated register. This mode requires the fewest steps as there's no need for memory access for the actual operand.

Immediate addressing is the simplest form of execution since the operand is embedded within the instruction. For example, if you have an instruction such as LOAD R1, 32, this means you are directly loading the number 32 into register R1 without needing to refer to memory. Following the standard fetch steps, the processor simply transfers the operand straight from the instruction register to the register in one additional step.

Think of immediate addressing like getting a snack directly from your pocket instead of going to the pantry. If you're hungry and pull out a granola bar you stashed away earlier (the operand), you can eat it right away without having to go through the process of looking for where the snack is stored (like fetching from memory).

--