AQA A-Level Computer Science (7517)

## Learning Outcomes

- Understand what an **addressing mode** is and why the CPU needs one
- Identify the difference between **immediate addressing** and **direct addressing**
- Explain the roles of **opcode** and **operand** in a machine-code instruction
- Interpret simple assembly language instructions such as `LDA #10` and `LDA 10`
- Trace the effect of addressing modes on the **accumulator**
- Compare immediate and direct addressing in terms of speed, flexibility, and use cases
- Avoid common exam mistakes, especially confusing a memory address with the contents stored there

## AQA A-Level Computer Science (7517) Syllabus

For the AQA A-Level Computer Science (7517), you are expected to understand addressing modes within processor instructions, with a focus on the following syllabus points:

- Know that an instruction is made up of an **opcode** and an **operand**
- Identify that the **addressing mode** determines how the operand is interpreted
- Explain **immediate addressing** as the case where the operand is the actual value
- Explain **direct addressing** as the case where the operand is the memory address of the data
- Interpret assembly language instructions expressed in mnemonic form using immediate and direct addressing
- Understand the effect of instructions on a register such as the **accumulator**
- Compare immediate and direct addressing in simple processor operations
- Distinguish clearly between an address and the contents of that address

## Test Your Knowledge

_Attempt these questions before reading this article. If you find some difficult or cannot remember the answers, look more closely at that area during your revision._

1. What is the difference between an opcode and an operand?
2. How does immediate addressing differ from direct addressing?
3. If memory location 10 contains the value 42, what is the effect of `LDA #10` and `LDA 10`?
4. Why is immediate addressing often faster than direct addressing?
5. Why can direct addressing be more useful than immediate addressing when data changes?

## Introduction

Addressing modes are a small topic in terms of content, but they are very easy to get wrong in an exam. Many students can recognise the terms **immediate** and **direct**, but lose marks when they have to explain exactly what the operand means or what value ends up in the accumulator.

This subtopic matters because processor instructions are not just about _what_ operation is carried out. The CPU must also know _how to interpret the operand_. Is the operand the actual data value? Or is it the address of where that data is stored? That single distinction changes the whole meaning of an instruction.

> **Key Term: addressing mode**
> The part of an instruction that tells the CPU how to interpret the operand, such as whether the operand is a value or a memory address.

### Why addressing modes are needed in machine code instructions

A processor executes instructions stored in memory. Each instruction must be precise. The CPU cannot just be told to "load 10" unless it also knows what that 10 means.

There are two possibilities in this topic:

- 10 could mean the actual value **10**
- 10 could mean memory address **10**, where some other value is stored

Without an addressing mode, the processor would not know which meaning to use.

A machine-code instruction is normally divided into at least two parts:

- the **opcode**
- the **operand**

The opcode tells the processor what operation to perform, such as LOAD, ADD, STORE, or COMPARE. The operand provides the data needed for that operation, but the operand is not always interpreted in the same way. That is why the instruction also includes the addressing mode.

> **Key Term: opcode**
> The part of an instruction that specifies the operation to be carried out by the processor.
>
> **Key Term: operand**
> The part of an instruction that provides the data, or the address of the data, used by the operation.

In a simple teaching model, the addressing mode is treated as part of the opcode. In other words, the opcode does two jobs:

- it identifies the operation
- it identifies how the operand should be read

That is why two instructions that look similar can behave differently.

For example, suppose a processor uses an accumulator architecture. The accumulator is a register used to hold data being worked on. Consider these two instructions:

- `LDA #10`
- `LDA 10`

They both use the same basic operation: load data into the accumulator. But the meaning of the operand changes because of the addressing mode.

> **Key Term: accumulator (ACC)**
> A register used by some processor models to store data currently being processed.

If the CPU sees immediate addressing, it loads the number 10 itself.

If the CPU sees direct addressing, it treats 10 as a memory address and loads whatever value is stored at that address.

This is the core idea of the whole topic. Many longer answers are really testing whether you can explain this clearly and accurately.

> **Test Tip:** If a question asks you to explain an addressing mode, do not just say "it tells the CPU where data is." You must state whether the operand is the actual value or the address of the value.

### Immediate addressing

In **immediate addressing**, the operand is the actual data value that the instruction will use. The CPU does not need to go to another memory location to fetch that operand, because it is already present in the instruction itself.

A common assembly notation uses the `#` symbol to show this. For example:

- `LDA #10`
- `ADD #3`
- `MOV R1, #20`

