![Page 1: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/1.jpg)
Métodos para la construcción de software fiable: Análisis estático
María del Mar Gallardo MelgarejoPedro Merino Gómez
Dpto. de Lenguajes y Ciencias de la ComputaciónUniversidad de Málaga
(gallardo,pedro)@lcc.uma.es
![Page 2: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/2.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
2
Tres técnicas
– Análisis del flujo de datos– Interpretación Abstracta
– Model checking
– Abstract Model checking
Análisis estático
Análisis dinámico
![Page 3: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/3.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
3
Análisis estático
– Conjunto de técnicas para predecir en tiempo de compilación aproximaciones correctas y computablesdel conjunto de valores o comportamientos que pueden ocurrir dinámicamente cuando un programa se ejecuta en un computador.
– Objetivos• Optimización del código generado por el compilador• Validación del software
![Page 4: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/4.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
4
Ejemplo:Terminación y aproximación
read(x);
if x>0 then
y:=1
else
y:=2;S;(S no contiene asignaciones a y)
{¿qué valores toma y en este punto cualquieraque sea la ejecución de este programa?}
z := y
![Page 5: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/5.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
5
Ejemplo:Terminación y aproximación
read(x);
if x>0 then
y:=1
else
y:=2;S;(S no contiene asignaciones a y)
{{y = 1}, {y = 2}} Respuesta correctaz := y
![Page 6: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/6.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
6
Ejemplo:Terminación y aproximación
read(x);
if x>0 then
y:=1
else
y:=2;S;(S no contiene asignaciones a y)
{{y = 1}} Respuesta correcta?
z := ysi S no termina es correcta ymás precisa que {{y = 1}, {y = 2}}
![Page 7: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/7.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
7
Ejemplo:Terminación y aproximación
read(x);if x>0 theny:=1
elsey:=2;S;(S no contiene asignaciones a y)
{{y = 1}, {y = 2}, {y = 27}} Respuesta correcta?z := y
• Es correcta pero menos precisa que {{y = 1}, {y = 2}}
• El reto está en encontrar respuestas útiles y correctas.
• Esta respuesta puede ser útil. Sabemos que y puede almacenarse en un byte de memoria.
![Page 8: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/8.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
8
Ejemplo:Terminación y aproximación
read(x);
if x>0 then
y:=1
else
y:=2;S;(S no contiene asignaciones a y)
{x es entero}z := y
• Esta respuesta es correcta pero es poco útil
![Page 9: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/9.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
9
Lenguaje WHILE[y := x]1 ; [z := 1]2 ;while [y > 1]3 do
([z := z * y]4 ; [y := y - 1]5);[y := 0]6
– Tests– Asignaciones– Selecciones– Bucles– Cada bloque elemental tiene asociada una etiqueta que
representa un punto del programa donde se obtiene información
![Page 10: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/10.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
10
Ejemplo: Análisis del ámbito de las definiciones
– Definición = Asignación– La definición [x := a]l alcanza el punto p del programa
(típicamente la entrada o salida de un bloque elemental) sii
• hay una ejecución del programa en la que se pasa por el punto p y
• la última vez que se le asignó un valor a x fue en l.
– En el ejemplo, [y:=x]1 alcanza [z := 1]2 o, de forma simplificada, el punto 2.
– El análisis viene dado por RD = (RDentry, RDexit)
![Page 11: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/11.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
11
Ejemplo: Análisis del ámbito de las definiciones (AAD)
[y:=x]1 ; [z := 1]2 ;
while [y > 1]3 do
([z := z * y]4 ; [y := y - 1]5);
[y := 0]6
l RDentry(l) RDexit(l) 1 2 3 4 5 6
(x,?), (y,?), (z,?) (x,?), (y,1), (z,?) (x,?), (y,1), (y,5), (z,2), (z,4) (x,?), (y,1), (y,5), (z,2), (z,4) (x,?), (y,1), (y,5), (z,4) (x,?), (y,1), (y,5), (z,2), (z,4)
(x,?), (y,1), (z,?) (x,?), (y,1), (z,2) (x,?), (y,1), (y,5), (z,2), (z,4)(x,?), (y,1), (y,5), (z,4) (x,?), (y,5), (z,4) (x,?), (y,6), (z,2), (z,4)
![Page 12: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/12.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
12
Ejemplo: Análisis del ámbito de las definiciones (AAD)
[y:=x]1 ; [z := 1]2 ;
while [y > 1]3 do
([z := z * y]4 ; [y := y - 1]5);
[y := 0]6
l RDentry(l) RDexit(l) 1 2 3 4 5 6
(x,?), (y,?), (z,?) (x,?), (y,1), (z,?) (x,?), (y,1), (y,5), (z,2), (z,4) (x,?), (y,1), (y,5), (z,2), (z,4) (x,?), (y,1), (y,5), (z,4), (z,2) (x,?), (y,1), (y,5), (z,2), (z,4)
(x,?), (y,1), (z,?) (x,?), (y,1), (z,2) (x,?), (y,1), (y,5), (z,2), (z,4) (x,?), (y,1), (y,5), (z,4) (x,?), (y,5), (z,4) (x,?), (y,6), (z,2), (z,4)
![Page 13: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/13.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
13
Análisis de flujo de datos
[y:=x]1 ; [z := 1]2 ;
while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5);
[y := 0]6
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
![Page 14: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/14.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
14
Análisis de flujo de datosMétodo ecuacional
RDexit(1) = (RDentry(1) \ {(y,l)| l ∈ Lab}) ∪ {(y,1)} RDexit(2) = (RDentry(2) \ {(z,l)| l ∈ Lab}) ∪ {(z,2)} RDexit(3) = RDentry(3) RDexit(4) = (RDentry(4) \ {(z,l)| l ∈ Lab}) ∪ {(z,4)} RDexit(5) = (RDentry(5) \ {(y,l)| l ∈ Lab}) ∪ {(y,5)} RDexit(6) = (RDentry(6) \ {(y,l)| l ∈ Lab}) ∪ {(y,6)}
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
Se extraen dos tipos de ecuacionesUna que relaciona la salida/entrada en un mismo bloque
![Page 15: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/15.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
15
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
Otra que relaciona la información de entrada de un bloquecon la de salida de todos los bloques que se conectan con él
RDentry(2) = RDexit(1) RDentry(3) = RDexit(2) ∪ RDexit(5) RDentry(4) = RDexit(3) RDentry(5) = RDexit(4) RDentry(6) = RDexit(3)
![Page 16: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/16.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
16
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
Inicialmente
RDentry(1) = {(x,?),(y,?),(z,?)}
![Page 17: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/17.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
17
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)}
{}{}{}
{}{}
{}{}
{}{}
{}
{}
entry
exit
![Page 18: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/18.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
18
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{}{}
{}{}
{}{}
{}{}
{}
{}
![Page 19: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/19.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
19
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{}
{}{}
{}{}
{}{}
{}
{}
{(x,?),(y,1),(z,?)}
![Page 20: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/20.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
20
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{}{}
{}{}
{}{}
{}
{}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
![Page 21: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/21.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
21
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{}{}{}
{}{}
{}
{}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
![Page 22: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/22.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
22
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{}{}
{}{}
{}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{}
![Page 23: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/23.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
23
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{}
{}{}
{}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
![Page 24: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/24.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
24
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{}{}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,6),(z,2)}
{(x,?),(y,1),(z,4)}
![Page 25: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/25.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
25
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,6),(z,2)}
{(x,?),(y,1),(z,4)}{(x,?),(y,1),(z,4)}
![Page 26: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/26.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
26
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,6),(z,2)}
{(x,?),(y,1),(z,4)}{(x,?),(y,1),(z,4)}
{(x,?),(y,5),(z,4)}
![Page 27: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/27.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
27
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,6),(z,2)}
{(x,?),(y,1),(z,4)}{(x,?),(y,1),(z,4)}
{(x,?),(y,5),(z,4)}
![Page 28: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/28.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
28
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,2)}
{(x,?),(y,6),(z,2)}
{(x,?),(y,1),(z,4)}{(x,?),(y,1),(z,4)}
{(x,?),(y,5),(z,4)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,?)}
![Page 29: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/29.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
29
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,6),(z,2)}
{(x,?),(y,1),(z,4)}{(x,?),(y,1),(z,4)}
{(x,?),(y,5),(z,4)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}{(x,?),(y,1),(z,2),(y,5),(z,4)}}
![Page 30: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/30.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
30
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,4)}
{(x,?),(y,5),(z,4)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(z,2),(y,6),(z,4)}}
{(x,?),(y,1),(y,5),(z,4)}}
![Page 31: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/31.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
31
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,5),(z,4)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(z,2),(y,6),(z,4)}}
{(x,?),(y,1),(y,5),(z,4)}}{(x,?),(y,1),(y,5),(z,4)}}
![Page 32: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/32.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
32
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}} {(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(z,2),(y,6),(z,4)}}
{(x,?),(y,1),(y,5),(z,4)}}{(x,?),(y,1),(y,5),(z,4)}}
{(x,?),(y,5),(z,4)}}
![Page 33: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/33.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
33
Análisis de flujo de datosMétodo ecuacional
no
si
[y := x]1
[z := 1]2
[y > 1]3
[z := z * y]4
[y := y - 1]5
[y := 0]6
{(x,?),(y,?),(z,?)} {(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,?)}
{(x,?),(y,1),(z,2)}
{(x,?),(y,1),(z,2),(y,5),(z,4)}} {(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(y,1),(z,2),(y,5),(z,4)}}{(x,?),(y,1),(z,2),(y,5),(z,4)}}
{(x,?),(z,2),(y,6),(z,4)}}
{(x,?),(y,1),(y,5),(z,4)}}{(x,?),(y,1),(y,5),(z,4)}}
{(x,?),(y,5),(z,4)}}
Punto fijo
![Page 34: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/34.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
34
AFD. Método EcuacionalLa menor solución• El sistema de ecuaciones anterior puede escribirse como una
función que transforma conjuntos de definiciones - pares del tipo (var,lab) - en conjuntos de definiciones
F : (℘ (Var* × Lab*))12 � (℘ (Var* × Lab*))12
Var*={x,y,z} y Lab ={1,…,6,?}
F(RD) = (Fentry(1)(RD), Fexit(1)(RD), … , Fentry(12)(RD), Fexit(12)(RD))
P. e. Fentry(3)(…, RDexit(2), … ,RDexit(5), … ) = RDexit(2) ∪ RDexit(5)
– Buscamos RD tal que F(RD) = RD
![Page 35: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/35.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
35
AFD. Método Ecuacional.La menor solución #2
– (℘ (Var* × Lab*))12 está parcialmente ordenadoRD ⊆ RD' sii ∀ i : RDi ⊆ RD'i, siendo RD = (RD1, … , RD12) y RD' = (RD'1, … , RD'12)
![Page 36: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/36.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
36
AFD. Método Ecuacional.La menor solución #2
– (℘ (Var* × Lab*))12 está parcialmente ordenadoRD ⊆ RD' sii ∀ i : RDi ⊆ RD'i, siendo RD = (RD1, … , RD12) y RD' = (RD'1, … , RD'12)
– ((℘ (Var* × Lab*))12 , ⊆ ) es un retículo completo• ∅ = (∅ , …, ∅ ) es el ínfimo• RD ∪ RD' = (RD1 ∪ RD'1, … , RD12 ∪ RD'12)
![Page 37: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/37.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
37
AFD. Método Ecuacional.La menor solución #2
– (℘ (Var* × Lab*))12 está parcialmente ordenadoRD ⊆ RD' sii ∀ i : RDi ⊆ RD'i, siendo RD = (RD1, … , RD12) y RD' = (RD'1, … , RD'12)
– ((℘ (Var* × Lab*))12 , ⊆ ) es un retículo completo• ∅ = (∅ , …, ∅ ) es el ínfimo• RD ∪ RD' = (RD1 ∪ RD'1, … , RD12 ∪ RD'12)
– F es una función monótona sobre ((℘ (Var* × Lab*))12 , ⊆ )
![Page 38: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/38.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
38
AFD. Método Ecuacional.La menor solución #2
– (℘ (Var* × Lab*))12 está parcialmente ordenadoRD ⊆ RD' sii ∀ i : RDi ⊆ RD'i, siendo RD = (RD1, … , RD12) y RD' = (RD'1, … , RD'12)
– ((℘ (Var* × Lab*))12 , ⊆ ) es un retículo completo• ∅ = (∅ , …, ∅ ) es el ínfimo• RD ∪ RD' = (RD1 ∪ RD'1, … , RD12 ∪ RD'12)
– F es una función monótona sobre ((℘ (Var* × Lab*))12 , ⊆ )
– (℘ (Var* × Lab*))12 es finito
![Page 39: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/39.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
39
AFD. Método Ecuacional.La menor solución #2
– (℘ (Var* × Lab*))12 está parcialmente ordenadoRD ⊆ RD' sii ∀ i : RDi ⊆ RD'i, siendo RD = (RD1, … , RD12) y RD' = (RD'1, … , RD'12)
– ((℘ (Var* × Lab*))12 , ⊆ ) es un retículo completo• ∅ = (∅ , …, ∅ ) es el ínfimo• RD ∪ RD' = (RD1 ∪ RD'1, … , RD12 ∪ RD'12)
– F es una función monótona sobre ((℘ (Var* × Lab*))12 , ⊆ )
– (℘ (Var* × Lab*))12 es finito– ∅ ⊆ F(∅ ) ⊆ F2(∅ ) ⊆ … ⊆ Fm(∅ ) ⊆ se estabiliza
en el menor punto fijo
![Page 40: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/40.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
40Algoritmo para calcular el menor punto fijo
– Buscamos RD tal que RD = F(RD)– donde F: (℘ (Var* × Lab* ))12 → (℘ (Var* × Lab* ))12
– es una función monótona – (℘ (Var* × Lab* ))12 es finito
– la solución deseada se puede obtener como Fn(∅ ) para cualquier n tal que Fn(∅ ) = Fn+1(∅ )
– sabemos que dicho n además existe.
![Page 41: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/41.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
41
Algoritmos. Iteración CaóticaRD = (RD1, …, RD12)F(RD) = (F(RD1), …, F(RD12))
INPUT: Ecuaciones del ejemplo para el análisis del ámbito de definiciones.
OUTPUT: La menor solución RD = (RD1, …, RD12)
MÉTODO: Paso 1: InicializaciónRD1 := ∅ ; …; RD12 := ∅
Paso 2: Iteraciónwhile RDj ≠ Fj(RD1,…, RD12) para algún j do
RDj = Fj (RD1, …, RD12)
![Page 42: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/42.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
42
Otros análisis de flujo de datos
• Análisis de las expresiones disponiblesAvailable expressions -- AE
• Análisis del ámbito de las definiciones (2)Reaching definitions -- RD
• Análisis de las expresiones muy ocupadasVery busy expressions -- VBE
• Análisis de las variables libresLive variables -- LV
![Page 43: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/43.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
43
Terminología: Etiquetas iniciales
– Stmt ::= [x:=a]l | [skip]l | Stmt ; Stmt | if [b]l then Stmt else Stmt | while [b]l do Stmt
– init : Stmt � Labdevuelve la etiqueta inicial de una instrucción
init([x:=a]l) = linit([skip]l) = linit(S1 ; S2) = init(S1)init(if [b]l then S1 else S2) = linit(while [b]l do S) = l
![Page 44: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/44.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
44
Terminología: Etiquetas finales
– final:Stmt � ℘ (Lab)devuelve el conjunto de etiquetas finales de una instrucción
final([x:=a]l) = lfinal([skip]l) = lfinal(S1 ; S2) = final(S2)final(if [b]l then S1 else S2) = final(S1) ∪ final(S2)final(while [b]l do S) = l
![Page 45: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/45.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
45
Terminología: Bloques
– Blocks ::= [x:=a]l | [skip]l | [b]l
– blocks : Stmt � ℘ (Blocks)Para acceder a las instrucciones simples o tests asociados a una instrucción usamos la función blocks
blocks([x:=a]l) = {[x.=a]l}blocks([skip]l) = {[skip]l}blocks(S1 ; S2) = blocks(S1) ∪ blocks(S2)blocks(if [b]l then S1 else S2) =
{[b]l} ∪ blocks(S1) ∪ blocks(S2)blocks(while [b]l do S) = {[b]l} ∪ blocks(S)
![Page 46: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/46.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
46
Terminología: Etiquetas
– labels: Stmt � ℘ (Lab)etiquetas de una instrucción
– labels(S) = {l | [B]l ∈ blocks(S)}
– Claramente– init(S) ∈ labels(S) – final(S) ⊆ labels(S)
![Page 47: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/47.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
47
Terminología: Flujo de datos
– flow : Stmt � ℘ (Lab × Lab)• Asocia instrucciones con conjuntos de flechas
flow([x.=a]l) = ∅flow([skip]l) = ∅flow(S1 ; S2) = flow(S1) ∪ flow(S2)
∪ {(l,init(S2)) | l ∈ final(S1)}flow(if [b]l then S1 else S2) = flow(S1) ∪ flow(S2)
∪ {(l,init(S1)), (l,init(S2))}flow(while [b]l do S) =flow(S)
∪ {(l,init(S))} ∪ {(l',l) | l' ∈ final(S)}
![Page 48: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/48.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
48
Terminología: Flujo de datos #2labels(S) y flow(S) representan el grafo S
Power = [z:=1]1 ; while [x > 0]2 do ([z := z * y]4 ; [x := x - 1]5)
• init(power) = 1• final(power) = {2} • labels(power) = {1,2,3,4}• flow(power) =
{(1,2), (2,3), (3,4), (4,2)}
no
si
[z := 1]1
[x > 0]2
[z := z * y]3
[x :=x - 1]4
![Page 49: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/49.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
49
Terminología: Flujo de datos #3
flow se utiliza en la formalización de los análisis hacia delante (que siguen la misma dirección que el flujo de datos)
– labels(S) = {init(S)} ∪{l | (l,l') ∈ flow(S)} ∪{l' | (l,l') ∈ flow(S)}
– si S ≠ [B]l
labels(S) = {l | (l,l') ∈ flow(S)} ∪{l' | (l,l') ∈ flow(S)}
no
si
[z := 1]1
[x > 0]2
[z := z * y]3
[x :=x - 1]4
![Page 50: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/50.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
50
Terminología: Flujo de datos #4
– flowR : Stmt � ℘ (Lab × Lab)• flowR(S) = {(l,l') | (l',l) ∈ flow(S)}
flowR(power) ={(2,1), (2,4), (3,2), (4,3)} no
si
[z := 1]1
[x > 0]2
[z := z * y]3
[x :=x - 1]4
![Page 51: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/51.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
51
Análisis del Flujo de datosPreliminares• S* es el programa que estamos analizando (las instrucciones
de alto nivel)• Lab* representa las etiquetas (labels(S*)) que aparecen en S*, • Var* representa las variables de S*
• Blocks* representa los bloques elementales (blocks(S*))• AExp* representa el conjunto de subexpresiones aritméticas
no triviales de S*;– una expresión es trivial si es una variable o una constante.
• AExp(a) y AExp(b) representa el conjunto de subexpresionesaritméticas (booleanas) no triviales de una expresión dada.
![Page 52: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/52.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
52
Análisis del Flujo de datosPreliminares #2• suponemos que el programa S* tiene entradas aisladas, es
decir,– ∀ l ∈ Lab : (l,init(S*)) ∉ flow(S*))Esto ocurre siempre que S* no comience en un bucle while.
• A veces supondremos que el programa también tiene salidas aisladas, es decir,– ∀ l1 ∈ final(S*) ∀ l2 ∈ Lab : (l1,l2) ∉ flow(S*)
• Una instrucción, S, es etiqueta-consistente sii:– [B1]l, [B2]l ∈ blocks(S) implica que B1 = B2
![Page 53: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/53.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
53
Análisis del Flujo de datosPreliminares #3• power tiene entradas aisladas, • Es claramente etiqueta-consistente• No tiene salidas aisladas
no
si
[z := 1]1
[x > 0]2
[z := z * y]3
[x :=x - 1]4
![Page 54: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/54.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
54
Análisis de las Expresiones Disponibles
– Determina:• Para cada punto del programa, las expresiones que han
sido ya calculadas, y que ya no se modifican posteriormente, en todos los caminos que llegan a dicho punto.
• Esta información es útil para evitar la re-computaciónde una expresión. (Nos centramos en expresiones aritméticas)
![Page 55: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/55.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
55
Análisis de las Expresiones Disponibles #2
[x := a+b]1; [y := a * b]2; while [y > a+b]3 do ([a := a + 1]4; [x := a+b]5)
la expresión a + b está disponible cada vez que la ejecución alcanza el test (etiqueta 3) en el bucle; como consecuencia, la expresión no tiene que ser recomputada.
![Page 56: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/56.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
56
Análisis de las Expresiones Disponibles #3
Función killAE
killAE : Blocks* � ℘ (AExp*)• killAE([x := a]l) = {a' ∈ AExp* | x ∈ FV(a')}• killAE([skip]l) = ∅• killAE([b]l) = ∅
– Un bloque mata (kill) una expresión si cualquiera de las variables usadas en la expresión son modificadas en el bloque
– Los bloques de test y skip no matan ninguna expresión y las asignaciones matan cualquier expresión que use la variable que aparece en la parte izquierda de la asignación.
![Page 57: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/57.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
57
Análisis de las Expresiones Disponibles #4
Función genAE
genAE : Blocks* � ℘ (AExp*)
• genAE([x := a]l) = {a' ∈ AExp(a)| x ∉ FV(a')}• genAE([skip]l) = ∅• genAE([b]l) = AExp(b)
• Una expresión generada (gen) es una expresión que es evaluada en el bloque y que no utiliza ninguna de las variables modificadas en el bloque.
![Page 58: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/58.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
58
Análisis de las Expresiones Disponibles #5
Ecuaciones de flujo de datos
• El análisis viene definido por las funciones AEentry y AEexitque aplican etiquetas a conjuntos de expresiones:
AEentry, AEexit : Lab* � ℘ (AExp*)
– AEentry(l) =
– AEexit(l) = (AEentry(l) \ killAE(Bl)) ∪ genAE(Bl) donde Bl ∈ blocks(S*)
∅ , si l = init(S*)∩{AEexit(l') | (l',l) ∈ flow(S*)}, en otro caso
![Page 59: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/59.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
59
Análisis de las Expresiones Disponibles #6
[z := x + y]l; while [true]l' do [skip]l''
• AEentry(l) = ∅• AEentry(l') = AEexit(l) ∩ AEexit(l”)• AEentry(l”) = AEexit(l')
• AEexit(l) = AEentry(l) ∪ {x + y}• AEexit(l') = AEentry(l')• AEexit(l") = AEentry(l")
no
si
[…]l
[… ]l'
[…]l''
![Page 60: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/60.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
60
Análisis de las Expresiones Disponibles #7
• Simplificando• AEentry(l) = ∅• AEentry(l') = {x + y } ∩ AEentry(l')• AEentry(l”) = AEentry(l')
• Estas ecuaciones tienen dos soluciones• (∅ , {x + y}, {x + y})• (∅ , ∅ , ∅ )
• La primera solución da más información: la expresión x + y está disponible cada vez que entramos en l'. Así que pedimos la mayor solución del conjunto de ecuaciones
![Page 61: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/61.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
61
Análisis de las Expresiones Disponibles #8
[x := a + b]1; [y := a * b]2 ;while [y > a + b]3 do ([a := a + 1]4 ; [x := a + b]5)
AEentry(1) = ∅AEentry(2) = AEexit(1)AEentry(3) = AEexit(2) ∩ AEexit(5)AEentry(4) = AEexit(3)AEentry(5) = AEexit(4)
AEexit(1) = AEentry(1) ∪ {a + b}AEexit(2) = AEentry(2) ∪ {a * b}AEexit(3) = AEentry(3) ∪ {a + b}AEexit(4) = AEentry(4) \ {a + b, a*b, a + 1}AEexit(5) = AEentry(5) ∪ {a + b}
l killAE(l) genAE(l)12345
∅∅∅{a + b, a*b, a + 1}∅
{a + b}{a * b}{a + b}∅{a + b}
![Page 62: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/62.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
62Análisis de las Expresiones Disponibles #8AEentry(1) = ∅ AEexit(1) = AEentry(1) ∪ {a + b}AEentry(2) = AEexit(1) AEexit(2) = AEentry(2) ∪ {a * b}AEentry(3) = AEexit(2) ∩ AEexit(5) AEexit(3) = AEentry(3) ∪ {a + b}AEentry(4) = AEexit(3) AEexit(4) = AEentry(4) \ {a + b, a*b, a + 1}AEentry(5) = AEexit(4) AEexit(5) = AEentry(5) ∪ {a + b}
∅∅5∅∅4∅∅3∅∅2∅∅1AEentry(l)AEentry(l)l
{a+b}∅5∅∅4
{a+b}∅3
{a*b}∅2
{a+b}∅1AEentry(l)AEentry(l)l
![Page 63: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/63.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
63Análisis de las Expresiones Disponibles #8AEentry(1) = ∅ AEexit(1) = AEentry(1) ∪ {a + b}AEentry(2) = AEexit(1) AEexit(2) = AEentry(2) ∪ {a * b}AEentry(3) = AEexit(2) ∩ AEexit(5) AEexit(3) = AEentry(3) ∪ {a + b}AEentry(4) = AEexit(3) AEexit(4) = AEentry(4) \ {a + b, a*b, a + 1}AEentry(5) = AEexit(4) AEexit(5) = AEentry(5) ∪ {a + b}
{a+b}∅5∅∅4
{a+b}∅3
{a*b}∅2
{a+b}∅1AEentry(l)AEentry(l)l
{a+b}∅5∅{a+b}4
{a+b}{a+b}3
{a*b}{a+b}2
{a+b}∅1AEentry(l)AEentry(l)l
![Page 64: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/64.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
64Análisis de las Expresiones Disponibles #8AEentry(1) = ∅ AEexit(1) = AEentry(1) ∪ {a + b}AEentry(2) = AEexit(1) AEexit(2) = AEentry(2) ∪ {a * b}AEentry(3) = AEexit(2) ∩ AEexit(5) AEexit(3) = AEentry(3) ∪ {a + b}AEentry(4) = AEexit(3) AEexit(4) = AEentry(4) \ {a + b, a*b, a + 1}AEentry(5) = AEexit(4) AEexit(5) = AEentry(5) ∪ {a + b}
{a+b}∅5∅{a+b}4
{a+b}{a+b}3
{a*b}{a+b}2
{a+b}∅1AEentry(l)AEentry(l)l
{a+b}∅5∅{a+b}4
{a+b}{a+b}3
{a*b,a+b}{a+b}2
{a+b}∅1AEentry(l)AEentry(l)l
![Page 65: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/65.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
65Análisis de las Expresiones Disponibles #8[x := a + b]1; [y := a * b]2 ;while [y > a + b]3 do ([a := a + 1]4 ; [x := a + b]5)AEentry(1) = ∅ AEexit(1) = AEentry(1) ∪ {a + b}AEentry(2) = AEexit(1) AEexit(2) = AEentry(2) ∪ {a * b}AEentry(3) = AEexit(2) ∩ AEexit(5) AEexit(3) = AEentry(3) ∪ {a + b}AEentry(4) = AEexit(3) AEexit(4) = AEentry(4) \ {a + b, a*b, a + 1}AEentry(5) = AEexit(4) AEexit(5) = AEentry(5) ∪ {a + b}
{a+b}∅5∅{a+b}4
{a+b}{a+b}3
{a*b,a+b}{a+b}2
{a+b}∅1AEentry(l)AEentry(l)l
{a+b}∅5∅{a+b}4
{a+b}{a+b}3
{a*b,a+b}{a+b}2
{a+b}∅1AEentry(l)AEentry(l)l
![Page 66: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/66.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
66
Análisis del ámbito de las definiciones (RD)
– Determina:• Para cada punto del programa, qué asignaciones
pueden haber sido hechas y no sobreescritas, cuando la ejecución del programa llega a ese punto a través de algún camino
• La aplicación principal de RD es la construcción de enlaces directos entre los bloques que producen valores y bloques que los usan.
![Page 67: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/67.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
67
RD #2Función killRD
killRD : Blocks* � ℘ (Var* × Lab*?)
• killRD([x := a]l) = {(x,?)} ∪{(x,l')| Bl' es una asignación a x en S*}
• killRD ([skip]l) = ∅• killRD ([b]l) = ∅
– killRD produce el conjunto de pares (var ,label) destruidas por el bloque.
– Una asignación [v:=a] es destruida si el bloque asigna un nuevo valor a la variable.
![Page 68: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/68.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
68
RD #3Función genRD
genRD : Blocks* � ℘ (Var* × Lab*?)
• genRD([x := a]l) = {(x,l)}• genRD([skip]l) = ∅• genRD([b]l) = ∅
– genRD produce el conjunto de pares (var ,label) generadas por el bloque.
– Sólo las asignaciones generan definiciones.
![Page 69: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/69.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
69
RD #5
Ecuaciones de flujo de datos
• El análisis viene definido por las funciones RDentry y RDexit que aplican etiquetas a conjuntos de pares (var,label):
RDentry, RDexit : Lab* � ℘ (Var* × Lab*?)
– RDentry(l) =
– RDexit(l) = (RDentry(l) \ killRD(Bl)) ∪ genRD(Bl)donde Bl ∈ blocks(S*)
{(x,?) | x ∈ FV(S*)} , si l = init(S*)∪∪∪∪ {RDexit(l') | (l',l) ∈ flow(S*)}, en otro caso
![Page 70: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/70.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
70
RD #5
[z := x + y]l; while [true]l' do [skip]l''
• RDentry(l) = {(x,?), (y,?), (z,?)}• RDentry(l') = RDexit(l) ∪ RDexit(l")• RDentry(l") = RDexit(l')
• RDexit(l) = (RDentry(l) \ {(z,?)}) ∪ {(z,l)}• RDexit(l') = RDentry(l')• RDexit(l") = RDentry(l")
no
si
[…]l
[… ]l'
[…]l''
![Page 71: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/71.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
71
RD #6
• SimplificandoRDentry(l') = {(x,?), (y,?), (z,l)} ∪ RDentry(l')
• Estas ecuaciones tienen muchas solucionesS es solución sii {(x,?), (y,?), (z,l)} ⊆ S
• como l' no genera nuevas soluciones, la solución más precisa es {(x,?), (y,?), (z,l)} – nos interesa la menorsolución de la ecuación
![Page 72: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/72.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
72
RD #7[x := 5]1; [y := 1]2;
while [x > 1]3 do ([y := x * y]4 ; [x := x - 1]5)
RDentry(1) = {(x,?), (y,?)}RDentry(2) = RDexit(1) RDentry(3) = RDexit(2) ∪ RDexit(5)RDentry(4) = RDexit(3) RDentry(5) = RDexit(4)
RDexit(1) = (RDentry(1) \ {(x,?), (x,1),(x,5)}) ∪ {(x,l)}RDexit(2) = (RDentry(2) \ {(y,?), (y,2),(y,4)}) ∪ {(y,2)}RDexit(3) = RDentry(3)RDexit(4) = (RDentry(4) \ {(y,?), (y,2),(y,4)}) ∪ {(y,4)}RDexit(5) = (RDentry(5) \ {(x,?), (x,1),(x,5)}) ∪ {(x,5)}
l killAE(l) genAE(l) 1 2 3 4 5
{(x,?), (x,1), (x,5)} {(y,?), (y,2), (y,4)} ∅ {(y,?), (y,2), (y,4)} {(x,?), (x,1), (x,5)}
{(x,1)} {(y,2)} ∅ {(y,4)} {(x,5)}
![Page 73: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/73.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
73
RD #8[x := 5]1; [y := 1]2;
while [x > 1]3 do ([y := x * y]4 ; [x := x - 1]5)
RDentry(1) = {(x,?), (y,?)}RDentry(2) = RDexit(1) RDentry(3) = RDexit(2) ∪ RDexit(5)RDentry(4) = RDexit(3) RDentry(5) = RDexit(4)
RDexit(1) = (RDentry(1) \ {(x,?), (x,1),(x,5)}) ∪ {(x,l)}RDexit(2) = (RDentry(2) \ {(y,?), (y,2),(y,4)}) ∪ {(y,2)}RDexit(3) = RDentry(3)RDexit(4) = (RDentry(4) \ {(y,?), (y,2),(y,4)}) ∪ {(y,4)}RDexit(5) = (RDentry(5) \ {(x,?), (x,1),(x,5)}) ∪ {(x,5)}
l RDentry(l) RDexit(l) 1 2 3 4 5
{(x,?), (y,?)} {(x,1), (y,?)} {(x,1), (y,2), (y,4), (x,5)} {(x,1), (y,2), (y,4), (x,5)} {(x,1), (y,4), (x,5)}
{(x,1), (y,?)} {(x,1), (y,2)} {(x,1), (y,2), (y,4), (x,5)} {(x,1), (y,4), (x,5)} {(y,4), (x,5)}
![Page 74: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/74.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
74
Análisis de las Expresiones muy Ocupadas (VBE)
– Determina:• Una expresión exp está muy ocupada a la salida de una
etiqueta l si, cualquier camino que parte de l utiliza expantes de que cualquiera de las variables que contiene expsean redefinidas.
• El objetivo del Análisis de las Expresiones muy Ocupadas es determinar para cada punto del programa, qué expresiones están muy ocupadas.
• Un posible uso es evaluar la expresión en el bloque y guardar su valor para un uso posterior.
![Page 75: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/75.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
75
VBE #2
if [a > b]1
then ([x := b - a]2; [y := a - b]3)else ([y := b - a]4; [x := a - b]5)
– Las expresiones a – b y b – a están ambas muy ocupadas al comienzo de la selección [1]; pueden guardarse en ese punto produciendo un ahorro de espacio en el tamaño del código generado por este programa.
![Page 76: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/76.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
76
VBE #3Función killVB
killVB : Blocks* � ℘ (AExp*)• killVB([x := a]l) = {a' ∈ AExp* | x ∈ FV(a')}• killVB([skip]l) = ∅• killVB([b]l) = ∅
– Se define igual que KillAE para el análisis de las expresiones disponibles.
– Un bloque mata (kill) una expresión si cualquiera de las variables usadas en la expresión es modificada por el bloque.
![Page 77: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/77.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
77
VBE #4Función genVB
genVB : Blocks* � ℘ (AExp*)
• genVB([x := a]l) = AExp(a)• genVB([skip]l) = ∅• genVB([b]l) = AExp(b)
– Todas las expresiones que aparecen en un bloque están muy ocupadas a la entrada del bloque (al contrario de lo que ocurría para el Análisis de las Expresiones disponibles).
![Page 78: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/78.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
78
VBE #5
Ecuaciones de flujo de datos
• El análisis viene definido por las funciones VBentry y VBexit que aplican etiquetas a conjuntos de expresiones
VBentry, VBexit: Lab* � ℘ (AExp*)
– VBexit(l) =
– VBentry(l) = (VBexit(l) \ killVB(Bl)) ∪ genVB(Bl)donde Bl ∈ blocks(S*)
∅ , si l = final(S*)∩{VBentry(l') | (l',l) ∈ flowR(S*)}, en otro caso
![Page 79: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/79.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
79
VBE #6
– VBexit(l) =
– El análisis VBE es un análisis hacia atrás (inverso)– Las funciones propagan información contra el flujo
del programa:• una expresión está muy ocupada a la salida de un
bloque si está muy ocupada a la entrada de cada bloque que lo sigue.
• ninguna expresión está muy ocupada a la salida del bloque final.
∅ , si l = final(S*)∩{VBentry(l') | (l',l) ∈ flowR(S*)}, en otro caso
![Page 80: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/80.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
80
VBE #7
(while [x > 1]l do [skip]l'); [x := x + 1]l"
• VBentry(l) = VBexit(l)• VBentry(l') = VBexit(l')• VBentry(l") = {x + 1}
• VBexit(l) = VBentry(l') ∩ VBentry(l")• VBexit(l') = VBentry(l)• VBexit(l") = ∅
no
si
[…]l
[…]l'
[… ]l"
![Page 81: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/81.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
81
VBE #8• Simplificando
• VBexit(l) = VBexit(l) ∩ {x + 1}
• Esta ecuación tiene dos soluciones• ∅• {x + 1}
• La solución que da más información es {x + 1} – nos interesa la mayor solución de la ecuación
![Page 82: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/82.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
82
VBE #9
if [a > b]1
then ([x := b - a]2; [y := a - b]3) else ([y := b - a]4; [x := a - b]5)
VBentry(1) = VBexit(1) VBexit(1) = VBentry(2) ∩ VBentry(4)VBentry(2) = VBexit(2) ∪ {b – a} VBexit(2) = VBentry(3)VBentry(3) = {a – b} VBexit(3) = ∅VBentry(4) = VBexit(4) ∪ {b – a} VBexit(4) = VBentry(5)
VBentry(5) = {a – b} VBentry(5) = ∅
l killVB(l) genVB(l)
1 2 3 4 5
∅ ∅ ∅ ∅ ∅
∅ {b –a} {a – b} {b –a} {a – b}
![Page 83: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/83.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
83
VBE #10if [a > b]1
then ([x := b - a]2; [y := a - b]3) else ([y := b - a]4; [x := a - b]5)
VBentry(1) = VBexit(1) VBexit(1) = VBentry(2) ∩ VBentry(4)VBentry(2) = VBexit(2) ∪ {b – a} VBexit(2) = VBentry(3)VBentry(3) = {a – b} VBexit(3) = ∅VBentry(4) = VBexit(4) ∪ {b – a} VBexit(4) = VBentry(5)
VBentry(5) = {a – b} VBentry(5) = ∅
l VBentry(l) VBexit(l) 1 2 3 4 5
{a – b, b – a} {a – b, b – a}
{a – b} {a – b, b – a}
{a – b}
{a – b, b – a} {a – b}
∅ {a – b}
∅
![Page 84: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/84.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
84
Análisis de las Variables Vivas (LV)• Una variable está viva a la salida de una etiqueta si
hay un camino que parte de la etiqueta en la que la variable es usada y no redefinida.
• El análisis de las variables vivas determina para cada punto del programa, qué variables pueden estar vivas a la salida de dicho punto.
• Este análisis podría usarse como base para la Eliminación del Código Muerto (Dead Code Elimination). Si una variable no está viva a la salida de una etiqueta entonces, si el bloque elemental es una asignación a la variable, el bloque elemental puede eliminarse.
![Page 85: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/85.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
85
LV #2
[x := 2]1; [y := 4] 2; [x := 1] 3; (if [y > x] 4 then [z := y] 5 else [z := y*y] 6) [x := z]7
– La variable x no está viva a la salida de la etiqueta 1; la primera asignación del programa es redundante.
– Tanto x como y están vivas a la salida de la etiqueta 3.
![Page 86: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/86.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
86
LV #3Función killLV
killLV : Blocks* � ℘ (Var*)
• killLV([x := a]l) = {x}• killLV ([skip]l) = ∅• killLV ([b]l) = ∅
– La variable que aparece a la izquierda de una asignación es destruida por la asignación;
– Los tests y skip no destruyen variables.
![Page 87: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/87.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
87
LV #4Función genLV
genLV : Blocks* � ℘ (Var*)
• genLV ([x := a]l) = FV(a)• genLV ([skip]l) = ∅• genLV([b]l) = FV(b)
– genLV produce el conjunto de variables que aparecen en el bloque
![Page 88: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/88.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
88
LV #5Ecuaciones de flujo de datos
LVentry, LVexit: Lab* � ℘ (Var*)
– El análisis viene dado por las funciones LVentry y LVexitque asocian etiquetas y conjuntos de variables:
LVexit(l) =
LVentry(l) = (LVexit(l) \ killLV(Bl)) ∪ genLV(Bl)donde Bl ∈ blocks(S*)
∅ , si l = final(S*)∪ {LVentry(l') | (l',l) ∈ flowR(S*)}, en otro caso
![Page 89: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/89.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
89
LV #6
– LVexit(l)=
– Suponemos que S* es etiqueta-consistente y que tiene salidas aisladas.
– La ecuación para LVexit(l) incluye una variable en el conjunto de las variables vivas (a la salida de l) si está viva a la entrada de cualquiera de los bloques que siguen a l; si no ocurre esto es ∅ .
– El análisis es un análisis hacia atrás (inverso).
∅ , si l = final(S*)∪ {LVentry(l') | (l',l) ∈ flowR(S*)}, en otro caso
![Page 90: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/90.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
90
LV #7(while [x > 1]l do [skip]l'); [x := x + 1]l”
• LVentry(l) = LVexit(l) ∪ {x}• LVentry(l') = LVexit(l')• LVentry(l") = {x}
• LVexit(l) = LVentry(l') ∪ LVentry(l")• LVexit(l') = LVentry(l)• LVexit(l") = ∅
no
si
[…]l
[…]l'
[… ]l"
![Page 91: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/91.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
91
LV #8(while [x > 1]l do [skip]l'); [x := x + 1]l”
• SimplificandoLVexit(l) = LVexit(l) ∪ {x}
– Cualquier superconjunto de {x} es una solución.– Las optimizaciones basadas en este análisis se basan en
las variables muertas (dead) – cuanto menor es el conjunto de las variables vivas, es posible hacer más optimizaciones.
– Por lo tanto estamos interesados en la menor solución {x} de la ecuación.
![Page 92: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/92.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
92
LV #9
[x := 2]1; [y := 4] 2; [x := 1] 3; (if [y > x] 4 then [z := y] 5 else [z := y*y] 6) [x := z]7
• LVentry(1) = LVexit(1) \ {x}• LVentry(2) = LVexit(2) \ {y}• LVentry(3) = LVexit(3) \ {x}• LVentry(4) = LVexit(4) \ {x, y}• LVentry(5) = (LVexit(5) \ {z}) ∪ {y}• LVentry(6) = (LVexit(6) \ {z}) ∪ {y}• LVentry(7) = {z}
l killLV(l) genLV(l) 1 2 3 4 5 6 7
{x} {y} {x} ∅ {z} {z} {x}
∅ ∅ ∅ {x, y} {y} {y} {z}
![Page 93: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/93.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
93
LV #10
[x := 2]1; [y := 4] 2; [x := 1] 3; (if [y > x] 4 then [z := y] 5 else [z := y*y] 6) [x := z]7
• LVexit(1) = LVentry(2)• LVexit(2) = LVentry(3)• LVexit(3) = LVentry(4)• LVexit(4) = LVentry(5) ∪ LVentry(6)• LVexit(5) = LVexit(7)• LVexit(6) = LVexit(7)• LVexit(7) = ∅
l killLV(l) genLV(l) 1 2 3 4 5 6 7
{x} {y} {x} ∅ {z} {z} {x}
∅ ∅ ∅ {x, y} {y} {y} {z}
![Page 94: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/94.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
94
LV #11[x := 2]1; [y := 4] 2; [x := 1] 3; (if [y > x] 4 then [z := y] 5 else [z := y*y] 6) [x := z]7
– Usando la Iteración Caótica para calcular la solución obtenemos:
l LVentry(l) LVexit(l) 1 2 3 4 5 6 7
∅ ∅ {y} {x, y} {y} {y} {z}
∅ {y} {x, y} {y} {z} {z} ∅
![Page 95: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/95.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
95
Información derivada del AFD– Es conveniente enlazar directamente las etiquetas de las
instrucciones que producen valores con las etiquetas de las instrucciones que las usan.
[x := 0]1; [x :=3] 2; (if [z = x]3 then [z := 0]4 else [z := x]5); [y:=x]6; [x := y + z]7
– Los enlaces que, para cada uso de una variable, asocian todas las asignaciones que alcanzan ese uso se llaman Cadenas de uso-definición o ud-cadenas.
– 3 --> 2
![Page 96: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/96.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
96
Información derivada del AFD #2
[x := 0]1; [x :=3] 2; (if [z = x]3 then [z := 0]4 else [z := x]5); [y:=x]6; [x := y + z]7
– Los enlaces que cada asignación de una variable la asocian con todos los puntos en los que se usa dicha variable se llaman cadenas de definición-uso o du-cadenas.
– 2-->{3,5,6}
![Page 97: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/97.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
97
∃ l1, …, ln : (l1 = l) ∧ (ln = l') ∧ (n > 0) ∧(∀ i ∈ {1,…,n – 1} : (li,li+1) ∈ flow(S*)) ∧
(∀ i ∈ {1,…,n – 1} : ¬def(x,li)) ∧ use(x,ln)clear(x,l,l') =
Información derivada del AFD #3
– l1, …, ln es una cadena limpia para x si• ninguno de los bloques etiquetados con l1, …, ln
asigna a x un valor y• ln la usa x.
![Page 98: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/98.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
98
Información derivada del AFD #4
use(x,l) = (∃ B : [B]l ∈ blocks(S*) ∧ x ∈ genLV([B]l))
def(x,l) = (∃ B : [B]l ∈ blocks(S*) ∧ x ∈ killLV([B]l))
![Page 99: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/99.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
99
Información derivada del AFD #5ud: Var* ×××× Lab* ���� ℘℘℘℘ (Lab*)
– ud(x,l') devuelve las etiquetas l donde la variable x, usada en l, podría haber obtenido su valor;
• puede ser en una etiqueta l o• puede no estar inicializada como indica la ocurrencia de ?.
{l | def(x,l) ∧ ∃ l" : (l,l") ∈ flow(S*) ∧ clear(x,l",l'))}
∪ {? | clear(x,init(S*),l')}ud(x,l') =
![Page 100: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/100.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
100
Información derivada del AFD #6du: Var* ×××× Lab* ���� ℘℘℘℘ (Lab*)
– du(x,l) devuelve las etiquetas en las que el valor asignado a x en l podría haber sido usado; distinguimos entre el caso en que x obtiene su valor en el programa y el caso en que no está inicializada.
– Además se tiene que:du(x,l) = {l' | l ∈ ud(x,l')}
{l' | def(x,l) ∧ ∃ l" : (l,l") ∈ flow(S*) ∧ clear(x,l",l')} si l ≠ ?
{l' | clear(x,init(S*),l')} si l = ?du(x,l) =
![Page 101: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/101.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
101
Información derivada del AFD #7
[x := 0]1; [x :=3] 2; (if [z = x]3 then [z := 0]4 else [z := x]5); [y:=x]6; [x := y + z]7
ud(x,l) x y z
1 2 3 4 5 6 7
∅ ∅
{2} ∅
{2} {2} ∅
∅ ∅ ∅ ∅ ∅ ∅
{6}
∅ ∅
{?} ∅ ∅ ∅
{4, 5}
![Page 102: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/102.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
102
Información derivada del AFD #8
[x := 0]1; [x :=3] 2; (if [z = x]3 then [z := 0]4 else [z := x]5); [y:=x]6; [x := y + z]7
du (x,l) x y z
1 2 3 4 5 6 7 ?
∅ {3, 5, 6}
∅ ∅ ∅ ∅ ∅ ∅
∅ ∅ ∅ ∅ ∅
{7} ∅ ∅
∅ ∅ ∅
{7} {7} ∅ ∅
{3}
![Page 103: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/103.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
103
Información derivada del AFD #9
• Aplicaciones:– Eliminación del Código Muerto (Dead Code Elimination);
• para el programa del ejemplo anterior podemos eliminar el bloque etiquetado con 1 ya que no habrá ningún uso del valor asignado a x antes de que sea reasignado en el siguiente bloque.
– Movimiento del Código (Code Motion); • en el programa del ejemplo, el bloque 6 puede moverse
justo antes del condicional ya que sólo usa variables asignadas en bloques anteriores y el condicional no usa la variable asignada en el bloque 6.
![Page 104: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/104.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
104
Información derivada del AFD #10– Las definiciones de las ud- y du-cadenas no son
constructivas. – Para definir de forma constructiva las ud-cadenas
podemos usar RDentry
UD : Var* × Lab* � ℘ (Lab*)
– Similarmente, podemos definir la función DU : Var* ×Lab* � ℘ (Lab*) para las du-cadenas basándonos en funciones dadas anteriormente.
{l' | (x,l') ∈ RDentry(l)}, si x ∈ genLV(Bl)
∅ , en otro casoUD(x,l) =
![Page 105: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/105.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
105
Semántica Operacional Estructural (SOS)
– Estados• σ ∈ State = Var � Z
– Configuración• un par consistente en una instrucción y un estado o
es un estado <S,σ>;• o simplemente un estado σ.
– Transición• <S,σ> � σ'
– expresa cómo cambia la configuración con un paso de la computación (semántica de paso pequeño)
![Page 106: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/106.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
106Semántica Operacional Estructural (SOS) #2
– En configuración <S,σ> podrían ocurrir una de las dos siguientes opciones:
• La ejecución termina después de un paso y sabemos que da el resultado σ', o
• La ejecución no termina después de un paso y lo representamos mediante una nueva configuración <S',σ'> donde S' es el resto del programa y σ' el estado actualizado.
![Page 107: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/107.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
107Semántica Operacional Estructural (SOS) #3• Expresiones aritméticas y booleanas
• Α : AExp � (State � Z)• Β : BExp � (State � Z)
Α : AExp � (State � Z)Α[[x]]σ = σ(x)
Α[[n]] σ= Ν[[x]]Α[[a1 opa a2]] σ = Α[[a1]]σ opa Α[[a2]]σ
Β : AExp � (State � Z)Β[[not b]]σ = ¬ Β[[b]]σ
Β[[a1 opb a2]] σ = Β[[a1]]σ opb Β[[a2]]σΒ[[a1 opr a2]] σ = Α[[a1]]σ opr Α[[a2]]σ
Semántica de las expresiones en WHILE
![Page 108: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/108.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
108Semántica Operacional Estructural (SOS) #4
– La cláusula [ass] especifica que la asignación x := a se ejecuta en un paso;
– σ[x � Α[[a]]σ] es el estado que es como σ salvo que x es aplicado a Α[[a]]σ, es decir, el valor al que a se evaluará en el estado σ. Formalmente,
[ass] <[x := a]l,σ> � σ[x � Α[[a]]σ[skip] <[skip]l,σ> � σ
(σ[x � Α[[a]]σ])(y) =Α[[a]]σ, si x = y
σ(y), en otro caso
![Page 109: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/109.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
109Semántica Operacional Estructural (SOS) #5
– El primer paso al ejecutar S1; S2 es el primer paso de ejecutar S1.
• [seq2] Sólo se necesita un paso para terminar S1. Pasamos a <S2,σ'> y estamos listos para ejecutar S2.
• [seq1] S1 no termina en un paso, pasamos a otra configuración <S'1,σ'>; queda por ejecutar el resto de S1 y todo S2. La nueva configuración es <S'1;S2,σ'>.
[seq1] ><→ ><
><→ ><
',S;S',S;S
',S',S
2121
11
σσ
σσ
[seq2]><→ ><
→ ><
',S,S;S
',S
221
1
σσ
σσ
![Page 110: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/110.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
110
Semántica Operacional Estructural (SOS) #6
[if1] <if [b]l then S1 else S2 , σ> � <S1,σ>,if Β[[b]]σ = true
[if2] <if [b]l then S1 else S2 , σ> � <S2,σ>,if Β[[b]]σ = false
– el primer paso de la computación seleccionará la rama adecuada basándose en el valor actual de las expresiones booleanas.
![Page 111: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/111.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
111
Semántica Operacional Estructural (SOS) #7
[wh1] <while [bl] do S , σ> � <S ; while [bl] do S , σ>if Β[[b]]σ = true
[wh2] <while [bl] do S , σ> � σif Β[[b]]σ = false
– [wh1] si las expresiones booleanas se evalúan a trueentonces el primer paso es desplegar el bucle.
– [wh2] la ejecución termina si la expresión booleana se evalúa a false.
![Page 112: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/112.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
112Semántica Operacional Estructural (SOS) #8 • Secuencias de Derivación
– Una secuencia de derivación para una instrucción S1 y un estado σ1 puede tener dos formas
• (secuencia finita) corresponde a una computación que termina: <S1,σ1>, …,<Sn,σn>, donde
<Si,σi> � <Si+1,σi+1> para i = 1, …, n – 1 <Sn,σn> � σn+1;
• (secuencia infinita) corresponde a una computación infinita: <S1,σ1>, …,<Si,σi>, … , donde
<Si,σi> � <Si+1,σi+1> para todo i ≥ 1; lo que.
![Page 113: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/113.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
113Semántica Operacional Estructural (SOS) #9
• Ejemplo (factorial)suponemos que σnms aplica x con n, y con m y z con s.
<[y:=x]1 ; [z := 1]2 ; while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6, σ300> �
< [z := 1]2 ; while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6, σ330> �
< while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6, σ331> �
< [z := z * y]4 ; [y := y - 1]5; while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6,
σ331> �
< [y := y - 1]5; while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6, σ333> �
![Page 114: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/114.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
114Semántica Operacional Estructural (SOS) #10
< while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6, σ323> �
< [z := z * y]4 ; [y := y - 1]5; while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6,
σ323> �< [y := y - 1]5; while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6, σ326> �
< while [y > 1]3 do ([z := z * y]4 ; [y := y - 1]5); [y := 0]6, σ316> �
< [y := 0]6, σ316> � σ306
– las etiquetas no tienen efecto sobre la semántica. Nunca son inspeccionadas.
![Page 115: Análisis estático Métodos para la construcción degallardo/AnalisisProg0203.pdf · Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino 3 Análisis](https://reader033.vdocuments.pub/reader033/viewer/2022051507/5a7846367f8b9aea3e8ea9d2/html5/thumbnails/115.jpg)
Métodos para la Construcción de Software Fiable- María del Mar Gallardo—Pedro Merino
115
Bibliografía
F. Nielson, H. R. Nielson, C. Hankin, Principles of Program Analysis, 1998, Springer