cours Architecture des ordinateurs: programmation assembleur
Introduction 2
La conception d’un processeur faire des choix
concernant son jeu d’instruction. Ces choix sont conditionnés par: Le nombre de transistors Compatibilité avec les modèles précédents La performance souhaitée L’inclusion de nouvelles fonctionnalités (traitement vidéo) Le jeu d’instructions d’un processeur est représenté par des instructions assembleur. cours Architecture des ordinateurs: programmation assembleur Introduction 3
On utilise la programmation assembleur :
Le développement des pilotes logiciels Programmation des systèmes embarqués (carte à puce) Application temps réel (performance maximale). Types d’instructions : Transfert de données Opérations arithmétiques et logique Décalages et rotation Ruptures de séquences
cours Architecture des ordinateurs: programmation assembleur
Modèle de processeur 4
Processeur 32 bits contenant :
Une UAL entière 32 registres généraux de 32 bits (r0, …, r31) Un compteur ordinal sur 32 bits Un registre d’état contenant les bits Z, V, C et N. Une mémoire pour stocker les instructions et les données Les seuls instructions faisant référence à la mémoire sont les transferts de données. Mode d’adressage direct, immédiat et indirect
cours Architecture des ordinateurs: programmation assembleur
Transfert de données 5
Transferts registre – mémoire ou registre – registre.
Les transferts mémoire – mémoire sont interdites. Exemple MOV rx, ry rx ry Le registre rx reçoit la valeur contenue dans ry MVI rx, #i rx i Le registre rx reçoit la valeur immédiate i LDB rx, (ry) rx Mem[ry]8 le registre rx reçoit l’octet mémoire dont l’adresse est dans ry (LoaD Byte) LDH rx, (ry) rx Mem[ry]16 le registre rx reçoit les deux octets mémoire dont l’adresse est dans ry (LoaD Half word)
cours Architecture des ordinateurs: programmation assembleur
Transfert de données 6
LDW rx, (ry) rx Mem[ry]32
le registre rx reçoit les quatre octets mémoire dont l’adresse est dans ry (LoaD word) STB (rx), ry Mem[rx]8 ry L’octet de poids faible de ry est stocké en mémoire à l’adresse contenu dans rx (Store Byte). STH (rx), ry Mem[rx]16 ry Les deux octets de poids faible de ry sont stockés en mémoire à l’adresse contenu dans rx (Store Half word). STW (rx), ry Mem[rx]32 ry Les quatre octets de ry sont stockés en mémoire à l’adresse contenu dans rx (Store Word).
cours Architecture des ordinateurs: programmation assembleur
Transfert de données 7
L’instruction MVI utilise l’adressage immédiat.
La valeur donnée en décimal. Valeur négative, on utilise le codage Cà2 #-1 #0xffff Les caractères sont représentés entre apostrophes. Un caractère est remplacé par son code ASCII #’A’ #65
cours Architecture des ordinateurs: programmation assembleur
Opérations arithmétiques et logiques 8
Addition ADD rx, ry, rz rx ry+rz ADD rx, ry, #i rx ry+i Soustraction SUB rx, ry, rz rx ry-rz SUB rx, ry, #i rx ry-i Multiplication MUL rx, ry, rz rx ry x rz MUL rx, ry, #i rx ry x i cours Architecture des ordinateurs: programmation assembleur Opérations arithmétiques et logiques 9
Division DIV rx, ry, rz DIV rx, ry, #i Et logique AND rx, ry, rz AND rx, ry, #i Ou logique OR rx, ry, rz OR rx, ry, #i Ou exlusif XOR rx, ry, rz XOR rx, ry, #i Complémentaire NOT rx, ry NOT rx, #i Opposé arithmétique NEGcours rx,Architecture ry NEG rx, #i programmation assembleur des ordinateurs: Décalages et rotations 10
Effectuer rapidement des multiplications ou divisions par
2 Si rz ou i positif LRT rx, ry, rz LRT rx, ry, #i rx<- ry décalé par rotation vers la gauche rz fois (ou i fois) (Left Rotate) . Les bits de poids faible sont remplacés par les plus forts. LLS rx, ry, rz LLS rx, ry, #i rx<- ry décalé vers la gauche rz fois (ou i fois) (Logical Left Shift). Les bits de poids faible sont remplacés par des 0. cours Architecture des ordinateurs: programmation assembleur Décalages et rotations 11
ALS rx, ry, rz ALS rx, ry, #i
rx<- ry décalé vers la gauche rz fois (ou i fois) (Arithmetical Left Shift). Cette instruction garde le signe de rx. Si rz ou i négatif, le décalage ou la rotation sera à droite. Les bits Z et N se positionnent comme d’habitude. Le bit V est toujours mis à 0. Le bit C est au dernier bit décalé de ry.
cours Architecture des ordinateurs: programmation assembleur
Ruptures de séquences 12
JMP Adr PC<-Adr : saut inconditionnel à Adr (jump) JZ rx, Adr PC<-Adr si rx=0 (jump if zero) JNZ rx, Adr PC<-Adr si rx≠0 (jump if not zero) JGT rx, Adr PC<-Adr si rx>0 (jump if greater than zero)
cours Architecture des ordinateurs: programmation assembleur
Ruptures de séquences 13
JLT rx, Adr
PC<-Adr si rx<0 (jump if rx less than zero) JGE rx, Adr PC<-Adr si rx≥0 (jump if rx greater or equal to zero) JLE rx, Adr PC<-Adr si rx ≤0 (jump if rx less or equal to zero) CCR rx rx<- bit C : le bit C du registre d’état est mis dans le bit de poids faible de rx. Les autres bits de rx sont mis à 0 (Copy bit C into Registre) cours Architecture des ordinateurs: programmation assembleur Ruptures de séquences 14
CZR rx Copy bit Z into registre CNR rx Copy bit N into registre CVR rx Copy bit V into registre Exemple : Les instructions de copie permettent de tester une condition dans structure conditionnelle. CVR ro JNZ ro, etiquette_debordement //On continue s’il n’y a pas débordement
cours Architecture des ordinateurs: programmation assembleur
Format des instructions 15
Quatre familles d’instructions:
Les instructions à trois données. ADD r0, r1, r2 Les instructions à deux registres. MOV r0, r1 Les instructions à un registre et une valeur immédiate. MVI r0, #0 Les instructions à un seul registre. CCR r0 Instructions à trois données: 5 bits code de l’opération. 5 bits pour coder un registre (32 registres) 1 bit pour indiquer le type d’adressage (immédiat ou bien par registre) 16 bits pour la troisième donnée (immédiat/ registre)
cours Architecture des ordinateurs: programmation assembleur
Format des instructions 16
Code opération à trois données :
Les 5 premiers bits donnent le code opération de l’instruction suivant le tableau
ci-après (qui liste les 4 bits restant à déterminer). Le premier bit est à 0 pour indiquer au processeur une opération de ce type. Le bit i est à 0 si les 16 derniers bits donnent un numéro de registre, à 1 si c’est une valeur immédiate. Les deux champs de 5 bits qui suivent correspondent au numéro des registres destination (rX) et première source (rY). Comme elles appartiennent à la même famille d’opérations arithmétiques, et bien qu’elles n’aient que deux données, on a inclus les deux instructions NEG et NOT ; dans ce cas, le processeur ignore le champ rY.
cours Architecture des ordinateurs: programmation assembleur
Format des instructions 17
Code opération à trois données :
cours Architecture des ordinateurs: programmation assembleur
Le premier correspond à ADD r0,r1,r2 : on remplace le premier champ par les 4 bits donnant le codage de ADD (0000), puis chacun des trois champs de données contient le numéro en binaire du registre correspondant. Pour finir, on met un 0 dans le bit indiquant si la dernière valeur est immédiate (car ici c’est un registre). Le second exemple est similaire : 0110 est le code de XOR, le bit suivant est à 1 pour indiquer une valeur immédiate comme troisième donnée, et les trois champs suivants précisent les données (registre r30, codé 11110 ; registre r10, codé 01010 ; valeur hexadécimale 3b2a en binaire). cours Architecture des ordinateurs: programmation assembleur Format des instructions 19
Instructions à deux registres
Les instructions de transfert entre registres ou depuis/vers la mémoire utilisent au plus deux registres comme données. On peut donc prendre le même format en laissant à 0 les 16 derniers bits de l’instruction. Les codes opération sont donnés dans le tableau ci-après et le format (ainsi que deux exemples). Pour différencier ces instructions, on fixe les deux premiers bits à 10 et il reste trois bits pour spécifier une instruction parmi sept cours Architecture des ordinateurs: programmation assembleur Format des instructions 20
Instructions à deux registres
cours Architecture des ordinateurs: programmation assembleur
Format des instructions 21
Instructions à deux registres
Les instructions entre registres ou registre/mémoire. On peut prendre le même format (3 registres) en mettant le dernier champ (16 bits) à 0. STH (r3), r22
10101 0 00011 10110 0000000000000000
cours Architecture des ordinateurs: programmation assembleur
Format des instructions 22
Instruction à un registre et une valeur immédiate
Les sauts (JZ rx, Adr) ou le chargement d’une valeur immédiate (MVI rx, #i). Le code d’opération sur 6 bits. On peut élargir, sur 21 bits, la zone contenant la valeur immédiate.
cours Architecture des ordinateurs: programmation assembleur
Format des instructions 23
Exemple MVI r6, #0x56ac3
110101 00 110 001010110101011000011
cours Architecture des ordinateurs: programmation assembleur
Format des instructions 24
Instructions à un seul registre
On fixe 4 bits des 6 bits du code d’opération, 2 bits étant suffisant pour coder les différents instructions. On met à 0 les deux derniers champs. CCR r6 111100 00110 00000 0000000000000000
cours Architecture des ordinateurs: programmation assembleur
Programme d’assemblage 25
Un programme d’assemblage prend comme entrée un fichier
de code source et génère un fichier binaire en effectuant: Vérification de la syntaxe. Mémorisation de la correspondances entre les étiquettes et les adresses mémoires. Génération du code exécutable. Une étiquette est utilisée dans une opération de saut. Le programme d’assemblage s’effectue en deux passes: Évaluation des étiquettes. Traduction en langage machine.
cours Architecture des ordinateurs: programmation assembleur
Exercice 1 26
Dans r0 se trouve l’adresse d’une chaine de caractères
terminée par l’octet nul. Développer un programme en assembleur qui permet de récupérer , dans r1, le nombre de caractères dans la chaine.
cours Architecture des ordinateurs: programmation assembleur
Correction 27
cours Architecture des ordinateurs: programmation assembleur
cours Architecture des ordinateurs: programmation assembleur
Exercice 2 29
Un tableau d’entiers est stocké en mémoire.
Chaque élément a une valeur de 1 à 127 (stocké sur 1 octet). L’octet qui suit le dernier élément du tableau est nul. L’adresse du premier élément du tableau se trouve dans le registre r0. développer un programme en assembleur qui permet de récupérer le plus grand élément du tableau dans r1. Ajouter au programme précédent le calcul de la somme de tous les éléments du tableau dans r2.
cours Architecture des ordinateurs: programmation assembleur
Correction 30
cours Architecture des ordinateurs: programmation assembleur
Correction 31
cours Architecture des ordinateurs: programmation assembleur
Correction 32
Version 1 : Version 2 :
MVI r1,#0 MVI r1,#0
Ici : LDB r3, (r0) MVI r2, #0 ADD r0, r0, #1 Ici : LDB r3, (r0) JZ r3, Fin ADD r0, r0, #1 SUB r31, r3, r1 JZ r3, Fin JLE r31, ici ADD r2, r2, r3 MOV r1, r3 SUB r31, r3, r1 JMP ici JLE r31, ici Fin : MOV r1, r3 JMP ici Fin : cours Architecture des ordinateurs: programmation assembleur Exercice 3 33
Une chaine de caractère est stockée en mémoire. Chaque
caractère occupe 1 octet et aucun est nul. L’octet qui suit le dernier élément de la chaine est nul. L’adresse du premier élément de la chaine se trouve dans r0. on souhaite effectuer une opération de remplacement de certains caractère de la chaine. Le registre r1 contient le caractère à remplacer. Il s’agit de substituer à chaque occurrence de ce dernier, le caractère se trouvant dans r2. On souhaite également à la fin avoir, dans le registre r3, le nombre de remplacements effectués.
cours Architecture des ordinateurs: programmation assembleur
Correction 34
MVI r3,#0 ; nombre de remplacements égal à 0
Ici : LDB r4, (r0) ; charger prochain caractère JZ r4, fin ; fin de la chaîne ? SUB r4, r4, r1 ; comparer r4 et r1 JNZ r4, Next ; sauter remplacement si différent STB (r0), r2 ; si égal, remplacer par r2 ADD r3, r3, #1 ; nombre de remplacements + 1 Next : ADD r0, r0, #1 ; avancer pointeur sur suivant JMP ici ; retour dans la boucle Fin :
cours Architecture des ordinateurs: programmation assembleur
Exercice4 35
Une chaine de caractère est stockée en mémoire.
Chaque caractère occupe 1 octet et aucun est nul. L’octet qui suit le dernier élément de la chaine est nul. L’adresse du premier élément de la chaine se trouve dans r0. On souhaite renverser la chaine. La nouvelle chaine sera stockée en mémoire à une adresse contenue dans r1
cours Architecture des ordinateurs: programmation assembleur
Correction 36
Il faut d’abord parcourir toute la première chaîne pour arriver à la fin
et commencer à recopier à partir du dernier caractère (donc un caractère avant le zéro final de la première chaîne). Mais il faut également savoir quand s’arrêter. Pour cela, on profite du parcours pour compter au passage le nombre de caractères de la chaîne.
cours Architecture des ordinateurs: programmation assembleur
Correction 37
MVI r2,#0 SUB r2, r2, #1
Comp : LDB r3, (r0) JMP suite1 JZ r3, Suite Fin : MVI r3, #0 ADD r2, r2, #1 STB (r1), r3 ADD r0, r0, #1 JMP Comp Suite : SUB r0,r0, #1 Suite1 : JZ r2, fin LDB r3, (r0) STB (r1), r3 ADD r1, r1, #1 SUB r0, r0, #1 cours Architecture des ordinateurs: programmation assembleur Exercice 5 38
On dispose d’une valeur A stockée dans l’adresse
mémoire qui existe dans le registre r0. On souhaite développer un programme qui détermine le nombre de bit égale à 1 dans A. ce nombre sera stocké dans r1.
cours Architecture des ordinateurs: programmation assembleur
Correction 39
MVI r1,#0 MVI r3,#0 LDW r2, (r0) Ici : SUB r4,r3,#32 JZ r4, Fin ADD r3,r3,#1 LLS r2,#1 CCR r5 SUB r6, r5,#1 JNZ r6, ici ADD r1, r1, #1 JMP ici Fin : cours Architecture des ordinateurs: programmation assembleur Exercice 6 40
Dans r0 se trouve l’adresse d’une chaine de caractère
terminée par l’octet nul. Développer un programme assembleur qui permet de récupérer le nombre de mots de la chaine dans r1. un mot est un ensemble de caractères ne comprenant pas d’espace (32 en décimal). Attention, tous les cas sont possibles : la chaîne peut être vide, il peut n’y avoir que des espaces dans la chaîne, il peut y avoir plusieurs espaces entre deux mots et il n’y a pas forcément d’espace avant le premier mot ni après le dernier.
cours Architecture des ordinateurs: programmation assembleur
Correction 41
MVI r1,#0 compteur égal à 0
loop1 : LDB r2,(r0) lire un caractère ADD r0,r0,#1 avancer le pointeur JZ r2, Fin fin de la chaine ? SUB r31,r2,#32 une espace ? JZ r31, loop1 dans ce cas reboucler ADD r1, r1, #1 sinon début d’un mot Loop2: LDB r2, (r0) lire un caractère ADD r0,r0,#1 avancer le pointeur JZ r2, Fin fin de la chaine ? SUB r31, r2, #32 une espace? JNZ r31, loop2 sinon reboucler sur le mot JMP loop1 sinon revenir au début Fin: cours Architecture des ordinateurs: programmation assembleur
