Compilation : thorie, techniques et outils

Exercices

HABIB ABDULRAB (INSTITUT NATIONAL DES SCIENCES

APPLIQUES DE ROUEN)
CLAUDE MOULIN (UNIVERSIT DE TECHNOLOGIE DE
COMPIGNE)
SID TOUATI (UNIVERSIT DE VERSAILLES SAINT-QUENTIN
EN YVELINES)
 Table des
matires

I - TD 0 - Introduction la programmation assembleur 7

A.Pr-requis du TD 0.....................................................................................7

B.Exercice 1.................................................................................................7

C.Exercice 2.................................................................................................9

D.Exercice 3...............................................................................................10

E.Exercice 4...............................................................................................10

F.Exercice 5................................................................................................10

II - TD1 - Analyse lexicale 13

A.Exercice 1...............................................................................................13

B.Exercice 2...............................................................................................14

C.Exercice 3...............................................................................................14

D.Exercice 4...............................................................................................15

E.Exercice 5...............................................................................................15

III - TD 2 - Analyse syntaxique 17

A.Exercice 1 : Analyse descendante...............................................................17

B.Exercice 2 : Grammaire............................................................................17

C.Exercice 3 : IF ... THEN ... ELSE (LL)..........................................................18

D.Exercice 4 : IF ... THEN ... ELSE (LR)........................................................19

E.Exercice 5 : SLR, LALR..............................................................................19

IV - TD3 - Analyse smantique 21

A.Exercice 1 : Grammaire LR d'expressions arithmtiques................................21

B.Exercice 2 : Grammaire LL d'expressions arithmtiques................................21

V - TD 4 - Actions smantiques et Yacc (table Aes symboles

simple) 23

3
 TD 0 - Introduction la programmation assembleur

A.Pr-requis du TD4....................................................................................23

B.Exercice 1...............................................................................................23

C.Exercice 2 : Utilisation de Yacc...................................................................24

D.Exercice 3 : Utilisation de Yacc (suite)........................................................24

VI - TD 5 - Actions smantiques et Yacc (Gestion des types) 27

A.Pr-requis du TD 5 ..................................................................................27

B.Exercice 1...............................................................................................27

C.Exercice 2...............................................................................................28

VII - TD 6 - Tables de symboles et types. 29

A.Pr-requis du TD 6 ..................................................................................29

B.Exercice 1...............................................................................................29

C.Exercice 2...............................................................................................30

VIII - TD 7 - Gnration de code 31

A.Pr-requis du TD 7...................................................................................31

B.Exercice 1...............................................................................................31

C.Exercice 2...............................................................................................32

IX - TD 8 - Gnration de code 35

A.Pr-requis du TD 8 ..................................................................................35

B.Exercice 1...............................................................................................35

C.Exercice 2...............................................................................................36

D.Exercice 3...............................................................................................36

X - TD 9 - Gnration de code et optimisation. 39

A.Pr-requis du TD 9...................................................................................39

B.Exercice 1...............................................................................................39

C.Exercice 2...............................................................................................40

Solution des exercices rdactionnels 43

4
TD 0 -
I-

I
Introduction la
programmation
assembleur

Pr-requis du TD 0 7
Exercice 1 7
Exercice 2 9
Exercice 3 10
Exercice 4 10
Exercice 5 10

A.Pr-requis du TD 0

Avoir suivi le cours d'introduction la compilation qui explique les rudiments

de la programmation assembleur (x86).
Pour l'architecture i386, avoir tudi les diffrences entre la syntaxe asm
AT&T et la syntaxe intel. Voir le document donn en annexe (cf. Annexe
TD0).
Pour faire l'exercice 1, il faudrait tudier le document donn en annexe
dcrivant la smantique de chaque instruction asm i386. Attention, il y a
une diffrence entre la syntaxe intel et la syntaxe AT&T (adopte par gnu
gcc).

B.Exercice 1
Traduire le programme assembleur ci-dessous en langage C.

Question
[Solution n1 p 37]

5
 TD 0 - Introduction la programmation assembleur

6
 TD 0 - Introduction la programmation assembleur

C.Exercice 2
Gnrer le code assembleur du programme C ci-dessous.

Question
[Solution n2 p 39]

7
 TD 0 - Introduction la programmation assembleur

D.Exercice 3
Gnrer le code assembleur du programme C ci-dessous.

Question
[Solution n3 p 40]

E.Exercice 4
Gnrer le code assembleur du code C ci-dessous. On supposera que le tableau est
rang e, lignes.

Question
[Solution n4 p 40]

F.Exercice 5
Dans la dclaration suivante, dterminez la formule donnant l'adresse de la case
mmoire rfrence par l'expression: tab[i][j][k].

Question
[Solution n5 p 41]

8
TD1 - Analyse
II -

II
lexicale

Exercice 1 13
Exercice 2 14
Exercice 3 14
Exercice 4 15
Exercice 5 15

A.Exercice 1
Trouver un automate reconnaissant :

Question 1
[Solution n6 p 42]
Le langage ; o L est le langage des mots ayant une seule occurrence de

Question 2
[Solution n7 p 42]
L'ensemble de nombres entiers (signs ou non) sur l'alphabet .

Question 3
[Solution n8 p 42]
L'ensemble de nombres rationnels (signs ou non) sur l'alphabet
.
Les langages suivants sont-ils reconnaissables ?

Question 4
[Solution n9 p 42]
= l'ensemble des mots sur terminant par .
i.e. .

Question 5
[Solution n10 p 43]
l'ensemble des mots sur qui sont des reprsentations binaires des
entiers naturels multiples de 3.
Un automate est complet si pour chaque tat de , et chaque lettre de , il
existe une flche de la forme , o est un tat de l'automate.

Question 6
[Solution n11 p 43]

9
 TD1 - Analyse lexicale

Montrer que pour chaque automate on peut associer un automate not

t.q.:

B.Exercice 2
Les langages suivants sont-ils rguliers ?

Question 1
[Solution n12 p 44]
Le langage ; o est le langage des mots ayant une seule occurrence de

Question 2
[Solution n13 p 44]
L'ensemble de nombres entiers (signs ou non) sur l'alphabet
.

Question 3
[Solution n14 p 44]
L'ensemble de nombres rationnels (signs ou non) sur l'alphabet
.

Question 4
[Solution n15 p 44]
l'ensemble des mots sur terminant par .
i.e. .

Question 5
[Solution n16 p 44]
1.10)

C.Exercice 3
Dterminiser les automates suivants

Question 1
[Solution n17 p 44]

Question 2
[Solution n18 p 44]

10
 TD1 - Analyse lexicale

D.Exercice 4
Si et sont deux langages rguliers:

