Environnement d’exécution Cours de compilation Analyse sémantique Environnement d’exécution 10 octobre 2007 Cours de compilation 6 - Intranet

Les grandes lignes du cours Définitions de base Composition de compilateurs L’environnement d’un compilateur Evaluation partielle et compilation Analyses lexicales et syntaxiques Techniques d’analyse descendantes Techniques d’analyse ascendantes YACC Analyse sémantique Environnement d’exécution Génération de code Optimisation de code 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L ‘ A N A L Y S E S E M A N T I Q U E 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet V E R I F I C A T I O N D E S T Y P E S 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- Elle est faite en même temps que les analyses lexicales et syntaxiques ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- Elle est faite en même temps que les analyses lexicales et syntaxiques ! Il faut donc que tout soit déclaré avant d’être utilisé : Déclaration avant l’utilisation ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- Elle est faite en même temps que les analyses lexicales et syntaxiques ! Il faut donc que tout soit déclaré avant d’être utilisé : Déclaration avant l’utilisation ! Les seuls problèmes : Les procédures mutuellement récursives ! Les types récursifs ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- proc f ( . . . ) { g ( . . . ); } proc g ( . . . ) f ( . . . ); 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- proc f ( . . . ) { g ( . . . ); } proc g ( . . . ) f ( . . . ); 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- proc g ( . . . ) ; proc f ( . . . ) { g ( . . . ); } proc g ( . . . ) f ( . . . ); Il faut un prototype pour g ! ! ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- proc g ( . . . ) ; proc f ( . . . ) ; proc f ( . . . ) { g ( . . . ); } proc g ( . . . ) f ( . . . ); Il faut un prototype pour g ! ! ! Nous donnons tous les prototypes ! ! ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- Les types récursifs en Pascal : type ptr_arbre = ^arbre ; arbre = record champ : ptr_arbre end ; 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- Les types récursifs en Pascal : type ptr_arbre = ^arbre ; arbre = record champ : ptr_arbre end ; Une référence en avant (la seule tolérée en Pascal). 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- Les types récursifs en Pascal : type ptr_arbre = ^arbre ; arbre = record champ : ptr_arbre end ; Les types récursifs en C : struct moi_meme { struct moi_meme *self ; } *ptr_structure ; Une référence en avant (la seule tolérée en Pascal). 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’analyse sémantique ---------------------------------------------------------------- Les types récursifs en Pascal : type ptr_arbre = ^arbre ; arbre = record champ : ptr_arbre end ; Les types récursifs en C : struct moi_meme { struct moi_meme *self ; } *ptr_structure ; Une référence en avant (la seule tolérée en Pascal). Nous introduisons un nom auxiliaire ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Vérification des types ---------------------------------------------------------------- Il s’agit de vérifier l’adéquation entre : Les opérateurs et leurs arguments : #define ab 5 . . . int x . . . x + ( 3 * ab ) 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Vérification des types ---------------------------------------------------------------- Il s’agit de vérifier l’adéquation entre : Les opérateurs et leurs arguments : #define ab 5 . . . int x . . . x + ( 3 * ab ) Les membres gauche et droits d’une affectation : float x ; . . . x = 3.14 ; 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Vérification des types ---------------------------------------------------------------- Il s’agit de vérifier l’adéquation entre : Les opérateurs et leurs arguments : #define ab 5 . . . int x . . . x + ( 3 * ab ) Les membres gauche et droits d’une affectation : float x ; . . . x = 3.14 ; Les déclarations et appels des procédures et fonctions : float f ( int x , float y ) ; . . . f ( 5 , 3.14 ) . . . 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! int *p; float q; * + q deref 1 p 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! int *p; float q; * + q deref 1 int* p 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! int *p; float q; * + q int deref 1 int* p 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! int *p; float q; * + q int deref 1 int int* p 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! int *p; float q; * int +_int q int deref 1 int int* p 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! int *p; float q; * int +_int q float int deref 1 int int* p 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! int *p; float q; *_float float int +_int q float int deref 1 int int* p 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous faisons de la synthèse de types ! Nous partons des feuilles (variables et constantes) dont les types sont connus ! Nous déduisons et vérifions les types des expressions plus complexes ! int *p; float q; *_float float int_2_float int +_int q float Au passage, nous explicitons la conversion entre types ! int deref 1 int int* p 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous pouvons même propager des constantes, introduites par exemple à l’aide de #define ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous pouvons même propager des constantes, introduites par exemple à l’aide de #define ! #define ab 2 int x; * + x 2 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous pouvons même propager des constantes, introduites par exemple à l’aide de #define ! #define ab 2 int x; * int int + x int int 2 1 int 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous pouvons même propager des constantes, introduites par exemple à l’aide de #define ! #define ab 2 int x; * int int + x int val = 2 & int 2 1 int 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous pouvons même propager des constantes, introduites par exemple à l’aide de #define ! #define ab 2 int x; * int int + x int val = 2 & int 2 1 int & val = 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous pouvons même propager des constantes, introduites par exemple à l’aide de #define ! #define ab 2 int x; * int val = 3 & int + x int val = 2 & int 2 1 int & val = 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous pouvons même propager des constantes, introduites par exemple à l’aide de #define ! #define ab 2 int x; * int val = 3 & int + x int & val = ? val = 2 & int 2 1 int & val = 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- Nous pouvons même propager des constantes, introduites par exemple à l’aide de #define ! #define ab 2 int x; * int & val = ? val = 3 & int + x int & val = ? val = 2 & int 2 1 int & val = 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- On vérifie également que les tests des if , while , . . . sont des booléens, sauf en C ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- On vérifie également que les tests des if , while , . . . sont des booléens, sauf en C ! que les tableaux ne débordent pas, sauf en C ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- On vérifie également que les tests des if , while , . . . sont des booléens, sauf en C ! que les tableaux ne débordent pas, sauf en C ! var A = array [ 17 . . 39 ] of . . . 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Principe de la vérification des types ---------------------------------------------------------------- On vérifie également que les tests des if , while , . . . sont des booléens, sauf en C ! que les tableaux ne débordent pas, sauf en C ! var A = array [ 17 . . 39 ] of . . . test A [ i ] devient i >= 17 test ERREUR i <= 39 A [ i ] ERREUR 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet V I S I B I L I T E L E X I C A L E E T T A B L E S D E S S Y M B O L E S 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La table des symboles ---------------------------------------------------------------- Concernant les variables nous construisons la « table des symboles », nous respectons la « visibilité lexicale », nous déduisons la « durée de vie » des variables ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La table des symboles ---------------------------------------------------------------- Concernant les variables nous construisons la « table des symboles », nous respectons la « visibilité lexicale », nous déduisons la « durée de vie » des variables ! La table des symboles collecte pour chaque variable son type, ses éventuels paramètres, des attributs, . . . prend garde aux homonymes avec des numéros uniques. 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La table des symboles ---------------------------------------------------------------- Concernant les variables nous construisons la « table des symboles », nous respectons la « visibilité lexicale », nous déduisons la « durée de vie » des variables ! La table des symboles collecte pour chaque variable son type, ses éventuels paramètres, des attributs, . . . prend garde aux homonymes avec des numéros uniques. 1 2 3 ... x f ... int int->int float ... / inline double ... 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? int x ; int y ; int f ( float z ) { int x ; int t ; . . . x . . . y . . . z . . . t . . . } 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? int x ; int y ; int f ( float z ) { int x ; int t ; . . . x . . . y . . . z . . . t . . . } 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? int x ; int y ; int f ( float z ) { int x ; int t ; . . . x . . . y . . . z . . . t . . . } Cette occurrence de x est masquée par la redéfinition locale ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? int x ; int y ; int f ( float z ) { int x ; int t ; . . . x . . . y . . . z . . . t . . . } Cette occurrence de x est masquée par la redéfinition locale ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? int x ; int y ; int f ( float z ) { int x ; int t ; . . . x . . . y . . . z . . . t . . . } Cette occurrence de x est masquée par la redéfinition locale ! La variable y est dite « libre » dans f ! (variable globale) 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? int x ; int y ; int f ( float z ) { int x ; int t ; . . . x . . . y . . . z . . . t . . . } Cette occurrence de x est masquée par la redéfinition locale ! La variable y est dite « libre » dans f ! (variable globale) 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? int x ; int y ; int f ( float z ) { int x ; int t ; . . . x . . . y . . . z . . . t . . . } Cette occurrence de x est masquée par la redéfinition locale ! La variable y est dite « libre » dans f ! (variable globale) 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Qui référence quoi ? int x ; int y ; int f ( float z ) { int x ; int t ; . . . x . . . y . . . z . . . t . . . } Cette occurrence de x est masquée par la redéfinition locale ! La variable y est dite « libre » dans f ! (variable globale) x , t et z sont des variables dites « liées » dans f ! (variables locales) 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Un bloc ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Un bloc ! { Les variables locales . . . } 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Un bloc ! { Les variables locales sont créées . . . } Entrée 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Un bloc ! { Les variables locales sont créées . . . } Entrée Exécution 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Un bloc ! { Les variables locales sont créées . . . } Les variables locales sont détruites Entrée Exécution Sortie 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Un bloc ! { Les variables locales sont créées . . . } Les variables locales sont détruites La durée de vie est « statique » ou « lexicale » ! ! ! Entrée Exécution Sortie 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! Blocs disjoints 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! Blocs disjoints Blocs englobants 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! { . . . } { . . . } { { . . . } } Blocs disjoints Blocs englobants 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! Visibilité ! ! ! Blocs disjoints Blocs englobants 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! Visibilité ! ! ! Blocs disjoints Blocs englobants ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! Visibilité ! ! ! Blocs disjoints Blocs englobants non oui ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! Visibilité ! ! ! Blocs disjoints Blocs englobants non ICI oui ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Organisation relative des blocs ! Visibilité ! ! ! Blocs disjoints Blocs englobants non oui oui ICI oui ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! oui oui oui ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! oui oui oui ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! oui non non oui non oui ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! int x ; int x ; float y ; float z ; 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! float z int x ; Table des symboles chaînée : int x int x ; float y ; float y float z ; int x 10 octobre 2007 Cours de compilation 6 - Intranet /

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Règles de visibilité : - Nous voyons tout ce qui nous englobe (visibilité lexicale) ! - Pour les homonymes, nous voyons l’occurrence la plus interne ! float z int x ; Table des symboles chaînée : int x int x ; float y ; float y L’occurrence externe de x est masquée ! ! float z ; int x 10 octobre 2007 Cours de compilation 6 - Intranet /

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! int x ; Toutes les variables ont pu être initialisées ! int x ; float y ; float z ; ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! int x ; Toutes les variables ont pu être initialisées ! L’occurrence externe de x est masquée ! ! int x ; float y ; float z ; ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Nous avons une pile d'exécution ! ! ! La visibilité lexicale ---------------------------------------------------------------- Nous avons une pile d'exécution ! ! ! Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! int x ; Toutes les variables ont pu être initialisées ! L’occurrence externe de x est masquée ! ! int x ; float y ; float z ; ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Nous avons une pile d'exécution ! ! ! La visibilité lexicale ---------------------------------------------------------------- Nous avons une pile d'exécution ! ! ! Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! int x ; Toutes les variables ont pu être initialisées ! ENTREE L’occurrence externe de x est masquée ! ! int x ; float y ; float z ; ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Nous avons une pile d'exécution ! ! ! La visibilité lexicale ---------------------------------------------------------------- Nous avons une pile d'exécution ! ! ! Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! int x ; Toutes les variables ont pu être initialisées ! ENTREE L’occurrence externe de x est masquée ! ! int x ; float y ; float z ; ICI SORTIE 10 octobre 2007 Cours de compilation 6 - Intranet

