Corso di Programmazione di Sistema Anno accademico 2005/2006

1. Corso di Programmazione di SistemaAnno accademico 2005/2006 Debugging e gdb E. P. Mancini e U. Villano

2. PS0506 – Debugging e gdb Strategie generali di debugging • Conferma Quando un programma contiene un bug, da qualche parte c’è qualcosa che voi credete vero ma che in realtà non lo è. Esempi: • credete che a un certo punto una variabile abbia un certo valore • credete che in uno statement if-then-else sia eseguito il ramo else • credete che richiamando una funzione, essa riceva correttamente i parametri

3. PS0506 – Debugging e gdb Strategie generali di debugging • Il processo dell’individuazione della locazione di un bug consiste nel confermare quello che credete • Se credete che la variabile abbia un certo valore, controllate! • Se credete che venga eseguito un ramo else, controllate! Prima o poi troverete che quello che credete non è confermato  avete individuato il bug

4. PS0506 – Debugging e gdb Strategie generali di debugging • Ricerca binaria Nella ricerca di conferme a quello che credete, usate una tecnica di ricerca binaria Es.: supponiamo di avere un file sorgente unico di 200 linee senza chiamate di funzione. Credete che x[4]=9 per tutta l’esecuzione de programma. Esaminate x[4] alla linea 100. Se è 9, la ricerca si restringe alle linee 101-200. Poi provate alla linea 150, ...

5. PS0506 – Debugging e gdb Strategie generali di debugging • E se il programma non viene nemmeno compilato? • Spesso il compilatore segnala l’errore all’ultima linea della definizione di una funzione (o classe). L’errore può essere in un qualsiasi punto della funzione. Usate la ricerca binaria Commentate metà della funzione e ricompilate, ...

6. PS0506 – Debugging e gdb Usate un tool di debugging e un buon editor di testo • Non usate printf()/cout come principale strumento di debugging • Confermare il valore assunto da variabili potrebbe essere fatto aggiungendo printf() o cout nel sorgente Questa è una tecnica particolarmente poco conveniente (aggiunta di printf, ricompilazione, esecuzione, aggiunta di altri printf, ricompilazione, ..., eliminazione del bug, eliminazione dei printf)

7. PS0506 – Debugging e gdb Usate un tool di debugging e un buon editor di testo • Un tool di debugging permette di esaminare i valori di variabili in maniera molto più comoda • Non occorre ricompilare • Potete monitorare automaticamente tutte le variabili che volete Questo vi permette di concentrarvi sulla ricerca del bug!!

8. PS0506 – Debugging e gdb Usate un tool di debugging e un buon editor di testo • Un tool di debugging vi dice anche dove si è verificato un errore dalle conseguenze peggiori (per es., un segmentation fault) • Vi segnala anche chi ha chiamato la funzione che ha generato l’errore Fatevi un favore: usate un debugger, non printf !!!

9. PS0506 – Debugging e gdb Quali tool utilizzare? • gdb • Un classico, disponibile sulla maggioranza dei sistemi Unix (e non  Cygwin) • front-end grafici per gdb • gdb è un tool in modalità testo. Sono stati sviluppati molti front-end GUI per il gdb. Es.: • ddd • KDbg (kde) • Insight (Red Hat, Cygwin)

10. PS0506 – Debugging e gdb Quali tool utilizzare? • Un buon editor di testo può aiutare molto • Fondamentale l’utilizzo di un editor con: • funzionalità di undo/redo ( ricerca binaria) • subwindows (anche in modalità testo) • interfaccia con debugger e compilatore • Consigli: • vim (vi improved) • emacs • ....

11. PS0506 – Debugging e gdb Strategie di base • lanciare gdb • settare un certo numero di breakpoints (posizioni nel codice nelle quali vogliamo sospendere l’esecuzione del programma) • esaminare (a programma sospeso) i valori di variabili • magari procedere in single step (esecuzione di una istruzione per volta) per esaminare il flusso dell’esecuzione

12. PS0506 – Debugging e gdb Strategie di base • Per i segmentation faults: • eseguire il programma sotto gdb (magari senza breakpoints) • al fault, gdb ci dice la locazione dell’errore • se questa fosse in una funzione di libreria/system call, il comando bt(backtrace) ci permette di risalire alla chiamata della funzione che ha causato l’errore

13. PS0506 – Debugging e gdb Debugger • Un debugger è un programma che permette di effettuare un'analisi approfondita di un altro programma in modo da aiutare a trovare i difetti dello stesso. Un debugger, tra le altre cose, può, relativamente ad un programma: • avviarlo • interromperlo • esaminarlo • modificarne lo stato (variabili, registri)

14. PS0506 – Debugging e gdb Debugger DEBUGGER controllo dell’esecuzione Programma

15. PS0506 – Debugging e gdb Debugger Debugger Sorgente controlla registri memoria (stack, heap) codice macchina Programma in esecuzione

