Initiation assembleur

PDF : pour impression, diapos

Initiation à l’assembleur #

instructions machines #

• Les instructions machines sont exécutées par l’unité de commande.

• Un programme est une suite d’instructions.

Le CPU est incapable d’exécuter directement des programmes écrits en Python (ou C, java etc.).

Les instructions exécutées au niveau du CPU sont donc codées en binaire.

Langage machine : #

Ensemble des instructions exécutables par le microprocesseur

Les instructions machines sont propres à chaque processeur #

Chaque processeur possède son propre jeu d’instruction !

Heureusement, il existe de grandes familles (x86 PC, ARM téléphones etc.)

Précisions #

Une instruction machine est une chaîne binaire composée principalement de 2 parties :

• le champ “code opération” qui indique au processeur le type de traitement à réaliser. Par exemple le code “00100110” donne l’ordre au CPU 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.

Familles Instruction machine #

Trois grandes familles #

• arithmétiques
• transfert de données
• rupture de séquence

Arithmétique #

• Les instructions arithmétiques (addition, soustraction, multiplication...).

  “additionne la valeur contenue dans le registre R1 et le nombre 789 et range le résultat dans le registre R0”.

Transfert de données #

• Les instructions de transfert de données

  “prendre la valeur située à l’adresse mémoire 487 et la placer dans la registre R2”

Registre & Mémoire

Un “mot” est un entier binaire sur $n$ bits. $n$ est une puissance de 2 correspondant à la classe du processeur.

Donc, un processeur 8 bits utilisera des mots de 8 bits (des octets) et un processeur 32 bits, des mots de 32 bits (4 octets).

L’assembleur dispose généralement de deux type de mémoires :

• Les registres : très petits, peu nombreux (8, 13, 17 rarement plus). Ils permettent de stocker un “mot”,

• La mémoire vive (généralement abrégée en “Mémoire”) : c’est la RAM, elle est plus vaste, moins rapide et chaque emplacement dispose d’une adresse numérique.

• Les opérations courantes se font depuis un registre vers un registre.

• On lit depuis la mémoire vers un registre,

• on écrit depuis un registre vers la mémoire.

• On déplace vers un registre (soit une valeur littérale, soit la valeur d’un autre registre).

Rupture de séquence #

Séquence d’instruction

les instructions machines sont situées en mémoire vive. Au cours de l’exécution, le CPU passe d’une instruction à une autre

• l’instruction n°1 située à l’adresse mémoire 343,
• l’instruction n°2 située à l’adresse mémoire 344 etc.

Ce déroulé se poursuit jusqu’à :

• rencontrer un bug,
• rencontrer HALT,
• rencontrer une rupture de séquence,

Rupture de séquence (ou saut, branchement) :

interrompre l’ordre initial sous certaines conditions en passant à une instruction située une adresse mémoire donnée

Par exemple, :

Si la valeur contenue dans le registre R1 est >0,
alors la prochaine instruction à exécuter est l’adresse mémoire 4521,
sinon, la prochaine instruction à exécuter est à l’adresse mémoire 355.

Sauts conditionnels ou inconditionnels #

• Un saut inconditionnel se déroulera toujours. On passe de tel emplacement à tel emplacement.
• Un saut conditionnel doit suivre une comparaison. Selon le résultat de cette comparaison on sautera ou on passera à l’emplacement suivant.

Programme en langage machine #

Suite très très longue de “1” et de “0”.

Extrêmement difficile de lire ou d’écrire ainsi : on remplace les codes binaires par des symboles mnémoniques.

11100010100000100001000001111101 <--> ADD R1,R2,#125

En fait :

Assembler : #

Transformer ces codes mnémoniques en langage machine.
ADD R1,R2,#125 —> 11100010100000100001000001111101

“Programmer en assembleur” revient donc à écrire du code en “mnemonique” pour un processeur particulier.

Encore aujourd’hui, programmer en assembleur est une activité courante.

Présentation d’un langage assembleur par l’exemple #

Déplacements #

Opérations arithmétiques #

Rupture de séquence #

Exemple #

Expliquez brièvement :

ADD R0, R1, #42

LDR R5,98

CMP R4, #18
BGT 77

STR R0,15

B 100

Exemple #

Écrire les instructions en assembleur correspondant à :

• 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

Labels #

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

   CMP R4, #18
   BGT monLabel
   MOV R0,#14
   HALT
monLabel:
   MOV R0,#18
   HALT

Python –> assembleur #

x = 4
y = 8
if x == 10:
    y = 9
else:
    x = x+1
z = 6

Python –> assembleur #

   MOV R0, #4       
   MOV R1, #8       
   CMP R0, #10      
   BNE else         
   MOV R1, #9       
   B endif          
else: 
   ADD R0, R0, #1
   B endif
endif:
   MOV R0, #6
   HALT