SE250:lab-2:hpan027

Lab Report

• Is it just me or does this lab take forever?

1.

#include <stdio.h>

int main(void) {
    int* int_pointer;
    double* double_pointer;
    float* float_pointer;
    long* long_pointer;
    short* short_pointer;

    int int_variable;
    double double_variable;
    float float_variable;
    long long_variable;
    short short_variable;


    printf( "%d %d %d %d %d\n", sizeof(int_pointer), sizeof(double_pointer),
	    sizeof(float_pointer), sizeof(long_pointer), sizeof(short_pointer) );

    printf( "%d %d %d %d %d", sizeof(int_variable), sizeof(double_variable),
	     sizeof(float_variable), sizeof(long_variable), 
	     sizeof(short_variable) );
 
    return 1;
}

Returns (for both Windows and Linux)

4 4 4 4 4

4 8 4 4 2

From this we can see:

• All pointers are the same size, regardless of the variable type they point to
• Pointers and variables of type int, float and long share the same size
• Double variables are twice the size of pointers
• Short variables are half the size

2.

#include <stdio.h>

int main(void)
{
    int x;
    int y;

    printf( "&x = %p, &y = %p, diff = %ld\n", &x, &y, (long)(&x - &y) );
    printf( "&x = %p, &y = %p, diff = %ld\n", &x, &y, ((long)&x - (long)&y) );

    return 1;
}

Output (Windows):

&x = 0x22cca4, &y = 0x22cca0, diff = 1

&x = 0x22cca4, &y = 0x22cca0, diff = 4

Output (Linux):

&x = 0xffa159dc, &y = 0xffa159d8, diff = 1

&x = 0xffa159dc, &y = 0xffa159d8, diff = 4

• It seems that putting (long) in front of both variables make C treat this purely as a numerical calculation, where the difference between two numbers is calculated
• Putting (long) in front of the whole expression make C take into consideration the type of the variable, hence they are calculated to be one "int" apart
• Linux seems to have a completely different set of memory addresses, but the difference remains the same

3.

Output with arr[4] (Windows):

&x = 0x22cca4, &y = 0x22cc9c, diff(bytes) = 8

size of array = 4

&arr = 0x22cca0, arr+4 = 0x22cca4, &arr[4] = 0x22cca4

Output with arr[4] (Linux):

&x = 0xffe709dc, &y = 0xffe709d4, diff(bytes) = 8

size of array = 4

&arr = 0xffe709d8, arr+4 = 0xffe709dc, &arr[4] = 0xffe709dc

• The size of the array is 4 bytes
• &arr is the address of the first element in the array
• arr+4 and &arr[4] refers to the same thing: the address 4 bytes from the first element in arr - which in this case is where the variable x is stored
• Difference between &x and &y is 8 bytes
• Again, the only difference with running Linux is the part of memory the variables are stored in

Output for arr[0] - arr[10] (Windows):

arr[0], diff (bytes) = 32
arr[1], diff (bytes) = 8
arr[2], diff (bytes) = 8
arr[3], diff (bytes) = 32
arr[4], diff (bytes) = 8
arr[5], diff (bytes) = 32
arr[6], diff (bytes) = 32
arr[7], diff (bytes) = 32
arr[8], diff (bytes) = 16
arr[9], diff (bytes) = 32
arr[10], diff (bytes) = 32

Output for arr[0] - arr[10] (Linux):

arr[0], diff (bytes) = 4
arr[1], diff (bytes) = 4
arr[2], diff (bytes) = 4
arr[3], diff (bytes) = 4
arr[4], diff (bytes) = 8
arr[5], diff (bytes) = 4
arr[6], diff (bytes) = 4
arr[7], diff (bytes) = 4
arr[8], diff (bytes) = 4
arr[9], diff (bytes) = 4
arr[10], diff (bytes) = 4

• The Linux results were initially very confusing
• Upon closer inspection of the memory addresses, it seems that arr is not always stored between x and y. In fact, the only time it is stored between x and y is when the size of the array if 4. For all other instances, x and y is stored consecutively and arr is moved to either before or after the pair
• Windows seems to dump arr between x and y regardless of the size of the array

4.2

Windows

&x = 0x403030, &y = 0x403020, diff(byte) = 16

• x and y are now global variables, and are stored in a completely different area of memory
• There is now also a greater gap between the two variables

Linux

&x = 0x10010a68, &y = 0x10010a6c, diff(byte) = -4

• Variable order swapped around
• Only 4 bytes apart - same as when they were local variables

4.3

Windows

&x = 0x403040, &y = 0x403020, diff(bytes) = 32
size of array = 4
&arr = 0x403030, arr+4 = 0x403034, &arr[4] = 0x403034
arr[4], diff (bytes) = 32

• Again, different area of memory
• 32 bytes in between (each variable seems to be taking 16 bytes of memory)

Linux

&x = 0x10010b38, &y = 0x10010b40, diff(bytes) = -8
size of array = 4
&arr = 0x10010b3c, arr+4 = 0x10010b40, &arr[4] = 0x10010b40
arr[4], diff (bytes) = -8

• Different area of memory
• No extra usage of memory
• Order reversed

Output for arr[0] - arr[10] (Windows):

