EE182 - Programming Assignment #2

Part I Due: Wednesday 11/13/02
Part II Due: Wednesday 11/20/02

Your task

Write an assembly program that simulates a subset of the MIPS-I ISA. Your program will be called by a shell that establishes the environment and will execute until it does a return back to the shell. The shell for the program can be found here. You can also copy the shell from /usr/class/ee182/WWW/Projects/PA2/simulator.s. Please add your code DIRECTLY to the shell (where specified). Once you have completed the assignment, follow the submit directions to submit your program electronically. DO NOT turn in paper copies of your code.

The Subset
Your emulator should interpret the following MIPS instructions:

Loads and stores: lw, sw
ALU operations: add, addi, sub, and, andi, sll, slt, slti, lui
Branches and jumps: jr, jal, beq, bne

The Environment
Your routine will be called by our shell routine. The shell allocates memory, loads in a program, and passes you the following values:

$a0 -- pointer to an area of memory allocated to hold your virtual machine's registers. You will use this allocated memory to simulate your virtual registers. For example, if the loaded program has an instruction which uses register $s0, your simulator will access that register via 64($a0). Recall that $s0 is actually register 16 (see Hennessy and Patterson page A-23). But because registers are 1 word (4 bytes) in length, $s0 is found at an offset of 4*16 off of $a0.
$a1 -- pointer to the lowest word within the static memory area (area to be used by programs running on your virtual machine). For example, if the loaded program uses the memory address 0x0004, your simulator accesses that address via 4($a1).
$a2 -- pointer to the top of the program's stack area. Per the MIPS convention, it is the highest memory address within the static memory area.
$a3 -- pointer to the first instruction in the program. This also happens to be a pointer to the lowest memory position. In other words, registers $a3 and $a1 contain the same address. This is done for your convenience. You may want to keep $a1 constant throughout your simulator's operation, as a reference to your memory space. $a3 can then be used to track where your virtual machine's program is executing.
Be sure to refer to the memory map for further explanation.

As usual, $ra will have the return address. Execution halts on the simulator's (jr) to the address in $ra. The simulator procedure should return these values:

$v0 -- the return value for the program you are running
$v1 -- the total number of simulated instructions executed.

In addition, after you have completed simulation of the program, but before you return (via "jr $ra"), print out the following statistics:

The total number of executed R-type instructions.
The total number of executed I-type instructions.
The total number of executed J-type instructions.

For example, if your simulator executes 100 instructions, and if 57 are R-type, 32 are I-type, and 11 are J-type ... your code should print out the following:

R-type: 57

I-type: 32

J-type: 11

For our grading convenience, we are asking you to print out your statistics in this prescribed format and only in this prescribed format! You MUST print out your statistics in the above format! Be sure to place a carriage return at the end of each line.

Programs for your Simulator
Programs for your simulator consist of integer values, one per line, that represent hand-assembled MIPS instructions. The end of the program is signified by a 0. The shell that we give you will read in a file line-by-line, storing it into the "code" space, stopping when it reads in a 0. The 0 will also be stored in the code space so that your simulator knows where it should stop execution. The command-line used to execute a program is as follows:

spim -file simulator.s < myprogram

where "simulator.s" is your assembly language code implementing the MIPS simulator (shell plus your code) and "myprogram" is a text file containing integers representing MIPS instructions. The "<" symbol redirects input so that spim takes its input from the file "myprogram" rather than from the console.

Testing
We provide you with some test sequences here, but we recommend that you also create your own test sequences. While the programming is to be done individually, we encourage the group creation and sharing of test code. You will need to hand compile your test code to generate a file of integers that can be read in by the shell.

Test program 1: MIPS code, integer values, hex values
Test program 2: MIPS code, integer values, hex values
Test program 3: MIPS code, integer values, hex values
Addi Test program: MIPS code, integer values, hex values

The test code can also be copied from /usr/class/ee182/WWW/Projects/PA2/.

If you choose to write your own code the script spimulator.pl (written by Eric Silverberg, an EE182 from a previous quarter) might be useful. To run it, type spimulator.pl at the command line and follow the directions, you will need a file containing an assembly language program. PLEASE do not contact Eric Silverberg if you have problems with this script, since he is letting us use it as a favor, so please direct any questions to the TAs. Please also note that since the program was not written by the course staff it is "unsupported" and may have bugs.

Goals

This assignment is intended to facilitate your understanding of how MIPS instructions are decoded and executed.

Hints:

Be sure to distinguish carefully between the SPIM simulator and your own simulator.
Make sure to setup your system initially in the same way as a real machine would be initialized.
The only way your machine communicates to the outside world is through $v0 and $v1 when it finishes execution. Clearly this limits the type of programs you'll be able to write.
Look at appendix A of the book for diagrams of instruction formats.

Part I

The first part of the assignment is to implement the addi instruction. Your simulator should be able to run programs that contain only addi instructions, similar to the addi sample program provided. The output should include the instruction count for all three instruction types, though both R and J instruction counts will be 0.

This portion of the assignment is due on Wednesday, 11/13/02 by 11:59 PM. The goal is to get you started on the project early since this assignment is considerably more involved than the previous programming assignment.