Nous avons une pile d'exécution ! ! ! La visibilité lexicale ---------------------------------------------------------------- Nous avons une pile d'exécution ! ! ! Discipline d’exécution : - Nous entrons dans les blocs en respectant les niveaux ! - Nous exécutons les blocs en commençant au début ! int x ; Toutes les variables ont pu être initialisées ! ENTREE L’occurrence externe de x est masquée ! ! int x ; float y ; float z ; ICI SORTIE 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution des GOTO : 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution des GOTO : - Un GOTO est un saut vers une instruction (cf. assembleur) ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution des GOTO : - Un GOTO est un saut vers une instruction (cf. assembleur) ! - Les GOTO ne peuvent pas être quelconques ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution des GOTO : - Un GOTO est un saut vers une instruction (cf. assembleur) ! - Les GOTO ne peuvent pas être quelconques ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution des GOTO : - Un GOTO est un saut vers une instruction (cf. assembleur) ! - Les GOTO ne peuvent pas être quelconques ! NON ! ! ! GOTO Les variables ne sont pas initialisées ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Discipline d’exécution des GOTO : - Un GOTO est un saut vers une instruction (cf. assembleur) ! - Les GOTO ne peuvent pas être quelconques ! NON ! ! ! GOTO Les variables ne sont pas initialisées ! ICI SANS PROBLEMES ! ! ! GOTO 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Conséquences : 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Conséquences : Le dernier bloc dans lequel nous sommes entrés sera le premier que nous allons quitter ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Conséquences : Le dernier bloc dans lequel nous sommes entrés sera le premier que nous allons quitter ! Tout ce qui est lexicalement visible depuis un endroit a pu être initialisé au paravent ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité lexicale ---------------------------------------------------------------- Conséquences : Le dernier bloc dans lequel nous sommes entrés sera le premier que nous allons quitter ! Tout ce qui est lexicalement visible depuis un endroit a pu être initialisé au paravent ! L'exécution peut être gérée dans une pile ! ! ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet V I S I B I L I T E D Y N A M I Q U E 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... En visibilité lexicale, quand nous sommes dans g , nous ne voyons pas le paramètre formel x de f ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... PILE ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... PILE L’appel initial est f ( 5 ) ! ! ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... f ( 5 ) y = 3 x = 5 PILE L’appel initial est f ( 5 ) ! ! ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... f ( 5 ) y = 3 x = 5 PILE L’appel initial est f ( 5 ) ! ! ! ICI x et y ont des valeurs ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... PILE L’appel initial est g ( 4 ) ! ! ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... y = 4 g ( 4 ) PILE L’appel initial est g ( 4 ) ! ! ! ICI 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La visibilité dynamique ---------------------------------------------------------------- Toutes les variables de la pile sont visibles (en fait leurs dernières occurrences) ! ! ! void f ( x ) { g ( 3 ) ; } void g ( y ) ... y = 4 g ( 4 ) PILE L’appel initial est g ( 4 ) ! ! ! ICI y seule a une valeur ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L E S D U R E E S D E V I E 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Les durées de vie des variables ---------------------------------------------------------------- Les variables déclarées ont une durée de vie « statique » ! Elles sont créées à l’entrée dans le bloc ! Elles sont détruites à la sortie du bloc ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Les durées de vie des variables ---------------------------------------------------------------- Les variables déclarées ont une durée de vie « statique » ! Elles sont créées à l’entrée dans le bloc ! Elles sont détruites à la sortie du bloc ! Les valeurs allouées ont une durée de vie « dynamique » ! Elles sont créées par malloc , . . . ! Elles sont détruites explicitement ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Les durées de vie des variables ---------------------------------------------------------------- Les variables déclarées ont une durée de vie « statique » ! Elles sont créées à l’entrée dans le bloc ! Elles sont détruites à la sortie du bloc ! Les valeurs allouées ont une durée de vie « dynamique » ! Elles sont créées par malloc , . . . ! Elles sont détruites explicitement ! PILE ! HEAP ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Les durées de vie des variables ---------------------------------------------------------------- Les variables déclarées ont une durée de vie « statique » ! Elles sont créées à l’entrée dans le bloc ! Elles sont détruites à la sortie du bloc ! Les valeurs allouées ont une durée de vie « dynamique » ! Elles sont créées par malloc , . . . ! Elles sont détruites explicitement ! Attention : { . . . *p ; p = malloc ( . . . ) ; } p sera détruite, mais pas la donnée allouée ! PILE ! HEAP ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet E N V I R O N N E M E N T D ‘ E X E C U T I O N 10 octobre 2007 Cours de compilation 6 - Intranet

