From Nand to Tetris

Building a Modern Computer from First Principles

Lecture 6

Assembler

These slides support chapter 6 of the book

The Elements of Computing Systems
By Noam Nisan and Shimon Schocken
MIT Press, 2021

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 1
 Nand to Tetris Roadmap: Hardware

abstraction In project 4 we wrote some

machine p4 low-level assembly programs
language

We will now learn how to

assembler p6 write an assembler

abstraction p5 hardware platform

building a p2 p3
computer abstraction
computer
building
abstraction p1
ALU, RAM
chips building
elementary d
logic gates gates Nan

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 2
 Program translation
Assembly program Binary code Computer
// Program: Sum1ToN (R0 represents N) 0101111100111100
// Computes R1 = 1 + 2 + 3 + ... + R0 1010101010101010
// Usage: put a value >= 1 in R0 1100000010101010
// i = 1 1011000010000001
@i
0101111100111100
M=1
// sum = 0 1010101010101010
@sum assembler 1100000010101010 load and
M=0 0101111100111100 execute
(LOOP) 1010101010101010
// if (i > R0) goto STOP 1100000010101010
@i
1011000010000001
D=M
@R0 0101111100111100
D=D-M 1010101010101010
@STOP 1100000010101010
D;JGT
// sum = sum + i
0101111100111100 The assembler is…
1010101010101010
@sum
D=M
1100000010101010 • The “linchpin” that connects the hardware
1011000010000001
@i
D=D+M 0101111100111100
platform and the software hierarchy
@sum 1010101010101010
M=D 1100000010101010 • The lowest rung in the set of translators
// i = i + 1
@i
... developed in Part II of the course (compiler,
M=M+1 VM translator, assembler)
// goto LOOP
@LOOP
0;JMP
• A program that introduces key software
... engineering techniques (parsing, code
generation, symbol tables, …)

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 3
 Lecture plan

• Overview • Assembler architecture

• Translating Hack code: • Assembler API
q A-instructions • Project 6
q C-instructions
• Some history
• Translating programs
• Handling symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 4
 Translating A-instructions
Symbolic syntax: Binary syntax:
@ xxx 0vvvvvvvvvvvvvvvv

Where:
Where xxx is a non-negative
decimal value, or a symbol 0 is the A-instruction op-code, and
bound to such a value v v v … v is a binary value

Example:
@17 translate 0000000000010001

Implementation
If xxx is a decimal value: Translate the value into its 16-bit representation;
If xxx is a symbol: Later.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 5
 Lecture plan

• Overview • Assembler architecture

• Translating Hack code: • Assembler API
q A-instructions • Project 6
q C-instructions
• Some history
• Translating programs
• Handling symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 6
 Translating C-instructions
Symbolic syntax: dest = comp ; jump
Binary syntax: 1 1 1 a c c c c c c d d d j j j

comp c c c c c c dest d d d effect: the value is stored in:

0 1 0 1 0 1 0 null 0 0 0 the value is not stored
1 1 1 1 1 1 1 M 0 0 1 RAM[A]
-1 1 1 1 0 1 0 D 0 1 0 D register
D 0 0 1 1 0 0 DM 0 1 1 D register and RAM[A]
A M 1 1 0 0 0 0 A 1 0 0 A register
!D 0 0 1 1 0 1 AM 1 0 1 A register and RAM[A]
!A !M 1 1 0 0 0 1 AD 1 1 0 A register and D register
-D 0 0 1 1 1 1 ADM 1 1 1 A register, D register, and RAM[A]
-A -M 1 1 0 0 1 1
D+1 0 1 1 1 1 1 jump j j j effect:
A+1 M+1 1 1 0 1 1 1
null 0 0 0 no jump
D-1 0 0 1 1 1 0
JGT 0 0 1 if comp > 0 jump
A-1 M-1 1 1 0 0 1 0 JEQ 0 1 0 if comp = 0 jump
D+A D+M 0 0 0 0 1 0 JGE 0 1 1 if comp ≥ 0 jump
D-A D-M 0 1 0 0 1 1 JLT 1 0 0 if comp < 0 jump
A-D M-D 0 0 0 1 1 1 JNE 1 0 1 if comp ≠ 0 jump
D&A D&M 0 0 0 0 0 0 JLE 1 1 0 if comp ≤ 0 jump
D|A D|M 0 1 0 1 0 1 JMP 1 1 1 Unconditional jump
a == 0 a == 1

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 7
 Translating C-instructions
Symbolic syntax: dest = comp ; jump
Binary syntax: 1 1 1 a c c c c c c d d d j j j

comp c c c c c c dest d d d effect: the value is stored in:

0 1 0 1 0 1 0 null 0 0 0 the value is not stored
1 1 1 1 1 1 1 M 0 0 1 RAM[A]
-1 1 1 1 0 1 0 D 0 1 0 D register
D 0 0 1 1 0 0 DM 0 1 1 D register and RAM[A]
A M 1 1 0 0 0 0 A 1 0 0 A register
!D 0 0 1 1 0 1 AM 1 0 1 A register and RAM[A]
!A !M 1 1 0 0 0 1 AD 1 1 0 A register and D register
-D 0 0 1 1 1 1 ADM 1 1 1 A register, D register, and RAM[A]
-A -M 1 1 0 0 1 1
D+1 0 1 1 1 1 1 jump j j j effect:
A+1 M+1 1 1 0 1 1 1
null 0 0 0 no jump
D-1 0 0 1 1 1 0
JGT 0 0 1 if comp > 0 jump
A-1 M-1 1 1 0 0 1 0 JEQ 0 1 0 if comp = 0 jump
D+A D+M 0 0 0 0 1 0 JGE 0 1 1 if comp ≥ 0 jump
D-A D-M 0 1 0 0 1 1 JLT 1 0 0 if comp < 0 jump
A-D M-D 0 0 0 1 1 1 JNE 1 0 1 if comp ≠ 0 jump
D&A D&M 0 0 0 0 0 0 JLE 1 1 0 if comp ≤ 0 jump
D|A D|M 0 1 0 1 0 1 JMP 1 1 1 Unconditional jump
a == 0 a == 1
Binary:
Example: D = D+1 ; JLE

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 8
 Translating C-instructions
