1

Bitwise Operators

2

Bits and Constants

3

Bitwise Operators

Bitwise "and" operator & Bitwise "or" operator | Bitwise "exclusive or" operator ^ Bitwise "ones complement" operator ~

4

Expression Representation Value

a 00000000 00000000 10000010 00110101 33333

b 11111111 11111110 11010000 00101111 -77777

a & b 00000000 00000000 10000000 00100101 32805

a ^ b 11111111 11111110 01010010 00011010 -110054

a | b 11111111 11111110 11010010 00111111 -77249

~ ( a | b ) 00000000 00000001 00101101 11000000 77248

~ a & ~ b 00000000 00000001 00101101 11000000 77248

Representations

• int a = 33333, b = -77777;

The value of each bit is determined only by the bit(s) in its position

5

Expression Representation Action

c 00000000 00000000 00000000 01011010 unshifted

c << 4 00000000 00000000 00000101 10100000 left shifted 4

a 10000000 00000000 00000000 00000000 unshifted

a >> 3 11110000 00000000 00000000 00000000 right shifted 3

b 10000000 00000000 00000000 00000000 unshifted

b >> 3 00010000 00000000 00000000 00000000 right shifted 3

Representations

char c = 'Z';

int a = 1 << 31; /* shift 1 to the high bit */

unsigned b = 1 << 31;

For signed data types bit positions vacated by shifting is filled with a copy of the highest (sign) bit for signed data type

6

Left Shifts

short a = 0x68ab;

...

a <<= 3; /* shift left 3 bits */

Same as: a = a << 3;

http://www.harpercollege.edu/bus-ss/cis/166/mmckenzi/lect19/l19e.htm

Bits positions vacated by shift are filled with zeros

7

Right Shifts (Unsigned)

unsigned short a = 0x98ab;

. . .

a >>= 5; /* shift right 5 bits */

http://www.harpercollege.edu/bus-ss/cis/166/mmckenzi/lect19/l19e.htm

For unsigned data type, bits positions vacatedby shift are filled with zeros.

8

Right Shifts (Signed)short a = 0x98ab;

. . .

a >>= 5; /* shift right 5 bits */

http://www.harpercollege.edu/bus-ss/cis/166/mmckenzi/lect19/l19e.htm

Bit positions vacated by shifting is filled with a copy of the highest (sign) bit for signed data type

9

Right Shifts (Signed)short a = 0x78ab;

. . .

a >>= 5; /* shift right 5 bits */

http://www.harpercollege.edu/bus-ss/cis/166/mmckenzi/lect19/l19e.htm

Bit positions vacated by shifting is filled with a copy of the highest (sign) bit for signed data type

10

Implementation Note x<<n is equivalent to multiplication by 2n.

x>>n is equal to x/2n

Shifting is much faster than actual multiplication (*) or division (/)==> Multiplications / divisions by powers of 2 should be implemented using shifts.

0x00010x00020x00040x00080x00100x00200x0040 0000000001000000

0000000000000001

0000000000000010

0000000000000100

0000000000001000

0000000000010000

0000000000100000

11

int main(void){int num=0;do{

printf("Enter an integer:\n");scanf("%d", &num);bit_print(num);putchar('\n');

} while (num!=0);return 0;

}

Printing the bits of an integer

Prints the binary representation of an integer. E.g:00000000 00000000 00000000 00000111(MSB) (LSB)

12

#include <limits.h>void bit_print(int a) { int i; int n = sizeof(int) * CHAR_BIT; /* #define CHAR_BIT 8 (in <limits.h>)*/ int mask = 1 << (n - 1); /* mask = 100...0 */

for (i = 1; i <= n; ++i) {

putchar(((a & mask) == 0) ? '0' : '1');

a <<= 1;

if (i % CHAR_BIT == 0 && i < n) putchar(' ');

}}

n is the number of bits in an integer

Prints the most significant bit of a

Prints a space between the bytes

(condition) ? (if true) : (if false)if (a&mask == 0) putchar(`0`);else putchar(`1`);

