Here are the new partnerships. The course webpage has a section on expectations for working with partners.

---

Lab 5 Goals:

• To translate C program fragments to IA32 assembly code, and to test the IA32 translation in a real program.
• To understand the mechanics of passing pointers in C (i.e. pass by reference).
• To practice using gdb to debug at the assembly code level.

Contents:

• Getting Starting Point Code
• Part 1
• Part 2
• Extra Challenge
• Submitting

---

Getting Starting Point Code

Both you and your partner should:

1. On the CS system, cd into your cs31/labs subdirectory

   cd ~/cs31/labs
   

2. Get your Lab5 ssh-URL from the GitHub server for our class: CS31-s18
3. Clone a local copy of your shared repo in your private cs31/labs subdirectory:

   git clone [your_Lab5_URL]
   

You should see the following files in your repo:

Makefile       sum.s                sumtester.c
QUESTIONNAIRE  sum_C_goto_version   swap.s
compare.s      comparetester.s      swaptester.c

For more detailed instructions see the the using git guide.

For part 1 you will act like a compiler and generate IA32 instructions for part of a C program. In the file named sum.s finish the IA32 assembly code implementation of the function with this C implementation:

// this function computes the sum of the first x positive int values
// x: the top of the range of values to sum
// returns: the sum of the values 0 to x inclusive
int sum(int x) {
  int res, i;
  res = 0;
  for (i=1; i <= x; i++) {
    res = res + i;
  }
  return res;
}

sumtester.c makes use of the sum function. When you run make, it will build an executable, sumtester, that links in the assembly code you wrote in sum.s. Use this executable to test your solution for correctness.

• You are required to submit a C goto translation of the sum function. This should go in the sum_C_goto_version file. You are not required to compile your C goto version, but you can to verify that your translation is correct.
• The basic stack set-up and return code is provided for you in sum.s, including space for the two local variables res and i.
• The parameter value, x, is already copied onto the stack for you, and is in the caller's stack frame. Its value can be accessed relative to the %ebp pointer at ebp + 8:

  esp ---->    # sum's stack frame:
  
  
    ebp-0x8    # space for one local variable (for res or for i)
    ebp-0x4    # space for one local variable (for the other one)
  ebp ---->
               # main's stack frame:
    ebp+0x8:   # space for the parameter (x)
  

  Note: 8 and 0x8 are the same value. But be careful about the number representation you are using for literal values--be sure that you are using the value you think you are (e.g. 10 and 0x10 are not the same value).
• The return value must be stored in register %eax right before the leave, ret instruction sequence.
• Comment your IA32 instructions with what they are doing in terms of the C code. As an example:

  movl 0x8(%ebp), %eax   # load x into R[%eax] 
  addl $1, %eax          #  x + 1
  

• General purpose registers %eax, %ecx, %edx are the ones you can use in your IA32 version of sum.

  Tips:

• Draw a picture of the stack, showing where parameter and argument values are as you trace through the IA32 instructions.
• Implement and test incrementally. For example, first see if you can add code to return the value of the parameter. Next, try returning some function of the parameter (like x + 10).
• Use gdb (or ddd) to debug your solution. Set a breakpoint in sum, and use disass, ni, and print $reg to see values as you go. If you want to see the value referred to by an address, you need to tell gdb what type the address points to. For example, if you want to see an int value at address 0x1234, do:

  # re-cast address as an int pointer (int *), then dereference the pointer *
  (gdb) print *(int *)(0x1234)
  

  Or:

  # examine the value at 0x1234 as a decimal number
  (gdb) x/d 0x1234
  

• Look in sumtester.c to see how sum is called.
• Use the IA32 Cheatsheet.

For this problem you will again act like a compiler and translate a C function into IA32 assembly code. In compare.s you should finish implementing the compare function, which conditionally changes the value of the int pointed to by x to the value of y.

void compare(int *x, int y);

This function takes one int pointer, x, and one int, y. If the int pointed to by x is greater than y, it should be set to y. Otherwise, it should be unchanged by the call. A call to compare might look like this:

int a, b;
a = 10;
b = 8;
printf("%d %d\n", a, b);  // prints: 10 8
compare(&a, b);           // changes a's value to b's if a > b
printf("%d %d\n", a, b);  // prints: 8 8  (a's value was changed to b's)
a = 3;
b = 11;
printf("%d %d\n", a, b);  // prints: 3 11
compare(&a, b);           // changes a's value to b's if a > b
printf("%d %d\n", a, b);  // prints: 3 11  (a's value wasn't changed to b's)

The compare.s file already contains IA32 instructions that set up and tear down the function's stack frame.

testcompare.c contains code to test your implementation. Run make to build an executable, testcompare, that links in your compare.s solution and calls it. Use this to test your solution for correctness.

• The parameter values of x and y are on the stack in the caller's stack frame. They can be accessed relative to the %ebp pointer:

  esp ----> # compare's stack frame:
  
  ebp ---->
               # main's stack frame:
    ebp+0x8:   first parameter value  (x)
    ebp+0xc:   second parameter value (y)
  

• Comment your IA32 instructions.
• Start by figuring out what the C code version of compare would look like. Then convert it to a C goto version. You don't need to submit the the goto version this time.
• Design and test incrementally.

(This is not a required part of the lab assignment. Do not attempt this until you have successfully completed the other two parts.)

As extra practice with pointer parameters, try implementing swap in IA32:

/*
 *  swap: exchange the values pointed to by x and y
 *     x: a pointer to one int value
 *     y: a pointer to another int value
 */
void swap(int *x, int *y);

Implement the function in swap.s. Look at swaptester.c to see how it might be used.

There is a QUESTIONNAIRE file for you to fill out and submit with your lab solution. Your answers to the questionnaire will not affect your grade.

Only one member of your partnership needs to git push your solution before the deadline. We will grade sum.s, sum_C_goto_version, and compare.s. If you do the extra challenge we will also grade swap.s.