L'assembleur en ligne

Aujourd'hui, le langage assembleur est assez peu utilisé. La plupart des programmeurs utilisent les langages haut niveau, comme le C ou le C++, pour plusieurs raisons. En premier lieu, parce que ces langages permettent d'écrire des programmes indépendants de l'architecture, et donc portables. En second lieu, parce qu'ils présentent des syntaxes simples et compréhensibles, ce qui permet d'augmenter la productivité, lors de l'écriture et la maintenance du code. Mais, de temps en temps, les programmeurs ont besoin d'utiliser des instructions assembleur dans leurs programmes.

L'assembleur en ligne, Inline Assembly, est une extension des langages de programmation haut niveau standard offerte par certains compilateurs. Il permet d'inclure des instructions assembleur dans un programme écrit en langage haut niveau.

Ce tutoriel va vous présenter l'assembleur en ligne avec le langage C et le compilateur GCC. Les différents exemples cités sont téléchargeables sur Developpez.com.

I-A. Remerciements▲

L'ajout des instructions assembleur dépendantes de l'architecture à un programme écrit dans un langage haut niveau affecte sa portabilité. Ainsi, vous ne devriez utiliser des instructions assembleur qu'en dernier ressort. Par exemple, lorsque vous constatez que l'utilisation de l'assembleur va optimiser vos codes et vous produira un programme rapide, ou lorsque vous voulez utiliser des instructions spécifiques à l'architecture et non descriptibles par une syntaxe de haut niveau.

En fait, la capacité d'optimisation des compilateurs est limitée à cause de plusieurs facteurs, tels que leur compréhension limitée du comportement du code, et le contexte dans lequel il sera utilisé, et aussi le besoin des programmeurs d'effectuer la compilation rapidement. En effet, la tâche d'optimisation est coûteuse en mémoire et en temps de compilation. Ainsi, la substitution des parties complexes du code et sensibles à la performance du programme par des simples instructions assembleur va simplifier l'optimisation d'une part, et permettra de produire un programme performant et rapide, d'autre part.

En outre, plusieurs fonctionnalités des processeurs sont encore difficiles à décrire par une syntaxe de haut niveau. Ainsi, plusieurs instructions machine doivent être écrites à la main. Parmi celles-ci, on cite les instructions système d'accès aux ports d'entrée/sortie (x86 : instructions OUT, OUTS, IN, INS). On peut aussi citer les instructions de gestion de la mémoire (x86 : LLDT, LGDT…) et des tâches (x86 : LTR).

L'utilisation des instructions assembleur nécessite une connaissance avancée de l'architecture et du fonctionnement interne du compilateur. En effet, l'assembleur en ligne est largement utilisé par les développeurs des systèmes d'exploitation et des pilotes de périphériques (drivers).

Dans ces domaines de programmation, la portabilité d'un code n'est pas une exigence extrême et n'a parfois pas de sens. En effet, le code source d'un driver ou d'un système d'exploitation ne pourra jamais être portable. La haute priorité est, souvent, donnée à la production d'un programme performant qui s'exécute rapidement et qui permet d'exploiter efficacement toutes les fonctionnalités d'une architecture donnée.

Pour les systèmes d'exploitation, le terme multiplate-forme est plus précis. Par exemple, le système Linux est multiplate-forme parce qu'il peut tourner sur une variété d'architectures. En fait, dans le code source de son noyau, chaque architecture possède sa propre description en langage C et en assembleur (/usr/src/linux/arch/). Cela vient du fait que les instructions et les caractéristiques diffèrent d'une architecture à une autre. Autrement dit, le code source dépendant d'une architecture ne peut pas être compilé pour tourner sur une autre.

Les instructions assembleur sont souvent encapsulées dans des macros ou des fonctions en ligne définies dans des fichiers d'en-tête. C'est pour faciliter la maintenance du code source et pour faciliter son portage d'une architecture à une autre. Consultez le répertoire /usr/src/linux/arch/x86/include/asm pour avoir accès à des exemples de code contenant des instructions assembleur x86. Par exemple, le fichier io.h contient les instructions x86 d'accès aux ports d'entrée/sortie. En outre, le fichier string.h contient l'implémentation des opérations de manipulation des chaînes en utilisant le jeu d'instructions x86.

