Cours Architecture des Systèmes Informatiques

Présentation au sujet: "Cours Architecture des Systèmes Informatiques"— Transcription de la présentation:

1 Cours Architecture des Systèmes Informatiques
Jean-Jacques Girardot Quatrième séance Introduction à la Compilation

2 Plan Concepts des processeurs : la pile
Le simulateur pédagogique, suite… Langage machine, langage d’assemblage 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 Terminologie Source (code, programme) : texte rédigé par le programmeur dans un langage de programmation “évolué” Objet (code, programme) : traduction en langage de la machine d’un texte source Exécutable : programme obtenu en assemblant un programme objet et l’ensemble des sous-programmes nécessaires à son exécution Assembleur : génère du code objet à partir d’un programme en langage d’assemblage (source) Compilateur : génère du code objet à partir d’un programme source en langage de haut niveau (Pascal, C…) Éditeur de liens : rassemble des modules objets pour constituer un programme exécutable Chargeur : installe en mémoire centrale un programme en vue de son exécution

4 La pile du processeur Qu’est-ce, à quoi sert-elle ?
Portion de la mémoire centrale Référencée par un registre spécifique, le “pointeur de pile”, stack pointer “Empiler” une valeur : a: déplacer le pointeur de pile de ± un mot b: écrire la valeur dans le mot désigné par le pointeur de pile Note: certaines machines font b, puis a… “Dépiler” une valeur : effectuer les opérations inverses : b: lire le mot pointé par le registre de pile a: déplacer le pointeur de pile en sens inverse

5 La pile : outil des sous-programmes
Gestion des appels et retour de sous-programmes 2 instructions : Appel de sous-programme : Empiler la valeur du pointeur programme (PC) Se brancher à l’adresse du sous-programme Retour de sous-programme : Dépiler une valeur [le pointeur programme sauvegardé avant l’appel] Affecter cette valeur au pointeur programme

6 La machine mac : opérations sur la pile
Tout registre peut servir de pointeur de pile Empiler : PUSH, 0x0D Rx <- [Rx] - 2 MemW[[Rx]] <- valeur Formats : court/long, immédiat/direct/indirect-indexé Dépiler : POP, 0x0E destination <- MemW[[Rx]] Rx <- [Rx] + 2 Formats : court/long, direct/indirect-indexé [pas de mode immédiat]

7 La machine mac : appels et retour de sous-programme
Appel : JSR, Jump to SubRoutine, 0x0C Rx <- [Rx] - 2 MemW[[Rx]] <- PC PC <- adresse-du-sous-programme Formats : pas de mode court immédiat Retour : RET, Return, 0x1C PC <- MemW[[Rx]] Rx <- [Rx] + 2 Format : court immédiat : xxxx 0000

8 La machine mac : autres opérations
Appel du superviseur : TRAP, 0x1A Format court immédiat : xxxx yyyy Appel niveau X, sous-niveau Y. c.f. manuel pour les différentes fonctions… Opération ineffective : NOP, No OPération, 0x1B Format court immédiat : Ne modifie ni la mémoire, ni les registres Arrêt : HALT, 0x1E Format court immédiat : Arrêt du calculateur, lève l’exception ErrHalt

9 Le simulateur sim Modèle logiciel de la machine mac
Émulateur de la machine virtuelle : Simule registres et mémoire centrale Interprète les codes instructions Gère les erreurs/exceptions Metteur au point Visualise et modifie mémoire et registres Lance et interrompt la machine virtuelle Trace les instructions Visualise les registres modifiés en cours d’exécution

10 Les commandes du simulateur
Syntaxe des commandes Mot clef: /xxx suivi de compléments éventuels Ex : /R2 impression du contenu du registre R2 /PSW impression des drapeaux et de PC /run 2FC0 exécuter le programme débutant en 0x2FC0 /dm imprimer le contenu de la zone de mémoire de 32 octets débutant en 4096 /R2=237 affectation de la valeur 567 à R2 c.f. manuel pour l’ensemble des commandes

