# Modes of Addressing ## What is an addressing mode? - Addressing modes define **how instructions in assembly language or machine code access data stored in memory** - Different addressing modes provide flexibility in how operands are specified and retrieved - There are **four main types** of addressing modes: - Immediate - Direct - Indirect - Indexed

An **addressing mode** is a method by which an instruction specifies where to find its operand (data) in memory or registers

## Immediate Addressing - The **operand is part of the instruction itself** - The value to be used is directly embedded in the instruction - No memory access is required beyond fetching the instruction ```assembly MOV AX, 1234h ``` - This moves the immediate hexadecimal value `1234h` directly into the `AX` register - The value `1234h` is stored as part of the instruction

Immediate addressing is the fastest mode because it requires no additional memory lookups

### Example with different values ```assembly ADD BX, 50 ``` - Adds the immediate value `50` directly to whatever is currently in the `BX` register ## Direct Addressing - The **memory address of the operand is directly specified** in the instruction - The instruction contains the actual address where the data is located - One memory access is required to fetch the data ```assembly MOV AX, [1234h] ``` - Takes the value stored at memory location `1234h` and moves it to the `AX` register - The square brackets `[ ]` indicate "go to this address and fetch the value" ### Comparison table | Addressing Mode | Instruction Example | What Gets Moved | |-----------------|-------------------|-----------------| | Immediate | `MOV AX, 1234h` | The value `1234h` | | Direct | `MOV AX, [1234h]` | The value found at address `1234h` | ## Indirect Addressing - A **register contains the memory address** of the operand - The instruction uses a register as a pointer to the actual data location - Two lookups required: first the register, then the memory location it points to ### Example scenario If register `BX` contains the value `2000h`: ```assembly MOV AX, [BX] ``` - The CPU looks at what value is stored in `BX` (which is `2000h`) - It treats `2000h` as a memory address - It goes to memory location `2000h` and retrieves whatever value is stored there - That value is then moved into the `AX` register

`[BX]` does **not** mean "move the value in BX into AX" — it means "use BX as an address and fetch the data at that address"

### Key concept - **Without brackets**: `MOV AX, BX` → Copy the value from register `BX` to register `AX` - **With brackets**: `MOV AX, [BX]` → Use `BX` as a memory address, go to that address, and fetch the value stored there ### Practical analogy Think of indirect addressing like following directions: - `BX` contains the house number (e.g., "2000") - `[BX]` means "go to house number 2000 and get what's inside" - You're not interested in the number 2000 itself, but what you find when you go there ## Indexed Addressing - **Combines a base address with an offset** to compute the effective address - Useful for accessing elements in arrays or data structures - Adds two values together to determine where to look in memory ### Example scenario If `BX` contains `0050h` and `SI` has a base address `1000h`: ```assembly MOV AX, [BX + SI] ``` - Calculate the effective address: `1000h + 0050h = 1050h` - Go to memory location `1050h` - Move the value found at that location into the `AX` register ### Array access example Indexed addressing is commonly used for iterating through arrays: ```assembly MOV AX, [1000h + DI] ``` - If `DI` (destination index) starts at `0` and increments by `1` each loop iteration - First iteration: accesses address `1000h + 0 = 1000h` - Second iteration: accesses address `1000h + 1 = 1001h` - Third iteration: accesses address `1000h + 2 = 1002h`

Indexed addressing enables efficient traversal of sequential data structures without modifying the base address

## Summary Comparison Table | Mode | Syntax Example | Operand Location | Memory Accesses | |------|----------------|------------------|-----------------| | **Immediate** | `MOV AX, 42` | In the instruction itself | 0 (just instruction fetch) | | **Direct** | `MOV AX, [1200h]` | At address `1200h` | 1 | | **Indirect** | `MOV AX, [BX]` | At address stored in `BX` | 2 (register + memory) | | **Indexed** | `MOV AX, [BX + SI]` | At address `(BX + SI)` | 2 (registers + memory) | ## Worked Example Consider a basic computer system with the following assembly language instructions and a memory layout starting at address 1000. ```assembly 1000: MOV AX, 8 1002: ADD AX, [BX] 1004: MOV [0008], AX 1006: MOV CX, [BX+DI] 1008: HLT ``` **Initial register values:** - `AX = 0000` - `BX = 0003` - `DI = 0002` - `CX = 0010` **Memory contents:** | Address | Value | |---------|-------| | 0000 | 0 | | 0001 | 0 | | 0002 | 0 | | 0003 | 5 | | 0004 | 0 | | 0005 | 7 | | 0006 | 7 | | 0007 | 9 | | 0008 | 0 | ### Question (a) **For the instruction at 1002, identify the addressing mode used and explain what it does in the context of this instruction. [2 marks]** ### Answer (a) The instruction at `1002` uses **Indirect Addressing** The instruction `ADD AX, [BX]` adds the value at the memory address contained in the `BX` register to the `AX` register Since `BX` contains `3`, it will add the value at memory address `0003` (which is `5`) to `AX` ### Question (b) **After the instruction at 1004 has executed, what will the value at memory address 0008 be? Justify your answer. [2 marks]** ### Answer (b) The value at memory address `0008` will be **13** Before the instruction at `1004`, `AX` contains the value `8` After executing instruction at `1002` (`ADD AX, [BX]`), the value `5` from memory address `0003` is added to `AX`, giving `AX = 13` The instruction `MOV [0008], AX` then stores this value `13` at memory address `0008` ### Question (c) **What value will be moved into the CX register after the instruction at 1006 executes? Explain the addressing mode used. [2 marks]** ### Answer (c) The value moved into the `CX` register will be **7** The instruction at `1006` uses **Indexed Addressing** It accesses memory by combining the address in `BX` with the offset in `DI` Given `BX = 3` and `DI = 2`, the effective address is: $3 + 2 = 5$ It fetches the value `7` from address `0005` into `CX` ## Common Mistakes to Avoid ### Confusing register contents with addresses - `MOV AX, BX` → Copies the **value** in `BX` to `AX` - `MOV AX, [BX]` → Uses `BX` as an **address** and fetches data from that location ### Forgetting to calculate effective addresses In indexed addressing: - `MOV AX, [1000h + DI]` where `DI = 5` - The effective address is `1005h`, not two separate addresses ### Misunderstanding immediate vs direct - Immediate: `MOV AX, 100` → The value `100` itself - Direct: `MOV AX, [100]` → The value stored at address `100`