CS201 Lab: Introduction to QtSpim
Important Information
1. In CL136, we have Windows 10, and installed QtSpim version QtSpim_9.1.24_Windows.msi.
2. If you wish to install QtSpim_9.1.24_Windows.msi or the other versions
in your home computer, you can refer to the following website:
http://sourceforge.net/projects/spimsimulator/files/
3. To open the QtSpim, you can double click on the icon on your desk top,
or open C:\Program Files\QtSpim\qtspim.exe
4. Once you get it opened, click on the "Simulator" and
then select "Settings" . When you see the table,
make sure that "Load exception file" is NOT checked.
You only need to do this once, not every time.
Then, close the QtSpim, and reopen it.
All the examples in the lab notes will work fine for you.
5. SPIM is a simulator for the MIPS architecture.
In the lab, we are going to use QtSpim version 9.1.24.
For more information about SPIM, please follow the following link:
http://www.cs.wisc.edu/~larus/spim.html
MIPS Architecture
SPIM is a simulator for the MIPS. MIPS processor contains 32 general purpose registers that are numbered from 0 to 31.The registers are used in the SPIM instructions, particularly, in arithmetic operations.
Here is a summary of the MIPS register file for your reference.
Register Name Number Usage
===============================================================
Zero $0 Constant 0
---------------------------------------------------------------
$at $1 Reserved for assembler
---------------------------------------------------------------
$v0 $2 Used for the expression evaluation
$v1 $3 and results of a function
---------------------------------------------------------------
$a0 $4 Used to pass arguments to functions
$a1 $5
$a2 $6
$a3 $7
---------------------------------------------------------------
$t0 - $t7 $8-$15 Temporary (not preserved across call)
---------------------------------------------------------------
$s0 - $s7 $16-$23 Saved temporary (preserved across call)
---------------------------------------------------------------
$t8 - $t9 $24-$25 Temporary (not preserved across call)
---------------------------------------------------------------
$k0 - $k1 $26-$27 Reserved for OS kernel
---------------------------------------------------------------
$gp $28 Pointer to global area
---------------------------------------------------------------
$sp $29 Stack Pointer
---------------------------------------------------------------
$fp $30 Frame Pointer
---------------------------------------------------------------
$ra $31 Return address (used by function call)
---------------------------------------------------------------
NOTE: The MIPS processor also has 16 floating point registers
$f0, $f1, ..., $f15 to hold numbers in floating point
form, such as 3.1415.
Create an Assembly Language Program
To create an assembly language program, you need to use a text editor such as NotePad in Microsoft Windows environment. The file name must have a .s at the end. Let's assume that you have created the following program called hello.s by using NotePad on a PC. The file hello.s contains the source code of the program to print out a character string "hello world". We will use QtSpim to open and execute this program so that you can see the program output.
##
## hello.s - prints out "hello world"
##
## $a0 - points to the string
##
#################################################
# #
# text segment #
# #
#################################################
.text
.globl __start
__start: # execution starts here
la $a0,str # put string address into a0
li $v0,4 # system call to print
syscall # out a string
li $v0,10 # Exit
syscall # Bye!
#################################################
# #
# data segment #
# #
#################################################
.data
str: .asciiz "hello world\n"
##
## end of file hello.s
Now let's analyze the program and see how it works.
Analyze the Program
The MIPS assembly language program using QtSpim is usually held in
a file with .s at the end of the file name.
For example hello.s.
This file is processed line by line by the SPIM program.
In this file,
A sharp sign # is used to begin inline comments.
i.e. Everything from the # to the end of the line is
ignored by the assembler.
An identifier is a sequence of alphanumeric characters,
underbars/underscores(_),and dots(.) that does not begin with a number.
A label is declared by putting identifiers at the beginning of a line
followed by a colon. For example: str:
An operation field contains either a machine instruction or
an assembler directive.
One or more operands are required by some machine instructions.
Assembler directives may also require operands.
A constant is a value that does not change during program assembly
or execution. A string contant is delimited by double quotes(").
For example: "Hello World\n"
The program hello.s prints out the message hello world.
It sets up the string in the data segment and makes a system call to
print out this string in the text segment,
followed by a system call to exit the program.
.text
- a directive which tells the assembler to place
what follows in the text segment.
.globl __start
__start:
- These two lines attach the label __start
to the first instruction so that the assembler
can identify where the execution should begin.
All the exercises in the lab will have these two
lines unchanged.
.data
- a directive which tells the assembler what is in the memory.
Start up QtSpim
You can start up QtSpim by clicking on the icon
on the desktop or from the "Start" menu on a lab PC.
The following screen is what you will see.
Close it and reopen it.
Open and Run a Program
To open a program,
click on the "File" menu from QtSpim screen,
select "Reinitialize and Load File"
and find the program that you want to open.
Then click on the "run" button.
Then you should be able to see the output in the Console window.
If you wish to run the program again, click on the "Simulator" and then click on "Clear Registers" and then click on the "Run" button.
I/O Manipulation - MIPS System Calls (syscall)
SPIM provides a set of operating-system-like services through the system call (syscall) instructions. Basic input and output can be managed and implemented by system calls.
To request a service, a program loads the system call code into register $v0 and arguments into registers $a0, $a1, $a2, and $a3.
Here is a summary of the system calls for your reference.
Call Code
Service in $v0 Arguments Results
===========================================================================
Print Integer 1 $a0=number
(to be printed)
Example Code:
li $a0, 89
li $v0, 1
syscall
---------------------------------------------------------------------------
Print Float 2 $f12=number
(to be printed)
Example Code:
l.s $f12, flabel
li $v0, 2
syscall
.data
flabel: .float 3.14
---------------------------------------------------------------------------
Print double 3 $f12=number
(to be printed)
Example Code:
l.d $f12, dlabel
li $v0, 3
syscall
.data
dlabel: .double 3.1415926
---------------------------------------------------------------------------
Print String 4 $a0=address
(of string in memory)
Example Code:
la $a0, str1
li $v0, 4
syscall
.data
str1: .asciiz "Hi There!"
---------------------------------------------------------------------------
Read Integer 5 number in $v0
Example Code:
li $v0, 5
syscall
move $t0, $v0 # save the entered number
---------------------------------------------------------------------------
Read Float 6 number in $f0
Example Code:
li $v0, 6
syscall
---------------------------------------------------------------------------
Read double 7 number in $f0
Example Code:
li $v0, 7
syscall
---------------------------------------------------------------------------
Read String 8 $a0=address
(of input string in memory)
$a1=length of buffer(n bytes)
Example Code:
la $a0, str1
li $a1, 80
li $v0, 8
syscall
.data
str1: .space 80
---------------------------------------------------------------------------
Sbrk 9 $a0=n-byte address in $v0
(Dynamically (to allocate)
allocate n-byte
of memory) Example Code:
li $a0, 80
li $v0, 9
syscall # Get memory
move $a0, $v0
li $a1, 80
li $v0, 8
syscall # Read String
li $v0, 4
syscall # Print String
---------------------------------------------------------------------------
Exit 10 Example Code:
li $v0, 10
syscall
---------------------------------------------------------------------------
A Few Special Characters
Character Escape ======================= Newline \n Tab \t Double Quote \"
MIPS Reference Card
Lab Assignment
Copyright: Department of Computer Science, University of Regina.