# 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()))

<p align="center">
  <img src="./Images/operation_to_instructions.png">
</p>

<p align="center">
  <img src="./Images/o_t_i_inpc.png">
</p>

# 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. 

```C
if (expr.){statement} else {statement}
while (expr.) {statements}
for (statements;expr;statements){statements}
```
# Exemple de tests - if et boucles - for

```C
if (6==entrée()){
    sortie(0);
}
else{
    sortie(1);
}
```
```x86asm
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)
[..]
```

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

Peut être traduit en suite d’instructions génériques suivantes :
```x86asm
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 : 

```x86asm
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.