JeanJacques Girardot

1
Cours Architecture des Systèmes Informatiques

• Jean-Jacques Girardot
• girardot_at_emse.fr
• http//kiwi.emse.fr/ASI
• Cinquième séance
• Langages de Programmation

2
Plan

• Introduction aux langages de programmation
• Compilation et génération de code
• Expressions arithmétiques, boucles,
  sous-programmes
• Module objet, exécutable
• Allocation des variables
• Statique, automatique, dynamique
• Utilisation de la pile
• Notion de cadre

3
Les langages de programmation Une classification

• Assembleurs bien utiliser les ressources de
  la machine
• Premiers langages compilés FORTRAN
  (scientifique), COBOL (gestion) écrire des
  applications portables
• Langages de programmation structurée ALGOL,
  PASCAL programmes aisés à concevoir et
  maintenir
• Langages à objets C programmation dans le
  large
• Langages fonctionnels LISP, Caml vers des
  programmes plus faciles à prouver
• Langages déclaratifs Prolog
• Langages spécialisés SQL (bases de données),
  sh, ksh, perl (shell scripts), etc

4
Technologies d'implantation

• Langages compilés
• Un outil (compilateur) transforme le programme
  source en un programme objet, ou un programme
  core image
• Le résultat est directement exécutable par la
  machine
• Exemples C, C, Pascal, FORTRAN, ADA, COBOL,
  etc.
• Langage interprété
• Un outil (interprète) lit le programme source et
  (après transformations diverses) lexécute
  directement.
• Exemples APL, LISP, Perl, CAML, etc.
• Approches intermédiaires - ex SIM
• Source -gt code machine virtuelle, interprétation
  du code

5
Étapes de lexécutiondun programme compilé

• Compilation traduction dun langage source vers
  un langage d'assemblage ou un langage objet
• Assemblage traduction dun programme source en
  assembleur vers un langage objet
• Édition de liens création dun programme
  exécutable, rassemblant des modules objets et les
  sous-programmes de bibliothèque nécessaires à
  lexécution
• Exécution chargement en mémoire centrale du
  programme exécutable  le chargeur lui donne
  la main

6
Compilateur

• Lit un programme en un langage dit de haut
  niveauC, C, Pascal, Fortran, Ada langage
  source
• Opère en plusieurs phases analyse lexicale,
  analyse syntaxique, génération de code
• Convertit les instructions du programme en
  commandes pour la machine langage machine, dit
  langage cible
• A une instruction du langage source correspondent
  en général plusieurs instructions du langage
  cible.

7
Traduction

• Comment réalise-t-on sur la machine la
  représentation des éléments du langage source ?
• Génération du code
• Utilisation et gestion des registres
• Création du code machine
• Représentation des variables
• Cours 5, TP 5
• variables globales statiques, variables locales
  automatiques
• Sous-programmes
• Représentation
• Appel et retour.

8
Module objet

• Résultat dune compilation ou dun assemblage
• Structure de données
• segments de code machine
• valeurs dinitialisation données
• liste des externes et points dentrée
• informations de contrôle / mise au point
• Format dentrée pour léditeur de liens

9
Module exécutable

• Résultat dune édition de liens
• Structure de données
• segments de code machine
• valeurs dinitialisation des données
• liste des externes et points dentrée
• les externes sont résolus
• informations de contrôle / mise au point
• Format dentrée du chargeur
• Peut contenir des externes non résolus
• chargement dynamique

10
Un langage et son compilateur mcc

• mcc mini C compiler
• Sous-ensemble du langage C
• types de données entiers 16 bits, caractères 8
  bits
• structures de données scalaires, tableaux et
  pointeurs
• Compilateur minimal
• pas de pré processeur
• pas d'optimisation du code généré
• fournit de l'assembleur en format source
• Utilisation
• compilation gt assemblage gt simulation

11
Compilation - 1

• Expressions arithmétiques int a,b,c / var.
  globales / a 2 b 5 c
  (a3)(b-1) ld r2,2 mul
  r3 st.l r2,_at_a ld r2,r1
  ld r2,5 st.l r2,_at_c st.l
  r2,_at_b ld.l r2,_at_a add r2,3 ld.l
  r3,_at_b _at_a data 0 sub r3,1
  _at_b data 0 ld r0,r2 _at_c
  data 0

