Assembleur - Définition

Introduction

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.

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      

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 :

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