i % 8 == i & 7

13

Pack 4 chars into an int#include <limits.h>

int pack( char a, char b, char c, char d ){

int p = a;

p = (p << CHAR_BIT) | b;p = (p << CHAR_BIT) | c;p = (p << CHAR_BIT) | d;return p;

}

p = 0 0 0 a p = 0 0 a 0 0 0 0 b 0 0 a b

p = 0 a b 0 0 0 0 c 0 a b c

p = a b c 0 0 0 0 d a b c d

Most significant Least significant

14

Unpack a byte from an int

#include <limits.h>

char unpack( int p, int k )

{

unsigned mask = 0xFF;

int n = k * CHAR_BIT;

mask <<= n;

return ( ( p & mask ) >> n );

}

k = 0, 1, 2 or 3k = 0, 1, 2 or 3

n = 0, 8, 16 or 24n = 0, 8, 16 or 24

kth byte is onkth byte is on

15

Operators Associativity

() [] . -> ++(postfix) --(postfix) left to right

+(unary) -(unary) ++(prefix) --(prefix) ! sizeof(type) &(address) *(dereference) ~

right to left

* / % left to right

+ - left to right

<< >> left to right

< <= > >= left to right

== != left to right

& left to right

^ left to right

| left to right

&& left to right

|| left to right

?: right to left

= += -= *= /= &= >>= etc right to left

,(comma operator) left to right

Operator precedence and associativity - final look

(a+b << 12*a >> b) is equivalent to (((a+b)<<(12*a))>>b)

16

Software Project:Rehearsal

17

Overview Rehearsal on selected topics in C

Stack (automatic) vs. Heap (dynamic) arrays vs. pointers structures Binary tree example (including function

pointers) Macros (preprocessor)

Sample exam questions Additional examples and topics

18

Storage organization

Attempting to access an address outside the allocated partition (segment) of the program - a segmentation error (access violation) and core dump (only unix/linux).

The program stack grows for each function call

19

Runtime Stack Activation records

(0) - inactive

(1) - inactive

(2) - active

20

Arrays, Pointers and Strings

a b c d e \0p

21

Arrays

void f1(){ ANY_TYPE a[10]; int b[] = {1,2}; char c1[] = {‘a’,’b’,’c’}; char c2[] = “abc”; printf(“%d %d %d %d \n”, sizeof(a), sizeof(b), sizeof(c1), sizeof(c2));}

Automatic allocation – on stack De-allocated automatically Overall size is given by sizeof()

Q: Assume sizeof(ANY_TYPE) = 5, sizeof(int)=4, sizeof(char)=1 What is the output of f1()?

A: 50 8 3 4

sizeof() is an operator that computes the size in bytes. It is evaluated at compile time.

constant expression (compilation time)

22

Pointers and pointed values (1)

#include <stdio.h>

int main(){ int a = 10, b = 2; int *p1, *p2; p1 = &a; p2 = &b; printf("%d %d \n", *p1, *p2); printf("%p %p \n", p1, p2); return 0;}

0012FF7C

a: 100012FF78

b: 2

p1: p2:

0012FF7C 0012FF78

type = pointer.Prints a value of a pointer as an hexadecimal integer

23

Pointers

pointer = address in memory Pointer definition: ANY_TYPE *p

ANY_TYPE: primitive types (char, int,...), structs, pointers,...

* operator – returns the pointed memory (the type of *p is ANY_TYPE) *p == p[0]

& operator = returns the address (pointer). p == &(*p)

24

Pointers and pointed values (2)

#include <stdio.h>

int main(void){

int i = 42, j=17, *ptr;

ptr = &i;

*ptr = 1;

ptr = &j;

*ptr = 2;

printf ("The value of i is %d\n", i);

printf ("The value of j is %d\n", j);

return 0;

}

0012FF7C

i: 420012FF78

j: 17

ptr:

0012FF7C0012FF78

1 2

$%@#%

25

Pointer initialization

void f1(){ char *p; *p = ‘a’; .....}