Dans ce tutoriel, on va étudier quelques exemples des codes assembleur pris du code source du noyau Linux 0.01. Vous pouvez le télécharger sur https://www.kernel.org/pub/linux/kernel/Historic.

En particulier, le compilateur GCC, GNU Compilers Collection dispose d'une syntaxe simple et complète permettant d'utiliser efficacement des instructions assembleur dans un programme C.

Dans un programme assembleur classique, chaque instruction possède, typiquement, deux opérandes : un opérande source et un opérande destination. Ces opérandes peuvent être utilisés de façon explicite ou implicite. On peut citer comme exemple l'instruction x86 MOV, qui utilise explicitement deux opérandes. En utilisant la syntaxe AT&T, on peut écrire cette instruction comme suit :

MOV source, destination

Les opérandes peuvent être de trois types : registre, mémoire ou immédiat. Dans l'exemple ci-dessous, l'instruction MOV va transférer le contenu du registre EDX dans EAX :

MOV EDX, EAX

Avec l'assembleur en ligne, on ne va pas réinventer la roue, croyez-moi ! Les instructions seront écrites de la même façon, sauf que les opérandes seront définis séparément et leurs valeurs pourront être des expressions C. Autrement dit, tout ce que vous avez appris sur l'assembleur restera valide et vous en aurez besoin. Vous allez juste apprendre une syntaxe qui vous permettra d'écrire des instructions assembleur dans un programme C.

Avec le compilateur GCC, les instructions assembleur, ainsi que la définition de leurs opérandes, doivent être encapsulées dans une construction déclarée, typiquement, avec le mot clé asm. Cela va indiquer au compilateur que le code à l'intérieur doit être traité d'une façon différente. Pendant la compilation, le compilateur GCC va utiliser les informations incluses dans la construction asm pour générer les instructions assembleur et les placer dans le code-cible.

Notez bien que GCC utilise par défaut la syntaxe AT&T pour générer le code-cible. En effet, le compilateur utilise, par défaut, le programme as (GNU Assembler) pour générer le code objet. Ainsi, dans la construction asm, les instructions assembleur doivent être écrites en utilisant cette syntaxe, à moins que vous n'utilisiez l'option -masm du compilateur. Dans ce qui suit, on va utiliser la syntaxe AT&T. Voici un tutoriel qui va vous aider à l'apprendre rapidement :

http://asm.developpez.com/cours/gas/

Le mot clé asm doit être suivi par une expression entre parenthèses et constituée de sections séparées par deux points. La première section contient des instructions assembleur écrites entre guillemets. Dans la deuxième, on doit spécifier les opérandes de sortie des instructions. La troisième section contient les opérandes d'entrée. La quatrième section sert à déclarer les modifications apportées, sur les registres ou en mémoire, par les instructions.

Le programme suivant utilise l'instruction assembleur movl pour affecter la valeur de la variable b à variable a (a = b ;) :

#include <stdio.h>
int main(void)
{
 int a = 10;
 int b = 5;

 __asm__("movl\t%1, %0"

         : "=&r" (a) : "r" (b)
         : /* liste des modifications */
        );

 printf("a = b = %d \n", a);
 return 0;
}

Ici, chaque opérande est écrit comme une expression C placée entre parenthèses et précédée d'une chaîne de caractères indiquant sa contrainte. La lettre r dans chaque contrainte symbolise le nom d'un registre général du processeur. Ainsi, le compilateur GCC va allouer un registre de ce type, pour stocker la valeur (5) de la variable b, et un autre pour stocker celle (10) de a. Le caractère « = » dans la contrainte « =r » du premier opérande indique que c'est un opérande de sortie. Toutes les contraintes des opérandes de sortie doivent commencer par « = ».