Question 1
[Solution n19 p 45]
Calculer l'automate qui reconnat . En dduire l'automate
reconnaissant: .

Question 2
[Solution n20 p 46]
Calculer l'automate qui reconnait . En dduire l'automate
reconnaissant: .

Question 3
[Solution n21 p 46]
En dduire que et sont rguliers.

E.Exercice 5

Question
[Solution n22 p 46]
Trouver un scanner non dterministe qui associe chaque mot de , de
longueur , le mot si est pair, le mot sinon.

11
TD 2 - Analyse
III -

III
syntaxique

Exercice 1 : Analyse descendante 17

Exercice 2 : Grammaire 17
Exercice 3 : IF ... THEN ... ELSE (LL) 18
Exercice 4 : IF ... THEN ... ELSE (LR) 19
Exercice 5 : SLR, LALR 19

A.Exercice 1 : Analyse descendante

Soit la grammaire :

Question 1
[Solution n23 p 47]
Construire les ensembles PREMIER et SUIVANT pour cette grammaire.

Question 2
[Solution n24 p 47]
tablir la table d'analyse et montrer que cette grammaire n'est pas LL(1)

B.Exercice 2 : Grammaire
Soit la grammaire d'expressions arithmtiques dfinie par les productions suivantes
:

Question 1
[Solution n25 p 47]
Les terminaux de la grammaire sont :

13
 TD 2 - Analyse syntaxique

Donner les drivations les plus gauche pour les chanes et

Question 2
[Solution n26 p 48]
Cette grammaire est-t-elle rcursive gauche ? Si oui, transformez-la en
grammaire rcursive droite.

Question 3
[Solution n27 p 48]
On cherche maintenant crire un analyseur syntaxique descendant pour cette
grammaire. Quelle grammaire utiliser ?

Question 4
[Solution n28 p 48]
Simuler l'analyse de l'expression par un analyseur de type
descendant.

C.Exercice 3 : IF ... THEN ... ELSE (LL)

Soit la grammaire :

Les terminaux sont :

L'axiome est

Question 1
[Solution n29 p 50]
Cette grammaire est-elle LL(1) ?

Question 2
[Solution n30 p 50]
Comment lve-t-on gnralement l'ambigut rencontre ?

Question 3
[Solution n31 p 51]
Analyser l'instruction suivante en utilisant le choix de la question prcdente :

D.Exercice 4 : IF ... THEN ... ELSE (LR)

Soit la grammaire :

14
 TD 2 - Analyse syntaxique

Les terminaux sont :

Question 1
[Solution n32 p 51]
Cette grammaire est-elle LR(0) ?

Question 2
[Solution n33 p 51]
Cette grammaire est-elle SLR(1) ?

Question 3
[Solution n34 p 52]
S'il existe des conflits quelle convention utiliser pour les supprimer ?

E.Exercice 5 : SLR, LALR

Considrons la grammaire G suivante :

Question
[Solution n35 p 52]
Montrer que cette grammaire est LALR(1) mais pas SLR(1).

15
TD3 - Analyse
IV -

IV
smantique

Exercice 1 : Grammaire LR d'expressions arithmtiques. 21

Exercice 2 : Grammaire LL d'expressions arithmtiques. 21

A.Exercice 1 : Grammaire LR d'expressions

arithmtiques.
Soit la grammaire LR d'expressions arithmtiques dfinie par les productions
numrotes comme suit :

Question 1
[Solution n36 p 53]
Programmez cette grammaire avec lex & yacc.

Question 2
[Solution n37 p 54]
Ajouter des actions smantiques la grammaire yacc pour calculer la valeur d'une
expression arithmtique crite avec la grammaire prcdente.

17
 TD3 - Analyse smantique

B.Exercice 2 : Grammaire LL d'expressions

arithmtiques.
Soit la grammaire LL d'expressions arithmtiques dfinie par les productions
numrotes comme suit :

Question 1
[Solution n38 p 55]
Proposer une grammaire AntLR pour reprsenter cette grammaire.

Question 2
[Solution n39 p 55]
Ajouter des actions smantiques en Java la grammaire AntLR pour calculer la
valeur d'une expression arithmtique crite avec la grammaire prcdente.

Question 3
[Solution n40 p 56]
Donner un programme Java permettant de lire un fichier contenant une expression
arithmtique et utilisant le lexer et le parser crs partir de la grammaire AntLR.

18
TD 4 - Actions
V-

V
smantiques et
Yacc (table Aes
symboles simple)

Pr-requis du TD4 23
Exercice 1 23
Exercice 2 : Utilisation de Yacc 24
Exercice 3 : Utilisation de Yacc (suite) 24

A.Pr-requis du TD4

Avoir suivi le cours de compilation sur la traduction dirige par la syntaxe.

Matriser les outils { lex & yacc}, sinon relire le manuel et refaire les TD
prcdents.

B.Exercice 1
Afin de construire une calculatrice grant les affectations de variables, on utilise la
grammaire suivante :

Question 1
[Solution n41 p 56]
Donner une interface simple de programmation d'une table de symboles adapte
notre calculatrice.

Question 2
[Solution n42 p 57]
Dans le cas d'une traduction dirige par la syntaxe S-attribue, dterminer les

19
 TD 4 - Actions smantiques et Yacc (table Aes symboles simple)

actions smantiques associes chaque production.

Question 3
Soit le texte . Dessiner l'arbre de drivation correspondant en
mentionnant les valeurs des attributs pour chaque symbole syntaxique (terminal et
non terminal).

C.Exercice 2 : Utilisation de Yacc

On souhaite toujours raliser une calculatrice, mais en partant cette fois de la
grammaire suivante:

Question 1
[Solution n43 p 57]
Cette grammaire est-elle ambige ? Si oui, donner un exemple d'entre crant un
conflit .

Question 2
[Solution n44 p 57]
Ces conflits peuvent tre rsolus en exploitant l'associativit et les priorits usuelles
des oprateurs , , et .
L'oprateur unaire possde la plus haute priorit.
crire un analyseur lexical (avec ) et un analyseur syntaxique (avec ) pour
cette calculatrice aprs avoir lever l'ambigut de la grammaire.

D.Exercice 3 : Utilisation de Yacc (suite)

On ajoute maintenant notre calculatrice la gestion de variables dont le nom est
une lettre (en minuscule) de l'alphabet: il n'y a donc que 26 noms de variables
possibles.
La calculatrice doit galement accepter les nombres en virgule flottante et plusieurs
calculs la fois. Pour cela, on enrichit la grammaire:

Question
[Solution n45 p 59]
Modifier en consquence les spcifications et de la question prcdente.
On utilisera un tableau de type pour stocker les valeurs des variables.

20
TD 5 - Actions
VI -