12
Compilation - 1 notes

• Intervention nécessaire des registres
• Le compilateur traite chaque instruction de
  manière séparée
• Le compilateur utilise R2, R3 selon les besoins
• Renommage des variables
• a devient _at_a dans le code assembleur produit
• ceci permet d'utiliser r2, r3 comme noms de
  variables
• Code produit correct, mais médiocre
• génération indépendante de chaque instruction C
• pas d'optimisation spécifique mise en place

13
Compilation - 2

• Expressions logiques int i,j
  j ilt10 ld.l r2,_at_i ld
  r3,10 cmp r2,r3
  jlt _at_1002 ld r2,0
  jmp _at_1003_at_1002
  ld r2,1_at_1003
  st.l r2,_at_j
• Génération explicite d'une valeur logique 0 ou
  1
• Création d'étiquettes par le compilateur _at_1002

14
Compilation - 3

• Boucles int i i0 while (ilt10)
  ii1 ld r2,0 ld
  r2,1 st.l r2,_at_i _at_1005 _at_1003
  jeq.l _at_1002 ld.l r2,_at_i
  ld.l r2,_at_i ld r3,10
  add r2,1 cmp r2,r3
  st.l r2,_at_i jlt _at_1004 jmp.l
  _at_1003 ld r2,0 _at_1002 jmp
  _at_1005_at_1004 _at_i data 0

15
Compilation - 4

• Programme complet main() 23 _at_1001
  ld r2,2
  add r2,3 halt _at_main
  ld r14,0 ld
  r15,0 jmp.l _at_1001
  start _at_main
• Notes
• positionnement des registres R14 et R15
• instruction d'arrêt

16
Compilation - 5

• Variables globales initialisation int a5,
  b main() b3 _at_1001
  ld r2,3 st.l r2,_at_b
  halt _at_main
  ld r14,0 ld r15,0
  jmp.l _at_1001 start _at_main
  _at_a data 5 _at_b data 0

17
Compilation - 6

• Variables locales initialisation main()
  int a5,b b3 _at_1001
  ld r2,5 st.l r2,-2(r14)
  ld r2,3 st.l
  r2,-4(r14) halt _at_main
  ld r14,0 ld.l
  r15,-4 jmp.l _at_1001 start
  _at_main
• Utilisation de R14 comme registre de base

18
Structure du programme en mémoire
19
Compilation - 7Un exemple PGCD de 2 nombres
int x, y, z main() x 7953 y 12291
while (x ! y) if (x gt y) zx xy
yz y y-x out (x)
20
Le code assembleur
21
Compilation des sous-programmes

• Choix et contraintes
• Passages des paramètres, retour du résultat où,
  et comment ?
• Possibilités registres, pile
• Choix paramètres dans les registres R2, R3, R4
  résultat dans R0
• Représentation des variables locales du
  sous-programme
• Initialisation des variables ?
• Représentation des variables statiques
• Initialisation ?
• Préservation des registres ?
• Qui doit le faire appelant ou appelé ?
• Choix appelé

22
Compilation - 8

• Sous-programmes - Arguments int incr(int
  x) return x1 main() incr(3)
  _at_1001 ld.l r2,-2(r14) _at_1003 ld r2,3
  add r2,1 jsr.l _at_incr
  ld r0,r2 ld r2,r0
  jmp.l _at_1000 halt _at_1000 pop
  r2 _at_main ld r14,0 ld
  r15,r14 ld r15,0 pop
  r14 jmp.l _at_1003 ret
  start _at_main _at_incr push r14
  ld r14,r15 push r2 jmp.l
  _at_1001

23
Compilation - 8 Notes - 1

• Appel du sous-programme paramètre dans R2
• Prologue du sous-programme
• Avant appel
• R23, R140, R150
• Appel empile adresse retour (0x24)
• R150xFFFE
• Exécution du Prologue push r14 ld
  r14,r15 push r2
• Après le prologue
• R140xFFFC, R150xFFFA

24
Compilation - 8 Notes - 2