Symbolic syntax: dest = comp ; jump
Binary syntax: 1 1 1 a c c c c c c d d d j j j

comp c c c c c c dest d d d effect: the value is stored in:

0 1 0 1 0 1 0 null 0 0 0 the value is not stored
1 1 1 1 1 1 1 M 0 0 1 RAM[A]
-1 1 1 1 0 1 0 D 0 1 0 D register
D 0 0 1 1 0 0 DM 0 1 1 D register and RAM[A]
A M 1 1 0 0 0 0 A 1 0 0 A register
!D 0 0 1 1 0 1 AM 1 0 1 A register and RAM[A]
!A !M 1 1 0 0 0 1 AD 1 1 0 A register and D register
-D 0 0 1 1 1 1 ADM 1 1 1 A register, D register, and RAM[A]
-A -M 1 1 0 0 1 1
D+1 0 1 1 1 1 1 jump j j j effect:
A+1 M+1 1 1 0 1 1 1
null 0 0 0 no jump
D-1 0 0 1 1 1 0
JGT 0 0 1 if comp > 0 jump
A-1 M-1 1 1 0 0 1 0 JEQ 0 1 0 if comp = 0 jump
D+A D+M 0 0 0 0 1 0 JGE 0 1 1 if comp ≥ 0 jump
D-A D-M 0 1 0 0 1 1 JLT 1 0 0 if comp < 0 jump
A-D M-D 0 0 0 1 1 1 JNE 1 0 1 if comp ≠ 0 jump
D&A D&M 0 0 0 0 0 0 JLE 1 1 0 if comp ≤ 0 jump
D|A D|M 0 1 0 1 0 1 JMP 1 1 1 Unconditional jump
a == 0 a == 1
Binary:
Example: D = D+1 ; JLE 111

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 9
 Translating C-instructions
Symbolic syntax: dest = comp ; jump
Binary syntax: 1 1 1 a c c c c c c d d d j j j

comp c c c c c c dest d d d effect: the value is stored in:

0 1 0 1 0 1 0 null 0 0 0 the value is not stored
1 1 1 1 1 1 1 M 0 0 1 RAM[A]
-1 1 1 1 0 1 0 D 0 1 0 D register
D 0 0 1 1 0 0 DM 0 1 1 D register and RAM[A]
A M 1 1 0 0 0 0 A 1 0 0 A register
!D 0 0 1 1 0 1 AM 1 0 1 A register and RAM[A]
!A !M 1 1 0 0 0 1 AD 1 1 0 A register and D register
-D 0 0 1 1 1 1 ADM 1 1 1 A register, D register, and RAM[A]
-A -M 1 1 0 0 1 1
D+1 0 1 1 1 1 1 jump j j j effect:
A+1 M+1 1 1 0 1 1 1
null 0 0 0 no jump
D-1 0 0 1 1 1 0
JGT 0 0 1 if comp > 0 jump
A-1 M-1 1 1 0 0 1 0 JEQ 0 1 0 if comp = 0 jump
D+A D+M 0 0 0 0 1 0 JGE 0 1 1 if comp ≥ 0 jump
D-A D-M 0 1 0 0 1 1 JLT 1 0 0 if comp < 0 jump
A-D M-D 0 0 0 1 1 1 JNE 1 0 1 if comp ≠ 0 jump
D&A D&M 0 0 0 0 0 0 JLE 1 1 0 if comp ≤ 0 jump
D|A D|M 0 1 0 1 0 1 JMP 1 1 1 Unconditional jump
a == 0 a == 1
Binary:
Example: D = D+1 ; JLE 1110011111010110

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 10
 Translating C-instructions
Symbolic syntax: dest = comp ; jump
Binary syntax: 1 1 1 a c c c c c c d d d j j j

comp c c c c c c dest d d d effect: the value is stored in:

0 1 0 1 0 1 0 null 0 0 0 the value is not stored
1 1 1 1 1 1 1 M 0 0 1 RAM[A]
-1 1 1 1 0 1 0 D 0 1 0 D register
D 0 0 1 1 0 0 DM 0 1 1 D register and RAM[A]
A M 1 1 0 0 0 0 A 1 0 0 A register
!D 0 0 1 1 0 1 AM 1 0 1 A register and RAM[A]
!A !M 1 1 0 0 0 1 AD 1 1 0 A register and D register
-D 0 0 1 1 1 1 ADM 1 1 1 A register, D register, and RAM[A]
-A -M 1 1 0 0 1 1
D+1 0 1 1 1 1 1 jump j j j effect:
A+1 M+1 1 1 0 1 1 1
null 0 0 0 no jump
D-1 0 0 1 1 1 0
JGT 0 0 1 if comp > 0 jump
A-1 M-1 1 1 0 0 1 0 JEQ 0 1 0 if comp = 0 jump
D+A D+M 0 0 0 0 1 0 JGE 0 1 1 if comp ≥ 0 jump
D-A D-M 0 1 0 0 1 1 JLT 1 0 0 if comp < 0 jump
A-D M-D 0 0 0 1 1 1 JNE 1 0 1 if comp ≠ 0 jump
D&A D&M 0 0 0 0 0 0 JLE 1 1 0 if comp ≤ 0 jump
D|A D|M 0 1 0 1 0 1 JMP 1 1 1 Unconditional jump
a == 0 a == 1
Binary:
Example: A=–1

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 11
 Translating C-instructions
