Un langage d'assemblage ou langage assembleur est, en programmation informatique, le langage de plus bas niveau qui représente le langage machine sous une forme lisible par un humain. Les combinaisons de bits du langage machine sont représentées par des symboles dits « mnémoniques », c'est-à-dire faciles à retenir. Le programme assembleur convertit ces mnémoniques en langage machine, ainsi que les valeurs (écrites en décimal) en binaire et les libellés d'emplacements en adresses, en vue de créer par exemple un fichier objet ou un fichier exécutable.
Dans la pratique courante, le même terme assembleur est utilisé à la fois pour désigner le langage d'assemblage et le programme assembleur qui le traduit. On parle ainsi de « programmation en assembleur ».
La traduction une fois pour toutes par beaucoup d'interpréteurs de chaque nom de variable rencontré dans une instruction (évoluée) par la position mémoire associée et de chaque constante (écrite par l'utilisateur en décimal) en binaire est typique d'une opération d'assemblage, bien que le nom d'assembleur ne soit pas couramment utilisé dans ce cas précis. Cette opération s'appelle la compilation. Un programme compilé s'exécute beaucoup plus rapidement qu'un programme interprété.
Histoire vignette|Carte formatée pour être perforée pour l'assembleur de l'IBM 1620.|alt=La carte fait apparaître plusieurs zones de colonne pour correctement séparer le numéro de ligne, l'étiquette ou label, l'instruction et les opérandes.
Les programmes de l'EDSAC (1949)., premier calculateur à programmes enregistrés, étaient rédigés en utilisant des mnémoniques alphabétiques d'une lettre pour chaque instruction. La traduction était alors faite à la main par les programmeurs. Cette opération était longue, fastidieuse et entachée d'erreurs.
Le premier programme assembleur a été écrit par Nathaniel Rochester pour l'IBM 701 (le premier ordinateur commercialisé par IBM) en 1954.
Les langages d'assemblage ont éliminé une grande partie des erreurs commises par les programmeurs de la première génération d'ordinateurs, en les dispensant de mémoriser les codes numériques des instructions et de faire des calculs d'adresses. La programmation en assembleur était alors utilisée pour écrire toutes sortes de programmes.
Dans les années 1970-1980, l'utilisation de l'assembleur pour écrire des applications a été très largement supplantée par l'emploi de langages de programmation de haut niveau : Fortran, COBOL, PL/I, etc. : la puissance des machines le permettait, et consacrer quelques minutes de temps machine à une compilation pour économiser quelques heures de temps de programmeur était une opération rentable, même si les compilateurs de l'époque fournissaient un code moins performant (plus volumineux et souvent plus lent). Par ailleurs, ces langages de haut niveau permettaient de s'affranchir de la dépendance à une architecture matérielle unique. De plus, le code est nettement plus facile à lire, même pour son propre auteur, et réduit le risque d'un bug.
Les systèmes d'exploitation ont été écrits en langage d'assemblage jusqu'à l'introduction de MCP de Burroughs, en 1961, qui était écrit en ESPOL, dialecte d'Algol.
L'assembleur est revenu quelque peu en faveur sur les premiers micro-ordinateurs, où les caractéristiques techniques (taille mémoire réduite, puissance de calcul faible, architecture spécifique de la mémoire, etc.) imposaient de fortes contraintes, auxquelles s'ajoutaient un facteur psychologique important : l'attitude « hobbyiste » des premiers utilisateurs de micro-ordinateurs, qui ne se satisfaisaient pas de la lenteur des programmes écrits avec le BASIC interprété, généralement fourni avec l'ordinateur. De plus, un programme peut être écrit en BASIC ou un autre langage (plus lisibles) avec des appels à du code écrit en assembleur pour les parties du programme qui prennent le plus de temps.
De gros programmes ont été écrits entièrement en assembleur pour les micro-ordinateurs, comme le système d'exploitation DOS de l'IBM PC (environ 4000 lignes de code) et le tableur Lotus 1-2-3 (son rival Multiplan, qui existait déjà sous CP/M, était écrit en C). Dans les années 1990, c'était aussi le cas pour la plupart des jeux pour consoles vidéo (par exemple pour la Mega Drive ou la Super Nintendo).
Particularités de l'assembleur Un langage spécifique pour chaque processeur Le langage machine est le seul langage qu'un processeur puisse exécuter. Or chaque famille de processeurs utilise un jeu d'instructions différent.
Par exemple, un processeur de la famille x86 reconnaît une instruction du type : 10110000 01100001 En langage assembleur, cette instruction est représentée par un équivalent plus facile à comprendre pour le programmeur : movb $0x61,%al
(10110000 = movb %al 01100001 = $0x61)
Ce qui signifie : « écrire le nombre 97 (la valeur est donnée en hexadécimal : 61 = 97) dans le registre AL ».
Ainsi, le langage assembleur, représentation exacte du langage machine, est spécifique de chaque architecture de processeur. De plus, plusieurs groupes de mnémoniques ou de syntaxes de langage assembleur peuvent exister pour un seul ensemble d'instructions, créant ainsi des macro-instructions.
Désassemblage La transformation du code assembleur en langage machine est accomplie par un programme nommé programme assembleur. L'opération inverse, à savoir retrouver l'assembleur équivalent à un morceau de code machine, porte un nom : il s'agit de désassemblage.
Contrairement à ce que l'on pourrait penser, il n'y a pas toujours de correspondance un à un (une bijection) entre le code assembleur et le langage machine. Sur certains processeurs, le désassemblage peut donc donner un code dont la compréhension est très difficile pour un humain tout en restant parfaitement compilable par un ordinateur (code impénétrable). L'impossibilité d'un désassemblage peut avoir diverses raisons : usage de code auto-modifiant, instructions de taille variable, impossibilité de faire la différence entre code et données, etc.
Qui plus est, de nombreux éléments présents dans un code assembleur sont perdus lors de sa traduction en langage machine. Lors de la création du code en assembleur, le programmeur peut affecter des noms aux positions en mémoire, commenter son code, utiliser des macro-instructions ou utiliser du code généré sous conditions au moment de l'assemblage. Tous ces éléments sont réduits lors de l'assemblage à ce qui est strictement nécessaire pour la machine et n'apparaissent donc pas clairement lors du désassemblage : par exemple, une position en mémoire n'est repérée que par son adresse numérique ou par un offset.
Instructions machine Certaines opérations fondamentales sont disponibles dans la plupart des jeux d'instructions : déplacement dans la mémoire : chargement d'une valeur dans un registre, déplacement d'une valeur depuis un emplacement mémoire dans un registre, et inversement ; calcul : addition ou soustraction des valeurs de deux registres et chargement du résultat dans un registre, combinaison de valeurs de deux registres suivant une opération booléenne (ou opération bit à bit) ; modification du déroulement du programme : saut à un autre emplacement dans le programme (normalement, les instructions sont exécutées séquentiellement, les unes après les autres), saut à un autre emplacement, mais après avoir sauvegardé l'emplacement de l'instruction suivante afin de pouvoir y revenir (point de retour), retour au dernier point de retour ; comparaison : comparer les valeurs de deux registres.
Et on trouve des instructions spécifiques avec une ou quelques instructions pour des opérations qui auraient dû en prendre beaucoup : déplacement de grands blocs de mémoire ; multiplication, division ; arithmétique lourde (sinus, cosinus, racine carrée, opérations sur des vecteurs) ; application d'une opération simple (par exemple, une addition) à un ensemble de données par l'intermédiaire des extensions MMX ou SSE des nouveaux processeurs.
Directives du langage assembleur En plus de coder les instructions machine, les langages assembleur ont des directives supplémentaires pour assembler des blocs de données et affecter des adresses aux instructions en définissant des étiquettes ou labels.
Ils sont capables de définir des expressions symboliques qui sont évaluées à chaque assemblage, rendant le code encore plus facile à lire et à comprendre.
Ils ont habituellement un langage macro intégré pour faciliter la génération de codes ou de blocs de données complexes.
Exemples simples Voici quelques exemples simples : en syntaxe AT&T (écrits pour l'assembleur GNU (GAS) pour Linux) ; utilisant le jeu d'instructions i386 ; à utiliser comme suit : $ gcc foo.S -c -o foo.o $ ld foo.o -o foo $ ./foo
Afficher Bonjour (Les commentaires se trouvent après les points-virgules)
str: .ascii "Bonjour\n" .global _start
_start: movl $4, %eax movl $1, %ebx movl $str, %ecx movl $8, %edx int $0x80 movl $1, %eax movl $0, %ebx int $0x80
;Compilation: ;as code.s -o code.o ;ld code.o -o code
;Execution: ;./code
Lire le clavier (16 caractères max) puis l'afficher # define N 16
.global _start
.comm BUFF , N
_start: mov $3 , %eax mov $0 , %ebx mov $BUFF , %ecx mov $N , %edx int $0x80
mov %eax , %edx mov $4 , %eax mov $1 , %ebx mov $BUFF , %ecx int $0x80
mov $1 , %eax mov $0 , %ebx int $0x80
Exemples simples, syntaxe Intel x86 Voici les mêmes exemples, avec quelques différences : en syntaxe Intel x86, écrit pour l'assembleur NASM ; utilisant le jeu d'instructions i386 ; à utiliser comme suit : $ nasm -f elf foo.asm $ ld -o foo foo.o -melf_i386 $ ./foo
Afficher Bonsoir (Les commentaires se trouvent après les points-virgules)
section .data ; Variables initialisées Buffer: db 'Bonsoir', 10 ; En ascii, 10 = '\n'. La virgule sert à concaténer les chaines BufferSize: equ $-Buffer ; Taille de la chaine
section .text ; Le code source est écrit dans cette section global _start ; Définition de l'entrée du programme
_start: ; Entrée du programme
mov eax, 4 ; Appel de sys_write mov ebx, 1 ; Sortie standard STDOUT mov ecx, Buffer ; Chaine à afficher mov edx, BufferSize ; Taille de la chaine int 80h ; Interruption du kernel
mov eax, 1 ; Appel de sys_exit mov ebx, 0 ; Code de retour int 80h ; Interruption du kernel
Lire le clavier (64 caractères max) puis l'afficher section .bss ; Section des variables non-initialisees Buffer: resb 64 ; Reservation de 64 blocs (octets ?) memoire pour la variable où sera stockee l'entree de l'utilisateur BufferSize: equ $-Buffer ; taille de cette variable
section .text ; Section du code source global _start
_start: ; Entree du programme
mov eax, 3 ; Appel de sys_read mov ebx, 0 ; Entree standard STDIN mov ecx, Buffer ; Stockage de l'entree de l'utilisateur mov edx, BufferSize ; Taille maximale int 80h ; Interruption du kernel
mov eax, 4 ; Appel de sys_write mov ebx, 1 ; Sortie standard STDOUT mov ecx, Buffer ; Chaine à afficher mov edx, BufferSize ; Taille de la chaine int 80h ; Interruption du kernel
mov eax, 1 ; Appel de sys_exit mov ebx, 0 ; Code de retour int 80h ; Interruption du kernel
Usage du langage assembleur Il y a des débats sur l'utilité du langage assembleur. Dans beaucoup de cas, des compilateurs-optimiseurs peuvent transformer du langage de haut niveau en un code qui tourne aussi efficacement qu'un code assembleur écrit à la main par un très bon programmeur, tout en restant beaucoup plus facile, rapide (et donc moins coûteux) à écrire, à lire et à maintenir. Et réduisant ainsi les risques d'un bug (à la fois avec une meilleure lisibilité et une détection par le compilateur d'erreurs ou de warnings). Il y a aussi des programmes spéciaux qui font des suggestions pour écrire mieux le code ou signaler quelque chose non repéré par le compilateur.