0% found this document useful (0 votes)
25 views

Lecture 04 Machine Language

Uploaded by

zoro goh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
25 views

Lecture 04 Machine Language

Uploaded by

zoro goh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 18

Machine Language

Building a Modern Computer From First Principles

www.nand2tetris.org

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 1
Where we are at:

Human Abstract design Software


abstract interface
Thought hierarchy
Chapters 9, 12
H.L. Language Compiler
& abstract interface
Chapters 10 - 11
Operating Sys.
Virtual VM Translator
abstract interface
Machine Chapters 7 - 8

Assembly
Language

Assembler

Chapter 6

abstract interface
Computer
Machine Architecture
abstract interface
Language
Chapters 4 - 5
Hardware Gate Logic
abstract interface
Platform Chapters 1 - 3 Electrical
Chips & Engineering
Hardware Physics
Logic Gates
hierarchy

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 2
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

 Same spirit but different syntax across different hardware platforms.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 3
Binary and symbolic notation

1010 0001 0010 1011 ADD R1, R2, R3

Evolution:

 Physical coding

 Symbolic documentation

 Symbolic coding

 Translation and execution

 Requires a translator.
Jacquard loom Augusta Ada King,
(1801) Countess of Lovelace
(1815-1852)

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 4
Lecture plan

 Machine languages at a glance

 The Hack machine language:

 Symbolic version

 Binary version

 Perspective

(The assembler will be covered in lecture 6).

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 5
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

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 6
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.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 7
The A-instruction

@value // A  value

Where value is either a number or a symbol referring to some number.

Used for: Coding example:

 Entering a constant value


( A = value) @17 // A = 17
D = A // D = 17

 Selecting a RAM location @17 // A = 17


( register = RAM[A]) D = M // D = RAM[17]

Later
 Selecting a ROM location @17 // A = 17
( PC = A ) JMP // fetch the instruction
// stored in ROM[17]

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 8
The C-instruction (first approximation)

dest = x + y Exercise: Implement the following tasks


using Hack commands:
dest = x - y
 Set D to A-1
dest = x
dest = 0  Set both A and D to A + 1

dest = 1  Set D to 19
dest = -1
 Set both A and D to A + D

x = {A, D, M}  Set RAM[5034] to D - 1


y = {A, D, M , 1}
dest = {A, D, M, MD, A, AM, AD, AMD, null}
 Set RAM[53] to 171

 Add 1 to RAM[7],
and store the result in D.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 9
The C-instruction (first approximation)
Exercise: Implement the following tasks
dest = x + y using Hack commands:

dest = x - y  sum = 0
dest = x
 j = j + 1
dest = 0
 q = sum + 12 – j
dest = 1
dest = -1  arr[3] = -1

 arr[j] = 0
x = {A, D, M}
y = {A, D, M , 1}  arr[j] = 17
dest = {A, D, M, MD, A, AM, AD, AMD, null}
 etc.
Symbol table:
j 3012
(All symbols and values
sum 4500 are arbitrary examples)
q 3812
arr 20561

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 10
Control (focus on the yellow chips only)

D register D

a-bit

ALU
A
A register

A/M

Mux
address RAM M
input
(selected
register)
In the Hack architecture:

 ROM = instruction memory

 Program = sequence of 16-bit


address ROM numbers, starting at
input Instruction
PC ROM[0]
(selected
register)  Current instruction = ROM[PC]

 To select instruction n from the ROM,


we set A to n, using the instruction @n

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 11
Coding examples (practice) Hack commands:

Exercise: Implement the following A-command: @value // set A to value


tasks using Hack commands: C-command: dest = comp ; jump // dest = and ;jump
// are optional
 goto 50 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 ,
 if D==0 goto 112
D|A , M , !M , -M ,M+1, M-1 , D+M , D-M ,
M-D , D&M , D|M
 if D<9 goto 507 dest = M , D , MD , A , AM , AD , AMD, or null
jump = JGT , JEQ , JGE , JLT , JNE , JLE , JMP, or null
 if RAM[12] > 0 goto 50
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.
 if sum>0 goto END

