225. gdb der Gnu Debugger

Transkript

1 225. gdb der Gnu Debugger Debuggen Oftmals enthält ein Programm einen Fehler, und man findet den Fehler nicht sofort. Eine Möglichkeit besteht aus vielen printf-anweisungen in dem Quelltext. Eleganter ist folgende Idee: Man übersetzt das Programm und läßt es Quellzeile für Quellzeile kontrolliert ablaufen. Dabei sollte man sich Variablen, Speicherflächen usw. interaktiv ansehen können. Das Problem der Fehlersuche und -behebung nennt man Debuggen. Ein Programm zur kontrollierten Ausführung von Programmen nennt man Debugger. Ein erstes Problem debug/pointer.c Das Beispiel enthält einen Fehler: int main(int argc, void * argv) { int * i; } *i=8; return 0; Die Ausführung scheitert wie erwartet: $ gcc Wall o pointer pointer.c $ pointer Segmentation fault Mit dem Schalter -g bereitet man Programme für eine mögliche Ausführung durch einen Debugger vor. $ gcc Wall g o pointer pointer.c $ pointer Segmentation fault Nun kann man das Programm mit einem Debugger starten gdb der Gnu Debugger gdb Der wohl bekannteste Debbugger ist der Gnu Debugger gdb. $ gdb pointer GDB is free software and you are welcome to distribute copies of it under certain conditions; type "show copying" to see the conditions. There is absolutely no warranty for GDB; type "show warranty" for details. GDB 4.16.patched (i486 unknown linux target i486 linux), Copyright 1996 Free Software Foundation, Inc (gdb) run Starting program: /home/bernd/vorl/b98/code/debug/pointer Program received signal SIGSEGV, Segmentation fault. 0x in main (argc=1, argv=0xbffff6c4) at pointer.c:12 12 *i=8; (gdb) quit The program is running. Quit anyway (and kill it)? (y or n) y gdb erhält als Argument ein Programm, welches es dann im weiteren Verlauf kontrollieren soll. Durch den Befehl run startet gdb das angegebene Programm. Hier sieht man jetzt die Zeile, wo das Problem aufgetreten ist.

2 227. gdb der Gnu Debugger Befehlsübersicht (Auswahl) help break [file:][n name] list [file:][n name] step [n] next [n] run [args] print/fmt [expr NUM] set var=expr cont [n] call function(params) display/fmt expr quit file cmd signal tbreak [file:][n name] ptype typname whatis expr bt und frame undisplay n info display enable [n] delete [n] info breakpoints disable [n] enable [n] delete [n] info [arg] show [arg] search regexp commands [n] finish define cmdname cd und pwd awatch expr rwatch expr watch expr attach detach Hilfe zu den einzelnen Kommandos Breakpoint setzen Quellcode zeigen Einen Schritt ausführen Einen Schritt ausführen Programm starten Ausgabe eines Ausdrucks Variablen setzten Programmfortsetzung expliziter Funktionsaufruf Debugger beenden zu kontrollierendes Programm setzen Fortsetzung mit Signal einmaliger Breakpoint Typ ausgeben Datentyp bestimmen Stackuntersuchungen Verwaltung von Displays Verwaltungen von Break- und Watchpoints Information über den kontrollierten Prozeß Informationen über den Zustand des Debuggers Suche nach regulären Ausdrücken Kommandos auf Breakpoints setzen Programmfortsetzung neue Befehle definieren working directory Watchpoints setzen auf laufenden Prozeß aufsetzen Prozeß wieder lösen 228. help help help [arg] $ gdb GDB is Copyright 1996 Free Software Foundation, Inc. (gdb) help List of classes of commands:

