Tools di analisi di programmi sviluppati in ANSI C Studio dei tre tools di analisi CFlow, Fjalar e Metre. Verranno messi a confronto per i loro requisiti.

Presentazione sul tema: "Tools di analisi di programmi sviluppati in ANSI C Studio dei tre tools di analisi CFlow, Fjalar e Metre. Verranno messi a confronto per i loro requisiti."— Transcript della presentazione:

1 Tools di analisi di programmi sviluppati in ANSI C Studio dei tre tools di analisi CFlow, Fjalar e Metre. Verranno messi a confronto per i loro requisiti di installazione, semplicità di utilizzo e funzionalità offerte. Autore: Maurizio Pianfetti Esame per “Linguaggi e Traduttori” seguito da Armando Tacchella, Jacopo Mantovani e Luca Pulina

2 Tools di analisi di programmi sviluppati in ANSI C : CFlow il progetto GNU Cflow è un analizzatore di sorgenti C che restituisce come output il flusso computazionale del programma in base alle funzioni richiamate dalla funzione di partenza ( normalmente il main )‏ attualmente la versione stabile è la 1.2 ultimata il 29/06/2007 software rilasciato sotto licenze GPLv3, usufruibile gratuitamente riferimenti all'applicazione: http://www.gnu.org/software/cflow/ http://www.gnu.org/software/cflow/

3 Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( funzionalità )‏ è possibile avere il flow del programma da due punti di vista diversi Direct graph: partendo dalla funzione principale si elencano le chiamate e sotto chiamate in modo ricorsivo alle funzioni nel programma ( caller — callee dependencies )‏ Reverse graph: partendo da tutte le funzioni nel programma si risale a chi chiama la singola funzione in ordine inverso ( callee — caller dependencies )‏

4 Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( funzionalità )‏ informazioni aggiuntive: oltre alle firme delle funzioni e l'ordine con cui vengono chiamate è possibile avere: variabili o funzioni di tipo statico e globali ( i simboli )‏, non è possibile una analisi locale tipi, parametri e valori di ritorno delle variabili e funzioni rilevate è possibile fare una analisi di tipo PreProcessor è possibile avere l'elenco delle dichiarazioni di ogni singolo simbolo ( cross-reference listings )‏ segnala le funzioni richiamate ricorsivamente

5 Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( Output )‏ l'output di cflow può essere di due tipi: POSIX: si ha l'elenco delle firme di ogni singola funzione con dei caratteri aggiuntivi per definire l'ingresso in esse, col numero progressivo di ordine di chiamata e richiamo alla riga di dichiarazione nel caso di funzione ricorsiva. Questo standard è utilizzato da ulteriori tools di analisi che utilizzati in “pipe” dopo CFLow creano grafici costruendo flow del programma [ cflow2vcg http://cflow2vcg.sourceforge.net/ xvcg http://rw4.cs.uni- sb.de/users/sander/html/gsvcg1.html Comando: cflow --format=posix --omit-arguments \ --level-indent='0=\t' --level-indent='1=\t' \ --level-indent=start='\t' $* | cflow2vcg | xvcg -http://cflow2vcg.sourceforge.net/ http://rw4.cs.uni- sb.de/users/sander/html/gsvcg1.html

6 Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( Output )‏ GNU Output: si ha l'elenco delle firme di ogni singola funzione con dei caratteri di tabulazione per definire ciò che avviene all'interno di esse. L'output generato è configurabile ed è possibile: aggiungere il numero progressivo di chiamata cambiare i caratteri di ingresso nelle funzioni omettere la firma delle funzioni Attualmente non esiste l'estensione per un output XML o HTML, probabilmente funzione presente nelle versioni future

7 Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( Usabilità )‏ può essere installato come plugin di Emacs può essere facilmente integrato come parte di progetto facendo una configurazione opportuna nel file Makefile.am è possibile definire delle configurazioni di default settando delle variabili di ambiente o utilizzando un file di configurazione è possibile utilizzarlo agganciando l'analisi ad un debugger ( Es. gdd )‏

8 Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( Installazione )‏ per l'installazione necessita soltanto delle librerie “header” del kernel Linux per poter essere compilato l'installazione comporta l'esecuzione dei classici tre comandi:./configure; make; make install è un programma senza interfaccia grafica command-line adatto per sistemi di automazione e punto di partenza per analisi più complesse