Symbolic syntax: dest = comp ; jump
Binary syntax: 1 1 1 a c c c c c c d d d j j j

comp c c c c c c dest d d d effect: the value is stored in:

0 1 0 1 0 1 0 null 0 0 0 the value is not stored
1 1 1 1 1 1 1 M 0 0 1 RAM[A]
-1 1 1 1 0 1 0 D 0 1 0 D register
D 0 0 1 1 0 0 DM 0 1 1 D register and RAM[A]
A M 1 1 0 0 0 0 A 1 0 0 A register
!D 0 0 1 1 0 1 AM 1 0 1 A register and RAM[A]
!A !M 1 1 0 0 0 1 AD 1 1 0 A register and D register
-D 0 0 1 1 1 1 ADM 1 1 1 A register, D register, and RAM[A]
-A -M 1 1 0 0 1 1
D+1 0 1 1 1 1 1 jump j j j effect:
A+1 M+1 1 1 0 1 1 1
null 0 0 0 no jump
D-1 0 0 1 1 1 0
JGT 0 0 1 if comp > 0 jump
A-1 M-1 1 1 0 0 1 0 JEQ 0 1 0 if comp = 0 jump
D+A D+M 0 0 0 0 1 0 JGE 0 1 1 if comp ≥ 0 jump
D-A D-M 0 1 0 0 1 1 JLT 1 0 0 if comp < 0 jump
A-D M-D 0 0 0 1 1 1 JNE 1 0 1 if comp ≠ 0 jump
D&A D&M 0 0 0 0 0 0 JLE 1 1 0 if comp ≤ 0 jump
D|A D|M 0 1 0 1 0 1 JMP 1 1 1 Unconditional jump
a == 0 a == 1
Binary:
Example: A=–1 111

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 12
 Translating C-instructions
Symbolic syntax: dest = comp ; jump
Binary syntax: 1 1 1 a c c c c c c d d d j j j

comp c c c c c c dest d d d effect: the value is stored in:

0 1 0 1 0 1 0 null 0 0 0 the value is not stored
1 1 1 1 1 1 1 M 0 0 1 RAM[A]
-1 1 1 1 0 1 0 D 0 1 0 D register
D 0 0 1 1 0 0 DM 0 1 1 D register and RAM[A]
A M 1 1 0 0 0 0 A 1 0 0 A register
!D 0 0 1 1 0 1 AM 1 0 1 A register and RAM[A]
!A !M 1 1 0 0 0 1 AD 1 1 0 A register and D register
-D 0 0 1 1 1 1 ADM 1 1 1 A register, D register, and RAM[A]
-A -M 1 1 0 0 1 1
D+1 0 1 1 1 1 1 jump j j j effect:
A+1 M+1 1 1 0 1 1 1
null 0 0 0 no jump
D-1 0 0 1 1 1 0
JGT 0 0 1 if comp > 0 jump
A-1 M-1 1 1 0 0 1 0 JEQ 0 1 0 if comp = 0 jump
D+A D+M 0 0 0 0 1 0 JGE 0 1 1 if comp ≥ 0 jump
D-A D-M 0 1 0 0 1 1 JLT 1 0 0 if comp < 0 jump
A-D M-D 0 0 0 1 1 1 JNE 1 0 1 if comp ≠ 0 jump
D&A D&M 0 0 0 0 0 0 JLE 1 1 0 if comp ≤ 0 jump
D|A D|M 0 1 0 1 0 1 JMP 1 1 1 Unconditional jump
a == 0 a == 1
Binary:
Example: A=–1 1110111010100000

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 13
 Translating C-instructions
Symbolic syntax: dest = comp ; jump
Binary syntax: 1 1 1 a c c c c c c d d d j j j

comp c c c c c c dest d d d effect: the value is stored in:

0 1 0 1 0 1 0 null 0 0 0 the value is not stored
1 1 1 1 1 1 1 M 0 0 1 RAM[A]
-1 1 1 1 0 1 0 D 0 1 0 D register
D 0 0 1 1 0 0 DM 0 1 1 D register and RAM[A]
A M 1 1 0 0 0 0 A 1 0 0 A register
!D 0 0 1 1 0 1 AM 1 0 1 A register and RAM[A]
!A !M 1 1 0 0 0 1 AD 1 1 0 A register and D register
-D 0 0 1 1 1 1 ADM 1 1 1 A register, D register, and RAM[A]
-A -M 1 1 0 0 1 1
D+1 0 1 1 1 1 1 jump j j j effect:
A+1 M+1 1 1 0 1 1 1
null 0 0 0 no jump
D-1 0 0 1 1 1 0
JGT 0 0 1 if comp > 0 jump
A-1 M-1 1 1 0 0 1 0 JEQ 0 1 0 if comp = 0 jump
D+A D+M 0 0 0 0 1 0 JGE 0 1 1 if comp ≥ 0 jump
D-A D-M 0 1 0 0 1 1 JLT 1 0 0 if comp < 0 jump
A-D M-D 0 0 0 1 1 1 JNE 1 0 1 if comp ≠ 0 jump
D&A D&M 0 0 0 0 0 0 JLE 1 1 0 if comp ≤ 0 jump
D|A D|M 0 1 0 1 0 1 JMP 1 1 1 Unconditional jump
a == 0 a == 1