Tout sera géré dans la pile L’environnement d’exécution ---------------------------------------------------------------- Tout sera géré dans la pile sauf les malloc ! 10 octobre 2007 Cours de compilation 6 - Intranet

Tout sera géré dans la pile L’environnement d’exécution ---------------------------------------------------------------- Tout sera géré dans la pile sauf les malloc ! Dans la pile nous gérons : Les imbrications des opérations (adresses de retour) ! 10 octobre 2007 Cours de compilation 6 - Intranet

Tout sera géré dans la pile L’environnement d’exécution ---------------------------------------------------------------- Tout sera géré dans la pile sauf les malloc ! Dans la pile nous gérons : Les imbrications des opérations (adresses de retour) ! Les variables du programme ! 10 octobre 2007 Cours de compilation 6 - Intranet

Tout sera géré dans la pile L’environnement d’exécution ---------------------------------------------------------------- Tout sera géré dans la pile sauf les malloc ! Dans la pile nous gérons : Les imbrications des opérations (adresses de retour) ! Les variables du programme ! Les variables temporaires du compilateur ! 10 octobre 2007 Cours de compilation 6 - Intranet

Tout sera géré dans la pile L’environnement d’exécution ---------------------------------------------------------------- Tout sera géré dans la pile sauf les malloc ! Dans la pile nous gérons : Les imbrications des opérations (adresses de retour) ! Les variables du programme ! Les variables temporaires du compilateur ! Les paramètres des fonctions et procédures ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- Pour les fonctions et procédures nous distinguons entre leurs déclarations et leurs activations ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- Pour les fonctions et procédures nous distinguons entre leurs déclarations et leurs activations ! Soient proc f (... ) { ... f ... g ... } proc g (... ) { ... f ... g ... } 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- Pour les fonctions et procédures nous distinguons entre leurs déclarations et leurs activations ! Soient proc f (... ) { ... f ... g ... } proc g (... ) { ... f ... g ... } Un « arbre d’activations » possible : f f g g g f 10 octobre 2007 Cours de compilation 6 - Intranet f

