Le langage assembleur
« Dans le monde, il y a 10 catégories de personnes :
celles qui connaissent le binaire et celles qui ne le connaissent pas. »
Anonyme
I. Fonctionnement du CPU
1Un processeur donné est capable d’exécuter un certain nombre d’opérations de base, celles pour lesquelles il dispose d’un circuit électronique qui les réalise. L’ensemble des instructions exécutables directement par le microprocesseur (instructions machines) constitue ce que l’on appelle le « langage machine » du processeur.
Chaque instruction machine correspond à une configuration électronique binaire composée principalement de 2 parties.
Le champ « code opération » (opcode) qui indique au processeur le type de traitement à réaliser. Par exemple, sur un certain modèle de processeur, le code ”00100110” donne l’ordre d’effectuer une multiplication.
Le champ ”opérandes” indique la nature des données sur lesquelles l’opération désignée par le ”code opération” doit être effectuée.
Les instructions machines sont relativement basiques (on parle d'instructions de bas niveau), voici quelques exemples :
Les instructions arithmétiques (addition, soustraction, multiplication...). Par exemple, on peut avoir une instruction qui ressemble à "additionne la valeur contenue dans le registre R1 et le nombre 789 et range le résultat dans le registre R0" (l'adresse mémoire est donnée en base 10 pour souci de simplicité, n'oubliez pas qu'en interne elle est codée en binaire).
Les instructions de transfert de données qui permettent de transférer une donnée d'un registre du CPU vers la mémoire vive et vice versa. Par exemple, on peut avoir une instruction qui ressemble à
"prendre la valeur située à l'adresse mémoire 487 et la placer dans la registre R2" ou encore "prendre la valeur située dans le registre R1 et la placer à l'adresse mémoire 512"
Les instructions de rupture de séquence : les instructions machines sont situées en mémoire vive, si, par exemple, l'instruction n°1 est située à l'adresse mémoire 343, l'instruction n°2 sera située à l'adresse mémoire 344, l'instruction n°3 sera située à l'adresse mémoire 345... Au cours de l'exécution d'un programme, le CPU passe d'une instruction à une autre en passant d'une adresse mémoire à l'adresse mémoire immédiatement supérieure : après avoir exécuté l'instruction n°2 (situé à l'adresse mémoire 344), le CPU "va chercher" l'instruction suivante à l'adresse mémoire 344+1=345. Les instructions de rupture de séquence d'exécution encore appelées instructions de saut ou de branchement permettent d'interrompre l'ordre initial sous certaines conditions en passant à une instruction située une adresse mémoire donnée, par exemple, nous pouvons avoir une instruction qui ressemble à cela : imaginons qu'à l'adresse mémoire 354 nous avons l'instruction "si la valeur contenue dans le registre R1 est strictement supérieure à 0 alors exécuter l'instruction située à
1 eduscol.education.fr et pixees.fr
l'adresse mémoire 4521". Si la valeur contenue dans le registre R1 est strictement supérieure à 0 alors la prochaine instruction à exécuter est l'adresse mémoire 4521, dans le contraire, la prochaine instruction à exécuter est à l'adresse mémoire 355.
Un opérande peut être de 3 natures différentes :
l’opérande est une valeur immédiate : l’opération est effectuée directement sur la valeur donnée dans l’opérande ;
l’opérande est un registre du CPU : l’opération est effectuée sur la valeur située dans un des registres (R0,R1, R2,...) ; l’opérande indique de quel registre il s’agit ;
l’opérande est une donnée située en mémoire vive : l’opération est effectuée sur la valeur située en mémoire vive à l’adresse XXXXX. Cette adresse est indiquée dans l’opérande.
Le programme exécuté se trouve en RAM, tout comme les données. Un registre particulier du processeur, nommé PC (Program Counter) (ou IP -Instruction Pointer), contient l’adresse de la cellule RAM de la prochaine instruction à exécuter.
Un deuxième registre, IR (Instruction Register), joue un rôle important en raison de sa connexion physique au reste du processeur : placer dans ce registre la configuration électronique qui dénote une instruction provoque l’activation du circuit dédié à la réalisation de l’opération sous-jacente.
Le CPU a un fonctionnement cyclique :
il copie dans le registre IR le contenu de la RAM à l’adresse pointée par PC ;
il décode l’instruction contenue dans IR : ceci provoque l’activation du circuit électronique qui réalise l’opération visée ;
il exécute l’instruction décodée ; ceci met aussi à jour la valeur de PC pour continuer dans le programme.
La capacité du processeur à exécuter tous les programmes s’explique par ce fonctionnement très souple et par le fait que le jeu d’instructions de base est suffisamment riche pour être universel (on dit que le langage machine est Turing-complet).
Dans le modèle de von Neumann, il y a une seule mémoire vive pour le programme et les données : c’est par sa copie dans le registre IR qu’une configuration électronique initialement présente en RAM joue le rôle d’une instruction. La même configuration pourrait être interprétée comme une donnée (entier, etc.) dans un autre contexte. La réciproque vaut aussi : une grande famille d’attaques informatiques consiste à exploiter des défauts dans le flux de contrôle d’un programme pour faire exécuter par le processeur des configurations électroniques qui étaient censées être des données, notamment des données choisies par l’utilisateur- attaquant. Pour ces raisons de sécurité, les processeurs modernes sont dotés de la capacité de marquer des portions de la mémoire comme non-exécutables, s’écartant ainsi du principe d’origine du modèle de von Neumann.
II. Les instructions en assembleur
2LDR Rd, <adresse mémoire>
Charge la valeur enregistrée dans l'<adresse mémoire> dans le registre d.
LDR R1,78 STR Rd, <adresse
mémoire>
Enregistre la valeur du registre d dans la mémoire spécifiée par <adresse mémoire>.
STR R1,78
ADD Rd, Rn, <operand2> Ajoute la valeur spécifiée par <operand2> à la valeur du registre d et enregistre le résultat dans le registre d.
ADD R1,R0,#128 ADD R0,R1,R2 SUB Rd, Rn, <operand2> Soustrait la valeur de <operand2> à la valeur du registre n et
enregistre le résultat dans le registre d.
SUB R1,R0,#128 SUB R0,R1,R2 MOV Rd, <operand2> Copie la valeur <operand2> dans le registre d. MOV R1, #23
MOV R0, R3 CMP Rn, <operand2> Compare la valeur de registre n avec la valeur de <operand2>. CMP R0, #23
CMP R0, R1 B <label> Branchement inconditionnel jusqu'à la positon <label> dans le
programme.
B 45 B<condition> <label> Branchement conditionnel vers la position <label> dans le
programme si la dernière comparaison rempli le critère spécifié par <condition>. Les valeurs possibles sont : EQ : égal à ; NE : n'est pas égal à ; GT : Plus grand que ; LT : Moins grand que.
BEQ 78 BNE 78 BGT 78 BLT 78
HALT Arrête l'execution du programme. HALT
<operand2> peut être #nnn (c'est à dire un nombre, exemple #42) ou bien Rm (c'est à dire le registre m , par exemple R1 est le registre numéro 1).
Les registres vont de R0 à R12.
Compléments :
INP Rd,2 lis un nombre dans le registre d.
OUT Rd,4 retourne en sortie le nombre du registre d.
Travail à faire
1. Signification des instructions.
Expliquez brièvement, les instructions suivantes : - ADD R0, R1, #42
- LDR R5,98 - CMP R4, #18 - STR R0,15 - B 100 Travail à faire
2. Ecrire des instructions.
Écrire les instructions en assembleur correspondant aux phrases suivantes :
- Additionne la valeur stockée dans le registre R0 et la valeur stockée dans le registre R1, le résultat est stocké dans le registre R5
- Place la valeur stockée à l'adresse mémoire 878 dans le registre R0 - Place le contenu du registre R0 en mémoire vive à l'adresse 124
- La prochaine instruction à exécuter se situe en mémoire vive à l'adresse 478
- Si la valeur stockée dans le registre R0 est égale 42 alors la prochaine instruction à exécuter se situe à l'adresse mémoire 85
En faite, les instructions assembleur B, BEQ, BNE, BGT et BLT n'utilisent pas directement l'adresse mémoire de la prochaine instruction à exécuter, mais des "labels". Un label correspond à une adresse en mémoire vive (c'est l'assembleur qui fera la traduction "label"->"adresse mémoire"). L'utilisation d'un label évite donc
d'avoir à manipuler des adresses mémoires en binaire ou en hexadécimale. Voici un exemple qui montre comment utiliser un label :
CMP R4, #18 BGT monLabel MOV R0,#14 HALT monLabel:
MOV R0,#18 HALT
Dans l'exemple ci-dessus, le label est "monLabel". La ligne "MOV R0,#18" a pour label "monLabel" car elle est située juste après la ligne "monLabel:". Concrètement, si la valeur stockée dans le registre R4 est supérieure à 18 on place le nombre 18 dans le registre R0 sinon on place le nombre 14 dans le registre R0. ATTENTION : la présence du "HALT" juste après la ligne "MOV R0,#14" est indispensable, car sinon, la ligne "MOV R0,#18"
sera aussi exécutée.
Travail à faire
3. Python et assembleur.
x = 4 y = 8 if x == 10:
y = 9 else:
x=x+1 z=6
MOV R0, #4 STR R0,30 MOV R0, #8 STR R0,75 LDR R0,30 CMP R0, #10 BNE else MOV R0, #9 STR R0,75 B endif else:
LDR R0,30 ADD R0, R0, #1 STR R0,30 endif:
MOV R0, #6 STR R0,23 HALT
Après avoir analysé très attentivement le programme en assembleur ci-dessus, établir une correspondance entre les lignes du programme en Python et les lignes du programme en assembleur.
À quoi sert la ligne « B endif » ?
À quoi correspondent les adresses mémoires 23, 75 et 30 ?
III. Le simulateur
3A. Présentation
Un simulateur a développé par Peter L Higginson. Ce simulateur est basé sur une architecture de von Neumann. Ce simulateur est constitué :
une RAM
un CPU.
Il est relativement facile de distinguer les différentes parties du simulateur :
à droite, se trouve la mémoire vive ("main memory")
au centre, se trouve le microprocesseur
à gauche se trouve la zone d'édition ("Assembly Language"). C'est dans cette zone que les programmes en assembleur sont écrits.
La RAM
Par défaut le contenu des différentes cellules de la mémoire est en base 10 (entier signé), mais d'autres options sont possibles : base 10 (entier non-signé, "unsigned"), base 16 ("hex"), base 2 ("binary"). On accède à ces options à l'aide du bouton "OPTIONS" situé en bas dans la partie gauche du simulateur.
Travail à faire
4. Le langage machine.
À l'aide du bouton "OPTIONS", passez à un affichage en binaire.
Chaque cellule de la mémoire comporte 32 bits (classiquement une cellule de RAM comporte 8 bits).
Chaque cellule de la mémoire possède une adresse (de 000 à 199), ces adresses sont codées en base 10.
Repasser à un affichage en base 10 (bouton "OPTION"->"signed").
Le CPU
Il se trouve dans la partie centrale du simulateur en allant du haut vers le bas :
le bloc "registre" ("Registers"). Il y a 13 registres : (R0 à R12) et 1 registre (PC) qui contient l'adresse mémoire de l'instruction en cours d'exécution.
le bloc "unité de commande" ("Control Unit") qui contient l'instruction machine en cours d'exécution (au format hexadécimal).
le bloc "unité arithmétique et logique" ("Arithmetic and Logic Unit").
B. Programmation
Travail à faire
5. Le premier programme 1.
Dans la partie "éditeur" ("Assembly Language") saisir les lignes de codes suivantes : MOV R0,#42
STR R0,150 HALT
Cliquer sur le bouton "submit".
Des nombres apparaissent dans les cellules mémoires d'adresses 000, 001 et 002.
Cliquer sur "Run".
L'assembleur a fait son travail, il a converti les 3 lignes du programme en instructions machines, la première instruction machine est stockée à l'adresse mémoire 000 (elle correspond à "MOV R0,#42" en assembleur), la deuxième à l'adresse 001 (elle correspond à "STR R0,150" en assembleur) et la troisième à l'adresse 002 (elle correspond à "HALT" en assembleur). Pour avoir une idée des véritables instructions machines, il faut repasser à un affichage en binaire .
Ainsi, l'instruction machine "11100011 10100000 00000000 00101010" correspond au code assembleur "MOV R0,#42" (le dernier octet 001010102 est bien égale à 4210). L'instruction machine
"11100101 10001111 00000010 01001100" correspond au code assembleur "STR R0,150". Et, l'instruction machine "11101111 00000000 00000000 00000000" correspond au code assembleur "HALT".
Travail à faire
6. Le premier programme 2.
Cliquer sur "Run".
Travail à faire 7. Modification.
Modifier le programme précédent pour qu'à la fin de l'exécution on trouve le nombre 54 à l'adresse mémoire 50. On utilisera le registre R1 à la place du registre R0. Tester les modifications en exécutant la simulation.
Travail à faire
8. Tester un programme.
Saisir et tester le programme du Travail à faire 3.
Travail à faire
9. Traduire du Python.
Voici un programme Python : x=0
while x<3:
x=x+1
Écrire et tester un programme en assembleur équivalent à ce programme.