11 Exemples Placer la valeur 3 dans le registre R5
Note : constantes en hexadécimal… Écrire un programme qui place 3 dans R5 ld r5,# code : Placer l'instruction en mémoire, par exemple en 0 /addr 0 /sw 0153  Exécuter l'instruction /step 0  Vérifier /r5 

12 Exemple d'utilisation : calcul du PGCD de deux nombres
Programme chargé à l'adresse 1000 TEST: CMP R2,R JEQ FIN F JL SUITE F LD R0,R A 2103 LD R3,R C 2132 LD R2,R E 2120 SUITE: SUB R3,R JMP TEST F FIN: HALT E00

13 Exemple d'utilisation : calcul du PGCD de deux nombres
Mise en mémoire du programme /addr 1000 /sw f f /sw f e00 Positionnement des registres /r2=+7953 /r3=+12291 Lancement de l'exécution /run 1000 réponse : psw = Consultation du résultat /r2 réponse : r2 = 0x02D /723 2,-45 ‘ ‘

14 Tests sous sim Créer sous un éditeur le fichier de commandes
Utilisation directe du simulateur sim < pgcd.sim Utilisation interactive sim /rd "pgcd.sim" /run 0 Mise au point /db 1 : trace des registres modifiés /db 2 : trace des instructions

15 Langage d’assemblage Représentation symbolique des instructions
Syntaxe : [étiquette:] opération [opérandes] Symboles : registres, ex : R1, R2, R15, étiquettes, variables… opérations LD, ADD, SUB, ST… nombres (décimal, hexadécimal, octal, binaire, caractère) Sémantique : combinaison code opération et des opérandes Une instruction assembleur = une instruction machine

16 Assembleur Outil permettant le passage du langage d’assemblage au langage machine ; “machine dependent” Instructions Commentaires Directives ou “pseudo-instructions” DATA, ORG, BSS, START… Fournit : Binaire “absolu”/“core image”/“exécutable” ; ex l’assembleur ASM Binaire “translatable”, ou programme objet.

17 L'assembleur asm Programme réalisant la transformation d'instructions exprimées en assembleur en code chargeable par le simulateur Syntaxe Toutes les instructions de la machine (c.f. manuel) Commentaires : * … Directives : ORG : nouvelle adresse d'implantation des instructions suivantes BSS : réservation d'une zone de mémoire DATA : création d'une donnée initialisée occupant un mot START : définition de l'adresse de début du programme

18 Transformation de PGCD en un programme assembleur
ORG 0x1000 PGCD: CMP R2,R3 JEQ FIN JLT SUITE LD R0,R3 LD R3,R2 LD R2,R0 SUITE: SUB R3,R2 JMP PGCD FIN: RET R15 MAIN: LA.L R15,PILE LD.L R2,#1144 LD.L R3,#858 JSR R15,PGCD LD.L R3,#1287 HALT BSS 16 PILE: DATA 0 START MAIN

19 Le code généré et l’exécution
/addr 1000 /w f f /w f cf0 abf /w a 8cf cf0 1000 /w 1e00 /addr 1042 /w 0000 /run 1018 /rd “pgcd.sim” /run 1018 psw = /r2 r2 = 0x008f 143/ , ‘ ‘

20 Langages de “haut niveau”
Langages compilés Un outil (compilateur) transforme le programme source en un programme objet, ou un programme “core image” Exemples : C, C++, Pascal, FORTRAN, ADA, COBOL, etc. Langage interprété Un outil (interprète) lit le programme source et (après transformations diverses) l’exécute directement. Exemples : APL, LISP, Perl, CAML, etc. Approches intermédiaires - ex: SIM Source ® code machine virtuelle, interprétation du code

