CS 2731 Recitation 13

(Textbook. Click for information.)

CS 2733/2731
Computer Organization II
Fall 2004
Recitation 13
Exception Handling
    Week 13: Nov 15-19
Due (on time): 2004-11-24  23:59:59
Due (late):        2004-11-28  23:59:59

Recitation 13 must be submitted following directions at: submissions on or before

2004-11-24 23:59:59 (that's Wednesday, 24 November 2004, 11:59:59 pm) for full credit.
2004-11-28 23:59:59 (that's Sunday, 28 November 2004, 11:59:59 pm) for 75% credit.

Outline: In this laboratory you will explore exception handling in MIPS. Note: It may help you with this recitation to look over and work on the Take-Home Quiz, which is due in class, Monday, 29 November 2004, for full credit.

Make a new directory for the assignment.
Download the following files:
- The test program instructions.s ( .html)
- The default exception handler exceptions.s ( .html, .pdf (on one sheet) )
Execute the instructions.s program under spim:
```
      spim -file instructions.s
```
The program should generate six exceptions labeled with [Bad data address] (Exception 7) because the program assumes that the data segment starts at 0 and xspim assumes that it starts at 0x10010000.
Run the instructions.s program again using xspim and this time single step through at least two exceptions. Make sure you see how the flow of control is changed by looking at the source code and note where the exceptions occur.
```
      xspim -file instructions.s
```
Modify instructions.s to a MIPS program instr_good.s by changing two instructions so that it runs correctly. (The program should form the sum A[0] + A[1] + ... + A[8] = 0 + 1 + 2 + ... + 8 = 36 and print this number. Make no further use of the file instr_good.s below.)
Alter the file exceptions.s by changing the message for exception 7, for example, change [Bad data address] to [BAD DATA ADDRESS] (with all upper-case). This means you change what is at the label __e7_:.
At the end of the test program instructions.s, concatenate the default handler code exceptions.s. You could use the following Unix command for this:
```
     cat instructions.s exceptions.s > instr_excep.s
  
```
Run xspim using the following command line. (Don't forget the -notrap option, or Spim will load both the default handler and the one you concatenated at the end.) The program should run as before, except that you will get the new exception 7 message that you edited in: [BAD DATA ADDRESS].
```
     xspim -notrap -file instr_excep.s
```
You can also try out spim:
```
     spim -notrap -file instr_excep.s
```
The program should run the same way it did before, except with the altered exception 7 message.
Now edit the exception handler exceptions.s so that it handles a bad data address exception (Exception 7) as follows. (If you wish you can just directly edit the file instr_excep.s, say, to produce a file instr_excep_fixed.s.)
- Print a special new message indicating that you are adjusting for exception 7.
- Add 0x10010000 to $t1.
- Restart the current instruction. (Note: Restart the current instruction, not the next instruction as the current handler does.)
When you run the program you should only get two Exception 7 occurrences at the instructions:
```
        lw      $t4, 84($t1)    #Constant 4 stored in $t4

           ....
        sw      $t3, 0($t1)     #sum is stored
```
Your altered exception handler should handle these exceptions so that the correct calculation is performed and a 36 is printed at the end.
Hints:
- You may need to do a lot of single-stepping to debug.
- You may want to use addu when adding addresses so that you don't generate an overflow exception.
- Be very careful not to use any registers in your exception handler that you haven't explicitly saved in kernel static memory. It is best to just use the register $a0 for all your work.
- Note that when the exception error message is printed by the handler, register $k0 holds the exception number 7, but it is shifted 2 positions to the left, so that $k0 actually holds 28 = 0x1c = 11100 (base 2).
- You should NOT modify the original code instructions.s at all. The original bad data address references should remain. All modifications occur in the edited handler. This is the whole idea of this recitation: to show that you could fix a problem with code using the exception handler.
- To "add 0x10010000 to $t1", you can do a lui of 0x1001 into $a0, and then add $a0 into $t1.

What you should submit: Refer to the submissions directions and to deadlines at the top of this page. The text file that you submit should first have Your Name, the Course Number, and the Recitation Number. The rest of the file should have the following in it, in the order below, and clearly labeled, including at the beginning the appropriate number 1-4.

Contents of submission for Recitation 13:
Last Name, First Name; Course Number; Recitation Number (13).

Code for the revision of the original MIPS program: instr_good.s.
Results of a run with instr_good.s.
Code for the original program instructions.s, along with the revision of the exception handler: instr_excep_fixed.s.
Results of a run with instr_excep_fixed.s.
Special Note: In class I acted as if you could use spim on the Sun machines if you wanted to (the old version), but I've changed my mind. You must use the spim on the Linux machines, or on your own machine unless you have an old version. The code for exceptions.s will not run on the Sun machines.

Revision date: 2004-11-19. (Please use ISO 8601, the International Standard.)