Implementation: Get the binary code of each field of the symbolic instruction
(dest, comp, jump), and assemble the codes into a 16-bit instruction.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 14
 Chapter 6: Assembler

• Overview • Assembler architecture

• Translating instructions • Assembler API
• Translating programs • Project 6
• Handling symbols • Some history

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 15
 Program translation
Symbolic code Binary code
// Computes R1=1 + ... + R0 0000000000010000
// i = 1
@i
Translate 1110111111001000
0000000000010001
M=1 1110101010001000
// sum = 0 0000000000010000
@sum 1111110000010000
M=0 Need to Handle 0000000000000000
(LOOP) 1111010011010000
// if i>R0 goto STOP 0000000000010010
@i • White space 1110001100000001
D=M 0000000000010000
@R0 1111110000010000
D=D-M • Instructions 0000000000010001
@STOP 1111000010001000
D;JGT 0000000000010000
// sum += i
• Symbols 1111110111001000
@i 0000000000000100
D=M 1110101010000111
@sum 0000000000010001
M=D+M 1111110000010000
// i++ ...
@i
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 16
 Program translation
Symbolic code Binary code
// Computes R1=1 + ... + R0 0000000000010000
// i = 1
@i
Translate 1110111111001000
0000000000010001
M=1 1110101010001000
// sum = 0 0000000000010000
@sum 1111110000010000
M=0 Need to Handle 0000000000000000
(LOOP) 1111010011010000
// if i>R0 goto STOP 0000000000010010
@i • White space 1110001100000001
D=M 0000000000010000
@R0 1111110000010000
D=D-M • Instructions 0000000000010001
@STOP 1111000010001000
D;JGT 0000000000010000
// sum += i
• Symbols 1111110111001000
@i 0000000000000100
D=M 1110101010000111
@sum 0000000000010001
M=D+M We’ll start with programs 1111110000010000
// i++ that have no symbols, ...
@i
M=M+1 and handle symbols later
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 17
 Program translation
Symbolic code Binary code
// Computes R1=1 + ... + R0
// i = 1
@16
Translate
M=1
// sum = 0
@17
M=0 Need to Handle
// if i>R0 goto STOP
@16 • White space
D=M
@0
D=D-M • Instructions
@18
D;JGT
// sum += i
• Symbols (later)
@16
D=M
@17
M=D+M
// i++
@16
M=M+1
@4
0;JMP
@17
D=M
... no symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 18
 Program translation
Symbolic code Binary code
// Computes R1=1 + ... + R0
// i = 1
@16
Translate
M=1
// sum = 0
@17
M=0 Need to Handle
// if i>R0 goto STOP
@16 • White space Ignore it
D=M
@0
D=D-M • Instructions
@18
D;JGT
// sum += i
• Symbols (later)
@16
D=M
@17 White space:
M=D+M
// i++ Empty lines,
@16 Comments,
M=M+1
@4 Indentation
0;JMP
@17
D=M
... no symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 19
 Program translation
Symbolic code Binary code
@16
M=1
@17
Translate
M=0
@16
D=M
@0 Need to Handle
D=D-M
@18
D;JGT • White space
@16
D=M
@17 • Instructions
M=D+M
@16
M=M+1
• Symbols (later)
@4
0;JMP
@17
D=M
no white space
...no symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 20
 Program translation
Symbolic code Binary code
@16
M=1
@17
Translate
M=0
@16
D=M
@0 Need to Handle
D=D-M
@18
D;JGT • White space
@16 Translate,
D=M
@17 • Instructions one by one
M=D+M
@16
• Symbols (later) As shown
M=M+1
@4
earlier in
0;JMP the lecture
@17
D=M
...no symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 21
 Program translation
Symbolic code Binary code
@16 0000000000010000
M=1
@17
Translate 1110111111001000
0000000000010001
M=0 1110101010001000
@16 0000000000010000
D=M 1111110000010000
@0 Need to Handle 0000000000000000
D=D-M 1111010011010000
@18 0000000000010010
D;JGT • White space 1110001100000001
@16 Translate, 0000000000010000
D=M 1111110000010000
@17 • Instructions one by one 0000000000010001
M=D+M 1111000010001000
@16
• Symbols (later) As shown 0000000000010000
M=M+1 1111110111001000
@4
earlier in 0000000000000100
0;JMP the lecture 1110101010000111
@17 0000000000010001
D=M 1111110000010000
...no symbols ...

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 22
 Program translation
Symbolic code Binary code
@16 0000000000010000
M=1
@17
Translate 1110111111001000
0000000000010001
M=0 1110101010001000
@16 0000000000010000
D=M 1111110000010000
@0 Need to Handle 0000000000000000
D=D-M 1111010011010000
@18 0000000000010010
D;JGT • White space 1110001100000001
@16 0000000000010000
D=M 1111110000010000
@17 • Instructions 0000000000010001
M=D+M 1111000010001000
@16 0000000000010000
M=M+1
• Symbols (later) 1111110111001000
@4 0000000000000100
0;JMP 1110101010000111
@17 0000000000010001
D=M 1111110000010000
...no symbols ...

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 23
 Program translation
Symbolic code Binary code
// Computes R1=1 + ... + R0
// i = 1
@i
Translate
M=1
// sum = 0
@sum
M=0 Need to Handle
(LOOP)
// if i>R0 goto STOP
@i • White space
D=M
@R0
D=D-M • Instructions
@STOP
D;JGT
// sum += i
• Symbols (later)
@i
D=M
@sum
M=D+M
// no
i++
symbols Original program,
@i with symbols
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 24
 Handling symbols
