CoursTLS-SEC/Assembleur/cours.md

Architecture des processeurs, Langages d'assemblage et assembleur en ligne

Benoit Morgan - Intel corp

Introduction

L'assembleur est le langage qui permet de générer un langage machine / programme correct. Le langage est très proche du jeu d'instruction et de l'achitecture du processeur, mais suffisamment abstrait pour être lu et écrit par un humain. On associe une famille de processeur à un langage assemblage donnée

Architecture matérielles des processeurs

Processeur

Il s'agit du composant essentiel d'une machine, il est capable d'exécuter des instructions machine d'un programme, il a accès à la mémoire, et aux périphériques. On l'associe en général à l'intelligence de la machine

microprocesseur = processeur + mémoire + entrées / sorties + etc

Micro Processeur

Mémoire

Plusieurs types de mémoires

Mémoire court termes - Registres

Utilisés directement par les unités arithmétiques et logiques comme paramètre et stockage des opérations arithmétiques

Mémoire long terme - la RAM

Utilisée pour le stockage des instruction ou les données d'un programme (variables temporaires, locales, globales...)

Périphériques

Permettent l'acheminement du flot de données

Instructions machines

Il s'agit des opérations élémentaires exécutées par un processeur. On en distingue plusieurs types :

• UAL
• Accès mémoire
• I/O en lecture ou écriture
• Gestion du flot d'exécution - Sauts, fonctions, interruptions
• Système : configuration, noyau, VM, énergie...

Opérateurs binaires

Logique

• & ET
• | OU
• \oplus XOR

Arithmétiques

• Addition +
• Soustraction -
• Multiplication x

Binaires

Architecture générique typique et simplifiée

• Périph entrée et sortie
• CPU
• Mémoire
• Jeu d'instructions
  • Lire une entrée utilisateur
  • Ecrire une entrée utilisateur
  • Addition
  • Soustraction
  • Lecture mémoire
  • Ecriture mémoire

Calcul arithmétique avec une UAL

• Généralement deux entrées dans un CPU
• Généralement une sortie
• Processeur xbits <=> UAL x-bits

Décomposition en suite d'instructions arithmétiques :

sortie((entrée() +entrée()) * (entrée()+entrée()))

Drapeaux et comparaisons

Drapeaux arithmétiques

• Z : résultat nul
• C (carry) - retenue
• O (Overflow) l'espace des nombres signés a été dépassé
• P : parité
• S : Signé

Encodage des nombres signés en mémoire

n = -b_{n-1} \times 2^{n-1} + \sum_{i=0}^{n-2}{b_i\times2^i}

Instructions de contrôle du flot d'exécution

Permet la mise en oeuvre de tests et de bouvles quand utilisées en complément avec l'UAL.

if (expr.){statement} else {statement}
while (expr.) {statements}
for (statements;expr;statements){statements}

Exemple de tests - if et boucles - for

if (6==entrée()){
    sortie(0);
}
else{
    sortie(1);
}

Programme                         Commentaires
A = 6                             if (6 - entrée() == 0)
B = entrée
A = A - B     ou A CMP B
cpt. ordinal = 6 ssi Z = 0
sortie = 0                        sortie(0)
cpt. ordinal = 7                  else
sortie = 1                        sortie(1)
[..]

for (int i = 0; i < 10; i++) {
sortie(i);
}

Peut être traduit en suite d’instructions génériques suivantes :

Programme                         Commentaires
A = 0                             int i = 0
B = 10
A CMP B                           i < 10 ?
cpt. ordinal = 7 ssi Z = 1        {
sortie = A                        sortie(i)
A = A + 1                         i++
cpt. ordinal = 2                  }
[..]

Support des procédures

Une bonne façon de faire des appels de fonction supportant les appels de fonctions consécutifs et les appels imbriqués de fonction et de procéder de la façon suivante :

Un appel récursif avec pile et accès mémoire indirect :

Programme                           Commentaires
P = 41                              Initialisation pile
A = 0                               main() {}
appel 10                            f() et C = 2
appel 10                            f() et C = 3
[..]
P = P - 1                           f() {} sauvegarde du contexte
MEM[P] = C
A = A + 1
appel 20                            f2() et C = 14
C = MEM[P]                          restauration du contexte
P = P + 1
cpt. ordinal = C                    cpt. ordinal = @retour
[..]
A = A + 2                           f2() {}
cpt. ordinal = C                    cpt. ordinal = @retour

Attention, il n'est pas toujours nécessaire de passer par la pile. Par défaut ce sera cette structure qui sera utilisée dans une architecture x86, mais en soi, pour un simple appel de fonction non récursive, il suffirait de garder uniquement le registre C qui contient l'adresse de la ligne suivante de code à éxecuter.

Structure des instructions

Champ usuels

| Code opération | Opérandes |

• Code d'opération \simeq Opération à exécuter, peut donc spécifier la taille des opérandes :

  • addition, appel, cpt.ord = etc...

• Opérandes \simeq les paramètres de l'instruction :

  • adresse absolue, registre, etc...

Taille d’une instruction

• Jeu d’instruction à taille fixe
  • Exemple : ARM, MIPS
• Jeu d’instruction à taille variable
  • Exemple : Intel x86

Sémantique et structure d'une opérande

• Généralement interprétés en fonction du code opération
• Id du registre
  • Ex : 0 = A, 1=B
• Valeur imméditate
  • Ex : A=4
• Adresse -Ex : appel 20

Classification des processeurs

• Reduced Instruction Set Computer (RISC) : ARM Thumb, MIPS Peu d’instructions, faible emprunte silicium.
• Complex Instruction Set Computer (CISC) : Intel X86, ARMv8 Instructions complexes simplifiantes. Énorme emprunte silicium.