Assembleur

Infos
Un langage d'assemblage (ou langage assembleur ou simplement assembleur par abus de langage, abrégé ASM) est un langage de bas niveau proche du langage machine qui peut être directement interprété par le microprocesseur de l'ordinateur tout en restant lisible par un humain. L'assembleur a été créé pour faciliter le travail des programmeurs. Il consiste à représenter les combinaisons de bits employées en lang
Assembleur

Un langage d'assemblage (ou langage assembleur ou simplement assembleur par abus de langage, abrégé ASM) est un langage de bas niveau proche du langage machine qui peut être directement interprété par le microprocesseur de l'ordinateur tout en restant lisible par un humain. L'assembleur a été créé pour faciliter le travail des programmeurs. Il consiste à représenter les combinaisons de bits employées en langage binaire par des symboles appelés mnémoniques (du grec mnêmonikos, relatif à la mémoire), c'est à dire faciles à retenir. Par exemple, un processeur de la famille x86 reconnaît une instruction du type 10110000 01100001 En langage assembleur, cette instruction sera traduite par un équivalent plus facile à comprendre pour le programmeur : mov %al, $0x61 Ce qui signifie "mettre la valeur hexadécimale 61 (97 en décimal) dans le registre 'AL'.) Contrairement à un langage de haut niveau, il y a (excepté le cas des macros, ou macro-instructions) 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 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. 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 microprocesseur a son propre langage machine, et donc son propre langage d'assemblage (l'exemple ci-dessus est pour le x86). Ces différents microprocesseur ont des tailles de registres différentes et un jeu d'instructions plus ou moins étendu, selon leur conception et leur utilisation. 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.

Le sens des transferts

Les opérandes peuvent être inversés. Remarquons quand même que cette instruction se traduit dans la plupart des langages évolués par (ici en pseudo-C) : Al = 0x61 ; traduite en syntaxe Intel par mov 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; traduite en syntaxe AT&T par movl $0x61, %al et en langage Cobol on écrit move 97 to AL La syntaxe "AT&T" (opérandes inversés) 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.

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 :
- déplacement de grands blocs de mémoire
- multiplication, division
- arithmétique lourde (sinus, cosinus, racine carrée, operations 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.

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 truc.S -c -o truc.o $ ld truc.o -o truc $ ./truc

Afficher Bonjour

(les commentaires se trouvent après les points-virgule) .global _start BONJ: .ascii "Bonjour\n" ; Definition en mémoire de la chaîne 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 ; Mette l'adresse mémoire de notre chaîne de caractere dans le registre ecx mov $8 , %edx ; Mettre la taille de la chaîne dans edx int $0x80 ; Interruption 0x80, executant un appel systeme sous Linux) mov $1 , %eax ; Mettre 1 dans eax (appel système Exit) mov $0 , %ebx ; Mettre 0 dans ebx (valeur de retour du programme) int $0x80 ; Interruption 0x80, executant un appel systeme 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

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.

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, les compilateurs n'étant pas encore assez évolués pour tirer partie des spécificités de ces architectures.
-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 bas 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. 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 à coût et a une consommation élèctrique constants, l'investissement dans une programmation "tout assembleur" beaucoup plus coûteuse en heures de travail devient alors un non-sens en terme d'efforts.

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 ----

Références

Article connexe

Voir Programme assembleur ===
Sujets connexes
AT&T (assembleur)   Algèbre de Boole   Bit   Compilateur   Désassembleur   FASM   Fortran   GNU   Langage de bas niveau   Langage de haut niveau   Langage machine   Linux   MMX   Macro-définition   Microcontrôleur   Microprocesseur   Ordinateur   Programme assembleur   Racine carrée   Registre (informatique)   SSE   Système binaire   Système d'exploitation   Système embarqué   Vecteur   X86  
#
Accident de Beaune   Amélie Mauresmo   Anisocytose   C3H6O   CA Paris   Carole Richert   Catherinettes   Chaleur massique   Championnat de Tunisie de football D2   Classement mondial des entreprises leader par secteur   Col du Bonhomme (Vosges)   De viris illustribus (Lhomond)   Dolcett   EGP  
^