Chapitre 2 : Langage machine et assembleur¶

Programme officiel (B.O.)¶

B.O. spécial n° 1 du 22 janvier 2019 - NSI Première

Contenus	Capacités attendues	Commentaires
Modèle d'architecture séquentielle (von Neumann).	Dérouler l'exécution d'une séquence d'instructions simples du type langage machine.	Il s'agit de montrer comment sont exécutés des programmes écrits dans un langage de bas niveau.

1. Du programme au processeur¶

1.1 Les niveaux de langage¶

Un programme passe par plusieurs niveaux entre ce que le programmeur écrit et ce que le processeur exécute :

Langage de haut niveau (Python, JavaScript...)
        │
        ▼  (compilation ou interprétation)
Langage assembleur (mnémoniques : ADD, MOV, CMP...)
        │
        ▼  (assemblage)
Langage machine (suite de 0 et de 1)
        │
        ▼  (exécution)
Processeur (circuits électroniques)

Niveau	Exemple	Lisibilité
Langage de haut niveau	`x = x + 1`	Facile
Assembleur	`ADD R0, R0, #1`	Moyen
Langage machine	`11100010100000000000000000000001`	Illisible

1.2 Le langage machine¶

Le langage machine est le seul langage compris directement par le processeur. Chaque instruction est codée en binaire et comprend deux parties :

Le code opération (opcode) : indique l'opération à effectuer (addition, transfert, saut...)
Les opérandes : indiquent les données sur lesquelles opérer (registre, adresse mémoire, valeur immédiate)

┌──────────────┬───────────────────────┐
│  Code opér.  │      Opérandes        │
│   (opcode)   │ (registres, adresses) │
└──────────────┴───────────────────────┘

Programmer en langage machine est extrêmement difficile (longues suites de 0 et de 1), c'est pourquoi on utilise l'assembleur.

2. Le langage assembleur¶

2.1 Principe¶

L'assembleur remplace les codes binaires par des mnémoniques (abréviations faciles à retenir). Un programme appelé « assembleur » traduit ces mnémoniques en langage machine.

Par exemple : ADD R1, R0, #128 est bien plus lisible que 11100010100000000000000010000000.

2.2 Les types d'instructions¶

Les instructions assembleur se répartissent en trois catégories :

Instructions de transfert de données¶

Instruction	Signification	Exemple
`LDR Rd, adr`	Charger en registre depuis la mémoire	`LDR R1, 78` → R1 ← mémoire[78]
`STR Rd, adr`	Stocker un registre en mémoire	`STR R3, 125` → mémoire[125] ← R3
`MOV Rd, #val`	Placer une valeur immédiate dans un registre	`MOV R1, #23` → R1 ← 23
`MOV Rd, Rs`	Copier un registre dans un autre	`MOV R0, R3` → R0 ← R3

Instructions arithmétiques¶

Instruction	Signification	Exemple
`ADD Rd, Rs, #val`	Addition avec une valeur immédiate	`ADD R1, R0, #128` → R1 ← R0 + 128
`ADD Rd, Rs, Rt`	Addition de deux registres	`ADD R0, R1, R2` → R0 ← R1 + R2
`SUB Rd, Rs, #val`	Soustraction avec une valeur immédiate	`SUB R1, R0, #128` → R1 ← R0 - 128
`SUB Rd, Rs, Rt`	Soustraction de deux registres	`SUB R0, R1, R2` → R0 ← R1 - R2

Instructions de contrôle (branchement)¶

