Indirect Addressing Mode: Effective Address Calculation

Indirect address mode is a form of addressing mode in which the instruction first obtains an address (a pointer) and then uses that pointer to locate the actual operand in memory.

A useful way to reason about this is to distinguish two steps:

1. Compute a pointer address (often just the contents of a register or a computed memory location).
2. Dereference that pointer by performing a second memory access to obtain the effective address of the data.

In notation often used in computer architecture texts, the indirect addressing effective address can be described as:

• If the pointer is stored in memory at address $A$, then $EA = M[A]$.
• If the pointer is stored in a register $R$, then $EA = M[R]$.

The core intuition: the register or intermediate memory location does not directly point to the data; it points to another location that ultimately contains the data or its address. (This yields an extra memory reference relative to direct addressing.)

To visualize the dereference, consider this generic indirect flow:

Key terms you’ll see: effective address (EA), dereference, pointer, memory reference.

Effective Address (EA) formulas for common indirect forms

Indirect addressing appears in multiple syntactic/ISA flavors, but the effective-address principle is consistent: $EA$ is obtained by one dereference of a pointer value.

Below are the most common patterns used in architecture and assembly-logic explanations:

1) Register Indirect

• Pointer comes from a register: $EA = M[R]$
• Here, $R$ holds a pointer (an address), and indirect addressing dereferences it once to get the final data location.

2) Memory Indirect

• Pointer comes from a memory location: $EA = M[M[A]]$
• Here, $A$ is an address where a pointer is stored; you dereference that memory cell to retrieve another address, and then (conceptually) that retrieved address is used as the effective address.

3) Indirect with displacement / indexed variants

Some instruction sets combine indirect concepts with an added displacement or index before dereferencing:

• Pointer address first: $A = (R + d)$ (or other base/index expression)
• Then: $EA = M[A]$

So even when there’s an arithmetic step, indirect addressing still has the same hallmark:

The instruction performs (at least) one extra memory access to follow the pointer.

Worked example: Register indirect

Assume:

• Register $R = 200$
• Memory contents: $M[200] = 600$
• Then indirect addressing implies:
  • Pointer value is $M[R] = M[200] = 600$
  • Effective address is $EA = 600$
  • The operand is located at $M[EA] = M[600]$

This can be summarized as: $EA = M[R] \quad \Rightarrow \quad EA = M[200] = 600$

Worked example: Memory indirect

Assume:

• Intermediate address $A = 300$
• Pointer stored at that memory address: $M[300] = 700$
• Then: $EA = M[A] = M[300] = 700$ and the operand is found at $M[700]$.

Why it matters (performance implications)

Because indirect addressing typically requires an extra memory reference (dereference), it can increase latency relative to modes that access data directly. In a simple pipeline/memory model, this can add a dependency chain:

• EA depends on the pointer load
• operand depends on EA So the CPU may need to wait for the first memory read before it can complete the second. This is closely related to the concept of memory access latency, data dependency, and pointer chasing.

Summary table: indirect vs direct (EA rule focus)