CPR E 381x/382x

Exception Handling and the PCSpim Simulator

1. Objectives

In this lab you will explore how a processor handles exceptions. Since exception handling on the Power PC is fairly complex, we will begin our exploration with the PCSpim simulator.

1.1 Reference Files for Lab

Lab evaluation form

2. Prelab

Review assembly language. In these next labs, we will be moving away from the lower level Verilog programming and focusing on C and assembly language programming. Remember that PCSpim uses a version of the MIPS assembly language.

Look over the PCSpim guide in Appendix A of the Hennessy and Patterson textbook, available on the CD and also online here. Specifically section A-7 will serve as the guide for this lab.

3. Setup

Create the folder in your home directory U:\CPRE381\Lab08a to save all your work from this lab.

4. Exceptions in PCSpim

Exceptions in the MIPS architecture are handled by special hardware called co-processor 0. PCSpim simulates the functionality of co-processor 0 by providing a subset of the registers used by co-processor 0. These registers can be read using the mfc0 instruction and written to using the mtc0 instruction.

The co-processor 0 registers provided by PCSpim are listed below.

Also provided by PCSpim is a default exception handler, “trap.handler”. This file is located in c:/program files/PCSpim. Next we will open this file and try to understand what it is doing in the context of a small example.

5. Bad Data Address Exception

Consider the following assembly program below, the purpose of which is to try to read a bad address:

.text

main:

li $8, 0x80000000 #not a data address at all

lw $9, 0($8) #but we try to read it anyway J

#infinite loop

loop:

j loop

.end

Load this program into PCSpim, run it, and observe the results. Note the message that prints to the console window.

Now try stepping through the program (open the file, then press f10 to step). Notice the value of the PC after the lw instruction. This is the first line of the exception handler given in trap.handler. Open trap.handler (you can just use word pad), and read through it as you step through the code in PCSpim. The comments are very good, so you should be able to understand what it is doing.

The default handler prints out only the exception number and type, but often it is useful to give more information. For example, when a bad address is generated, it would be nice to know the PC value of the offending instruction, as well as the bad address that was generated.

Modify the exception handler to print out the PC of the exception generating instruction. Also, for bad data address exceptions print out the bad address that was generated. Save your new handler as newtrap.handler. You can load a new exception handler file by clicking on simulator, then settings… Your new output should look something like this:

Exception 7 [Bad data address] occurred

Exception generated at PC: 4194344

Tried to read address: -2147483648

(Note: numbers are printed as signed decimals. Brownie points will be awarded if you can figure out a way to print them in hexadecimal)

Hints:

You will have to access co-processor 0 registers 8 and 14.
You may use registers $v0 and $a0 however you want, since these have already been preserved in the default trap handler.
You may add new messages to the .kdata section at the beginning of the exception handler (__m3_, __m4_ etc.)

When you are done show your TA your output.

6. Overflow Exception

Write an assembly program that generates an arithmetic overflow exception. Modify your exception handler so that it prints out the number of the two registers that, when added together, generated the exception (assume that the instruction producing the overflow was R-type). Show your TA your output when you are done.