Symbolic code
// Computes R1=1 + ... + R0
// i = 1 Symbols
@i
M=1
// sum = 0 • Predefined symbols
@sum
M=0
(LOOP)
• Label symbols
// if i>R0 goto STOP
@i • Variable symbols
D=M
@R0
D=D-M
@STOP
D;JGT
// sum += i
@i
D=M
@sum
M=D+M
// i++ Original program,
@i with symbols
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 25
 Handling symbols
Symbolic code
// Computes R1=1 + ... + R0 The Hack language features
// i = 1 Symbols
@i 23 predefined symbols:
M=1
// sum = 0 • Predefined symbols symbol value
@sum R0 0
M=0 R1 1
(LOOP)
• Label symbols R2 2
// if i>R0 goto STOP ... ...
@i • Variable symbols R15 15
D=M SCREEN 16384
@R0 KBD 24576
D=D-M SP 0
@STOP This particular code uses LCL 1
D;JGT ARG 2
// sum += i one predefined symbol: R0 THIS 3
@i THAT 4
D=M
@sum
M=D+M
// i++
@i
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 26
 Handling symbols
Symbolic code
// Computes R1=1 + ... + R0 The Hack language features
// i = 1 Symbols
@i 23 predefined symbols:
M=1
// sum = 0 • Predefined symbols symbol value
@sum R0 0
M=0 R1 1
(LOOP)
• Label symbols R2 2
// if i>R0 goto STOP ... ...
@i • Variable symbols R15 15
D=M SCREEN 16384
@R0 KBD 24576
D=D-M SP 0
@STOP LCL 1
D;JGT ARG 2
// sum += i
@i Translating @ preDefinedSymbol THIS 3
THAT 4
D=M
@sum
Replace preDefinedSymbol with its value,
M=D+M and complete the translation.
// i++
@i Examples: @R0 0000000000000000
M=M+1
@LOOP @R12 0000000000001100
0;JMP
(STOP) @SCREEN 0100000000000000
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 27
 Handling symbols
Symbolic code
// Computes R1=1 + ... + R0
// i = 1 Symbols
@i
M=1
// sum = 0 • Predefined symbols
@sum
M=0
(LOOP)
• Label symbols
// if i>R0 goto STOP
@i • Variable symbols
D=M
@R0
D=D-M
@STOP
D;JGT
// sum += i
@i
D=M
@sum This particular code uses two
M=D+M
label symbols: LOOP, STOP
// i++
@i
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 28
 Handling symbols
Symbolic code
// Computes R1=1 + ... + R0 Label symbols
// i = 1
@i • Used to label destinations of goto instructions
M=1 • Declared by the pseudo-instruction (label)
// sum = 0
@sum • The (label) directive defines the symbol label to refer
M=0
(LOOP)
to the memory location holding the next instruction in
// if i>R0 goto STOP the program,
@i
D=M
• Which corresponds to the instruction’s line number
@R0
D=D-M
@STOP
D;JGT
// sum += i
@i
D=M
@sum This particular code uses two
M=D+M
label symbols: LOOP, STOP
// i++
@i
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 29
 Handling symbols
Symbolic code
// Computes R1=1 + ... + R0 Label symbols
// i = 1
0 @i • Used to label destinations of goto instructions
1 M=1 • Declared by the pseudo-instruction (label)
// sum = 0
2 @sum • The (label) directive defines the symbol label to refer
3 M=0
(LOOP)
to the memory location holding the next instruction in
// if i>R0 goto STOP the program,
4 @i
5 D=M
• Which corresponds to the instruction’s line number
6 @R0
7 D=D-M Example: symbol value
8 @STOP LOOP 4
9 D;JGT
STOP 18
// sum += i
10 @i
11 D=M
12 @sum
Translating @ labelSymbol :
13 M=D+M
// i++ Replace labelSymbol with its value
14 @i
15 M=M+1
16 @LOOP
17 0;JMP Example: @LOOP 0000000000000100
(STOP)
18 @sum
19 D=M
... ...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 30
 Handling symbols
Symbolic code
// Computes R1=1 + ... + R0
// i = 1
Symbols
@i
M=1 • Predefined symbols
// sum = 0
@sum
M=0 • Label symbols
(LOOP)
// if i>R0 goto STOP
@i • Variable symbols
D=M
@R0
D=D-M
@STOP
D;JGT
// sum += i
@i
D=M
@sum This particular code uses two
M=D+M
variable symbols: i, sum
// i++
@i
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 31
 Handling symbols
Symbolic code Variable symbols
// Computes R1=1 + ... + R0
// i = 1 • Any symbol xxx which is neither predefined,
@i nor defined elsewhere using an (xxx) label
M=1
// sum = 0
declaration, is treated as a variable
@sum • Hack convention: Each variable is bound to a
M=0
(LOOP) running memory address, starting at 16
// if i>R0 goto STOP
@i
D=M
@R0
D=D-M
@STOP
D;JGT
// sum += i
@i
D=M
@sum This particular code uses two
M=D+M
variable symbols: i, sum
// i++
@i
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 32
 Handling symbols
Symbolic code Variable symbols
// Computes R1=1 + ... + R0
// i = 1 • Any symbol xxx which is neither predefined,
@i nor defined elsewhere using an (xxx) label
M=1
// sum = 0
declaration, is treated as a variable
@sum • Hack convention: Each variable is bound to a
M=0
(LOOP) running memory address, starting at 16
// if i>R0 goto STOP
@i symbol value
D=M
Example:
@R0 i 16
D=D-M sum 17
@STOP
D;JGT
// sum += i Translating @ variableSymbol :
@i 1. If variableSymbol is seen for the first time,
D=M
@sum bind to it to a value, from 16 onward
M=D+M 2. Else, it has a value
// i++
@i 2. Replace variableSymbol with its value.
M=M+1
@LOOP
0;JMP Example: @sum 0000000000010001
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 33
 Handling symbols
