Documente Academic
Documente Profesional
Documente Cultură
Corriges du TD 5
E. Lozes
Corrig
e de lexercice 1
Corrig
e de lexercice 2
1.
code
donnees statiques
pile de controle
tas
2. ...
3. En gros (mais ce nest quun exemple) : analyse lexicale (liste de token), analyse syntaxique (arbre de
syntaxe abstraite), analyse semantique (arbre semantique), linearisation (code intermediaire), selection
dinstructions (expressions courtes),traduction des appels de fonctions, allocation de registres , puis
resolution des addresses de saut (code machine). Bien s
ur, on a des optimisations possibles `a differents
niveaux : exemples, de la source vers le code final : recursivite terminale, sous-expressions communes,
propagation de constantes, extraction dinvariants de boucles, utilisation fine des registres, rapprochement de blocs...
4. beaucoup de choses `
a verifier suivant les possibilites du langage, mais en gros on sauve les registres
utiles pour quand on revient (certains peuvent etre sauves automatiquement par le microprocesseur),
on met les param`etres l`
a o`
u il faut, et on fait un call, i.e. un saut apr`es avoir empile ladresse de retour.
Corrig
e de lexercice 3
1. Une grammaire hors contexte est donnee par un ensemble fini T de terminaux, un ensemble fini N de
non-terminaux, un non-terminal initial S, et un ensemble fini de r`egles de production R N (N T ) .
Un arbre de derivation est un arbre dont les nuds intermediaires sont etiquettes par des r`egles r R,
avec les contraintes suivantes :
la racine est etiquettee par une r`egle S
si un noeud est etiquette X 1 ..k , il a n fils n1 ..nk . De plus, ni est feuille si i est un terminal,
et ni est etiquette par Y 0 si i est un non-terminal Y .
Le langage reconnu par la grammaire est celui des mots de feuilles de lensemble des arbres de derivation,
elle est non ambigue si tout mot admet au plus un arbre de derivation dont il est le mot de feuille.
En compilation, on ne sinteresse pas tant au langage reconnu par la grammaire qu`a la reconstruction dun arbre de derivation pour un mot donne, afin de construire larbre de syntaxe abstraite du
programme. Il est donc essentiel de manipuler des grammaires non ambigues.
2. Lexpression ambig
ue est
if x = 0 then if y = 0 then do a else do b.
1
id
E T E0
(
E T E0
E 0 +T E 0
T FT
E0 E0
T FT
T0
T 0 F T 0
F id
T0
T0
F (E)
Corrig
e de lexercice 4
1. On remarque que
X 1 | .. | n | 1 | .. |m
0
FIRST(u
..u
)
ssi
u
=
u
et
FIRST(un ).
1
n
k
n
S n
FIRST(X) =
X FIRST()
1`
a commutation de contraction concurrentes pr`
es, pour rester simple on dira quon ne consid`
ere que des suites 1 .. n
o`
u les r
edex se d
eplacent de gauche `
a droite.
et en realite FIRST est la plus petite fonction satisfaisant ces equations. On calcule donc FIRST par
lalgorithme de point fixe classique :
entree : une grammaire G quelconque.
FIRST(a) {a} pour tout a.
FIRST(X) {} pour tout X .
repeter
- FIRST0 FIRST
S
- FIRST(X) FIRST0 (X) Xu1 ..un FIRST0 (u1 ) .. FIRST0 (uk ) {}
(on ajoute quand il faut)
tant que FIRST 6= FIRST0
sortie : FIRST(a), FIRST(X) (et par consequent FIRST())
qui termine, puisque FIRST grossit et quil existe un nombre fini FIRST possibles. On peut de meme
definir FOLLOW comme la plus petite solution des equations suivantes :
$ FOLLOW(S)
si X Y , FOLLOW(Y ) FIRST() {}.
si X Y , FOLLOW(X) FOLLOW(Y ).
si X Y et FIRST(), FOLLOW(X) FOLLOW(Y ).
4. Une table de prediction LL(k) est une table M [X, a1 ..ak ] telle que
M[X, a1 ..ak ] = { X : a1 ..ak }
On peut etendre facilement les algorithmes precedents `a ces tables plus generales. Pour le cas de la
grammaire consideree, on nest pas LL(1) parce que M[stmt, id] contient au moins les trois r`egles ecrites
pour stmt, mais en revanche M[stmt, id id] = {stmt type id}, etc. et la grammaire est LL(2).
Corrig
e de lexercice 5
1. On a le graphe de flot suivant :
2. si il y a une seule definition x = c possible pour un point de programme y = ...x..., on peut propager
la constante c et reecrire y = ...c...
3. in(B) est lensemble des definitions qui arrivent `a lentree de B, out(B) lensemble de celles qui en
sortent, gen(B) celles qui y sont generees, kill(B) celles qui sont masquees par celles de gen(B).
4. On surapproxime pour tous, sauf pour cdkill qui sous approxime. Ainsi pour R = R1 + R2 (execution
concurrente de R1 ou R2 ), on a in(R) = in(R1 ) = in(R1 ), out(R) = out(R1 ) out(R2 ), gen(R) =
gen(R1 ) gen(R2 ), et kill(R) = kill(R1 ) kill(R2 ).
5. Le syst`eme dequation peut secrire (out, in)S= F(out, in), o`
u F est la fonction croissante (out)(B) =
gen(B) (in(B) kill(B)), et (in)(B) = B 0 B out(B 0 ), et la solution recherchee est le plus petit
point fixe de F, donc la valeur stationnaire de la suite x0 = et xn+1 = F(xn ) (algo classique
de construction de plus petit point fixe). Par exemple, si lon developpe les equations de flot pour
lexemple precedent sur out(B2 ), on trouve out(B2 ) = {d3 , d4 , d5 , d6 } (out(B2 ) {d1 , d2 , d7 }, soit
out(B2 ) = {d3 , d4 , d5 , d6 }.
6. in(B) = use(B)(out(B)def (B)) o`
u use(B) est lensemble des variables lues avant detre ecrites, et
def (B) lensemble des variables ecrites avant detre lues. Quand on connait en chaque point lensemble
des variables vivantes, on peut calculer le graphe dinterference : deux variables interf`erent en un
meme point de programme si elles sont toutes deux vivantes. Colorier ce graphe = allouer les registres,
probl`eme NP-complet, il existe des heuristiques, par ex : en cas dimpossibilite on retire la variable
utilisee la moins recemment, on dit quelle part en memoire et on reessaie.