18 octobre 2007Cours de compilation 7 - Intranet1 Cours de compilation Génération de code Optimisation de code.

Présentation au sujet: "18 octobre 2007Cours de compilation 7 - Intranet1 Cours de compilation Génération de code Optimisation de code."— Transcription de la présentation:

1 18 octobre 2007Cours de compilation 7 - Intranet1 Cours de compilation Génération de code Optimisation de code

2 18 octobre 2007Cours de compilation 7 - Intranet2 Les grandes lignes du cours Définitions de base Définitions de base Composition de compilateurs Composition de compilateurs Lenvironnement dun compilateur Lenvironnement dun compilateur Evaluation partielle et compilation Evaluation partielle et compilation Analyses lexicales et syntaxiques Analyses lexicales et syntaxiques Techniques danalyse descendantes Techniques danalyse descendantes Techniques danalyse ascendantes Techniques danalyse ascendantes YACC YACC Analyse sémantique Analyse sémantique Environnement dexécution Environnement dexécution Génération de code Génération de code Optimisation de code Optimisation de code

3 18 octobre 2007Cours de compilation 7 - Intranet3 I N T R O D U C T I O N

4 18 octobre 2007Cours de compilation 7 - Intranet4 Génération de code ---------------------------------------------------------------- Nous pouvons,Nous pouvons, –soit, réécrire larbre de syntaxe abstraite dans un autre langage évolué,

5 18 octobre 2007Cours de compilation 7 - Intranet5 Génération de code ---------------------------------------------------------------- Nous pouvons,Nous pouvons, –soit, réécrire larbre de syntaxe abstraite dans un autre langage évolué, –soit, écrire un code de type assembleur, plus précisément un code pour une machine à pile (virtuelle),pour une machine à pile (virtuelle), ou pour un processeur donné.ou pour un processeur donné.

6 18 octobre 2007Cours de compilation 7 - Intranet6 Génération de code ---------------------------------------------------------------- Nous pouvons,Nous pouvons, –soit, réécrire larbre de syntaxe abstraite dans un autre langage évolué, –soit, écrire un code de type assembleur, plus précisément un code pour une machine à pile (virtuelle),pour une machine à pile (virtuelle), ou pour un processeur donné.ou pour un processeur donné.

7 18 octobre 2007Cours de compilation 7 - Intranet7 M A C H I N E A P I L E

8 18 octobre 2007Cours de compilation 7 - Intranet8 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz

9 18 octobre 2007Cours de compilation 7 - Intranet9 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz push @x

10 18 octobre 2007Cours de compilation 7 - Intranet10 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz push @x push y

11 18 octobre 2007Cours de compilation 7 - Intranet11 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz push @x push y push z

12 18 octobre 2007Cours de compilation 7 - Intranet12 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz push @x push y push z push x

13 18 octobre 2007Cours de compilation 7 - Intranet13 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz push @x push y push z push x mult

14 18 octobre 2007Cours de compilation 7 - Intranet14 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz push @x push y push z push x multadd

15 18 octobre 2007Cours de compilation 7 - Intranet15 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz push @x push y push z push x multaddset

16 18 octobre 2007Cours de compilation 7 - Intranet16 Machine à pile ---------------------------------------------------------------- Voici les opérations et leurs effets sur la pile.Voici les opérations et leurs effets sur la pile. –push x... x devient

17 18 octobre 2007Cours de compilation 7 - Intranet17 Machine à pile ---------------------------------------------------------------- Voici les opérations et leurs effets sur la pile.Voici les opérations et leurs effets sur la pile. –push x –add... x a b a + b devient devient

18 18 octobre 2007Cours de compilation 7 - Intranet18 Machine à pile ---------------------------------------------------------------- Voici les opérations et leurs effets sur la pile.Voici les opérations et leurs effets sur la pile. –push x –add –set... x a b a + b val adr devient devient devient + affectation

19 18 octobre 2007Cours de compilation 7 - Intranet19 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_:= calcul_adr ( lhs ) calcul_val ( rhs ) calcul_val ( rhs ) gencode ( « set » ) gencode ( « set » )

20 18 octobre 2007Cours de compilation 7 - Intranet20 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_:= calcul_adr ( lhs ) calcul_val ( rhs ) calcul_val ( rhs ) gencode ( « set » ) gencode ( « set » ) calcul_adr ( lhs ) si lhs = var gencode ( « push », @var ) si lhs = var gencode ( « push », @var )

21 18 octobre 2007Cours de compilation 7 - Intranet21 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_:= calcul_adr ( lhs ) calcul_val ( rhs ) calcul_val ( rhs ) gencode ( « set » ) gencode ( « set » ) calcul_adr ( lhs ) si lhs = var gencode ( « push », @var ) si lhs = var gencode ( « push », @var ) si lhs = var [ind] calcul_val ( ind ) si lhs = var [ind] calcul_val ( ind ) calcul_adr ( var ) calcul_adr ( var ) gencode ( « add » ) gencode ( « add » )

