Unit 6 Assignment
Hack CPU description: it has A and D registers and pseudo-register M which refer to transferring data
between CPU and RAM.
Hack CPU has two types of instructions A-instructions and C-instructions. These two instructions are
going to help us solve the assignment, and here is how we are going to use these instructions.
1. A-instructions description
- A-instructions load A register with a constant value between 0 and 32767 and they don’t
read from RAM.
- Assembly language syntax is as follows
a. @value – instructions will load a non-negative decimal constant into register A.
b. @symbol – instructions will load the address of the code label or RAM variable symbol
into the A register.
NOTE: The A-instruction is used for three different purposes. First, it provides the only way to enter a
constant into the computer under program control. Second, it sets the stage for a subsequent
C-instruction designed to manipulate a certain data memory location, by first setting A to the address of
that location. Third, it sets the stage for a subsequent C-instruction that specifies a jump, by first loading
the address of the jump destination to the A register.
Predefined Symbols
A: Address Register.
D: Data Register.
M: Refers to the register in Main Memory whose address is currently stored in A.
SP: RAM address 0.
LCL: RAM address 1.
ARG: RAM address 2.
THIS: RAM address 3.
THAT: RAM address 4.
R0-R15: Addresses of 16 RAM Registers, mapped from 0 to 15.
SCREEN: Base address of the Screen Map in Main Memory, which is equal to 16384.
KBD: Keyboard Register address in Main Memory, which is equal to 24576.
2. C-instructions description
Assembly language syntax: dest = comp; jmp, where:
1. Dest: destination register in which the result of computation will be stored.
2. Comp: computation code
3. Jmp: the jump directive.
Binary syntax:
1 1 1 a c1 c2 c3 c4 c5 c6 d1 d2 d3 j1 j2 j3, where:
- 111 bits: C-Instructions always begin with bits 111.
- a bit: Chooses to load the contents of either A register or M (Main Memory register
addressed by A) into the ALU for computation.
- Bits c1 through c6: Control bits expected by the ALU to perform arithmetic or bit-wise logic
operations.
- Bits d1 through d3: Specify which memory location to store the result of ALU computation
into: A, D or M.
- Bits j1 through j3: Specify which JUMP directive to execute (either conditional or
unconditional).
After describing the A and C-instructions am using the reference image to be able to convert program 1
and 2 to machine language.
Below is the reference image from
nandetetrics.
Reference IMAGE for C-instruction
Converting program 1 from assembly to machine code.
//Program 1 to convert to machine language
// Computes R0 = 2 + 3
@2
D=A
@3
D=D+A
@0
M=D
Assembly language Machine Language
@2 0000000000000010
D=A 1110110000010000
@3 0000000000000011
D=D+A 1110000010010000
@0 0000000000000000
M=D 1110001100001000
Instructions on how to convert assembly language to machine language;
Machine code:
The characters that start with double forward slashes are comments, so in our conversion we ignore
comments and spaces. These are called white spaces.
1. @2 – loads a non-negative binary equivalent 15 bit binary constant which is 0000000000000010
- Simply convert the decimal constant 2 to equivalent binary constant.
2. D=A – Sets D register to A register which is 1110110000010000
- This is a C-instruction with the syntax 1 1 1 a c1 c2 c3 c4 c5 c6 d1 d2 d3 j1 j2 j3
- The first 3 bits are 111 of which C-instructions start with bits 111
- The computational numeric ‘a’ is 0 when we look at the reference diagram we are setting A
to D of which the computation is 110000.
- The destination of the result of computation is, referencing the diagram again we look at D
and we find its 010.
- Is there any jump? NO jump so the bits are 000.
- Combining the bits in machine language D=A is 1110110000010000.
3. @3 – a value of 3 is loaded in A register 0000000000000011
- We simply convert the decimal 3 to equivalent binary constant 0000000000000011
4. D=D+A - add A-register to D-register and set D-register to incremented value which is
1110000010010000
- Referencing the diagram, this is a C-instruction which in machine code the binary value
starts with bits 111
- The computational numeric is a = 0.
- Looking at the computational value of D+A is 000010
- The destination address is 010.
- There is no jump directive 000
- Combining the bits we have 1110000010010000
5. @0 – loads a zero in A register and the binary equivalent is 0000000000000000
6. M=D – sets RAM[A] to D-register is 1110001100001000
- This is a C instruction and it begins with bits 111
- Computational numeric a = 0
- Computational value is 001100
- Destination value is 001
- And without a jump directive is 000
- Combining the bits in machine language is 1110001100001000
Screen shot Image above is program 1 converted to machine language from Assembler software.
Converting program 2 from assembly to machine code.
// Program 2 to convert to machine language
// Symbol-less version of the Max.asm program.
@0
D=M
@1
D=D-M
@10
D;JGT
@1
D=M
@12
0;JMP
@0
D=M
@2
M=D
@14
0;JMP
Assembly Language Machine Language
@0 0000000000000000
D=M 1111110000010000
@1 00000000000000001
D=D-M 1111010011010000
@10 0000000000001010
D;JGT 1110001100000001
@1 00000000000000001
D=M 1111110000010000
@12 0000000000001100
0;JMP 1110101010000111
@0 0000000000000000
D=M 1111110000010000
@2 0000000000000010
M=D 1110001100001000
@14 00000000000001110
0;JMP 1110101010000111
1. @0 – Loads a constant zero in A-register whose equivalent value is 0000000000000000
- Simply convert decimal constant zero to binary constant 15bit zero.
2. D=M – sets D-register to RAM[A]
- This is a C-instruction whose starting bits are 111
- Referencing from the diagram the computational numerical value a = 1
- The computational value is 110000
- Destination value is 010
- And without a jump directive 000
- Combining the bits we have 1111110000010000
3. @1 – loads a 15 bit binary value in A-register
- Simply converting the decimal 1 value to 15 bit binary 00000000000000001
4. D=D-M – subtracts RAM[A] from D-register and sets D-register to the decremented value
- This is a C-instruction whose starting bits are 3 bits 111
- The computational numerical value is a=1
- The computational value is 010011 from the reference diagram.
- Its destination is 010
- And without a jump directive 000
- Combining the bits we have 1111010011010000
5. @10 – the A-register is loaded with the binary equivalent value of 10 in decimal
- We simply convert the decimal 10 to 15 bit binary value which is 0000000000001010
6. D;JGT – this is C-instruction which says jump to ROM in address A-register if D register is greater
than zero
- It begins with 3 bits 111
- The computational numeric is 0
- The computational value is 001100
- This computational has no destination 000
- And the jump directive is 001
- Reference from the diagram.
- Combining the bits we have 1110001100000001
7. @1 – loads a 15 bit binary value in A-register
- Simply converting the decimal 1 value to 15 bit binary 00000000000000001
8. D=M – sets D-register to RAM[A]
- This is a C-instruction whose starting bits are 111
- Referencing from the diagram the computational numerical value a = 1
- The computational value is 110000
- Destination value is 010
- And without a jump directive 000
- Combining the bits we have 1111110000010000
9. @12 – loads a 15 bit binary value in A-register
- Simply converting the decimal 12 value to 15 bit binary 0000000000001100
10. 0; JMP - Unconditional jump to ROM address in A register. Note that there must be a
computation; the convention is to use 0 for unconditional jumps
- The machine code begins with 111
- It computational numerical a= 0
- Computational value is zero 101010
- Without a destination 000
- Being unconditional jump to ROM 111
- Combining the bits we have 1110101010000111
11. @0 – Loads a constant zero in A-register whose equivalent value is 0000000000000000
- Simply convert decimal constant zero to binary constant 15bit zero.
12. D=M – sets D-register to RAM[A]
- This is a C-instruction whose starting bits are 111
- Referencing from the diagram the computational numerical value a = 1
- The computational value is 110000
- Destination value is 010
- And without a jump directive 000
- Combining the bits we have 1111110000010000
13. @0 – Loads a constant 2 in A-register whose equivalent value is 0000000000000010
- Simply convert decimal constant 2 to binary constant 15bit 2.
14. M=D – RAM[A] set to D-register
- The machine code begins with 111
- Whose computational numeric is a = 0
- Computational value is 001100
- Destination is RAM[A] 001
- Without a jump directive 000
- Combining the bit we have 1110001100001000
15. @14 – loads a 15 bit binary value in A-register
- Simply converting the decimal 14 value to 15 bit binary 00000000000001110
16. 0; JMP - Unconditional jump to ROM address in A register. Note that there must be a
computation; the convention is to use 0 for unconditional jumps
- The machine code begins with 111
- It computational numerical a= 0
- Computational value is zero 101010
- Without a destination 000
- Being unconditional jump to ROM 111
- Combining the bits we have 1110101010000111
Screen shot for program 2 convertion in assembler software.
Finally, I have learnt how physical hardware communicates or interact with software, and also the
under-laying principal of hardware and software interaction.