L’environnement d’exécution ---------------------------------------------------------------- Pour les fonctions et procédures nous distinguons entre leurs déclarations et leurs activations ! Soient proc f (... ) { ... f ... g ... } proc g (... ) { ... f ... g ... } Un « arbre d’activations » possible : f Le parcours préfixe de l’arbre d’activation donne la séquence des appels et retours de fonctions ! f g g g f 10 octobre 2007 Cours de compilation 6 - Intranet f

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- main () var_main begin end 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- main () var_main f ( … ) var_f begin end begin end 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- main () var_main f ( … ) var_f g (…) var_g begin end begin end begin end 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- main () var_main f ( … ) var_f g (…) var_g begin end h (…) var_h begin end begin end begin end 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- main () var_main main f ( … ) var_f f g (…) var_g begin end f h (…) var_h begin end g begin end h begin end g 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- main () var_main main f ( … ) var_f f g (…) var_g begin end f h (…) var_h begin end g begin end h begin end La pile g 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- main () var_main main f ( … ) var_f f g (…) var_g begin end f h (…) var_h begin end g begin end h main begin end La pile g 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet L’environnement d’exécution ---------------------------------------------------------------- main () var_main main f ( … ) var_f f g g (…) var_g begin end h f g h (…) var_h begin end f g f begin end h main begin end La pile g 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f g g (…) var_g begin end h g h (…) var_h begin end f f begin end main begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f g g (…) var_g begin end h Nous n’avons pas envie d’inspecter toute la pile à chaque fois que nous avons besoin de la valeur d’une variable ! g h (…) var_h begin end f f begin end main begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f g OUI, le bloc courant ! g (…) var_g begin end h g h (…) var_h begin end f f begin end main begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f g OUI g (…) var_g begin end h NON, à cause de la lexicalité ! g h (…) var_h begin end f f begin end main begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f g OUI g (…) var_g begin end h NON g NON, pas la dernière activation ! h (…) var_h begin end f f begin end main begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f g OUI g (…) var_g begin end h NON g NON h (…) var_h begin end f OUI, dernière activation d’un bloc englobant ! f begin end main begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f g OUI g (…) var_g begin end h NON g NON h (…) var_h begin end f OUI f NON, c’est bien un bloc englobant, mais pas la dernière activation ! begin end main begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f g OUI g (…) var_g begin end h NON g NON h (…) var_h begin end f OUI f NON begin end main OUI, l’unique activation du bloc principal ! begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f En résumé : g OUI g (…) var_g begin end h NON g NON h (…) var_h begin end f OUI f NON begin end main OUI begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f En résumé : Nous voyons les dernières activations du bloc courant et de ses blocs englobants ! g OUI g (…) var_g begin end h NON g NON h (…) var_h begin end f OUI f NON begin end main OUI begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f En résumé : Nous voyons les dernières activations du bloc courant et de ses blocs englobants ! g OUI g (…) var_g begin end h NON g NON h (…) var_h begin end f OUI f NON begin end main OUI begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f En résumé : Nous voyons les dernières activations du bloc courant et de ses blocs englobants ! Leur nombre dépend du texte du programme ! g OUI g (…) var_g begin end h NON g NON h (…) var_h begin end f OUI f NON begin end main OUI begin end La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f Nous créons une mini-pile appelée « adresseur » ou « display » ! g g (…) var_g begin end h g h (…) var_h begin end f f begin end main begin end La pile L’adresseur 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( … ) var_f Nous créons une mini-pile appelée « adresseur » ou « display » ! g g (…) var_g begin end h L’adresseur repère les blocs actifs. g h (…) var_h begin end f f begin end main begin end La pile L’adresseur 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( x ) var_f Nous créons une mini-pile appelée « adresseur » ou « display » ! g g (…) var_g begin end h L’adresseur repère les blocs actifs. g h (…) var_h begin end x f x f begin end main Trouver le paramètre x de f . . . begin end La pile L’adresseur 10 octobre 2007 Cours de compilation 6 - Intranet

