The two-pass assembler: finding everything before building anything

Read this program from the top, the way an assembler would:

100  LDM #3
101  STO 200
102  loop  LDD 200
103        SUB 201
104        STO 200
105        CMP #0
106        JPN loop
107        END

Line 106 says JPN loop. The assembler has to put the address of loop into the machine code.

But loop is at address 102, and when the assembler reaches line 106 it has already passed it. In a one-pass assembler it would have needed that address before it knew it.

A label used before it is defined is called a forward reference. It is the entire reason assembling takes two passes.

Pass 1 reads the source code one line at a time and builds a map of the program. It does four jobs:

1. Reads each line in turn.
2. Removes white space and comments — they are for humans, and the processor has no use for them.
3. Keeps a count of the address each instruction will occupy, so it knows where it is in memory (start at 100 and add 1 per instruction here).
4. Adds every label to the symbol table — a list of label names and the addresses they stand for.

For the program above, pass 1 produces this symbol table:

Nothing is translated yet. Pass 1 is pure bookkeeping — but now loop has a known address even when the code jumps backwards or forwards to it.

Pass 2 reads the source code one line at a time again, and this time it produces output:

• every label is replaced by its address, looked up in the symbol table (JPN loop → JPN 102);
• each instruction is translated into machine code — one machine code instruction per assembly instruction;
• the object code is written out, ready to run.

It is also the pass that can finally complain about a label that is never defined. Pass 1 cannot: it only knows a label is missing once it has read the whole program.