ISBN 0- 0-321-49362-1 Chapitre 10 L'implémentation des sous- programmes.

Présentation au sujet: "ISBN 0- 0-321-49362-1 Chapitre 10 L'implémentation des sous- programmes."— Transcription de la présentation:

1 ISBN 0- 0-321-49362-1 Chapitre 10 L'implémentation des sous- programmes

2 1-2 Chapitre 10: Sujets La sémantique des appels et retour de sous- programme Sous-programmes simples Sous programmes avec variable locale dynamique sur pile Sous-programmes imbriqués Blocs d'instructions L'implémentation de la portée dynamique

3 1-3 Appel et retour de sous-programmes Les procédures d'appel et de retour de sous-programmes sont globalement appelées liaison de sous-programmes Plusieurs actions: –Méthode de passage des paramètres –Variables locales dynamique et statiques –Status d'exécution du programme appelant –Tranfert du contrôle

4 1-4 Sous-programmes simple: Sémantique des appels Simple: 1.Toutes les variables locales sont statiques 2.Aucune imbrication des sous-programmes Sauver le contexte du sous-programme appelant Effectuer la passage des paramètres Mettre l'adresse de retour sur la pile Tranférer le contrôle au sous-programme

5 1-5 Sous-programmes simple: Sémantique des retours Si le passage des paramètres par copie est utilisé, il faut copier les paramètres formels dans les paramètres d'appel Dans le cas des fonctions, il faut placer la valeur de retour à un endroit pouvant être accédé par le programme appelant Restaurer le contexte du programme appelant Transférer le contrôle au programme appelant

6 1-6 Sous-programmes simple: Code et cadre d' activation Chaque sous-programme contient deux parties: Le code et le cadre d' activation cadre d' activation: variables locales, paramètres, adresse de retour, etc.

7 1-7 cadre d' activation pour un programme simple

8 1-8 Code et cadres d'activation pour un programme avec sous-programmes simples

9 1-9 Sous-programmes avec variables locales dynamiques sur pile Cadres d'activation plus complexes –Le compilateur doit générer le code nécessaire à l'allocation et la désallocation des variables locales –Les cadres d'activation sont créés dynamiquement sur la pile –Permet la récursion

10 1-10 Sous-programmes avec variables locales dynamiques sur pile: cadres d' activation Dans la plupart des langages, le format des cadres d'activation est connu à la compilation mais quelques fois la taille peut être dynamique –Par exemple, en Ada la taille des tableaux déclarés localement peut dépendre des paramètres. Un cadre d'activation est créé dynamiquement lors d'un appel à un sous-programme Un pointeur appelé lien dynamique pointe au dessus du cadre d' activation du sous-programme appelant La pile système est utilisée pour contenir les cadres d'activation.

11 1-11 cadre d' activation typique pour un langage avec variables locales dynamique sur pile

12 1-12 Exemple: Une fonction en C void sub(float total, int part) { int list[4]; float sum; … } [4] [3] [2] [1] [0]

13 1-13 Un exemple sans récursion void fun1(float r) { int s, t;... fun2(s);... } void fun2(int x) { int y;... fun3(y);... } void fun3(int q) {... } void main() { float p;... fun1(p);... } main appelle fun1 fun1 appelle fun2 fun2 appelle fun3

14 1-14 Exemple sans récursion fun 1 main fun 2 fun 1 main fun 3 fun 2 fun 1 main

15 1-15 Chaîne dynamique et décalage local À un instant donné, la pile contient une suite de liens dynamiques que l'on appelle chaîne dynamique ou chaîne d'appels On peut accéder aux variables locales en ajoutant un décalage à l'adresse du commencement du cadre d' activation. Ce décalage est appelé décalage local Si la taille des cadres d'activation est connu, le décalage local d'une variable locale peut être déterminé au cours de la compilation

16 1-16 Un exemple avec récursion int factorial (int n) { <-----------------------------1 if (n <= 1) return 1; else return (n * factorial(n - 1)); <-----------------------------2 } void main() { int value; value = factorial(3); <-----------------------------3 }

17 1-17 Un exemple avec récursion: cadre d' activation

18 1-18 Un exemple avec récursion (suite)

19 1-19 Un exemple avec récursion (suite)

20 1-20 Un exemple avec récursion (suite)

21 1-21 Sous-programmes imbriqués Certains langages (e.g., Fortran 95, Ada, JavaScript, Python, Lua) utilisent une portée statique, des variables locales dynamique sur pile et permettent d'imbriquer les sous-programmes Toutes les variables qui ne sont pas locales doivent se trouver quelque part dans un autre cadre d' activation Processus pour retrouver une variable non locale: 1.Trouver le cadre d'activation approprié 2.Déterminer le déplacement local approprié

