<page>
    <title>Assembleur</title>
    <id>7941</id>
    <revision>
      <id>31229288</id>
      <timestamp>2008-07-02T14:58:01Z</timestamp>
      <contributor>
        <username>KhanBot</username>
        <id>386412</id>
      </contributor>
      <minor />
      <comment>robot  Ajoute: [[bn:অ্যাসেম্বলি ভাষা]]</comment>
      <text xml:space="preserve">{{voir homonymes|ASM}}
{{autre4|le langage d'assemblage|le programme produisant un exécutable à partir d'un source écrit dans ce langage|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 [[bit]]s du langage machine sont représentées par des symboles appelés ''[[mnémonique]]s'' (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 :
&lt;source lang=&quot;asm&quot;&gt;
  movb $0x61,%al
&lt;/source&gt;
Ce qui signifie : « mettre la valeur [[hexadécimal]]e 61 dans le [[registre (informatique)|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 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é [[Programme Assembleur|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 [[Algèbre de Boole (logique)|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 (mathématiques)|sinus]], [[cosinus]], [[racine carrée]], opérations sur des [[vecteur]]s)
* application d'une opération simple (par exemple, une addition) à un ensemble de données par l'intermédiaire des extensions [[MMX (processeur)|MMX]] ou [[Streaming SIMD Extensions|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 [[Macro-définition|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&amp;T (assembleur)|AT&amp;T]] (écrits pour l'[[Programme assembleur|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)
&lt;source lang=&quot;asm&quot;&gt;
         .global _start
 
 BONJ:   .ascii  &quot;Bonjour\n&quot;      ; 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   ; Mettre 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)
&lt;/source&gt;

=== Lire le clavier (16 caractères max) puis l'afficher ===
&lt;source lang=&quot;asm&quot;&gt;
 # 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
&lt;/source&gt;

== Usage du langage assembleur==

Il y a des débats sur l'utilité du langage assembleur. Dans beaucoup de cas, des [[compilateur]]s-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 à &quot;maintenir&quot;.

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ème embarqué|systèmes embarqués]], souvent à base de [[microcontrôleur]]s, est une &quot;niche&quot; 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 &quot;tout assembleur&quot; 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 [[Macro-définition|macros]]. Il s'agit de regrouper plusieurs instructions afin d'avoir un enchaînement plus logique et moins fastidieux.&lt;br /&gt;
Par exemple (en assembleur Microsoft [[MASM]]) :&lt;br /&gt;
&lt;source lang=&quot;asm&quot;&gt;
  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 &quot;putchar&quot; en DOS
          int     21h          ; appel au DOS
          endm                 ; fin macro
&lt;/source&gt;
est une macro qui affiche un caractère sous [[MS-DOS]]. On l'utilisera par exemple ainsi :&lt;br /&gt;
&lt;source lang=&quot;asm&quot;&gt;
        putchar &quot;X&quot;
&lt;/source&gt;
Et cela générera :
&lt;source lang=&quot;asm&quot;&gt;
        mov    dl,&quot;X&quot;
        mov    ah,2
        int    21h
&lt;/source&gt;

==Références==
===Article connexe===
Voir [[Programme assembleur]]

===Liens internes===
* [[GNU Assembler]] du [[projet GNU]]
* [[NASM]]
* [[FASM]]
* [[MASM]]
* [[TASM]] de Borland

===Liens externes===
{{Wiktionnaire}}
* {{fr}} [http://www.iprezo.org/index.php?page=asm Cours complet d'Assembleur] Les cours d'Iprezo
* {{fr}} [http://asm.developpez.com/faq/ La F.A.Q Assembleur] Les réponses à vos questions sur l'Assembleur
* {{fr}} [http://asm.developpez.com/cours/ Tutoriels Assembleur]
* {{fr}} [http://www.asmfr.com/ AsmFR ] : site de passionnés qui mettent en commun leurs connaissances
* {{en}} [http://sourceforge.net/projects/nasm/ NASM - Netwide Assembler]

{{Portail|programmation informatique}}

[[Catégorie:Langage de programmation]]
[[Catégorie:Langage impératif]]

[[ar:لغة التجميع]]
[[bg:Асемблер]]
[[bn:অ্যাসেম্বলি ভাষা]]
[[bs:Assembler]]
[[ca:Llenguatge assemblador]]
[[cs:Assembler]]
[[da:Assemblersprog]]
[[de:Assemblersprache]]
[[el:Assembly (γλώσσα προγραμματισμού)]]
[[en:Assembly language]]
[[eo:Asembla lingvo]]
[[es:Lenguaje ensamblador]]
[[et:Assemblerkeel]]
[[fi:Assembly (ohjelmointikieli)]]
[[he:שפת סף]]
[[hi:असेम्बली भाषा]]
[[hr:Asemblerski jezik]]
[[hu:Assembly]]
[[is:Smalamál]]
[[it:Assembly]]
[[ja:アセンブリ言語]]
[[ko:어셈블리어]]
[[lt:Asemblerio kalba]]
[[lv:Asamblervaloda]]
[[no:Assembler]]
[[pt:Linguagem de montagem]]
[[ro:Limbaj de asamblare]]
[[ru:Язык ассемблера]]
[[si:ඇසෙම්බ්ලි භාෂාව]]
[[sl:Zbirni jezik]]
[[sq:Assembly]]
[[sr:Асемблер]]
[[th:ภาษาแอสเซมบลี]]
[[tr:Çevirici diller]]
[[vi:Hợp ngữ]]
[[zh:汇编语言]]</text>
    </revision>
  </page>