[Solved] Lab Sheets 1 & 2 for CS F342 Computer Architecture

Goals for Lab 1 & 2:

Goal 1: Installing and launching QTSPIM this tool will be used for major part of the lab work.

Installing and launching QTSPIM

Open a terminal to run the following commands.

1. Check the OS and the processor support on your Linux machine verify whether it is

32 bit or 64 bit. [Try commands like uname p ; uname a ; man uname]

1. Download the appropriate QTSPIM binary from Internet

(https://sourceforge.net/projects/spimsimulator/files/) or from http://172.16.103.147/CA

1. Install using dpkg tool. Do not forget to get super user privilege using sudo. $ sudo dpkg -i <qtspim package>
2. Launch QTSPIM

Note: Please refer to the following: (i) HP_AppA.pdf (ii) Chapter 2 Hennessey & Patterson Book (iii) MIPS Reference Data Card (Green sheet)

Goal 2: To get introduced to QTSPIM and implement some code related to System Calls and User Input. Further, we will do basic integer Add/Sub/And/Or and their immediate flavours

(e.g. ori).

Reference for MIPS assembly refer to the MIPS Reference Data Card (Green sheet) uploaded in CMS. Further, some of the QTSPIM assembly instructions are beyond this data card (e.g. the pseudo instruction la).

Additionally use Appendix A (HP_AppA.pdf) from Patterson and Hennessey Assemblers, Linkers and the SPIM Simulator for gaining background knowledge of SPIM.

In this lab we focus on reversing only integer based instructions (add, or, subi etc.).

Reference for Registers:

System calls as well as functions (in later part of the semester) should take care of using the registers in proper sequence. Especially take note of V0, V1 [R2, R3 in QTSPIM] and a0-a3 [R4-R7 in QTSPIM] registers.

Reference for System Calls:

Reference for Data directives:

.word w1, , wn

-store n 32-bit quantities in successive memory words

.half h1, , hn

-store n 16-bit quantities in successive memory half words

.byte b1, , bn

-store n 8-bit quantities in successive memory bytes

.ascii str

-store the string in memory but do not null-terminate it

-strings are represented in double-quotes str

-special characters, eg.
, t, follow C convention

.asciiz str

-store the string in memory and null-terminate it

.float f1, , fn

-store n floating point single precision numbers in successive memory locations

.double d1, , dn

-store n floating point double precision numbers in successive memory locations

.space n

-reserves n successive bytes of space

Layout of Code in QTSPIM: Typical code layout (*.asm file edited externally)

# objective of the program

.data #variable declaration follows this line .text #instructions follow this line main: # the starting block label

xxx yyy zzz

..

li $v0,10 #System call- 10 => Exit;

syscall # Tells QTSPIM to properly terminate the run

#end of program

Exercise 0: Understanding Pseudo instruction.

Not all instructions used in the lab will directly map to MIPS assembly instructions. Pseudoinstructions are instructions not implemented in hardware. E.g. using $0 or $r0 we can load constants or move values across registers using add instruction.

E.g. li $v0, 10 actually gets implemented by assembler as ori $v0, $r0, 10

In subsequent exercises, identify the pseudo instruction by looking at the actual code used by QTSPIM.

Exercise 1: Integer input and output and stepping through the code.

Invoking system calls to output (print) strings and and input (read) integers.

The following code snippet prints the number 10 on console. Modify it to read any number and print it back.

Hint: To copy it from $v0 to $a0, you can use add or addi with 0 or similar options.

Edit the code in your editor of choice and then load it in QtSpim. Single Step [] through the code and look at the register values as you execute various instructions. The demo code is given below:

# demo code to print the integer value 10

.data #variable declaration follow this line

# sample string variable declaration not used in first exercise. myMsg: .asciiz Hello Enter a number. # string declaration

# .asciiz directive makes string null terminated

.text #instructions follow this line main: li $a0,10 li $v0,1 syscall

li $v0,10 #System call Exit QTSPIM to properly terminate the run syscall

#end of program

Exercise2: Modify the above code to output myMsg along with the input integer. You will use load address MIPS instruction (la $a0, myMsg)

Exercise 3: Take 2 integers as input, perform addition and subtraction between them and display the outputs. The result of addition is to be displayed as The sum is = and that of subtraction is to be displayed as The difference is =. Check if negative integers can be handled.

Observations: List all the pseudoinstructions used in this exercise and discuss.

Exercise 4: Disassemble the binary / hex code to MIPS assembly code. Note that pseudoinstructions cannot be identified using this. For your information, a brief discussion for a sample instruction follows below.

For code at address 0x0040 0038 which is having a value of 0x2048 0000 when we break into opcode etc. we get:

Binary representation: 0010 0000 0100 1000 0000 0000 0000 0000

OpCode value is: 0010 00 (8 decimal)

As per green card, OpCode 8 decimal is for addi (type I)

rs value is: 00 010 => 2 decimal- register v0 rt value is: 01 000 => 8 decimal register t0 immediate value is: 0000 0000 0000 0000 => 0

Hence the instruction is addi $t0, $v0, 0

In groups, write different assembly instructions and ask your group members to reverse from hexnotation.

Also as an exercise reverse the following three values:

1. 00a64020
2. 00a64822
3. 34020005