www.nand2tetris.org
Building a Modern Computer From First Principles
Machine (Assembly) Language
Where we are at:
Assembler Chapter 6
H.L. Language
&
Operating Sys.
abstract interface
Compiler
Chapters 10 - 11
VM Translator
Chapters 7 - 8
Computer Architecture
Chapters 4 - 5
Gate Logic
Chapters 1 - 3
Electrical
Engineering
Physics Virtual
Machine
abstract interface
Software hierarchy
Assembly Language
abstract interface
Hardware hierarchy
Machine Language
abstract interface
Hardware Platform
abstract interface
Chips &
Logic Gates
abstract interface
Human Thought
Abstract design
Chapters 9, 12
Machine language
Abstraction – implementation duality:
Machine language ( = instruction set) can be viewed as a programmer- oriented abstraction of the hardware platform
The hardware platform can be viewed as a physical means for realizing
the machine language abstraction
Machine language
Abstraction – implementation duality:
Machine language ( = instruction set) can be viewed as a programmer- oriented abstraction of the hardware platform
The hardware platform can be viewed as a physical means for realizing the machine language abstraction
Another duality:
Binary version: 0001 0001 0010 0011 (machine code)
Symbolic version ADD R1, R2, R3 (assembly)
Machine language
Abstraction – implementation duality:
Machine language ( = instruction set) can be viewed as a programmer- oriented abstraction of the hardware platform
The hardware platform can be viewed as a physical means for realizing the machine language abstraction
Another duality:
Binary version
Symbolic version Loose definition:
Machine language = an agreed-upon formalism for manipulating
a memory using a processor and a set of registers
combinational ALU
Memory
state
Lecture plan
Machine languages at a glance
The Hack machine language:
Symbolic version
Binary version
Perspective
(The assembler will be covered in chapter 6).
Typical machine language commands (3 types)
ALU operations
Memory access operations
(addressing mode: how to specify operands)
Immediate addressing, LDA R1, 67 // R1=67
Direct addressing, LD R1, 67 // R1=M[67]
Indirect addressing, LDI R1, R2 // R1=M[R2]
Flow control operations
Typical machine language commands (a small sample)
// In what follows R1,R2,R3 are registers, PC is program counter, // and addr is some value.
ADD R1,R2,R3 // R1 R2 + R3 ADDI R1,R2,addr // R1 R2 + addr
AND R1,R1,R2 // R1 R1 and R2 (bit-wise) JMP addr // PC addr
JEQ R1,R2,addr // IF R1 == R2 THEN PC addr ELSE PC++
LOAD R1, addr // R1 RAM[addr]
STORE R1, addr // RAM[addr] R1 NOP // Do nothing
// Etc. – some 50-300 command variants
The Hack computer
A 16-bit machine consisting of the following elements:
Data memory: RAM – an addressable sequence of registers
Instruction memory: ROM – an addressable sequence of registers Registers: D, A, M, where M stands for RAM[A]
Processing: ALU, capable of computing various functions Program counter: PC, holding an address
Control: The ROM is loaded with a sequence of 16-bit instructions, one per memory location, beginning at address 0. Fetch-execute cycle: later
Instruction set: Two instructions: A-instruction, C-instruction.
The Hack computer
A 16-bit machine consisting of the following elements:
Computer reset
Keyboard
Screen
The Hack computer
A 16-bit machine consisting of the following elements:
Data Memory (Memory) instruction
CPU
Instruction Memory (ROM32K)
inM
outM addressM writeM
pc
reset
The Hack computer
A 16-bit machine consisting of the following elements:
ALU
Mux
D
Mux
reset inM
addressM
pc outM
instruction A/M
decode
C C
C
C
C
D
A
PC
C C
A A A
M ALU output
writeM
C C
The A-instruction
@ value // A value
Where value is either a number or a symbol referring to some number.
Used for:
Entering a constant value
( A = value) @17 // A = 17
D = A // D = 17
Coding example:
@17 // A = 17
D = M // D = RAM[17]
Selecting a RAM location
( register = RAM[A])
@17 // A = 17
Selecting a ROM location
Why A-instruction? It is impossible to pack both addr and instr into 16 bits.
The C-instruction (first approximation)
Exercise: Implement the following tasks using Hack commands:
Set D to A-1
Set both A and D to A + 1
Set D to 19
Set both A and D to A + D
Set RAM[5034] to D - 1
Set RAM[53] to 171
Add 1 to RAM[7],
and store the result in D .
dest = x + y dest = x - y dest = x
dest = 0 dest = 1 dest = -1
x = {A , D , M}
y = {A , D , M , 1}
dest = {A , D , M , MD , AM , AD , AMD , null}
The C-instruction (first approximation)
Exercise: Implement the following tasks using Hack commands:
1.
Set D to A-1
2.
Set both A and D to A + 1
3.
Set D to 19
4.
Set both A and D to A + D
5.
Set RAM[5034] to D - 1
6.
Set RAM[53] to 171
7.
Add 1 to RAM[7],
and store the result in D .
1. D = A-1 2. AD=A+1 3. @19
D=A
4. AD=A+D 5. @5034
M=D-1 6. @171
D=A
@53 M=D 7. @7
D=M+1
The C-instruction (first approximation)
j 3012 sum 4500 Symbol table:
(All symbols and values are arbitrary examples)
Exercise: Implement the following tasks using Hack commands:
sum = 0
j = j + 1
q = sum + 12 – j
arr[3] = -1
arr[j] = 0
arr[j] = 17
etc.
dest = x + y dest = x - y dest = x
dest = 0 dest = 1 dest = -1
x = {A , D , M}
y = {A , D , M , 1}
dest = {A , D , M , MD , AM , AD , AMD , null}
The C-instruction (first approximation)
Exercise: Implement the following tasks using Hack commands:
1.
sum = 0
2.
j = j + 1
3.
q = sum + 12 – j
4.
arr[3] = -1
5.
arr[j] = 0
6.
arr[j] = 17
7.
etc.
1. @sum M=0 2. @j
M=M+1 3. @sum
D=M
@12 D=D+A
@j
D=D-M
@q M=D
4. @arr D=A
@3 A=D+A M=-1 5. @j
D=M
@arr A=A+D M=0
6. @j D=M
@arr D=A+D
@ptr M=D
@17 D=A
@ptr
A=M
M=D
Control (focus on the yellow chips only)
ALU
Mux
D
A/M a-bit
D register
A register A
RAM M (selected register)
ROM (selected register)
PC
Instruction
In the Hack architecture:
ROM = instruction memory
Program = sequence of 16-bit numbers, starting at ROM[0]
Current instruction = ROM[PC]
To select instruction n from the ROM,
address input
address
input
Coding examples (practice)
Exercise: Implement the following tasks using Hack commands:
goto 50
if D==0 goto 112
if D<9 goto 507
if RAM[12] > 0 goto 50
if sum>0 goto END
if x[i]<=0 goto NEXT.
sum 2200 x 4000 i 6151
Symbol table:
(All symbols and values in are
Hack commands:
A-command: @value // set A to value C-command: dest = comp ; jump // dest = and ;jump
// are optional Where:
comp = 0 , 1 , ‐1 , D , A , !D , !A , ‐D , ‐A , D+1 , A+1 , D‐1 , A‐1 , D+A , D‐A , A‐D , D&A , D|A , M , !M , ‐M , M+1 , M‐1 , D+M , D‐M , M‐D , D&M , D|M
dest = M , D , A , MD, AM , AD , AMD, or null
jump = JGT , JEQ , JGE , JLT , JNE , JLE , JMP, or null
In the command dest = comp; jump, the jump materialzes if (comp jump 0) is true. For example, in D=D+1,JLT, we jump if D+1 < 0.
Hack convention:
Coding examples (practice)
Exercise: Implement the following tasks using Hack commands:
1.
goto 50
2.
if D==0 goto 112
3.
if D<9 goto 507
4.
if RAM[12] > 0 goto 50
5.
if sum>0 goto END
6.
if x[i]<=0 goto NEXT.
1. @50 0; JMP 2. @112
D; JEQ 3. @9
D=D-A
@507 D; JLT 4. @12
D=M
@50
5. @sum D=M
@END D: JGT 6. @i
D=M
@x A=A+D D=M
@NEXT
D; JLE
if condition { code block 1 } else {
code block 2 }
code block 3 High level:
D condition
@IF_TRUE D;JEQ
code block 2
@END 0;JMP (IF_TRUE)
code block 1 (END)
code block 3 Hack:
IF logic – Hack style
Hack convention:
True is represented by -1
False is represented by 0
WHILE logic – Hack style
while condition { code block 1 }
Code block 2
High level:
(LOOP)
D condition
@END D;JNE
code block 1
@LOOP 0;JMP (END)
code block 2
Hack:
Hack convention:
True is represented by -1
False is represented by 0
Side note (focus on the yellow chip parts only)
ALU
Mux
D
A/M a-bit
D register
A register A
M RAM
(selected register)
ROM (selected register)
PC
Instruction address
input
address input
In the Hack architecture, the A register addresses both the RAM and the ROM, simultaneously. Therefore:
Command pairs like @addr followed by D=M;someJumpDirective make no sense
Best practice: in well-written Hack programs, a C-instruction should contain
either a reference to M, or
Complete program example
// Adds 1+...+100.
int i = 1;
int sum = 0;
while (i <= 100){
sum += i;
i++;
}
C language code:
// Adds 1+...+100.
@i // i refers to some RAM location M=1 // i=1
@sum // sum refers to some RAM location M=0 // sum=0
(LOOP)
@i
D=M // D = i
@100
D=D-A // D = i - 100
@END
D;JGT // If (i-100) > 0 goto END
@i
D=M // D = i
@sum
M=D+M // sum += i
@i
M=M+1 // i++
@LOOP
0;JMP // Got LOOP
Hack assembly code:
Demo
Hack assembly convention:
Variables: lower-case
Labels: upper-case