Instruction	Signification
`CMP Ra, #val`	Compare Ra avec une valeur (prépare un branchement)
`CMP Ra, Rb`	Compare Ra avec Rb
`B adr`	Branchement inconditionnel (saut à l'adresse)
`BEQ adr`	Branchement si égal (Branch if Equal)
`BNE adr`	Branchement si différent (Branch if Not Equal)
`BGT adr`	Branchement si supérieur (Branch if Greater Than)
`BLT adr`	Branchement si inférieur (Branch if Less Than)
`HALT`	Arrêt du programme

2.3 Les types d'opérandes¶

Un opérande peut être de trois natures :

Type	Notation	Exemple
Valeur immédiate	`#valeur`	`MOV R0, #42` (R0 ← 42)
Registre	`Rn`	`ADD R0, R1, R2` (R0 ← R1 + R2)
Adresse mémoire	`adresse`	`LDR R1, 78` (R1 ← mémoire[78])

3. Dérouler l'exécution d'un programme¶

3.1 Exemple 1 : calcul simple¶

Calculer 5 + 3 et stocker le résultat en mémoire à l'adresse 100 :

MOV R0, #5       ← R0 = 5
MOV R1, #3       ← R1 = 3
ADD R2, R0, R1   ← R2 = R0 + R1 = 8
STR R2, 100      ← mémoire[100] = 8
HALT             ← fin du programme

Déroulement pas à pas :

Étape	Instruction	R0	R1	R2	mémoire[100]
1	`MOV R0, #5`	5	—	—	—
2	`MOV R1, #3`	5	3	—	—
3	`ADD R2, R0, R1`	5	3	8	—
4	`STR R2, 100`	5	3	8	8
5	`HALT`	—	—	—	—

3.2 Exemple 2 : condition (if/else)¶

Programme Python :

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

Programme assembleur équivalent (x en mémoire 30, y en mémoire 75, z en mémoire 23) :

    MOV R0, #4       ← x = 4
    STR R0, 30       ← mémoire[30] = x
    MOV R0, #8       ← y = 8
    STR R0, 75       ← mémoire[75] = y
    LDR R0, 30       ← R0 = x
    CMP R0, #10      ← comparer x à 10
    BNE sinon        ← si x ≠ 10, aller à sinon
    MOV R0, #9       ← y = 9
    STR R0, 75
    B fin            ← sauter le bloc sinon
sinon:
    LDR R0, 30       ← R0 = x
    ADD R0, R0, #1   ← x = x + 1
    STR R0, 30
fin:
    MOV R0, #6       ← z = 6
    STR R0, 23
    HALT

Comme x = 4 ≠ 10, le branchement BNE sinon est pris : on exécute x = x + 1, ce qui donne x = 5. Puis z = 6.

3.3 Exemple 3 : boucle¶

Programme Python :

s = 0
for i in range(1, 4):
    s = s + i

Programme assembleur (s en mémoire 50, i en mémoire 51) :

    MOV R0, #0       ← s = 0
    STR R0, 50
    MOV R1, #1       ← i = 1
    STR R1, 51
boucle:
    CMP R1, #4       ← comparer i à 4
    BEQ fin          ← si i == 4, sortir de la boucle
    LDR R0, 50       ← R0 = s
    ADD R0, R0, R1   ← s = s + i
    STR R0, 50
    ADD R1, R1, #1   ← i = i + 1
    STR R1, 51
    B boucle         ← retour au début de la boucle
fin:
    HALT

Déroulement :

Itération	i	s avant	s + i	s après
1	1	0	0 + 1	1
2	2	1	1 + 2	3
3	3	3	3 + 3	6

Résultat final : s = 6.

4. Le simulateur¶

Pour expérimenter avec l'assembleur, on peut utiliser le simulateur de Peter L. Higginson qui permet de programmer en assembleur et de visualiser l'état des registres et de la mémoire à chaque étape.

L'interface montre :

Les registres (R0 à R12, IP, etc.) et leur contenu
La mémoire RAM avec les instructions et les données
Le déroulement pas à pas de l'exécution

En pratique

Le simulateur accepte les instructions présentées dans ce cours (LDR, STR, MOV, ADD, SUB, CMP, B, BEQ, BNE, BGT, BLT, HALT) et permet de visualiser chaque étape du cycle chargement-décodage-exécution.

À retenir¶

Le processeur ne comprend que le langage machine (suites de 0 et 1).
L'assembleur utilise des mnémoniques lisibles (ADD, MOV, CMP...) traduites en langage machine.
Trois types d'instructions : transfert (LDR, STR, MOV), arithmétique (ADD, SUB), contrôle (CMP, B, BEQ, BNE, BGT, BLT).
Le # indique une valeur immédiate, les noms R0, R1... désignent des registres, un nombre seul est une adresse mémoire.
Le cycle d'exécution : chargement (lire en mémoire) → décodage (analyser) → exécution (effectuer).
Les structures de contrôle (if, for) se traduisent en assembleur par des comparaisons (CMP) suivies de branchements conditionnels (BEQ, BNE...).