Adv. UNIX: debug/141 Advanced UNIX v Objectives of these slides: –tools and techniques for debugging C code Special Topics in Comp. Eng. 1 Semester 2, Debugging

Adv. UNIX: debug/142 Overview 1. What is Debugging? 2. Catching Errors at Compile Time 3. Debugging with printf() 's 4. Conditional Compilation 5. assert() 6. gdb 7. Memory Leaks 8. More Information

Adv. UNIX: debug/ What is Debugging? v Debugging is the process of locating and removing errors. v It has been estimated that 85% of debugging time is spent locating errors and only 15% spent fixing them –tools that speed up locating are very useful

Adv. UNIX: debug/144 Common C Coding Mistakes v Array index out of bounds v Unintended side effects –e.g. a = b instead of a == b v Use of uninitialised variables  case fall-through in a switch continued

Adv. UNIX: debug/145 v Pointers (memory leaks)  Reversed logic in conditions e.g. x 5 v Macros v Unterminated comments

Adv. UNIX: debug/ Catching Errors at Compile Time  Use the -Wall option of gcc : $ gcc -Wall -o example example.c v Extra warnings include: –not using a locally defined variable –not declaring a function

Adv. UNIX: debug/147 Example: useWall.c v v int main() { int a, b; int x1, x2; if (a = b) printf("%d\n", x1); return 0; }

Adv. UNIX: debug/148 v v $ gcc -o useWall useWall.c $ useWall $ gcc -Wall -o useWall useWall.c useWall.c: In function `main': useWall.c:9: warning: suggest parentheses around assignment used as truth value useWall.c:10: warning: implicit declaration of function `printf' useWall.c:7: warning: unused variable `x2' $ useWall Three warnings, along with line numbers.

Adv. UNIX: debug/149 Finding Line 10 in vi  Use G : –e.g. 10G or:  Switch on line numbering in vi : –:set nu –:set nonu /* to switch it off */

Adv. UNIX: debug/ Debugging with printf() s v Good places to add them in your code: –at the start of a function u to print input parameters –at the return point of a function u to print output parameters and the return value –at the start of a loop u print the loop counter continued

Adv. UNIX: debug/1411   printf() s must identify where they are in the code: – –e.g. print the function name, line number, as well as data values – –use __LINE__, and others   printf() s should be conditional – –see the next section

Adv. UNIX: debug/1412 Example: dprintf.c v v #include int main() { int x = 5; printf("Compiled: %s %s\n", __DATE__, __TIME__); printf("%s/main.%d: x=%d\n", __FILE__, __LINE__, x); printf("hello world, x=%d\n", x); return 0; }

Adv. UNIX: debug/1413 v v $ gcc -Wall -o dprintf dprintf.c $ dprintf Compiled: Dec :27:44 dprintf.c/main.11: x=5 hello world, x=5 the debugging printf is located by program/function. line number

Adv. UNIX: debug/ Conditional Compilation  Debugging printf() s can be 'switched off' by putting comments around them –but adding comments takes a lot of time v Conditional compilation: selectively compile portions of the program –conditional compilation can be used to select which printf() s to include in the compilation

Adv. UNIX: debug/1415 Example: cinfo.c v v #include int main() { int x = 5; #ifdef DEBUG printf("Compiled: %s %s\n", __DATE__, __TIME__); printf("%s/main.%d: x=%d\n", __FILE__, __LINE__, x); #endif printf("hello world, x=%d\n", x); return 0; }

Adv. UNIX: debug/1416 v $ gcc -Wall -o cinfo cinfo.c $ cinfo hello world, x=5 $ gcc -Wall -o cinfo cinfo.c -DDEBUG $ cinfo Compiled: Dec :39:14 cinfo.c/main.15: x=5 hello world, x=5 define the DEBUG constant

Adv. UNIX: debug/1417 Harder Debug Switching  Instead of having the -D option on the command line, the constant can be defined inside the program: #define DEBUG v This is more work.

Adv. UNIX: debug/1418 Fancier #if: ifsdebug.c #include int main() { int n1 = 1, n2 = 2, n3 = 3; #if TESTFLAG == 1 printf("main: n1=%d\n", n1); #elif TESTFLAG == 2 printf("main: n2=%d\n", n2); #else printf("main: n3=%d\n", n3); #endif printf("n1=%d, n2=%d, n3=%d\n", n1, n2, n3); return 0; }

