Assembleur Rappels d`architecture Mémoire Les registres

Assembleur
Rappels d’architecture
Un ordinateur se compose principalement
d’un processeur,
de m´ emoire.
On y attache ensuite des p´ eriph´ eriques, mais ils sont optionnels.
donn´ ees : disque dur, etc
entr´ ee utilisateur : clavier, souris
sortie utilisateur : ´ ecran, imprimante
processeur suppl´ ementaire : GPU
M´ emoire
Le processeur peut regarder trois zones de m´ emoire :
la zone de code,
la zone de donn´ ees,
la pile.
En th´ eorie, toutes les zones sont accessibles de la mˆ eme fac¸on : on
peut donc enregistrer des variables au milieu du code.
En pratique, non !
Les registres
En plus de cette m´ emoire, le processeur dispose de registres.
en nombre limit´ e : pour MIPS, 32 registres
en taille limit´ ee : 32 ou 64 bits pour la plupart des processeurs
L’acc` es est tr` es rapide. De ce fait, le processeur ne r´ ealise des
op´ erations que sur les registres.
Il faut donc continuellement faire des transferts entre la m´ emoire et
les registres.

Langage machine
Une instruction de langage machine correspond ` a une instruction
possible du processeur. Elle contient donc
un code correspondant ` a op´ eration ` a r´ ealiser,
les arguments de l’op´ eration : valeurs directes, num´ eros de
registres, adresses m´ emoire.
code op op´ erandes
Langage machinemachine lisible
Si on ouvre un fichier ex´ ecutable avec un ´ editeur (hexad´ ecimal), on
obtient
...
01ebe814063727473747566662e6305f5f43544f525f4c
5f05f5f44544f525f4c4953545f5f05f5f4a43525f4c49
53545f5f05f5f646f5f676c6f62616c5f64746f72735f6
75780636f6d706c657465642e36353331064746f725f69
...
C’est une suite d’instructions comme 01ebe814, que l’on peut
traduire directement de fac¸on plus lisible :
add $t7,$t3 ,$sp
C’est ce qu’on appelle l’assembleur.
Assembleur
L’assembleur est donc une repr´esentation du langage machine.
Il y a autant d’assembleurs que de type de processeurs diff´ erents.
En projet, on utilisera l’architecture du processeur (et donc
l’assembleur) MIPS.
de type RISC (Reduced Instruction Set Computer), c’est-` a-dire avec
peu d’instructions disponibles
sorti dans les ann´ ees 1980, utilis´ e jusqu’au d´ ebut 2000
(PlayStation 2)
utilis´ e en informatique embarqu´ ee
´
emulateurs :
spim en ligne de commande,
qtspim en version graphique (pr´ ef´ erable).
mars impl´ ementation en JAVA.
Registres
Un processeur MIPS dispose de 32 registres de 4 octets chacun. On les
distingue des adresses par le signe ’$’.
On travaillera principalement avec les suivants :
num´ ero nom utilit´ e
8-15, 24, 25 $t0-$t9 registres courants
31 $ra adresse de retour (apr` es un saut)
29 $sp pointeur de haut de pile
0$0 la valeur z´ ero
2, 3 $v0,$v1 appel et r´ esultat de routines
4-7 $a0-$a3 arguments des routines

Espace m´ emoire
La zone de m´ emoire de donn´ ees se d´ eclare avec le mot-clef .data.
C’est l` a que l’on stocke les “variables”.
Le “type” des variables renseigne uniquement sur la place en
m´ emoire de chaque variable : ce ne sont en r´ ealit´ e que des
adresses.
Le “type” .space indique simplement que l’on r´ eserve le
nombre d’octet indiqu´ es (sans les mettre ` a z´ ero).
.data
c.byte ’a’ ; octet
n1 .halfword 26 ; 2 octets
n2 .word 353 ; 4 octets
tab .space 40
Programme
La zone m´ emoire du programme est signal´ ee par le mot-clef .text.
.text
li $t1,0
li $t2,100
saut: add $t1,$t1,t2
addi $t2,$t2,-1
bgt $t2,$0,saut
On y lit :
des instructions,
des points d’accroche (saut), c’est-` a-dire des adresses dans le code.
Chargement, sauvegarde
Les instructions commenc¸ant par
lchargent (load) dans les registres,
ssauvegardent (save) un registre en m´ emoire.
Le caract` ere suivant donne la taille (word ou byte), ou bien
immediate pour une valeur directe.
lw $t0,a; charge a dans t0
lb $t1,b; charge le premier octet de b dans t1
sw $t0,a; enregistre t0 dans a
li $t0,5; charge 5 dans t0
L’instruction move se contente de copier les registres.
move $t0,$t1 ; t0 := t1
Op´ erations
La forme g´ en´ erale des instructions binaires est OP $d $s $t qui veut
dire “le registre $d prend la valeur $s OP $t”.
OP peut prendre les valeurs suivantes :
add, sub,
and, or, xor, op´ erations bool´ ennes bit-` a-bit.
Certains ont ´ egalement la variante OPi, o ` u$t est remplac´ e par une
valeur directe.
add $t0,$t1,$t2 ;t0=t1+t2
ori $t0,$t1,1; met le bit de poids faible de
; t1 a 1, puis le stocke dans t0

