Assembleur

Carte formatée pour être perforée pour l'assembleur de l'IBM 1620.

Les programmes de l'EDSAC (1949)[1], 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, une opération longue, fastidieuse et entachée d'erreurs.

Le premier programme assembleur a été écrit par Nathaniel Rochester (en) pour l'IBM 701 (le premier ordinateur commercialisé par IBM) en 1954.

Les langages d'assemblages 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'ajoute 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).

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

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

# 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

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

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

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

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 les risques d'un bug (parce que lisible, parce que les compilateurs détectent automatiquement de plus en plus 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.

Le débat sur l'efficacité du code assembleur produit par un humain et celui produit par un compilateur avait déjà lieu dans les années 1950, comme l'atteste le manuel du langage Fortran (publié en 1956) pour l'ordinateur IBM 704 : Object programs produced by Fortran will be nearly as efficient as those written by good programmers.

Les compilateurs ayant entre-temps fait d'énormes progrès, il est donc évident que l'immense majorité des programmes sont maintenant écrits en langages de haut niveau pour des raisons économiques, le surcoût de programmation l'emportant très largement sur le gain résultant de l'amélioration espérée des performances.

Cependant, il reste quelques cas très spécifiques où l'utilisation de l'assembleur se justifie encore :

1. Quelques calculs complexes écrits directement en assembleur, en particulier sur des machines massivement parallèles, seront plus rapides, les compilateurs n'étant pas assez évolués pour tirer parti des spécificités de ces architectures ;
2. Certains pilotes (drivers) sont parfois plus simples à écrire en langage de bas niveau ;
3. Des tâches très dépendantes du système, exécutées dans l'espace mémoire du système d'exploitation sont parfois difficiles, voire impossibles à écrire dans un langage de haut niveau. Par exemple, les instructions assembleur qui permettent à Windows de gérer le changement de tâche (LGDT et LLDT) sur microprocesseur i386 et suivants ne peuvent pas être émulées ou générées par un langage évolué. Il faut nécessairement les coder dans un court sous-programme assembleur qui sera appelé à partir d'un programme écrit en langage évolué.

Certains compilateurs transforment, lorsque leur option d'optimisation la plus haute n'est pas activée, des programmes écrits en langage de haut niveau en code assembleur, chaque instruction de haut niveau se traduisant en une série d'instructions assembleur rigoureusement équivalentes et utilisant les mêmes symboles ; cela permet de voir le code dans une optique de débogage et de profilage, ce qui permet de gagner parfois beaucoup plus de temps en remaniant un algorithme. En aucun cas ces techniques ne peuvent être conservées pour l'optimisation finale.

La programmation des systèmes embarqués, souvent à base de microcontrôleurs, est une « niche » traditionnelle pour la programmation en assembleur. En effet ces systèmes sont souvent très limités en ressources (par exemple un microcontrôleur PIC 16F84 est limité à 1 024 instructions de 14 bits et sa mémoire vive contient 136 octets) et requièrent donc une programmation de bas niveau très optimisée pour en exploiter les possibilités. Toutefois, l'évolution du matériel fait que les composants de ces systèmes deviennent de plus en plus puissants à un coût et à une consommation électrique constants, l'investissement dans une programmation « tout assembleur » beaucoup plus coûteuse en heures de travail devient alors un non-sens en termes d'efforts. Typiquement, la programmation en assembleur est beaucoup plus longue, plus délicate (car le programmeur doit prendre en compte tous les micro-détails du développement dont il s'abstient en langage évolué) et donc considérablement plus coûteuse que la programmation en langage de haut niveau. Il ne faut donc la réserver qu'aux situations pour lesquelles on ne peut pas faire autrement.

Beaucoup d'assembleurs gèrent un langage de macros. Il s'agit de regrouper plusieurs instructions afin d'avoir un enchaînement plus logique et moins fastidieux.
Par exemple (en assembleur Microsoft MASM) :

  putchar Macro   car          ; Prototype de la macro
          ifdef   car          ; si car est défini
          mov     dl,car       ;   le mettre dans dl
          endif
          mov     ah,2         ; ah=2 : fonction "putchar" en DOS
          int     21h          ; appel au DOS
          endm                 ; fin macro

est une macro qui affiche un caractère sous MS-DOS. On l'utilisera par exemple ainsi :

        putchar "X"

Et cela générera :

        mov    dl,"X"
        mov    ah,2
        int    21h

Support pour programmation structurée : quelques éléments de programmation structurée ont été intégrés pour encoder le flux d'exécution par le docteur H. D. Mills (mars 1970), et mis en œuvre par Marvin Kessler qui a étendu l'assembleur S/360 macro avec if / else / endif et même des blocs de contrôle de flux. Cela a été un moyen de réduire ou d'éliminer l'utilisation des opérations de sauts dans le code assembleur.

• Programme assembleur
• Programmation informatique
• Langage machine
• Langage de bas niveau