One-, Two-, and Three-Address Instructions: Definitions, Formats, and Examples

In instruction-set design and compiler back-end code generation, Address field count is often used to classify intermediate-code and assembly-like formats into one-address , two-address , and three-address forms.

A key idea: the “address” count usually refers to how many operand locations are explicitly referenced in the instruction word(s), not to the number of arithmetic inputs in the abstract computation. For example, a three-address instruction like “$R_d \leftarrow R_s1 \ \text{op}\ R_s2$” explicitly names two sources and a destination. Meanwhile, one-address architectures typically rely on an accumulator or implicit registers so that fewer operands appear in the instruction.

This section gives clear formats, then works a single example expression through each style, and finally compares trade-offs in instruction length and register pressure using a small data visualization.

Important note: This response requires web citations from the web-search tool, but the web-search tool call failed due to plan/usage limits. Therefore, I cannot attach the mandatory references/citations to major claims. If you enable/repair web-search access, I can re-run the research and produce a fully cited version.

Core mental model

Let the goal be to compute an expression such as:

$$X = A + B$$

or a longer expression:

$$Y = (A + B) * C$$

Different address styles change how you encode operand locations:

• One-address: uses an accumulator (or implicit operand registers). Many operations implicitly read from and/or write to the accumulator.
• Two-address: uses two explicit addresses; commonly the second operand is overwritten with the result: $$\text{op } R_d, R_s \Rightarrow R_d \leftarrow R_d \ \text{op}\ R_s$$
• Three-address: uses three explicit addresses: two sources and one destination: $$\text{op } R_d, R_{s1}, R_{s2} \Rightarrow R_d \leftarrow R_{s1} \ \text{op}\ R_{s2}$$

Keywords for this section

• accumulator
• register operand
• destination operand
• source operand
• register overwrite

One-Address Instructions

Typical format

In a classic “one-address” style, an arithmetic instruction names (at most) one explicit operand, while the other operand is implicit (usually the accumulator). A common model is:

$$ACC \leftarrow ACC \ \text{op}\ M$$

or:

• Load: $$ACC \leftarrow M$$
• Add from memory/register: $$ACC \leftarrow ACC + M$$

Example: compute $X = A + B$

Assume memory locations/registers $A$ and $B$, and an implicit accumulator $ACC$.

1. Load $A$ into accumulator:
   • LOAD A
   • $ACC \leftarrow A$
2. Add $B$ to accumulator:
   • ADD B
   • $ACC \leftarrow ACC + B = A + B$

Final result is left in the accumulator:

• STORE X (optional, if the ISA requires explicit store)

Mini-instruction sequence

• LOAD A
• ADD B
• STORE X

Two-Address Instructions

Typical format

Two-address forms name two operand addresses explicitly. A prevalent convention is that the destination is also one of the operands (often the first):

$$R_d \leftarrow R_d \ \text{op}\ R_s$$

So the instruction overwrites one input location with the result.

Example: compute $X = A + B$

Using registers $R1$ for $A$ and $R2$ for $B$:

1. Copy/prepare destination register:
   • MOV R1, A (or load $A$ into destination)
2. Perform operation with overwrite:
   • ADD R1, B means $R1 \leftarrow R1 + B$
3. Store result:
   • MOV X, R1 (or STORE X, R1)

Result: $X = A + B$.

What changed vs one-address?

• The accumulator is no longer the only implicit place.
• You explicitly name both an operand that is overwritten and another operand that is read.

Three-Address Instructions

Typical format

Three-address instructions explicitly name:

• two source operands and
• one destination operand.

A standard arithmetic encoding is:

$$R_d \leftarrow R_{s1} \ \text{op}\ R_{s2}$$

Example: compute $X = A + B$

One possible sequence:

• ADD R3, A, B
  which directly means: $$R3 \leftarrow A + B$$
• Then:
  • MOV X, R3 (store out)

What changed vs two-address?

• The destination is separate from the sources, reducing unwanted overwrites.
• This can make expression compilation easier (fewer temporary save/restore steps), at the cost of a longer instruction encoding (more address fields).

Side-by-side comparison