22 18 octobre 2007Cours de compilation 7 - Intranet22 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_val ( rhs ) si rhs = cste gencode ( « push », rhs ) si rhs = cste gencode ( « push », rhs )

23 18 octobre 2007Cours de compilation 7 - Intranet23 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_val ( rhs ) si rhs = cste gencode ( « push », rhs ) si rhs = cste gencode ( « push », rhs ) si lhs = var gencode ( « push », var ) si lhs = var gencode ( « push », var )

24 18 octobre 2007Cours de compilation 7 - Intranet24 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_val ( rhs ) si rhs = cste gencode ( « push », rhs ) si rhs = cste gencode ( « push », rhs ) si lhs = var gencode ( « push », var ) si lhs = var gencode ( « push », var ) si lhs = var [ind] calcul_adr ( lhs ) si lhs = var [ind] calcul_adr ( lhs ) gencode ( « fetch » ) gencode ( « fetch » )

25 18 octobre 2007Cours de compilation 7 - Intranet25 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_val ( rhs ) si rhs = cste gencode ( « push », rhs ) si rhs = cste gencode ( « push », rhs ) si lhs = var gencode ( « push », var ) si lhs = var gencode ( « push », var ) si lhs = var [ind] calcul_adr ( lhs ) si lhs = var [ind] calcul_adr ( lhs ) gencode ( « fetch » ) gencode ( « fetch » ) si rhs = a op b calcul_val ( b ) si rhs = a op b calcul_val ( b ) calcul_val ( a ) calcul_val ( a ) gencode ( « add » ) gencode ( « add » )

26 18 octobre 2007Cours de compilation 7 - Intranet26 Machine à pile ---------------------------------------------------------------- Bilan :Bilan : –La génération de code est très simple!

27 18 octobre 2007Cours de compilation 7 - Intranet27 Machine à pile ---------------------------------------------------------------- Bilan :Bilan : –La génération de code est très simple! –Le code est portable à cause de la machine virtuelle !

28 18 octobre 2007Cours de compilation 7 - Intranet28 Machine à pile ---------------------------------------------------------------- Bilan :Bilan : –La génération de code est très simple! –Le code est portable à cause de la machine virtuelle ! –Ce nest pas très efficace, car : Le code est interprété !Le code est interprété ! Il est simulé !Il est simulé ! Il nest pas pipeliné,... !Il nest pas pipeliné,... !

29 18 octobre 2007Cours de compilation 7 - Intranet29 U N P R O C E S S E U R E T U N O / S

30 18 octobre 2007Cours de compilation 7 - Intranet30 Processeur donné ---------------------------------------------------------------- Commentaire :Commentaire : –Le code est nest plus portable !

31 18 octobre 2007Cours de compilation 7 - Intranet31 Processeur donné ---------------------------------------------------------------- Commentaire :Commentaire : –Le code est nest plus portable ! –Il est (très) effiace ! ! !

32 18 octobre 2007Cours de compilation 7 - Intranet32 Processeur donné ---------------------------------------------------------------- Commentaire :Commentaire : –Le code est nest plus portable ! –Il est (très) effiace ! ! ! –Cest plus difficile, car : Nous tenons compte dun jeu dinstruction donné !Nous tenons compte dun jeu dinstruction donné ! Nous devons considérer le nombre de registres !Nous devons considérer le nombre de registres ! Nous devons prendre en compte les primitives et caractéristiques du système dexploitation !Nous devons prendre en compte les primitives et caractéristiques du système dexploitation !

33 18 octobre 2007Cours de compilation 7 - Intranet33 Processeur donné ---------------------------------------------------------------- Nous décomposons la traduction :Nous décomposons la traduction :

34 18 octobre 2007Cours de compilation 7 - Intranet34 Processeur donné ---------------------------------------------------------------- Nous décomposons la traduction :Nous décomposons la traduction : Syntaxe abstraite Code intermédiaire Code processeur optimisé

35 18 octobre 2007Cours de compilation 7 - Intranet35 Processeur donné ---------------------------------------------------------------- Nous décomposons la traduction :Nous décomposons la traduction : Syntaxe abstraite Code intermédiaire Code processeur optimisé - Proche du processeur final ! - Suffisamment générale pour permettre des optimisations ! permettre des optimisations !

36 18 octobre 2007Cours de compilation 7 - Intranet36 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (2) x y (3) x <- y

37 18 octobre 2007Cours de compilation 7 - Intranet37 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (2) x y (3) x <- y (4) goto L (5) if x y goto L

