CSI 3525, Implmentation des sousprogrammes, page 1

1
Implémentation des sous-programmes

• Lenvironnement dans les langages structurés en
  bloc
• La structure de la pile dactivation
• Chaîne statique
• Les fonctions et la pile

2
Lenvironnement des langages structurés en blocs

• Les sous-programmes sont strictement imbriqués
  lappelant attend que lappelé ait terminé.

3

• Lactivation dun sous-programme est représentée
  par un enregistrement dactivation sur la pile
  dactivation.
• Lenregistrement dactivation de lappelé est
  placé sur le dessus de la pile, directement au
  dessus de celui de lappelant.
• Les enregistrements dactivation sont de
  différentes tailles. La taille est habituellement
  déterminée à la compilation, à moins que les
  tableaux semi-dynamiques soient supportés par le
  langage. Toutefois, chaque enregistrement
  dactivation contient les mêmes genres
  dinformations sur lappelant et lappelé.

4
Information sur lappelant

• Un pointeur vers lenregistrement de lappelant
  (le prochain enregistrement sur la pile, mais qui
  est nécessaire pour traiter la taille variable
  des enregistrements ) ceci permet laccès à
  toute la chaîne des appelant précédant, jusquau
  programme principale.
• Ladresse de retours (Ce que lappelant va faire
  après lexécution du sous-programme).
• Si cest une fonction, ladresse ou la valeur de
  retours doit être placée.

5
Information sur lappelé

• Information sur la porté un pointeur vers
  lenregistrement dactivation record du bloc
  englobant (pas nécessairement le même bloc que
  lappelant).
• Les variables locales et constantes.
• Les paramètres formels (des copies, ou des
  pointeurs seulement).
• Mémoire temporaire (pour évaluer les expressions).

6

• Suffisamment de mémoire doit être allouée pour
  représenter le bloc de lappelé. Cette mémoire
  est allouée pour les appels aux procédures comme
  des segments de la pile.

Le compilateur génère un prologue, puis la
traduction du corps du sous-programme puis
finalement un épilogue.
7
Prologue entrer dans un sous-programme

• Obtenir un segment de la mémoire libre de la pile
  un bloc dactivation et déplacer le pointeur
  du  top  de la pile vers le haut.
• Placer dans le nouveau bloc dactivation les
  données sur lappelant et lappelé.

8
Épilogue sortir dun sous-programme

• Retourner une valeur (si le sous-programme est
  une fonction).
• Enlever le bloc de sur la pile, et mettre à jours
  le  top  de la pile.
• Continuer lexécution avec ladresse de retours
  (continuer les instructions dans le corps de
  lappelant).

9
Mémoire dexécution ( run-time )

• La mémoire dexécution est séparée en trois
  parties.
• Région du code programme principale,
  sous-programmes.
• Région des données la pile dexécution. Toutes
  les variables sont représentéesles variables
  globales sont locales dans lenregistrement
  dactivation du programme principale).

10

• Mémoire dexécution -- suite.
• Information de contrôle
• Pointeur sur linstruction courante IP indique
  la prochaine instruction à être exécuté.
• Pointeur sur lenvironnement courant EP montre
  lenregistrement dactivation du bloc courrant,
  et donne accès aux données locales et non-locales.

11

• Dans les exemples suivant, on suppose un modèle
  simple
• le pointeur vers lenregistrement dactivation
  de lappelant,
• le pointeur vers le bloc englobant,
• ladresse de retours,
• les données locales (si il y en a),
• les paramètres réels (si il y en a).
• Les adresses de retours seront symboliquesvoir
  les boites sur la page suivante.

12
La structure dune pile dactivation

• program M( input,output)
• var A, B integer
•  
• procedure P( C integer
• var D integer)
• begin P
• P1 C C 2
• P2 D D 3
• P3 write('P',A,B,C, D)
• P4 end
• procedure Q( var Cinteger)
• var B integer
• procedure R( C integer)
• begin R
• R1 C 29
• R2 P(B, C)
• R3 write('R',A, B, C)

• suite
• begin Q
• Q1 B 23
• Q2 R(A)
• Q3 P(B, C)
• Q4 write('Q', A, B,
  C)
• Q5 end
•  
• begin M
• M1 A 6
• M2 B 17
• M3 P(B, A)
• M4 write('M', A, B)
• M5 Q(A)
• M6 write('M', A, B)
• M7 end.

13
(lien dynamique)
F1
(lien statique)
Bloc dactivation
(adresse de retours)
M
A 9
B 17
Sous-programme
F2
F1
F1
M6
lien dynamique
Q
B 23
C ? A
F3
F2
Lien statique
F2
R
Q3
C 29
F4
F3
La pile, après P dans R dans Q dans M appelé IP
P1, EP F4
F1
R3
P
C 23
D ? C
14
Autre exemple

