1 / 69

Program slicing Techniques

(Frank Tip). Program slicing Techniques. Alberto Franzin 807980 Alice Marchiori 805090. Sommario. Cos’è una slice Slicing Statico : Intraprocedurale Dataflow equation PDG approach Interprocedurale Dataflow equation SDG approach. Program slice - Definizione.

noam
Download Presentation

Program slicing Techniques

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. (Frank Tip) Program slicing Techniques Alberto Franzin 807980 Alice Marchiori 805090 Corso di Analisi e Verifica di Programmi 2005/2006

  2. Sommario • Cos’è una slice • Slicing Statico : • Intraprocedurale • Dataflow equation • PDG approach • Interprocedurale • Dataflow equation • SDG approach Corso di Analisi e Verifica di Programmi 2005/2006

  3. Program slice - Definizione • Definizione originaria (Weiser) : La Program Slice S è un programma ridotto ed eseguibile ottenuto da un programma P, rimuovendo parti di codice, tale che S replichi parte del comportamento di P. • Ricavare una slice significa ridurre un programma alle sole istruzioni che influenzano il valore delle variabili in un determinato punto del codice che viene denominato slicing criterion • Slicing criterion: (n, V) – numero di riga n, insieme di variabili da controllare V • La tecnica di calcolare una program slice è detta Program Slicing Corso di Analisi e Verifica di Programmi 2005/2006

  4. Program slice - Proprietà Due caratteristiche fondamentali: • Minimale • Eseguibile • Minimale contiene il minor numero di linee di codice tali da rappresentare tutti i punti di interesse per lo slicing criterion (non deve esistere un’altra slice con un minor numero di istruzioni) • Eseguibile comportamento deve essere uguale a quello del programma originale per le parti considerate e per tutti i possibili valori in input Corso di Analisi e Verifica di Programmi 2005/2006

  5. Esempio (1) read (n); (2) i := 1; (3) (4) product := 1; (5) while i<= n do begin (6) • product := product *i; • i:= i + 1; end (9) (10) write (product) (1) read (n); (2) i := 1; (3) sum := 0; (4) product := 1; (5) while i<= n do begin (6) sum:= sum +i ; (7) product := product *i; (8) i:= i + 1; end (9) write(sum); (10) write (product) (b) Una slice del programma rispetto al criterio (10,product) (a) esempio di programma Corso di Analisi e Verifica di Programmi 2005/2006

  6. 1- BASIC ALGORITHM FOR STATIC SLICING Corso di Analisi e Verifica di Programmi 2005/2006

  7. Static Slicing • Nessuna assunzione sull’input • Informazioni disponibili staticamente • Probabilistico  approssimazione Corso di Analisi e Verifica di Programmi 2005/2006

  8. Intraprocedural Static Slicing Corso di Analisi e Verifica di Programmi 2005/2006

  9. Dataflow Equation - Weiser • Processo iterativo, computo insiemi consecutivi di variabili rilevanti per ogni nodo del CFG • Determino le variabilidirettamente rilevanti seguendo le dipendenze dati (data dependences), da qui derivo un insieme di comandi direttamente rilevanti • Determino le variabili indirettamente rilevanti a partire dai comandi presenti nei predicati di controllo • Parto da uno slicing criterion C = (n,V) • Ripeto l’iterazione finchè non arrivo ad un punto fisso (l’ultima iterazione non trova nuovi comandi rilevanti) Tecnica backward riconducibile al “reaching definition” Corso di Analisi e Verifica di Programmi 2005/2006

  10. Dataflow Equation – Definizioni • CFG – Control Flow Graph • Ogni comando del programma è un nodo • Arco dal nodo i al nodo j corrisponde a possibile control flow da i a j • Nodi speciali : Start e Stop • DEF(i): insiemi di variabili definite al nodo i • REF(i): insiemi di variabili referenziate al nodo i • INFL(i): insiemi di nodi influenzati da i Corso di Analisi e Verifica di Programmi 2005/2006

  11. CFG – Control Flow Graph (2) (3) (4) (1) (5) Start read(n) i:=1 sum:=0 product:=1 i<=n sum:= sum+i (6) (10) (9) Stop write(product) write(sum) product:= product*i (7) i:=i+1 (1) read (n); (2) i := 1; (3) sum := 0; (4) product := 1; (5) while i<= n do begin (6) sum:= sum +i ; (7) product := product *i; (8) i:= i + 1; end (9) write(sum); (10) write (product) CFG del programma (8) Corso di Analisi e Verifica di Programmi 2005/2006

  12. Dataflow Equation - Algoritmo Iterazione 0 Variabili direttamente rilevanti R0C(i): • R0C(i)= V quando i = n • per ogni arco da i a j nel CFG, R0C(i) contiene tutte le variabili v tali che • o 1) v Î R0C(j) e vÏDEF(i) • o 2) vÎREF(i) e DEF(i)∩ R0C(j) ≠ Comandi direttamente rilevanti S0C: S0C= {i| DEF(i) ∩ R0C(j) ≠ , per ogni j successore di i} Comandi indirettamente rilevanti B0C: B0C= {b| i Î S0C , iÎINFL (b) } Corso di Analisi e Verifica di Programmi 2005/2006

  13. Esecuzione algoritmo   {i} {i} {product , i} {product} {product ,i} {product , i} {product , i} {product} {product} {product} (1) read (n); (2) i := 1; (3) sum := 0; (4) product := 1; (5) while i<= n do begin (6) sum:= sum +i ; (7) product := product *i; (8) i:= i + 1; end (9) write(sum); (10) write (product) C=(10,{product}) S0C={2,4,7,8} B0C={5} C1=(5,{i,n}) Corso di Analisi e Verifica di Programmi 2005/2006

  14. Dataflow Equation - Algoritmo Iterazione k+1 Variabili indirettamente rilevanti Rk+1C(i): • Rk+1C(i)= RkC(i) È È R0(b,REF(b))(i) Comandi indirettamente rilevanti S0C: Sk+1C= BkC È{i| DEF(i) ∩ Rk+1C(j) ≠, per ogni j successore di i} Comandi indirettamente rilevanti B0C: Bk+1C= {b| i Î Sk+1C , iÎINFL (b) } Il punto fisso della computazione di Sk+1C costituisce lo slice del programma bBkC Corso di Analisi e Verifica di Programmi 2005/2006

  15. Esecuzione algoritmo  {n} {i,n} {i,n} {i,n} {i,n} {i,n} {i,n} C1=(5,{i,n}) Corso di Analisi e Verifica di Programmi 2005/2006

  16. Esecuzione algoritmo (1) read (n); (2) i := 1; (3) sum := 0; (4) product := 1; (5) while i<= n do begin (6) sum:= sum +i ; (7) product := product *i; (8) i:= i + 1; end (9) write(sum); (10) write (product) S1C={1,2,4,5,7,8} Corso di Analisi e Verifica di Programmi 2005/2006

  17. PDG Approach – Horwitz, Reps e Binkley Il P.D.G. del programma P, denotato con GP, è un grafo orientato I veritci del GP rappresentano: • Assignment statments: Comandi di assegnamento • Control predicates: Predicati di controllo (if, while) Inoltre, sono presenti tre altre categorie di vertici: • Entry vetrex • Finale Use(x): Per ogni variabile x presente nel comando end, c’è un vertice chiamato final use di x. Rappresenta il valore finale di x in P. Corso di Analisi e Verifica di Programmi 2005/2006

  18. Program Main sum := 0 i := 1 while i < 11 do sum := sum+i; i := i+1 od end(sum,i) ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) sum := sum+i i := i +1 Corso di Analisi e Verifica di Programmi 2005/2006

  19. Program Dependence Graph Un arco del GP rappresenta dipendenze tra le componenti del programma Control dependence • Etichettati con true o false • Partono da un entry vertex o da un predicate vertex • Etichettato con v1→c v2, significa che durante l’esecuzione, ogni qual volta il comando rappresentato da v1 viene valutato e il suo valore fa match con l’etichetta dell’arco verso v2, allora la parte del programma rappresentata da v2 viene eseguita GP contiene un arco control dependence da v1 a v2 se sono soddisfatte una delle seguenti condizioni: • v1 è un entry vertex e v2 rappresenta una componente di P che non è inserita all’interno di un comando if o while; l’arco è etichettato con true • v1 rappresenta un predicato di controllo e v2 rappresenta una componente di P inserito all’interno del while o dell’if • Caso while: arco etichettato con true • Caso if: arco è etichettato con true se v2 occorre nel then, con false se occorre nell’else Corso di Analisi e Verifica di Programmi 2005/2006

  20. Program Main sum := 0 i := 1 while i < 11 do sum := sum+i; i := i+1 od end(sum,i) ENTRY T T T T T sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) T T sum := sum+i i := i +1 Corso di Analisi e Verifica di Programmi 2005/2006

  21. Program Dependence Graph Data dependence • Dal vertice v1 a v2 significa che la computazione del programma P cambia se l’ordine relativo delle componenti rappresentate da v1 e v2 è invertito Flow dependences (v1→f v2) da v1 a v2 se tutte le seguenti condizioni sono soddisfatte: • v1 definisce la variabile x • v2 usa la variabile x • C’è un cammino nel control flow nel quale la definizione di x di v1 “arriva” a v2 Può essere classificata in: Loop carried: generata dal loop L, v1→lc(L) v2 Loop indipendent: denotata con v1→li v2 Corso di Analisi e Verifica di Programmi 2005/2006

  22. Program Main sum := 0 i := 1 while i < 11 do sum := sum+i; i := i+1 od end(sum,i) ENTRY T T T T T sum := 0 i := 1 while i < 11 FinalUse(i) FinalUse(sum) T T sum := sum+i i := i +1 Corso di Analisi e Verifica di Programmi 2005/2006

  23. Program Slices - Definizione Per il vertice s del program dependence graph G, lo slice di G che rispetta s, denotato G/s è: • Un grafo contenente tutti i vertici con i quali s ha una dipendenza flow o control • Tutti i vertici che possono “raggiungere” (reach) s attraverso un arco flow e/o control V(G/s) = { w | w V(G) and w →*c,f s } Possiamo estendere la definizione ad un insieme di vertici S = i si : V(G/S) = i V(G/si) Gli archi del grafico G/S sono essenzialmente quelli di G inclusi da V(G/S), formalmente: E(G/S) = {(v →f w) | (v →f w) E(G) and v,w V(G/S)} {(v →c w) | (v →c w) E(G) and v,w V(G/S)} Corso di Analisi e Verifica di Programmi 2005/2006

  24. Program Main i := 1 while i < 11 do i := i+1 od end(i) Program Main sum := 0 i := 1 while i < 11 do sum := sum+i; i := i+1 od end(sum,i) Slice che rispetta il vertice FinalUse(i) ENTRY ENTRY T T T T T sum := 0 i := 1 i := 1 while i < 11 while i < 11 FinalUse(i) FinalUse(sum) T T sum := sum+i i := i +1 i := i +1 Corso di Analisi e Verifica di Programmi 2005/2006

  25. Interprocedural Static Slicing Corso di Analisi e Verifica di Programmi 2005/2006

  26. Dataflow Equation - Weiser Approccio a due fasi • Computo la slice della procedura P che contiene il criterio originale • Creo nuovi criteri per procedure Q chiamate da P e per procedure R che chiamano P Le fasi si ripetono finchè non ci sono più nuovi criteri da generare Corso di Analisi e Verifica di Programmi 2005/2006

  27. Dataflow Equation – Fase 1 1.Computo la slice della procedura che contiene il criterio originale: • MOD(P) e USE(P) delle procedure chiamate da Example • Chiamata a procedura trattata come se definisse tutte le variabili in MOD e usasse le variabili in USE della procedura stessa (parametri attuali sostituiti a quelli formali) • Problema: slice impreciso Potrebbe esser tolto perché P non usa a per calcolare d ma Weiser considera rilevanti tutti i parametri passati a P (non considera dipendenze input output) REF(4)={a,b} DEF(4)={c,d} C USE(P)={v,w} MOD(P)={x,y} Corso di Analisi e Verifica di Programmi 2005/2006

  28. Dataflow Equation – Fase 2 2. Creo nuovi criteri: • per procedure Q chiamate da P e • per procedure R che chiamano P I nuovi criteri: • (nq,Vq) – nqultimo comando di Q, Vqvariabili rilevanti in P che sono nello scope di Q (formali sostituiti agli attuali) • (NR,VR) – NRchiamata a P in R, VRvariabili rilevanti al primo comando di P che sono nello scope di R (attuali sostituiti ai formali) Funzioni UP e DOWN formalizzano: • UP(S) : un insieme di criteri per le procedure che chiamano P • DOWN(S): un insieme di criteri per le procedure chiamate da P Corso di Analisi e Verifica di Programmi 2005/2006

  29. Esempio Calling Context: quando la computazione scende in una procedura Q chiamata da P risalirà a tutte le procedure che chiamano Q non solo a P C=(10,{product}) USE(Add)={a,b} MOD(Add) ={a} USE(Multiply) ={c,d} MOD(Multiply) ={c} Nuovi Criteri: UP(10, {product})= DOWN(10,{product})=(11,{a}), (17, {c,d}) Applicando passo 1 ottengo la slice: {1,2,4,5,7,8} Problema : generando lo slice sulla procedura Multiply le chiamate a Add (15,16) causa la generazione di un nuovo criterio (11,{a,b}) reslicing di Add Corso di Analisi e Verifica di Programmi 2005/2006

  30. System Dependence Graph – Horwitz, Reps e Binkley Il System Dependence Graph è un’estensione del PDG per la gestione di procedure e delle chiamate a procedura ed include: • Program Dependence Graph: rappresenta il programma main • Procedure Dependence Graphs: rappresentano le procedure ausiliarie Assunzione: paramentri passati per valore Obbiettivi della progettazione del SDG : • costruire il Procedure Depencence Graph attraverso la conoscenza minima degli altri componenti del sistema • facile costruire, possibilmente in modo diretto, il SDG partendo dal PDG e dai vari procedure dependence graphs • possibile estrarre uno slice interprocedurale preciso in modo efficiente Corso di Analisi e Verifica di Programmi 2005/2006

  31. Passaggio dei parametri Il meccanismo per il passaggio dei parametri è il seguente: Quando la procedura P chiama la procedura Q: • Prima della chiamata, P copia i valori dei parametri attuali nelle call temporaries • Q inizializza i propri parametri formali da queste temporaries • Prima della fase di ritorno, Q copia i valori di ritorno nelle return temporaries • P preleva i valori da queste temporaries Corso di Analisi e Verifica di Programmi 2005/2006

  32. Passaggio dei parametri Questo modello viene rappresentato nel procedure dependence graph attraverso l’utilizzo di seguenti nuovi tipi di vertici: • Call site vertex: rappresenta il punto della chiamata L’informazione trasferita viene rappresentata da quattro tipi di paremeter vertices: Dalla parte del chiamante, insieme di vertici actual-in e actual-out • Rappresentano gli assegnamenti che copiano i valori dei parametri attuali nelle call temporaries e delle return temporaries nei parementri attuali, ripettivemente • control dependent con call site vertex • actual-in è etichettato con r_in := e • actual-out vertex, etichettato con a:= r_out Nota: tutti i parametri sono copiati nelle call temporaries e tutti vengono prelevati dalle return temporaries Corso di Analisi e Verifica di Programmi 2005/2006

  33. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A call Add call Inc a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out Program Main sum := 0 i := 1 while i <11 call A (sum,i) od end(sum,i) Procedure A(x,y) call Add(x,y) call Increment (y) return Procedure Add(a,b) a := a+b return ENTER Add Procedure Increment(a,b) call Add(z,1) return a := a+b Corso di Analisi e Verifica di Programmi 2005/2006

  34. Passaggio dei parametri Dalla parte della procedura chiamata, insieme di vertici formal-ine formal-out • Copiano i valori dalle call temporaries nei paramentri formali e dai parametri formali alle return temporaries • control dependent con entry vertex della procedura • formal-in e un formal-out vertex, etichettati con r := r_in e r_out:=r, ripettivemente Corso di Analisi e Verifica di Programmi 2005/2006

  35. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A x := x_in y := y_in call Add call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out Program Main sum := 0 i := 1 while i <11 call A (sum,i) od end(sum,i) Procedure A(x,y) call Add(x,y) call Increment (y) return Procedure Add(a,b) a := a+b return ENTER Add Procedure Increment(a,b) call Add(z,1) return a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

  36. System Dependence Graph - Costruzione La generazione del System Depencence Graph partendo da: • Program Dependence Graph • Procedure Dependence Graphs si effettua in modo diretto, con l’aggiunta di tre nuovi tipi di archi: • Call edge: viene aggiunto da ogni call-site vertex al corrispondente procedure-entry vertex • Parameter-in edge: viene aggiunto da ogni actual-in vertex al corrispondente formal-in vertex nella procedura chiamata • Parameter-out vertex: viene aggiunto da ogni formal-out vertex nella procedura chiamata alla corrispondente actual-out vertex del punto di chiamata Corso di Analisi e Verifica di Programmi 2005/2006

  37. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A x := x_in y := y_in call Add call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out Program Main sum := 0 i := 1 while i <11 call A (sum,i) od end(sum,i) Procedure A(x,y) call Add(x,y) call Increment (y) return ENTER Inc Procedure Add(a,b) a := a+b return z := z_in call Add z_out := z Procedure Increment(a,b) call Add(z,1) return a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

  38. Interprocedural Slicing - Limite Lo slicing interprocedurale può essere pensato come un problema di raggiungibilità, come visto per lo slice di tipo intraprocedurale Fornisce lo stesso risultato dell’ algoritmo interprocedurale fornito da Weiser, cioè, una slice non precisa perché fallisce nel tenere in considerazione il calling context di una procedura chiamata Corso di Analisi e Verifica di Programmi 2005/2006

  39. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A x := x_in y := y_in call Add call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out Il valore di i dopo la chiamata alla procedura A è dipendente dal valore di sum prima della chiamata ENTER Inc z := z_in call Add z_out := z a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

  40. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A x := x_in y := y_in call Add call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out Il cammino corrisponde alla chiamata della procedura Add da A, ma viene ritornata la procedura Increment ENTER Inc z := z_in call Add z_out := z a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

  41. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A x := x_in y := y_in call Add call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out Non tutti i cammini corrispondono ad un possibile cammino di esecuzione ENTER Inc z := z_in call Add z_out := z a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

  42. Realizable Path Si devono considerare solamente i • Realizable paths: cammini che riflettono il fatto che, quando una chiamata a procedura termina, l’esecuzione ritorna al più punto di chiamata più recente per quella procedura Il processo per determinare se un cammino èsame-level realizable path è il seguente: • Assegna ad ogni call vertex in SDG un numero unico da 1 a k • Per ogni punto di chiamata ci, etichetta: • L’arco parameter-in uscente con il simbolo “(i” • L’arco parameter-out entrante con il simbolo “)i” • Il call edge con “(i” • Un cammino in G viene definito same-level realizable path sse la sequenza dei simboli che identificano gli archi parameter-in, parameter-out e call nel cammino è una stringa del linguaggio delle “parentesi bilanciate” generato dalle seguente grammatica: matched → matched (i matched )i | ε per 1 ≤ i ≤ k Corso di Analisi e Verifica di Programmi 2005/2006

  43. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) 1 call A y_in := i sum := x_out i := y_out x_in := sum ENTER A 2 x := x_in y := y_in call Add 3 call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out Il linguaggio generato è: (1 (2 )4 )3 )1 ENTER Inc z := z_in call Add z_out := z 4 a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

  44. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) 1 call A y_in := i sum := x_out i := y_out x_in := sum ENTER A 2 x := x_in y := y_in call Add 3 call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out Il linguaggio generato è: (1 (2 )2 )1 ENTER Inc z := z_in call Add z_out := z 4 a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

  45. Summary Edge Per fare in modo che l’algoritmo per lo slicing interprocedurale si basi solo sui same-level realizable path si deve introdurre una nuova tipologia di archi: Summary edge • Inserito dal actual-in v (valore del parametro attuale x prima della chiamata) al actual-out w (valore del parametro attuale y dopo la chiamata) rappresenta il fatto che il valore di y dopo la chiamata dipende dal valore di x prima della chiamata • permette di superare il problema del “calling context”: le operazioni per determinare lo slice possono muoversi “attraverso” una chiamata senza dover descendere dentro essa Corso di Analisi e Verifica di Programmi 2005/2006

  46. Speeding Up Slicing – Reps, Hortwitz, Sogiv e Rosay Idea: Trovare per ogni procedura P, tutti i same-realizable path che partono da un formal-in vertex della procedura P e che terminano in un formal-out vertex della procedura stessa actual-in actual-out formal-out qualsisi tipo y x w formal-in formal-out x v w v parameter-in o parameter-out edge path edge v ≠ formal-in (possibile nuovo) path edge nuovo summary edge Corso di Analisi e Verifica di Programmi 2005/2006

  47. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A x := x_in y := y_in call Add call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out ENTER Inc z := z_in call Add z_out := z a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in b := b_in a := a+b a_out := a a_out := a b_out := b b_out := b a := a_in b := b_in Corso di Analisi e Verifica di Programmi 2005/2006

  48. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A x := x_in y := y_in call Add call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out ENTER Inc z := z_in call Add z_out := z a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

  49. Interprocedural Slicing - Algoritmo La computazione dello slice del SDG G che rispetta l’insieme di vertici S nella procedura P viene eseguito in due fasi: PRIMA FASE • Seguiti flow edges, control edges, call edges, e parameter-in edges • Identifica i vertici che possono raggiungere S, e che sono sia in P o in una procedura che chiama P (o direttamente o transitivamente) • Summary edges permettono di conoscere i vertici che possono raggiungere S solamente attraverso una chiamata a procedura, senza discendere nelle procedure chiamate da P Corso di Analisi e Verifica di Programmi 2005/2006

  50. ENTER Main sum := 0 i := 1 while i < 11 FinalUse(sum) FinalUse(i) call A y_in := i sum := x_out i := y_out x_in := sum ENTER A x := x_in y := y_in call Add call Inc x_out := x y_out := y a_in = x b_in := y x := a_out y := b_out z_in := y y := z_out ENTER Inc z := z_in call Add z_out := z a_in := z b_in := 1 z := a_out ENTER Add a := a_in b := b_in a := a+b a_out := a b_out := b Corso di Analisi e Verifica di Programmi 2005/2006

More Related