Menu
CoddyTech

Qu'est-ce que le langage assembleur ?

Le langage assembleur est un langage de programmation de bas niveau dans lequel les instructions d'un processeur s'écrivent une par ligne, avec des noms courts comme mov et add plutôt qu'avec des nombres binaires. Un programme appelé assembleur le traduit en code machine, que le processeur exécute.

Par Kevin Spektor, Cofondateur et CTO

Mis à jour le 16 novembre 2026

Ce programme affiche une ligne. Clique sur Run : il est assemblé avec NASM, lié en un programme Linux puis exécuté. Il parle directement à Linux par des appels système, sans la bibliothèque C.

Hello from assembly!

Chaque ligne sous _start est une instruction pour un processeur x86-64, celui de la plupart des PC sous Windows et Linux. Il n'y a pas de fonction print. Le programme place quatre nombres dans les registres du processeur et demande au noyau Linux d'écrire les octets.

Lire le programme ligne par ligne

section .data ouvre la partie du programme qui contient les données fixes. msg db "Hello from assembly!", 10 réserve des octets pour le texte, et db signifie « define bytes », définir des octets. Le 10 à la fin est le code du caractère de retour à la ligne.

len equ $ - msg est calculé par l'assembleur, pas par le processeur : $ est la position courante, donc la différence donne la longueur du message, 21 octets.

section .text contient les instructions. global _start rend l'étiquette _start visible pour l'éditeur de liens, qui la désigne comme l'endroit où le programme commence.

mov rax, 1 copie le nombre 1 dans le registre rax. Un registre est un petit emplacement de stockage situé dans le processeur lui-même, large de 64 bits sur x86-64, et la plupart des calculs se font dans des registres. Les trois lignes mov suivantes remplissent rdi, rsi et rdx de la même façon.

syscall passe la main au système d'exploitation. Linux regarde rax pour savoir quel service est demandé (1 correspond à write) et rdi, rsi et rdx pour ses arguments : où écrire, l'adresse des octets et leur nombre. Le second syscall, avec 60 dans rax, termine le programme avec le code de sortie 0.

Les mots après ; sont des commentaires. L'assembleur les ignore, et en assembleur ils comptent plus que dans la plupart des langages, car les instructions disent ce qui se passe mais pas pourquoi.

Comment l'assembleur devient un programme

Le processeur ne sait pas lire le texte ci-dessus. Un assembleur le traduit en code machine, et un éditeur de liens en fait un fichier que le système d'exploitation peut exécuter :

  1. L'assembleur (nasm -f elf64 hello.asm -o hello.o) traduit chaque instruction en ses octets et écrit un fichier objet.
  2. L'éditeur de liens (ld hello.o -o hello) inscrit les adresses mémoire définitives, comme l'emplacement de msg, et écrit l'exécutable.
  3. Lancer ./hello amène le noyau à charger ces octets en mémoire et à démarrer le processeur à _start.

Un désassembleur montre ce que l'assembleur a produit. Voici objdump -d -M intel hello.o, limité aux trois premières instructions :

0000000000000000 <_start>:
   0:   b8 01 00 00 00          mov    eax,0x1
   5:   bf 01 00 00 00          mov    edi,0x1
   a:   48 be 00 00 00 00 00    movabs rsi,0x0
  11:   00 00 00

Chaque ligne d'assembleur est devenue une instruction de 2 à 10 octets. Deux détails montrent que l'assembleur fait plus que recopier : NASM a choisi un encodage plus court pour mov rax, 1, puisque écrire dans eax efface aussi la moitié haute de rax, et l'adresse de msg ne contient encore que des zéros, car seul l'éditeur de liens la connaît. La page sur le code machine lit ces octets un par un.

C'est la différence avec un compilateur. Un compilateur part d'un langage comme le C, où une ligne peut devenir de nombreuses instructions, et choisit lui-même ces instructions. En assembleur, c'est toi qui choisis chaque instruction.

Les registres font le travail

L'assembleur n'a pas de variables déclarées avec un type, comme en Python ou en C. C'est toi qui décides où se trouve chaque valeur : dans un registre pendant que le processeur travaille dessus, ou en mémoire, où une étiquette comme digit donne un nom à l'adresse. Ce programme additionne deux nombres et affiche le résultat :

7

La somme est le nombre 7, mais l'écran affiche des caractères, donc le programme ajoute 48, le code du caractère 0, avant de l'écrire. al est l'octet le plus bas de rax, et [digit] entre crochets signifie « la mémoire à l'adresse digit ». Remplace le 5 par 15 et la sortie devient A, le caractère de code 65 : afficher un nombre à deux chiffres demande une boucle qui divise par 10. Voilà tout le compromis de l'assembleur en un exemple. Tu contrôles chaque étape, et tu dois écrire chaque étape.

Un langage assembleur par famille de processeurs

L'assembleur n'est pas un langage unique. Chaque famille de processeurs a ses propres instructions, registres et règles, et du code écrit pour l'une ne fonctionne pas sur une autre. Voici la même opération, « mettre 1 dans le premier registre d'argument », dans trois d'entre elles :

x86-64 (NASM):  mov rdi, 1
ARM64:          mov x0, #1
RISC-V:         li a0, 1
  • x86-64 équipe la plupart des PC et serveurs sous Windows et Linux, avec des processeurs Intel et AMD. Ses deux syntaxes placent les opérandes dans l'ordre inverse : la syntaxe Intel écrit mov rax, 1, et la syntaxe AT&T, celle par défaut des outils GNU, écrit movq $1, %rax.
  • ARM64, aussi appelé AArch64, équipe presque tous les téléphones, les Mac à puce Apple silicon et une part croissante des serveurs cloud.
  • RISC-V est un jeu d'instructions ouvert, répandu dans les microcontrôleurs et l'enseignement.