9 Tools di analisi di programmi sviluppati in ANSI C : CFlow Esempio #include #include #include int division(int dividend, int divisor) { int remainder = dividend; int quotient = 0; assert(divisor > 0); //assert(dividend > 0); while (divisor <= remainder) { remainder = remainder - divisor; ++quotient; } return quotient; } int main(int argc, char *argv []) { int dividend, divisor; if (argc != 3) { printf("Usage: div "); exit(EXIT_FAILURE); } dividend = atoi(argv[1]); divisor = atoi(argv[2]); //if (divisor <= 0) return 2; printf("%d", division( dividend, divisor )); return 0; } Si consideri il seguente programma C che esegue una divisione tra due numeri

10 Tools di analisi di programmi sviluppati in ANSI C : CFlow Direct Flow Formato di default main() : printf() exit() atoi() division() : assert()‏ Formato posix 1 main: int (int argc,char *argv[]), 2 printf: <> 3 exit: <> 4 atoi: <> 5 division: int (int dividend,int divisor), 6 assert: <> Ecco i due output possibili come flow diretto del codice d'esempio

11 Tools di analisi di programmi sviluppati in ANSI C : CFlow Reverse Flow assert(): division() : main() atoi(): main() division() : main() exit(): main() main() printf(): main() Viene evidenziata ogni singola funzione da chi viene richiamata

12 Tools di analisi di programmi sviluppati in ANSI C : CFlow Numero di richiami e simboli assert division.c:9 atoi division.c:24 atoi division.c:25 division *division.c:6 int (int dividend,int divisor) division division.c:27 exit division.c:22 main *division.c:18 int (int argc,char *argv[]) printf division.c:21 printf division.c:27 1 main: int (int argc,char *argv[]), 2 printf: <> 3 exit: <> 4 EXIT_FAILURE: <> 5 atoi: <> 6 division: int (int dividend,int divisor), 7 assert: <> Cflow evidenzia tutti i singoli richiami alle varie funzioni, visualizza le dichiarazioni e i simboli di compilazione

13 Tools di analisi di programmi sviluppati in ANSI C : CFlow Visualizzazione umana E' anche possibile una visualizzazione ad albero 1 +-main() 2 +-printf()‏ 3 +-exit()‏ 4 +-atoi()‏ 5 \-division()‏

14 Tools di analisi di programmi sviluppati in ANSI C : Metre il progetto Metre è un analizzatore di sorgenti ANSI C che restituisce come output una analisi statistica secondo alcune metriche che descrivono il livello di complessità / ottimalità di funzionamento del sorgente scritto e analizzato attualmente la versione stabile è la 2.3 ultimata il 03/04/1995 software rilasciato con Copyright “Metre Copyright (c) 1993-1995 by Paul Long All rights reserved”. La licenza specificata è l'utilizzo gratuito per applicazioni No profit, diversamente bisogna richiedere la licenza d'uso direttamente allo sviluppatore (Paul Long) http://www.lysator.liu.se/c/metre-v2-3.html http://www.lysator.liu.se/c/metre-v2-3.html

15 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Metriche )‏ vengono calcolate le seguenti metriche: McCabe's cyclomatic complexity : calcola la complessità del programma analizzando il numero di costruttori con punti di decisione. L'antologia su questo argomento mette a confronto complessità con numero di possibili bug Myers' extended complexity : evoluzione della metrica precedente, rileva l'effettivo numero di decisioni considerando il numero di condizioni per ogni costrutt o

16 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Metriche )‏ Halstead's program length: vengono calcolati il numero di “parole” e “operatori” del linguaggio usate, con questi numeri vengono a loro volta calcolati i seguenti parametri: Considerando un programma di due funzioni: operatori univoci f1 n1 operatori univoci f2 n2 totali operatori f1 N1 totali operatori f2 N2 velocità di scrittura S = 18 momenti / secondo fattore di secondo all'ora f = 60 * 60 Si calcolano i segunti parametri: Lunghezza Prog. N = N1 + N2 Vocabolario n = n1 + n2 Volume V = N * log2(n)‏ Livello L^ = (2 / n1) * (n2 / N2)‏ Effort E = V / L^ Durata del programma in ore T^ = E / (S * f)‏ Intelligenza I = L^ * V Livello del linguaggio L' = L^ * L^ * V