Qu'est-ce qui est visible de la pile ? L’environnement d’exécution ---------------------------------------------------------------- Qu'est-ce qui est visible de la pile ? main () var_main f ( x ) var_f Nous créons une mini-pile appelée « adresseur » ou « display » ! g g (…) var_g begin end h L’adresseur repère les blocs actifs. g h (…) var_h begin end x f x f Niveau de f begin end main Trouver le paramètre x de f est simple. begin end La pile L’adresseur 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet G E S T I O N D E L ‘ A D R E S S E U R 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 1 ) g est de niveau N+1 : - Nous rajoutons une entrée à l’adresseur ! ! ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 1 ) g est de niveau N+1 : - Nous rajoutons une entrée à l’adresseur ! ! ! N . . . 1 La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 1 ) g est de niveau N+1 : - Nous rajoutons une entrée à l’adresseur ! ! ! N+1 g N . . . 1 La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 2 ) g est de niveau N : 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 2 ) g est de niveau N : - Si g = f , la nouvelle activation invalide l’ancienne ! - Si g <> f , alors f devient invisible par lexicalité ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 2 ) g est de niveau N : - Si g = f , la nouvelle activation invalide l’ancienne ! - Si g <> f , alors f devient invisible par lexicalité ! Dans tous les cas : - Nous sauvons l’entrée N de l’adresseur ! - Nous y installons le pointeur vers le bloc g ! - A la sortie, nous restaurons l’entrée sauvée ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 3 ) g est de niveau N - k : 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 3 ) g est de niveau N - k : Si k = 0 , nous retrouvons le cas 2 ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Soit f une fonction de niveau N qui appelle g ! Discussion par cas suivant le niveau de g : ( 3 ) g est de niveau N - k : Si k = 0 , nous retrouvons le cas 2 ! Donc : - Nous sauvons les entrées N - k , . . . , N ! - Nous y installons le pointeur vers le bloc g ! - A la sortie, nous restaurons les entrées sauvées ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Nous avons donc les quatre étapes suivantes : N f ( 1 ) N-k-1 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Sauvegardées ! ! ! Nous avons donc les quatre étapes suivantes : N f ( 1 ) ( 2 ) N-k-1 N-k-1 1 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Sauvegardées ! ! ! Nous avons donc les quatre étapes suivantes : N f ( 1 ) ( 2 ) N-k-1 N-k-1 1 1 ( 3 ) N-k g N-k-1 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Sauvegardées ! ! ! Nous avons donc les quatre étapes suivantes : N f ( 1 ) ( 2 ) N-k-1 N-k-1 1 1 La restauration des entrées sauvegardées nous ramène au point de départ. ( 3 ) N-k g ( 4 ) N-k-1 1 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- En C nous avons : Des variables globales de niveau 1 ! Des fonctions et procédures de niveau 2 ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- En C nous avons : Des variables globales de niveau 1 ! Des fonctions et procédures de niveau 2 ! Ce n’est pas la peine de gérer un adresseur de 2 niveaux ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- En C nous avons : Des variables globales de niveau 1 ! Des fonctions et procédures de niveau 2 ! Ce n’est pas la peine de gérer un adresseur de 2 niveaux ! . . . L’adresseur La pile 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables libres ! void f ( x ) { void g ( y ) return ( x+y ) ; h ( g ) ; } void h ( z ) int x = 3 ; . . . z ( 4 ) . . . ; 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La gestion de l’adresseur ---------------------------------------------------------------- Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables libres ! void f ( x ) { void g ( y ) return ( x+y ) ; h ( g ) ; } void h ( z ) int x = 3 ; . . . z ( 4 ) . . . ; Pour un appel f ( 5 ), la fonction g doit considérer que x vaut 5 ! x = 5 10 octobre 2007 Cours de compilation 6 - Intranet