• program Main
• var A, B integer
• procedure P
• begin P
• L1P A A 1
• L2P B B 1
• L3P end
•  
• procedure Q
• var B integer
•  
• procedure R
• var A integer
• begin R
• L1R A 16
• L2R P
• L3R write(A, B)
• L4R end

• continued
• begin Q
• L1Q B 11
• L2Q R
• L3Q P
• L4Q write(A, B)
• L5Q end
•  
• begin Main
• L1m A 1
• L2m B 6
• L3m P
• L4m write(A, B)
• L5m Q
• L6m write(A, B)
• L7m end.

15
(dynamic link)
F1
(static link)
(return address)
Main
A 1
B 6
situation dans Main juste avant lappel à P IP
L3m, EP F1
16
(dynamic link)
F1
(static link)
(return address)
Main
A 1
B 6
F2
F1
F1
P
L4m
situation après P dans Main appelé IP L1P, EP
F2
17
(dynamic link)
F1
(static link)
(return address)
Main
A 2
B 7
situation après P dans Main terminé IP L4m,
EP F1
18
(dynamic link)
F1
(static link)
(return address)
Main
A 2
B 7
F2
F1
F1
Q
L6m
situation après Q dans Main appelé IP L1Q,
EP F2
B
19
6)
(dynamic link)
F1
(static link)
(return address)
Main
A 2
B 7
F2
F1
F1
Q
L6m
situation après R dans Q dans Main appelé IP
L1R, EP F3
B 11
F3
F2
F2
R
L3Q
A
20
(dynamic link)
F1
(static link)
(return address)
Main
A 2
B 7
F2
F1
F1
Q
L6m
situation après P dans R dans Q dans Main
appelé IP L1P, EP F4
B 11
F3
F2
F2
R
L3Q
A 16
F4
F3
F1
P
L3R
21
(dynamic link)
F1
(static link)
(return address)
Main
A 3
B 8
F2
F1
F1
Q
L6m
situation après P dans R dans Q dans Main
terminé IP L4R, EP F3
B 11
F3
F2
F2
R
L3Q
A 16
22
(dynamic link)
F1
(static link)
(return address)
Main
A 3
B 8
F2
F1
F1
Q
L6m
situation après P dans Q dans Main terminé IP
L3Q, EP F2
B 11
23
(10)
(dynamic link)
F1
(static link)
(return address)
Main
A 3
B 8
F2
F1
F1
Q
L6m
situation après P dans Q dans Main appelé IP
L1P, EP F3
B 11
F3
F2
F1
P
L4Q
24
(dynamic link)
F1
(static link)
(return address)
Main
A 4
B 9
F2
F1
F1
Q
L6m
situation après P dans Q dans Main terminé IP
L4Q, EP F2
B 11
25
(dynamic link)
F1
(static link)
(return address)
Main
A 4
B 9
situation après Q dans Main terminé IP L6m,
EP F1
26
Chaînes statiques

• On naccède pas aux variables représentées sur la
  pile par leur nom. Dans un langage à porté
  statique, une variable doit, cependant, être
  trouvée en remontant la chaîne dimbrication.
• Une adresse de la variable V sur la pile est
  composée de deux nombres qui nous disent
• de combien denregistrements dactivation
  doit-on remonter la chaîne pour retrouver
  lenregistrement R contenant V,
• à quelle adresse V se trouve t-elle du début de
  R.

27

• Dans la situation où Q dans Main a été appelé
• Main.Q.B (0, 3)
• Main.A (1, 3)
• Main.B invisible

(dynamic link)
F1
(static link)
(return address)
Main
A 2
B 7
F2
F1
F1
Q
L6m
B
28

• Dans la situation où P dans R dans Q dans Main a
  été appelé
• Main.Q.R.A invisible
• Main.Q.B invisible
• Main.A (1, 3)
• Main.B (1, 4)

(dynamic link)
F1
(static link)
(return address)
Main
A 2
B 7
F2
F1
F1
Q
L6m
B 11
F3
F2
F2
R
L3Q
A 16
F4
F3
F1
P
L3R
29
Les fonctions et la pile

• La description des adresses des fragments du
  programme doit être plus élaborée
• L1G if N lt 1 then
• L2G value 1
• L3G goto L7G
• L4G G(N-1)
• L5G ? temp
• L6G value temp N
• L7G
• L1M G(3)
• L2M ? temp
• L3M A temp
• L4M write(A)
• L5M

• program Main
• var A integer
• function G(N integer)
• integer
• begin
• if N lt 1 then
• G 1
• else
• G G(N-1) N
• end
• begin
• A G(3)
• write(A)
• end.

30
(2)
(dynamic link)
F1
(static link)
(return address)
Main
A ?
F2
F1
F1
L2M
G
value ?
G dans G dans G dans Main retourne avec 1 IP
L3G, EP F4
N 3
F3
F2
F1
G
L5G
value ?
N 2
F4
F3
F1
L5G
G
value 1
N 1