CSE 378 Homework 4

Due: Wednesday 1/29/03
Work in pairs or individually

Purpose

An Aside on Mechanics: Your "Build Environment"

$ cebasm fact.s

$ java asm.parser fact.s

If you want to run at home, you'll need at least to install Cebollita - see the Cebollita documentation. You might also want to install Cygwin (which I recommend in any case) - www.cygwin.com - and you'll need a relatively up-to-date version of the Java runtime - jre V1.4.0_03. To set up the aliases as in the lab, create a file named .profile in your Cygwin home directory (type cd in the Cygwin shell and you're in the home directory) with these contents. Even if this sounds complicated, you should be able to manage it, with a little effort. Install Cebollita first - it could be that it will simply work on your machine.

(Note: Cebollita is written in Java, and so you should be able to run it on a non-lab machine, even if that machine is running Linux or, say, Mac OS X.)

Introduction

 1  # compute the factorial of 9 using the following algorithm
 2  #   N = 9
 3  #   result = 1
 4  #   while (N != 0) {
 5  #     result = result * N
 6  #     N = N - 1
 7  #   }
 8
 9  .data                                   # begin data section
10  msg:    .asciiz  "The factorial is: "   # message string
11
12  .text                           # begin program text
13  __start:
14          addi    $sp, $sp, -4            # make some space on the stack
15          addi    $t0, $0, 1              # $t0 will hold result, initially 1
16          addi    $t1, $0, 9              # $t1 will hold N, initially 9
17  top:    beq     $t1, $0, bottom
18          mult    $t0, $t0, $t1           # result = result * N
19          addi    $t1, $t1, -1            # decrement N
20          j       top                     # goto top
21  bottom:
22          sw      $t0, 0($sp)             # we'd better save result
23          addi    $v0, $0, 4              # finished w/ loop, now print out
24          addi    $a0, $gp, msg           # message, by invoking syscall 4
25          syscall                         # (print_string)
26
27          addi    $v0, $0, 1              # now print out result, by 
28          lw      $a0, 0($sp)             # invoking syscall 1 (print_int)
29          syscall
30
31          addi    $sp, $sp, 4             # reset the stack
32          addi    $v0, $0, 10             # exit syscall
33          syscall

Assembling/Linking Your Program

1. Start a BASH shell - on the lab machines, Start/Program Files/Desktop Tools/cse378/ceb. If all goes well, you'll have a UNIX like command prompt. Most of your UNIX skills should be applicable at this command prompt.
2. Assemble the program. In your Cygwin window, use the cd command to navigate to the directory where you put fact.s. Then, at the prompt type: cebasm fact.s
3. If this step was successful, you should find a file called fact.o has been produced in that directory. (You can type ls to find out.)
4. Link the program. Now type ceblink fact.o. This should create a file called a.out.

Other useful tools are the object-file inspector and executable inspector. Typing cebdumpm fact.o should dump interesting information about the object file. Typing cebdumpe a.out should dump interesting information about the executable.

Using the Simulator: Instructions and Questions

1. You'll first want to read over the document, Cebollita MIPS Simulator.

2. Start the simulator (cebsim a.out ought to do it), and run it by single-stepping through it.
3. Complete the following table by examining various registers and memory location contents after the appropriate instructions are executed. Using the breakpoint command may help in certain situations.

   Location	Line 16	Line 19 3rd iteration	Line 19 5th iteration	Line 19 8th iteration	Line 24
   $t0
   $t1
   0($sp)

4. In total, how many instructions (in the simulator) are executed to calculate the factorial of 9? The right way to answer this question is not to step the program through 9 loops and count instructions, but rather determine how many instructions are exectuted before the loop, during one iteration of the loop, and after the loop. Then you can give us an answer in terms of N, where N is the value we're calculating the factorial of (as well as the number of times the loop iterates).

Assembly Programming: Modifications

Compilers

1. Compile: cebcc hw4.c. This will create a file called hw4.s.
2. Now assemble hw4.s (as above).
3. In the earlier exercise, at this point you would link the hw4.o file to create an executable. But, linking is a little trickier now, because hw4.c makes references to printInt(), printString() and exit(), which are simple functions that wrap up the associated system calls. (If we try to link at this point, with ceblink hw4.o, we'll get an error. Try it and see what kind of error you get.)
4. These functions are, of course, just software. They're defined in a file called syscall.s. Download this file and assemble it into an object file - syscall.o.
5. Now you're ready to build an executable. Link the two object files (hw3.o and syscall.o) as follows: java asm.Linker hw3.o syscall.o. This should produce an executable (a.out).

__start() {
  int N = 9;
  int result = 1;
  while (N != 0) {
    result = result * N;
    N = N - 1;
  }
  printString("The factorial is: ");
  printInt(result);
  exit();
}

__start() {
  printString("Please enter a number: ");
  int x = readInt();
  if (x < 0) {
    printString("Your number is negative.\n");
  }
  else {
    printString("Your number is non-negative.\n");
  }
  exit();
}

Deliverables