Instructions assembleur

Instructions assembleur

0001011011110110
0001011101101101
10001001

Instruction vue par le programmeur assembleur

ou instruction élémentaire cible d'un compilateur

Réalise une modification de l'état interne du processeur

ou de la mémoire

3. 1
Instructions assembleur

1. Programme binaire
● Généré par le compilateur (ou écrit par le programmeur en langage
machine)
● Ensemble d'instructions machine chargées en mémoire centrale lors
de l'exécution d'un programme
● Les instructions sont exécutées séquentiellement
PC (Program Counter) contient l'adresse de l'instruction à exécuter
mémoire centrale
..... si le programme commence
0001011011110110 à l'adresse 5000h PC vaut 5000h
PC
0001011101101101 puis 5002h puis 5006h ....
0011000100100100

les instructions de contrôle (if else, boucle for, while, ...)

modifient la valeur de PC

3. 2
Instructions assembleur

Exemples de programme binaire

// Programme C // code 68000 cross-compilé // code Pentium 4
gcc2_compiled.: .file "essai.c"
int i=5; ___gnu_compiled_c: .globl i
int j=10; .data .data
.globl _i
int k = 0; _i: .align 4
main() { .long 5 .type i,@object
.globl _j Les données .size i,4
i= i+j+k; _j: i:
} .long 10 .long 5
.globl _k ...
_k:
.long 0 ...

.text .text
directives .globl main
.globl _main
_main: .type main,@function
étiquettes movel _i,d0 Les instructions main:
addl _j,d0 movl j, %eax
movel d0,d1 addl i, %eax
addl _k,d1 addl k, %eax
movel d1,_i movl %eax, i
3. 3
Instructions assembleur
2. Jeu d'instructions

●
Une instruction est définie par :
– l'opération à réaliser que faire ?

– les opérandes : registres et cases mémoire modifiés / utilisés par

l'instruction sur quoi opérer ?
●
Une instruction est représentée par un code binaire qui suit un
format d'instruction

3. 4
Instructions assembleur

●
Quelles instructions ?
– quelles opérations élémentaires ? (différentes utilisations : DSP,
multimédia, CPU...)
– quels types de données ? (booléens, flottants, entiers, codes ASCII, BCD)

●
Objectif : assurer les meilleures performances en terme de
– rapidité d'exécution
– taille du code
– facilité d'utilisation (écriture des compilateurs)

●
Tendance : simplicité du jeu d'instructions et du codage (même
format d'instruction, même temps d'exécution)
RISC : Reduced Instruction Set Computers

3. 5
Instructions assembleur

Exemple d'instruction 68000

En binaire : 0010 0010 0011 1001 0000 0000 0000 0000 0000 0000 0010 0000
En hexadécimal : 2239 0000 0020h

La même chose lisible (langage assembleur) :

movel _i,d1
• movel : transfert de données (move) de type long (l)
• i : opérande source (une donnée mémoire)
• d1 : opérande destination (un registre interne)

Le registre interne d1 reçoit le contenu de la variable en mémoire centrale i

3. 6
Instructions assembleur
3. Format d'instruction

●
L'instruction est représentée par un code binaire. Ce code
binaire est découpé en champs ayant des rôles différents : c'est
le format d'instruction.
CODE MODE OP1 OP2

comment calculer informations pour calculer

opération à réaliser les opérandes les opérandes

●
Le format d’instruction peut varier selon le type des opérandes
●
Tendance : un format uniforme

3. 7
Instructions assembleur

Exemple : PROCSI
• Langage assembleur : <inst> <op-dest> , <op-source>
page 3/4
Exemple : add R1, R4

• Format d'instruction : 1, 2 ou 3 mots de 16 bits

1er mot : code_op mode source dest
6 4 3 3

code_op : le code de l'opération

mode : le mode d'adressage
source : le code du n° de registre source
dest : le code du n° de registre destination
2ème mot : valeur immédiate ou adresse
3ème mot : adresse
Exemple : 000000 0000 0100 0001

3. 8
Instructions assembleur

Exemple : Processeur ARM

3. 9
Instructions assembleur

Exemple : famille xx86 (Pentium)

très grand nombre d'instructions (synonymes) et modes d'adressage

* Source :[Link]

syntaxe: op-code op-dest , op-source

Ex: add cx, bx

add cl, bl
mov 80[bx], ax

3. 10
Instructions assembleur
4. Opérandes

