Assembleur
Page d'aide sur les redirections Cet article concerne le langage d'assemblage. Pour le programme produisant un exécutable à partir d'un source écrit dans ce langage, voir Programme assembleur.

Un langage d'assemblage ou langage assembleur ou simplement assembleur par abus de langage, abrégé ASM est, en programmation informatique, un langage de 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 » (du grec mnêmonikos, relatif à la mémoire), c'est-à-dire faciles à retenir. Le programme assembleur convertit ces mnémoniques en langage machine en vue de créer par exemple un fichier exécutable.

Sur les premiers ordinateurs, la tâche d'assemblage était accomplie manuellement par le programmeur.

Sommaire

Particularités de l'assembleur

Un langage spécifique à chaque processeur

Le langage machine est le seul langage qu'un processeur puisse exécuter. Or chaque famille de processeur 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 : « mettre la valeur hexadécimale 61 dans le registre "AL" ».

Ainsi le langage assembleur, représentation exacte du langage machine, est spécifique à 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.

Réversibilité du langage machine

Contrairement à un langage de haut niveau, il y a une correspondance un à un (une bijection) entre le code assembleur et le langage machine. Ainsi il est théoriquement possible de traduire le code dans les deux sens sans perte d'information. La transformation du code assembleur en langage machine est accomplie par un programme nommé assembleur, dans l'autre sens par un programme désassembleur. Les opérations s'appellent respectivement assemblage et désassemblage.

En pratique, le désassemblage est un peu plus complexe que cela car lors de la création du code en assembleur on peut affecter des noms aux positions en mémoire, commenter son code, utiliser des macro instructions ou générer du code conditionnel au moment de l'assemblage. Tous ces éléments n'apparaissent pas clairement lors du désassemblage.

Instructions machine