Symbolic code Symbol table
// Computes R1=1 + ... + R0
symbol value A data structure that the
// i = 1
@i R0 0 assembler creates and uses
M=1 R1 1 during the program translation
// sum = 0
R2 2
@sum
M=0 ... ... Contains every symbol,
(LOOP) R15 15 and its binding.
// if i>R0 goto STOP SCREEN 16384
@i
KBD 24576
D=M
@R0 SP 0
D=D-M LCL 1
@STOP ARG 2
D;JGT THIS 3
// sum += i
@i THAT 4
D=M LOOP 4
@sum STOP 18
M=D+M i 16
// i++
@i sum 17
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 34
 Handling symbols
Symbolic code Symbol table
// Computes R1=1 + ... + R0 symbol value
// i = 1 A data structure that the
@i assembler creates and uses
M=1 during the program translation
// sum = 0
@sum
M=0
(LOOP)
// if i>R0 goto STOP
@i
D=M
@R0
D=D-M
@STOP
D;JGT
// sum += i
@i
D=M
@sum
M=D+M
// i++
@i
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 35
 Handling symbols
Symbolic code Symbol table
// Computes R1=1 + ... + R0 symbol value
// i = 1 A data structure that the
@i R0 0 assembler creates and uses
M=1 R1 1 during the program translation
// sum = 0
R2 2
@sum
M=0 ... ...
(LOOP) R15 15
// if i>R0 goto STOP SCREEN 16384 Initialization:
@i KBD 24576 Creates the symbol table and adds the
D=M
SP 0
predefined symbols to the table
@R0
D=D-M LCL 1
@STOP ARG 2
D;JGT THIS 3
// sum += i
@i THAT 4
D=M
@sum
M=D+M
// i++
@i
M=M+1
@LOOP
0;JMP
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 36
 Handling symbols
Symbolic code Symbol table
// Computes R1=1 + ... + R0 symbol value
// i = 1 A data structure that the
0 @i R0 0 assembler creates and uses
1 M=1 R1 1 during the program translation
// sum = 0
R2 2
2 @sum
3 M=0 ... ...
(LOOP) R15 15
// if i>R0 goto STOP SCREEN 16384 Initialization:
4 @i KBD 24576 Creates the symbol table and adds the
5 D=M
SP 0
predefined symbols to the table
6 @R0
7 D=D-M LCL 1
8 @STOP ARG 2
9 D;JGT THIS 3
// sum += i
@i THAT 4
10
11 D=M LOOP 4 First pass: Counts lines and adds
12 @sum STOP 18 the label symbols to the table
13 M=D+M
// i++
14 @i
15 M=M+1
16 @LOOP
17 0;JMP
(STOP)
18 @sum
19 D=M
... ...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 37
 Handling symbols
Symbolic code Symbol table
// Computes R1=1 + ... + R0 symbol value
// i = 1 A data structure that the
@i R0 0 assembler creates and uses
M=1 R1 1 during the program translation
// sum = 0
R2 2
@sum
M=0 ... ...
(LOOP) R15 15
// if i>R0 goto STOP SCREEN 16384 Initialization:
@i KBD 24576 Creates the symbol table and adds the
D=M
SP 0
predefined symbols to the table
@R0
D=D-M LCL 1
@STOP ARG 2
D;JGT THIS 3
// sum += i
@i THAT 4
D=M LOOP 4 First pass: Counts lines and adds
@sum STOP 18 the label symbols to the table
M=D+M i 16
// i++ Second pass:
sum 17 • Generates binary code; in the process:
@i
M=M+1 • Adds the variable symbols to the table
@LOOP
0;JMP (details, soon)
(STOP)
@sum
D=M
...
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 38
 Lecture plan

• Overview • Assembler architecture

• Translating instructions • Assembler API
• Translating programs • Project 6
• Handling symbols • Some history

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 39
 Assembler: Usage
Input (Prog.asm): a text file containing a
sequence of lines, each being a string
representing a comment, an A-instruction,
a C-instruction, or a label declaration
Output (Prog.hack): a text file containing
a sequence of lines, each being a string
of sixteen 0 and 1 characters

Usage: (if the assembler is implemented in Java)

$ java HackAssembler Prog.asm

Action: Creates a Prog.hack file, containing the translated Hack program.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 40
 Assembler: Algorithm
Initialize
Opens the input file (Prog.asm),
and gets ready to process it
Constructs a symbol table,
and adds to it all the predefined symbols

First pass
Reads the program lines, one by one, Assembler implementation options
focusing only on (label) declarations.
Adds the found labels to the symbol table • Manual

Second pass (main loop) • Program-based

(starts again from the beginning of the file)
While there are more lines to process:
Gets the next instruction, and parses it
If the instruction is @ symbol
If symbol is not in the symbol table, adds <symbol , value> to the table, and
translates value to its binary value
If the instruction is dest = comp ; jump
Translates each of the three fields into its binary value
Assembles the binary values described above into a string of sixteen 0’s and 1’s
Writes the string to the output file.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 41
 Assembler: Architecture

drives the
HackAssembler translation process

Parser Code SymbolTable

reads and parses generates handles

an instruction binary codes symbols