In these examples, `#10`, `#3`, and `#20` are literal values. The processor uses those exact numbers.

> **Key Term: immediate addressing**
> An addressing mode in which the operand is the actual value to be used by the instruction.

Take this example:

- accumulator initially contains 7
- instruction: `ADD #5`

The CPU interprets the operand `#5` as the number 5 itself. It adds 5 to the accumulator.

Result:

- ACC = 12

No extra memory lookup is needed for the operand. That is why immediate addressing is usually faster than direct addressing. The value is already inside the instruction.

But speed is not the only issue. Immediate addressing is best when the value is fixed and known at the time the program is written. It is useful for constants such as:

- adding 1 in a loop counter
- comparing with 0
- loading a known starting value

A good example is:

`MOV R1, #0`

This sets register 1 to zero directly. It would be wasteful to store the number 0 in memory somewhere first and then load it from there.

#### Worked example: tracing immediate addressing

Suppose the instruction is:

`LDA #12`

Step by step:

1. `LDA` tells the CPU to load data into the accumulator.
2. `#12` shows immediate addressing.
3. The operand is interpreted as the value 12.
4. The accumulator becomes 12.

So the final result is:

- ACC = 12

Now consider:

`ADD #4`

If ACC was already 12, then:

1. `ADD` tells the CPU to perform addition.
2. `#4` means use the literal value 4.
3. CPU adds 4 to the accumulator.
4. ACC becomes 16.

This is straightforward, but students sometimes overcomplicate it by talking about memory addresses when there are none involved in the operand value itself.

#### Why immediate addressing is often faster

Immediate addressing avoids an additional memory access for the operand. The CPU still has to fetch the instruction from memory as part of the fetch-execute cycle, but once the instruction is decoded, the operand value is already available.

Cause and effect:

- operand is stored in the instruction
- CPU does not need a second fetch to read data from another memory location
- fewer steps are needed
- execution is often quicker

This does not mean the entire instruction always runs instantly or that immediate addressing is always "best". It just means that for the operand itself, no extra memory fetch is required.

> **Test Tip:** If asked why immediate addressing is faster, link your answer to memory access. A strong answer says that the operand is already contained in the instruction, so the CPU does not need an extra read from memory to obtain the data.

### Direct addressing

In **direct addressing**, the operand is not the data itself. Instead, it is the memory address where the data is stored. The CPU must go to that address to retrieve the value.

For example:

- `LDA 10`
- `ADD 25`

Here, `10` and `25` are memory addresses, not literal values.

> **Key Term: direct addressing**
> An addressing mode in which the operand contains the memory address of the data to be used.

Suppose memory location 10 contains the value 42.

Then the instruction:

`LDA 10`

means:

1. `LDA` tells the CPU to load into the accumulator.
2. The operand `10` is treated as an address.
3. The CPU accesses memory location 10.
4. It reads the contents stored there, which is 42.
5. The accumulator becomes 42.

So:

- ACC = 42

This is very different from `LDA #10`, which would load the number 10 itself.

That single missing `#` changes the instruction from immediate to direct addressing.

#### Worked example: side-by-side comparison

Assume:

- memory location 10 stores 42
- accumulator starts at 0

Instruction 1:

`LDA #10`

Interpretation:

- immediate addressing
- operand is the value 10

Result:

- ACC = 10

Instruction 2:

`LDA 10`

Interpretation:

- direct addressing
- operand is address 10
- contents of address 10 are 42

Result:

- ACC = 42

This is the exam classic. If you can explain this clearly, you are handling the main distinction properly.

#### Why direct addressing is more flexible

Direct addressing is slower than immediate addressing in many cases because the CPU must access memory to fetch the data at the given address. However, it is more flexible for variables.

Why?

Because the instruction does not need to change when the data changes.

Suppose a program contains:

`LDA 10`

Today, memory location 10 might contain 42. Later, after another part of the program runs, memory location 10 might contain 99. The same instruction still works. It loads whatever value is currently stored there.

That makes direct addressing suitable for:

- variables
- changing totals
- user input stored in memory
- values produced during program execution

By contrast, `LDA #42` will always load 42 unless the instruction itself is changed.

This leads to an important exam distinction:

- **Immediate addressing** is good for constants
- **Direct addressing** is good for variable data held in memory

### Assembly language notation and instruction interpretation

In assembly language, mnemonics are used instead of raw binary opcodes. This makes programs easier for humans to read. For addressing modes, the notation often gives you a clue to how the operand should be read.