Pour se référer aux opérandes dans le code assembleur, on peut écrire leurs indices précédés du caractère « % ». Ainsi, l'instruction movl va transférer le contenu (5) du deuxième opérande (source ou entrée d'indice 1) dans le registre alloué au premier opérande (destination ou sortie d'indice 0).

Dans le code ci-dessus, après l'exécution de l'instruction movl, la sortie a sera produite. C'est en affectant le contenu du registre destination à la variable a.

GCC ne peut pas analyser les instructions assembleur et vérifier si elles sont valides ou non. Ainsi, il ne peut pas vérifier si le type des opérandes est raisonnable pour les instructions ou non. En fait, c'est le rôle de l'assembleur as. En ce qui concerne la construction asm, GCC va juste, dans un premier temps, vérifier la syntaxe des expressions C utilisées comme opérandes. Ensuite, il va générer les opérandes des instructions en utilisant les informations contenues dans les sections d'entrées et de sorties. Finalement, il va placer les instructions assembleur avec leurs opérandes dans le code-cible.

Enfin, pour obtenir le code-cible produit par le compilateur GCC, faites-lui passer l'option -S. Faites passer, également, l'option -O2, pour appliquer le deuxième niveau d'optimisation de GCC à votre code. Voici une portion du code-cible de l'exemple ci-dessus :

        movl        $5, %edx
        movl        %esp, %ebp
        .cfi_def_cfa_register 5
        andl        $-16, %esp
        subl        $16, %esp
#APP
# 9 "movl.c" 1
        movl        %edx, %eax
# 0 "" 2
#NO_APP
        movl        $.LC0, (%esp)
        movl        %eax, 4(%esp)
        call        printf
        xorl        %eax, %eax
        leave

Dans le code-cible, le bloc asm est placé entre les deux lignes de commentaires #APP et #NO_APP. Le compilateur a alloué deux registres généraux pour stocker les valeurs de a et b : le registre EAX pour a et le registre EDX pour b.

IV-A. Les instructions assembleur▲

__asm__("\tnop;nop;nop\t"
        "jmp \t1f\n"
        "1:" ::);

IV-B. Les opérandes▲

IV-C. Les sorties▲

__asm__("movl\t%0, %1"

        : "=&r" (a)
        : "r" (b)
        :/* liste des modifications */
       )

IV-D. Les entrées▲

__asm__( "addl %2, %1" : "=r" (a) : "0" (a), "r"(b));

__asm__( "addl %2, %1" : "=r" (a) : "r" (a), "r"(b));

IV-E. Déclaration des modifications▲

#include<asm/unistd.h>             /* __NR_write */
#include<unistd.h>                 /* STDOUT_FILENO */
#include<string.h>                 /* strlen() */

#define STDOUT STDOUT_FILENO

int main(void)
{
 char msg[] = "hello!\n";
 int res;

 __asm__("movl \t%2, %%ebx\n\t"
         "int \t$0x80"

         :"=a" (res)
         :"0" (__NR_write), "I" (STDOUT),
          "c" (msg), "d" (strlen(msg))
         :"ebx");

return 0;
}

__asm__( "shll $2, %1" : "=r" (res) : "r" (a) : "cc");

__asm__("movl %1, %%eax\n\t"
        "addl %2, %%eax\n\t"
        "subl %1, %1"
        :"=a" (res)
        :"r" (a), "b" (b));

        movl        $3, %edx
        movl        $10, %eax
#APP
# 9 "addition2.c" 1
        movl         %eax, %eax
        addl         %edx, %eax
        subl         %eax, %eax
# 0 "" 2
#NO_APP

#include <stdio.h>

int main(void)
{
 int x = 10;             /* EAX */
 int mult = 3;
 int res;                /* EAX */

 __asm__("movl %2, %%ebx\n\t"
         "imul %%ebx"
         :"=&a" (res)
         :"0" (x), "r" (mult)
         :"ebx");

 printf("%d * %d = %d \n", x, mult, res);
 return 0;
}

#include <stdio.h>

int main(void)
{
 int x = 10;           /* EAX */
 int divs = 3;
 int quot;             /* EAX */
 int reste;            /* EDX */

 __asm__("subl %%edx, %%edx\n\t"
         "movl %3, %%ebx\n\t"
         "idivl %%ebx"

         :"=a" (quot), "=&d" (reste)
         :"0" (x), "r" (divs)
         :"ebx");

 printf("%d / %d = %d \n", x, divs, quot);
 printf("%d %% %d = %d \n", x, divs, reste);
 return 0;
}

Durant l'optimisation, GCC tente de réordonner et de réécrire le code du programme, même en présence de la construction asm. Si les opérandes de sortie ne sont pas utilisés (la section 2 de asm est vide), ou si leurs valeurs ne sont pas modifiées par les instructions, l'optimiseur considère que les instructions n'ont pas un effet de bord dans le programme. Ainsi, la construction asm peut être supprimée. Pour bien comprendre le problème, on va étudier la portion de code suivante, prise du fichier include/string.h du code source du noyau Linux-0.01) :

extern inline char *strcpy(char *dest,const char *src)
{

 __asm__("cld\n"
         "1: lodsb\n\t"
         "stosb\n\t"
         "testb %%al,%%al\n\t"
         "jne 1b"
         ::"S" (src), "D" (dest)
         :"ax", "memory");
 return dest;
}

La construction asm du code ci-dessus ne possède pas d'opérande de sortie. Pour le moment, on n'a pas besoin d'utiliser de sortie puisque les instructions lodsb et stosb utilisent directement la mémoire. Ainsi, on n'a pas de résultat à récupérer depuis un registre dans la mémoire à la fin de l'exécution du bloc asm. Mais l'optimiseur est parfois fou ! L'optimisation risquera de supprimer la construction asm. Et, par conséquent, la fonction strcpy() devient inutilisable.

Vous pouvez empêcher la construction asm d'être supprimée, par l'utilisation du mot-clé volatile, qui va indiquer au compilateur que les instructions ont un effet de bord important. GCC ne supprime jamais un asm volatile. Mais il peut le déplacer dans le code. Pour éviter ça, vous devez toujours spécifier tout opérande modifié dans le code assembleur, comme opérande de sortie. Ainsi :

extern inline char *strcpy(char *dest,const char *src)
{
 int S, D, A;

 __asm__ __volatile__(
         "cld \n"
         "1:lodsb \n\t"
         "stosb \n\t"
         "testb %%al, %%al \n\t"
         "jne 1b"

         :"=&S (S)", "=&D (D)", "=&a (A)"
         :"0" (src),"1" (dest), "2" (0));
 return dest;
}

Dans l'exemple ci-dessus, le contenu des registres ESI, EDI et EAX a été modifié. Ainsi, on les a spécifiés comme opérandes de sortie. Les variables S, D et A déclarées dans le code C sont utilisées juste pour créer une dépendance avec le bloc asm. Ainsi, l'optimiseur ne déplacera pas ce dernier.

Si vous décidez d'utiliser des instructions assembleur dépendantes de l'architecture, il vaut mieux pour vous les encapsuler dans des macros et les placer dans un fichier d'en-tête. Cela peut vous aider à la maintenance de vos programmes. Ainsi, si vous décidez de porter un programme vers une autre architecture, vous n'aurez besoin de réécrire qu'un seul fichier. Dans l'exemple max.c, on a encapsulé la construction asm dans la macro max(a,b) définie dans le fichier d'en-tête max.h :

#ifndef MAX_H
#define MAX_H

#define max(a,b)                      \
({                                    \
 int __res, __x = (a), __y = (b);     \
 __asm__ __volatile__(                \
        "cmpl %1, %2\n\t"             \
        "jge 1f\n\t"                  \
        "movl %1, %0\n\t"             \
        "jmp 2f\n\t"                  \
        "1: movl %2, %0\n\t"          \
        "2:"                          \
        :"=r" (__res)                 \
        :"r" (__x), "r" (__y));       \
 __res;                               \
})

#endif

Notez que la dernière instruction d'une instruction composée, écrite entre « {} », doit être une expression suivie par « ; ». Elle sert à donner une valeur à l'instruction entière. Dans notre exemple, on veut récupérer la valeur de l'opérande de sortie dans le code C, pour l'afficher par exemple. Ainsi, on a écrit __res ; à la fin de l'instruction composée.

Dans la définition de la macro max(a,b), les variables __x et __y sont utilisées pour s'assurer que la construction asm opère sur des valeurs entières. Une autre méthode pour faire en sorte que la construction asm opère sur le type de données correct est l'utilisation de forçage de type (casting) dans les entrées. Dans l'exemple ci-dessus, on peut forcer l'utilisation du type entier dans les opérandes d'entrée de la construction asm comme suit :

(::"r" ((int)a), "r" ((int)b);

Pour le même objectif, les constructions asm peuvent être encapsulées dans des fonctions en ligne. La section suivante en donne un exemple.

VII-A. Opérations sur les chaînes de caractères avec l'architecture x86▲

#include <stdio.h>
#include <stdlib.h>
#include "string.h"

#define  TAILLE 10

int main (void)
{
 char * str1 = (char*)
        malloc(TAILLE*sizeof(char));
 char * str2 = (char*)
        malloc(TAILLE*sizeof(char));

 if(!str1 || !str2)
        return EXIT_FAILURE;

 my_strcpy((char*)"foo", str1);
 my_strcpy((char*)"bar", str2);

 if(!my_strcmp(str1, str2))
        printf("Les deux chaines \"%s\" et \"%s\" "\
          "sont egales.\n", str1, str2);
 else
        printf("Les deux chaines \"%s\" et \"%s\" "\
          "ne sont pas egales.\n", str1, str2);

 free (str1);
 free (str2);

 return EXIT_SUCCESS;
}

VII-B. La fonction my_strcpy▲

static inline void
my_strcpy(char * src, char * dest)
{
 int S, D, A;

 __asm__ __volatile__ (
        "cld\n\t"               /* ESI++, EDI++ */
        "1:\tlodsb\n\t"         /* MOVB DS:ESI, AL */
        "stosb\n\t"             /* MOVB AL, ES:EDI */
        "testb\t%%al,%%al\n\t"  /* ZF=1 si AL == 0 */
        "jne\t1b"               /* JMP si ZF == 0 */

        :"=&S" (S),"=&D" (D), "=&a" (A)
        :"0" (src),"1" (dest), "2" (0)
        :"memory");
}

VII-C. La fonction my_strcmp▲

static inline int
my_strcmp(const char * str1,const char * str2)
{
 int S, D, __res;

 __asm__ __volatile__(
        "cld\n"                /* ESI++, EDI++ */
        "1:\tlodsb\n\t"        /* MOV DS:ESI, AL */
        "scasb\n\t"            /* SUB ES:ESI, AL */
        "jne 2f\n\t"           /* JMP si ZF == 0 (ES:EDI != AL) */
        "testb %%al,%%al\n\t"  /* ZF=1 si AL == 0 */
        "jne 1b\n\t"           /* JMP si ZF == 0 => il y a encore des caracteres */
                               /* pour comparer */
        "xorl %%eax,%%eax\n\t" /* (str1 == str2) => __res = 0 */
        "jmp 3f\n"             /* on a termine ! */
        "2:\tmovl $1,%%eax\n\t"
        "jl 3f\n\t"            /* (str1 != str2) et (str1[i] > str2[i]) => __res = 1 */
        "negl %%eax\n"         /* (str1 != str2) et (str1[i] < str2[i]) => __res = -1 */
        "3:"

        :"=&D" (S), "=&S" (S),"=&a" (__res)
        :"0" (str1),"1" (str2), "2" (0)
        :"memory");

 return __res;
}

VII-D. La compilation avec GCC▲

CFLAGS = -O2 -fomit-frame-pointer -W -Wall

string: string.o
        cc string.o -o string

string.o: string.c string.h
        cc -c $(CFLAGS) string.c -o string.o

clean:
        rm -rfv string.o