38 18 octobre 2007Cours de compilation 7 - Intranet38 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (2) x y (3) x <- y (4) goto L (5) if x y goto L (6) param a_1...... param a_k param a_k call f, k call f, k (7) return

39 18 octobre 2007Cours de compilation 7 - Intranet39 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (8) x z (8) x <- y [ z ] (2) x y (9) x [ y ] y (9) x [ y ] <- z (3) x <- y (10) x <- &y (4) goto L (5) if x y goto L (6) param a_1...... param a_k param a_k call f, k call f, k (7) return

40 18 octobre 2007Cours de compilation 7 - Intranet40 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (8) x z (8) x <- y [ z ] (2) x y (9) x [ y ] y (9) x [ y ] <- z (3) x <- y (10) x <- &y (4) goto L (11) x <- *y (5) if x y goto L (12) *x y goto L (12) *x <- y (6) param a_1...... param a_k param a_k call f, k call f, k (7) return

41 18 octobre 2007Cours de compilation 7 - Intranet41 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (8) x z (8) x <- y [ z ] (2) x y (9) x [ y ] y (9) x [ y ] <- z (3) x <- y (10) x <- &y (4) goto L (11) x <- *y (5) if x y goto L (12) *x y goto L (12) *x <- y (6) param a_1...... param a_k param a_k call f, k call f, k (7) return Les instructions complexes deviennent une séquence dinstructions 3-adresses qui utilisent des variables temporaires.

42 18 octobre 2007Cours de compilation 7 - Intranet42 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (8) x z (8) x <- y [ z ] (2) x y (9) x [ y ] y (9) x [ y ] <- z (3) x <- y (10) x <- &y (4) goto L (11) x <- *y (5) if x y goto L (12) *x y goto L (12) *x <- y (6) param a_1...... param a_k param a_k call f, k call f, k (7) return x = ( x + y ) * z => t <- x + y t <- t * z x <- t

43 18 octobre 2007Cours de compilation 7 - Intranet43 G E N E R A T I O N D E C O D E I N T E R M E D I A I R E

44 18 octobre 2007Cours de compilation 7 - Intranet44 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat !

45 18 octobre 2007Cours de compilation 7 - Intranet45 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place !

46 18 octobre 2007Cours de compilation 7 - Intranet46 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si E = id : E.place = id.place E.code = E.code =

47 18 octobre 2007Cours de compilation 7 - Intranet47 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si E = id : E.place = id.place E.code = E.code = Si E = E op E : E.place = newtemp () E.place = newtemp () E.code = E.code ; E.code ; E.code = E.code ; E.code ; gencode ( E.place « <- » gencode ( E.place « <- » E.place op E.place ) E.place op E.place ) 1 1 2 2 1 2

48 18 octobre 2007Cours de compilation 7 - Intranet48 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si E = id : E.place = id.place E.code = E.code = Si E = E op E : E.place = newtemp () E.place = newtemp () E.code = E.code ; E.code ; E.code = E.code ; E.code ; gencode ( E.place « <- » gencode ( E.place « <- » E.place op E.place ) E.place op E.place ) 1 1 2 2 1 2

49 18 octobre 2007Cours de compilation 7 - Intranet49 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S qui est id := E : S.code = E.code ; S.code = E.code ; gencode ( id.place « <- » E.place ) gencode ( id.place « <- » E.place )

50 18 octobre 2007Cours de compilation 7 - Intranet50 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S qui est id := E : S.code = E.code ; S.code = E.code ; gencode ( id.place « <- » E.place ) gencode ( id.place « <- » E.place ) Si S est S ; S : S.code = S.code ; S.code S.code = S.code ; S.code 12 2 1

51 18 octobre 2007Cours de compilation 7 - Intranet51 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S est while E do S : Soient S.begin = newlabel () et S.after = newlabel () 1

52 18 octobre 2007Cours de compilation 7 - Intranet52 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S est while E do S : Soient S.begin = newlabel () et S.after = newlabel () S.code = S.code = gencode ( « S.begin: » ) ; E.code ; gencode ( « S.begin: » ) ; E.code ; 1

53 18 octobre 2007Cours de compilation 7 - Intranet53 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S est while E do S : Soient S.begin = newlabel () et S.after = newlabel () S.code = S.code = gencode ( « S.begin: » ) ; E.code ; gencode ( « S.begin: » ) ; E.code ; gencode ( « if » E.place « =0 goto » S.after ) ; gencode ( « if » E.place « =0 goto » S.after ) ; 1

