Solution - Autoincrement and Autodecrement Addressing Modes

Both are Register Indirect with automatic update modes, useful for array/table traversal and stack operations.

1. Autoincrement Addressing Mode: $(R)+$ or $[R+]$

• Definition: Effective Address $EA = [R]$ (content of register gives address). After operand is accessed, register is automatically incremented by size of operand ($+1$ for byte, $+2$ for 16-bit word, $+4$ for 32-bit).
• Operation: $EA \leftarrow R$; $R \leftarrow R + d$ (where $d$ = operand size).
• Use: For traversing arrays/buffers in forward direction, popping from stack, reading sequential data.

Example (8086-like / PDP-11 style):
Suppose $R_1 = 1000H$, Memory[1000]= $AB$, Memory[1001]= $CD$ (16-bit).
Instruction: MOV (R1)+, R2 ; or MOV @R1+, AC

• Fetch operand from address 1000H into R2.
• Then $R_1 \leftarrow 1000H + 2 = 1002H$ (for word).
  Now $R_1$ points to next element automatically.

Array sum loop:

      MOV #ARRAY, R1   ; R1 -> start
      CLR  R3          ; sum=0
LOOP: ADD (R1)+, R3    ; add *R1 to sum, R1 moves to next
      DEC  R2          ; count
      BNE  LOOP

2. Autodecrement Addressing Mode: $-(R)$ or $-[R]$

• Definition: Register is first decremented by operand size, then its content is used as Effective Address. $R \leftarrow R - d$; $EA \leftarrow R$.
• Use: For traversing arrays backward, pushing onto stack (stack grows downward).

Example:
Suppose $R_1 = 1002H$, $SP = 2000H$.
Instruction: MOV R2, -(R1) or PUSH R2 is MOV R2, -(SP)

• First $SP \leftarrow 2000H - 2 = 1FFEH$
• Then Memory[$1FFEH$] $\leftarrow R_2$.
  So decrement-before-store prevents overwriting.

Array reverse traversal:

      MOV #ARRAY_END, R1  ; point beyond last element
LOOP: MOV -(R1), R2       ; R1-- first, then fetch

Combined Example - Stack:

• PUSH A = MOV A, -(SP) (autodecrement)
• POP A = MOV (SP)+, A (autoincrement)

Comparison Table:

Feature	Autoincrement $(R)+$	Autodecrement $-(R)$
Order	Use then increment	Decrement then use
Pointer moves	Forward	Backward
For Stack	POP	PUSH
Initial R points	To current operand	To next free location

Both modes eliminate extra ADD/SUB instructions, improving code density and loop efficiency.