archi_cours6

Structure d’un programme Entrees/Sorties Sous-programmes Exemple

Architecture des ordinateurs

Cours 6

3 decembre 2012

Archi 1/30


Structure d’un programme

Archi 2/30


Programme en Assembleur

programme en assembleur = fichier texte (extension .asm)

organise en plusieurs SECTIONS (= segments)

sections differentes pour les donnees et le code

directives pour NASM 6= instructions pour le processeur

une seule instruction par ligne, separateur = chgt de ligne

1 ligne de code = 4 champs (certains optionnels) :

etiquette: instruction operandes ; commentaire

Archi 3/30


Sections de donnees

B Donnees initialisees : SECTION .data

declarer des donnees initialisees 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 (caracteres)

l3: dw ’abc’ ; 0x61 0x62 0x63 0x00 (string)

definir des constantes non modifiables avec la directive : equ

exemple : nb lettres: equ 26

Archi 4/30


Sections de donnees - suite

repeter une declaration avec la directive : times

exemples :

p0: times 100 db 0 ; 100 fois l’octet 0x00

p1: times 28 dd 0xffffffff ; 28 fois le meme mot

B Donnees non initialisees : SECTION .bss

declarer des donnees non initialisees avec la directive : resX

X = b (1 octet), w (2 octets) ou d (4 octets = 1 mot).

exemples (etiquettes obligatoires) :

input1: resb 100 ; reserve 100 octets

input2: resw 1 ; reserve 2 octets

input3: resd 1 ; reserve 1 mot (4 octets)

! ! ! Etiquette = adresse de la donnee.

Archi 5/30


Section de code

B Corps du programme : SECTION .text

commencer par declarer global l’etiquette de debut deprogramme (main) pour qu’elle soit visible :

SECTION .text

global main

main:

...

fin de fichier :

mov ebx, 0 ; code de sortie, 0 = normal

mov eax, 1 ; numero de la commande exit

int 0x80 ; interruption 80 hex, appel au noyau

Archi 6/30


Fichier squelette

%include "asm_io.inc"

SECTION .data

; donnees initialisees

;

SECTION .bss

; donnees non initialisees

;

SECTION .text

global main ; rend l’etiquette visible de l’exterieur

main:

; programmme

;

mov ebx,0 ; code de sortie, 0 = normal

mov eax,1 ; numero de la commande exit

int 0x80 ; interruption 80 hex, appel au noyau

Archi 7/30


Assembler un programme

