This lab should be done with your partner:

Here are the Lab 5 partner lists.

Expectations for Working with Partners

---

Lab 5 Goals:

• To translate C program fragments to IA32, and test the IA32 translation in a real program.
• To understand the mechanics of C "pass-by-reference" style parameters.
• To practice using gdb to debug at the assembly code level.

Contents:

• Getting Starting Point Code
• Assignment Part 1 IA32 Loop, Part 1 Requirements and Hints
• Assignment Part 2 IA32 C-style pass by reference, Part 2 Requirements and Hints
• Extra Problem (not required) IA32 swap function
• Lab Questionnaire
• Submitting your Lab

---

Lab 5 Starting point code:

Both you and your partner should do:

1. Get your Lab05 ssh-URL from the GitHub server for our class: CS31-F17
2. On the CS system, cd into your cs31/labs subdirectory

   cd ~/cs31/labs
   

3. Clone a local copy of your shared repo in your private cs31/labs subdirectory:

   git clone [your_Lab05_URL]
   

   Then cd into your Lab05-you-partner subdirectory.

If all was successful, you should see the following files when you run ls:

If this didn't work, or for more detailed instructions see the the Using Git page.

As you and your partner work on your joint solution, you will want to push and pull changes from the master into your local repos frequently.

For this part, you will act like a compiler and generate IA32 instructions for part of a C program. In the file named loop.s finish the implementation of the following function in IA32:

// 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 loop(int x) {
  int res, i;
  res = 0;
  for(i=1; i <= x; i++) {
    res = res + i;
  }
  return res;
}

In mainloop.c is a main program that makes a call to this function. If you run make, you can build an executable, mainloop, that links in your loop.s solution. Use this to test your solution for correctness.

• You are required to submit your C-goto translation of the loop in part1. In the file loop_C_goto_version enter your C goto translation of the loop function. You are not required to compile your C goto version, but you can try doing so to test that your translation is correct.
• The basic stack set-up and return code is provided for you in loop.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 the caller's stack frame. Its value can be accessed relative to the %ebp pointer at ebp + 8:

  esp ---->    # loop'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 ones you can use in your IA32 version of loop.

  Help:

• Draw a picture of the stack, draw where parameter and argument values are and trace through the instruction execution to help you determine what IA32 instructions you need to use to implement loop.
• Try implementing and testing 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).
• You can use gdb (or ddd) to debug your solution. Set a breakpoint in loop, 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) *(int *)(0x1234)
  

  Look at the week 6 Wednesday lab page and in-lab examples for how to use gdb to examing code at the IA32 instruction level.
• look in mainloop.c for the call to your loop function to help you see how it is called.
• The IA32 Cheatsheet is available at the bottom of the class webpage: Resources

For this problem you will also act like a compiler and generate IA32 code translation for part of a C function. In the file named compareA.s, finish the IA32 implementation of the compareA function that conditionally changes the value of the int pointed to by x to the value of y.

void compareA(int *x, int y);

This function takes one int, x, passed by reference (the parameter points to the storage location of its argument), and one int, y, passed by value. 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 compareA would look like (see mainCompareA.c for another example):

int a, b;
a = 10;
b = 8;
printf("%d %d\n", a, b);  // prints: 10 8
compareA(&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
compareA(&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 compareA.s file already contains some IA32 instructions that set up up and tear down the stack frame associated with the function. You will add IA32 instructions to the body of this IA32 function to perform the compareA operation.

In mainCompareA.c is code to test your implementation. Run make to build an executable, mainCompareA, that links in your compareA.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 ---->    # compareA's stack frame:
  
  ebp ---->
               # main's stack frame:
    ebp+0x8:   first parameter value  (&a)
    ebp+0xc:   second parameter value (b)
  

• 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
  

• Start by figuring out what the C code version of compareA would look like. Then convert it to a C goto version.
• Draw a picture of the stack, draw where parameter and argument values are and trace through the instruction execution to help you determine what IA32 instructions you need to use to implement compareA.
• Design and test incrementally. See if you can get the compareA function to compare a's value to b without the conditional part first. Once that works, then try adding in the conditional part.
• Look at your lecture notes about pointer variables and IA32 functions.

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, you can try implementing a swap function in IA32:

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

In the swap.s file implement your function, and look at the swaptester.c program for how it calls to your swap function. Your solution to Part 2 should help you with this.

With every lab assignment is a file named QUESTIONNAIRE for you to fill out and submit with your lab solution. In this file you will answer some questions about the lab assignment. You should fill this out and submit it with your lab solution.

Before the Due Date

Only one of you or your partner needs to push your solution from one of your local repos to the GitHub remote repo. (it doesn't hurt if you both push, but the last pushed version before the due date is the one we will grade, so be careful that you are pushing the version you want to submit for grading):

From one of your local repos (in your ~you/cs31/labs/Lab05-partner1-partner2 subdirectory)

git push

Troubleshooting

If git push fails, then there are likely local changes you haven't committed. Commit those first, then try pushing again:

make clean
git add * 
git commit
git push

Another likely source of a failed push is that your partner pushed, and you have not pulled their changes. Do a git pull. Compile and test that your code still works. Then you can add, commit, and push.

If that doesn't work, take a look at the "Troubleshooting" section of the Using git page. You may need to pull and merge some changes from master into your local. If so, this indicates that your partner pushed changes that you have not yet merged into your local. Anytime you pull into your local, you need to check that the result is that your code still compiles and runs before submitting.