10 octobre 2007Cours de compilation 6 - Intranet1 Cours de compilation Analyse sémantique...

10 octobre 2007 Cours de compilation 6 - Intranet 1

Cours de compilationCours de compilation

Analyse sémantiqueAnalyse sémantique

Environnement d’exécutionEnvironnement d’exécution


Les grandes lignes du coursLes grandes lignes du cours

•Définitions de baseDéfinitions de base•Composition de compilateursComposition de compilateurs•L’environnement d’un compilateurL’environnement d’un compilateur•Evaluation partielle et compilationEvaluation partielle et compilation•Analyses lexicales et syntaxiquesAnalyses lexicales et syntaxiques•Techniques d’analyse descendantesTechniques d’analyse descendantes•Techniques d’analyse ascendantesTechniques d’analyse ascendantes•YACCYACC•Analyse sémantiqueAnalyse sémantique•Environnement d’exécutionEnvironnement d’exécution•Génération de codeGénération de code•Optimisation de codeOptimisation de code


L ‘ A N A L Y S EL ‘ A N A L Y S E

S E M A N T I Q U ES E M A N T I Q U E


V E R I F I C A T I O NV E R I F I C A T I O N

D E SD E S

T Y P E ST Y P E S


L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------

----• Elle est faite en même temps que les Elle est faite en même temps que les

analyses lexicales et syntaxiques !analyses lexicales et syntaxiques !





• Il faut donc que tout soit déclaré avant Il faut donc que tout soit déclaré avant d’être utilisé :d’être utilisé :

– Déclaration avant l’utilisation !Déclaration avant l’utilisation !





• Il faut donc que tout soit déclaré avant Il faut donc que tout soit déclaré avant d’être utilisé :d’être utilisé :

– Déclaration avant l’utilisation !Déclaration avant l’utilisation !

• Les seuls problèmes :Les seuls problèmes :

– Les procédures mutuellement récursives !Les procédures mutuellement récursives !

– Les types récursifs !Les types récursifs !



----

proc f ( . . . )proc f ( . . . )

{{

gg ( . . . ); ( . . . );

}}

proc g ( . . . )proc g ( . . . )

{{

ff ( . . . ); ( . . . );

}}



----proc g ( . . . ) ;proc g ( . . . ) ;

proc f ( . . . )proc f ( . . . )

{{

gg ( . . . ); ( . . . );

}}

proc g ( . . . )proc g ( . . . )

{{

ff ( . . . ); ( . . . );

}}

Il faut unIl faut unprototypeprototypepour g ! ! !pour g ! ! !



----proc g ( . . . ) ;proc g ( . . . ) ;

proc f ( . . . ) ;proc f ( . . . ) ;

proc f ( . . . )proc f ( . . . )

{{

gg ( . . . ); ( . . . );

}}

proc g ( . . . )proc g ( . . . )

{{

ff ( . . . ); ( . . . );

}}

Il faut unIl faut unprototypeprototypepour g ! ! !pour g ! ! !

Nous donnonsNous donnonstous lestous lesprototypes ! ! !prototypes ! ! !



----• Les types récursifs en Pascal :Les types récursifs en Pascal :

type ptr_arbre = ^arbre ;type ptr_arbre = ^arbre ;

arbre = recordarbre = record

champ : ptr_arbrechamp : ptr_arbre

end ;end ;




type ptr_arbre = type ptr_arbre = ^arbre^arbre ; ;

arbrearbre = record = record


end ;end ;

Une référenceUne référenceen avant (la seuleen avant (la seuletolérée en Pascal).tolérée en Pascal).







end ;end ;

• Les types récursifs en C :Les types récursifs en C :

struct moi_memestruct moi_meme

{{

struct moi_meme *self ; struct moi_meme *self ;

}}

*ptr_structure ;*ptr_structure ;








end ;end ;

• Les types récursifs en C :Les types récursifs en C :

struct struct moi_mememoi_meme

{{

struct struct moi_mememoi_meme *self ; *self ;

}}

*ptr_structure ;*ptr_structure ;


Nous introduisonsNous introduisonsun nom auxiliaire !un nom auxiliaire !


Vérification des typesVérification des types----------------------------------------------------------------------------------------------------------------------------

----• Il s’agit de vérifier l’adéquation entre :Il s’agit de vérifier l’adéquation entre :