p is not initialized p contains “garbage”p may point to any memory address (legal / illegal)

void f2(int *a){ char *p; p = (char*)a; .....}

void f4(){ char *p; p = (char *)malloc(...); .....}

void f3(){ char c, *p; p = &c; .....}

X

assignment between any two pointers (using cast)

Dynamic allocation - on heap - no automatic de-allocation

26

Pointers arithmetic

Q: If a pointer p contain the value x (address), what is the value of p+1?

A: depends on the type of p (ANY_TYPE *) => x+sizeof(ANY_TYPE)

p[n] == *(p+n)

27

Pointers vs. Arrays Same arithmetic:

int a[10] *(a+2) == a[2] (no check of index boundaries, e.g. a[-1]) Pointers can point to elements in an array

Example: int a[10]; int *p = a; // p points to a[0] Pointers and arrays are not the same:

Pointer Array

Allocation malloc etc. – on heap. Any size.

On definition (automatic) - on stack. Size must be known at compilation

De-allocation Explicit command (free) Automatic

Constant inite.g. a = {1,2,3}

Disallowed Allowed - on declaration

Pointer / array Assignment (a = b)

Allowed Disallowed

sizeof Fixed pointer size (no relation to pointed memory)

Overall array size

28

Example: printing the bytes of an integer

void print_bytes(int n){int i;char *pc = (char *)&n;

for (i=0; i < sizeof(int); i++, pc++){printf(“%d “,*pc);

}printf(“\n”);

}

char char char charint

Use sizeof(int) for portability.

29

Multidimensional Arrays

int a[3][4];int i, j;

&a[i][j] = a[i]+j = (int *)a+i*4+j

int a[3][4];int i, j;

&a[i][j] = a[i]+j = (int *)a+i*4+j

C has only one-dimensional arrays:

(i,j) (i,j)<=>

Dimensions are known at compilation.

30

Dynamic matrix allocation (1) Q: What if the matrix dimensions are

unknown at compilation? A: use pointers and dynamic allocation

The matrix can be ragged – i.e. rows can have different sizes.

int i;int **a = malloc(n*sizeof(int*));for (i=0; i <n; i++)

a[i] =malloc(m*sizeof(int));

int i;int **a = malloc(n*sizeof(int*));for (i=0; i <n; i++)

a[i] =malloc(m*sizeof(int));

a

31

Dynamic matrix allocation (2)

Allocating an nm matrix using 2 allocationsint **allocate_matrix(int n, int m){ int i; int **a = malloc(n * sizeof(int *)); int *p = malloc(n * m * sizeof(int)); /* get the space all at once */ for (i = 0; i < n; i++, p+=m) a[i] = p; return a;}

a

p

32

Strings

char *p = “abcde”;

a b c d e \0

char s[] = “abcde”;

a b c d e \0

s:

* Constant string “abcde” is kept somewhere1. Allocates a memory for pointer p2. Initializes p to the base address of “abcde”

Allocates and initializes 6 bytes for the arrays

p

33

Allocating memory for strings

All strings have a terminating '\0' character. Add 1 to the count that strlen return when calling

malloc

char *somestring=“1234”, *copy;copy = (char *) malloc(strlen(somestring) + 1); /* +1 for \0 */ /* check malloc's return value */ strcpy(copy, somestring); int strlen(char s[]){

int i =0; while (s[i] != ‘\0’) ++i; return i;}

34

Structs with Arraystypedef struct soldier {

int id; char name[64]; char *rank;} Soldier;

int main(){ Soldier s0, s1, s2 = {5705706, "Enzo Agada", "General"};

s0.id = 5705705; strcpy(s0.name, "John Doe"); /* incorrect: s0.name = "John Doe"; */ s0.rank = "Captain"; /* incorrect: strcpy(s0.rank, "Captain"); */ s1 = s0; printf("%d %s %s\n", s0.id, s0.name, s0.rank); printf("%d %s %s\n", s1.id, s1.name, s1.rank); printf("%d %s %s\n", s2.id, s2.name, s2.rank);}