Des opérations de base sont disponibles dans la plupart des jeux d'instructions

  • déplacement :
    • 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'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. Exemples :

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 assigner 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-virgule)

         .globl _start
 BONJ:   .ascii  "Bonjour\n"      ; Definition en memoire de la chaine a afficher. \n correspond au saut de ligne
 _start: mov     $4      , %eax   ; Mettre 4 dans le registre eax (appel système '''Write'')
         mov     $1      , %ebx   ; Mettre 1 dans le registre ebx (descripteur de fichier ''STDOUT'')
         mov     $BONJ   , %ecx   ; Mettre l'adresse memoire de notre chaine de caractere dans le registre ecx
         mov     $8      , %edx   ; Mettre la taille de la chaine dans edx
         int     $0x80            ; Interruption 0x80, executant un appel systeme sous Linux)
 
         mov     $1      , %eax   ; Mettre 1 dans eax (appel systeme ''Exit'')
         mov     $0      , %ebx   ; Mettre 0 dans ebx (valeur de retour du programme)
         int     $0x80            ; Interruption 0x80, executant un appel système sous Linux)

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 foo.o -o foo
$ ./foo

Afficher Bonjour

(les commentaires se trouvent après les points-virgule)

section .data    ; Variables initialisées
        Buffer:           db 'Bonjour', 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-initialisées
        BufferSize:   resb 64                       ; Réservation de 64 blocs mémoire
        Buffer:         equ $-BufferSize          ; Variable où sera stockée l'entrée de l'utilisateur
 
section .text                                           ; Section du code source
        global _start
 
 _start:                                                   ; Entrée du programme
 
        mov eax, 3                                     ; Appel de sys_read
        mov ebx, 0                                     ; Entrée standard STDIN
        mov ecx, Buffer                              ; Stockage de l'entrée de l'utilisateur
        mov edx, BufferSize                        ; Taille maximale
        int 80h                                            ; Interruption du kernel
 
        mov eax, 4                                     ; Appel de sys_read
        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 dans un code qui tourne de façon presque aussi efficace qu'un code assembleur écrit à la main, tout en restant beaucoup plus facile (et moins coûteux) à écrire, à lire et à maintenir.

Cependant,

  1. quelques calculs complexes écrits directement en assembleur, en particulier sur des machines massivement parallèles, seront plus rapides, les compilateurs n'étant pas encore assez évolués pour tirer parti des spécificités de ces architectures ;
  2. certaines routines (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é à 1024 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 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.

Macro-assembleur

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

Pseudo-instructions

Une pseudo-instruction est un type particulier de macro-instruction. Elle est prédéfinie par l'éditeur du logiciel assembleur et sa fonction est d'émuler une instruction manquante du processeur ou de faciliter l'usage d'une instruction existante. Comme la pseudo-instruction a un nom très ressemblant à celui d'une vraie instruction du processeur, il est possible à première vue de la confondre avec une de ces dernières. Par exemple, un processeur RISC peut ne pas posséder d'instruction JMP, instruction permettant de sauter à un point particulier du programme et de continuer son exécution en séquence. L'éditeur du logiciel aura dans ce cas créé à l'intention du programmeur une pseudo-instruction « JMP <paramètre> », qui sera remplacée à l'assemblage par une instruction « mov pc, <paramètre> », pc étant le pointeur de l'instruction sur le point d'être exécutée. Autre exemple, une pseudo-instruction « PUSH <paramètre> » sera remplacée par un stockage de <paramètre> à l'adresse pointée par sp avec pré-décrémentation de celui-ci, sp étant le pointeur de pile du processeur.

Sur des microprocesseurs ou microcontroleurs RISC tels que ceux de la famille ARM, il n'existe pas d'instruction assembleur permettant de charger n'importe quelle constante immédiate dans un registre, quelle que soit sa valeur. La plupart des assembleurs disposent d'une pseudo-instruction permettant un tel chargement de la façon la plus efficace possible en termes de temps d'exécution, épargnant cette tâche au programmeur.

Programmation structurée en assembleur

Support pour programmation structurée : quelques éléments de programmation structurée ont été integrés pour encoder le flux d'exécution par Dr. 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 GOTO dans le code assembleur.

Voir aussi

Articles connexes

Liens externes

Sur les autres projets Wikimedia :


Wikimedia Foundation. 2010.

Contenu soumis à la licence CC-BY-SA. Source : Article Assembleur de Wikipédia en français (auteurs)

Regardez d'autres dictionnaires:

  • assembleur — assembleur, euse [ asɑ̃blɶr, øz ] n. • apr. 1650; assembleor 1281; de assembler 1 ♦ Ouvrier, ouvrière qui assemble des pièces. ⇒ monteur. Assembleur de charpente en fer. N. f. Machine pour assembler les feuilles imprimées. 2 ♦ N. m. (v. 1965, de… …   Encyclopédie Universelle

  • assembleur — assembleur, euse (a san bleur, bleû z ) s. m. et f. 1°   Ouvrier, ouvrière qui fait les assemblages après le tirage des volumes. 2°   Poétiquement. •   ... Notre engeance Prit pied sur cette indulgence.... Et l assembleur de nuages Jura le Styx,… …   Dictionnaire de la Langue Française d'Émile Littré

  • assembleur — ● n. m. ● 1. ►CIEL Logiciel qui permet de compiler du code source en langage d assemblage. ● 2. ►LANG Nom d usage d une version un peu humanisée du langage machine (celui du processeur). Les instructions sont celles de la machine, mais un… …   Dictionnaire d'informatique francophone

  • Assembleur — As|sem|bleur [asã blø:ɐ̯] der; s, s <aus gleichbed. fr. assembleur> (veraltet) Beschäftigter in der Buchbinderei, der die einzelnen Druckbogen eines Buches zusammenträgt …   Das große Fremdwörterbuch

  • ASSEMBLEUR — EUSE. s. Ouvrier, ouvrière qui fait les assemblages, dans une imprimerie ou une librairie …   Dictionnaire de l'Academie Francaise, 7eme edition (1835)

  • Assembleur (langage) — Assembleur  Cet article concerne le langage d assemblage. Pour le programme produisant un exécutable à partir d un source écrit dans ce langage, voir Programme assembleur. Un langage d assemblage ou langage assembleur ou simplement… …   Wikipédia en Français

  • Assembleur D'ordinateur — Un assembleur d ordinateur est la personne qui assemble les ordinateurs personnels, dits « PC » (« Peronnal Computer). Le métier consiste à assembler les pièces qui compose l ordinateur et à les installer dans un boîtier de… …   Wikipédia en Français

  • Assembleur moléculaire — Un assembleur moléculaire est un concept purement théorique. Tel que le définit Eric Drexler, il s agit d « une machine capable d encadrer les réactions chimiques en positionnant les molécules réactives avec une précision nanométrique… …   Wikipédia en Français

  • ASSEMBLEUR, EUSE — n. Celui, celle qui assemble. Poétiquement, L’assembleur de nuages, Jupiter. Il se dit spécialement de Celui, celle qui fait les assemblages dans une imprimerie …   Dictionnaire de l'Academie Francaise, 8eme edition (1935)

  • Assembleur d'ordinateur — Un assembleur d ordinateur est la personne qui assemble les ordinateurs personnels, dits « PC » (Personal Computer). Le métier consiste à assembler les pièces qui compose l ordinateur et à les installer dans un boîtier de protection… …   Wikipédia en Français

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”