Assembly Language and the Little Man Computer

Machine code and assembly language

The CPU only executes machine code (binary instructions). Assembly language is a low-level language that uses short mnemonics (like ADD, STA) in place of binary — one assembly instruction usually maps to one machine instruction. It is processor-specific and translated to machine code by an assembler.

The Little Man Computer (LMC)

The LMC is a simplified model of a von Neumann CPU used to teach assembly. It has an accumulator, a program counter, and numbered mailboxes (memory). Typical instruction set:

Mnemonic	Meaning
INP	Input a value into the accumulator
OUT	Output the accumulator
STA / STO	Store the accumulator into a memory location
LDA	Load a value from memory into the accumulator
ADD / SUB	Add / subtract a memory value to/from the accumulator
BRA	Branch (jump) always
BRZ	Branch if the accumulator is zero
BRP	Branch if the accumulator is positive
HLT	Stop

Example — add two inputs and output the total:

INP        // first number → accumulator
STA 99     // store it in mailbox 99
INP        // second number → accumulator
ADD 99     // add the stored number
OUT        // output the total
HLT

Instruction format

A machine-code instruction has two parts:

• the opcode — what operation to do (e.g. ADD);
• the operand — the data or the address of the data to use.

Addressing modes

How the operand is interpreted:

• Immediate — the operand is the actual value to use.
• Direct — the operand is the memory address where the value is stored.
• Indirect — the operand is the address of a location that holds the address of the value.
• Indexed — the address is found by adding the operand to an index register (useful for stepping through arrays).

Why use assembly?

• Precise control of hardware and memory; can be highly optimised (speed/size).
• Used for embedded systems, device drivers and time-critical code.
• Drawbacks: harder to write, not portable (processor-specific).

Worked example

In ADD 99, what are the opcode and operand, and which addressing mode is typical here?

• Opcode = ADD; operand = 99 (a memory address, mailbox 99) → direct addressing. ✓

Common mistakes

• Confusing immediate (operand is the value) with direct (operand is the address).
• Forgetting LDA loads into the accumulator and STA stores from it.
• Thinking assembly is portable — it is processor-specific.

Exam tips

• Learn the common LMC mnemonics and be able to trace or write a short program.
• Know the opcode/operand split and the four addressing modes.
• Give a reason to use assembly (control/optimisation) and a drawback (portability).

Key facts to remember

• Assembly = low-level mnemonics, ~one-to-one with machine code, translated by an assembler, processor-specific.
• LMC uses an accumulator + mailboxes with instructions like INP, OUT, LDA, STA, ADD, SUB, BRA, BRZ, BRP, HLT.
• Instruction = opcode + operand; addressing modes: immediate, direct, indirect, indexed.