CMPSC 311- Introduction to Systems Programming Module: Arrays and Pointers

Size: px

Start display at page:

Download "CMPSC 311- Introduction to Systems Programming Module: Arrays and Pointers"

Benjamin Palmer
6 years ago
Views:

1 CMPSC 311- Introduction to Systems Programming Module: Arrays and Pointers Professor Patrick McDaniel Fall 2014

2 Course notes Exam moved to Oct 1, 2014 Assignment #3 introduction section This Thur (9/25) 112 Walker Doughnuts! Late policy is up to 4 days Page

size sizeof(scores) is not reliable; only works in some situations recent versions of

3 Arrays type name[size]; int scores[100]; example allocates 100 ints worth of memory initially, each array element contains garbage data an array does not know its own size sizeof(scores) is not reliable; only works in some situations recent versions of C allow the array size to be an expression int n=100; int scores[n]; // OK in C99 Page 3

than the array size, fills rest with 0 name[index] = expression; sets the value of an array

4 Initializing and using arrays type name[size] = {value, value,..., value; allocates and array and fills it with supplied values if fewer values are given than the array size, fills rest with 0 name[index] = expression; sets the value of an array element int primes[6] = {2, 3, 5, 6, 11, 13; primes[3] = 7; primes[100] = 0; // smash! // 1000 zeroes int allzeroes[1000] = {0; Page 4

$) int val[3] = { 5, 5, 5 ; printf( "val [%d, %d, %d]\n", val[0], val[1], val[2] ); int$ $val1[3] = { 0 ; printf( "val1 [%d, %d, %d]\n", val1[0], val1[1], val1[2] ); int val2[3] = { 1$ $.. 2] = 1 ; int val3[3] = {; printf( "val3 [%d, %d, %d]\n", val3[0], val3[1], val3[2] ); int$

5 Setting array values (cont.) int val[3] = { 5, 5, 5 ; printf( "val [%d, %d, %d]\n", val[0], val[1], val[2] ); int val1[3] = { 0 ; printf( "val1 [%d, %d, %d]\n", val1[0], val1[1], val1[2] ); int val2[3] = { 1 ; printf( // "val2 Best [%d, approach %d, %d]\n", to val2[0], init all val2[1], values val2[2] ); int val4[3] = { [0... 2] = 1 ; int val3[3] = {; printf( "val3 [%d, %d, %d]\n", val3[0], val3[1], val3[2] ); int val4[3] = { [0... 2] = 1 ; printf( "val4 [%d, %d, %d]\n", val4[0], val4[1], val4[2] ); [5, 5, 5] [0, 0, 0] [1, 0, 0] [0, 0, 0] [1, 1, 1] Page 5

6 Multi-dimensional arrays type name[rows][columns] = {{values,..., {values; allocates a 2D array and fills it with predefined values // a 2 row, 3 column array of doubles double grid[2][3]; // a 3 row, 5 column array of ints int matrix[3][5] = { {0, 1, 2, 3, 4, {0, 2, 4, 6, 8, {1, 3, 5, 7, 9 ; grid[0][2] = (double) matrix[2][4]; // which val? matrix.c Page 6

Arrays as parameters It s tricky to use arrays as parameters arrays are effectively passed by reference (not copied) arrays do not know their own size int sumall(int a[]); //

7 Arrays as parameters It s tricky to use arrays as parameters arrays are effectively passed by reference (not copied) arrays do not know their own size int sumall(int a[]); // prototype declaration int main(int argc, char **argv) { int numbers[5] = {3, 4, 1, 7, 4; int sum = sumall(numbers); return 0; int sumall(int a[]) { int i, sum = 0; for (i = 0; i <...??? Page 7

Arrays as parameters Solution 1: declare the array size in the function problem: code isn t very flexible int sumall(int a[5]); // prototype declaration int main(int argc, char **argv) { int

8 Arrays as parameters Solution 1: declare the array size in the function problem: code isn t very flexible int sumall(int a[5]); // prototype declaration int main(int argc, char **argv) { int numbers[5] = {3, 4, 1, 7, 4; int sum = sumall(numbers); return 0; int sumall(int a[5]) Note: the size is not enforced! int sumall(int a[5]) { int i, sum = 0; for (i = 0; i < 5; i++) { sum += a[i]; return sum; Page 8

$sumall(numbers, 5); printf("sum is: %d\n", sum); return 0; int sumall(int a[], int size) { int i, sum = 0; for (i = 0; i <= size; i++) { sum += a[i]; return sum; arraysum.c // CAN YOU SPOT THE BUG?$

9 Arrays as parameters Solution 2: pass the size as a parameter int sumall(int a[], int size); // Array passed by reference int main(int argc, char **argv) { int numbers[5] = {3, 4, 1, 7, 4; int sum = sumall(numbers, 5); printf("sum is: %d\n", sum); return 0; int sumall(int a[], int size) { int i, sum = 0; for (i = 0; i <= size; i++) { sum += a[i]; return sum; arraysum.c // CAN YOU SPOT THE BUG? Page 9

$functions int[] copyarray(int src[], int size) { int i, dst[size]; // OK in C99 for (i = 0; i < size; i++) { dst[i] = src[i]; return dst; // NO -- bug buggy_copyarray.$

10 Returning an array Local variables, including arrays, are stack allocated they disappear when a function returns therefore, local arrays can t be safely returned from functions int[] copyarray(int src[], int size) { int i, dst[size]; // OK in C99 for (i = 0; i < size; i++) { dst[i] = src[i]; return dst; // NO -- bug buggy_copyarray.c Page 10

11 Solution: an output parameter Create the returned array in the caller pass it as an output parameter to copyarray works because arrays are effectively passed by reference void copyarray(int src[], int dst[], int size) { int i; for (i = 0; i < size; i++) { dst[i] = src[i]; copyarray.c Page 11

12 OS and processes (redux) The OS lets you run multiple applications at once an application runs within an OS process the OS timeslices each CPU between runnable processes happens very fast; ~100 times per second! process 1 process 2 process N operating system Page 12

13 Processes and virtual memory OS gives each process the illusion of its own, private memory this is called the process address space contains the process virtual memory, visible only to it 32-bit pointers on 32- bit machine 64-bit pointers on 64- bit machine 0xFFFFFFFF" process address space" 0x " contains code, data, libraries, stack, etc. Page 13

14 Loading When the OS loads a program, it: creates an address space inspects the executable file to see what s in it (lazily) copies regions of the file into the right place in the address space does any final linking, relocation, or other needed preparation 0xFFFFFFFF" OS kernel [protected] stack shared libraries heap (malloc/free) read/write segment.data,.bss read-only segment.text,.rodata 0x " Page 14

15 Loading 0xFFFFFFFF" Process State/local variables OS kernel [protected] stack Code/Data for Libraries shared libraries Dynamic Data Static Data Code heap (malloc/free) read/write segment.data,.bss read-only segment.text,.rodata 0x " Page 15

return to local variables used by the function a few other pieces of bookkeeping int f(int p1, int p2) { int

16 The stack in detail Used to store data associated with function calls when you call a function, compiler-inserted code will allocate a stack frame to store: the function call arguments the address to return to local variables used by the function a few other pieces of bookkeeping int f(int p1, int p2) { int x; int a[3];... return x; offset! 24" 20" 16" 12" 8" 4" 0" contents! p2 p1 return address a[2] a[1] a[0] x a stack frame" Page 16

$h> int showstack( int i, int j ) { int k = 2; int32_t l[2]; printf( "i is at [%p], size [%lu], value [%d]\n", &i, sizeof(i), i ); printf( "j is at [%p], size [%lu], value [%d]\n", &j, sizeof(j), j );$

17 Stack example #include <stdio.h> #include <stdint.h> int showstack( int i, int j ) { int k = 2; int32_t l[2]; printf( "i is at [%p], size [%lu], value [%d]\n", &i, sizeof(i), i ); printf( "j is at [%p], size [%lu], value [%d]\n", &j, sizeof(j), j ); printf( "k is at [%p], size [%lu], value [%d]\n", &k, sizeof(k), k ); printf( "l is at [%p], size [%lu], value [%d]\n", &l[1], sizeof(l[1]), l[1] ); return( 0 ); int main( void ) { printf( "Hello world!\n" ); showstack( 3, 4 ); return( 0 ); Page 17

Stack example mcdaniel@ubuntu:~/tmp/helloworld$ make gcc showstack.

$.. int showstack( int i, int j ) { int k = 2; int32_t l[2];.$

18 Stack example make gcc showstack.c -o showstack Hello world! i is at [0x7fffe345f0ec], size [4], value [3] j is at [0x7fffe345f0e8], size [4], value [4] k is at [0x7fffe345f0fc], size [4], value [2] l is at [0x7fffe345f104], size [4], value [0] mcdaniel@ubuntu:~/tmp/helloworld$... int showstack( int i, int j ) { int k = 2; int32_t l[2];... int main( void ) { printf( "Hello world!\n" ); showstack( 3, 4 ); return( 0 ); Page 18

19 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 19

20 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 20

21 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 21

22 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 f p1, p2, x, a heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 22

23 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 f p1, p2, x, a heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 23

24 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 f p1, p2, x, a heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 24

25 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 f p1, p2, x, a g param heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 25

26 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 f p1, p2, x, a g param heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 26

27 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 f p1, p2, x, a g param heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 27

28 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 f p1, p2, x, a heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 28

29 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 f p1, p2, x, a heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 29

30 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 30

31 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 g param heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 31

32 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 g param heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 32

33 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack main argc, argv, n1 heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 33

34 The stack in action OS kernel [protected] int main(int argc, char **argv) { int n1 = f(3, -5); n1 = g(n1); int f(int p1, int p2) { int x; int a[3];... x = g(a[2]); return x; int g(int param) { return param * 2; stack heap (malloc/free) read/write segment globals read-only segment (main, f, g) Page 34

$c int main(int argc, char **argv) { int x, y; int a[2]; printf("x is at %p\n", &x); printf("y is at %p\n", &y); printf("a[0] is at %p\n", &a[0]); printf("a[1] is at %p\n", &a[1]);$

35 Addresses and & &foo produces the virtual address of foo #include <stdio.h> int foo(int x) { return x+1; addresses.c int main(int argc, char **argv) { int x, y; int a[2]; printf("x is at %p\n", &x); printf("y is at %p\n", &y); printf("a[0] is at %p\n", &a[0]); printf("a[1] is at %p\n", &a[1]); printf("foo is at %p\n", &foo); printf("main is at %p\n", &main); return 0; Page 35

Pointers type *name; // declare a pointer type *name = address; // declare + initialize a pointer a pointer is a variable that contains a memory address it points to somewhere in the process virtual

36 Pointers type *name; // declare a pointer type *name = address; // declare + initialize a pointer a pointer is a variable that contains a memory address it points to somewhere in the process virtual address space int main(int argc, char **argv) { int x = 42; int *p; // p is a pointer to an integer pointy.c p = &x; printf("x is %d\n", x); printf("&x is %p\n", &x); printf("p is %p\n", p); // p now stores the address of x return 0; Page 36

way is what I prefer int* p1; int *p2; // I prefer int* p1, p2; // bug?

37 A stylistic choice C gives you flexibility in how you declare pointers one way can lead to visual trouble when declaring multiple pointers on a single line the other way is what I prefer int* p1; int *p2; // I prefer int* p1, p2; // bug?; equivalent to int *p1; int p2; int* p1, * p2; // correct or int *p1, *p2; // correct, preferred Page 37

$// p now stores the address of x printf("x is %d\n", x); *p = 99; printf("x is %d\n", x);$

38 Dereferencing pointers *pointer // dereference a pointer *pointer = value; // dereference / assign dereference: access the memory referred to by a pointer #include <stdio.h> deref.c int main(int argc, char **argv) { int x = 42; int *p; // p is a pointer to an integer p = &x; // p now stores the address of x printf("x is %d\n", x); *p = 99; printf("x is %d\n", x); return 0; Page 38

39 & and * &foo // address of foo *pointer // dereference a pointer *pointer = value; // dereference / assign deref.c int x = 42; // x now contains the value 42 int *p; // p is a pointer to an integer p = &x; // p now contains the address of x printf("x is %d\n", x); *p = 99; // store 99 where p points to printf("x is %d\n"); Page 39

40 Something curious Let s try running this program several times: #include <stdio.h> asr.c int main(int argc, char **argv) { int x = 1; int *p = &x; printf("&x: %p; p: %p; &p: %p\n", &x, p, &p); return 0; [butler]>./asr &x: 0xbfa521dc; p: 0xbfa521dc; &p: 0xbfa521d8 [butler]>./asr &x: 0xbf836f5c; p: 0xbf836f5c; &p: 0xbf836f58 [butler]>./asr &x: 0xbfea39dc; p: 0xbfea39dc; &p: 0xbfea39d8 Page 40

tougher google disable linux address space randomization 0xFFFFFFFF 0x00000000 OS kernel [protected]

41 ASLR Linux uses address-space randomization for added security linux randomizes: base of stack shared library (mmap) location makes stack-based buffer overflow attacks tougher makes debugging tougher google disable linux address space randomization 0xFFFFFFFF 0x OS kernel [protected] stack shared libraries heap (malloc/free) read/write segment.data,.bss read-only segment.text,.rodata Page 41

CSE 333 Lecture 3 - arrays, memory, pointers

CSE 333 Lecture 3 - arrays, memory, pointers Steve Gribble Department of Computer Science & Engineering University of Washington Administrivia HW 0.5 (a 4-question survey) - out today, due Monday HW 1.0