Proposed architecture
• Four software modules
• Can be realized in any programming language

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 42
 HackAssembler
Initialize:
Opens the input file (Prog.asm) and gets ready to process it
Constructs a symbol table, and adds to it all the predefined symbols

First pass:
Reads the program lines, one by one
focusing only on (label) declarations.
Adds the found labels to the symbol table The HackAssembler
implements this
Second pass (main loop): assembly algorithm,
(starts again from the beginning of the file) using the services of:
While there are more lines to process: • Parser
Gets the next instruction, and parses it • Code
If the instruction is @ symbol • SymbolTable
If symbol is not in the symbol table, adds it to the table
Translates the symbol into its binary value
If the instruction is dest = comp ; jump
Translates each of the three fields into its binary value
Assembles the binary values into a string of sixteen 0’s and 1’s
Writes the string to the output file.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 43
 Assembler API

drives the
HackAssembler
process

Parser Code SymbolTable

reads and parses generates handles

an instruction binary codes symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 44
 Parser API
Routines
• Constructor / initializer: Creates a Parser and opens the source text file

• Getting the current instruction:

hasMoreLines(): Checks if there is more work to do (boolean)
advance(): Gets the next instruction and makes it the current instruction (string)

• Parsing the current instruction:

instructionType(): Returns the current instruction type, as a constant:
A_INSTRUCTION for @ xxx, where xxx is either a decimal number or a symbol
C_INSTRUCTION for dest = comp ; jump
L_INSTRUCTION for (label)

current instruction
Examples: @17 instructionType() returns A_INSTRUCTION

@sum instructionType() returns A_INSTRUCTION

D=0 instructionType() returns C_INSTRUCTION

(END) instructionType() returns L_INSTRUCTION

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 45
 Parser API
Routines
• Constructor / initializer: Creates a Parser and opens the source text file

• Getting the current instruction:

hasMoreLines(): Checks if there is more work to do (boolean)
advance(): Gets the next instruction and makes it the current instruction (string)

• Parsing the current instruction:

instructionType(): Returns the instruction type
symbol(): Returns the instruction’s symbol (string)
Used only if the current instruction is
@ symbol or ( symbol )
current instruction
Examples: @sum symbol() returns "sum"

(LOOP) symbol() returns "LOOP"

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 46
 Parser API
Routines
• Constructor / initializer: Creates a Parser and opens the source text file

• Getting the current instruction:

hasMoreLines(): Checks if there is more work to do (boolean)
advance(): Gets the next instruction and makes it the current instruction (string)

• Parsing the current instruction:

instructionType(): Returns the instruction type
symbol(): Returns the instruction’s symbol (string)
dest(): Returns the instruction’s dest field (string)
comp(): Returns the instruction’s comp field (string) Used only if the current instruction is
jump(): Returns the instruction’s jump field (string)
dest = comp ; jump

current instruction
Examples: D=D+1;JLE dest() returns "D" comp() returns "D+1" jump() returns "JLE"

M=-1 dest() returns "M" comp() returns "-1" jump() returns null

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 47
 Implementation

drives the
process
HackAssembler

Parser Code SymbolTable

reads and parses generates handles

an instruction binary code symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 48
 Code API
Deals only with C-instructions: dest = comp ; jump
Routines:
dest(string): Returns the binary representation of the parsed dest field (string)
comp(string): Returns the binary representation of the parsed comp field (string)
jump(string): Returns the binary representation of the parsed jump field (string)

According to the language specification:

Examples:
dest("DM") returns "011"

comp("A+1") returns "0110111"

comp("D&M") returns "1000000"

jump("JNE") returns "101"

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 49
 Implementation

drives the
process
HackAssembler

Parser Code SymbolTable

reads and parses generates handles

an instruction binary code symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 50
 SymbolTable API
Routines
Constructor / initializer: Creates and initializes a SymbolTable

void addEntry(String symbol, int address): Adds <symbol, address> to the table

boolean contains(String symbol): Checks if symbol exists in the table

int getAddress(String symbol): Returns the address associated with symbol

Symbol
table:
(example)

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 51
 HackAssembler: Drives the translation process

drives the
process
HackAssembler

Parser Code SymbolTable

reads and parses generates handles

an instruction binary code symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 52
 Assembler API (detailed)
Parser module:

53
Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 53
 Assembler API (detailed)
Code module:

SymbolTable module:

HackAssembler module (main program):

No proposed design; Implement as you see fit.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 54
 Chapter 6: Assembler

• Overview • Assembler architecture

• Translating instructions • Assembler API
• Translating programs • Project 6
• Handling symbols • Some history

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 55
 Developing a Hack Assembler
Contract
Develop a program that translates symbolic Hack programs into binary Hack instructions;
The source assembly program (input) is read from a text file named Prog.asm
The generated binary code (output) is written to a text file named Prog.hack
Assumption: Prog.asm is error-free.

Usage (if the assembler is implemented in Java):

$ java HackAssembler Prog.asm

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 56
 Testing
Prog.asm Prog.hack
// Computes R1 = 1 + ... + R0 0000000000010000
// i = 1 1110111111001000
@i 0000000000010001
M=1 1110101010001000 CPU
// sum = 0 Your 0000000000010000 Load / Emulator
1111110000010000
@sum
M=0
assembler 0000000000000000 Run
(LOOP) 1111010011010000
// if i > R0 goto STOP 0000000000010010
1110001100000001
@i
0000000000010000
D=M
1111110000010000
@R0
0000000000010001
D=D-M
@STOP 1111000010001000
0000000000010000
D;JGT
...
...