21 Étapes de l’exécution d’un programme
Compilation : traduction d’un langage source vers un langage objet Assemblage : traduction d’un programme source en assembleur vers un langage objet Édition de liens : création d’un programme exécutable, rassemblant des modules objets et les sous-programmes de bibliothèque nécessaires à l’exécution Exécution : chargement en mémoire centrale du programme exécutable ; le “chargeur” lui “donne la main”

22 Compilateur Lit un programme en un langage dit “de haut niveau” C, C++, Pascal, Fortran, Ada : langage source 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.

23 Module objet Résultat d’une compilation ou d’un assemblage
Structure de données segments de code machine valeurs d’initialisation données liste des “externes” et “points d’entrée” informations de contrôle / mise au point Format d’entrée pour l’éditeur de liens

24 Module exécutable Résultat d’une édition de liens Structure de données
segments de code machine valeurs d’initialisation des données liste des “externes” et “points d’entrée” les externes sont “résolus” informations de contrôle / mise au point Format d’entrée du chargeur Peut contenir des “externes” non résolus chargement dynamique

25 Traduction Comment réalise-t-on sur la machine la représentation des éléments du langage source ? Variables TP 4 variables globales statiques, variables locales automatiques Sous-programmes Représentation Appel et retour.

26 Un langage et son compilateur : mcc
mcc : “mini C compiler” Sous-ensemble du langage C type de données unique : entier 16 bits pas de structures de données Compilateur minimal pas de pré processeur pas d'optimisation du code généré fournit de l'assembleur en format source Utilisation compilation => assemblage => simulation

27 Compilation - 1 Expressions arithmétiques int a,b,c; a = 2; b = 5; c = (a+3)*(b-1); ld r2,#2 st.l ld r2,#5 st.l ld.l add r2,#3 ld.l sub r3,#1 ld r0,r2 mul r3 ld r2,r1 st.l ... @a: data 0 @b: data 0 @c: data 0

28 Compilation - 2 Boucles int i; i=0; while (i<10) i=i+1; ld r2,#0
st.l @1002: ld.l ld r3,#10 cmp r2,r3 jlt @1004 jmp @1005 @1004: ld r2,#1 @1005: jeq.l @1003 ld.l add r2,#1 st.l jmp @1002 @1003: ... @i: data 0

29 Un exemple : PGCD de 2 nombres
Le programme C int x, y, z; main() { x = 7953; y = 12291; while (x != y) if (x > y) { z=x; x=y; y=z; } y = y-x; } // out (x);

30 Le code assembleur (presque complet)
@main: ld.l r2,#7953 st.l ld.l r2,#12291 st.l @1003: ld.l ld.l cmp r2,r3 ld r2,#0 @1005: ld r2,#1 @1006: @1007: ld r2,#1 @1008: ld.l st.l ld.l st.l ld.l st.l @1002: ld.l sub r2,r3 @1004: halt @a: data 0 @b: data 0 @c: data 0

31 Compilation : sous-programmes
Passer des paramètres aux sous-programmes Valeurs transmises dans les registres R2, R3, R4, R5… Que fait le compilateur ? Le registre R14 est sauvegardé dans la pile Le registre R14 pointe sur la pile à l’entrée du sous-programme Les registres R2, R3, R4… sont empilés Les paramètres sont désignés par -2(R14), -4(R14)… Les valeurs des registres sont restaurées à la sortie du sous-programme Le résultat de la fonction est rendu dans R0 Les sous-programmes peuvent être récursifs.

32 Compilation - 3 Sous-programmes int incr(int x) { return x+1; } main(){ incr(3); } @1000: ld.l r2,-2(r14) add r2,#1 ld r0,r2 jmp.l @1001 @1001: pop r15,r2 ld r15,r14 pop r15,r14 ret r15 @incr: push r15,r14 ld r14,r15 push r15,r2 jmp.l @1000 @1002: ld r2,#3 jsr.l r15,incr ld r2,r0 halt main: ld r14,#0 ld r15,#0 jmp.l @1002 start main