– Les opérateurs et leurs arguments :Les opérateurs et leurs arguments :

#define ab 5 . . . int x . . . x + ( 3 * ab ) #define ab 5 . . . int x . . . x + ( 3 * ab )






– Les membres gauche et droits d’une affectation :Les membres gauche et droits d’une affectation :

float x ; . . . x = 3.14 ;float x ; . . . x = 3.14 ;






– Les membres gauche et droits d’une affectation :Les membres gauche et droits d’une affectation :

float x ; . . . x = 3.14 ;float x ; . . . x = 3.14 ;

– Les déclarations et appels des procédures et Les déclarations et appels des procédures et fonctions :fonctions :

float f ( int x , float y ) ;float f ( int x , float y ) ;

. . . f ( 5 , 3.14 ) . . .. . . f ( 5 , 3.14 ) . . .


Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------

----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !




– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !

– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !






int *p;int *p;

float q;float q;

pp

derefderef

++

11

qq

**






int *p;int *p;

float q;float q;

pp

derefderef

++

11

qq

**

int*int*






int *p;int *p;

float q;float q;

pp

derefderef

++

11

qq

**

int*int*

intint






int *p;int *p;

float q;float q;

pp

derefderef

++

11

qq

**

int*int*

intint intint






int *p;int *p;

float q;float q;

pp

derefderef

+_int+_int

11

qq

**

int*int*

intint intint

intint






int *p;int *p;

float q;float q;

pp

derefderef

+_int+_int

11

qq

**

int*int*

intint intint

intint floatfloat






int *p;int *p;

float q;float q;

pp

derefderef

+_int+_int

11

qq

*_float*_float

int*int*

intint intint

intint floatfloat

floatfloat






int *p;int *p;

float q;float q;

pp

derefderef

+_int+_int

11

qq

int_2_floatint_2_float

int*int*

intint intint

intint floatfloat

Au passage,Au passage,nous explicitonsnous explicitonsla conversionla conversionentre types !entre types !

*_float*_float floatfloat



----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,

introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !





#define ab 2#define ab 2

int x;int x;

22

++

11

xx

**






int x;int x;

22

++

11

xx

**

intint intint

intint intint

intint






int x;int x;

22

++

11

xx

**

val = 2 &val = 2 & int int intint

intint intint

intint






int x;int x;

22

++

11

xx

**

val = 2 &val = 2 & int int int int & val = 1& val = 1

intint intint

intint






int x;int x;

22

++

11

xx

**


val = 3 &val = 3 & int int intint

intint






int x;int x;

22

++

11

xx

**


val = 3 &val = 3 & int int int int & val = ?& val = ?

intint






int x;int x;

22

++

11

xx

**


val = 3 &val = 3 & int int int int & val = ?& val = ?

int int & val = ?& val = ?



----• On vérifie égalementOn vérifie également

– que les tests des if , while , . . . sont des que les tests des if , while , . . . sont des booléens, sauf en C !booléens, sauf en C !





– que les tableaux ne débordent pas, sauf en C !que les tableaux ne débordent pas, sauf en C !






var A = array [ 17 . . 39 ] of . . .var A = array [ 17 . . 39 ] of . . .






var A = array [ 17 . . 39 ] of . . .var A = array [ 17 . . 39 ] of . . .

A [ i ]A [ i ] devientdevient

testtest

i >= 17i >= 17 ERREURERREURtesttest

i <= 39i <= 39 ERREURERREURA [ i ]A [ i ]


V I S I B I L I T E V I S I B I L I T E L E X I C A L EL E X I C A L E

E TE T

T A B L E ST A B L E SD E SD E S

S Y M B O L E SS Y M B O L E S


La table des symbolesLa table des symboles----------------------------------------------------------------------------------------------------------------------------

----• Concernant les variablesConcernant les variables

– nous construisons la « table des symboles »,nous construisons la « table des symboles »,– nous respectons la « visibilité lexicale »,nous respectons la « visibilité lexicale »,– nous déduisons la « durée de vie » des variables !nous déduisons la « durée de vie » des variables !





• La table des symboles collecte pour chaque variableLa table des symboles collecte pour chaque variable

– son type, ses éventuels paramètres, des son type, ses éventuels paramètres, des attributs, . . .attributs, . . .

– prend garde aux homonymes avec des numéros prend garde aux homonymes avec des numéros uniques.uniques.