Des familles plus anciennes comme le 8086, le 6502 et MIPS sont encore enseignées à l'université parce qu'elles sont petites. Les idées se transposent de l'une à l'autre : registres, adresses mémoire, comparaison et saut.

À quoi sert le langage assembleur

  • Les systèmes d'exploitation. Le code qui démarre le processeur, gère les interruptions et passe d'un programme à l'autre est en partie écrit en assembleur. Le noyau Linux le range dans un dossier séparé pour chaque famille de processeurs.
  • Les boucles où la vitesse est critique. Des décodeurs vidéo comme dav1d et des outils multimédias comme FFmpeg utilisent de l'assembleur écrit à la main pour les quelques boucles où ils passent le plus de temps.
  • Les systèmes embarqués. Les toutes petites puces, avec quelques kilo-octets de mémoire, ont parfois besoin d'un code où chaque octet est choisi.
  • Lire ce qu'un compilateur a produit. gcc -S et des sites comme Compiler Explorer montrent l'assembleur qui se cache derrière du code C, C++ ou Rust, et c'est ainsi qu'on vérifie les optimisations.
  • La sécurité et la rétro-ingénierie. Un programme sans son code source peut quand même être désassemblé, et c'est ainsi que les analystes de logiciels malveillants et les développeurs d'exploits le lisent.
  • Comprendre comment fonctionne un ordinateur. Une erreur de segmentation, un dépassement de pile ou un pointeur prend beaucoup plus de sens une fois qu'on a écrit les instructions qui se cachent derrière.

Idées reçues sur l'assembleur

  • « L'assembleur, c'est du code machine. » C'est du texte qui correspond de très près au code machine. Les étiquettes, les commentaires, db et equ n'existent que pour l'assembleur, et il choisit les encodages pour toi, comme l'a montré mov rax, 1.
  • « L'assembleur est toujours plus rapide. » Un code n'est rapide que si les instructions choisies le sont, et les compilateurs modernes choisissent très bien. L'assembleur écrit à la main gagne dans des cas étroits, en général des boucles qui utilisent des instructions spéciales, et ceux qui l'écrivent mesurent d'abord.
  • « Il faut apprendre l'assembleur avant tout autre langage. » Non. C'est un bon deuxième ou troisième langage : une fois que tu sais ce que sont une variable et une boucle, il est plus facile de voir comment le processeur les exécute.

Pour aller plus loin

Modifie les programmes ci-dessus dans le playground Assembleur, qui utilise la même chaîne d'outils x86-64 NASM. L'aide-mémoire Assembleur liste les registres, les instructions et les appels système Linux sur une seule page. Pour voir en détail ce que produit l'assembleur, lis ce qu'est le code machine, et pour pratiquer pas à pas les registres, la mémoire, les appels système, l'arithmétique et les boucles, suis le cours d'assembleur gratuit.

Questions fréquentes

Le langage assembleur est-il encore utilisé aujourd'hui ?

Oui, mais à des endroits précis et peu nombreux. Les noyaux de systèmes d'exploitation l'utilisent pour le code qui démarre le processeur et passe d'un programme à l'autre, le firmware des toutes petites puces l'utilise là où chaque octet compte, et des décodeurs vidéo comme dav1d emploient de l'assembleur écrit à la main pour leurs boucles les plus sollicitées. Beaucoup de développeurs qui n'en écrivent jamais en lisent quand même, pour déboguer un plantage, vérifier ce qu'un compilateur a produit ou analyser un logiciel malveillant.

L'assembleur est-il plus difficile que le C++ ?
Le langage lui-même est plus petit : quelques dizaines d'instructions courantes, des registres et la mémoire. Écrire un programme complet est plus difficile, car tu gères toi-même les registres, la mémoire et le flux de contrôle. Il n'y a ni types, ni instructions de boucle, ni print, si bien qu'une seule ligne de C++ peut demander dix lignes d'assembleur.
Quelle est la différence entre le langage assembleur et le programme assembleur ?
Le langage assembleur est le langage : le texte que tu écris, par exemple mov rax, 1. Un assembleur est le programme qui traduit ce texte en code machine, comme NASM, l'assembleur GNU as ou MASM de Microsoft. On dit souvent "assembleur" pour désigner aussi le langage, en particulier en allemand, en russe et en polonais, où c'est le nom habituel.
Le C++ est-il un langage assembleur ?
Non. Le C++ est un langage de haut niveau : un compilateur le traduit, et une ligne peut devenir de nombreuses instructions machine, que le compilateur sait produire pour chaque famille de processeurs qu'il prend en charge. L'assembleur est lié à une famille de processeurs, et chaque ligne est une instruction. Les compilateurs comme GCC peuvent te montrer l'assembleur qu'ils génèrent pour ton code C++ avec l'option -S.
Combien existe-t-il de langages assembleur ?

Un par famille de processeurs, avec en plus plusieurs syntaxes pour certaines. Les plus courants aujourd'hui sont x86-64 pour les PC Intel et AMD, ARM64 pour les téléphones et les Mac à puce Apple silicon, et RISC-V. Pour x86-64 seul, il existe deux syntaxes, Intel (utilisée par NASM et MASM) et AT&T (celle par défaut de l'assembleur GNU).

Illustration des langages de programmation de Coddy

Apprendre à coder avec Coddy

Commencer