17 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Metriche )‏ Line Classifications: vengono calcolate le righe di codice, commenti e linee senza testo. Nel caso in cui si analizza il programma in modalità preprocessor per avere l'analisi dei commenti bisognerà compilarlo considerando eliminazione / mantenimento dei commenti Statement-Counting Standard: si classificano le “parole” del linguaggio utilizzate secondo l'antologia e regole descritte nel libro “Applied Software Measurement” di Capers Jone, in particolare si contano: Executable-Statement: direttive del linguaggio utilizzato ( C )‏ Declaration-Statement: dichiarazioni di variabili e funzioni Preprocessor Statements: vengono contate le parole di codice per il preprocessore ( nel caso del C le linee che iniziano con “#” )‏ Backfired function points: parametro empirico che descrive il rapporto tra numero di “function points” e numero di righe di codice, utilizzato nei grandi progetti per valutarne la complessità

18 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Metriche )‏ Maximum control depth: definisce la profondità di annidiamento dei costrutti utilizzati Identifier count and length: definisce il numero di identificatori ( nomi ) variabili e funzioni con la loro lunghezza massima Number of functions and modules: definisce il numero di funzioni e moduli, intesi come file separati, librerie e sorgenti nell'intero progetto analizzato

19 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Output )‏ Esistono due tipi di output: standard : per ogni modulo e funzione vengono calcolate le singole metriche e viene visualizzata una lista con il totale, il minimo, il massimo e la media del valori trovati secondo il seguente formato: per ogni funzione: Cyclomatic: total Extended: total Halstead Length: total Vocabulary: total Volume: total Level: total Effort: total Intelligence: total Time (hours) total Lang Level: total Lines: total Code: total Comment: total Blank: total Exec Statements: total Decl Statements: total Max Depth: total Identifiers: total Length: max ~avg

20 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Output )‏ per ogni modulo: -Function- Cyclomatic: max ~avg Extended: max ~avg Halstead Length: max ~avg Vocabulary: max ~avg Volume: max ~avg Level: max ~avg Effort: max ~avg Intelligence: max ~avg Time (hours) max ~avg total Lang Level: max ~avg Lines: max ~avg total Code: max ~avg total Comment: max ~avg total Blank: max ~avg total Exec Statements: max ~avg Decl Statements: max ~avg total Max Depth: max ~avg -Module- Lines: total Code: total Comment: total Blank: total Exec Statements: total Decl Statements: total PP Statements: total Function Points: total Identifiers: total Length: max ~avg Functions: total

21 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Output )‏ per ogni modulo: -Function- Cyclomatic: max ~avg Extended: max ~avg Halstead Length: max ~avg Vocabulary: max ~avg Volume: max ~avg Level: max ~avg Effort: max ~avg Intelligence: max ~avg Time (hours) max ~avg total Lang Level: max ~avg Lines: max ~avg total Code: max ~avg total Comment: max ~avg total Blank: max ~avg total Exec Statements: max ~avg Decl Statements: max ~avg total Max Depth: max ~avg -Module- Lines: total Code: total Comment: total Blank: total Exec Statements: total Decl Statements: total PP Statements: total Function Points: total Identifiers: total Length: max ~avg Functions: total

22 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Output )‏ CSV ( comma separated value ): viene generata una riga di output per ogni funzione, modulo o progetto analizzato. Ogni riga è composta da diversi campi divisi per “,”. E' possibile personalizzare quali metriche stampare e disabilitare i messaggi di warning che non vengono stampati nel formato standard ma come righe separate mod,insertsort.c,3,3,3,3,3,3,146,146,146,33,33,33,73 6,736,736,0.051,0.051,0.051,14510,14510,14510,37,3 7,37,0.2,0.2,0.2,0.2,1.89,1.89,1.89,33,33,33,33,32,32, 32,32,0,0,0,0,1,1,1,1,26,26,26,1,1,1,1,2,2,2,86,37,42,7,26,2,12,0,46,1,6,2,1 non è supportato XML