VI
smantiques et
Yacc (Gestion des
types)

Pr-requis du TD 5 27
Exercice 1 27
Exercice 2 28

A.Pr-requis du TD 5

Avoir compris le cours de compilation sur la traduction dirige par la

syntaxe.
Avoir suivi le cours de compilation sur la table des symboles.

B.Exercice 1
On reprend la grammaire de calculatrice suivante:

On dsire tendre le nom des variables une suite quelconque de lettres de

l'alphabet.

Question 1
[Solution n46 p 60]
A-t-on besoin d'une table de symboles ? Si oui, proposez plusieurs types
d'implmentations possibles. Quelle structure de donnes est la plus utilise ?

Question 2
[Solution n47 p 61]

21
 TD 5 - Actions smantiques et Yacc (Gestion des types)

Implmentez en langage C une table de symboles possdant l'interface suivante:

Question 3
[Solution n48 p 62]
crire des spcifications et utilisant la table de symboles implmente
dans la question prcdente.

C.Exercice 2
Le but de cet exercice est d'analyser des dclarations de fonctions du type
.
On utilise pour cela la grammaire suivante:

Question 1
[Solution n49 p 66]
A l'aide de et , crivez un parseur analysant ces dclarations et affichant
pour chaque dclaration un rsum du type:

Question 2
[Solution n50 p 69]
Dans l'ventualit de dclarations multiples d'une fonction, on dsire vrifier la
cohrence des dclarations, et afficher au besoin des messages d'erreur. Modifiez
votre parseur en consquence.

22
TD 6 - Tables de
VII -

VII
symboles et
types.

Pr-requis du TD 6 29
Exercice 1 29
Exercice 2 30

A.Pr-requis du TD 6

Avoir compris le cours de compilation sur la traduction dirige par la

syntaxe.
Avoir suivi le cours de compilation sur la table des symboles.

B.Exercice 1
Dclarations de variables
On souhaite crire un compilateur pour un langage comportant des dclarations de
variables locales une procdure, du type:

On dcrit la syntaxe de ces dclarations l'aide de la grammaire suivante:

On souhaite enregistrer chaque variable dclare dans une table de symboles, et

associer chaque variable la position (relative) en mmoire dans laquelle elle sera
stocke.

Question 1
[Solution n51 p 75]
Proposez une interface adapte pour la table des symboles.

23
 TD 6 - Tables de symboles et types.

Question 2
[Solution n52 p 75]
Proposez des actions smantiques (en syntaxe ) pour chaque production de la
grammaire.

C.Exercice 2
Dclarations de variables (suite)
On reprend la grammaire de l'exercice prcdent.
On souhaite maintenant traiter galement des dclarations internes un bloc (et
dont la porte se limite ce bloc), avec des blocs ventuellement imbriqus,
comme dans l'exemple suivant:

{ int c;
int a; /* re-dclaration licite de 'a' */
...
}
...
}
On tend la grammaire de l'exercice prcdent en ajoutant la rgle:

o dsigne une que l'on ne dtaillera pas.

Question 1
[Solution n53 p 76]
Peut-on encore utiliser une table de symboles unique ?
Proposez un mcanisme permettant de grer les dclarations internes chaque
bloc et crivez les actions smantiques de la grammaire.

Question 2
[Solution n54 p 77]
On dsire afficher un message d'avertissement lorsqu'une variable dclare dans un
bloc en masque une autre dclare dans un bloc englobant. Modifiez les actions
smantiques en consquence.

24
TD 7 - Gnration
VIII -

VIII
de code

Pr-requis du TD 7 31
Exercice 1 31
Exercice 2 32

A.Pr-requis du TD 7

Assembleur i386 (revoir le TD1).

Avoir compris les cours de compilation sur la traduction dirige par la
syntaxe.
Avoir suivi le cours de compilation sur les codes intermdiaires et sur la
gnration de code.

B.Exercice 1
Un compilateur pour calculatrice
On reprend la grammaire des expressions arithmtiques vue prcdemment :

Au lieu de calculer les expressions lors de l'analyse syntaxique, on dsire cette fois
gnrer du code assembleur pour architecture i386.
Ce code devra calculer chaque expression et en afficher la valeur en appelant la
fonction de la librairie C.

Question 1
[Solution n55 p 78]
Proposez une structure de donnes simple permettant de reprsenter et manipuler
un programme assembleur.

Question 2
[Solution n56 p 78]
Notre code assembleur doit pouvoir lire et affecter des variables.

25
 TD 7 - Gnration de code

Proposez plusieurs mcanismes d'allocation des variables et de gnration de code

correspondante.