16. PS0506 – Debugging e gdb Sessione di debugging • Un programma deve essere compilato in modo adeguato: Con gcc: gcc –g –o testprog testprog.c -g: inclusione dei dati di debug -o nome: nome dell’eseguibile. *.c: sorgenti c L’opzione –ggdb al posto di –g permette di inserire informazioni specifiche per gdb ma potrebbe non essere compatibile con altri debugger.

17. PS0506 – Debugging e gdb Sessione di debugging sorgenti (es. *.c) Editor (es. vim) codice oggetto (es. *.o, *.obj) Compilatore (es. gcc) informazioni di debug eseguibile/libreria Linker (es. ld)

18. PS0506 – Debugging e gdb Sessione di debugging Se nell’eseguibile non vengono inserite le informazioni di debug non è possibile avere una corrispondenza con il codice ad alto livello  si ha la sola vista del codice assembly.

19. PS0506 – Debugging e gdb Operazioni possibili • Avvio programma • Esecuzione a passi (single-stepping) • Inserimento di punti di interruzione (breakpoints) • Ispezione dei dati e visualizzazione strutturata

20. PS0506 – Debugging e gdb Esempio Creare un programma, chiamato test, che accetti un parametro da linea di comando. Se il parametro è la parola “utente” (senza controllo delle maiuscole), deve stampare la frase “abilitato”, altrimenti deve stampare la frase “accesso fallito”. Compilarlo con le opzioni per il debug attive. Il controllo della stringa deve avvenire in un’apposita funzione che usa strcmp (che però è case sensitive). > ./test utente abilitato > ./test Utente abilitato > ./test prova accesso fallito

21. PS0506 – Debugging e gdb Esempio con errori #include <stdio.h> #include <string.h> #define BUFLEN 7 int test(char *word) { return (strcmp("utente", word)==0); } int main(int argc, char **argv) { char buffer[BUFLEN]; int result; strcpy(buffer, argv[0]); result = test(buffer); if (result) printf("abilitato\n"); else printf("accesso fallito\n"); return result; }

22. PS0506 – Debugging e gdb Problemi nel programma di esempio • non c’è controllo sul numero di parametri • argv[0] non è il primo parametro • strcpy non controlla il superamento del buffer ( segmentation fault) • strcmp è sensibile alla differenza maiuscole/minuscole

23. PS0506 – Debugging e gdb Avvio del debugger • Su un eseguibile esterno: gdb nome_eseguibile es. gdb test • Su un programma in esecuzione gdb programma pid • Su un core dump gdb programma corefile • Per terminare: q, quit o ctrl-D

24. PS0506 – Debugging e gdb gdb in versione GUI Uscita Esecuzione di una funzione Espressioni Entrata in una funzione Stack Memoria Avvio Variabili locali Breakpoints Registri Modalità di visualizzazione: - sorgente, - assembly, - mista. Funzione Modulo

25. Avvio del programma run – esegue il programma caricato fino a quando non trova un punto di interruzione (breakpoint o watchpoint) PS0506 – Debugging e gdb

26. PS0506 – Debugging e gdb Avvio del programma Argomenti da linea di comando: (gdb) set args imposta gli argomenti. (gdb) show args visualizza gli argomenti oppure: (gdb) run args esecuzione con gli argomenti dati Ambiente: path: aggiunge una directory al path. cd: cambia la directory corrente. set environment: imposta una var. di ambiente.

27. PS0506 – Debugging e gdb Avvio del programma • Connessione a programmi già in esecuzione (attach) (gdb) attach pid si collega ad un processo avviato fuori dal gdb. (gdb) detach rilascia il processo cui ci si è collegati tramite attach.

28. PS0506 – Debugging e gdb Avvio del programma • Esame di un core dump Un “core dump” è un’istantanea prodotta dal sistema operativo di un programma che ha avuto un errore grave (es. Segmentation Fault) durante l’esecuzione. Permette di effettuare un’analisi post-mortem del programma. gdb test core #0 0x40054b03 in ?? () from /lib/libc.so.6 a questo punto si può fare un backtrace (analisi delle chiamate) per capire dove si trova l’errore: (gdb) bt

29. Esecuzione a passi (gdb) continue [ignorecount] (gdb) c [ignorecount] Continua l’esecuzione di un programma dall’istruzione in cui era stato fermato. (gdb) step [count] (gdb) s [count] Esegue una o più istruzioni successive. (gdb) next [count] (gdb) n [count] Esegue le istruzioni successive considerando le funzioni come atomiche. Non entra, cioè, all’interno del corpo delle funzioni che incontra. (gdb) finish Continua fino alla terminazione della funzione corrente. PS0506 – Debugging e gdb

30. PS0506 – Debugging e gdb Analisi dello stack Ogni funzione chiamata crea un frame sullo stack. (gdb) frame (gdb) frame num (gdb) frame address Visualizza il frame corrente o si sposta su uno diverso. (gdb) backtrace [n] (gdb) bt [n] Visualizza una riga per gli ultimi n frames presenti sullo stack. Fa un’analisi delle chiamate.

