Address-format code for Y=(A-B/C)×(D+E×G)/F

Assumptions: the operands are memory locations, R1, R2, ... are CPU registers, T1, T2, ... are temporary memory locations, and Y receives the result. Multiplication and division are done before addition and subtraction, and equal-priority operators go left to right. The product and the division at the same level are done left to right: ((A - B/C) × (D + E×G)) / F.

Fully bracketed: Y = ((A-(B/C))(D+(EG)))/F. Postfix (reverse Polish) form: A B C / - D E G * + * F /.

Three-address instructions (OP dest, src1, src2)

DIV R1, B, C    ; R1 = B / C
SUB R2, A, R1   ; R2 = A - R1
MUL R3, E, G    ; R3 = E * G
ADD R4, D, R3   ; R4 = D + R3
MUL R5, R2, R4  ; R5 = R2 * R4
DIV Y, R5, F    ; Y = R5 / F

Number of instructions: 6. Shortest program, but each instruction is long (three addresses).

Two-address instructions (OP dest, src; dest = dest OP src)

MOV R1, A   ; R1 = A
MOV R2, B   ; R2 = B
DIV R2, C   ; R2 = R2 / C
SUB R1, R2  ; R1 = R1 - R2
MOV R2, D   ; R2 = D
MOV R3, E   ; R3 = E
MUL R3, G   ; R3 = R3 * G
ADD R2, R3  ; R2 = R2 + R3
MUL R1, R2  ; R1 = R1 * R2
DIV R1, F   ; R1 = R1 / F
MOV Y, R1   ; Y = R1

Number of instructions: 11. A MOV is needed first because the destination operand is overwritten.

One-address instructions (accumulator AC is the implied operand)

LOAD B    ; AC = B
DIV C     ; AC = AC / C
STORE T1  ; T1 = AC
LOAD A    ; AC = A
SUB T1    ; AC = AC - T1
STORE T2  ; T2 = AC
LOAD E    ; AC = E
MUL G     ; AC = AC * G
ADD D     ; AC = AC + D
MUL T2    ; AC = AC * T2
DIV F     ; AC = AC / F
STORE Y   ; Y = AC

Number of instructions: 12. Intermediate results that cannot stay in AC are saved in memory temporaries.

Zero-address instructions (stack machine)

PUSH A  ; push A
PUSH B  ; push B
PUSH C  ; push C
DIV     ; pop two, compute, push result
SUB     ; pop two, compute, push result
PUSH D  ; push D
PUSH E  ; push E
PUSH G  ; push G
MUL     ; pop two, compute, push result
ADD     ; pop two, compute, push result
MUL     ; pop two, compute, push result
PUSH F  ; push F
DIV     ; pop two, compute, push result
POP Y   ; Y = top of stack

Number of instructions: 14. Only PUSH and POP carry an address; ADD, SUB, MUL, DIV work on the top two stack items, so the program follows the postfix form directly.

Summary: 3-address = 6, 2-address = 11, 1-address = 12, 0-address = 14 instructions. Fewer addresses per instruction means shorter instructions but more of them.