54 18 octobre 2007Cours de compilation 7 - Intranet54 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S est while E do S : Soient S.begin = newlabel () et S.after = newlabel () S.code = S.code = gencode ( « S.begin: » ) ; E.code ; gencode ( « S.begin: » ) ; E.code ; gencode ( « if » E.place « =0 goto » S.after ) ; gencode ( « if » E.place « =0 goto » S.after ) ; S.code ; S.code ; gencode ( « goto » S.begin ) ; gencode ( « goto » S.begin ) ; 1 1

55 18 octobre 2007Cours de compilation 7 - Intranet55 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S est while E do S : Soient S.begin = newlabel () et S.after = newlabel () S.code = S.code = gencode ( « S.begin: » ) ; E.code ; gencode ( « S.begin: » ) ; E.code ; gencode ( « if » E.place « =0 goto » S.after ) ; gencode ( « if » E.place « =0 goto » S.after ) ; S.code ; S.code ; gencode ( « goto » S.begin ) ; gencode ( « goto » S.begin ) ; gencode ( « S.after: » ) ; gencode ( « S.after: » ) ; 1 1

56 18 octobre 2007Cours de compilation 7 - Intranet56 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Cette générationCette génération –utilise beaucoup de temporaires, –utilise beaucoup de copies de variable à variable !

57 18 octobre 2007Cours de compilation 7 - Intranet57 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Cette générationCette génération –utilise beaucoup de temporaires, –utilise beaucoup de copies de variable à variable ! Nous nous en occuperont dans la suite !Nous nous en occuperont dans la suite ! Pour linstant, nous avons un code correct ! ! !Pour linstant, nous avons un code correct ! ! !

58 18 octobre 2007Cours de compilation 7 - Intranet58 O P T I M I S A T I O N D U C O D E I N T E R M E D I A I R E

59 18 octobre 2007Cours de compilation 7 - Intranet59 Optimisation du code intermédiaire ---------------------------------------------------------------- Il fautIl faut –tenir compte du nombre de registres, –veiller à garder le pipeline plein !

60 18 octobre 2007Cours de compilation 7 - Intranet60 Optimisation du code intermédiaire ---------------------------------------------------------------- Il fautIl faut –tenir compte du nombre de registres, –veiller à garder le pipeline plein ! Loptimisation du code intermédiaireLoptimisation du code intermédiaire –redresse les imperfections du code intermédiaire, –redresse les imperfections du code utilisateur !

61 18 octobre 2007Cours de compilation 7 - Intranet61 Optimisation du code intermédiaire ---------------------------------------------------------------- Il fautIl faut –tenir compte du nombre de registres, –veiller à garder le pipeline plein ! Loptimisation du code intermédiaireLoptimisation du code intermédiaire –redresse les imperfections du code intermédiaire, –redresse les imperfections du code utilisateur ! La suite des instructions est découpée en de séquences appelées « blocs fondamentaux » !La suite des instructions est découpée en de séquences appelées « blocs fondamentaux » !

62 18 octobre 2007Cours de compilation 7 - Intranet62 Optimisation du code intermédiaire ---------------------------------------------------------------- Il fautIl faut –tenir compte du nombre de registres, –veiller à garder le pipeline plein ! Loptimisation du code intermédiaireLoptimisation du code intermédiaire –redresse les imperfections du code intermédiaire, –redresse les imperfections du code utilisateur ! La suite des instructions est découpée en de séquences appelées « blocs fondamentaux » !La suite des instructions est découpée en de séquences appelées « blocs fondamentaux » ! Un « bloc fondamental » correspond à une séquence dinstructions exécutées de la première à la dernière sans interruption !Un « bloc fondamental » correspond à une séquence dinstructions exécutées de la première à la dernière sans interruption !

63 18 octobre 2007Cours de compilation 7 - Intranet63 Le bloc fondamental ---------------------------------------------------------------- Il faut dabord identifier les « têtes de bloc ». Ce sont :Il faut dabord identifier les « têtes de bloc ». Ce sont : –la première instruction du programme, –toute instruction atteinte par un « goto », –toute instruction suivant un « goto », –sachant que les fonctions et procédures sont assimilées à des « goto » !

64 18 octobre 2007Cours de compilation 7 - Intranet64 Le bloc fondamental ---------------------------------------------------------------- Il faut dabord identifier les « têtes de bloc ». Ce sont :Il faut dabord identifier les « têtes de bloc ». Ce sont : –la première instruction du programme, –toute instruction atteinte par un « goto », –toute instruction suivant un « goto », –sachant que les fonctions et procédures sont assimilées à des « goto » ! Un « bloc fondamental » estUn « bloc fondamental » est –une tête de bloc, –et toutes les instructions qui la suivent jusquà la fin du programme,la fin du programme, ou la prochaine tête de bloc, non incluse !ou la prochaine tête de bloc, non incluse !