4.1. Registres internes

Registres généraux dans une mémoire statique interne, accessible en

un top d’horloge processeur

● moins de traffic mémoire

● programmes plus rapides
● code machine plus dense

A chaque fois que c'est possible

3. 11
Instructions assembleur

4.2. Opérandes mémoire :

la donnée est dans la mémoire centrale
accès à un octet (8 bits), mot (16 bits), double mot (32 bits), mot long (64 bits)

Initialisation de variables locales, tableaux

Organisation mémoire :
0 Accès à un mot ou double :
0 1
Accès à un octet : 1 adresse paire 2 3
2 4 5
adresse paire
3 . .
ou impaire . . .
.

3. 12
Instructions assembleur

4.3. Modes d'adressage

•
Spécification de la façon de calculer un opérande (objet à accéder)
– constante
– registre
– case mémoire
•
Codé par un champ d'instruction
•
Le codage dépend du nombre de modes possibles et de
l'interdépendance entre modes et codes opération
•
Exigences contradictoires :
– Avoir autant de modes d'adressage que possible (facilité de
programmation)
– Impact sur la taille des instructions et donc du programme

3. 13
Instructions assembleur
Modes d'adressage usuels
Mode Informations codées Mode de calcul de Utilisation
d'adressage dans l’instruction l'opérande
Immédiat op = valeur immédiate op constantes
la valeur elle-même i = 6;
Registre op = numéro registre reg[op] calculs intermédiaires
for (int i =0;i<100;i++)
le registre interne n° op x = x+ y*x +2*y
Direct ou op = adresse mem[op] accès variables statiques
absolu la case n° op de la
int i;
mémoire centrale

Indirect op = numéro registre mem[reg[op]] accès par pointeur ou référence

accès à une case de la
Train t = new Train(“TGV”);
mémoire centrale.
Train tt = t;
le n° est stoké dans le
registre interne n° op [Link](“corail”);