3 running Running the program stack Examining the stack data Examining data breakpoints Making program stop at certain points files Specifying and examining files Type "help" followed by a class name for a list of commands in that class. Type "help" followed by command name for full documentation. Command name abbreviations are allowed if unambiguous. Ein Aufruf von help liefert eine Übersicht von Kommando-Klassen. So sind z.b. alle Kommandos zur Steuerung der Ausführung eines Prozesses in einer Klasse running zusammengefaßt. help class gibt eine Übersicht über alle Befehle in einer Klasse. (gdb) help running Running the program. List of commands: run Start debugged program continue Continue program being debugged step Step program until it reaches a different source line next Step program 229. help help command gibt endlich die Hilfe zu einem gesuchten Kommando aus. (gdb) help run Start debugged program. You may specify arguments to give it. Args may include "*", or "[]"; they are expanded using "sh". Input and output redirection with ">", "<", or ">>" are also allowed. With no arguments, uses arguments last specified (with "run" or "set args"). To cancel previous arguments and run with no arguments, use "set args" without arguments. Generell (nicht nur beim Kommando help) sind Abkürzungen, die eindeutig auf einen Kommando- oder Klassennamen verweisen, erlaubt break, list, step, next, run, cont break und list break [file:]function break [file:]number list [file:]function list [file:]number break setzt einen Breakpoint auf eine Zeile oder eine Funktion. Jedesmal, wenn der Prozeß während der Ausführung