65 18 octobre 2007Cours de compilation 7 - Intranet65 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after :

66 18 octobre 2007Cours de compilation 7 - Intranet66 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after : Têtes de bloc !

67 18 octobre 2007Cours de compilation 7 - Intranet67 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after : Têtes de bloc ! Blocs !

68 18 octobre 2007Cours de compilation 7 - Intranet68 Le bloc fondamental ---------------------------------------------------------------- Le graphe de dépendance des blocs :Le graphe de dépendance des blocs : –Son objectif est de dire comment les blocs se suivent potentiellement !

69 18 octobre 2007Cours de compilation 7 - Intranet69 Le bloc fondamental ---------------------------------------------------------------- Le graphe de dépendance des blocs :Le graphe de dépendance des blocs : –Son objectif est de dire comment les blocs se suivent potentiellement ! –Cest un graphe orienté ! –Les sommets correspondent aux blocs ! –Les dépendances correspondent aux arcs !

70 18 octobre 2007Cours de compilation 7 - Intranet70 Le bloc fondamental ---------------------------------------------------------------- Le graphe de dépendance des blocs :Le graphe de dépendance des blocs : –Son objectif est de dire comment les blocs se suivent potentiellement ! –Cest un graphe orienté ! –Les sommets correspondent aux blocs ! –Les dépendances correspondent aux arcs ! Nous avons A - > B siNous avons A - > B si –la tête de B est atteinte par un goto depuis A, –B suit séquentiellement A et celui-ci se termine par un goto conditionnel !

71 18 octobre 2007Cours de compilation 7 - Intranet71 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after :

72 18 octobre 2007Cours de compilation 7 - Intranet72 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after : 1 2 3

73 18 octobre 2007Cours de compilation 7 - Intranet73 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after : 1 2 3

74 18 octobre 2007Cours de compilation 7 - Intranet74 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after : 1 2 3

75 18 octobre 2007Cours de compilation 7 - Intranet75 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after : 1 2 3

76 18 octobre 2007Cours de compilation 7 - Intranet76 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc :

77 18 octobre 2007Cours de compilation 7 - Intranet77 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. a <- b + c b <- a – d c <- b + c d <- a - d

78 18 octobre 2007Cours de compilation 7 - Intranet78 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. a <- b + c b <- a – d c <- b + c d <- a - d

79 18 octobre 2007Cours de compilation 7 - Intranet79 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. a <- b + c b <- a – d c <- b + c d <- a - d a <- b + c b <- a – d c <- b + c d <- b

80 18 octobre 2007Cours de compilation 7 - Intranet80 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. a <- b + c b <- a – d c <- b + c d <- a - d a <- b + c b <- a – d c <- b + c d <- b La valeur de b change entre les deux expressions !

81 18 octobre 2007Cours de compilation 7 - Intranet81 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. –Elimination de code mort.

82 18 octobre 2007Cours de compilation 7 - Intranet82 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. –Elimination de code mort. Toute affectation de « variable du compilateur » ( temporaire ) qui nest pas utilisée dans la suite du bloc !Toute affectation de « variable du compilateur » ( temporaire ) qui nest pas utilisée dans la suite du bloc ! Toute « variable locale » dont on sait quelle nest pas utilisée dans la suite ( il faut plus dinformations ) !Toute « variable locale » dont on sait quelle nest pas utilisée dans la suite ( il faut plus dinformations ) !

83 18 octobre 2007Cours de compilation 7 - Intranet83 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. –Elimination de code mort. –Renommage des variables temporaires, qui peuvent de ce fait devenir des registres.

84 18 octobre 2007Cours de compilation 7 - Intranet84 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. –Elimination de code mort. –Renommage des variables temporaires, qui peuvent de ce fait devenir des registres. –Echange de lordre des calculs, si les dépendances entre les instructions le permettent.

85 18 octobre 2007Cours de compilation 7 - Intranet85 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. –Elimination de code mort. –Renommage des variables temporaires, qui peuvent de ce fait devenir des registres. –Echange de lordre des calculs, si les dépendances entre les instructions le permettent. Ces transformations sont possibles parce que le bloc est exécuté intégralement et sans interruption !Ces transformations sont possibles parce que le bloc est exécuté intégralement et sans interruption !

86 18 octobre 2007Cours de compilation 7 - Intranet86 A N A L Y S E D E L A D U R E E D E V I E D E S V A R I A B L E S

87 18 octobre 2007Cours de compilation 7 - Intranet87 Durée de vie des variables ---------------------------------------------------------------- Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !

88 18 octobre 2007Cours de compilation 7 - Intranet88 Durée de vie des variables ---------------------------------------------------------------- Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) ! –Pour les variables du compilateur cest facile à savoir !

