Structure d un programme

Architecture des ordinateurs Cours 6 Structure d un programme 3 décembre 2012 Archi 1/30 Programme en Assembleur Archi 2/30 Sections de données programme en assembleur = fichier texte (extension.asm) organisé en plusieurs SECTIONS (= segments) sections différentes pour les données et le code directives pour NASM instructions pour le processeur une seule instruction par ligne, séparateur = chgt de ligne 1 ligne de code = 4 champs (certains optionnels) : étiquette: instruction opérandes ; commentaire Données initialisées : déclarer des données initialisées avec la directive : dx X = b (1 octet), w (2 octets) ou d (4 octets = 1 mot). exemples : l1: db 0x55 ; l octet 0x55 db 0x55,0x66,0x77 ; 3 octets successifs dw 0x1234 ; 0x34 0x12 (little endian) dw a ; 0x61 0x00 l2: dw ab ; 0x61 0x62 (caractères) l3: dw abc ; 0x61 0x62 0x63 0x00 (string) définir des constantes non modifiables avec la directive : equ exemple : nb lettres: equ 26 Archi 3/30 Archi 4/30

Sections de données - suite Section de code répéter une déclaration avec la directive : times exemples : p0: times 100 db 0 ; 100 fois l octet 0x00 p1: times 28 dd 0xffffffff ; 28 fois le m^eme mot Données non initialisées : SECTION.bss déclarer des données non initialisées avec la directive : resx X = b (1 octet), w (2 octets) ou d (4 octets = 1 mot). exemples (étiquettes obligatoires) : input1: resb 100 ; réserve 100 octets input2: resw 1 ; réserve 2 octets input3: resd 1 ; réserve 1 mot (4 octets)!!! Étiquette = adresse de la donnée. Corps du programme : commencer par déclarer global l étiquette de début de programme (main) pour qu elle soit visible : fin de fichier : mov ebx, 0 ; code de sortie, 0 = normal mov eax, 1 ; numéro de la commande exit ; interruption 80 hex, appel au noyau Archi 5/30 Fichier squelette ; données initialisées ; SECTION.bss ; données non initialisées ; ; rend l étiquette visible de l extérieur ; programmme ; mov ebx,0 ; code de sortie, 0 = normal mov eax,1 ; numéro de la commande exit ; interruption 80 hex, appel au noyau Archi 7/30 Archi 6/30 Assembler un programme Assemblage : créer un fichier objet (transformer le programme écrit en langage d assemblage en instructions machine) nasm -g -f <format> <fichier> [-o <sortie>] Exemples : nasm -g -f coff toto.asm nasm -g -f elf toto.asm -o toto.o Produire un listing des instructions machine : nasm -g -f elf toto.asm -l toto.lst Édition de lien : ld -e main toto.o -o toto En utilisant des bibliothèques C ou écrites en C (par exemple, asm io de P. Carter, pour les E/S) : nasm -g -f elf toto.asm gcc toto.o asm_io.o -o toto Archi 8/30

Interruptions Entrées/Sorties Le flot ordinaire d un programme doit pouvoir être interrompu pour traiter des évènements nécessitant une réponse rapide. Mécanisme d interruptions (ex : lorsque la souris est déplacée, le programme en cours est interrompu pour gérer ce déplacement). Passage du contrôle à un gestionnaire d interruptions. Certaine interruptions sont externes (ex : la souris). D autres sont soulevées par le processeur, à cause d une erreur (traps) ou d une instruction spécifique (interruption logicielle). En général, le gestionnaire d interruptions redonne le contrôle au programme interrompu, une fois l interrupion traitée. Il restaure tous les registres (sauf eax). Le programme interrompu s exécute comme si rien n était arrivé. Les traps arrêtent généralement le programme. Archi 9/30 Entrées/sorties Entrées-sorties (I/O) : échanges d informations entre le processeur et les périphériques. Entrées : données envoyées par un périphérique (disque, réseau, clavier) à destination de l unité centrale. Sorties : données émises par l unité centrale à destination d un périphérique (disque, réseau, écran). Gestion par interruptions : permet de réagir rapidement à un changement en entrée. le périphérique prévient le processeur par une interruption, le processeur interrompt la tâche en cours, effectue l action prévue pour cette interruption et reprend l exécution du programme principal là où il l avait laissée. Gestion haut-niveau : Bibliothèques standards en C pour les E/S (pas en assembleur). MAIS, les conventions d appels utilisées par C sont complexes Archi 11/30 Archi 10/30 Affichage par interruption msg1:db "message 1",10 lg1: equ $-msg1 mov edx, lg1 mov ecx, msg1 mov ebx, 1 ; stdout mov eax, 4 ; write Archi 12/30