22 1-22 Trouver une variable non locale Les variables non locales d'un sous-programme doivent être déclarées dans la portée statique de ses ancêtres. Les cadres d'activation de ces sous-programmes doivent êtres présent sur la pile Pour chaque variable, on considère le plus récent cadre d'activation contenant cette variable.

23 1-23 Chaînes statiques Un nouveau pointeur, appelé lien statique, est ajouté au cadre d'activation. –Le lien statique pointe vers une instance du cadre d'activation du parent statique de A Une chaîne statique est une chaîne de liens statiques qui connectent un cadre d'activation à tous ses ancêtres statiques –Cela permet de retrouver toutes les variables non locales lorsque la portée est statique. La profondeur statique d'une variable non locale peut être déterminée au moment de la compilation Variable non locale => (décalage de chaîne, décalage local)

24 1-24 Exemple en Pascal program MAIN_2; var X : integer; procedure BIGSUB; var A, B, C : integer; procedure SUB1; var A, D : integer; begin { SUB1 } A := B + C; end; { SUB1 } procedure SUB2(X : integer); var B, E : integer; procedure SUB3; var C, E : integer; begin { SUB3 } SUB1; E := B + A: end; { SUB3 } begin { SUB2 } SUB3; A := D + E; end; { SUB2 } begin { BIGSUB } SUB2(7); end; { BIGSUB } begin BIGSUB; end; { MAIN_2 }

25 1-25 Exemple en Pascal program MAIN_2; var X : integer; procedure BIGSUB; var A, B, C : integer; procedure SUB1; var A, D : integer; begin { SUB1 } A := B + C; <-----------------------1 end; { SUB1 } procedure SUB2(X : integer); var B, E : integer; procedure SUB3; var C, E : integer; begin { SUB3 } SUB1; E := B + A: <--------------------2 end; { SUB3 } begin { SUB2 } SUB3; A := D + E; <-----------------------3 end; { SUB2 } begin { BIGSUB } SUB2(7); end; { BIGSUB } begin BIGSUB; end; { MAIN_2 }

26 1-26 Exemple en Pascal (suite) Séquence d'appel pour MAIN_2 MAIN_2 appelle BIGSUB BIGSUB appelle SUB2 SUB2 appelle SUB3 SUB3 appelle SUB1 Relation statique: MAIN_2 BIGSUB SUB1SUB2 SUB3

27 1-27 Contenu de la pile MAIN_2 BIGSUB SUB1SUB2 SUB3

28 1-28 Les blocs Les blocs permettent à l'usager de définir une portée locale Exemple en C {int temp; temp = list [upper]; list [upper] = list [lower]; list [lower] = temp } Avantage: Il n'y a aucune interférence entre la variable temp définie dans le bloc et une autre variable temp pouvant avoir été définie à l'extérieur.

29 1-29 Implémentation des blocs Deux méthodes: 1.On traite le bloc comme une fonction sans paramètre toujours appelée de la même position –Chaque bloc possède un cadre d'activation –Une instance est créée chaque fois que le bloc est exécuté 2.L'espace nécessaire pour le bloc est calculé au moment de la compilation; Cet espace est ajouté après les variables locales dans le cadre d'activation du sous-programme courant.

30 1-30 Implémentations de la portée dynamique Accès profond : Une référence à une variable non locale est réalisée en parcourant la chaîne dynamique des cadres d'activation –Remarque: Pour la portée statique, on utilise plutôt la chaîne statique Accès superficiel : Les variables locales ne sont pas mises dans les cadres d'activation –Une pile par nom de variable –Ajout d'un tableau central contenant une entrée par nom de variable

31 1-31 Sommaire La sémantique de liaison des sous-programmes requiert plusieurs actions pour son implémentation L'utilisation de la pile augmente en complexité pour: 1.Les langages statiques 2.Les langages utilisant des variables locales dynamique 3.Les langages utilisant des sous-programmes imbriqués L'implémentation des sous-programmes imbriqués et les sous-programmes avec variables locales dynamiques sur la pile nécessitent deux parties: –Le code –Le cadre d'activation

32 1-32 Sommaire (suite) Les cadres d'activation contient, entre autres, les paramètres formels, les variables locales et l'adresse de retour Le chaînage statique est la méthode principale pour implémenter l'accès aux variables non locales lorsque la portée est statique et que l'imbrication des sous- programmes est permise. L'accès aux variables non locales pour les langages à portée dynamique peut être implémenté à l'aide de la chaîne dynamique ou en utilisant un tableau central