arr[0], diff (bytes) = 32
arr[1], diff (bytes) = 32
arr[2], diff (bytes) = 32
arr[3], diff (bytes) = 32
arr[4], diff (bytes) = 32
arr[5], diff (bytes) = 32
arr[6], diff (bytes) = 32
arr[7], diff (bytes) = 32
arr[8], diff (bytes) = 32
arr[9], diff (bytes) = 32
arr[10], diff (bytes) = 32

• Windows seems to be pretty consistent here, with 32 bytes between x and y regardless of the size of the array

Output for arr[0] - arr[10] (Linux):

arr[0], diff (bytes) = -4
arr[1], diff (bytes) = -8
arr[2], diff (bytes) = -8
arr[3], diff (bytes) = -8
arr[4], diff (bytes) = -8
arr[5], diff (bytes) = -12
arr[6], diff (bytes) = -12
arr[7], diff (bytes) = -12
arr[8], diff (bytes) = -12
arr[9], diff (bytes) = -4
arr[10], diff (bytes) = -4

• When the length of the array is 0, arr[0] and y shares the same addresses - i.e. the array isn't allocated any memory
• For array length 1-8, the array is stored between x and y
• For array length 9-10, x and y are stored consecutively, and arr is shuffled to the end

5.

• p1 and p2 stores the address of q and r respectively

6.

Windows

sp = 0x22cc70(456)
sp = 0x22cc70(efg)
sp = 0x402000(tuvwxyz)
sp = 0x1062100(hijklmn)

• Parts of the string seems to have been lost with the first two instances. This is probably due to local variables not being retained after the function finishes running
• Also local, static and malloc uses different parts of memory as shown

Linux

sp = 0xffcb09a4(�þîÐ�)
sp = 0xffcb09a4(abcdefg)
sp = 0x10010cc4(tuvwxyz)
sp = 0x10011008(hijklmn)

• Local, static and malloc uses different parts of memory as in Windows
• For some reason the second local string is retained while the first is lost completely!?

Adding

strcpy( sp, "XXXXXXX");
printf( "sp X'd = %p(%s)\n", sp, sp);

to the code

Windows:

sp = 0x22cc70(456)
sp X'd = 0x22cc70(-0@)
sp = 0x22cc70(efg)
sp X'd = 0x22cc70(-0@)
sp = 0x402000(tuvwxyz)
sp X'd = 0x402000(XXXXXXX)
sp = 0xda2100(hijklmn)
sp X'd = 0xda2100(XXXXXXX)

• Can't seem to X the area of memory where the local variable was stored

Linux:

sp = 0xffa399a4(�þîÐ�)
sp X'd = 0xffa399a4(XXXXXXX)
sp = 0xffa399a4(abcdefg)
sp X'd = 0xffa399a4(XXXXXXX)
sp = 0x10010db0(tuvwxyz)
sp X'd = 0x10010db0(XXXXXXX)
sp = 0x10011008(hijklmn)
sp X'd = 0x10011008(XXXXXXX)

• Can seem to X the area of memory where the local variable was stored

7.

Output (Windows):

&my_struct = 0x403020
offsets:
my_char: 0
my_short: -2
my_int: -4
my_long: -8
my_float: -12
my_double: -16

output (Linux):

&my_struct = 0x10010ac0
offsets:
my_char: 0
my_short: -2
my_int: -4
my_long: -8
my_float: -12
my_double: -16

• Identical offsets to Windows

8.

Windows:

&my_struct = 0x403020
offsets:
my_char: 0
my_short: 0
my_int: 0
my_long: 0
my_float: 0
my_double: 0

Linux:

&my_struct = 0x10010ab8
offsets:
my_char: 0
my_short: 0
my_int: 0
my_long: 0
my_float: 0
my_double: 0

• Unlike struct, there doesn't seem to be any space preallocated for each variable
• Linux and Windows have same output barring difference in memory address

9.

Windows:

*sp1 = 0xd920f0
*sp2 = 0xda2108
*sp3 = 0xd920f0

• An area of memory that's freed will be reused subsequently

Linux:

*sp1 = 0x10011008
*sp2 = 0x10011018
*sp3 = 0x10011008

• This is also the case for Linux

10.

Using the code from 6)

Windows:

local_str = 0x401050
sp = 0x22cc70(456)
sp X'd = 0x22cc70(=0@)
sp = 0x22cc70(efg)
sp X'd = 0x22cc70(=0@)
sp = 0x402000(tuvwxyz)
sp X'd = 0x402000(XXXXXXX)
sp = 0xda20f8(hijklmn)
sp X'd = 0xda20f8(XXXXXXX)

• Seems to be somewhat close to where the static variables are stored

Linux:

local_str = 0x100004dc
sp = 0xffe8f9a4(0123456)
sp X'd = 0xffe8f9a4(XXXXXXX)
sp = 0xffe8f9a4(abcdefg)
sp X'd = 0xffe8f9a4(XXXXXXX)
sp = 0x10010df0(tuvwxyz)
sp X'd = 0x10010df0(XXXXXXX)
sp = 0x10011008(hijklmn)
sp X'd = 0x10011008(XXXXXXX)

• Near static variables and malloc space

Hpan027 15:56, 11 March 2008 (NZDT)