> **Key Term: assembly language**
> A low-level programming language that uses mnemonic codes to represent machine instructions.
>
> **Key Term: mnemonic**
> A short human-readable code, such as `LDA` or `ADD`, that represents a machine-code instruction.

Typical examples include:

- `LDA #10` means load the value 10
- `LDA 10` means load the contents of address 10
- `ADD #1` means add the value 1
- `ADD 20` means add the contents of address 20

Do not just memorise the symbols. Understand what they mean operationally.

#### Worked example: high-level meaning

Assume:

- memory location 20 contains 8
- accumulator initially contains 5

Instruction:

`ADD 20`

Reasoning:

1. `ADD` means add to the accumulator.
2. No `#` means direct addressing in this notation.
3. Operand 20 is a memory address.
4. CPU reads contents of location 20, which is 8.
5. CPU adds 8 to current ACC value 5.

Final value:

- ACC = 13

Now compare with:

`ADD #20`

Reasoning:

1. `ADD` means add to accumulator.
2. `#20` means immediate addressing.
3. CPU uses the literal value 20.
4. CPU adds 20 to current ACC value 5.

Final value:

- ACC = 25

Again, same operation, different interpretation of operand.

#### Common student errors

Students often lose marks in three predictable ways.

First, they confuse the address with the contents of the address.

Wrong idea:

- "`LDA 10` loads 10"

Correct idea:

- `LDA 10` loads the contents stored at address 10

Second, they forget the meaning of `#`.

Wrong idea:

- `#` is optional decoration

Correct idea:

- `#` changes the operand from an address to an immediate value in standard teaching notation

Third, they write vague definitions.

Weak definition:

- "Immediate addressing means the value is given"

Better definition:

- "Immediate addressing means the operand field contains the actual data value used by the instruction"

The better answer removes ambiguity.

> **Test Tip:** In a compare question, use a paired sentence structure: "In immediate addressing, the operand is the actual value. In direct addressing, the operand is the memory address of the value." This is concise and usually scores well.

### How to reason through exam questions

AQA questions on this topic often ask you to interpret an instruction, explain a difference, or state the effect on the accumulator. The safest method is to break the instruction into parts.

Use this sequence:

1. Identify the operation from the mnemonic or opcode.
2. Identify the addressing mode.
3. Decide whether the operand is a value or an address.
4. If it is an address, look up the contents stored there.
5. State the final effect on the accumulator or register.

#### Worked exam-style example

Suppose:

- memory location 15 contains 9
- ACC currently contains 4

Instruction:

`ADD 15`

Step by step:

1. Operation is `ADD`
2. Addressing mode is direct
3. Operand 15 is a memory address
4. Contents of address 15 are 9
5. Add 9 to ACC value 4

Final result:

- ACC = 13

Now change the instruction to:

`ADD #15`

Step by step:

1. Operation is `ADD`
2. Addressing mode is immediate
3. Operand is the value 15
4. Add 15 to ACC value 4

Final result:

- ACC = 19

This style of answer shows both knowledge and method. That matters because examiners reward precision.

#### A clear comparison table in words

Think of the two modes like this:

- Immediate addressing: "Use this number"
- Direct addressing: "Go to this location and use the number stored there"

Comparison:

- Immediate addressing uses the operand as data
- Direct addressing uses the operand as an address
- Immediate addressing avoids an extra memory fetch for the operand
- Direct addressing allows the stored value to change without rewriting the instruction
- Immediate addressing is usually used for constants
- Direct addressing is usually used for variables in memory

A common weak answer says one is "better". A stronger answer says each is useful for different reasons.

## Key Point Checklist

_This article has covered the following key knowledge points:_

- An instruction contains an opcode and an operand
- The opcode states the operation to be performed
- The operand supplies either the data or the address of the data
- The addressing mode tells the CPU how to interpret the operand
- In immediate addressing, the operand is the actual value used by the instruction
- In direct addressing, the operand is the memory address where the data is stored
- `LDA #10` loads the value 10 into the accumulator
- `LDA 10` loads the contents of memory location 10 into the accumulator
- Immediate addressing is often faster because no extra memory fetch is needed for the operand
- Direct addressing is more flexible because the contents of a memory location can change
- A common exam mistake is confusing an address with the contents stored at that address
- The `#` symbol in typical assembly notation indicates immediate addressing

## Key Terms and Concepts

- addressing mode
- opcode
- operand
- accumulator (ACC)
- immediate addressing
- direct addressing
- assembly language
- mnemonic


Computer Organisation and Architecture - Addressing modes