Assemblage : creer un fichier objet (transformer le programmeecrit 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

Edition de lien :

ld -e main toto.o -o toto

En utilisant des bibliotheques C ou ecrites 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


Entrees/Sorties

Archi 9/30


Interruptions

Le flot ordinaire d’un programme doit pouvoir etre interrompupour traiter des evenements necessitant une reponse rapide.

Mecanisme d’interruptions (ex : lorsque la souris est deplacee, leprogramme en cours est interrompu pour gerer ce deplacement).

Passage du controle a un gestionnaire d’interruptions.

Certaine interruptions sont externes (ex : la souris).

D’autres sont soulevees par le processeur, a cause d’une erreur(traps) ou d’une instruction specifique (interruption logicielle).

En general, le gestionnaire d’interruptions redonne le controle auprogramme interrompu, une fois l’interrupion traitee.

Il restaure tous les registres (sauf eax).

Le programme interrompu s’execute comme si rien n’etait arrive.

Les traps arretent generalement le programme.

Archi 10/30


Entrees/sorties

Entrees-sorties (I/O) : echanges d’informations entre leprocesseur et les peripheriques.

Entrees : donnees envoyees par un peripherique (disque, reseau,clavier...) a destination de l’unite centrale.Sorties : donnees emises par l’unite centrale a destination d’unperipherique (disque, reseau, ecran...).

Gestion par interruptions :

permet de reagir rapidement a un changement en entree.le peripherique previent le processeur par une interruption,le processeur interrompt la tache en cours, effectue l’actionprevue pour cette interruption et reprend l’execution duprogramme principal la ou il l’avait laissee.

Gestion “haut-niveau” :

Bibliotheques standards en C pour les E/S (pas en assembleur).MAIS, les conventions d’appels utilisees par C sont complexes...

Archi 11/30


Affichage par interruption

SECTION .data

msg1:db "message 1",10

lg1: equ $-msg1

SECTION .text

global main

main:

...

mov edx, lg1

mov ecx, msg1

mov ebx, 1 ; stdout

mov eax, 4 ; write

int 0x80

...

Archi 12/30


Affichage en utilisant printf

extern printf

SECTION .data

msg2: db "msg 2", 10, 0

SECTION .text

global main

main:

...

push msg2

call printf

...

Archi 13/30


Affichage avec ams io.inc


SECTION .data

msg3: db "msg 3", 10, 0

SECTION .text

global main

main:

...

mov eax, msg3

call print_string

...

Archi 14/30


Routines d’E/S de P. Carter

print int affiche a l’ecran la valeur de l’entier stocke dans eax

print char affiche a l’ecran le caractere dont le code ASCII eststocke dans al

print string affiche a l’ecran le contenu de la chaıne de caracteresa l’adresse stockee dans eax. La chaıne doit etre unechaıne de type C (terminee par 0)

print nl affiche a l’ecran un caractere de nouvelle ligne

read int lit un entier au clavier et le stocke dans le registre eaxread char lit un caractere au clavier et stocke son code ASCII

dans le registre eax

%include "asm io.inc"

Pour chaque fonction d’affichage,

il faut charger eax avec la valeur correcte,utiliser une instruction call pour l’invoquer.

ces fonctions preservent les valeurs de tous les registres,sauf les deux read qui modifient eax.

Archi 15/30


Sous-programmes

Archi 16/30


Sous-programmes

Les sous-programmes servent a mutualiser du code (eviter lescopier-coller)

Exemple : les fonctions des langages haut niveau.

Le code appelant le sous-programme et le sous-programmelui-meme doivent se mettre d’accord sur la facon de se passerles donnees (conventions d’appel).

Un saut peut etre utilise pour appeler le sous-programme, maisle retour pose probleme.

Le sous-programme peut etre utilise par differentes parties duprogramme B il doit revenir au point ou il a ete appele !

Donc, le retour du sous-programme ne peut pas etre code “endur” par un saut vers une etiquette.

L’etiquette de retour doit etre un parametre du sous-programme.

Archi 17/30


Exemple, sans sous-programme


SECTION .data

msg1: db "entier <10 ?",10,0

msg2: db "bravo",10,0

msg3: db "perdu",10,0

SECTION .text

global main

main: mov eax, msg1

call print_string

call read_int

cmp eax, 10

jl ok

rate: mov eax, msg3

call print_string

jmp fin

ok: mov eax, msg2

call print_string

fin: mov ebx, 0

mov eax, 1

int 0x80

Archi 18/30


Sous-programme “a la main”


SECTION .data

msg1: db "entier <10 ?",10,0



SECTION .text

global main

main: mov eax, msg1

call print_string

call read_int

mov ecx, ret_sb

jmp sb

ret_sb: call print_string

fin: mov ebx, 0

mov eax, 1

int 0x80

sb: cmp eax, 10

jl ok

rate: mov eax, msg3

jmp ecx

ok: mov eax, msg2

jmp ecx

Archi 19/30


Instructions call et ret

Problemes :

Un peu complique

Besoin d’autant d’etiquettes que d’appels du sous-programme.

Solution : call et ret

L’instruction call effectue un saut inconditionnel vers un sous-programme apres avoir empile l’adresse de l’instruction suivantel1: call fonction push l2

l2: ... jmp fonction

L’instruction ret depile une adresse et saute a cette adresse :ret pop reg.

jmp reg.

Lors de l’utilisation de ces instructions, il est tres important degerer la pile correctement (depiler tout ce qu’on a empile) afinque l’adresse depilee par l’instruction ret soit correcte.

Permet d’imbriquer des appels de sous-programmes facilement.Archi 20/30


Sous-programme avec call et ret


SECTION .data

msg1: db "entier <10 ?",10,0



SECTION .text

global main

main: mov eax, msg1

call print_string

call read_int

call sb

call print_string

fin: mov ebx, 0

mov eax, 1

int 0x80

sb: cmp eax, 10

jl ok

rate: mov eax, msg3

ret

ok: mov eax, msg2

ret

Archi 21/30


Passage des parametres

! ! Il est tres important de depiler toute donnee qui a eteempilee dans le corps du sous-programme.

Exemple :

plus2: add eax, 2

push eax

ret ; depile la valeur de eax !!

Ce code ne reviendra pas correctement !

Autre probleme : passage des parametres par registres

limite le nombre de parametres ;

mobilise les registres pour les conserver.

Solution : passer les parametres par la pile (convention de C).

Archi 22/30


Passer les parametres par la pile

Les parametres passes par la pile sont empiles avant le call.

Si le parametre doit etre modifie par le sous-programme, c’estson adresse qui doit etre passee.

Les parametres sur la pile ne sont pas depiles par lesous-programme mais accedes depuis la pile elle-meme :

Sinon, comme ils sont empiles avant le call, l’adresse de retourdevrait etre depilee avant tout (puis re-empilee ensuite).Si les parametres sont utilises a plusieurs endroits :B ca evite de les conserver dans un registre ;B les laisser sur la pile permet de conserver une copie de ladonnee en memoire accessible a n’importe quel moment.

Lors d’un appel de sous-programme : la pile ressemble a...

esp adresse de retouresp+4 parametre

Acces au parametre par adressage indirect : [esp+4]

Archi 23/30


Passer les parametres par la pile - suite

Si la pile est egalement utilisee dans le sous-programme pourstocker des donnees, le nombre a ajouter a esp change.

Par exemple, apres un push la pile ressemble a :...

esp donnee du sous-programmeesp+4 adresse de retouresp+8 parametre

Maintenant, le parametre est en esp+8, et non plus en esp+4.

esp pour faire reference aux parametres ⇒ erreurs possibles.

Pour resoudre ce probleme, utiliser ebp (base de la pile).

La convention de C est qu’un sous-programme commence parempiler la valeur de ebp puis affecte a ebp la valeur de esp.

Permet a esp de changer sans modifier ebp.

A la fin du programme, la valeur originale de ebp est restauree.

Archi 24/30


Passer les parametres par la pile - suite

Forme generale 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

ret

La pile au debut du code du sous-programme ressemble a

...esp ebp ebp prec.esp+4 ebp+4 adr. de retouresp+8 ebp+8 parametre

...esp donneeesp+4 ebp ebp prec.esp+8 ebp+4 adr. de retouresp+12 ebp+8 parametre

Le parametre est accessible avec [ebp+8] depuis n’importe quelendroit du sous-programme.

Archi 25/30


Passer les parametres par la pile - fin

Une fois le sous-programme termine, les parametres qui ontete empiles doivent etre retires.

La convention d’appel C specifie que c’est au code appelantde le faire (convention differente en Pascal, par exemple).

Un sous-programme utilisant cette convention peut etreappele comme suit :

push param ; passe un parametre

call fnc

add esp, 4 ; retire le parametre de la pile

La 3eme ligne retire le parametre de la pile en manipulantdirectement l’adresse du sommet de la pile.

Une instruction pop pourrait egalement etre utilisee, maisle parametre n’a pas besoin d’etre stocke dans un registre.

Archi 26/30


Exemple de passage de parametre par la pile


SECTION .data

msg1: db "entier <10 ?",10,0



SECTION .text

global main

main: mov eax,msg1

call print_string

call read_int

push eax

call sb

add esp, 4

call print_string

fin: mov ebx,0

mov eax,1

int 0x80

sb: push ebp

mov ebp, esp

cmp dword [ebp+8], 10

jl ok

rate: mov eax, msg3

pop ebp

ret

ok: mov eax, msg2

pop ebp

ret

Archi 27/30


Exemple complet

Archi 28/30


Afficher des rayures

On souhaite ecrire un programme qui affiche k rayuresverticales sur n lignes. Les rayures doivent etre dessinees enutilisant un caractere choisi par l’utilisateur.

Archi 29/30


Programme


SECTION .data

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

SECTION .text

global main

main:

mov eax, msg1

call print_string

call read_int

mov [nbb], eax

mov eax, msg2

call print_string

call read_int

mov [nbl], eax

mov eax,msg3

call print_string

call read_char

call read_char

mov ecx, [nbl]

nxt:push eax

push dword [nbb]

call ligne

add esp, 4

pop eax

loop nxt

fin:mov ebx, 0

mov eax, 1

int 0x80

ligne:

push ebp

mov ebp, esp

push ecx

mov ecx, [ebp+8]

sv: mov eax, [ebp+12]

call print_char

mov eax, blanc

call print_string

loop sv

call print_nl

pop ecx

pop ebp

ret

Archi 30/30

Documents

archi_cours6