• La table des symboles collecte pour chaque variableLa table des symboles collecte pour chaque variable

– son type, ses éventuels paramètres, des son type, ses éventuels paramètres, des attributs, . . .attributs, . . .

– prend garde aux homonymes avec des numéros prend garde aux homonymes avec des numéros uniques.uniques.11

22

33

......

xx

ff

xx

......

intint

int->intint->int

floatfloat

......

//

inlineinline

doubledouble

......


La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------

---- Qui référence quoi ?Qui référence quoi ?




int x ;int x ;

int y ;int y ;

int f ( float z )int f ( float z )

{ int x ;{ int x ;

int t ;int t ;

. . . x . . . y . . . z . . . t . . .. . . x . . . y . . . z . . . t . . .

}}




int x ;int x ;

int y ;int y ;


{ { int x ;int x ;

int t ;int t ;

. . . . . . xx . . . y . . . z . . . t . . . . . . y . . . z . . . t . . .

}}




int x ;int x ;

int y ;int y ;


{ { int x ;int x ;

int t ;int t ;

. . . . . . xx . . . y . . . z . . . t . . . . . . y . . . z . . . t . . .

}}

Cette occurrence de x est masquéeCette occurrence de x est masquéepar la redéfinition locale !par la redéfinition locale !




int x ;int x ;

int y ;int y ;


{ { int x ;int x ;

int t ;int t ;

. . . . . . xx . . . . . . yy . . . z . . . t . . . . . . z . . . t . . .

}}





int x ;int x ;

int y ;int y ;


{ { int x ;int x ;

int t ;int t ;

. . . . . . xx . . . . . . yy . . . z . . . t . . . . . . z . . . t . . .

}}


La variable y est dite « libre » dans f !La variable y est dite « libre » dans f !(variable globale)(variable globale)




int x ;int x ;

int y ;int y ;

int f ( int f ( float zfloat z ) )

{ { int x ;int x ;

int t ;int t ;

. . . . . . xx . . . . . . yy . . . . . . zz . . . t . . . . . . t . . .

}}






int x ;int x ;

int y ;int y ;


{ { int x ;int x ;

int t ;int t ;

. . . . . . xx . . . . . . yy . . . . . . zz . . . . . . tt . . . . . .

}}






int x ;int x ;

int y ;int y ;


{ { int x ;int x ;

int t ;int t ;

. . . . . . xx . . . . . . yy . . . . . . zz . . . . . . tt . . . . . .

}}


x , t et z sont des variablesx , t et z sont des variablesdites « liées » dans f !dites « liées » dans f !

(variables locales)(variables locales)




---- Un bloc !Un bloc !




{ { Les variables localesLes variables locales

. . .. . .

. . .. . .

. . .. . .

. . .. . .

}}




{ { Les variables locales Les variables locales sont crééessont créées

. . .. . .

. . .. . .

. . .. . .

. . .. . .

}}

EntréeEntrée





. . .. . .

. . .. . .

. . .. . .

. . .. . .

}}

EntréeEntrée

ExécutionExécution





. . .. . .

. . .. . .

. . .. . .

. . .. . .

} } Les variables locales sont détruitesLes variables locales sont détruites

EntréeEntrée


SortieSortie





. . .. . .

. . .. . .

. . .. . .

. . .. . .

} } Les variables locales sont détruitesLes variables locales sont détruites

La durée de vie est « statique » ou La durée de vie est « statique » ou « lexicale » ! ! !« lexicale » ! ! !

EntréeEntrée


SortieSortie



---- Organisation relative des blocs !Organisation relative des blocs !




Blocs disjoints Blocs disjoints




Blocs disjoints Blocs Blocs disjoints Blocs englobantsenglobants




{ . . . } { . . . } { { . . . } { . . . } { . . . } { { . . . } }}

Blocs disjoints Blocs englobantsBlocs disjoints Blocs englobants




Visibilité ! ! !Visibilité ! ! !







ICIICI






ICIICI

ouioui

nonnon






ICIICI

ouioui

nonnon

ICIICI






ICIICI

ouioui

nonnon

ICIICI

ouioui

ouioui



---- Règles de visibilité :Règles de visibilité :




- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!





- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !






ICIICI






ICIICI

ouioui

ouioui

ouioui






ICIICI

ouioui

ouioui

ouioui

nonnonnonnon

nonnon






