Assembleur

Le langage assembleur ou langage d'assemblage, dit aussi assembleur ou abrégé ASM, est le langage de programmation lisible pour un humain le plus proche du langage machine utilisé par le microprocesseur de la machine. Le langage machine est une combinaison de bits, il est rendu lisible en remplaçant les valeurs brutes par des symboles appelés mnémoniques (du grec mnêmonikos, relatif à la mémoire) simples et plus faciles à retenir.

Par exemple, alors qu'un processeur de la famille x86 reconnaîtra ce que l'instruction machine

 10110000 01100001

signifie, pour le programmeur c'est plus simple de se souvenir de son équivalent en langage assembleur :

 mov %al,$0x61

(cela signifie de mettre la valeur hexadécimale 61 (97 en décimal) dans la partie de registre 'AL'.)

Contrairement à un langage de haut niveau, il y a une correspondance un à un entre le code assembleur et le langage machine, ainsi il est possible de traduire le code dans les deux sens sans perdre 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. Dans un programme réel en assembleur, c'est un peu plus complexe que cela (on peut donner des noms aux routines, aux variables), et on n'a plus cette correspondance. Sur les premiers ordinateurs, la tâche d'assemblage était accomplie manuellement par le programmeur.

Chaque architecture d'ordinateurs a son propre langage machine, et donc son propre langage d'assemblage (l'exemple ci-dessus est pour le x86). Ces différents langages diffèrent par le nombre et le type d'opérations qu'ils ont à supporter. Ils peuvent avoir des tailles et des nombres de registres différents, et différentes représentations de type de données en mémoire. Tous les ordinateurs sont capables de faire les mêmes choses, ils peuvent les faire de manières différentes.

De plus, plusieurs groupes de mnémoniques ou de syntaxes de langage assembleur peuvent exister pour un seul ensemble d'instructions.

Sommaire

1 Le sens des transferts
2 Instructions machine
3 Exemples simples
- 3.1 Afficher Bonjour
- 3.2 Lire le clavier (16 caractères max) puis l'afficher
4 Directives du langage assembleur
5 Usage du langage Assembleur
6 Macro-assembleur
7 Références

[modifier] Le sens des transferts

les opérandes peuvent être inversées.

Remarquons quand même que cette instruction se traduit dans la plupart des langages évolués par (ici en pseudo-C) :

Al = 0x61 ;

Cette syntaxe ("Intel") semble la plus logique. En effet la plupart des langages évolués ont une filiation (indirecte) avec le grand ancêtre Fortran qui a introduit cette convention.

Remarquons aussi que en français on dirait :

mettre 0x61 dans AL

et en langage Cobol on écrit

move 97 to AL

La syntaxe "AT&T" (opérandes inversées) semble alors la plus logique.

Mais en français on écrit aussi :

AL reçoit 0x61

qui semble tout aussi naturel. La langue parlée ne permet donc pas de justifier certaines préférences lorsqu'il s'agit de définir la syntaxe d'un langage de programmation.

[modifier] 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, soustraction, multiplication ou division des valeurs de deux registres et chargement du résultat dans un registre
- combinaison de valeurs de deux registres avec un et/ou logique
- rendre négative la valeur d'un registre arithmétiquement (complément à 2) ou par un non logique (complément à 1)
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 :

déplacement de grands blocs de mémoire
arithmétique lourde (sinus, cosinus, racine carrée, etc.)
application d'une opération simple (par exemple, une addition) à un ensemble de données

[modifier] Exemples simples

Voici quelques exemples simples :

en syntaxe AT&T (écrits pour l'assembleur GNU)
utilisant le jeu d'instructions i386
à utiliser comme suit :

$ as truc.s -o truc.o
$ ld truc.o -o truc
$ ./truc

[modifier] Afficher Bonjour

        .global _start

BONJ:   .ascii  "Bonjour\n"

_start: mov     $4      , %eax
        mov     $1      , %ebx
        mov     $BONJ   , %ecx
        mov     $8      , %edx
        int     $128

        mov     $1      , %eax
        mov     $0      , %ebx
        int     $128

[modifier] 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     $128

        mov     %eax    , %edx
        mov     $4      , %eax
        mov     $1      , %ebx
        mov     $BUFF   , %ecx
        int     $128

        mov     $1      , %eax
        mov     $0      , %ebx
        int     $128

[modifier] 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.

[modifier] 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 plus efficace qu'un code assembleur écrit à la main, tout en restant beaucoup plus facile (et moins coûteux) à écrire, à lire et à "maintenir".

Cependant,

quelques calculs complexes écrits directement en assembleur, en particulier sur des machines massivement parallèles, seront plus rapides,
certaines routines (drivers) sont parfois plus simples à écrire en langage de bas niveau.
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 à écrire dans un langage de haut niveau.

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.

Le 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 à coût constant, l'investissement dans une programmation "tout assembleur" beaucoup plus coûteuse en heures de travail devient alors un non-sens économique.

[modifier] 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

[modifier] Références

[modifier] Article connexe

Voir Programme assembleur

[modifier] Liens internes

FASM
MASM

[modifier] Liens externes

(fr) Cours complet d'Assembleur Les cours d'Iprezo
(fr) La F.A.Q Assembleur Les réponses à vos questions sur l'Assembleur
(fr) Tutoriels Assembleur
(fr) Le forum d'entraide Assembleur
(fr) ABC de la programmation en assembleur
(fr) AsmFR : site de passionnés qui mettent en commun leurs connaissances
NASM - Netwide Assembler

Portail de l'informatique – Accédez aux articles de Wikipédia concernant l’informatique.

Récupérée de « http://fr.wikipedia.org../../../a/s/s/Assembleur.html »

Catégories : Langage de programmation • Langage impératif