La fonction g est passée à La gestion de l’adresseur ---------------------------------------------------------------- Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables libres ! void f ( x ) { void g ( y ) return ( x+y ) ; h ( g ) ; } void h ( z ) int x = 3 ; . . . z ( 4 ) . . . ; Pour un appel f ( 5 ), la fonction g doit considérer que x vaut 5 ! x = 5 La fonction g est passée à h où elle prend le nom z ! 10 octobre 2007 Cours de compilation 6 - Intranet

La fonction g est passée à La gestion de l’adresseur ---------------------------------------------------------------- Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables libres ! void f ( x ) { void g ( y ) return ( x+y ) ; h ( g ) ; } void h ( z ) int x = 3 ; . . . z ( 4 ) . . . ; Pour un appel f ( 5 ), la fonction g doit considérer que x vaut 5 ! x = 5 PROBLEME ! La fonction g est passée à h où elle prend le nom z ! z est appliquée dans un contexte où x vaut 3 alors qu’elle doit considérer que x vaut 5 ! 10 octobre 2007 Cours de compilation 6 - Intranet

La fonction g est passée à La gestion de l’adresseur ---------------------------------------------------------------- Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables libres ! void f ( x ) { void g ( y ) return ( x+y ) ; h ( g ) ; } void h ( z ) int x = 3 ; . . . z ( 4 ) . . . ; Pour un appel f ( 5 ), la fonction g doit considérer que x vaut 5 ! x = 5 PROBLEME ! La fonction g est passée à h où elle prend le nom z ! z est appliquée dans un contexte où x vaut 3 alors qu’elle doit considérer que x vaut 5 ! SOLUTION ! Si les fonctions sont définies au même niveau, le problème ne se pose pas car elles référencent toutes le même contexte ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet S T R U C T U R E D ‘ U N B L O C D ‘ A C T I V A T I O N 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet La structure d’un bloc d’activation ---------------------------------------------------------------- Point de référence ! Lien de contrôle Le bloc précédent ! 10 octobre 2007 Cours de compilation 6 - Intranet

Sauvegarde des registres « Place pour le résultat » La structure d’un bloc d’activation ---------------------------------------------------------------- } Mémoire temporaire Variables locales Sauvegarde des registres Mis en place par l’appelé ! Point de référence ! } Lien de contrôle Mis en place par l’appelant ! Les arguments « Place pour le résultat » Le bloc précédent ! 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet Résumé ---------------------------------------------------------------- Analyse sémantique Environnement d’exécution 10 octobre 2007 Cours de compilation 6 - Intranet

Cours de compilation 6 - Intranet C ’ e S t L a F i N ! ! ! b O n N e J o U r N é E ! ! ! 10 octobre 2007 Cours de compilation 6 - Intranet