Question 3
[Solution n57 p 78]
On dcide dans un premier temps de gnrer un code exploitant essentiellement la
pile d'excution du processeur i386, en adoptant les conventions suivantes:
Les oprandes d'une expression sont toujours prsentes sur la pile
(l'oprande la plus droite sur le sommet de la pile).
Le rsultat d'une expression est systmatiquement empil.
crire une spcification correspondante. A cet effet, nous supposons que
chaque symbole syntaxique non terminal a un attribut qui contient le code
gnr.

Question 4
[Solution n58 p 82]
On modifie lgrement nos conventions de gnration de code en exploitant
davantage les registres du processeur:
Les oprandes d'une expression sont places dans les registres %eax et
%ecx.
Le rsultat d'une expression est systmatiquement plac dans le registre
%eax.
Modifiez en consquence votre spcification yacc.

Question 5
[Solution n59 p 85]
Le code assembleur ainsi gnr est-il directement excutable ?
Expliquez comment obtenir un binaire excutable, et compltez ventuellement
votre spcification .

Question 6
[Solution n60 p 86]
Si la fonction utilisait le passage par au lieu du passage par
des chanes de caractres, comment votre programme serait-il modifi ? on
suppose dans ce cas que les chanes de caractres ont une taille fixe de 128 octets.

C.Exercice 2
Appels de fonctions
On souhaite maintenant utiliser dans la calculatrice de l'exercice prcdent des
fonctions externes (comme par exemple , de la librairie C). Ces fonctions
devront avoir un prototype C de la forme:

On tend la grammaire de la calculatrice:

Question 1
[Solution n61 p 86]
En utilisant les conventions de gnration de code de la question 1.3, crire les
actions smantiques correspondant aux appels de fonction.

26
 TD 7 - Gnration de code

Question 2
[Solution n62 p 88]
Mme question en adoptant les conventions de la question 4.

27
TD 8 - Gnration
IX -

IX
de code

Pr-requis du TD 8 35
Exercice 1 35
Exercice 2 36
Exercice 3 36

A.Pr-requis du TD 8

Avoir suivi le cours de compilation sur sur la gnration de code.

B.Exercice 1
On souhaite gnrer du code pour valuer des expressions sur une machine
registres (pas d'opration mmoire-registre). On considre l'expression suivante :

Question 1
[Solution n63 p 89]
Dessinez l'arbre abstrait de cette expression et calculez le nombre de registres
ncessaires pour valuer cette expression (on utilisera l'algorithme de Sethi et
Ullman vu en cours). On supposera que toutes les variables sont initialement
places en mmoire.
On suppose dans la suite que notre machine ne dispose que de deux registres.

Question 2
[Solution n64 p 92]
Calculer le nombre minimal d'oprations de spill ncessaires pour valuer
l'expression.

Question 3
[Solution n65 p 94]
On souhaite ne pas gnrer de code pour une expression dont les deux oprandes
sont des constantes, i.e., c'est le compilateur lui mme qui doit calculer les sous-
expressions constantes. Proposez une mthode permettant d'implmenter une telle
optimisation dans un compilateur.

29
 TD 8 - Gnration de code

C.Exercice 2
Reprenons la grammaire de la mini-calculatrice :

On souhaite maintenant traduire un programme crit dans ce langage de mini-

calculatrice en un code cible trois adresses proche du C, soit une squence
d'instructions de la forme :

o , et sont des identificateurs, des constantes ou des variables temporaires

produites par le compilateur. Le terme dnote un des oprateurs .
Ainsi l'expression pourra par exemple tre traduite de la manire
suivante :

Question 1
[Solution n66 p 97]
On considre dans un premier temps que l'on dispose :
D'une fonction qui fournit un nouveau nom de variable temporaire
non utilis.
D'un attribut pour chaque symbole syntaxique non terminal.
D'un attribut pour chaque symbole syntaxique non terminal qui
contient le nom de la variable stockant le rsultat.
Proposez des actions smantiques pour les rgles de la grammaire qui gnrent du
code trois adresses.

Question 2
[Solution n67 p 98]
Dessinez l'arbre de drivation et donnez le code gnr pour l'entre suivante :
.

D.Exercice 3
Afin de traiter les boucles, on ajoute la grammaire de la calculatrice la production
suivante :

On ajoute galement dans le langage trois adresses les instructions suivantes :

Le branchement inconditionnel qui a pour effet de faire excuter
ensuite l'instruction tiquete par L.
Le branchement conditionnel : . Le terme op dsigne un des
oprateurs de comparaison .

Question 1
[Solution n68 p 98]
Dfinir un modle de traduction de la structure de contrle for l'aide des

30
 TD 8 - Gnration de code

branchements inconditionnels et conditionnels du langage trois adresses.

Question 2
[Solution n69 p 99]
Proposer une traduction dirige par la syntaxe pour appliquer ce modle de
traduction et gnrer le code. On dispose:
D'un attribut pour chaque symbole syntaxique non terminal.
D'un attribut pour E qui contient le nom de la variable stockant le
rsultat.
D'une fonction qui fournit une nouvelle tiquette non utilise.

Question 3
[Solution n70 p 99]
Dessiner l'arbre de drivation et donner le code gnr pour :

31
TD 9 - Gnration
X-

X
de code et
optimisation.

Pr-requis du TD 9 39
Exercice 1 39
Exercice 2 40

A.Pr-requis du TD 9

Avoir compris le cours de compilation sur la gnration de code.

Avoir suivi le cours de compilation sur l'introduction l'optimisation de code.

B.Exercice 1
La grammaire de la mini-calculatrice est prsent tendue pour permettre
l'utilisation de conditionnelles:

On suppose ce qui suit :

le terminal a un attribut qui sert dterminer le type d'oprateur
de comparaison utilis parmi , etc.
le non-terminal possde les attributs suivants:
- Deux tiquettes et .
- Un code gnr . Ce code gnre un branchement vers si
l'expression est vraie, et vers dans le cas contraire.
le non-terminal a un attribut qui contient le code valuant
l'expression, et un attribut qui contient le nom de la variable
contenant le rsultat de .
On dispose d'une fonction qui fournit un nouveau nom
d'tiquette non utilis chaque appel.

33
 TD 9 - Gnration de code et optimisation.

On dsire traduire le code de la calculatrice en code trois adresses:

Question 1
[Solution n71 p 100]
Proposer une traduction dirige par la syntaxe qui gnre le code des productions
du type . On ne soucie donc pas pour l'instant de la gnration de .

Question 2
[Solution n72 p 101]
Considrons dans cette question la sous-grammaire associe au productions des
expressions boolennes . Proposer une traduction dirige par la syntaxe
(par ncessairement S-attribue) qui gnre du code pour les expressions
boolennes. On souhaite que l'valuation des expressions boolennes soit
optimise, c'est--dire que l'valuation d'une expression ( resp.
) s'arrte si est valu faux ( resp. vrai ). A cet effet, reportez-
vous au modle de traduction dit "par branchements" tel vu au cours.

Question 3
[Solution n73 p 103]
La traduction automatique de en code trois adresses produit la paire
d'instructions:

On pourrait se limiter une seule instruction:

et faire en sorte que l'excution suive son cours si l'ingalit est vraie. En d'autres
termes, nous ne gnrons pas deux branchements, l'un vers une tiquette et
l'autre vers une tiquette , mais uniquement un seul branchement vers l'une
des deux tiquettes. Modifier en consquence la traduction dirige par la syntaxe
de la question prcdente.

C.Exercice 2
On tudie dans cet exercice quelques optimisations sur du code trois adresses
dcoup en blocs de base. On considre le petit programme suivant en syntaxe
mini-calculatrice:

Question 1
[Solution n74 p 104]
Traduire le programme en code trois adresses.

Question 2
[Solution n75 p 105]
Dcouper ce code trois adresses en blocs de base.

34
 TD 9 - Gnration de code et optimisation.

Question 3
Reprsenter le graphe de flot de contrle ainsi obtenu.

Question 4
[Solution n76 p 105]
Effectuer la main une limination de sous-expressions communes sur chacun des
blocs.

Question 5
[Solution n77 p 105]
Effectuer une limination de code mort sur chacun des blocs.

35
 Solution des
exercices
rdactionnels

> Solution n1 (exercice p. 5)

Code assembleur comment

37
 TD 9 - Gnration de code et optimisation.

38
 TD 9 - Gnration de code et optimisation.

Programme C source

> Solution n2 (exercice p. 7)

39
 TD 9 - Gnration de code et optimisation.

> Solution n3 (exercice p. 8)

> Solution n4 (exercice p. 8)

40
 TD 9 - Gnration de code et optimisation.

> Solution n5 (exercice p. 8)

Toues les lments du tableau sont contigus en mmoire => un tableau trois
dimensions reprsente un cube.
Si le tableau est rang en lignes, cela veut dire que les lments contigus sont
tab[0][0][0], tab[0][0][1], tab[0][0][2], .... tab[0][0][n3-1],tab[0][1][0], tab[0]
[1][1], ....

41
 TD 9 - Gnration de code et optimisation.

adresse de l'lment tab[i][j][k]= ( n2*n3*i + n3*j + k )*sizeof( struct t )

> Solution n6 (exercice p. 9)

> Solution n7 (exercice p. 9)

dnote est un chiffre quelconque de l'alphabet

> Solution n8 (exercice p. 9)

dnote est un chiffre quelconque de l'alphabet , et d un chiffre diffrent de 0

> Solution n9 (exercice p. 9)

42
 TD 9 - Gnration de code et optimisation.

Oui, il est reconnu par:

> Solution n10 (exercice p. 9)

Oui, il est reconnu par:

RQ: Cet automate reconnat galement le mot vide. Pour l'carter, il suffit de
considrer l'automate suivant:

> Solution n11 (exercice p. 9)

On cre un nouvel tat (tat poubelle). Puis on ajoute des flches de la forme
, pour chaque tat et chaque lettre qui ne sont pas tat de dpart et
tiquette d'une mme flche de .
De plus, on ajoute flches de la forme , pour chaque lettre a de .
Le nouvel automate est complet et reconnat le mme langage que .

43
 TD 9 - Gnration de code et optimisation.

> Solution n12 (exercice p. 10)

Oui.

> Solution n13 (exercice p. 10)

.

> Solution n14 (exercice p. 10)

> Solution n15 (exercice p. 10)

Oui. .

> Solution n16 (exercice p. 10)

.

> Solution n17 (exercice p. 10)

> Solution n18 (exercice p. 10)

44
 TD 9 - Gnration de code et optimisation.

> Solution n19 (exercice p. 11)

et sont rguliers, donc reconnaissables (Th. de Kleene) par
, et .
, avec:
.
.
.

.
Les automates et reconnaissant et sont respectivement:

est:

45
 TD 9 - Gnration de code et optimisation.

> Solution n20 (exercice p. 11)

est rgulier, donc reconnaissable (Th. De Kleene) par .
On considre l'automate dterministe associ , et
l'automate complet de (cf. exercice 1.5)
Soit .
On a: ,
L'automate reconnaissant est:

Il est dterministe. Son est:

Son complmentaire est:

> Solution n21 (exercice p. 11)

et sont donc rguliers, car reconnaissables (Th. de Kleene). Il
peuvent donc se rcrire en utilisant uniquement les trois oprations rgulires.

> Solution n22 (exercice p. 11)

46
 TD 9 - Gnration de code et optimisation.

> Solution n23 (exercice p. 13)

> Solution n24 (exercice p. 13)

Cette grammaire n'est pas LL(1) puisque la table d'analyse possde une cellule
contenant plus d'une rgle.

> Solution n25 (exercice p. 13)

Pour 5+3*2 ;

47
 TD 9 - Gnration de code et optimisation.

Pour 3 ;2/3*(1-3)

> Solution n26 (exercice p. 14)

La rgle montre que cette grammaire est rcursive gauche. La
variable est la fois en tte de rgle et du choix de cette rgle.
Elimination des rcursivits gauche :
De manire gnrale :
devient et

> Solution n27 (exercice p. 14)

On utilise la grammaire non rcursive gauche puisque aucune grammaire
rcursive gauche ne peut tre LL(1).

> Solution n28 (exercice p. 14)

On rcrit les rgles sous la forme :

48
 TD 9 - Gnration de code et optimisation.

Table d'analyse :

Analyse de

49
 TD 9 - Gnration de code et optimisation.

> Solution n29 (exercice p. 14)

Table d'analyse :

> Solution n30 (exercice p. 14)

On constate un conflit Premier, Suivant pour la variable la

50
 TD 9 - Gnration de code et optimisation.

rencontre du symbole . On privilgie la rgle 3 qui consiste produire

ce qui associe au le plus proche.

> Solution n31 (exercice p. 14)

Suivant l'analyse prcdente on devra la considrer comme :

et non comme :

Analyse :

> Solution n32 (exercice p. 15)

Items LR(0) et tats :

L'tat I10 prsente un conflit dcaler - rduire ; la grammaire n'est pas LR(0).

> Solution n33 (exercice p. 15)

51
 TD 9 - Gnration de code et optimisation.

En prsence du symbole ELSE, l'tat 10 prsente :

un dcalage vers l'tat ,
et une rduction par la rgle
car ELSE SUIVANTS(<else-inst>).
La grammaire n'est pas SLR(1).

> Solution n34 (exercice p. 15)

On choisira de privilgier le dcalage en prsence du symbole ELSE ce qui attache
le ELSE au THEN le plus rcent.

> Solution n35 (exercice p. 15)

Les tats ne prsentent pas de conflits. La grammaire est LR(1).

Aucun tat ne peut fusionner avec un autre. La grammaire est LALR(1).
On construit les items LR(0) pour l'tude SLR(1).

52
 TD 9 - Gnration de code et optimisation.

et
L'tat I4 prsente un conflit dcaler-rduire :
=I9 indique un dcalage vers I9 pour c.
A d . indique une rduction par la rgle A d pour chaque suivant de A et en
particulier c.
De mme l'tat I8 prsente le mme type de conflit.
La grammaire n'est pas SLR(1).

> Solution n36 (exercice p. 17)

fichier lex.l

fichier yacc.y

53
 TD 9 - Gnration de code et optimisation.

> Solution n37 (exercice p. 17)

fichier lex.l

fichier yacc.y

54
 TD 9 - Gnration de code et optimisation.

> Solution n38 (exercice p. 18)

> Solution n39 (exercice p. 18)

55
 TD 9 - Gnration de code et optimisation.

> Solution n40 (exercice p. 18)

> Solution n41 (exercice p. 19)

Table des symboles : on peut penser plusieurs fonctions d'accs et de maj de la
table des symboles

cherche un symbole et l'ajoute s'il n'est pas trouv

associe la valeur v au symbole, et marque le symbole comme tant initialis.

lit la valeur associe au symbole.

56
 TD 9 - Gnration de code et optimisation.

indique si la variable est dj initialise ou non.

> Solution n42 (exercice p. 19)

Actions smantiques

> Solution n43 (exercice p. 20)

Exemple de conflit shift/reduce: 1+2*3

> Solution n44 (exercice p. 20)

57
 TD 9 - Gnration de code et optimisation.

Exercice tir de "Lex & Yacc" (O'Reilly), pp 58-66.

58
 TD 9 - Gnration de code et optimisation.

> Solution n45 (exercice p. 20)

Le fait que les noms des variables sont de simples lettres nous permet de simplifier
la table des symboles. En effet, cette lettre permet d'indexer la table des symboles
(que l'on nomme "variables").

59
 TD 9 - Gnration de code et optimisation.

> Solution n46 (exercice p. 21)

Types d'implmentation : listes chaines, tableaux, table de hachages, arbres, etc.
La plus utilise: table de hachage.

60
 TD 9 - Gnration de code et optimisation.

> Solution n47 (exercice p. 21)

Avec une table de hachage:

61
 TD 9 - Gnration de code et optimisation.

> Solution n48 (exercice p. 22)

exo1.h

exo1.l

62
TD 9 - Gnration de code et optimisation.

63
 TD 9 - Gnration de code et optimisation.

exo1.y : Attention, j'ai simplifi le symbole d'affectation

de ":=" en le remplaant par un '=' : ainsi, l'oprateur
d'affectation devient un simple caractre retourn par
lex

64
TD 9 - Gnration de code et optimisation.

65
 TD 9 - Gnration de code et optimisation.

> Solution n49 (exercice p. 22)

exo2_1.h

exo2_1.l

66
 TD 9 - Gnration de code et optimisation.

exo2_1.y

67
 TD 9 - Gnration de code et optimisation.

68
 TD 9 - Gnration de code et optimisation.

> Solution n50 (exercice p. 22)

exo2_2.y : il faut crer une table des symboles pour les
fonctions

69
 TD 9 - Gnration de code et optimisation.

70
TD 9 - Gnration de code et optimisation.

71
 TD 9 - Gnration de code et optimisation.

72
TD 9 - Gnration de code et optimisation.

73
 TD 9 - Gnration de code et optimisation.

74
 TD 9 - Gnration de code et optimisation.

> Solution n51 (exercice p. 23)

Une interface de table de symboles possible:

> Solution n52 (exercice p. 24)

Actions smantiques:

75
 TD 9 - Gnration de code et optimisation.

> Solution n53 (exercice p. 24)

Oui, mais cela serait compliqu cause des dclarations multiples avec le mme
nom dans des blocs
imbriqus. Il faudrait inclure de nouvelles informations pour chaque symbole.
Mcanisme plus adapt : une table de symboles par bloc. Par exemple une pile de
tables de symboles.

76
 TD 9 - Gnration de code et optimisation.

Les autres actions smantiques sont identiques celles de l'exercice prcdent sauf
que l'on utilise la table courante top().

> Solution n54 (exercice p. 24)

Je suppose que les tables sont chanes afin de pouvoir les accder les unes aprs
les autres.
On change une action smantique:

77
 TD 9 - Gnration de code et optimisation.

> Solution n55 (exercice p. 25)

Du code assembleur n'est autre que du texte brut ayant une certaine structure.
Dans quoi allons nous stocker le code que l'on gnre ?
Des solutions videntes et simples : listes chanes, tableaux, etc.
D'autres structures de donnes sophistiques existent : graphe de flot de contrle,
etc.
En gnral, les compilateurs passent d'abord par une reprsentation intermdiaire
(un langage plus bas niveau, mais indpendant de la machine cible) avant de
gnrer un code assembleur dpendant de la machine cible.
Dans ce TD, nous court-circuitons la reprsentation intermdiaire. En d'autres
termes, nous gnrons directement du code assembleur.

> Solution n56 (exercice p. 25)

Les variables scalaires peuvent tre alloues avec plusieurs mthodes (au choix) :
sur la pile : variables locales. Une variable est substitue par un calcul
d'adresse %ebp(offset)
dans la mmoire (mais en dehors de la pile) : variables globales, externes,
etc. La variable devient une tiquette.
sur la tas (utilisant malloc). La variable devient un pointeur
dans des registres : pour peu de variables uniquement. Une variable devient
un nom de registre processeur.

> Solution n57 (exercice p. 26)

L'utilisation de la pile comme moyen d'valuer une expression arithmtique suggre
que cette expression est crite en notation post-fixe. Par exemple, serait
crite . Ceci se traduirait par :

Or, cela tombe bien, car une analyse LR avec yacc parcourt l'expression (la
grammaire) dans cette ordre post-fix. Ceci ne serait pas aussi ais avec une
analyse LL (descendante).

Hypothses
On suppose que chaque non-terminal a un attribut, que nous appelons "code", qui
est une liste linaire chane. Cette liste contient le code que l'on gnre au fur et
mesure (des chanes de caractres). Ainsi, j'utilise une notation oriente objet
comme ceci :
: insrer le texte assembleur "add x,y,z" dans la liste
(code).
: initialise la chane vide.
: initialisation avec une chane donne en paramtre.
On suppose que les fonctions insert et init admettent un nombre quelconque de
paramtres. De plus, nous supposons que le token "ident" contient un attribut
"nom". Pour simplifier notre exercice, nous supposons que les variables sont

78
 TD 9 - Gnration de code et optimisation.

alloues en mmoire. Ainsi, on peut y accder par leur nom (tiquette) en code
assembleur. Si ces variables taient alloues sur la pile, il faudrait accder la
table des symboles pour extraire le dplacement (offset) de la variable par rapport
la base de la pile %ebp. Mais, supposons que les variables sont en mmoire pour
simplifier !
Nous supposons galement que le token "const" a un attribut numrique appel
"valeur".
On suppose que l'on a dclar dans yacc une chane de caractre temporaire
"temp" utilise par les actions smantiques pour gnrer une instruction temporaire
courante.

Dans ce qui suit, le symbole d'affectation := est remplac par le token "affect".

Actions smantiques le code final est dans la liste

S.code

79
 TD 9 - Gnration de code et optimisation.

80
TD 9 - Gnration de code et optimisation.

81
 TD 9 - Gnration de code et optimisation.

> Solution n58 (exercice p. 26)

Pour comprendre, considrons l'arbre abstrait d'une expression arithmtique :

Par convention :
on stocke les rsultats des nuds intermdiaires dans le registre %eax.
Ainsi, le rsultat de l'addition ci-dessous est mis dans %eax.
on gnre le code de B, le fils droit. Le rsultat est dans %eax par
convention, puis on l'empile.
on gnre le code de A, le fils gauche. Le rsultat est dans %eax par
convention. Dpiler dans %ecx pour rcuprer le rsultat de B, effectuer le
calcul et stocker dans %eax.
Le parcours LR suit ce schma l. Il nous reste crire les actions smantiques.
Actions smantiques : le code final est dans la liste S.code

82
TD 9 - Gnration de code et optimisation.

83
 TD 9 - Gnration de code et optimisation.

84
 TD 9 - Gnration de code et optimisation.

> Solution n59 (exercice p. 26)

Le code gnr n'est pas excutable. Il faut l'assembler puis le linker.
Mais tel qu'il est, le programme assembleur n'est pas complet. Il manque le
prologue et l'pilogue comme ceci:

85
 TD 9 - Gnration de code et optimisation.

> Solution n60 (exercice p. 26)

Le passage par valeur implique de copier la chane sur la pile avant d'appeler printf.
Pour copier des donnes d'une zone mmoire une autre, on a le choix entre crire
une boucle qui copie les caractres un un, ou bien d'appeler la fonction strcpy de
la libc, ou bien utiliser une instruction assembleur MOVS du i386.
Dans cette solution, je vous propose d'utiliser strcpy.
Le code gnr pour l'appel de fonction strcpy(@src, @dest) doit d'abord empiler
l'adresse destination (adresse sommet de pile), ensuite l'adresse de la chaine
source.

> Solution n61 (exercice p. 26)

La convention du langage C suggre que les paramtres s'empilent dans le sens
inverse de leur apparition (de droite gauche). Par exemple, l'appel de fonction
toto(a,b,c,d) gnre un code qui empile les paramtres dans l'ordre d c b a. Les
paramtres peuvent tre des expressions, donc il faut d'abord gnrer le code qui

86
 TD 9 - Gnration de code et optimisation.

value ces expressions.

Aprs avoir empil les paramtres, puis avoir gnr le call, il ne faut pas oublier
de vider la pile.

Afin de connatre le nombre d'lments empils, les actions smantiques doivent

maintenir un compteur.
Soit L.NbArgs un attribut contenant le nombre de paramtres dans la liste L.

87
 TD 9 - Gnration de code et optimisation.

> Solution n62 (exercice p. 27)

machine registres

88
 TD 9 - Gnration de code et optimisation.

> Solution n63 (exercice p. 29)

arbre d'expression binaire

89
 TD 9 - Gnration de code et optimisation.

Algorithme : Sethi and Ullman 1970. Algorithme prouv

optimal.
Premire variante: calculer le nombre minimal de registres ncessaires
pour l'valuation d'un arbre abstrait.
L'algorithme calcule une tiquette/nombre L(u) pour chaque nud u : cette
tiquette correspond au nombre minimal de registres requis pour calculer
l'expression dont la racine est u. Le code pour un sous-arbre u est gnr de telle
sorte ce que le sous-arbre fils qui a la plus petite tiquette soit calcul le premier.
Si les deux sous arbres fils ont la mme tiquette, alors cela veut dire qu'il nous
faut un registre supplmentaire.
La consommation en registres chaque instruction dans le code gnr a la
proprit suivante :
Initialement, le besoin en registres est 0.
En avanant dans le code gnr instruction par instruction, si l'instruction
est un load, alors le besoin de registres est incrment de 1.
Si c'est une opration arithmtique, la consommation en registres est dcrmente
de 1 (puisqu'on a libre deux registres oprandes, et on consomme un registre
pour le rsultat).
Algorithme de Sethi Ullman pour la minimisation du nombre de registres
requis : Cas sans spill:

voici l'arbre tiquet (il requiert 3 registres au minimum)

90
 TD 9 - Gnration de code et optimisation.

Voici l'ordre optimal d'valuation de l'expression avec 3 registres (R1,R2,R3):

91
 TD 9 - Gnration de code et optimisation.

> Solution n64 (exercice p. 29)

nombre minimal de spill.
L'algorithme Sethi-Ullman prcdent n'introduit pas de spill. Dans cette partie, nous
donnons la deuxime variante de l'algorithme qui introduit un nombre minimal de
spill s'il n'y a pas assez de registres dans le processeur.
Supposons qu'il y a R registres disponibles.
L'algorithme de Sethi_Ullman avec spill commence d'abord par calculer les
tiquettes L(u) pour chaque nud u (voir algo prcdent).

92
 TD 9 - Gnration de code et optimisation.

Voici les sous arbres spilles dans l'arbre prcdent en supposant 2 registres
disponibles.

Ayant deux registres, on aura besoin de trois temporaires (rsultat optimal),

comme suit.

93
 TD 9 - Gnration de code et optimisation.

gestion de variables temporaires

Au fur et au mesure que l'on gnre du code, on aura besoin de variables
temporaires. On a le choix entre ajouter ces noms de variables dans la table des
symboles (temp1, temp2, ...), ou dclarer un grand tableau temp, que l'on y
accdera en l'indexant avec le numro du temporaire (temp[1], temp[2], etc.).
Aussi, on peut utiliser la pile de la machine. En effet, l'algo de spill prsent ci-
dessus est rcursif. Ainsi, au lieu de dclarer un temporaire pour spiller, on peut
empiler le rsultat intermdiaire dans la pile d'excution.

> Solution n65 (exercice p. 29)

calcul des constantes
On ajoute un attribut boolen is_constant a chaque non terminal de la grammaire.
Ce boolen vaut "vrai" si le non-termina reprsente une constante.
Si un non-terminal est une constante, nous n'avons pas besoin de gnrer son
code. Par ex, supposons que nous ayons l'arbre suivant :

94
 TD 9 - Gnration de code et optimisation.

supposons que E1 est une constante (vallant 73) et que E2 ne le soit pas. Ainsi, le
code gnr pour l'arbre ci-dessus est :
<E2.code>
add R <- E2.reg + 73 /* nous ne gnrons pas de code pour E1, il suffit de mettre
sa valeur numrique comme argument. Cette valeur est calcule par le compilateur
*/
Notre mthode pour implmenter une telle solution possde en deux tapes.
1. Une premire passe avec lex&yacc construit l'arbre abstrait (de bas en haut)
et permet de calculer les constantes pendant le parsing comme dans le cas
d'une mini-calculatrice (voir les prcdents TDs). Cette premire passe
calcule galement les tiquettes L vue dans les questions prcdentes.
2. Une deuxime passe applique l'algo de Sethi Ullman sur l'arbre abstrait de
haut en bas.

Passe 1
Les routines smantiques suivantes ne calculent que les valeurs des constantes et
les attributs is_constant. Elle n'incluent pas ( tord) les instructions montrant
comment construire l'arbre abstrait ni comment calculer les tiquettes L (vues dans
les questions prcdentes). La construction de l'arbre et le calcul des tiquettes L
sont laisss aux tudiants !
Les routines smantiques suivantes sont excutes lors du parsing (premire
passe) de l'expression. Je ne dtaille ici que le traitement fait pour valuer les
attributs is_constant et val

95
 TD 9 - Gnration de code et optimisation.

Passe 2
Cette passe applique l'algorithme rcursif de Sethi et Ullman, en parcourant l'arbre
de haut en bas (de la racine jusqu'aux feuilles).

96
 TD 9 - Gnration de code et optimisation.

> Solution n66 (exercice p. 30)

Actions smantiques
en pseudo code, pas en syntaxe yacc
On dclare un attribut nom_res pour chaque non-terminal X. Cet attribut contient le
nom de la variable contenant le rsultat du sous arbre dont X est la racine.
On suppose aussi un attribut Code pour chaque non terminal.

97
 TD 9 - Gnration de code et optimisation.

> Solution n67 (exercice p. 30)

Arbre de drivation avec code
a =3; /* code de I -> ident := CONST */
temp1 = a + 5;
temp2 = temp1 * 2; /* E.nom_res=temp2 */

> Solution n68 (exercice p. 30)

Traduction du for
for ident := E1 to E2 { S }
Je suppose que E a deux attributs:
E.code : contient le code valuant l'expression E
E.nom_res : contient le nom de la variable contenant le rsultat de l'expression
I a un attribut I.code.

98
 TD 9 - Gnration de code et optimisation.

On suppose que l'expression E2 de fin de boucle n'est value qu'une seule fois a
l'entre de la boucle. En d'autres termes, on interdit que :
ident le compteur de boucle soit modifi l'intrieur du corps de boucle
la valeur de l'expression E2 dfinissant l'indice maximal d'itrations n'est pas
modifie dans le corps de boucle. Ce n'est pas le cas du langage C par
exemple.
Le code gnrer dans notre cas est le suivant:

> Solution n69 (exercice p. 31)

Actions smantiques

> Solution n70 (exercice p. 31)

code gnr

99
 TD 9 - Gnration de code et optimisation.

> Solution n71 (exercice p. 34)

Exercice 1
Priorit et associativit des oprateurs logiques :
%left or
%left and
%nonassoc not
Et pour if-then-else /* le premier else rencontr se rattache au dernier if-then */
%nonassoc then
%nonassoc else
Il y a deux mthodes d'valuation d'une expression boolenne/logique :
ou bien on la calcule comme tant une expression arithmtique;
ou bien on utilise le flot de contrle du programme : le rsultat d'une
expression logique est alors deux tiquettes B.true et B.false.
C'est cette mthode qu'on va utiliser dans ce TD. Cette mthode s'appuie sur les
instructions de branchements du processeur.
B.true est un attribut qui contient l'tiquette de la prochaine instruction a excuter
si B est value vrai;
Rciproquement, B.false est l'attribut qui contient l'tiquette de la prochaine
instruction a excuter si B est value fausse;
On suppose ce qui suit :
le terminal op a un attribut "comp" qui sert dterminer le type d'oprateur
de comparaison utilis parmi {<, >, ==, !=}.
le non-terminal B possde les attributs suivants:
Deux tiquettes B.true et B.false.
Un code gnr B.code. Ce code gnre un branchement vers B.true si
l'expression est vraie, et vers B.false dans le cas contraire.
le non-terminal E a un attribut "code" qui contient le code valuant
l'expression, et un attribut "nom_res" qui contient le nom de la variable
contenant le rsultat de $E$.
On dispose d'une fonction nouvelle_etiquette() qui fournit un nouveau nom
d'tiquette non utilis chaque appel.
On suppose que la fonction "concat" permet de concatner des chanes de
caractres : elle est utilise pour la gnration de code (instructions).
Les routines smantiques ci-dessous ne font pas partie d'une traduction dirige par
la syntaxe S-attribue. En effet, l'attribut B.code est synthtis, par contre les
attributs B.true et B.false sont hrits.

Dans le cas d'un if-then-else, I.suiv est l'etiquette de l'instruction juste apres le if-
then-else.

100
 TD 9 - Gnration de code et optimisation.

Les rgles smantiques suivantes ne sont gure destines une traduction diriges
par la syntaxe S-attribue (yacc). Ceci, car elles calculent des attributs hrits,
exigeant un parcours de l'arbre syntaxique de haut en bas, et non pas de bas en
haut comme le fait yacc.

> Solution n72 (exercice p. 34)

gnration de B.code

101
 TD 9 - Gnration de code et optimisation.

102
 TD 9 - Gnration de code et optimisation.

> Solution n73 (exercice p. 34)

Avec les actions smantiques prcdentes, l'expression a<b ou c<d et e<f se
traduit en

103
 TD 9 - Gnration de code et optimisation.

On pourrait faire mieux : en effet, si on laisse l'excution du code gnr suivre son
cours, alors l'expression prcdente se rduit en :
exemple : a<b se traduit en

Cette mthode de gnration de code pour une expression logique B nous oblige
dornavant placer le code de la branche vrai juste aprs le code qui value B.
Avec la mthode des branchements standards (voir question prcdente), on avait
deux tiquettes (vrai et faux), on pouvait placer les deux branches d'un if dans
n'importe quel ordre. Or avec la mthode actuelle, la branche vraie doit apparatre
juste aprs B.code.
Les autres rgles smantiques peuvent rester inchanges. Nanmoins, elles
gnrent des tiquettes caduques (tiquettes des branches vrai).

> Solution n74 (exercice p. 34)

code trois adresses

104
 TD 9 - Gnration de code et optimisation.

Bloc de base et CFG : voir rponse de la question suivante

> Solution n75 (exercice p. 34)

Bloc de base et CFG

> Solution n76 (exercice p. 35)

limination des sous-expressions communes (common
sub-expression elimination)

> Solution n77 (exercice p. 35)

limination de code mort (dead code elimination)
Le code mort est tout bout de programme qui ne sert a rien! En d'autres termes, il
ne contribue pas au rsultat final calcul par le programme. Deux cas de code
mort:
1. les blocs de base inaccessibles dans le CFG : ce sont les blocs de base vers
lesquels on ne se branche jamais. Il est clair qu'on peut les enlever non pas
pour acclrer le programme (puisque de toute faon, ils ne sont pas

105
 TD 9 - Gnration de code et optimisation.

excuts), mais pour rduire la taille de code gnr.

2. les instructions produisant des rsultats intermdiaires qui ne contribuent
pas aux rsultats finaux du programme peuvent tre limines. Les
informations sur les flots de donnes nous renseignent ce sujet.
Dans notre cas, si aucune des variables calcules par le programme n'est ni lue ni
affiche ni produite en sortie, on peut liminer tout ce code ! Croyez moi, les
compilateurs ne se gnent pas pour le faire.
Supposons que a et i sont des variables lues aprs la boucle, mais pas les variables
c et tmp.
Donc, en faisant une premire tape d'limination de code mort, on obtient :
B2 :
a=i+1;
b=a;
i=a
Lors d'une deuxime etape, on remarque que l'instruction "b=a" peut aussi tre
limine.

106