Symbol table:
 if x[i]<=0 goto NEXT.
sum 2200
Hack convention:
x 4000 (All symbols and
i 6151 values in are
 True is represented by -1
END 50 arbitrary examples)
 False is represented by 0 NEXT 120

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 12
IF logic – Hack style

High level: Hack:

if condition { D  not condition


code block 1} @IF_TRUE
else { D;JEQ
code block 2}
code block 2
code block 3
@END
0;JMP
Hack convention: (IF_TRUE)
code block 1
 True is represented by -1
(END)
 False is represented by 0 code block 3

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 13
WHILE logic – Hack style

High level: Hack:

while condition { (LOOP)


code block 1 D  not condition)
} @END
Code block 2
D;JEQ
code block 1
@LOOP

Hack convention: 0;JMP


(END)
 True is represented by -1
code block 2
 False is represented by 0

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 14
Side note (focus on the yellow chip parts only)

D
D register

a-bit

ALU
A
A register

A/M

Mux
address RAM M
input
(selected
register)
In the Hack architecture, the A register
addresses both the RAM and the ROM,
simultaneously. Therefore:
 Command pairs like @addr followed by
address ROM D=M;someJumpDirective make no sense
input Instruction
PC  Best practice: in well-written Hack
(selected
register) programs, a C-instruction should contain
 either a reference to M, or
 a jump directive,
 but not both.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 15
Complete program example
C language code: Hack assembly code:
// Adds 1+...+100. // Adds 1+...+100.
into i = 1; @i // i refers to some RAM location
into sum = 0; M=1 // i=1
while (i <= 100){ @sum // sum refers to some RAM location
M=0 // sum=0
sum += i;
(LOOP)
i++;
@i
} D=M // D = i

@100
Hack assembly convention: D=D-A // D = i - 100

 Variables: lower-case @END


D;JGT // If (i-100) > 0 goto END
 Labels: upper-case
@i
D=M // D = i
 Commands: upper-case
@sum
M=D+M // sum += i
Demo
CPU emulator @i
M=M+1 // i++
@LOOP
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 16
0;JMP // Got LOOP
Symbols in Hack assembly programs // Typical symbolic
// Hack code, meaning
// not important
Symbols created by Hack programmers and code generators: @R0
 Label symbols: Used to label destinations of goto commands. Declared D=M
@INFINITE_LOOP
by the pseudo command (XXX). This directive defines the symbol XXX to
D;JLE
refer to the instruction memory location holding the next command in
@counter
the program (within the program, XXX is called “label”)
M=D
 Variable symbols: Any user-defined symbol xxx appearing in an assembly @SCREEN
program that is not defined elsewhere using the (xxx) directive is D=A
treated as a variable, and is “automatically” assigned a unique RAM @addr
address, starting at RAM address 16 M=D
 By convention, Hack programmers use lower-case and upper-case letters (LOOP)
@addr
for variable names and labels, respectively.
A=M
Predefined symbols: M=-1
@addr
 I/O pointers: The symbols SCREEN and KBD are “automatically” D=M
predefined to refer to RAM addresses 16384 and 24576, respectively @32
(base addresses of the Hack platform’s screen and keyboard memory D=D+A
maps) @addr
 Virtual registers: covered in future lectures. M=D
@counter
 VM control registers: covered in future lectures. MD=M-1
@LOOP
Q: Who does all the “automatic” assignments of symbols to RAM addresses?
D;JGT
A: The assembler, which is the program that translates symbolic Hack (INFINITE_LOOP)
programs into binary Hack program. As part of the translation process, the symbols
@INFINITE_LOOP
are resolved to RAM addresses. (more about this in future lectures)
0;JMP
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 17
Perspective

 Hack is a simple machine language

 User friendly syntax: D=D+A instead of ADD D,D,A

 Hack is a “½-address machine”: any operation that needs to operate on the


RAM must be specified using two commands: an A-command to address the
RAM, and a subsequent C-command to operate on it

 A Macro-language can be easily developed

 A Hack assembler is needed and will be discusses and developed later in


the course.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 18

You might also like