assembly-process

Two-pass assembler

What is a two-pass assembler?

• A two-pass assembler translates assembly language into machine code in two stages

• It produces an object program that can be stored, loaded, and run later

• To execute this program, another utility called a loader is needed

• The assembler scans the source code twice:

  • In the first pass, it identifies all labels and records their memory addresses

  • In the second pass, it replaces those labels with the correct memory addresses in the machine code

• This ensures the final machine code is accurate and ready to be executed

Example

• The following program loads the value of A (5), adds the value of B (3), stores the result (8) in C, then halts:

 LOAD A ADD B STORE C HALT
A: DATA 5
B: DATA 3
C: DATA 0

• Pass 1:

  • The assembler reads each line and assigns memory addresses to labels (e.g. A, B, C), but does not translate the instructions yet

Symbol table created:

• Pass 2:

  • The assembler replaces labels with their corresponding memory addresses and outputs machine code

  • In this example we assume the following opcodes for simplicity:

• Now generate the object (machine) code:

Final object program:

01 04
02 05
03 06
00 00
00 05
00 03
00 00

Program tracing

What is a trace table?

• A trace table is a table used to manually track the values of variables as a program runs

• It helps to follow the flow of a program line by line, checking whether the logic works as expected

• Trace tables are used to:

  • Understand how a program works

  • Debug errors in the logic

  • Predict outputs before running the program

  • Check variable values at each step

Example

• An assembly program that loads the value from A (4) into the accumulator, adds the value from B (2), stores the result (6) into C, and halts

 LOAD A ADD B STORE C HALT
A: DATA 4
B: DATA 2
C: DATA 0

• To trace the program, assumptions must be made:

  • Accumulator (ACC): Used for calculations

  • Memory is addressed from 00 onwards

  • Simple instructions:

    • LOAD X → ACC = memory[X]

    • ADD X → ACC = ACC + memory[X]

    • STORE X → memory[X] = ACC

    • HALT → Stop

Trace table

Final outcome:

• ACC = 6

• C = 6

• The program has successfully added A and B, then stored the result in C