5705705 John Doe Captain 5705705 John Doe Captain 5705706 Enzo Agada General

35

Verifying allocated memory malloc may fail to allocate memory - returns a null

pointer upon failure. It is vital to check the returned pointer before

using it!! (even if the requested memory size is small)

int *ip = (int *) malloc(10000000 * sizeof(int)); if (ip == NULL) { printf("ERROR: out of memory\n"); return -1;

}

36

(Heap) Memory de-allocation

Memory free == memory recycling Avoiding memory leaks:

Keep track of the allocated memory For every malloc there should be a corresponding free

The one who allocates is the one who frees free - a non-expensive function (allocating memory is more

expensive) Any allocated memory is automatically released upon exit by

the operating system. However, it is a coding standard to free the memory that you don’t need as soon as possible.

37

Accessing de-allocated memory (1)

De-allocated memory should not be access! De-allocated heap-memory is immediately usable

for next memory allocation. After calling free(p); p still points at the same

memory Do not use the memory pointed to by p after

free(p);

while (ptr != NULL) { free(ptr); ptr = ptr->next;

}

Illegal reference to deallocated memory.Unknown results...

38

Accessing de-allocated memory (2)

Local variables (stack memory) are de-allocatedautomatically on the return of their function

char *wrong_allocate(){ char s[] = "123"; return s;{char *valid_allocate(){ char* s1 = "456"; char* s = malloc(strlen(s1)+1); strcpy(s,s1); return s; }int main(int argc, char ** argv){ printf("%s %s \n",wrong_allocate(), valid_allocate());{

s points to a memory on stack, which is freed when the function returns

39

Memory leaks

Memory leak = Non-reachable, non-freed allocated memory.

In java / c#: the garbage collector frees “memory leaks”

void f(){ int *p = malloc(10*sizeof(int));}

The memory pointed by p remains allocated. However there is no way to access it.

40

realloc

accepts an old pointer and a new size Attempts to allocate memory in the original position.

If the size of the old block can be changed - the same pointer is returned.

otherwise, it Attempts to allocate new memory. If successful:

Copies old data to new memory Frees old memory block Returns new pointer

Otherwise, returns NULL (no free of ip)

int ip = malloc(10*sizeof(int);...... ip = realloc(ip, 200 * sizeof(int));

41

Example: Sorted binary tree

typedef struct node {

int value;

struct node * right;

struct node * left;

} Node;

node_ptr->value;

(*node_ptr).value;

equivalent

value

value value

Left Right

struct node { int value; struct node * right; struct node * left; };typedef struct node Node;

equivalent

42

Node allocation and initialization

Node *create_node(int value){ Node * tmp = (Node *) malloc(sizeof(Node)); if (!tmp) { fprintf(stderr, "ERROR: not enough memory!\n"); return NULL; } tmp->left = tmp->right = NULL; tmp->value = value; return tmp;}

Returns a new node1. Allocate memory for the new node.

3. Initialize node’s fields

2.Verify allocation

43

Inserting new values to an existing treeNode * insert(Node * root, int value){

Node * parent, *child, *new_node; new_node = create_node(value); if (!new_node) return NULL; if (!root) return new_node; child = root; do{ parent = child; if (child->value > value) child = child->left; else child = child->right; } while (child); if (parent->value > value) parent->left = new_node; else parent->right = new_node; return root;}

2

3

5

7

9

4

parent

4

new_node root

Create the new node

44

Traversing a binary tree (inorder)

void print_tree(Node *root)

{

if (!root) return;

print_tree(root->left);

printf("%d ", root->value);

print_tree(root->right);

}Printing the right subtree (recursive call)

Print the value of the current node.

Printing the right subtree (recursive call)

L R

P

Null Null Null Null

empty tree – do nothing

45

Example: pointer to a function

Suppose we want to perform operations on the tree nodes – using our tree traversal function, E.g. printing the nodes

Pass a traversal function a pointer the desired function

void print_node(Node * node){ printf("%d ", node->value);}

prints the value of a node

traverse_tree(root, print_node);

46

Example: pointer to a function (2) Define the type of the functions that the traversal

function can get

typedef void(Op)(Node *);

parameters typeReturn value

Data type name, which can be used to define variables / parameters

void traverse_tree(Node * root, Op * op){

if (!root) return;

traverse_tree(root->left, op);

op(root);

traverse_tree(root->right, op);

}

Invocation of the function (passed as argument op)

47

Reminder: Things you can do with structures...

Define data types of structures Declare variables of structure type Assign entire structures Pass as arguments to functions Define functions which return structures Initialize a structure variable (comma-separated list of

values enclosed in braces {})

typedef struct node Node;

node1 = node2

Node node;

Node node = {0,NULL, NULL};

48

Additional notetypedef struct node {

struct node * right; struct node * left; int value;

char *name;} Node;

void f(){Node *new_node;new_node = create_node(value);new_node->name = malloc(100);....free(new_node->name); free(new_node) ;

}

Every allocated field of a struct must be deallocated – before the struct itself is deallocated

49

Macros (preprocessor)gcc -E: runs only the preprocessor and writes to standard output. E.g.: gcc -E a.c > aa.c

50

Macros

Macros are not functions Even when written with all the parentheses

#define MAX(a,b) (((a)>(b)) ? (a) : (b))

int a[4];int biggest;

biggest = x[0];i = 1;while (i < 4) biggest = MAX(biggest, x[i++]);

#define MAX(a,b) (((a)>(b)) ? (a) : (b))

int a[4];int biggest;

biggest = x[0];i = 1;while (i < 4) biggest = MAX(biggest, x[i++]);

This code would have worked fine if MAX was a function

51

Macros

Let’s expand the macro:

#define MAX(a,b) (((a)>(b)) ? (a) : (b))

int a[4];int biggest;

biggest = x[0];i = 1;while (i < 4) biggest = (biggest > x[i++]) ? biggest : x[i++];

#define MAX(a,b) (((a)>(b)) ? (a) : (b))

int a[4];int biggest;

biggest = x[0];i = 1;while (i < 4) biggest = (biggest > x[i++]) ? biggest : x[i++];

52

Macros

Macros are not statements Lets try to write the assert macro

assert(x > y); /* should print info only if x <= y */

#define assert(e) if (!(e)) assert_error(__FILE__,__LINE__)

assert(x > y); /* should print info only if x <= y */

#define assert(e) if (!(e)) assert_error(__FILE__,__LINE__)

if ((x > 0) && (y > 0)) assert(x > y);else assert(y > x);

if ((x > 0) && (y > 0)) assert(x > y);else assert(y > x);

This macro is not safe:

53

Macros

assert(x > y); /* should print info only if x <= y */

#define assert(e) { if (!e) assert_error(__FILE__,__LINE__) }

assert(x > y); /* should print info only if x <= y */

#define assert(e) { if (!e) assert_error(__FILE__,__LINE__) }

if ((x > 0) && (y > 0)) { if (!(x > y)) assert_error(__FILE__,__LINE__) };else { if (!(y > x)) assert_error(__FILE__,__LINE__) };

if ((x > 0) && (y > 0)) { if (!(x > y)) assert_error(__FILE__,__LINE__) };else { if (!(y > x)) assert_error(__FILE__,__LINE__) };

This will solve the dangling else problem but will cause a problemwith the semicolon:

We can try and add braces:

The correct solution is:

#define assert(e) ((void)((e) || assert_error(__FILE__,__LINE__)))

#define assert(e) ((void)((e) || assert_error(__FILE__,__LINE__)))

54

Sample Exam Questions

int main(void){ int a=1,b=2, c=3; what_happens(&a, &b, &c); printf("a=%d b=%d c=%d\n", a, b, c); return 0;

}void what_happens(int *a, int *b, int *c){

c = a; a = b; b = c;

printf("*a=%d *b=%d *c=%d\n", *a, *b, *c); return;}

a: b: c:

in what_happens:

0012FF7C

0012FF78 0012FF780012FF7C

0012FF78

0012FF8C0012FF7C

Printed 2 1 1

Question 1a: What is the output?

0012FF7C 0012FF78

b: 2

in main:

0012FF8C

c: 3a: 1

Printed 1 2 3

int main(void){ int a=5,b = 7; int* c = do_balagan(&a, &b); printf("In main:\na=%d b=%d *c=%d\n", a, b, *c); return 0;}

int* do_balagan(int* a, int* b){ int* c; c = b; b = a; a = c; *a = *a + 5; *b = *a + *b; printf("In balagan:\n*a=%d *b=%d *c=%d\n", *a, *b, *c); return c;}

0012FF7C

a: 50012FF78

b: 7

in main:

12

a: b: c:

in do_balagan:

0012FF7C

0012FF78 0012FF780012FF7C

0012FF78

17

Question 1b: What is the output?

57

real

image

1

2

c1:

real

image

3

5

c2:

1+2*2

abs2 = ((c2.image*c2.image)

+(c2.real*c2.real)) =34

abs1 = ((c1.image*c1.image)+(c1.real*c1.real)) =5

Reminder: the preprocessor performs textual substitutions before compilationQuestion 2: What is the output?

58

1st invocation:initial: a=2, count =0;final: count = 1*2 = 2;

2nd invocation:initial: a=2, count = 2;final: count =3*2 = 6;

Question 3: What is the output?

59

Pointer to the next entry

If it is the end of a word increment the count

If there is no space after the last word

Question 4: -Is the code valid? If no - why?-If yes - What does it do?(isspace returns 1 iff the given character is a white space)C

What happens if strlen(s)=0? (i.e. s==`\0`)

60

Access to a freed pointer!!!

Question 5: -Is the code valid? If no - why?-If yes - What does it do?

61

Exam Grading (previous semester)

62

Good Luck in the exam!

(30.03.2008)

63

Additional Examples and topics

64

getline() function - Description

Implement a function int getline(char line[], int max); Description: Reads from standard input into a given line array

till new-line, end-of-file, the given array is filled.If newline was reached – it is not copied into the given array.

line – the given array to be filled (output parameter) max – the size of the given array (i.e. maximal characters to

read) Return value = line length

0 – for empty line EOF – for end-of-file (and nothing was read)

65

getline() function - Usage

#include <stdio.h>#include <stdlib.h>

#define MAX_LINE 80

int main(){ char line[MAX_LINE]; getline(line, MAX_LINE); printf("%s\n", line); return 0;}

Define a fixed size array and pass it to the getline function

The getline function reads a line and we print it

66

int getline(char line[], int max){ int nch = 0, c; max = max - 1; while ( ( (c = getchar()) != EOF) && (c != '\n') && (nch<max) ){

line[nch] = c; nch++; } if (c == EOF && (nch == 0)) return EOF; line[nch] = '\0'; return nch;}

getline() function – Implementation

Reserve a place for ‘\0’

May happen when stdout is redirected to a text file.

67

getline() –Usage (dynamic allocation)int main(){

char * line; int linelen; printf("Specify the sentence length:\n"); scanf("%d", &linelen); if (linelen <= 0) { printf("ERROR: line length must be positive!\n"); return 1; } line = (char *) malloc(linelen); if (line == NULL) { printf("ERROR: out of memory!\n"); return 1; } flushall(); printf("\nPlease type your sentence:\n"); getline(line, linelen); printf("\nYou typed:\n%s\n",line);

return 0;}

You could have written:line = (char *) calloc (linelen, sizeof(char));

malloc() – allocates the required amount of bytes.

calloc() – allocates and initializes to zero bytes.

68

Searching for Substrings – Impl.

/* Finds out whether a given array appears as a sub array in another */

int * find_sub_array(int * array, int size, int * sub_array, int sub_size) {

int i, j; for (i = 0; i++ <= size - sub_size; ++array) { for (j = 0; j < sub_size; ++j){ if ( *(array + j) != sub_array[j]) break;

} if (j == sub_size) return array; } return NULL;}

Counter “i” is used to validate that we are still within the array boundaries. Note that i is incremented only after the condition i<=size-sub_size is evaluated

69

Searching for Substrings - Usage

#include <stdio.h>int main(){ int array1[] = {1, 45, 67, 1001, -19, 67, 89, 1004, -867, 34, 3, -1900,

10029, 34, 3, -1900}; int array2[] = {34, 3, -1900}; int * position; int offset = -1; position = find_sub_array(array1, sizeof (array1) / sizeof (int), array2, sizeof (array2) / sizeof(int)); if (position != NULL)

offset = position - array1 + 1; printf("array2 appears in array1 starting from place : %d.\n", offset); return 0;}

70

Dangling else

The meaning was two cases: x = 0 and x != 0 However else is associated with the closest unmatched if.

if (x == 0) if (y == 0) error();else { z = x + y; f(z);}

if (x == 0) if (y == 0) error();else { z = x + y; f(z);}

if (x == 0) if (y == 0) error(); else { z = x + y; f(z); }

if (x == 0) if (y == 0) error(); else { z = x + y; f(z); }

71

Dangling else

Always use curly braces ‘{}’ with if-else statements

if (x == 0) { if (y == 0) error();} else { z = x + y; f(z);}

if (x == 0) { if (y == 0) error();} else { z = x + y; f(z);}

72

Using CORE dumps

On Unix (including Linux) a process is usually killed if it access memory incorrectly This usually happens due to pointers going mad

and bad Before the process is killed important

information on why it was killed is saved in a core file This information can be used to pinpoint what

went wrong

73

Using CORE dumps

#include <stdlib.h>

int main() { int* i = NULL;

*i = 5; /* This will cause a core dump in Unix/Linux */

return 0;}

#include <stdlib.h>

int main() { int* i = NULL;

*i = 5; /* This will cause a core dump in Unix/Linux */

return 0;}

Lets look at this faulty program (test.c) that tries to access a NULL pointer

Running this program yields the expected error message:Segmentation fault (core dumped)

74

Using CORE dumps

To use the core dump the program must be compiled with debug information.

This is done by adding –g flag to the gcc compilation line For example: gcc –g test.c –o myTest

(Make sure that your core file was generated while running the program compiled with debug information before continuing to the next step - you may need to run the program again after adding flag)

gdb <program executable> coreorddd <program executable> core

gdb <program executable> coreorddd <program executable> core Graphical

Non graphical

75

Using CORE dumps

nova~> gdb myTest coreGNU gdb Red Hat Linux (5.2-2)Copyright 2002 Free Software Foundation, Inc.Core was generated by `./myTest'.Program terminated with signal 11, Segmentation fault.Reading symbols from /lib/i686/libc.so.6...done.Loaded symbols for /lib/i686/libc.so.6Reading symbols from /lib/ld-linux.so.2...done.Loaded symbols for /lib/ld-linux.so.2#0 0x080483d0 in main () at test.c:66 *i = 5;(gdb) where#0 0x080483d0 in main () at test.c:6#1 0x42017589 in __libc_start_main () from /lib/i686/libc.so.6(gdb)

nova~> gdb myTest coreGNU gdb Red Hat Linux (5.2-2)Copyright 2002 Free Software Foundation, Inc.Core was generated by `./myTest'.Program terminated with signal 11, Segmentation fault.Reading symbols from /lib/i686/libc.so.6...done.Loaded symbols for /lib/i686/libc.so.6Reading symbols from /lib/ld-linux.so.2...done.Loaded symbols for /lib/ld-linux.so.2#0 0x080483d0 in main () at test.c:66 *i = 5;(gdb) where#0 0x080483d0 in main () at test.c:6#1 0x42017589 in __libc_start_main () from /lib/i686/libc.so.6(gdb)

Your command line

The gdb analysis of the core