89 18 octobre 2007Cours de compilation 7 - Intranet89 Durée de vie des variables ---------------------------------------------------------------- Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) ! –Pour les variables du compilateur cest facile à savoir ! –Pour les variables de lutilisateur qui sont locales, nous pourrons faire des choses !

90 18 octobre 2007Cours de compilation 7 - Intranet90 Durée de vie des variables ---------------------------------------------------------------- Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) ! –Pour les variables du compilateur cest facile à savoir ! –Pour les variables de lutilisateur qui sont locales, nous pourrons faire des choses ! –Pour les variables de lutilisateur qui sont globales, nous ne pouvons en gros rien faire !

91 18 octobre 2007Cours de compilation 7 - Intranet91 Durée de vie des variables ---------------------------------------------------------------- Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) ! –Pour les variables du compilateur cest facile à savoir ! –Pour les variables de lutilisateur qui sont locales, nous pourrons faire des choses ! –Pour les variables de lutilisateur qui sont globales, nous ne pouvons en gros rien faire !

92 18 octobre 2007Cours de compilation 7 - Intranet92 Durée de vie des variables ---------------------------------------------------------------- Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) ! –Pour les variables du compilateur cest facile à savoir ! –Pour les variables de lutilisateur qui sont locales, nous pourrons faire des choses ! –Pour les variables de lutilisateur qui sont globales, nous ne pouvons en gros rien faire ! Nous voulons savoirNous voulons savoir –« qui définit quoi ? », –« qui utilise quoi ? » !

93 18 octobre 2007Cours de compilation 7 - Intranet93 Durée de vie des variables ---------------------------------------------------------------- Au niveau dun bloc, nous pouvons définirAu niveau dun bloc, nous pouvons définir –use ( bloc ), resp. def ( bloc ), qui est lensemble des variables lues, resp. écrites, par ce bloc.

94 18 octobre 2007Cours de compilation 7 - Intranet94 Durée de vie des variables ---------------------------------------------------------------- Au niveau dun bloc, nous pouvons définirAu niveau dun bloc, nous pouvons définir –use ( bloc ), resp. def ( bloc ), qui est lensemble des variables lues, resp. écrites, par ce bloc. –Use ( bloc ), resp. Def ( bloc ), qui est lensemble des variables lues, resp. écrites, par ce bloc ou un de ses successeurs.

95 18 octobre 2007Cours de compilation 7 - Intranet95 Durée de vie des variables ---------------------------------------------------------------- Au niveau dun bloc, nous pouvons définirAu niveau dun bloc, nous pouvons définir –use ( bloc ), resp. def ( bloc ), qui est lensemble des variables lues, resp. écrites, par ce bloc. –Use ( bloc ), resp. Def ( bloc ), qui est lensemble des variables lues, resp. écrites, par ce bloc ou un de ses successeurs. Une autre idée : « next_use ».Une autre idée : « next_use ». i : x <-... i : x <-... x <-... x <-...... <-... x...... <-... x... j :... <-... x... j :... <-... x... next_use ( i ) = j

96 18 octobre 2007Cours de compilation 7 - Intranet96 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction

97 18 octobre 2007Cours de compilation 7 - Intranet97 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers !

98 18 octobre 2007Cours de compilation 7 - Intranet98 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers ! Initialisation :Initialisation : –Toutes les variables : no-use –Les variables globales : live –Les variables locales et temporaires : live, si elles sont lues dans un bloc successeur, live, si elles sont lues dans un bloc successeur, live, sinon. live, sinon.

99 18 octobre 2007Cours de compilation 7 - Intranet99 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers ! Pour toute instruction i : x < - y op zPour toute instruction i : x < - y op z

100 18 octobre 2007Cours de compilation 7 - Intranet100 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers ! Pour toute instruction i : x < - y op zPour toute instruction i : x < - y op z –Nous attachons à i les informations sur x, y et z.

101 18 octobre 2007Cours de compilation 7 - Intranet101 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers ! Pour toute instruction i : x < - y op zPour toute instruction i : x < - y op z –Nous attachons à i les informations sur x, y et z. –x devient live et no-use.

102 18 octobre 2007Cours de compilation 7 - Intranet102 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers ! Pour toute instruction i : x < - y op zPour toute instruction i : x < - y op z –Nous attachons à i les informations sur x, y et z. –x devient live et no-use. –y et z deviennent live et de numéro i.

103 18 octobre 2007Cours de compilation 7 - Intranet103 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers ! Pour toute instruction i : x < - y op zPour toute instruction i : x < - y op z –Nous attachons à i les informations sur x, y et z. –x devient live et no-use. –y et z deviennent live et de numéro i. Attention à lordre, car la variable x pourrait être identique à y ou z !