Adv. UNIX: debug/1419 v v $ gcc -Wall -o ifsdebug ifsdebug.c -DTESTFLAG=1 $ ifsdebug main: n1=1 n1=1, n2=2, n3=3 $ gcc -Wall -o ifsdebug ifsdebug.c -DTESTFLAG=2 $ ifsdebug main: n2=2 n1=1, n2=2, n3=3 $ gcc -Wall -o ifsdebug ifsdebug.c $ ifsdebug main: n3=3 n1=1, n2=2, n3=3 No -D option means that TESTFLAG is undefined.

Adv. UNIX: debug/ assert() v For testing assertions about the program.  assert() calls can contain any C expression: assert(x==y); assert(ptr != NULL); v If the evaluation is 0 (false) at runtime, an error message is produced, and execution is aborted.

Adv. UNIX: debug/1421 Example: assertTest.c v v #include #include #include double my_sqrt(double x); int main() { printf("sqrt +2 = %g\n", my_sqrt(2.0)); printf("sqrt -2 = %g\n", my_sqrt(-2.0)); return 0; } double my_sqrt(double x) { assert(x >= 0.0); return sqrt(x); }

Adv. UNIX: debug/1422 v v $ gcc -Wall -o assertTest assertTest.c -lm $ assertTest sqrt +2 = assertTest: assertTest.c:20: my_sqrt: Assertion `x >= 0.0' failed. Aborted $ gcc -Wall -o assertTest assertTest.c -lm -DNDEBUG $ assertTest sqrt +2 = sqrt -2 = nan $ assert() switched off "not a number"

Adv. UNIX: debug/ gdb  gdb is the interactive source-level debugger from the GNU Project –the debugger allows the programmer to see bugs in the source code as the program executes  Information on gdb : –$ man gdb –$ gdb -help –$ info gdb –type help when running gdb

Adv. UNIX: debug/ Main Features v Source line stepping v Printing/monitoring variables v Source-level breakpoints v Analysing core dumps v Graphical interfaces exist (using X) –xxgdb

Adv. UNIX: debug/ How to use gdb 1) Compile with the -g option of gcc : $ gcc -g -o examp examp.c 2) Execute the object code within gdb : $ gdb examp

Adv. UNIX: debug/ gdb and Crashing Code v v include void foo(int *px); void bar(int *px); int main() { int *px; px = (int *) 1000; /* px is address 1000 */ foo(px); return 0; } void foo(int *px) { bar(px); } void bar(int *px) { *px = 3; } /* assign 3 into address 1000 */ crash.c

Adv. UNIX: debug/1427 v v $ gcc -Wall -o crash crash.c $ crash Segmentation fault $ gcc -Wall -g -o crash crash.c $ gdb crash GNU gdb. Copyright (gdb) run Starting program: crash Program received signal SIGSEGV, Segmentation fault. 0x80483f2 in bar (px=0x3e8) at crash.c:27 27 *px = 3; (gdb) where #0 0x80483f2 in bar (px=0x3e8) at crash.c:27 #1 0x80483e6 in foo (px=0x3e8) at crash.c:22 #2 0x80483c9 in main () at crash.c:16 (gdb) quit The program is running. Exit anyway? (y or n) y $ crash crashes at line 27 in bar()

Adv. UNIX: debug/ gdb and Non-terminating Code 1. Start the code: run 2. Wait; interrupt execution: ctrl-c 3. Find location: where –list –list –print –print 4. Step through the code: step

Adv. UNIX: debug/1429 Example: nonterm.c v v include int main() { int num = 1; while (num > 0) if (num*num > 10000) { printf("Largest n is %d\n", num-1); num++; } return 0; }

Adv. UNIX: debug/1430 v v $ gcc -Wall -g -o nonterm nonterm.c $ gdb nonterm GNU gdb Copyright... (gdb) run Starting program: nonterm Program received signal SIGINT, Interrupt. 0x in main () at nonterm.c:12 12 if (num*num > 10000) { (gdb) where #0 0x in main () at nonterm.c:12 : I typed ctrl-C

Adv. UNIX: debug/1431 (gdb) list 7 int main() 8 { 9 int num = 1; while (num > 0) 12 if (num*num > 10000) { 13 printf("Largest n is %d\n", num-1); 14 num++; 15 } 16 return 0; (gdb) print num $1 = 1 (gdb) cont Continuing. Program received signal SIGINT, Interrupt. main () at nonterm.c:15 15 } : I typed ctrl-C again

Adv. UNIX: debug/1432 v v (gdb) print num $2 = 1 (gdb) step 12 if (num*num > 10000) { (gdb) step 15 } (gdb) step 12 if (num*num > 10000) { (gdb) step 15 } (gdb) quit The program is running. Exit anyway? (y or n) y $

Adv. UNIX: debug/1433 Getting indents Right v v $ indent -kr nonterm.c -o nonterm2.c $ cat nonterm2.c #include int main() { int num = 1; while (num > 0) if (num * num > 10000) { printf("Largest n is %d\n", num - 1); num++; } return 0; }

Adv. UNIX: debug/ gdb and Wrong Answers 1)Think about the error before using gdb. 2)Put breakpoints into the code. 3)Run the code. 4)At each breakpoint, step through the code. 5)Print variables and list code often: 6)If the code looks okay, continue execution. 7)Delete breakpoints that are no longer needed.

Adv. UNIX: debug/1435 Example: lowercase.c v v /* convert input to lowercase */ #include #include #define SIZE 1024 void lower(char lin[]); int main() { char line[SIZE]; while (fgets(line, 1024, stdin) != NULL) { lower(line); fputs(line, stdout); } return 0; } continued

Adv. UNIX: debug/1436 void lower(char lin[]) /* convert any uppercase letters to lowercase */ { int count = 0; while (lin[count] != '\0') { if (isupper(lin[count])) /* lin[count] = tolower(lin[count]); */ lin[count] += 34; count++; } }

Adv. UNIX: debug/1437 The Debugging Process v v $ gcc -Wall -g -o lowercase lowercase.c $ lowercase abcde abcde AAAAA ccccc BBBAAAA dddcccc $ gdb lowercase GNU gdb... (gdb) break lower Breakpoint 1 at 0x80484ee: file lowercase.c, line 28. : something is wrong

Adv. UNIX: debug/1438 (gdb) run Starting program: lowercase AAAAA Breakpoint 1, lower (lin=0xbffff8fc "AAAAA\n") at lowercase.c:28 28 int count = 0; (gdb) finish Run till exit from #0 lower (lin=0xbffff8fc "AAAAA\n") at lowercase.c:28 0x80484c4 in main () at lowercase.c:17 17 lower(line); (gdb) print $1 = "ccccc\n\000\000\000" : typed in by me

Adv. UNIX: debug/1439 (gdb) info break Num Type Disp Enb Address What 1 breakpoint keep y 0x080484ee in lower at lowercase.c:28 breakpoint already hit 1 time (gdb) delete 1 (gdb) list int count = 0; while (lin[count] != '\0') { 31 if (isupper(lin[count])) 32/* lin[count] = tolower(lin[count]); */ 33 lin[count] += 34; 34 count++; 35 } 36} 37 :

Adv. UNIX: debug/1440 (gdb) break 33 Breakpoint 2 at 0x : file lowercase.c, line 33. (gdb) cont Continuing. ccccc BBBBAAAA Breakpoint 2, lower (lin=0xbffff8fc "BBBBAAAA\n") at lowercase.c:33 33 lin[count] += 34; (gdb) step 34 count++; (gdb) print $2 = "dBBBAAAA\n" (gdb) quit The program is running. Exit anyway? (y or n) y $ typed in by me

Adv. UNIX: debug/ Memory Leaks  Dynamic data created with malloc() is not checked when it is used –it is easy for a programmer to assign data outside the malloc'ed area –the error will probably not cause a crash until much later when the altered memory is accessed by another part of the program continued

Adv. UNIX: debug/1442 v There are a number of tools which monitor the usage of malloc'ed space, and cause an error if they are used incorrectly –the ElectricFence library ( efence ) –the checkergcc compiler

Adv. UNIX: debug/1443 Example: efTest.c v v #include #include int main() { char *ptr = (char *)malloc(1024); ptr[0] = 0; /* now write beyond the block */ ptr[1024] = 0; printf("Everything is wondeful (I don't think)\n"); exit(0); }

Adv. UNIX: debug/1444 Execution v v $ gcc -Wall -o efTest efTest.c $ efTest Everything is wondeful (I don't think) $ gcc -Wall -o efTest efTest.c -lefence $ efTest Electric Fence Copyright (C) Bruce Perens. Segmentation fault $ continued

Adv. UNIX: debug/1445 $ gcc -Wall -g -o efTest efTest.c -lefence $ gdb efTest GNU gdb... (gdb) run Starting program: efTest Electric Fence Copyright (C) Bruce Perens. Program received signal SIGSEGV, Segmentation fault. 0x80485c9 in main () at efTest.c:17 17 ptr[1024] = 0; (gdb) quit The program is running. Exit anyway? (y or n) y $

Adv. UNIX: debug/ More Information v Beginning Linux Programming Neil Matthew and Rick Stones Wrox Press, 1996 Chapter 9: Debugging