Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Architecture des ordinateurs

Cours 6

3 decembre 2012

Archi

1/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Structure dun programme

Archi

2/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

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 op
erandes

Archi

; commentaire

3/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Sections de donn
ees
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
db
dw
dw
l2: dw
l3: dw

0x55
0x55,0x66,0x77
0x1234
a
ab
abc

;
;
;
;
;
;

loctet 0x55
3 octets successifs
0x34 0x12 (little endian)
0x61 0x00
0x61 0x62 (caract`
eres)
0x61 0x62 0x63 0x00 (string)

definir des constantes non modifiables avec la directive : equ

exemple :

nb lettres:

Archi

equ 26

4/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Sections de donn
ees - suite
repeter une declaration avec la directive : times
exemples :
p0: times 100
p1: times 28

db 0
; 100 fois loctet 0x00
dd 0xffffffff ; 28 fois le m^
eme 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:
input2:
input3:

resb
resw
resd

100
1
1

; r
eserve 100 octets
; r
eserve 2 octets
; r
eserve 1 mot (4 octets)

! ! ! Etiquette
= adresse de la donnee.
Archi

5/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Section de code
B Corps du programme : SECTION .text
commencer par declarer global letiquette de debut de
programme (main) pour quelle soit visible :
SECTION .text
global main
main:
...

fin de fichier :
mov
mov
int

ebx, 0
eax, 1
0x80

; code de sortie, 0 = normal

; num
ero de la commande exit
; interruption 80 hex, appel au noyau

Archi

6/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Fichier squelette
%include "asm_io.inc"
SECTION .data
; donn
ees initialis
ees
;
SECTION .bss
; donn
ees non initialis
ees
;
SECTION .text
global main

; rend l
etiquette visible de lext
erieur

main:
; programmme
;
mov ebx,0
mov eax,1
int 0x80

; code de sortie, 0 = normal

; num
ero de la commande exit
; interruption 80 hex, appel au noyau
Archi

7/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Assembler un programme
Assemblage : creer un fichier objet (transformer le programme
ecrit en langage dassemblage 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 biblioth`eques 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

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Entr
ees/Sorties

Archi

9/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Interruptions
Le flot ordinaire dun programme doit pouvoir etre interrompu
pour traiter des ev`enements necessitant une reponse rapide.
Mecanisme dinterruptions (ex : lorsque la souris est deplacee, le
programme en cours est interrompu pour gerer ce deplacement).
Passage du controle `
a un gestionnaire dinterruptions.
Certaine interruptions sont externes (ex : la souris).
Dautres sont soulevees par le processeur, `
a cause dune erreur
(traps) ou dune instruction specifique (interruption logicielle).
En general, le gestionnaire dinterruptions redonne le controle au
programme interrompu, une fois linterrupion traitee.
Il restaure tous les registres (sauf eax).
Le programme interrompu sexecute comme si rien netait arrive.
Les traps arretent generalement le programme.
Archi

10/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Entr
ees/sorties
Entr
ees-sorties (I/O) : echanges dinformations entre le
processeur et les peripheriques.
Entrees : donnees envoyees par un peripherique (disque, reseau,
clavier...) `a destination de lunite centrale.
Sorties : donnees emises par lunite centrale `
a destination dun
peripherique (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 t
ache en cours, effectue laction
prevue pour cette interruption et reprend lexecution du
programme principal l`
a o`
u il lavait laissee.
Gestion haut-niveau :
Biblioth`eques standards en C pour les E/S (pas en assembleur).
MAIS, les conventions dappels utilisees par C sont complexes...
Archi

11/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Affichage par interruption

SECTION .data
msg1:db "message 1",10
lg1: equ $-msg1
SECTION .text
global main
main:
...
mov
mov
mov
mov
int
...

edx,
ecx,
ebx,
eax,
0x80

lg1
msg1
1
; stdout
4
; write

Archi

12/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Affichage en utilisant printf

extern printf
SECTION .data
msg2: db "msg 2", 10, 0

SECTION .text
global main
main:
...
push
call
...

msg2
printf

Archi

13/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Affichage avec ams io.inc

%include "asm_io.inc"
SECTION .data
msg3: db "msg 3", 10, 0

SECTION .text
global main
main:
...
mov eax, msg3
call print_string
...

Archi

14/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Routines dE/S de P. Carter

print int
print char
print string

print nl
read int
read char

affiche `
a lecran la valeur de lentier stocke dans eax
affiche `
a lecran le caract`ere dont le code ASCII est
stocke dans al
affiche `
a lecran le contenu de la chane de caract`eres
a ladresse stockee dans eax. La chane doit etre une
`
chane de type C (terminee par 0)
affiche `
a lecran un caract`ere de nouvelle ligne
lit un entier au clavier et le stocke dans le registre eax
lit un caract`ere au clavier et stocke son code ASCII
dans le registre eax

%include "asm io.inc"

Pour chaque fonction daffichage,
il faut charger eax avec la valeur correcte,
utiliser une instruction call pour linvoquer.

ces fonctions preservent les valeurs de tous les registres,

sauf les deux read qui modifient eax.
Archi

15/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Sous-programmes

Archi

16/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Sous-programmes
Les sous-programmes servent `
a mutualiser du code (eviter les
copier-coller)
Exemple : les fonctions des langages haut niveau.
Le code appelant le sous-programme et le sous-programme
lui-meme doivent se mettre daccord sur la facon de se passer
les donnees (conventions dappel).
Un saut peut etre utilise pour appeler le sous-programme, mais
le retour pose probl`eme.
Le sous-programme peut etre utilise par differentes parties du
programme B il doit revenir au point o`
u il a ete appele !
Donc, le retour du sous-programme ne peut pas etre code en
dur par un saut vers une etiquette.
Letiquette de retour doit etre un param`etre du sous-programme.
Archi

17/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Exemple, sans sous-programme

%include "asm_io.inc"

cmp
jl

SECTION .data
msg1: db "entier <10 ?",10,0
msg2: db "bravo",10,0
msg3: db "perdu",10,0

eax, 10
ok

rate: mov
call
jmp

eax, msg3
print_string
fin

SECTION .text
global main

ok:

mov
call

eax, msg2
print_string

main: mov
call

fin:

mov
mov
int

ebx, 0
eax, 1
0x80

call

eax, msg1
print_string
read_int
Archi

18/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Sous-programme `
a la main
%include "asm_io.inc"
SECTION .data
msg1: db "entier <10 ?",10,0
msg2: db "bravo",10,0
msg3: db "perdu",10,0
SECTION .text
global main
main: mov
call

eax, msg1
print_string

mov
jmp
ret_sb: call

ecx, ret_sb
sb
print_string

fin:

mov
mov
int

ebx, 0
eax, 1
0x80

sb:

cmp
jl
mov
jmp
mov
jmp

eax, 10
ok
eax, msg3
ecx
eax, msg2
ecx

rate:
ok:

call

read_int

Archi

19/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Instructions call et ret

Probl`emes :
Un peu complique
Besoin dautant detiquettes que dappels du sous-programme.
Solution : call et ret
Linstruction call effectue un saut inconditionnel vers un sousprogramme apr`
es avoir empile ladresse de linstruction suivante
push
l2
l1: call
fonction
l2: ...
jmp
fonction
Linstruction ret depile une adresse et saute `
a cette adresse :
ret
pop
reg.
jmp
reg.
Lors de lutilisation de ces instructions, il est tr`es important de
gerer la pile correctement (depiler tout ce quon a empile) afin
que ladresse depilee par linstruction ret soit correcte.
Permet dimbriquer des appels de sous-programmes facilement.
Archi

20/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Sous-programme avec call et ret

%include "asm_io.inc"
SECTION .data
msg1: db "entier <10 ?",10,0
msg2: db "bravo",10,0
msg3: db "perdu",10,0
SECTION .text
global main

call
call

sb
print_string

fin:

mov
mov
int

ebx, 0
eax, 1
0x80

sb:

cmp
jl
mov
ret
mov
ret

eax, 10
ok
eax, msg3

rate:
main: mov
call
call

eax, msg1
print_string

ok:

eax, msg2

read_int
Archi

21/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Passage des param`

etres
! ! Il est tr`es important de depiler toute donnee qui a ete
empilee dans le corps du sous-programme.
Exemple :
plus2:

add
push
ret

eax, 2
eax
; d
epile la valeur de eax !!

Ce code ne reviendra pas correctement !

Autre probl`eme : passage des param`etres par registres

limite le nombre de param`etres ;
mobilise les registres pour les conserver.
Solution : passer les param`etres par la pile (convention de C).
Archi

22/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Passer les param`

etres par la pile
Les param`etres passes par la pile sont empiles avant le call.
Si le param`etre doit etre modifie par le sous-programme, cest
son adresse qui doit etre passee.
Les param`etres sur la pile ne sont pas depiles par le
sous-programme mais accedes depuis la pile elle-meme :
Sinon, comme ils sont empiles avant le call, ladresse de retour
devrait etre depilee avant tout (puis re-empilee ensuite).
Si les param`etres 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 la
donnee en memoire accessible `
a nimporte quel moment.

Lors dun appel de sous-programme : la pile ressemble `a

...
esp
adresse de retour
esp+4
param`etre
Acc`es au param`etre par adressage indirect : [esp+4]
Archi

23/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Passer les param`

etres par la pile - suite
Si la pile est egalement utilisee dans le sous-programme pour
stocker des donnees, le nombre `
a ajouter `
a esp change.
Par exemple, apr`es un push la pile ressemble `a :
...
esp
donnee du sous-programme
esp+4
adresse de retour
esp+8
param`etre
Maintenant, le param`etre est en esp+8, et non plus en esp+4.
esp pour faire reference aux param`etres erreurs possibles.
Pour resoudre ce probl`eme, utiliser ebp (base de la pile).
La convention de C est quun sous-programme commence par
empiler 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

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Passer les param`

etres par la pile - suite
Forme generale dun 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 lancienne valeur de ebp
ret

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

...
...
esp
donnee
esp
ebp
ebp prec.
esp+4
ebp
ebp prec.
esp+4 ebp+4 adr. de retour
esp+8
ebp+4 adr. de retour
esp+8 ebp+8
param`etre
esp+12 ebp+8
param`etre
Le param`etre est accessible avec [ebp+8] depuis nimporte quel
endroit du sous-programme.
Archi

25/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Passer les param`

etres par la pile - fin
Une fois le sous-programme termine, les param`etres qui ont
ete empiles doivent etre retires.
La convention dappel C specifie que cest au code appelant
de le faire (convention differente en Pascal, par exemple).
Un sous-programme utilisant cette convention peut etre
appele comme suit :
push
call
add

param
fnc
esp, 4

; passe un param`
etre
; retire le param`
etre de la pile

La 3`eme ligne retire le param`etre de la pile en manipulant

directement ladresse du sommet de la pile.
Une instruction pop pourrait egalement etre utilisee, mais
le param`etre na pas besoin detre stocke dans un registre.
Archi

26/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Exemple de passage de param`

etre par la pile
%include "asm_io.inc"
SECTION .data
msg1: db "entier <10 ?",10,0
msg2: db "bravo",10,0
msg3: db "perdu",10,0

fin:

sb:

print_string

mov
mov
int

ebx,0
eax,1
0x80

push
mov
cmp
jl
rate: mov
pop
ret
ok:
mov
pop
ret

SECTION .text
global main
main: mov
eax,msg1
call print_string
call read_int
push
call
add

call

eax
sb
esp, 4
Archi

ebp
ebp, esp
dword [ebp+8], 10
ok
eax, msg3
ebp
eax, msg2
ebp
27/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Exemple complet

Archi

28/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Afficher des rayures

On souhaite ecrire un programme qui affiche k rayures
verticales sur n lignes. Les rayures doivent etre dessinees en
utilisant un caract`ere choisi par lutilisateur.

Archi

29/30

Structure dun programme

Entr
ees/Sorties

Sous-programmes

Exemple

Programme
%include "asm_io.inc"
SECTION .data
msg1:db
msg2:db
msg3:db
blanc:

"nb bandes?",10,0
"nb lignes?",10,0
"caractere?",10,0
db "
",0

SECTION .bss
nbb: resd 1
nbl: resd 1
SECTION .text
global main

mov
call
call
mov

eax, msg2
print_string
read_int
[nbl], eax

mov
call
call
call
mov

eax,msg3
print_string
read_char
read_char
ecx, [nbl]

ligne:
push ebp
mov ebp, esp
push ecx

nxt:push
push
call
add
pop

eax
dword [nbb]
ligne
esp, 4
eax

mov
sv: mov
call
mov
call
loop

ecx, [ebp+8]
eax, [ebp+12]
print_char
eax, blanc
print_string
sv

call print_nl
pop ecx

main:
mov
call
call
mov

loop nxt
eax, msg1
print_string
read_int
[nbb], eax

fin:mov ebx, 0
mov eax, 1
int 0x80
Archi

pop
ret

ebp

30/30