Affichage en utilisant printf Affichage avec ams io.inc extern printf msg2: db "msg 2", 10, 0 msg3: db "msg 3", 10, 0 push msg2 printf mov eax, msg3 Archi 13/30 Routines d E/S de P. Carter Archi 14/30 print int print char print string print nl read int read char affiche à l écran la valeur de l entier stocké dans eax affiche à l écran le caractère dont le code ASCII est stocké dans al affiche à l écran le contenu de la chaîne de caractères à l adresse stockée dans eax. La chaîne doit être une chaîne de type C (terminée par 0) affiche à l écran un caractère de nouvelle ligne lit un entier au clavier et le stocke dans le registre eax lit un caractère au clavier et stocke son code ASCII dans le registre eax Sous-programmes %include "asm io.inc" Pour chaque fonction d affichage, il faut charger eax avec la valeur correcte, utiliser une instruction pour l invoquer. ces fonctions préservent les valeurs de tous les registres, sauf les deux read qui modifient eax. Archi 15/30 Archi 16/30

Sous-programmes Exemple, sans sous-programme Les sous-programmes servent à mutualiser du code (éviter les copier-coller) Exemple : les fonctions des langages haut niveau. Le code appelant le sous-programme et le sous-programme lui-même doivent se mettre d accord sur la façon de se passer les données (conventions d appel). Un saut peut être utilisé pour appeler le sous-programme, mais le our pose problème. Le sous-programme peut être utilisé par différentes parties du programme il doit revenir au point où il a été appelé! Donc, le our du sous-programme ne peut pas être codé en dur par un saut vers une étiquette. L étiquette de our doit être un paramètre du sous-programme. msg1: db "entier <10?",10,0 msg2: db "bravo",10,0 msg3: db "perdu",10,0 mov eax, msg1 read_int rate: mov jmp cmp eax, 10 jl ok eax, msg3 fin ok: mov eax, msg2 fin: mov ebx, 0 mov eax, 1 Archi 17/30 Sous-programme à la main msg1: db "entier <10?",10,0 msg2: db "bravo",10,0 msg3: db "perdu",10,0 mov eax, msg1 read_int mov jmp _sb: ecx, _sb sb fin: mov ebx, 0 mov eax, 1 sb: cmp eax, 10 jl ok rate: mov eax, msg3 jmp ecx ok: mov eax, msg2 jmp ecx Archi 19/30 Archi 18/30 Instructions et Problèmes : Un peu compliqué Besoin d autant d étiquettes que d appels du sous-programme. Solution : et L instruction effectue un saut inconditionnel vers un sousprogramme après avoir empilé l adresse de l instruction suivante l1: fonction push l2 l2: jmp fonction L instruction dépile une adresse et saute à cette adresse : pop reg. jmp reg. Lors de l utilisation de ces instructions, il est très important de gérer la pile correctement (dépiler tout ce qu on a empilé) afin que l adresse dépilée par l instruction soit correcte. Permet d imbriquer des appels de sous-programmes facilement. Archi 20/30

