CS 367 HW #4
Due April 15 at classtime

1. Consider the given C array declarations (and sizes from Fig 3.1 of your text).

   double A[50];
   int B[10][50];
   char C[10][20][5];
   

   • What is the size (in bytes) of each array?
   • Assuming these three arrays are allocated row-major contiguously (and in the given order) starting at address 100, what is the starting address of each array?

     What is the address of the following elements:

     • A[40]
     • B[2][10]
     • C[2][15][1]
   • Give IA32 code that loads B[i][j] into register %eax. Assume the following:

     Register	holds:
     %edx	&B
     %ecx	i
     %ebx	j

2. Consider the following datatype definitions on an IA32 (x86) machine.

   typedef struct {				typedef union {		
      char c;					   char c;
      double *p;					   double *p;
      int i;					   int i;
      double d;					   double d;
      short s;					   short s;
   } struct1;					} union1;
   

   • Using the template below (allowing a maximum of 32 bytes), indicate the allocation of data for a structure of type struct1. Assume data sizes as given in figure 3.1 of your text. Mark off and label the areas for each individual element (there are 5 of them). Cross hatch the parts that are allocated, but not used (to satisfy alignment). Assume the alignment rules discussed in lecture: data types of size x must be aligned on x-byte boundaries (i.e. with memory addresses divisible by x). Clearly indicate the right hand boundary of the data structure with a vertical line.

       0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
     |                                                                                               |
     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
     

   • Give the offset that would be used for each field in struct1.

   • If we define the fields of struct1 in a different order, we can reduce the number of bytes wasted by each variable of type struct1. What is the number of unused, allocated bytes in the best case?

   • How many bytes are allocated for an object of type union1?

3. In the following problem, you are given the task of reconstructing C code based on some declarations of C structures and unions, and the IA32 assembly code generated when compiling the C code. Use the same size and alignment assumptions as question 1. Below are the data structure declarations. (Note that this is a single declaration which includes several data structures; they are shown horizontally rather than vertically simply so that they fit on one page.)

   struct s1 {			struct s2 {			union u1 {
      char a[3];			   struct s1 *d;		   struct s1 *h;
      union u1 b;			   char e;			   struct s2 *i;
      int c;			   int f[4];			   char j;
   };				   struct s2 *g;		};
   				};
   
   

   You may find it helpful to diagram these data structures before considering the code below.

   For each IA32 assembly code sequence below on the left, fill in the missing portion of corresponding C code on the right.

   • proc1:                                int proc1(struct s2 *x) {
        pushl %ebp
        movl %esp,%ebp                         return x->____________________
        movl 8(%ebp),%eax
        movl 12(%eax),%eax                  }
        movl %ebp,%esp
        popl %ebp
        ret
     

   • proc2:                                 int proc2(struct s1 *x) {
        pushl %ebp
        movl %esp,%ebp	                     return x->________________
        movl 8(%ebp),%eax
        movl 4(%eax),%eax                   }
        movl 20(%eax),%eax
        movl %ebp,%esp
        popl %ebp
        ret
     

   • proc3:                                  char proc3(union u1 *x) {
        pushl %ebp
        movl %esp,%ebp                           return x->___________________
        movl 8(%ebp),%eax
        movl (%eax),%eax                     }
        movsbl 4(%eax),%eax
        movl %ebp,%esp
        popl %ebp
        ret
     

   • proc4:                                  char proc4(union u1 *x) {
        pushl %ebp
        movl %esp,%ebp                           return x->_________________
        movl 8(%ebp),%eax
        movl (%eax),%eax                      }
        movl 24(%eax),%eax
        movl (%eax),%eax
        movsbl 1(%eax),%eax
        movl %ebp,%esp
        popl %ebp
        ret