104 18 octobre 2007Cours de compilation 7 - Intranet104 Durée de vie des variables ---------------------------------------------------------------- Une illustration, avec t temporaire locale au bloc :Une illustration, avec t temporaire locale au bloc : ( 1 ) x <- y + t ( 2 ) y <- x + y ( 3 ) x <- y - z

105 18 octobre 2007Cours de compilation 7 - Intranet105 Durée de vie des variables ---------------------------------------------------------------- Une illustration, avec t temporaire locale au bloc :Une illustration, avec t temporaire locale au bloc : ( 1 ) x <- y + t ( 2 ) y <- x + y ( 3 ) x <- y - z live : x, y, z live : t x, y, z, t : no-use

106 18 octobre 2007Cours de compilation 7 - Intranet106 Durée de vie des variables ---------------------------------------------------------------- Une illustration, avec t temporaire locale au bloc :Une illustration, avec t temporaire locale au bloc : ( 1 ) x <- y + t ( 2 ) y <- x + y ( 3 ) x <- y - z live : x, y, z live : t x, y, z, t : no-use live : y, z live : x, t x, t : no-use y, z : 3

107 18 octobre 2007Cours de compilation 7 - Intranet107 Durée de vie des variables ---------------------------------------------------------------- Une illustration, avec t temporaire locale au bloc :Une illustration, avec t temporaire locale au bloc : ( 1 ) x <- y + t ( 2 ) y <- x + y ( 3 ) x <- y - z live : x, y, z live : t x, y, z, t : no-use live : y, z live : x, t x, t : no-use y, z : 3 live : x, y, z live : t t : no-use x, y : 2 z : 3

108 18 octobre 2007Cours de compilation 7 - Intranet108 Durée de vie des variables ---------------------------------------------------------------- Une illustration, avec t temporaire locale au bloc :Une illustration, avec t temporaire locale au bloc : ( 1 ) x <- y + t ( 2 ) y <- x + y ( 3 ) x <- y - z live : x, y, z live : t x, y, z, t : no-use live : y, z live : x, t x, t : no-use y, z : 3 live : x, y, z live : t t : no-use x, y : 2 z : 3 live : y, z, t live : x x : no-use y, t : 1 z : 3

109 18 octobre 2007Cours de compilation 7 - Intranet109 Durée de vie des variables ---------------------------------------------------------------- Une illustration, avec t temporaire locale au bloc :Une illustration, avec t temporaire locale au bloc : ( 1 ) x <- y + t ( 2 ) y <- x + y ( 3 ) x <- y - z live : x, y, z live : t x, y, z, t : no-use live : y, z live : x, t x, t : no-use y, z : 3 live : x, y, z live : t t : no-use x, y : 2 z : 3 live : y, z, t live : x x : no-use y, t : 1 z : 3 Pour t :

110 18 octobre 2007Cours de compilation 7 - Intranet110 Durée de vie des variables ---------------------------------------------------------------- Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) !Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) ! –Nous supposons, par défaut, que les variables doivent être vivantes !

111 18 octobre 2007Cours de compilation 7 - Intranet111 Durée de vie des variables ---------------------------------------------------------------- Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) !Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) ! –Nous supposons, par défaut, que les variables doivent être vivantes ! –Nous essayons ensuite de montrer que certaines variables sont en fait inutiles !

112 18 octobre 2007Cours de compilation 7 - Intranet112 Durée de vie des variables ---------------------------------------------------------------- Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) !Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) ! –Nous supposons, par défaut, que les variables doivent être vivantes ! –Nous essayons ensuite de montrer que certaines variables sont en fait inutiles ! –Souvent lanalyse est obtenu par itérations jusquà atteindre un point-fixe !

113 18 octobre 2007Cours de compilation 7 - Intranet113 Durée de vie des variables ---------------------------------------------------------------- Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) !Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) ! –Nous supposons, par défaut, que les variables doivent être vivantes ! –Nous essayons ensuite de montrer que certaines variables sont en fait inutiles ! –Souvent lanalyse est obtenu par itérations jusquà atteindre un point-fixe ! –Ceci veut dire que nous nous arrêtons seulement lorsque la dernière itération na plus apporté de modifications !

114 18 octobre 2007Cours de compilation 7 - Intranet114 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN x <- x-1 y <- x FIN : y <- x+1 Les flèches donnent les dépendances !

115 18 octobre 2007Cours de compilation 7 - Intranet115 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x

116 18 octobre 2007Cours de compilation 7 - Intranet116 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y)

117 18 octobre 2007Cours de compilation 7 - Intranet117 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) OK

118 18 octobre 2007Cours de compilation 7 - Intranet118 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) OK

119 18 octobre 2007Cours de compilation 7 - Intranet119 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) PROBLEME