Testing strategy
To test your assembler’s correctness, you will use it to translate some given test assembly programs;
If the resulting binary code will execute correctly, we’ll assume that your assembler is correct.
Not a complete test, but that’s the project 6 contract.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 57
 Testing
Prog.asm Prog.hack
// Computes R1 = 1 + ... + R0 0000000000010000
// i = 1 1110111111001000
@i 0000000000010001
M=1 1110101010001000 CPU
// sum = 0 Your 0000000000010000 Load / Emulator
1111110000010000
@sum
M=0
assembler 0000000000000000 Run
(LOOP) 1111010011010000
// if i > R0 goto STOP 0000000000010010
1110001100000001
@i
0000000000010000
D=M
1111110000010000
@R0
0000000000010001
D=D-M
@STOP 1111000010001000
0000000000010000
D;JGT
...
...

Staged development plan Test programs

• Add.asm
1. Develop a basic assembler that translates Hack
assembly programs containing no symbols • Max.asm • MaxL.asm
• Rect.asm • RectL.asm
2. Develop an ability to handle symbols
• Pong.asm • PongL.asm
3. Morph your basic assembler into an assembler (with symbols) (same programs, without symbols,
that translates any Hack assembly program. for unit-testing your basic assembler)

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 58
 Testing: Add
Add.asm Testing on the CPU emulator:
// Computes RAM[0] = 2 + 3
@2
D=A
@3
D=D+A
@0
M=D

Techincal note
When loading a binary
Prog.hack file into the
CPU emulator, the
emulator may present the
code symbolically, for
readability (depending on
the emulator’s version).
To inspect the binary code,
select “binary” from the
1. Translate Add.asm using your assembler
ROM menu. 2. Load into the CPU emulator the translated Add.hack
3. Run the code, inspect R0.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 59
 Testing: Max
Max.asm MaxL.asm
// Computes RAM[2] = // Computes RAM[2] =
// max(RAM[0],RAM[1]) // max(RAM[0],RAM[1])
@R0 @0
D=M D=M
@R1 @1
D=D-M D=D-M
@OUTPUT_RAM0 @12
D;JGT D;JGT
// Output RAM[1] // Output RAM[1]
@R1 @1
D=M D=M
@R2 @2
(Same test program,
M=D M=D without symbols, for unit-
@END
0;JMP
@16
0;JMP
testing the basic assembler)
(OUTPUT_RAM0)
@R0 @0
D=M D=M
@R2 @2
M=D M=D
(END)
@END @16
0;JMP 0;JMP

with symbols without symbols

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 60
 Testing: Max
Max.asm Testing on the CPU emulator:
// Computes RAM[2] =
// max(RAM[0],RAM[1])
@R0
D=M
@R1
D=D-M
@OUTPUT_RAM0
D;JGT
// Output RAM[1]
@R1
D=M
@R2
M=D
@END
0;JMP
(OUTPUT_RAM0)
@R0
D=M
@R2
M=D
(END) 1. Translate Max.asm
@END
0;JMP 2. Load Max.hack
3. Put test values in R0 and R1, run the code, inspect R2.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 61
 Testing: Rect
Rect.asm Testing on the CPU emulator:
// Draws a rectangle,
// 16 pixels wide,
// R0 pixels high,
// at the screen’s top-left.
@R0
D=M
@n
M=D
@i
M=0
@SCREEN
D=A
@address
M=D
(LOOP)
@i
D=M
@n
D=D-M 1. Translate Rect.asm
@END
D;JGT 2. Load Rect.hack
...
3. Put a non-negative value in R0, run the code, inspect the screen.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 62
 Testing: Pong
Pong.asm
// Pong game
@256
D=A
@SP
Pong game action
M=D
@133
0;JMP
@R15
M=D
@SP
AM=M-1
D=M
A=A-1
D=M-D
M=0
@END_EQ
D;JNE
@SP
A=M-1
M=-1
(END_EQ)
@R15
A=M
Translate Pong.asm, load Pong.hack, and then play the game:
... Select “no animation” from the Animate menu, set the speed slider to “fast”,
and run the code. Move the paddle using the left- and right-arrow keys.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 63
 Testing: Pong
Pong.asm
// Pong game
Background
@256 The source Pong program was written in the high-level Jack language;
D=A
@SP The computer’s operating system is also written in Jack;
M=D
@133
The Pong code + the OS code were compiled by the Jack compiler,
0;JMP creating a single file named Pong.asm;
@R15
This file contains many compiler-generated addresses and symbols.
M=D
@SP
AM=M-1
D=M
A=A-1
D=M-D
M=0
@END_EQ
D;JNE
@SP
A=M-1
M=-1
(END_EQ)
@R15
A=M
... 28,374 instructions

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 64
 Testing option II: Using the hardware simulator
1. Use your assembler to translate Prog.asm, generating the executable file Prog.hack
2. Put the Prog.hack file in a folder containing the chips that you developed in project 5:
Computer.hdl, CPU.hdl, and Memory.hdl

3. Load Computer.hdl into the Hardware Simulator

4. Load Prog.hack into the ROM32K chip-part
5. Run the clock to execute the program.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 65
 Testing option III: Using the supplied assembler
Prog.hack file, Prog.hack file,
translated by the translated by your
supplied assembler assembler

Source
Prog.asm
test file

1. Use your assembler to translate Prog.asm, generating the executable file Prog.hack
2. Load Prog.asm into the supplied assembler, and load Prog.hack as a compare file
3. Translate Prog.hack, and inspect the code comparison feedback messages.

Nand to Tetris / www.nand2tetris.org / Chapter 6 / Copyright © Noam Nisan and Shimon Schocken Slide 66