Op´ erations multiplicatives
Une multiplication de deux entiers ` a 32 bits peut prendre 64 bits.
L’op´ eration mult s´ epare le r´ esultat dans deux registres cach´ es Lo
et Hi. On r´ ecup` ere la valeur avec les op´ erations mflo, mfhi
(move from lo, hi).
L’op´ eration de division utilise ces mˆ emes registres pour
enregistrer le quotient (dans Lo) et le reste (dans Hi).
div $t4,$t5
mflo $t2 ;t2=t4/t5
mfhi $t3 ;t3=t4%t5
mult $t4,$t5
mflo $t0 ; t0 = t4 * t5 si ce n’est pas trop grand
J-commandes : sauts
Les sauts inconditionnels commencent par jcomme jump :
jadresse ; va au label "adresse:"
jal adresse ; enregistre en plus la ligne du programme
; dans ra
jr $t0 ; va a l’adresse de code t0
B-commandes : branchements
Les saut conditionnels s’appellent branchements et commencent donc
par la lettre b.
beq branche (saute) si ´ egal
bne branche si n’est pas ´ egal
bgt branche si sup´ erieur (greater than)
bge branche si sup´ erieur ou ´ egal
blt, ble ... inf´ erieur (less than)
li $t1,0
li $t2,100
saut: add $t1,$t1,t2
addi $t2,$t2,-1
bgt $t2,$0,saut
Que vaut $t1 ` a la fin de ce morceau de code ?
Appels syst` eme
MIPS permet de communiquer avec le syst` eme de fac¸on simple par la
commande syscall. La fonction utilis´ ee est d´ etermin´ ee selon la
valeur de $v0.
$v0 commande argument r´ esultat
1print int $a0 = entier ` a lire
4print string $a0 = adresse de chaˆ ıne
5read int $v0 = entier lu
8read string $a0 = adresse de chaˆ ıne,
$a1 = longueur max
10 exit

Chargement d’adresses
Pour acc´ eder ` a une adresse (un tableau, par exemple), on utilise
l’instruction la (load adress).
Pour acc´ eder ` a la valeur adress´ ee par $t0, on ´ ecrit 0($t0).
On peut ´ egalement acc´ eder aux valeurs environnantes en variant
le num´ ero, comme 4($t0).
On ne peut pas ´ ecrire i($t0), ni $t1($t0), ni 0(tab).
Pour acc´ eder ` a l’indice id’un tableau tab d’entiers de taille 10 :
.data
i: .word 5
tab: .space 40
.text
la $t0,tab
li $t1,i
add $t1,$t1,$t1
add $t1,$t1,$t1
add $t0,$t1,$t0
lw $t2,0($t0)
Chargement d’adresses
La mauvaise nouvelle : on ne peut pas ´ ecrire
.data
a: .word 8
b: .word 0
On se retrouve ` a factoriser toutes les variables.
.data
vars: .word 8
.word 0
Ce n’est pas grave, on a justement une table des symboles !
Chargement d’adresses
nom adresse . . .
a0
b4
On veut calculer a+b, avec ainitialis´ e` a 8, b` a 0.
.data
vars: .word 8
.word 0
.text
la $t0,vars
lw $t1,0($t0)
lw $t2,4($t0)
add $t3,$t1,$t2
Et plus encore ...
Il reste des zones de MIPS que l’on n’utilisera pas :
coprocesseur pour flottants
exceptions (retenue de l’addition, etc ...)
Voir la table de r´ ef´ erence sur la page web du cours.
Par exemple, on pourra utiliser l’op´ eration sll (shift left logical) pour
multiplier les indices de tableau par 4 :
add $t1,$t1,$t1
add $t1,$t1,$t1
sll $t1,$t1,2