120 18 octobre 2007Cours de compilation 7 - Intranet120 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) PROBLEME

121 18 octobre 2007Cours de compilation 7 - Intranet121 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 :

122 18 octobre 2007Cours de compilation 7 - Intranet122 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 :

123 18 octobre 2007Cours de compilation 7 - Intranet123 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 : Itération 3 :

124 18 octobre 2007Cours de compilation 7 - Intranet124 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 : Itération 3 :

125 18 octobre 2007Cours de compilation 7 - Intranet125 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 : Itération 3 :

126 18 octobre 2007Cours de compilation 7 - Intranet126 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 : Itération 3 :

127 18 octobre 2007Cours de compilation 7 - Intranet127 Durée de vie des variables ---------------------------------------------------------------- x <- 5 si x = 0 goto FIN FIN : y <- x+1 x <- x-1

128 18 octobre 2007Cours de compilation 7 - Intranet128 Résumé ---------------------------------------------------------------- Génération de code Génération de code Optimisation de code Optimisation de code

129 18 octobre 2007Cours de compilation 7 - Intranet129 E T P O U R C O N C L U R E...

130 18 octobre 2007Cours de compilation 7 - Intranet130 Résumé du cours ---------------------------------------------------------------- Définitions de base Définitions de base Composition de compilateurs Composition de compilateurs Lenvironnement dun compilateur Lenvironnement dun compilateur Evaluation partielle et compilation Evaluation partielle et compilation Analyses lexicales et syntaxiques Analyses lexicales et syntaxiques Techniques danalyse descendantes Techniques danalyse descendantes Techniques danalyse ascendantes Techniques danalyse ascendantes YACC YACC Analyse sémantique Analyse sémantique Environnement dexécution Environnement dexécution Génération de code Génération de code Optimisation de code Optimisation de code

131 18 octobre 2007Cours de compilation 7 - Intranet131 Résumé du cours ---------------------------------------------------------------- Définitions de base Définitions de base Composition de compilateurs Composition de compilateurs Lenvironnement dun compilateur Lenvironnement dun compilateur Evaluation partielle et compilation Evaluation partielle et compilation Analyses lexicales et syntaxiques Analyses lexicales et syntaxiques Techniques danalyse descendantes Techniques danalyse descendantes Techniques danalyse ascendantes Techniques danalyse ascendantes YACC YACC Analyse sémantique Analyse sémantique Environnement dexécution Environnement dexécution Génération de code Génération de code Optimisation de code Optimisation de code

132 18 octobre 2007Cours de compilation 7 - Intranet132 Résumé du cours ---------------------------------------------------------------- Définitions de base Définitions de base Composition de compilateurs Composition de compilateurs Lenvironnement dun compilateur Lenvironnement dun compilateur Evaluation partielle et compilation Evaluation partielle et compilation Analyses lexicales et syntaxiques Analyses lexicales et syntaxiques Techniques danalyse descendantes Techniques danalyse descendantes Techniques danalyse ascendantes Techniques danalyse ascendantes YACC YACC Analyse sémantique Analyse sémantique Environnement dexécution Environnement dexécution Génération de code Génération de code Optimisation de code Optimisation de code

133 18 octobre 2007Cours de compilation 7 - Intranet133 Résumé du cours ---------------------------------------------------------------- Définitions de base Définitions de base Composition de compilateurs Composition de compilateurs Lenvironnement dun compilateur Lenvironnement dun compilateur Evaluation partielle et compilation Evaluation partielle et compilation Analyses lexicales et syntaxiques Analyses lexicales et syntaxiques Techniques danalyse descendantes Techniques danalyse descendantes Techniques danalyse ascendantes Techniques danalyse ascendantes YACC YACC Analyse sémantique Analyse sémantique Environnement dexécution Environnement dexécution Génération de code Génération de code Optimisation de code Optimisation de code

134 18 octobre 2007Cours de compilation 7 - Intranet134 Résumé du cours ---------------------------------------------------------------- Définitions de base Définitions de base Composition de compilateurs Composition de compilateurs Lenvironnement dun compilateur Lenvironnement dun compilateur Evaluation partielle et compilation Evaluation partielle et compilation Analyses lexicales et syntaxiques Analyses lexicales et syntaxiques Techniques danalyse descendantes Techniques danalyse descendantes Techniques danalyse ascendantes Techniques danalyse ascendantes YACC YACC Analyse sémantique Analyse sémantique Environnement dexécution Environnement dexécution Génération de code Génération de code Optimisation de code Optimisation de code

135 18 octobre 2007Cours de compilation 7 - Intranet135 C e S t L a F i N d U c O u R s ! ! ! L e P r O j E t A p P o R t E r A l A p R a T i Q u E ! ! !