Déplacement op = numéro du registre mem[reg[op] + op'] accès tableau ou pile

op' = adresse de base accès à une case de la
mémoire centrale. int[] t = {8,2,5};
le n° est op' + la valeur int x = t[2];
stokée dans le
registre interne n° op
3. 14
Instructions assembleur
Exemple: modes d'adressage de PROCSI

page 4
Représentation Effet Mode adressage Code
ADD R1, R5 REG[1] <- REG[1] + REG[5] registre/registre 000000 0000 101 001
Addition des registres 1 et 5 000000 : addition
Le résultat va dans le registre 1 0000 : mode registre / registre
001 : la destination est le registre n°1
011 : la source est le registre n°5
ADD R2, # 24 REG[2] <- REG[2] + 24 registre/immédiat 000000 0100 xxx 010
0000000000011000
24 est additionné au registre R2 000000 : addition
0100 : mode registre / immédiat
010 : la destination est le registre n°2
XXX : il n'y a pas de registre source
0000000000011000 : 24, la donnée immédiate
ADD [8], # 24 MEM[8] <- MEM[8] + 24 direct/immédiat 000000 0101 xxx xxx
0000000000011000
0000000000001000
24 est additionné à la case mémoire n°8 000000 : addition
0101 : mode direct / immédiat
XXX : il n'y a pas de registre mis en jeu
0000000000011000 : 24, la donnée immédiate
0000000000001000 : 8, l'adresse de la case mémoire

3. 15
Instructions assembleur

Quel est le code binaire de ADD R5,R7 ?

000000 0001 0011 0101
000000 0000 0111 0101
000000 0000 0101 0111

La variable i est à l'adresse 9 dans la mémoire

Comment traduire l'instruction java “i = i + 3”
ADD [9],R3
ADD [9],#3
ADD [9],[3]

3. 16
Instructions assembleur

Exemple: modes d'adressage de PROCSI suite ...

Représentation Effet Mode adressage Code

ADD R1, [R5] REG[1] <- REG[1] + MEM[REG[5]] registre/indirect 000000 1100 101 001
Additionne le registre 1 et
le mot mémoire dont l'adresse est dans R5
Le résultat va dans le registre 1

ADD R2, 8[R5] REG[2] <- REG[2] + MEM[REG[5]+ 8] registre/déplacement 000000 1001 xxx 010
0000 0000 0000 1000
Additionne le registre 2 et le mot mémoire
Dont l'adresse est le contenu de R5 + 8
Le résultat va dans le registre 2

3. 17
Instructions assembleur

Si le tableau “int[] T” est à l'adresse 8 dans la mémoire, si le registre R5

contient la valeur 8 alors [R5] correspond à T[0]

MEM REG
Adresse Contenu Numéro Contenu
8 T[0] 0
9 1
10 2
11 3
12 T[1] 4
13 5 8
14 6
15 7

Sachant que les “int” en Java sont codés sur 32 bits (soit 4 cases
mémoire), à quoi correspond 8[R5] ?
T[5]
T[8]
T[2]
3. 18
Instructions assembleur

5. Opérations du jeu d'instruction

5.1. Classes d'opérations

● arithmétiques et logiques (entier ou flottant)
Calculs
● chargement / rangement
Transferts de / vers la mémoire
● contrôle
Rompt l’exécution séquentielle du programme (modifie PC)
● système
Interruptions : pour appel périphériques
● autres (Ex: MMX)

3. 19
Instructions assembleur

5.2. Instructions de contrôle

Rompt l'exécution séquentielle du programme

PC: registre «Program Counter» contient l'adresse de la prochaine instruction à exécuter

● exécution séquentielle : PC est incrémenté de la taille du format

de l’instruction en cours d’exécution
il pointe donc sur la prochaine instruction à exécuter

● instruction de contrôle : modifie la valeur de PC

ce n'est donc pas l'instruction suivante qui est exécutée

3. 20
Instructions assembleur

Exemple PROCSI

PC = 8000h
8000h : 000000 0000 010 001 ADD R1, R2 PC <- 8000h + 1 séquentiel
8001h : 000000 0100 xxx 001 ADD R1, #24 PC <- 8001h + 2
8002h : 0000000000011000
8003h : 000100 xxxx xxx xxx JMP 8360h PC <- 8360h contrôle
8004h : 1000 0011 0110 0000
8005h : .................................
.......... : ................................
8360h : 000000 0000 110 000 ADD R0, R5

adresses en hexa dans mémoire instruction

3. 21
Instructions assembleur

• Adresse de branchement
– le programme est écrit avec une étiquette symbolique,
– l’adresse relative du branchement est connue lors de la phase de compilation,
– l’adresse réelle du branchement est connue lors du chargement du programme en
mémoire centrale (dépend de la machine).
• Condition de branchement
– test sur le résultat d'une opération arithmétique ou logique
Exemple : résultat nul, résultat positif, retenue …
• La condition est
– générée par l'unité de calcul de l'unité centrale (ALU)
– stockée dans un registre spécial accessible par la partie contrôle (SR)
-> la partie contrôle prend en entrée la valeur de SR pour savoir si le branchement
doit être pris

3. 22
Instructions assembleur

5.3. Catégories d'instructions de contrôle

● saut (branchement inconditionnel)

PC <- adresse branchement
goto

● branchement conditionnel
si condition vraie PC <- adresse branchement
sinon PC inchangé
if then else, while, for

● appel procédure
"PC_sauv "<- PC
PC <- adresse branchement

● retour procédure
PC <- "PC_sauv"

3. 23
Instructions assembleur
Exemple: PROCSI

jmp : “jump”saut non conditionnel

Non conditionnel
8301h add R1, R2 PC = 8301h : PC <- 8302h; R1 <- R1 + R2
8302h jmp suite PC = 8302h : PC <- 8304h; PC <- 8600h
8304h sub R1, R4
… … PC = 8600h : PC <- 8602h; MEM[80] <- R1
suite:
8600h store [80],R1

3. 24
Instructions assembleur
Exemple: PROCSI

jeq : “Jump if EQual”saut conditionnel si le résultat est nul

Conditionnel
PC = 8301h : PC <- 8302h; R1 <- R1 + R2
Si R1 = - R2:
8301h add R1, R2
8302h jeq suite PC = 8302h : PC <- 8304h; PC <- 8600h
8304h sub R1, R4
… … PC = 8600h : PC <- 8602h; MEM[80] <- R1
suite:
8600h store [80],R1 Si R1≠ - R2:
PC = 8302h : PC <- 8304h;
PC = 8304h: PC <- 8306h; R1 <- R1 - R4

Ici le résultat est nul, le flag Z de SR est à 1

donc le branchement est pris

3. 25
Instructions assembleur
On suppose que le compilateur a associé le registre R1 à la variable x,
le registre R2 à la variable y et le registre R3 à la variable z
Quel code PROCSI correspond à : x = x + y;
if (x!=10) x = x + 22;
z++;

add R1,R2 add R1,R2 add R1,R2

cmp R1,#10 cmp R1,#10 cmp R1,#10
jeq suite jne suite jne suite
add R1,#22 add R3,#1 add R3,#1
suite : add R3,#1 suite : add R1,#22 jmp fin
add R3,#1 suite : add R1,#22
add R3,#1
fin :
3. 26
Instructions assembleur

Exemple : une boucle en C et en 68000

_main:
int result = 8; moveq #5,d0 d0 vaut 5
int i=0; movel d0,_i i vaut d0
L2:
main() moveq #9,d0 d0 reçoit 9
cmpl _i,d0 comparaison de i et d0
{
jge L5 saut à L5 si i <= d0
for (i = 5;i < 10; i++) jra L3 saut à L3
result++; L5:
} addql #1,_result result reçoit result+1
L4:
addql #1,_i i reçoit i + 1
jra L2 saut à L2
L3:
rts retour

3. 27
Instructions assembleur

5.4. Procédures
• Le code de la procédure utilise les paramètres
• La valeur des paramètres est connue lors de l'exécution
• Le nombre d’appels n’est pas toujours connu de façon statique : appels dans un
if, appels imbriqués de procédures, procédures récursives, ...
Il faut un mécanisme de saut pour “aller” à la procédure, et il faut un
mécanisme pour en revenir

Une pile pour gérer :

- le passage des paramètres

- l'appel de procédure
- le retour de procédure

Pile: zone contiguë de la mémoire centrale

un registre spécialisé SP (stack pointer) du CPU contient l'adresse du
sommet de pile

3. 28
Instructions assembleur

Communication entre appelant et procédure

1. Séquence d'appel
Programme appelant
empiler les paramètres
empiler l'adresse de retour (PC courant)
PC prend l'adresse de la procédure

2. Séquence d'entrée Procédure

sauvegarde additionnelle de registres
allocation de pile pour variables locales

3. Séquence de sortie Procédure

désalloue les variables locales de la pile
met le résultat du calcul dans un endroit accessible par l'appelant
PC prend la valeur du sommet de pile

4. Séquence de retour Programme appelant

l'appelant récupère le résultat et en dispose

Le détail des appels de procédures sera vu en cours d’assembleur ARM

3. 29
Instructions assembleur

Appel de la procédure dans le programme appelant :

- “push” pour chaque paramètre
- “call <adresse_proc>” : 1. empile l'adresse de retour (PC courant)
2. modifie PC : PC  <adresse_proc>

L'exécution continue dans la procédure

Dans la procédure :
- “push” pour sauvegarder les registres modifiés par la procédure
- récupère les paramètres dans la pile : adressage mémoire avec déplacement
par rapport à SP
- calcul
- “pop” pour restituer les valeurs initiales des registres
- “ret” : la valeur en sommet de pile est dépilée et placée dans PC

L'exécution continue dans le programme appelant

3. 30
Instructions assembleur
variable à l'adresse 50 main à l'adresse 1000h
public static void main(String [] s){
int a = plus(3, 8); procédure à l'adresse 8000h
a++;
} instruction à l'adresse 1008h

Code PROCSI : le résultat est renvoyé dans R0

Le main La procédure plus
1000h : push #3 8000h : push R1
1002h : push #8 Nouvelle load R1,2[SP]
valeur de PC:
1004h : call 8000h add R1, 3[SP]
1006h : store [50],R0 move R0,R1
1008h : add [50],#1 Nouvelle pop R1
valeur de PC ret

3 8 1008 R1 La pile d'exécution

sp
3. 31
Instructions assembleur
5.5. Interruptions
L'exécution normale du programme est interrompue pour
raison logicielle ou matérielle

Trois mécanismes de base

• Interruptions logicielles : appel au noyau du système d'exploitation
• Conditions d'erreur : division par 0, stack overflow, défaut de page, ...
• Interruptions matérielles : clic souris, clic clavier, ...

Traitement identique à un appel de procédure mais :

– Sauvegarde du contexte du programme (pas seulement PC actuel)
– La routine d'interruption est stockée dans un endroit protégé de la
mémoire
– L'appel de la routine d'interruption est fait par la partie contrôle
dans le cas des conditions d'erreur et des interruptions matérielles
– Table d'interruption : fait le lien entre type d'interruption et adresse
de la routine associée

3. 32