23 Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Installazione )‏ per l'installazione necessita soltanto delle librerie “header” del kernel Linux per poter essere compilato l'installazione comporta l'esecuzione del comando di compilazione dei sorgenti. Sono disponibili due tools, metre e mtree gcc -ansi -w -o metre metrules.c ytab.c lex_yy.c - lm gcc -ansi -w -o mtree trerules.c ytab.c lex_yy.c -lm è un programma senza interfaccia grafica command-line adatto per sistemi di automazione

24 Tools di analisi di programmi sviluppati in ANSI C : Metre Considerazioni‏ se un sorgente non è ANSI C, per esempio contiene righe con commenti “//” viene generato un “Fatal Error” e non viene completata l'analisi l'autore consiglia l'analisi di sorgenti di tipo PREPROCESSED

25 Tools di analisi di programmi sviluppati in ANSI C : Metre Confronto tra “Mtree” di Metre e la funzione “tree” di CFLow Cflow - tree 1 +-main() 2 +-printf()‏ 3 +-exit()‏ 4 +-atoi()‏ 5 \-division()‏ Metre – Mtree ision_ANSI.c main +---printf +---exit +---atoi ision_ANSI.c `---division `---assert Table of Contents division_ANSI.c division........... 6 main............. 18 #include int division(int dividend, int divisor) { int remainder = dividend; int quotient = 0; assert(divisor > 0); /* assert(dividend > 0); */ while (divisor <= remainder) { remainder = remainder - divisor; ++quotient; } return quotient; } int main(int argc, char *argv []) { int dividend, divisor; if (argc != 3) { printf("Usage: div "); exit(EXIT_FAILURE); } dividend = atoi(argv[1]); divisor = atoi(argv[2]); /* if (divisor <= 0) return 2; */ printf("%d", division( dividend, divisor )); return 0; }

26 Tools di analisi di programmi sviluppati in ANSI C : Metre Esempio Module Summary -Function- Cyclomatic: 2 ~2 Extended: 2 ~2 Halstead Length: 43 ~37 Vocabulary: 24 ~20 Volume: 197 ~159 Level: 0.167 ~0.127 Effort: 1400 ~1291 Intelligence: 33 ~22 Time (hours): 0.0 ~0.0 0.0 Lang Level: 5.47 ~3.18 Lines: 11 ~11 21 Code: 10 ~10 19 Comment: 1 ~1 2 Blank: 0 ~0 0 Exec Statements: 8 ~7 Decl Statements: 2 ~2 3 Max Depth: 1 ~1 -Module- Lines: 29 Code: 26 Comment: 2 Blank: 1 Exec Statements: 14 Decl Statements: 3 PP Statements: 3 Function Points: 0 Identifiers: 34 Length: 12 ~7 Functions: 2 #include int division(int dividend, int divisor) { int remainder = dividend; int quotient = 0; assert(divisor > 0); /* assert(dividend > 0); */ while (divisor <= remainder) { remainder = remainder - divisor; ++quotient; } return quotient; } int main(int argc, char *argv []) { int dividend, divisor; if (argc != 3) { printf("Usage: div "); exit(EXIT_FAILURE); } dividend = atoi(argv[1]); divisor = atoi(argv[2]); /* if (divisor <= 0) return 2; */ printf("%d", division( dividend, divisor )); return 0; } mod,division_ANSI.c,2,2,2,2,2,2,30,43,37,16,24,20,120,197,159,0.086,0.167,0.127,1182,1400,1291,10,33,22,0.0,0.0,0.0,0.0,0.88,5.47,3.18,10,11,11,21,9,10,10,19,1,1,1,2,0,0,0,0,6,8,7,1,2,2,3,1,1,1,29, 26,2,1,14,3,3,0,34,4,12,7,2

27 Tools di analisi di programmi sviluppati in ANSI C : Fjalar il progetto Fjalar è un framework per lo sviluppo di tools analizzatori del comportamento a compile-time e run-time di programmi C e C++, sfruttando il noto simulatore di CPU Valgrind, verificando problemi di allocazione di memoria legati alle dichiarazioni di variabili attualmente la versione stabile è la 1.3 rilasciata il 30/08/2007 il software è rilasciato con licenza GNU General Public License e Copyright (C) 2004-2006 Philip Guo (pgbovine@alum.mit.edu), MIT CSAIL Program Analysis Group http://groups.csail.mit.edu/pag/fjalar/pgbovine@alum.mit.edu http://groups.csail.mit.edu/pag/fjalar/