Sous-programme avec et Passage des paramètres msg1: db "entier <10?",10,0 msg2: db "bravo",10,0 msg3: db "perdu",10,0 mov eax, msg1 read_int sb fin: mov ebx, 0 mov eax, 1 sb: cmp eax, 10 jl ok rate: mov eax, msg3 ok: mov eax, msg2!! Il est très important de dépiler toute donnée qui a été empilée dans le corps du sous-programme. Exemple : plus2: add eax, 2 push eax ; dépile la valeur de eax!! Ce code ne reviendra pas correctement! Autre problème : passage des paramètres par registres limite le nombre de paramètres ; mobilise les registres pour les conserver. Solution : passer les paramètres par la pile (convention de C). Archi 21/30 Passer les paramètres par la pile Archi 22/30 Passer les paramètres par la pile - suite Les paramètres passés par la pile sont empilés avant le. Si le paramètre doit être modifié par le sous-programme, c est son adresse qui doit être passée. Les paramètres sur la pile ne sont pas dépilés par le sous-programme mais accédés depuis la pile elle-même : Sinon, comme ils sont empilés avant le, l adresse de our devrait être dépilée avant tout (puis ré-empilée ensuite). Si les paramètres sont utilisés à plusieurs endroits : ça évite de les conserver dans un registre ; les laisser sur la pile permet de conserver une copie de la donnée en mémoire accessible à n importe quel moment. Lors d un appel de sous-programme : la pile ressemble à esp adresse de our esp+4 paramètre Accès au paramètre par adressage indirect : [esp+4] Archi 23/30 Si la pile est également utilisée dans le sous-programme pour stocker des données, le nombre à ajouter à esp change. Par exemple, après un push la pile ressemble à : esp donnée du sous-programme esp+4 adresse de our esp+8 paramètre Maintenant, le paramètre est en esp+8, et non plus en esp+4. esp pour faire référence aux paramètres erreurs possibles. Pour résoudre ce problème, utiliser ebp (base de la pile). La convention de C est qu un sous-programme commence par empiler la valeur de ebp puis affecte à ebp la valeur de esp. Permet à esp de changer sans modifier ebp. A la fin du programme, la valeur originale de ebp est restaurée. Archi 24/30

Passer les paramètres par la pile - suite Passer les paramètres par la pile - fin Forme générale d un sous-programme qui suit ces conventions : etiquette sousprogramme: push ebp ; empile la valeur originale de ebp mov ebp, esp ; ebp = esp ; code du sous-programme pop ebp ; restaure l ancienne valeur de ebp La pile au début du code du sous-programme ressemble à esp donnée esp ebp ebp prec. esp+4 ebp ebp prec. esp+4 ebp+4 adr. de our esp+8 ebp+4 adr. de our esp+8 ebp+8 paramètre esp+12 ebp+8 paramètre Le paramètre est accessible avec [ebp+8] depuis n importe quel endroit du sous-programme. Archi 25/30 Exemple de passage de paramètre par la pile Une fois le sous-programme terminé, les paramètres qui ont été empilés doivent être irés. La convention d appel C spécifie que c est au code appelant de le faire (convention différente en Pascal, par exemple). Un sous-programme utilisant cette convention peut être appelé comme suit : push param ; passe un paramètre fnc add esp, 4 ; ire le paramètre de la pile La 3ème ligne ire le paramètre de la pile en manipulant directement l adresse du sommet de la pile. Une instruction pop pourrait également être utilisée, mais le paramètre n a pas besoin d être stocké dans un registre. Archi 26/30 msg1: db "entier <10?",10,0 msg2: db "bravo",10,0 msg3: db "perdu",10,0 mov eax,msg1 read_int push eax sb add esp, 4 fin: mov ebx,0 mov eax,1 sb: push ebp mov ebp, esp cmp dword [ebp+8], 10 jl ok rate: mov eax, msg3 pop ebp ok: mov eax, msg2 pop ebp Exemple complet Archi 27/30 Archi 28/30

Afficher des rayures Programme On souhaite écrire un programme qui affiche k rayures verticales sur n lignes. Les rayures doivent être dessinées en utilisant un caractère choisi par l utilisateur. msg1:db "nb bandes?",10,0 msg2:db "nb lignes?",10,0 msg3:db "caractere?",10,0 blanc: db " ",0 SECTION.bss nbb: resd 1 nbl: resd 1 mov eax, msg1 read_int mov [nbb], eax mov eax, msg2 read_int mov [nbl], eax mov eax,msg3 read_char read_char mov ecx, [nbl] nxt:push eax push dword [nbb] ligne add esp, 4 pop eax loop nxt fin:mov ebx, 0 mov eax, 1 ligne: push ebp mov ebp, esp push ecx mov ecx, [ebp+8] sv: mov eax, [ebp+12] print_char mov eax, blanc loop sv print_nl pop ecx pop ebp Archi 29/30 Archi 30/30