Hi, and Welcome. I hope this is helpful in preparation for the exam. If you find anything wrong, please do not hesitate in sending a pull-request.

NB. Exercise 4,5 and 6 have more throughout explanations in the .md-files.

Best Regards, Henry.

• Exercise 4
• Exercise 5
• Exercise 6

We are to translate the following instructions into binary code.

0x00 ldi %r2, 1
0x04 ldi %r1, 1
0x08 mul %r2, %r2, %r0
0x0C sub %r0, %r0, %r1
0x10 cmp %r3, %r0, %r1
0x14 jgt %r3, -16

We are given one example in the exercise handout:

add %r7, %r8, %r9 translates to

00001 00111 01000 01001 XXXX XXXX XXXX
add   r7    r8    r9

See page 5 in the handout for state diagram of the machine. (shown below) We can see the opcodes listed as...

00000000100000000000000000000001
00000000010000000000000000000001
00010000100001000000XXXXXXXXXXXX
00101000000000000001XXXXXXXXXXXX
00011000110000000001XXXXXXXXXXXX
00100000111111111111111111110000

Assume that register %r0 contains 2 before the program is executed. What would be the value in register %r2 once the program reaches the instruction at address 0x18, i.e. the branch at address 0x14 is not taken. What would be the value in %r2, if %r0 would contain 3, 4, 9?

Submission

Hand in a plain text file with the corresponding values per line, i.e. the value for 2 on the first line, the value for 3 on the second, etc.

• Table of all content
• Exercise 5
  • Solution for the hasty
  • The lazymans Quickstart to the instruction set architecture
    • ldi
    • mul
    • sub
    • cmp
    • jgt
  • Step by step Exercise solutions
    • If %r0 = 2
    • If %r0 = 3
    • If %r0 = 4
    • If %r0 = 9

2
6
24
362880

To do these exercises we have to look at the instruction set architecture. Page 2. For the lazy, here is a quick Explanation of them:

NB. These instructions only apply to the instruction set architecture for these exercises. Remember to check the isa that is appended in the exam. A lot of the things should be similar though.

A=B Load the integer in B into the register in A

A=B*C Multiply B with C, store in A.

A=B-C Subtract C from B, store in A.

This is a compare operation that returns a binary...

if (A < B) => 100

if (A > B) => 010

if (A == B) => 001

Jump-Greater-Than Instruction Returns the program-counter + the immidiate.

Depending on what the output of the compare function is (see above), we will get different outcome.

If the output of cmp is "0b010" we will jump. Setting the Program-Counter (PC) to the PC + immidiate.

Example

Quick Explanation The cmp instruction have stored in register 3 that A > B. Therefore we will jump to PC + immidiate = 0x14 + (-)16 = 0x04

NB. Note that the PC-Values are written in hexadecimals. Made clear by "0x" preceeding the number.

For the other two possibilities we will just continue down the program.

Then %r2 = 2

Then %r2 = 6

Then %r2 = 24

Then %r2 = 362880

Assume that register %r0 contains 1 before the program is executed. Given the microarchitecture in Section 2 and the control unit’s state machine in Section 3, write down the values of the control unit’s output signals for each executed instruction in the following order: imm, alu, regw, branch.

Submission Hand in a plain text file with the values for each executed instruction per line.

• Table of all content
• Exercise 6
  • Step by step solution
  • SOLUTION

This exercise is as easy as reading off the state machine schema during execution of the program.

The program is still:

0x00 ldi %r2, 1
0x04 ldi %r1, 1
0x08 mul %r2, %r2, %r0
0x0C sub %r0, %r0, %r1
0x10 cmp %r3, %r0, %r1
0x14 jgt %r3, -16

And we can write it out more clear as a sheet.

NB. I have also written down the Register-values just so we can see that the program actually ends with just "one go".

Notice that we are interested in finding the values for imm,alu,regw and branch for each step. Let's feed the state-machine some input and read its outputs for each step.

And then it's just a matter of filling out each program-step with the corresponding "opcode outputs".

1310
1310
0410
0510
0110
0201