Describing an Assembler: Using the 6502 Example

An assembler is a software tool that translates human-readable assembly language code into machine code—the binary instructions a processor can execute. Assembly language uses mnemonics (e.g., MOV for move, ADD for add) and labels for memory addresses, making it easier to program than raw binary. The assembler resolves labels to addresses, handles directives (e.g., .ORG for origin), and generates object files or hex dumps. It's the lowest-level programming tool above hand-coding binary, essential for early hobbyists and embedded systems.

Assembly vs. Machine Code

Assembly provides abstraction: instead of writing binary opcodes, you use text. For example, on the MOS 6502 processor, the binary 0xA9 0x05 (load accumulator with 5) is written as "LDA #$05". The assembler converts this to bytes, calculates jumps, and outputs loadable code.

Simple 6502 Program Example

We'll use the 6502 (from Apple II, C64) for a program that loops a counter from 0 to 100 (decimal), then prints "Hello Readers" to an assumed output port at $8000 (where storing a byte "prints" it to a terminal). Assume hardware maps $8000 as a serial output register. The program uses a loop with branching, a subroutine for printing, and labels.

Assembly Code

Here's the program in 6502 assembly (using standard syntax):

.ORG $8000  ; Start address

MAIN:
  LDX #0      ; Initialize counter X = 0
LOOP:
  INX         ; Increment X
  CPX #101    ; Compare X to 101 (loop 0-100)
  BNE LOOP    ; Branch if not equal back to LOOP

  JSR PRINT   ; Call subroutine to print message
  BRK         ; End program

PRINT:
  LDY #0      ; Index for message
PRINT_LOOP:
  LDA MESSAGE,Y ; Load byte from message
  BEQ DONE      ; If 0 (null terminator), done
  STA $8000     ; Store to output port (prints char)
  INY           ; Next byte
  JMP PRINT_LOOP ; Jump back
DONE:
  RTS           ; Return from subroutine

MESSAGE:
  .BYTE "Hello Readers",0  ; Null-terminated string

Explanation

• Loop for Counting: LDX sets counter to 0; INX increments; CPX checks against 101; BNE branches back if not 100 loops done. This is a simple delay/count loop.
• Printing: JSR calls PRINT subroutine; LDA loads chars from MESSAGE; STA to $8000 "prints"; BEQ ends on null; RTS returns to MAIN.

How Assemblers Handle Calls and Jumps to Labels

Labels (e.g., LOOP, PRINT) are symbolic addresses. The assembler resolves them during a two-pass process:

• Pass 1: Scans code, assigns addresses to labels (e.g., LOOP at $8003).
• Pass 2: Replaces labels with actual addresses in instructions (e.g., BNE LOOP becomes BNE $8003-relative offset).
• Jumps (JMP): Absolute/relative branch to label (e.g., JMP PRINT goes to subroutine start).
• Calls (JSR/RTS): JSR pushes return address to stack and jumps to label; RTS pops and returns. Assembler calculates the address for JSR.

In the "old days," hobbyists hand-assembled (calculated opcodes manually) or used simple assemblers on tape/disk. Modern cross-assemblers (e.g., ca65) generate binaries for emulators.

Back to Misc