4 einen aktiven Breakpoint erreicht, wird die Abarbeitung unterbrochen. list zeigt Zeilen des Quellcodes. Beispiel debug/cat.c cat.c ist das Beispiel cat5 aus dem io-katalog. Es enthält eine Funktion namens cat. $ gdb cat (gdb) break cat Breakpoint 1 at 0x80486c6: file cat.c, line 16. break bekommt neben einem optionalen Dateinamen als Argument einen Funktionsnamen oder eine Zeilennummer. Bei Ausführung wird der Prozeß vor der Abarbeitung der angegebenen Zeile oder Funktion unterbrochen. Wird list mit einer Zahl als Argument aufgerufen, so wird die Zahl als Zeilennummer interpretiert, und die umgebenden Zeilen werden angezeigt. Ohne Argument zeigt list die Zeilen in der Umgebung der als nächstes auszuführenden Zeile an. (gdb) list while ((ch = getc(fp))!= EOF) 22 putchar(ch); if (fp!= stdin) 25 fclose(fp); 26 } int main (int argc, char * argv[]) { 29 int n; (gdb) break 25 Breakpoint 2 at 0x80487d9: file cat.c, line break, list, step, next, run, cont run und step run [args] step [n] run startet das beim Aufruf von gdb angegebene Argument als Prozeß Schritt für Schritt. Die Argumente zu run werden dem Prozeß als Kommandozeilen-Argumente übergeben. Trifft der Prozeß zur Laufzeit auf einen Breakpoint, so wird wieder in den Befehlsmodus gewechselt. (gdb) run data Starting program: /home/bernd/vorl/b98/code/debug/cat data Breakpoint 1, cat (fnm=0xbffff851 "data") at cat.c:16 16 if (strcmp(fnm, " ") == 0) (gdb) l void cat (const char * fnm) { 13 int ch; 14 FILE * fp; if (strcmp(fnm, " ") == 0) 17 fp = stdin, clearerr(fp); 18 else if (! (fp = fopen(fnm, "r")))

5 19 perror(fnm), exit(1); 20 Bei einem Breakpoint auf eine Funktion wird vor der Bearbeitung der ersten Befehlszeile angehalten. step führt nun einen Schritt aus. step n führt n Schritte aus. (gdb) s 18 else if (! (fp = fopen(fnm, "r"))) (gdb) s 21 while ((ch = getc(fp))!= EOF) (gdb) s 40 Hello World! 21 while ((ch = getc(fp))!= EOF) 232. break, list, step, next, run, cont next next [n] next führt wie step einen Schritt aus, wechselt dabei aber nicht in Unterfunktionen. $ gdb cat (gdb) break main Breakpoint 1 at 0x80487f6: file cat.c, line 31. (gdb) r Starting program: /home/bernd/vorl/b98/code/debug/cat Breakpoint 1, main (argc=1, argv=0xbffff6d4) at cat.c:31 31 if (argc <= 1) (gdb) s 32 cat(" "); (gdb) s cat (fnm=0x80488d8 " ") at cat.c:16 16 if (strcmp(fnm, " ") == 0) (gdb) r The program being debugged has been started already. Start it from the beginning? (y or n) y Starting program: /home/bernd/vorl/b98/code/debug/cat Breakpoint 1, main (argc=1, argv=0xbffff6d4) at cat.c:31 31 if (argc <= 1) (gdb) n 32 cat(" "); (gdb) n Hallo Hallo 37 if (fflush(stdout), ferror(stdout))

6 233. break, list, step, next, run, cont cont cont [n] cont ohne Argument setzt die Ausführung des Programms bis zum nächsten Breakpoint, Fehler oder bis zum Programmende fort. Mit einer Zahl als Argument setzt es die Ausführung bis zum Erreichen des n-ten Breakpoints, eines Fehlers oder bis zum Programmende fort print $ gdb cat (gdb) break cat Breakpoint 1 at 0x80486c6: file cat.c, line 16. (gdb) r data data Starting program: /home/bernd//code/debug/cat data data Breakpoint 1, cat (fnm=0xbffff84a "data") at cat.c:16 16 if (strcmp(fnm, " ") == 0) (gdb) c 2 Will ignore next crossing of breakpoint 1. Continuing. Hello World! Hallo Welt! Hallo zusammen Hallo zusammen Breakpoint 1, cat (fnm=0xbffff851 "data") at cat.c:16 16 if (strcmp(fnm, " ") == 0) (gdb) c Continuing. Hello World! Hallo Welt! Program exited normally. (gdb) print und set var=expr print/fmt [expr NUM] set var=expr print gibt den Wert von Ausdrücken aus. Im folgenden Beispiel wird ein Breakpoint auf die while-schleife in der Funktion cat gesetzt: $ gdb cat (gdb) break 21 Reading in symbols for cat.cdone. Breakpoint 1 at 0x3c5c: cat.c:21. (gdb) run data Reading symbols from loaded filedone. Breakpoint 1, cat (fnm=0xbffff8d3 "data") at cat.c:21

7 21 while ((ch = getc(fp))!= EOF) fp war als lokale Variable eine Dateiverbindung vom "Typ" FILE*. (gdb) p fp $1 = (struct _iobuf *) 0x50c03f0 (gdb) p *fp $2 = { _cnt = 0, _ptr = 0x0, _base = 0x0, _bufsiz = 0, _flag = 1, _file = 3 \003, _smallbuf = 0 \000 } Man sieht, daß hier FILE* der Typ struct _iobuf* ist. Nun ist der interne Aufbau der I/O-Bufferung zu sehen. Der Name der Struktur und ihr Aufbau sind natürlich von Compiler zu Compiler verschieden (hier NeXT) print Mit step liest man nun ein Zeichen ein und sieht sich dann den Inhalt der Struktur neu an. (gdb) s 22 putchar(ch); (gdb) p ch $3 = 72 (gdb) p/c ch $4 = 72 H (gdb) p *fp $5 = { _cnt = 24, _ptr = 0x8c1a1 "ello World!\nHallo Welt!\n", _base = 0x8c1a0 "Hello World!\nHallo Welt!\n", _bufsiz = 8192, _flag = 9, _file = 3 \003, _smallbuf = 0 \000 } (gdb) s putchar(ch); (gdb) p/c ch $6 = 100 d (gdb) p *fp $7 = { _cnt = 14, _ptr = 0x8c1ab "!\nhallo Welt!\n", _base = 0x8c1a0 "Hello World!\nHallo Welt!\n", _bufsiz = 8192, _flag = 9, _file = 3 \003, _smallbuf = 0 \000 } Direkt hinter print kann ein / mit einer folgenden Formatanweisung stehen.

8 Erlaubte Formatanweisungen sind z.b. o(octal), x(hex), d(decimal), u(unsigned decimal), t(binary), f(float), a(address), i(instruction), c(char) und s(string) print print liefert pro Ausgabe eine korrespondierende Nummer wie $7. Diese Nummer darf man bei weiteren Aufrufen wieder verwenden. (gdb) s 20 Hello World! 22 putchar(ch); (gdb) p $7 $9 = { _cnt = 14, _ptr = 0x8c1ab "!\nhallo Welt!\n", _base = 0x8c1a0 "Hello World!\nHallo Welt!\n", _bufsiz = 8192, _flag = 9, _file = 3 \003, _smallbuf = 0 \000 } (gdb) p fp >_base+2 $10 = 0x8c1a2 "llo World!\nHallo Welt!\n" (gdb) p *(int *) $10 $11 = (gdb) p (int) * $10 $12 = 108 (gdb) p (char *) 0x8c1a2 $13 = 0x8c1a2 "llo World!\nHallo Welt!\n" Beliebige Arithmetik und Casten sind erlaubt. $ und $$ sind die beiden letzten Werte. $$n ist der n-te Wert vom Ende her gezählt. Man kann Ausdrücke angeben, die den Wert von Daten im laufenden Prozeß ändern. (gdb) p fp >_cnt=9 $26 = 9 (gdb) p *fp $27 = { _cnt = 9, _ptr = 0x8c1b5 "lt!\n", _base = 0x8c1a0 "Hello World!\nHallo Welt!\n", _bufsiz = 8192, _flag = 9, _file = 3 \003, _smallbuf = 0 \000 }

9 237. print Den Wert von Variablen setzt man normalerweise mit set. (gdb) set fp=0 Mit set kann man weiterhin eine Vielzahl von Einstellungen für den Debbuger setzen. Näheres zu set entnehmen Sie dem help-kommando call call call function(params) Mit call kann man in einem Programm gezielt Funktionen aufrufen. $ gdb cat (gdb) b main Breakpoint 1 at 0x80487f6: file cat.c, line 31. (gdb) r Starting program: /home/bernd/vorl/b98/code/debug/cat Breakpoint 1, main (argc=1, argv=0xbffff6d4) at cat.c:31 31 if (argc <= 1) (gdb) call cat("data") Hello World! Hallo Welt! (gdb) call tmpfile() $16 = (gdb) p * $16 $17 = 0 (gdb) p $16 $18 = (gdb) p *(FILE*)$16 No symbol "FILE" in current context. (gdb) p *(struct _iobuf *)$16 $19 = { _cnt = 0, _ptr = 0x0, _base = 0x0, _bufsiz = 0, _flag = 256, _file = 5 \005, _smallbuf = 0 \ Displays display, undisplay, info display, enable, disable display/fmt expr undisplay n info display disable display n enable display n Mit display wird der als Argument angegebene Ausdruck bei jedem Programmstop ausgegeben. $ gdb cat

10 (gdb) b main Breakpoint 1 at 0x80487f6: file cat.c, line 31. (gdb) b 35 Breakpoint 2 at 0x : file cat.c, line 35. (gdb) l for (n = 1; n < argc; ++ n) 35 cat(argv[n]); 36 (gdb) r data data Starting program: /home/bernd/vorl/b98/code/debug/cat data data Breakpoint 1, main (argc=4, argv=0xbffff6a8) at cat.c:31 31 if (argc <= 1) (gdb) display argc 1: argc = 4 (gdb) display n 2: n = 0 (gdb) display argv[n] 3: argv[n] = 0xbffff81c "/home/bernd/vorl/b98/code/debug/cat" (gdb) c Continuing. Breakpoint 2, main (argc=4, argv=0xbffff6a8) at cat.c:35 35 cat(argv[n]); 3: argv[n] = 0xbffff840 "data" 2: n = 1 1: argc = 4 (gdb) c Continuing. Hello World! Hallo Welt! Breakpoint 2, main (argc=4, argv=0xbffff6a8) at cat.c:35 35 cat(argv[n]); 3: argv[n] = 0xbffff845 " " 2: n = 2 1: argc = 4 (gdb) c Continuing. Hallo Hallo Breakpoint 2, main (argc=4, argv=0xbffff6a8) at cat.c:35 35 cat(argv[n]); 3: argv[n] = 0xbffff847 "data" 2: n = 3 1: argc = 4 (gdb) c Continuing. Hello World! Hallo Welt! Program exited normally.

11 info display zeigt eine Übersicht aller Displays. (gdb) info display Auto display expressions now in effect: Num Enb Expression 3: y argv[n] (cannot be evaluated in the current context) 2: y n (cannot be evaluated in the current context) 1: y argc (cannot be evaluated in the current context) Mit undisplay kann man Displays wieder löschen. disable kann Displays deaktivieren. enable kann deaktivierte Displays aktivieren. Beide Kommandos beziehen sich ohne Argumente auf alle Displays und mit einer Zahl als Argument auf den Display mit dieser Nummer. (gdb) undisplay 2 (gdb) info display Auto display expressions now in effect: Num Enb Expression 3: y argv[n] (cannot be evaluated in the current context) 1: y argc (cannot be evaluated in the current context) (gdb) disable display 3 (gdb) info display Auto display expressions now in effect: Num Enb Expression 3: n argv[n] (cannot be evaluated in the current context) 1: y argc (cannot be evaluated in the current context) 240. Verschiedenes quit quit quit beendet den Debugger. file file cmd Der Debugger kontrolliert ab nun das Programm cmd. signal signal n Setzt die Ausführung mit dem Eintreffen des Signals n fort. Dabei steht die Nummer 0 für kein Signal, also normale Weiterbearbeitung. tbreak tbreak [file:][n name] tbreak funktioniert wie break. Der Breakpoint gilt jedoch nur einmal.

12 ptype ptype typename Gibt die Definition des Typs typename aus. Das Argument typename kann ein einfacher Datentyp, ein durch typedef definierter Typ, "struct struct-tag", "union union-tag" oder "enum enum-tag" sein. (gdb) ptype struct _iobuf type = struct _iobuf { int _cnt; char *_ptr; char *_base; int _bufsiz; short int _flag; unsigned char _file; char _smallbuf; } (gdb) ptype size_t type = long unsigned int 241. Verschiedenes bt oder backtrace frame bt[n] backtrace[n] frame[n] bt oder backtrace geben den Aufruf-Stack bzw. die letzten n Elemente des Aufruf-Stacks aus. $ gdb cat (gdb) b cat Reading in symbols for cat.cdone. Breakpoint 1 at 0x3be6: cat.c:16. (gdb) r data Starting program: /export/home/bernd//code/debug/cat data Reading symbols from loaded filedone. Breakpoint 1, cat (fnm=0xbffff8d3 "data") at cat.c:16 16 if (strcmp(fnm, " ") == 0) (gdb) bt #0 cat (fnm=0xbffff8d3 "data") at cat.c:16 #1 0x3e06 in main (argc=2, argv=0xbffff7f4) at cat.c:35 #2 0x3b1e in start () at crt0.c:144 (gdb) bt 1 #0 cat (fnm=0xbffff8d3 "data") at cat.c:16 (More stack frames follow) (gdb) frame ohne Argument zeigt den aktuellen Frame an. Mit Argument n wechselt man für Bewertungen in den Frame n. (gdb) frame #0 cat (fnm=0xbffff8d3 "data") at cat.c:16 16 if (strcmp(fnm, " ") == 0) (gdb) p *argv

13 No symbol "argv" in current context. (gdb) frame 1 #1 0x3e06 in main (argc=2, argv=0xbffff7f4) at cat.c:35 35 cat(argv[n]); (gdb) p *argv $3 = 0xbffff8a8 "/export/home/bernd/vorl/b98/code/debug/cat" Wird der Prozeß fortgesetzt, so wird wieder in den aktuellen Frame gewechselt Verschiedenes Verwaltung von Breakpoints info breakpoints disable n delete n enable n Das Kommando info liefert eine Vielzahl von Informationen über den zu kontrollierenden Prozeß. Mit dem Argument breakpoints zeigt es alle Breakpoints und deren Zustände an. $ gdb cat (gdb) break main Reading in symbols for cat.cdone. Breakpoint 1 at 0x3dcd: cat.c:31. (gdb) break cat Breakpoint 2 at 0x3be6: cat.c:16. (gdb) break 28 Breakpoint 3 at 0x3dc0: cat.c:28. (gdb) info breakpoints Num Type Disp Enb Address What 1 breakpoint keep y 0x00003dcd in main at cat.c:31 2 breakpoint keep y 0x00003be6 in cat at cat.c:16 3 breakpoint keep y 0x00003dc0 in main at cat.c:28 Die Kommandos enable, disable und delete aktivieren, deaktivieren und löschen Breakpoints. Mit einer Zahl als Argument bezieht sich das Kommando auf den Breakpoint mit dieser Nummer. Ohne Argument beziehen sie sich auf alle Breakpoints. (gdb) disable 2 (gdb) delete 3 (gdb) enable 1 (gdb) info breakpoints Num Type Disp Enb Address What 1 breakpoint keep y 0x00003dcd in main at cat.c:31 2 breakpoint keep n 0x00003be6 in cat at cat.c:16 (gdb) info info args info liefert eine Vielzahl von Informationen über den zu kontrollierenden Prozeß. Den genauen Funktionsumfang entnehmen Sie bitte dem help-kommando.

14 243. Verschiedenes search search regexp search sucht ab der aktuellen Zeile nach dem regulären Ausdruck regexp. show show arg show liefert eine Vielzahl von Informationen über den Zustand des Debuggers. Den genauen Funktionsumfang entnehmen Sie bitte dem help-kommando. commands commands [n] commands sammelt Befehle, die beim Erreichen eines Breakpoints ausgeführt werden sollen. finish finish Setzt die Ausführung bis zum Ende der aktuellen Funktion oder bis zum nächsten Breakpoint fort. whatis whatis expr whatis zeigt den Datentyp eines Ausdrucks an. Dabei wird der Ausdruck nicht ausgewertet. (gdb) p fp $2 = (struct _iobuf *) 0x50c03f0 (gdb) whatis fp++ type = struct _iobuf * (gdb) p fp $3 = (struct _iobuf *) 0x50c03f0 (gdb) whatis (int) 2 + (double) 3 type = double 244. Verschiedenes define define cmdname Mit define kann man einen neuen Befehl für den Debugger definieren. (gdb) define lmain Type commands for definition of "lmain". End with a line saying just "end". >list main >end (gdb) lmain if (fp!= stdin) 25 fclose(fp);

15 26 } int main (int argc, char * argv[]) { 29 int n; if (argc <= 1) 32 cat(" "); (gdb) cd und pwd cd pwd Die Hilfe sagt alles. (gdb) help cd Set working directory to DIR for debugger and program being debugged. The change does not take effect for the program being debugged until the next time it is started. (gdb) help pwd Print working directory. This is used for your program as well Verschiedenes awatch, rwatch und watch awatch expr rwatch expr watch expr Diese Kommandos setzen Breakpoints auf den Zustand von Variablen (eigentlich Ausdrücken). Diese Watchpoints kann man sich mit info breakpoints bzw. info watchpoints ansehen und mit enable, disable und delete verwalten. watch setzt einen Watchpoint auf den als Argument angegebenen Ausdruck. Der Watchpoint stopt die Ausführung immer dann, wenn sich der Wert des Ausdrucks geändert hat. rwatch stopt, wenn der Wert des Ausdrucks gelesen wird. awatch stopt, wenn der Wert des Ausdrucks gelesen wird oder sich geändert hat. $ gdb cat (gdb) break cat Reading in symbols for cat.cdone. Breakpoint 1 at 0x3be6: cat.c:16. (gdb) r data data Starting program: /home/bernd//code/debug/cat data data Breakpoint 1, cat (fnm=0xbffff8cb "data") at cat.c:16 16 if (strcmp(fnm, " ") == 0) (gdb) watch fp Watchpoint 2: fp (gdb) delete 1 (gdb) c Continuing. Watchpoint 2: fp

16 Old value = (struct _iobuf *) 0xbffff7e4 New value = (struct _iobuf *) 0x50c03f0 0x3c3e in cat (fnm=0xbffff8cb "data") at cat.c:18 18 else if (! (fp = fopen(fnm, "r"))) (gdb) c Continuing. Hello World! Hallo Welt! Watchpoint 2 deleted because the program has left the block in which its expression is valid. 0x3dbd in cat (fnm=0x3 <Address 0x3 out of bounds>) at cat.c:26 26 } (gdb) attach und detach gdb cmd pid attach pid detach gdb cmd pid Der Debugger kann auch bereits laufende Prozesse analysieren. Dazu braucht man die Prozeß-ID des Prozesses und die Rechte, dem Prozeß Signale senden zu dürfen. attach bekommt als Argument eine Prozeß-ID. Damit versucht der Debugger den damit gewählten Prozeß zu kontrollieren. Die Datei von der das laufende Programm aus gestartet worden ist, kann über den Befehl file oder als einziges Argument beim Aufruf des Debuggers angegeben werden. detach löst die Verbindung des Debuggers zum Prozeß wieder. Der Prozeß läuft ganz normal weiter. Anstelle von attach kann die PID auch als zweites Argument beim Aufruf von gdb angegeben werden. Unter Linux wurde folgendes ausgeführt. $ cat /dev/zero & [1] 1224 $ ps axu fgrep cat bernd p0 S 13:56 0:02 cat /dev/zero bernd p0 S 13:56 0:00 fgrep cat $ gdb cat (gdb) attach 1224 Attaching to program `/home//debug/cat, process 1224 Reading symbols from /lib/libc.so.5done. Reading symbols from /lib/ld linux.so.1done. 0x40072db0 in write () (gdb) break 22 Breakpoint 1 at 0x : file cat.c, line 22. (gdb) c Continuing. Breakpoint 1, cat (fnm=0xbffff86e "/dev/zero") at cat.c:22 22 putchar(ch); (gdb)

17 246. Verschiedenes gdb und core-dateien gdb cmd core gdb kann auch mit einem core-dump (Speicherauszug) unterbrochene Prozesse nachträglich untersuchen. Beispiel debug/coretest.c Das Programm verhält sich wie ein echo-programm, außer wenn eines der Kommandozeilenargumente das Wort core ist. Dann bricht das Programm über abort(3) ab. int main(int argc, char * argv[]) { int i; } for(i=0; i<argc; i++) if(strcmp(argv[i], "core")) printf("%s ", argv[i]); else abort(); putchar( \n ); return 0; Bei einigen Systemen muß man erst das Schreiben von core-dateien erlauben. $ ulimit S c $ ulimit H c unlimited $ ulimit S c artemis debug 19 coretest core IOT trap (core dumped) artemis debug 20 ls l core rw r r 1 bernd inform Jul 9 11:05 core artemis debug 21 gdb coretest core Reading symbols from /home/bernd//code/debug/coretestdone. 0x5078ae0 in?? () (gdb) bt Reading in symbols for coretest.cdone. Reading in symbols for crt0.cdone. #0 0x5078ae0 in?? () #1 0x503febd in?? () #2 0x3de9 in main (argc=2, argv=0xbffff80c) at coretest.c:20 #3 0x3cce in start () at crt0.c:144 (gdb) frame 2 #2 0x3de9 in main (argc=2, argv=0xbffff80c) at coretest.c:20 20 abort(); (gdb) p *argv $1 = 0xbffff8c4 "coretest" (gdb) p *(argv+1) $2 = 0xbffff8cd "core" (gdb)

18 247. xxgdb xxgdb Die Arbeit mit dem Debugger auf der Kommandozeile ist relativ mühsam, wenn man sich an grafische Oberflächen und deren Applikationen gewöhnt hat. xxgdb ist ein grafischer Aufsatz auf den gdb für die Oberfläche X. In dem oberen Ausschnitt wird die aktuelle Zeile des Programmtexts dargestellt. Der mittlere Ausschnitt enthält für einige gdb-kommandos Knöpfe. Im unteren Teile kann man Befehle für den Debugger eingeben bzw. die Ausgabe von Kommandos betrachten. $ xxgdb cat

19 248. ddd ddd Auch ddd setzt auf gdb auf. Allerdings ist die Oberfläche wesentlich komfortabler und der Befehlsumfang mächtiger. In dem Beispiel wird das Listen-Programm liste aus dem Katalog struct untersucht.

20