Objectives

to give you experience writing MIPS assembly code
to give you experience with functions in MIPS
to give you experience with data and control structures in MIPS

Background

A common sight in shops is a grid of LEDs where text scrolls across the grid, something like …The aim of this assignment is to complete a MIPS program that can scroll alphabetic text strings like the
above video.

Setting Up

Create a private directory for doing the assignment, and put the assignment files in it by running the
following command:
$ u n z i p / h o m e / c s 1 5 2 1 / w e b / 1 8 s 2 / a s s i g n m e n t s / a s s i g n 1 / a s s i g n 1 . z i p
If you’re working on this at home, download the ZIP file and create the files on your home machine. It’s
fine to work on your own machine but remember to always test your code on the CSE machines before
submitting.
The above command will create the following files:
Makefile
A file to control compilation of scroll.c. It is not critical for the MIPS assembler part: it creates the
executable C program to give you an exemplar, and can produce the exe.s file.
scroll.c
A complete solution, written in C. Your goal is to write a MIPS assembler program to copy the
behaviour of this program.
chars.h
The array of big characters used in producing the scrolling text. This is #include’d in scroll.c.
scroll.s
A partly complete solution to the assignment, written in MIPS assembler.
chars.s
A MIPS version of the array of big characters used in producing the scrolling text. This file requires
no modification.
Initially, it would be worth compiling the C program and running it on some examples to get a feel for its
behaviour. The compiled C program, called scroll, expects a single command-line argument: the text
string to be scrolled.
You can compile and run the C program (scroll) as follows:

The Program

What the scrolling program should do, whether implemented in MIPS or C:
check the command-line argument (< 100 chars, only letters and spaces)
create a buffer containing big versions of the characters in argv[1]
add part of the content of the big-char buffer into the display buffer, starting at starting_pos
write the contents of the display buffer to standard output
repeat, moving one column to the left each time, until the message scrolls of the left of the display
Both the C and the MIPS programs are structured the same, with a main function to handle the
command-line arguments and then run the scrolling. The programs also have the same set of lowerlevel
functions. In scroll.c, there are comments describing the purpose of each function and the code
is hopefully clear enough that you can understand how each function works.
The diagram below shows the major data structures used by the programs:
theString[100] holds a copy of the string from argv[1]
bigString[9][1000] holds a copy of theString in big characters and with one column of space
between adjacent big characters
display[9][80] is where characters are placed before being written out to the screen
all_chars[52*9*9] array containing representation of ‘A’-‘Z’ and ‘a’-‘z’ as big chars (not shown in
the diagram; defined in the chars.s file)

Exercise

The aim of this exercise is to complete the supplied MIPS program skeleton (in the file scroll.s) to
behave exactly like the C program (in scroll.c). You should not change the chars.s file; treat its
contents as a read-only data structure.
In scroll.s each function has comments to:
indicate which registers the function uses
indicate which registers the function overwrites (clobbers)
give a mapping between local variables in the C code and registers in MIPS
Note that these are suggestions only; you can use whatever registers you like, provided that you save
and restore any $s? registers that you overwrite in the function code. And, of course, provided that the
code behaves the same as the C code.
To save you some time, we have included function prologues and epilogues in some functions. These
save and restore registers $fp, $ra, and any $s? registers that the function happens to use, and also
maintain the stack. You can use these as templates for how to implement the prologue and epilogue in
the functions that do not provide them.
Some of the functions from scroll.s are already implemented, but others require you to write MIPS
assembler for them. Here’s a rundown of the functions in scroll.s and their status:
main Partly complete, including the epilogue and prologue, and the command-line
argument checking.
setUpDisplay Function prologue and epilogue ok. ToDo: function body.
showDisplay Function prologue and epilogue ok. ToDo: function body.
delay Already complete, but you can tweak the numbers if you want, to speed up or
slow down the animation.
isUpper ToDo: function prologue and epilogue, and function body.
isLower Already complete (and makes isUpper very easy).