28 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( struttura )‏ Valgrind Fjalar Framework Kvasir ( rileva strutture dati ) DynComp ( analisi dinamica di strutture astratte )

29 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( funzionalità )‏ fornisce informazioni relative all'accesso alle variabili, tipi, indirizzi fisici, spazio allocato e visibilità (file, static, private, public) rileva associazioni tra strutture e tipi di classe, con variabili per capire eventuali annidamenti e definizioni di strutture in modo ricorsivo fornisce informazioni relative all'accesso alle funzioni, indirizzi, prototype, visibilità, parametri associati con valore e tipo di ritorno crea nomi univoci per le variabili e funzioni globali per eliminare ambiguità in modo da facilitare l'analisi globale per altri ipotetici tools collegati

30 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( funzionalità )‏ offre molte informazioni Run-time basate sull'esecuzione del programma per fare analisi di crash e memory lack è possibile analizzare solo parte del programma definendo quali funzioni analizzare

31 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( output )‏ offre diversi formati di output, derivati dai formati garantiti da Valgrind: default output su standard error stampa su file, se ci sono più processi è possibile fare un unico file o più files per ogni processo stampa su socket per la stampa via rete, Valgrind offre un listener ed un client rispettivamente per ricevere e inviare messaggi offre il formato XML per strutturare le varie informazioni in modo maggiormente interpretabile da altri tools

32 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( Installazione )‏ per l'installazione necessita soltanto delle librerie “header” del kernel Linux per poter essere compilato l'installazione comporta l'esecuzione di alcuni comandi per la compilazione dei sorgenti../autogen.sh./configure make make install è un programma senza interfaccia grafica command-line adatto per sistemi di automazione

33 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Esempio./select 0x8049860./select.c 1 19 D_UNSIGNED_FLOAT 4 float arr[20] = { 5, 4, 10.3, 1.1, 5.7, 100, 231, 111, 49.5, 99, 10, 150, 222.22, 101, 77, 44, 35, 20.54, 99.99, 888.88 };

34 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Esempio 0x8048364 0x8048640./select.c D_UNSIGNED_INT 4 4 D_UNSIGNED_INT 4 D_UNSIGNED_FLOAT 4 float select(unsigned long k, unsigned long n)‏ { unsigned long i,ir,j,l,mid; float a,temp; int flag, flag2;... } return arr[k]; }

35 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Esempio 0x8048640 0x8048670./select.c D_INT 4 > main()‏ { select(10, 20); }

36 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Considerazioni‏ è necessario compilare il programma per poterlo analizzare e se la compilazione non termina con successo non si ha l'analisi del programma non vengono considerate le variabili all'interno delle funzioni ma solo quelle globali, parametri e funzioni, poichè non è ingrado di avere informazioni nella fase di registry dal compilatore se il programma non contiene un main e non si può compilare, non è possibile analizzarlo

37 Tools di analisi di programmi sviluppati in ANSI C Analisi di sorgenti Benchmark Tools di analisi di programmi sviluppati in ANSI C : Fjalar Considerazioni‏ è necessario compilare il programma per poterlo analizzare e se la compilazione non termina con successo non si ha l'analisi del programma non vengono considerate le variabili all'interno delle funzioni ma solo quelle globali, parametri e funzioni, poichè non è ingrado di avere informazioni nella fase di registry dal compilatore se il programma non contiene un main e non si può compilare, non è possibile analizzarlo

38 Tools di analisi di programmi sviluppati in ANSI C : Fjalar Considerazioni‏ è necessario compilare il programma per poterlo analizzare e se la compilazione non termina con successo non si ha l'analisi del programma non vengono considerate le variabili all'interno delle funzioni ma solo quelle globali, parametri e funzioni, poichè non è ingrado di avere informazioni nella fase di registry dal compilatore se il programma non contiene un main e non si può compilare, non è possibile analizzarlo