• Épilogue du sous-programme
• Avant retour
• R04, R23, R14 0xFFFC , R15 0xFFFA
• Exécution de l'épilogue pop r2 ld
  r15,r14 pop r14
• Après l'épilogue
• R04, R23, R140, R150xFFFE
• Retour du sous-programme résultat dans R0
• R04, R23, R140, R150

25
Compilation - 8 Notes - 3

• Registre R14 accès aux arguments
• premier argument -2(R14), deuxième -4(R14),
  etc
• La pile contient
• Adresse de retour
• ici 0x0024
• Sauvegarde registre R14 (registre de base de
  l'appelant)
• Valeur des paramètres
• ici, un seul, R2
• Sauvegarde des registres modifiés par l'appelé
  
• aucune sauvegarde nécessaire dans le cas présent
• Variables locales de l'appelé
• aucune dans le cas présent

26
Compilation - 9

• Sous-programmes - Variables locales int
  sub() int x3 return x1 main()
  sub()

_at_1001 ld r2,3 st.l r2,-2(r14)
ld.l r2,-2(r14) add r2,1 ld
r0,r2 jmp.l _at_1000 _at_1000 pop r2
add r15,2 ld r15,r14
pop r14 ret
_at_sub push r14 ld r14,r15
sub r15,2 push r2 jmp.l _at_1001
27
Compilation - 9 Notes

• Le sous-programme n'a pas de paramètre, mais une
  variable locale  il a besoin d'un registre de
  travail
• Prologue
• Sauvegarde R14 de l'appelant
• Positionne R14 de l'appelé
• Réserve 2 octets pour x
• Sauvegarde R2
• Épilogue
• Opérations inverses

28
Compilation - 10

• Sous-programmes - Variables locales statiques
  int sub() static int x3 return x1
  main() sub()

_at_1001 ld.l r2,_at_1002 add r2,1
ld r0,r2 jmp.l _at_1000 _at_1000 pop
r2 ld r15,r14 pop r14
ret
_at_sub push r14 ld r14,r15
push r2 jmp.l _at_1001 _at_1002 data 3
29
Compilation 10 - Notes

• Une variable locale statiques est similaire à une
  variable globale
• Le compilateur génère un nom unique
• ici, _at_1002 remplace le nom x choisi par
  l'utilisateur

30
Compilation - 11

• Tableau global int tab10 main()
  tab35

_at_1001 ld r2,5 ld
r3,3 sll r3,1 st.l
r2,_at_tab(r3) halt _at_main ld
r14,0 ld r15,0
jmp.l _at_1001 start _at_main _at_tab
bss 20

• Notes
• sll r3,1 permet de passer de l'indice de
  l'élément à un déplacement en octets à
  l'intérieur du tableau
• utilisation de l'adressage indexé

31
Compilation - 12

• Tableau local main() int tab10
  tab35

_at_1001 ld r2,5 ld r3,3
sll r3,1 add r3,r14 st.l
r2,-20(r3) halt _at_main ld
r14,0 ld.l r15,-20 jmp.l
_at_1001 start _at_main

• Notes
• Le tableau est réservé dans la pile
• sll r3,1 permet de passer de l'indice de
  l'élément à un déplacement en octets à
  l'intérieur du tableau
• utilisation de l'adressage indexé une
  instruction machine supplémentaire est
  nécessaire pour accéder à l'élément

32
Compilation - 13

• Tableau passé en paramètre int sub(int
  tab10) return tab3 int tab10
  main() tab35 sub(tab)

_at_1001 ld r2,3 sll r2,1
add.l r2,-2(r14) ld r3,(r2) ld
r0,r3 jmp.l _at_1000 _at_1000 pop r3
pop r2 ld r15,r14 pop
r14 ret _at_sub push r14 ld
r14,r15 push r2 push r3
jmp.l _at_1001 _at_1003 ld r2,5 ld
r3,3 sll r3,1 st.l
r2,_at_tab(r3) la.l r2,_at_tab jsr.l
_at_sub ld r2,r0 halt _at_main ld
r14,0 ld r15,0 jmp.l
_at_1003 start _at_main _at_tab bss 20