Computer Science 220
Assembly Language & Computer Architecture

Fall 2010, Siena College

Home     Syllabus     Schedule

This lab assignment is designed to get you started doing your own MIPS programming using SPIM. The amount of coding is relatively small but you should expect to spend some time getting familiar with SPIM (which you should be able to do during the lab meeting), and perhaps some time installing an appropriate version on your own computer if you wish.

You may work individually or with a partner on this lab.

SPIM

SPIM is a free and open source software simulator of the MIPS architecture that we will use to execute MIPS programs. It was developed and is maintained by James Larus. You can learn more and download your own copy at SPIM's web page.

SPIM's capabilities include:

• reading MIPS assembly language programs
• simulating the execution of each instruction
• displaying the values of registers and memory
• providing execution breakpoints and step-by-step execution
• providing primitive I/O to allow interactive processing.

Three SPIM versions are available:

• spim - command-line only
• xspim - graphical interface using X11 (Macs, Linux/Unix workstations)
• PCspim - graphical interface with Windows
• QtSpim - a cross-platform interface built on the Qt UI framework.

I will grade submissions with spim, but you are welcome to use any version you wish when developing MIPS programs.

spim and xspim are available on the Linux systems in our labs.

In Lab: Running Complete MIPS Assembly Programs

A complete program consists of several parts, including the MIPS assembly code we have been considering in our class examples. Consider a very simple MIPS program.

See Example:
~jteresco/shared/cs220/examples/spim-simple/simple.s

Parts of that are familiar: MIPS instructions. But there are several other things to notice that allow us to take a set of MIPS instructions and turn them into a complete MIPS program, capable of being executed in SPIM.

Here are some things to notice about this example:

• Comments in MIPS assembly are any part of a line after a # character.
• We can define variables in the .data portion of the program.
• Here, we define three word-sized (32 bit) variables with initial values. The names num1, num2, and num3 are labels that define the names of the variables, .word indicates that these are word-sized variables, and numbers are the initial values given to the variables. These are local labels, meaning that they exist only within this assembly source file.
• We also define an uninitialized word-sized variable sum, using the .space directive, followed by a 4 to indicate the number of bytes of space to allocate.
• The program is defined in the .text portion - the "code section".
• The line .align 2 is included to make sure our code starts on a word boundary (a multiple of 4). If some of our .data definitions included byte-sized values, this could be important, but shouldn't be strictly necessary here. (Note that .align n forces the next defined item to align on a 2ⁿ-byte boundary.)
• .globl main makes the main label an external, or global label, which allows the main subroutine to be callable from outside of this file (in this case, by the simulator, in general, by a subroutine defined in another assembly source file).
• The program itself is defined starting at the main: label.
• The program loads some values from memory, adds them, and stores the sum back in memory. Note that we can use lw and sw to load register values from and store register values to the named memory locations we allocated in the .data segment.
• Since we'd like to print out the answer, and there is no simple MIPS instruction that knows how to print anything, we need to use SPIM's (very primitive but functional) I/O system calls, accessed by the keyword syscall. syscall can perform one of several functions, as determined by the value in $v0. Here, we have a 1 in $v0, which specifies print_int as the I/O system call to perform. As you might guess, this I/O system call prints an int value. The int to print must be placed in $a0. We will see a few other examples of syscall soon.
• Finally, when main completes, we return from the subroutine with jr $ra.

To run this at the command line:

spim -file simple.s

This should print our answer.

We can learn much more about the execution of the program running SPIM in interactive mode.

Run spim without any command-line parameters to get the (spim) prompt, and type help to see the options available. Load the program into the simulator, then step through the program, examining the contents of the registers as you go.

Some things to notice when stepping through our program:

• Execution starts at 0x00400000 by default, which is the code that sets up the call to main.
• After a few steps, main gets invoked with a jal call.
• When we get to main, we find that we are executing a lui instruction rather than the expected lw. Why?
  • The lw instruction requires a base register and offset:

    lw $t0, offset($base)

  • The assembler allows us to write lw $t0, num1 (which constitues a different addressing mode) and inserts appropriate instructions to perform a load from a labelled memory location.
  • It computes the appropriate address, loads it into the reserved assembler register $at, then issues a lw instruction in the machine's memory addressing mode.

While the text-only spim simulator is fine for running a program to obtain a result, xspim has a much friendlier (even if a bit old fashioned) interface for tracing through and debugging programs. Run simple.s using xspim and experiment with the interface.

Another simple example:

See Example:
~jteresco/shared/cs220/examples/spim-simple/hello.s

A few things to note here:

• We can define a string constant as part of our data segment with an .asciiz directive.
• The la is a pseudoinstruction that directs the assembler to load the given register with the address of the given label.
• A syscall with $v0 set to 4 is the print_string operation, and will print the null-terminated string starting at the address in $a0.

Finally, we look at a complete version of the factorial program you saw/will see in class. (Tuesday lab group may wish to skip this example until after seeing it in Thursday's lecture.)

See Example:
~jteresco/shared/cs220/examples/spim-factorial/factorial.s

• The factorial subroutine is identical to what we looked at/will look at in class.
• We fill in the missing multiply routine with the one you did for the lecture assignment, changed to use $a0 and $a1 as the parameters and to put the answer into $v0.
• The main subroutine will use two "s" registers and will call subroutines, so we begin by pushing $s0, $s1, and $ra onto the stack. Note that SPIM initialized $sp for us appropriately.
• We print a prompt string with the print_string syscall and then read in an int from the keyboard with the read_int syscall. Note: a complete list of syscall codes is in Figure B.9.1.
• After the call to factorial, we use a series of syscalls to print the answer.
• Finally, we pop the stack and return from main.

Programming Tasks

Task 1

First, write a MIPS assembly language program sumarray.s to sum the elements of an array.

To declare the array, do something like this:

ar:   .word 5, 17, -3, 22, 120, -1	# a six-element array

This will allocate space for 6 word-sized values and will assign the ar label to refer to the address of the first element.

Fill your array with an assortment of initial values, and declare a sum variable, using .space 4 as in the simple.s example. The simplest way to loop through an array is to use a pointer and stop when it runs off the end of the array. You can do that by declaring a label right after the array, and then initializing a register to point to the start of the array (i.e. in the program, initialize the register with the array address) and looping until your pointer register equals the value in the end-of-array register (which is the address just past the array).

ar:	.word 5, 17, -3, 22, 120, -1	# a six-element array
endar:
sum: .space 4

At the end, print out the value of the sum variable.

Task 2

Second, write a MIPS assembly language program swapelements.s that will swap the contents of two elements of an array, given the array and the indices of the elements to be swapped.

For the indices, use two more integer variables declared in the data section with .word. (Warning: you can't use `j' as a label/variable name, since j is an instruction name).

Print all of the elements of your array both before and after the swap. This will involve a loop much like the one you wrote for the first task of this lab.

Submission and Evaluation

This lab is graded out of 35 points.

By 10:00 AM, Friday, October 8, 2010, submit documented MIPS assembly source code for your two programs. All necessary files should be submitted by email to jteresco AT siena.edu.

Note: During grading, I will replace your array's contents with our own, so be sure your programs work with a variety of array sizes and contents. Also, make sure that your programs work in SPIM on the CS Linux systems, as that is where I will test your programs.

Appropriate documentation is especially important in assembly language programs (and make sure your name is in each of the files). Equivalent high-level language code often makes good comments. Be sure to describe your register and memory usage clearly in the comments.

Please do not include any additional files, such as emacs backup files.