CS 367 HW #4

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?
  A - 50 elements * 8 bytes = 400 bytes
  B - 10 elements * 50 elements * 4 bytes = 2000 bytes
  C - 10 elements * 20 elements * 5 elements * 1 bytes = 1000 bytes
- 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?
  A starts at 100
  B starts at 500
  C starts at 2500
  What is the address of the following elements:
  - A[40]
    100 + 40*8 = 420
  - B[2][10]
    500 + 2*200 + 10*4 = 940
  - C[2][15][1]
    2500 + 2*100 + 15*5 + 1*1 = 2776
- Give IA32 code that loads B[i][j] into register %eax. Assume the following:
  
  Register holds:
  
  %edx &B
  
  %ecx i
  
  %ebx j
  
  Several ways to do this. Remember that B[i][j] will be found at start + i*4*50 + j*4
```
leal (,%ebx,4),%ebx                   -- ebx has j*4
imull $200,%ecx                       -- i*200
addl %ecx,%ebx                        -- i*200+j*4
movl (%edx,%ebx),eax			
```
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
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|c |xxxxxxxx|     p     |     i     |xxxxxxxxxxx|           d           |  s  |                 |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
                                                                              |
```
- Give the offset that would be used for each field in struct1.
  c has offset 0, p has offset 4, i has offset 8, d has offset 16, and s has offset 24
- 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?
  If we place d first followed by p, i, s and c, this will take 19 bytes
- How many bytes are allocated for an object of type union1?
  8, the size of the largest field (which is double).

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];	0		   struct s1 *d;	0	   struct s1 *h;	0
   union u1 b;	4		   char e;		4	   struct s2 *i;	4
   int c;	8		   int f[4];		8	   char j;		8
};				   struct s2 *g;	24	};
				};

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

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->f[1];  }
   movl 8(%ebp),%eax -- get x (struct ptr)
   movl 12(%eax),%eax  -- add offset 12 to address of x, this indexes to the second array element             
   movl %ebp,%esp
   popl %ebp
   ret

proc2:                                 int proc2(struct s1 *x) {
   pushl %ebp
   movl %esp,%ebp	                     return x->b.i ->f[3]    }
   movl 8(%ebp),%eax  -- get x (struct ptr)
   movl 4(%eax),%eax    -- load union value (offset 4)               
   movl 20(%eax),%eax   -- assuming pointer to struct2 (offset too big for struct1), use offset 20 to get to last element in f
   movl %ebp,%esp
   popl %ebp
   ret

proc3:                                  char proc3(union u1 *x) {
   pushl %ebp
   movl %esp,%ebp                           return x->i->e   }
   movl 8(%ebp),%eax  -- get x (union ptr)
   movl (%eax),%eax    -- treat x as pointer - load element                
   movsbl 4(%eax),%eax  -- load a character - struct s2 has character at offset 4
   movl %ebp,%esp
   popl %ebp
   ret

proc4:                                  char proc4(union u1 *x) {
   pushl %ebp
   movl %esp,%ebp                           return x->g->d->a[1]; }
   movl 8(%ebp),%eax  -- get x (union ptr)
   movl (%eax),%eax    -- treat x as pointer - load element                  
   movl 24(%eax),%eax  -- load from s2 at offset 24 
   movl (%eax),%eax   -- this is a pointer to s2 - load element                  
   movsbl 1(%eax),%eax  -- load a character - struct s1 has character at offset 1
   movl %ebp,%esp
   popl %ebp
   ret

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