31. PS0506 – Debugging e gdb Analisi dello stack All’inizio dell’esecuzione programma gli unici frame dello stack sono quelli di libreria kernel32 e del main.

32. PS0506 – Debugging e gdb Analisi delle espressioni e delle variabili (gdb) print [expr] (gdb) p[/formato] [expr] visualizza il risultato dell’espressione utilizzando un formato specificato (es. p/x stampa in esadecimale, p/d in decimale con segno, ...), se non viene indicato un formato, questo viene desunto dalle informazioni di debug. Es. all’inizio del programma “test”: (gdb) p argv[0] $1 = 0x22fdc4 “/home/user/testgdb/test“ mostra che argv[0] è il nome del programma e non il primo parametro.

33. PS0506 – Debugging e gdb Analisi delle espressioni e delle variabili (gdb) display [expr] (gdb) disp[/formato] [expr] visualizza il valore dell’espressione utilizzando un formato specificato ogni volta che l’esecuzione del programma viene sospesa (cioè ai breakpoints e nello stepping). L’effetto di un comando display si cancella con (gdb) undisplay expr_code_number (gdb)info display mostra la lista corrente di code numbers

34. PS0506 – Debugging e gdb Analisi delle espressioni e delle variabili gdb accetta anche comandi printf, assolutamente simili alla omonima funzione C (gdb) printf “X=%d, Y=%d\n”,X,Y Con display e print, tenere sempre presente la differenza tra variabili globali e locali se x è una variabile dichiarata nella funzione f e f non e’ attiva, il comando print x produce un messaggio: No variable x in current context

35. Analisi della memoria (gdb) x[/formato] indirizzo visualizza il contenuto della memoria. PS0506 – Debugging e gdb

36. PS0506 – Debugging e gdb Disassemblare il codice Per disassemblare il codice (gdb) disassemble nome_funzione (gdb) disass main Dump of assembler code for function main: 0x8048420 <main>: push %ebp 0x8048421 <main+1>: mov %esp,%ebp 0x8048423 <main+3>: sub $0x8,%esp 0x8048426 <main+6>: call 0x8048400 <fun> 0x804842b <main+11>: sub $0xc,%esp 0x804842e <main+14>: push $0x80484a8 0x8048433 <main+19>: call 0x80482f0 <printf> 0x8048438 <main+24>: add $0x10,%esp 0x804843b <main+27>: mov %ebp,%esp 0x804843d <main+29>: pop %ebp 0x804843e <main+30>: ret 0x804843f <main+31>: nop End of assembler dump.

37. Analisi dei registri Si fa riferimento ai registri indicandone il nome preceduto dal simbolo $. Ad esempio $pc per il program counter e $sp per lo stack pointer. (gdb) info registers visualizza tutti i registri escluso quelli in virgola mobile. (gdb) info all-registers visualizza tutti i registri. Es. (gdb) p/x $pc $6 = 0x401100 visualizza il program counter (gdb) x/i $pc lea 0xffffffe8(%ebp),%eax 0x401100 <main+30>: visualizza l’istruzione successiva (gdb) set $sp += 4 modifica il valore dello stack pointer PS0506 – Debugging e gdb

38. PS0506 – Debugging e gdb Breakpoints Sono punti di interruzione del flusso dell’applicazione, si inseriscono con il comando break (abbreviato b) seguito dal nome di una funzione, da un indirizzo di memoria o da un numero di linea. es. (gdb) b main interrompe l’esecuzione all’inizio della funzione main es.(gdb) b 7 Breakpoint 2 at 0x40109e: file test.c, line 7. inserisce un breakpoint sulla linea 7 (per vedere il sorgente coi numeri di linea: list)

39. PS0506 – Debugging e gdb Breakpoints I punti di interruzione possono essere inseriti: • su una funzione: break funzione • su un indirizzo relativo: break [+][-]offset • su una linea: break numlinea • su una linea di un file specifico break filename:numlinea • su un indirizzo break *indirizzo • sulla prossima istruzione break E’ possibile inserire breakpoints condizionali es. (gdb) b 3 z>92 ferma l’istruzione al breakpoint n. 3 (settato in precedenza) solo se z>92

40. PS0506 – Debugging e gdb Watchpoints Un watchpoint è uno speciale breakpoint che si attiva quando il valore di un’espressione cambia. es. (gdb) watch expr il programma viene interrotto quando cambia il valore dell’espressione indicata.

41. PS0506 – Debugging e gdb Comandi set e call • Il comando set può essere utilizzato per modificare il valore di una variabile o di un registro es. (gdb) set variable x=12 • Il comando call serve per invocare l’esecuzione di una funzione (tipicamente una funzione scritta per il debugging, per es. per stampare una lista a puntatori)

42. PS0506 – Debugging e gdb Ricompilazione Non occorre uscire dal gdb prima di ricompilare Ricompilate in un’altra finestra. All’esecuzione di r (run), il gdb automaticamente utilizzerà l’eseguibile più recente.