int x ;int x ;

int x ; float y ;int x ; float y ;

float z ;float z ;






int x ;int x ;


float z ;float z ;

Table desTable dessymbolessymboleschaînée :chaînée :

float yfloat y

int xint x

//

int xint x

float zfloat z






int x ;int x ;


float z ;float z ;

Table desTable dessymbolessymboleschaînée :chaînée :

float yfloat y

int xint x

//

int xint x

float zfloat z

L’occurrence externeL’occurrence externede x est masquée ! !de x est masquée ! !



---- Discipline d’exécution :Discipline d’exécution :




- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !





- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !






ICIICI






ICIICI

int x ;int x ;


float z ;float z ;

Toutes les variables ontToutes les variables ontpu être initialisées !pu être initialisées !






ICIICI

int x ;int x ;


float z ;float z ;








ICIICI

int x ;int x ;


float z ;float z ;



ENTREEENTREE






ICIICI

int x ;int x ;


float z ;float z ;



ENTREEENTREE

SORTIESORTIE



---- Discipline d’exécution des GOTO :Discipline d’exécution des GOTO :




- Un GOTO est un saut vers une instruction (cf. - Un GOTO est un saut vers une instruction (cf. assembleur) !assembleur) !





- Les GOTO ne peuvent pas être quelconques !- Les GOTO ne peuvent pas être quelconques !






GOTOGOTO

Les variables ne sont pas initialisées !Les variables ne sont pas initialisées !

ICIICI






GOTOGOTO

Les variables ne sont pas initialisées !Les variables ne sont pas initialisées !

ICIICI

GOTOGOTO



---- Conséquences :Conséquences :




Le dernier bloc dans lequel nous sommes Le dernier bloc dans lequel nous sommes entrésentrés

sera le premier que nous allons quitter !sera le premier que nous allons quitter !






Tout ce qui est lexicalement visible depuis unTout ce qui est lexicalement visible depuis un

endroit a pu être initialisé au paravent !endroit a pu être initialisé au paravent !


L AL A

V I S I B I L I T EV I S I B I L I T E

D Y N A M I Q U ED Y N A M I Q U E


La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------

----Toutes les variables de la pile sont Toutes les variables de la pile sont

visibles (en fait leurs dernières visibles (en fait leurs dernières occurrences) ! ! !occurrences) ! ! !



----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles

(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !

void f ( x )void f ( x )

{{

g ( 3 ) ;g ( 3 ) ;

}}

void g ( y )void g ( y )

{{

......

} } ICIICI






{{

g ( 3 ) ;g ( 3 ) ;

}}


{{

......

} } ICIICI

En visibilité lexicale,En visibilité lexicale,quand nous sommes dansquand nous sommes dansg , nous ne voyons pas leg , nous ne voyons pas le

paramètre formel x de f !paramètre formel x de f !






{{

g ( 3 ) ;g ( 3 ) ;

}}


{{

......

} } ICIICI

PILEPILE






{{

g ( 3 ) ;g ( 3 ) ;

}}


{{

......

} } ICIICI

PILEPILEL’appel initialL’appel initialest f ( 5 ) ! ! !est f ( 5 ) ! ! !






{{

g ( 3 ) ;g ( 3 ) ;

}}


{{

......

} } ICIICI


f ( 5 )f ( 5 )

x = 5x = 5

y = 3y = 3






{{

g ( 3 ) ;g ( 3 ) ;

}}


{{

......

} } ICIICI

PILEPILEL’appel initialL’appel initialest g ( 4 ) ! ! !est g ( 4 ) ! ! !






{{

g ( 3 ) ;g ( 3 ) ;

}}


{{

......

} } ICIICI


y = 4y = 4g ( 4 )g ( 4 )


L E SL E S

D U R E E SD U R E E S

D ED E

V I EV I E


Les durées de vie des variablesLes durées de vie des variables----------------------------------------------------------------------------------------------------------------------------

----• Les variables déclarées ont une durée de vie Les variables déclarées ont une durée de vie

« statique » !« statique » !

– Elles sont créées à l’entrée dans le bloc !Elles sont créées à l’entrée dans le bloc !– Elles sont détruites à la sortie du bloc !Elles sont détruites à la sortie du bloc !






• Les valeurs allouées ont une durée de vie Les valeurs allouées ont une durée de vie « dynamique » !« dynamique » !

– Elles sont créées par malloc , . . . !Elles sont créées par malloc , . . . !– Elles sont détruites explicitement !Elles sont détruites explicitement !






• Les valeurs allouées ont une durée de vie Les valeurs allouées ont une durée de vie « dynamique » !« dynamique » !







• Les valeurs allouées ont une durée de vie « dynamique » !Les valeurs allouées ont une durée de vie « dynamique » !


• Attention : Attention : { . . . *p ;{ . . . *p ;

p = malloc ( . . . ) ;p = malloc ( . . . ) ;

} } p sera détruite, mais pas la donnée allouée !p sera détruite, mais pas la donnée allouée !


E N V I R O N N E M E N TE N V I R O N N E M E N T

D ‘ E X E C U T I O ND ‘ E X E C U T I O N


L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------

----



----

• Dans la pile nous gérons :Dans la pile nous gérons :

– Les imbrications des opérations (adresses de Les imbrications des opérations (adresses de retour) !retour) !



----



– Les variables du programme !Les variables du programme !



----




– Les variables temporaires du compilateur !Les variables temporaires du compilateur !



----




– Les variables temporaires du compilateur !Les variables temporaires du compilateur !

– Les paramètres des fonctions et procédures !Les paramètres des fonctions et procédures !



----• Pour les fonctions et procédures nous distinguons Pour les fonctions et procédures nous distinguons

entreentre

leurs déclarations et leurs activations !leurs déclarations et leurs activations !




entreentre


• SoientSoient proc f (... ) { ... f ... g ... }proc f (... ) { ... f ... g ... }

proc g (... ) { ... f ... g ... }proc g (... ) { ... f ... g ... }




entreentre



proc g (... ) { ... f ... g ... }proc g (... ) { ... f ... g ... }

• Un « arbre d’activations » possible :Un « arbre d’activations » possible :ff

gg

ff

gg

ff

gg

ff




entreentre



proc g (... ) { ... f ... g ... }proc g (... ) { ... f ... g ... }

• Un « arbre d’activations » possible :Un « arbre d’activations » possible :ff

gg

ff

gg

ff

gg

ff

Le parcours préfixe de l’arbreLe parcours préfixe de l’arbred’activation donne la séquenced’activation donne la séquence

des appels et retours de fonctions !des appels et retours de fonctions !



----main ()main ()var_mainvar_main

beginbeginendend




beginbeginendend

f ( … )f ( … )var_fvar_f

beginbeginendend




beginbeginendend


beginbeginendend

g (…)g (…)var_gvar_gbeginbeginendend




beginbeginendend


beginbeginendend


h (…)h (…)var_hvar_hbeginbeginendend




beginbeginendend


beginbeginendend



mainmain

ff

ff

gg

hh

gg




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg

mainmain




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg

mainmain

ff

ff

gg

hh

gg




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg

Nous n’avons pas envieNous n’avons pas envied’inspecter toute la piled’inspecter toute la pileà chaque fois que nousà chaque fois que nousavons besoin de la valeuravons besoin de la valeurd’une variable !d’une variable !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUI, le bloc courant !OUI, le bloc courant !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NON, à cause de la lexicalité !NON, à cause de la lexicalité !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NONNON

NON, pas la dernière activation !NON, pas la dernière activation !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NONNON

NONNON

OUI, dernière activation d’un blocOUI, dernière activation d’un blocenglobant !englobant !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NONNON

NONNON

OUIOUI

NON, c’est bien un bloc englobant,NON, c’est bien un bloc englobant,mais pas la dernière activation !mais pas la dernière activation !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NONNON

NONNON

OUIOUI

NONNON

OUI, l’unique activation du blocOUI, l’unique activation du blocprincipal !principal !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NONNON

NONNON

OUIOUI

NONNON

OUIOUI

En résumé :En résumé :




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NONNON

NONNON

OUIOUI

NONNON

OUIOUI


Nous voyons lesNous voyons lesdernières activationsdernières activationsdu bloc courant etdu bloc courant etde ses blocsde ses blocsenglobants !englobants !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NONNON

NONNON

OUIOUI

NONNON

OUIOUI






beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg OUIOUI

NONNON

NONNON

OUIOUI

NONNON

OUIOUI



Leur nombre dépendLeur nombre dépenddu texte dudu texte duprogramme !programme !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg

L’adresseurL’adresseur

Nous créons une mini-pileNous créons une mini-pileappelée « adresseur »appelée « adresseur »ou « display » !ou « display » !




beginbeginendend


beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg


L’adresseurL’adresseurrepère lesrepère lesblocs actifs.blocs actifs.





beginbeginendend

f ( f ( xx ) )var_fvar_f

beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg



xx

xx

Trouver leTrouver leparamètre xparamètre xde f . . .de f . . .





beginbeginendend

f ( f ( xx ) )var_fvar_f

beginbeginendend



La pileLa pile

mainmain

ff

ff

gg

hh

gg




xx

xx

Trouver leTrouver leparamètre xparamètre xde f de f est simple.est simple.

Niveau de fNiveau de f


G E S T I O NG E S T I O N

D ED E

L ‘ A D R E S S E U RL ‘ A D R E S S E U R


La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------

----•Soit f une fonction de niveau N qui appelle Soit f une fonction de niveau N qui appelle g !g !

•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :





( 1 ) g est de niveau N+1 :( 1 ) g est de niveau N+1 :

-- Nous rajoutons une entrée à Nous rajoutons une entrée à l’adresseur ! ! !l’adresseur ! ! !







11

NN

La pileLa pile

. . .. . .







11

NN

La pileLa pile

gg

. . .. . .

N+1N+1



----•Soit f une fonction de niveau N qui appelle g !Soit f une fonction de niveau N qui appelle g !


( 2 ) g est de niveau N :( 2 ) g est de niveau N :






-- Si g = f , la nouvelle activation invalide Si g = f , la nouvelle activation invalide l’ancienne !l’ancienne ! -- Si g <> f , alors f devient invisible par Si g <> f , alors f devient invisible par lexicalité !lexicalité !






-- Si g = f , la nouvelle activation invalide Si g = f , la nouvelle activation invalide l’ancienne !l’ancienne ! -- Si g <> f , alors f devient invisible par Si g <> f , alors f devient invisible par lexicalité !lexicalité !

Dans tous les cas :Dans tous les cas :

-- Nous sauvons l’entrée N de l’adresseur ! Nous sauvons l’entrée N de l’adresseur ! -- Nous y installons le pointeur vers le bloc g ! Nous y installons le pointeur vers le bloc g ! -- A la sortie, nous restaurons l’entrée sauvée ! A la sortie, nous restaurons l’entrée sauvée !





( 3 ) g est de niveau N - k :( 3 ) g est de niveau N - k :






Si k = 0 , nous retrouvons le cas 2 !Si k = 0 , nous retrouvons le cas 2 !






Si k = 0 , nous retrouvons le cas 2 !Si k = 0 , nous retrouvons le cas 2 !

Donc :Donc :

-- Nous sauvons les entrées N - k , . . . , N ! Nous sauvons les entrées N - k , . . . , N ! -- Nous y installons le pointeur vers le bloc g ! Nous y installons le pointeur vers le bloc g ! -- A la sortie, nous restaurons les entrées A la sortie, nous restaurons les entrées sauvées !sauvées !



----•Nous avons donc les quatre étapes suivantes :Nous avons donc les quatre étapes suivantes :

( 1 )( 1 )

11

N-k-1N-k-1

NN ff




( 1 )( 1 )

11

N-k-1N-k-1

NN ff( 2 )( 2 )

11

N-k-1N-k-1

Sauvegardées ! ! !Sauvegardées ! ! !




( 1 )( 1 )

11

N-k-1N-k-1

NN ff( 2 )( 2 )

11

N-k-1N-k-1


( 3 )( 3 )

11

N-k-1N-k-1

N-kN-k gg




( 1 )( 1 )

11

N-k-1N-k-1

NN ff( 2 )( 2 )

11

N-k-1N-k-1


( 3 )( 3 )

11

N-k-1N-k-1

N-kN-k gg ( 4 )( 4 )La restauration desLa restauration desentrées sauvegardéesentrées sauvegardéesnous ramène aunous ramène aupoint de départ.point de départ.



----•En C nous avons :En C nous avons :

•Des variables globales de niveau 1 !Des variables globales de niveau 1 !•Des fonctions et procédures de niveau 2 !Des fonctions et procédures de niveau 2 !





•Ce n’est pas la peine de gérer un adresseur de 2 Ce n’est pas la peine de gérer un adresseur de 2 niveaux !niveaux !





•Ce n’est pas la peine de gérer un adresseur de 2 Ce n’est pas la peine de gérer un adresseur de 2 niveaux !niveaux !

L’adresseurL’adresseur La pileLa pile

. . .. . .



----Le choix de C se justifie si nous voulons passer, de Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables manière simple, en argument des fonctions à variables libres !libres !

void f ( x )void f ( x ) {{ void g ( y ) return ( x+y ) ;void g ( y ) return ( x+y ) ; h ( g ) ;h ( g ) ; }}

void h ( z )void h ( z ) {{ int x = 3 ;int x = 3 ; . . . z ( 4 ) . . . ;. . . z ( 4 ) . . . ; }}




void f ( x )void f ( x ) {{ void g ( y ) return ( x+y ) ;void g ( y ) return ( x+y ) ; h ( g ) ;h ( g ) ; }}

void h ( z )void h ( z ) {{ int x = 3 ;int x = 3 ; . . . z ( 4 ) . . . ;. . . z ( 4 ) . . . ; }}

Pour un appel f ( 5 ), laPour un appel f ( 5 ), lafonction g doit considérerfonction g doit considérer

que x vaut 5 !que x vaut 5 !

x = 5x = 5




void f ( x )void f ( x ) {{ void g ( y ) return ( x+y ) ;void g ( y ) return ( x+y ) ; h ( g )h ( g ) ; ; }}

void h ( void h ( zz ) ) {{ int x = 3 ;int x = 3 ; . . . z ( 4 ) . . . ;. . . z ( 4 ) . . . ; }}



x = 5x = 5

La fonction g est passée àLa fonction g est passée àh où elle prend le nom z !h où elle prend le nom z !





void h ( void h ( zz ) ) {{ int x = 3int x = 3 ; ; . . . . . . z z ( 4 ) . . . ;( 4 ) . . . ; }}



x = 5x = 5


z est appliquée dans un contexte où x vaut 3z est appliquée dans un contexte où x vaut 3alors qu’elle doit considérer que x vaut 5 !alors qu’elle doit considérer que x vaut 5 !





void h ( void h ( zz ) ) {{ int x = 3int x = 3 ; ; . . . . . . z z ( 4 ) . . . ;( 4 ) . . . ; }}



x = 5x = 5


z est appliquée dans un contexte où x vaut 3z est appliquée dans un contexte où x vaut 3alors qu’elle doit considérer que x vaut 5 !alors qu’elle doit considérer que x vaut 5 !

Si les fonctions sont définies au mêmeSi les fonctions sont définies au mêmeniveau, le problème ne se pose pas carniveau, le problème ne se pose pas car

elles référencent toutes le même contexte !elles référencent toutes le même contexte !


S T R U C T U R ES T R U C T U R E

D ‘ U ND ‘ U N

B L O CB L O C

D ‘ A C T I V A T I O ND ‘ A C T I V A T I O N


La structure d’un bloc d’activationLa structure d’un bloc d’activation----------------------------------------------------------------------------------------------------------------------------

----

Lien de contrôleLien de contrôle

Point dePoint deréférence !référence !

Le blocLe blocprécédent !précédent !


La structure d’un bloc d’activationLa structure d’un bloc d’activation----------------------------------------------------------------------------------------------------------------------------

----

Mémoire temporaireMémoire temporaire

Variables localesVariables locales

Sauvegarde des registresSauvegarde des registres

Les argumentsLes arguments

« Place pour le résultat » « Place pour le résultat »

Lien de contrôleLien de contrôle

Mis en placeMis en placepar l’appelé !par l’appelé !}}Mis en placeMis en placepar l’appelant !par l’appelant !}}

Point dePoint deréférence !référence !

Le blocLe blocprécédent !précédent !


RésuméRésumé----------------------------------------------------------------------------------------------------------------------------

----

•Analyse sémantiqueAnalyse sémantique

•Environnement d’exécutionEnvironnement d’exécution


C ’ e S t L a F i N ! C ’ e S t L a F i N ! ! !! !

b O n N eb O n N eJ o U r N é E ! ! !J o U r N é E ! ! !

10 octobre 2007Cours de compilation 6 - Intranet1 Cours de compilation Analyse sémantique...

Documents

Transcript of 10 octobre 2007Cours de compilation 6 - Intranet1 Cours de compilation Analyse sémantique...