asm

Norme : C89 / C99 / C11
Description : ce mot-clef est une extension qui permet d'introduire des portions de code en assembleur dans un code source C. La norme ne précise que son comportement, son fonctionnement varie donc selon les compilateurs. Ainsi, ce mot-clef n'est pas portable puisqu'il dépend de l'implémentation.

Citation : Norme C89 - A.6.5.10 The asm keyword

The asm keyword may be used to insert assembly-language code directly into the translator output. The most common implementation is via a statement of the form

asm ( character-string-literal );

Ce mot-clef étant une extension, l'utilisation de l'option de compilation -ansi le désactive. Il faut donc utiliser le mot-clef défini par le compilateur choisi.

Exemple et / ou commentaire :

Avec GCC / MinGW

Pour GCC / MinGW, le mot-clef est __asm__. La syntaxe pour l'utiliser est la suivante :

__asm__
(
    /* code assembleur */
);

Assembleur inline basique

Avant toute chose, il faut savoir que l'assembleur utilisé par GCC (appelé as ou Gas)utilise la syntaxe AT&T et non la syntaxe Intel. Pour ceux qui ne connaissent pas, une petite liste des différences entre les deux syntaxes a été dressée ici.

Les instructions assembleur se déclarent entre guillemets et se terminent par "\n\t", exceptée la dernière. Ces deux caractères permettent de formater correctement le code pour l'envoyer à Gas (l'assembleur de GCC). Il est très fortement recommander de les utiliser. Voici un exemple de code assembleur basique :

__asm__
(
     "movl %eax, %ebx\n\t"
     "movl $56, %esi\n\t"
     "movb %ah, (%ebx)"
);

Pour l'instant, c'est assez limité : on ne peut même pas manipuler de variables. C'est là qu'intervient l'assembleur étendu.

L'assembleur étendu

L'assembleur étendu nous permet de spécifier des opérandes et ainsi manipuler des variables dans notre code assembleur. La syntaxe est la suivante :

__asm__
(
    /* instructions assembleur */
        : opérandes de sortie                               /* optionnel */
        : opérandes d'entrée                                /* optionnel */
        : liste des registres "pollués"  ou clobber list    /* optionnel */
);

Chaque opérande est décrite par une contrainte entre guillemets suivie par une expression en C entre parenthèses. La contrainte sert à décrire où sera stockée la variable en paramètre. Elle peut être parmi la liste suivante :

• "r" : dans n'importe quel registre (eax, ebx, etc) ;
• "a" : spécifiques aux registres eax, ax et al ;
• "b" : spécifiques aux registres ebx, bx et bl ;
• "c" : spécifiques aux registres ecx, cx et cl ;
• "d" : spécifiques aux registres edx, dx et dl ;
• "S" : pour les registres esi et si ;
• "D" : pour les registres edi et di ;
• "m" : lorsque l'opérateur est dans la mémoire ; on peut donc effectuer des opérations directement sur l'adresse mémoire sans avoir à passer par un registre. Par exemple dans un OS, l'IDT définie par le noyau peut être chargée ainsi :
  
  

  __asm__ ("lidt %0\n" : /* pas de sortie */ :"m"(idt));
  

  
  
  Cependant, il n'est recommandé d'utiliser cette contrainte que si elle est vraiment nécessaire ou si elle accélère suffisamment le processus.

D'autres contraintes sont spécifique à l'architecture x86 :

• "f" : pour un registre flottant ;
• "t" : pour le premier registre flottant ;
• "u" : pour le second registre flottant ;
• "q" : registre a, b, c ou d

En plus de ces contraintes, il existe également des modificateurs de contrainte :

• "=" : signifie que l'opérande est en écriture seule pour cette instruction, la valeur précédente est éliminée et remplacée par des données de sortie. Ce modificateur est utilisé pour les opérandes de sortie.
• "&" : signifie que l'opérande sera modifiée avant la fin de la fonction. Il est utilisé quand on fait une boucle par exemple.
• "=&" : c'est la combinaison des deux précédents.

Le troisième paramètre est quant à lui la liste des registres utilisés dans le code assembleur sans compter les opérandes d'entrée et de sortie. Elle permet d'indiquer à GCC que nous gérons nous-mêmes ces registres. Ainsi, GCC ne vérifiera pas si la valeur chargée dans ces registres est valide. Par contre, GCC connait les registres utilisés par les opérandes d'entrée et de sortie, il ne faut donc pas les préciser.

Il est temps de tout récapituler par un exemple. Prenons ce code qui additionne deux variables.

int main(void)
{
    int foo = 10, bar = 15;
    
    __asm__
    (
        "addl %%ebx, %%eax"
            : "=a"(foo)
            : "a"(foo), "b"(bar)
    );
        
    printf("foo + bar = %d\n", foo);
    return 0;
}

On demande dans cette exemple de stocker la variable foo dans le registre eax ("a"(foo)), et la variable bar dans le registre ebx ("b"(bar)), puis on demande d'additionner les deux registres et de stocker le résultat dans la variable foo ("=a"(foo)). On remarque ici que la liste des registres pollués n'est pas précisée puisque les deux registres utilisés sont déjà connus d'avance par GCC, car ils sont utilisés par les opérandes de sortie / d'entrée.

Plus d'opérandes, de contraintes et de clobber list

Il faut aussi préciser que pour un nombre <math>\(x\)</math> d'opérateurs (à la fois d'entrée et de sortie), alors le premier opérande de sortie est numéroté 0, et le dernier opérande d'entrée est numéroté <math>\(x-1\)</math>. Cela nous permet de manipuler directement nos variables dans le code assembleur, au contraire du code précédent où nous sommes passés par des registres bien spécifiques. Illustrons ce nouveau concept par un code :

int main(void)
{
    int a = 10, b;
    
    __asm__
    (
        "movl %1, %%eax\n\t"
        "movl %%eax, %0"
            :"=r"(b)
            :"r"(a)
            :"%eax"
    );
    
    printf("b = %d\n", b);
    
    return 0;
}

Il y a deux opérandes, donc "=r"(b) est l'opérande 0, représentée par %0, et "r"(a) l'opérande 1, représentée par %1. Le code charge donc la variable a et stocker son contenu dans eax, qui est lui même copié dans la variable b. Ainsi à la fin de l'instruction, la variable a et la variable b valent toutes les deux 10. Cela nous permet de manipuler plus précisément les opérandes d'entrées et de sorties.

Cette possibilité s'étend également aux contraintes des opérandes. En effet, pour une opérande d'entrée, une contrainte composée d'un chiffre <math>\(x\)</math> qui signifie "cette entrée a les mêmes contraintes que la <math>\(x^{eme}\)</math> opérande de sortie". Cette technique est utilisée si on veut que l'opérande d'entrée et l'opérande de sortie soient stockées dans le même registre. Prenons un exemple :

int main(void)
{
    int a = 10, b = 25;

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

    printf("a += b = %d", a);

    return 0;
}

Dans ce code, on demande à ce que l'opérande d'entrée <math>\(0\)</math> ait les mêmes contraintes que la <math>\(0^{eme}\)</math> opérande de sortie (soit "=a"). Ainsi, les deux variables seront stockées dans le registre eax. Sans cette technique, il aurait fallu préciser que l'opérande d'entrée <math>\(0\)</math> devait être stockée dans le registre eax.

Je finis en ajoutant des précisions sur la liste des registres pollués. Nous en avons parlé précédemment, mais nous n'avons pas tout dit dessus. Il y a en effet également d'autres précisions à ajouter.

• Si l'instruction modifie le registre de condition de code, alors il faut rajouter "cc" à cette liste.
• Si l'instruction modifie la mémoire de manière imprévisible, il faut ajouter "memory" à la liste. Si la mémoire modifiée n'est pas listée dans les opérandes d'entrée ou de sortie, il faut alors rajouter le mot-clef volatile.

Ce dernier point m'amène à la sous-partie suivante.

volatile

Ce mot-clef est bien connu des programmeurs système. Il permet de définir une variable de façon à ce que celle-ci ne puisse pas être placée dans un registre du processeur, mais en mémoire. Dans le cas de l'assembleur inline, il sert à empêcher les optimisations que pourrait faire GCC. En effet, le compilateur va essayer d'améliorer notre code pour l'optimiser et le rendre plus propre. Si jamais on veut qu'il respecte à la lettre le code que l'on a écrit, on utilisera ce mot-clef (à noter que l'on préfère souvent utiliser __volatile__ à la place de volatile).

Il est à noter que s'il n'est pas nécessaire (dans le cas de calculs, ou si le code ne produit aucun effet de bord), il ne sert à rien de le mettre. Dans ce cas il est mieux de laisser GCC optimiser le code.

Variables globales et fonctions

Depuis tout à l'heure, nous n'avons vu que le chargement de variables locales à une fonction. Il est pourtant possible de charger des variables globales, et c'est même encore plus facile ! En effet, il suffit d'écrire directement dans le code ceci : _ID, sans même passer par les opérandes d'entrées et de sortie. Exemple :

int b = 25;

int main(void)
{
    int a = 10;

    __asm__
    (
        "addl _b, %%eax"
            : "=a"(a)
            : "0"(a)
    );

    printf("a += b = %d", a);

    return 0;
}

Il est de même pour les appels de fonctions. Voici un exemple appelant la fonction puts :

const char * const str = "Hello world!";

int main(void)
{
    __asm__
    (
        "movl _str, %eax\n\t"
        "pushl %eax\n\t"
        "call _puts\n\t"
        "add $8, %esp\n\t"
        "leave\n\t"
        "ret"
    );

    return 0;
}

Exemples

Pour illustrer cette grosse partie théorique, je vais prendre des exemples que j'ai pu voir sur Internet, accompagnés de quelques explications.

Mise à zéro de bit

__asm__
(   "btsl %1,%0"
       : "=m" (ADDR)
       : "Ir" (pos)
       : "cc"
);

Ce code permet de mettre à 1 le bit numéro <math>\(pos\)</math> de l'adresse ADDR. Si on avait voulu mettre le bit à 0, on aurait utilisé l'instruction btrl.

strcpy
Ce code tiré de la Glibc de Linux est celui de la fonction strcpy :

static inline char * strcpy(char * dest,const char *src)
{
    int d0, d1, d2;

    __asm__ __volatile__
    (  
       "1:\tlodsb\n\t"
       "stosb\n\t"
       "testb %%al,%%al\n\t"
       "jne 1b"
           : "=&S" (d0), "=&D" (d1), "=&a" (d2)
           : "0" (src),"1" (dest) 
           : "memory"
    );

    return dest;
}

L'adresse de la chaîne source est située dans esi, celle de la chaîne de destination dans edi. Dès que l'on atteint 0, la copie est terminée. Les contraintes "&S", "&D", "&a" indiquent que les registres esi, edi and eax sont dans la liste des registres modifiés car leur valeur change durant l'exécution. L'instruction lodsb charge dans le registre al l'octet adressé par di:si, si le flag DF vaut 0 après ça, si est incrémenté, sinon décrémenté. L'instruction stosb stocke le contenu de al dans l'octet pointé par es:di, si le flag DF vaut 0 après ça, di est incrémenté, sinon décrémenté.

Des instructions inaccessibles ?
Il est fréquent lors de la création d'un système d'exploitation d'écrire sur divers ports (pour s'adresser au PIC par exemple), ou bien pour activer / désactiver les interruptions. Or il n'existe pas en C de fonction pour se faire. On a donc recours à l'assembleur inline. Dans cette exemple, on utilise des #define, ce qui s'avère pratique quand on appelle plusieurs fois la même instruction.

/* désactive les interruptions */
#define cli __asm__("cli"::)

/* réactive les interruptions */
#define sti __asm__("sti"::)

/* écrit un octet sur un port */
#define outb(port,value) \
	__asm__ __volatile__ ("outb %%al, %%dx" :: "d" (port), "a" (value));

/* lit un octet sur un port */
#define inb(port)(    \
	unsigned char _v;       \
	__asm__ __volatile__ ("inb %%dx, %%al" : "=a" (_v) : "d" (port)); \
        _v;     \
})

Utiliser la syntaxe Intel

Pour ceux qui maitriserait mal la syntaxe AT&T ou qui par gouts personnels préfèrent la syntaxe Intel, il est possible d'utiliser cette dernière. Pour cela, il suffit de rajouter deux lignes dans son code assembleur : ".intel_syntax noprefix\n\t" au début et ".att_syntax" à la fin. Toute instruction écrite entre ces deux lignes sera considérée comme utilisant la syntaxe Intel. Exemple :

int a;

__asm__
(
    ".intel_syntax noprefix\n\t"
    "mov ax, 2\n\t"
    "shl ax, 2\n\t"
    ".att_syntax"
       :"=r"(a)
);

Concernant le passage en argument, la méthode est quasiment la même que pour la syntaxe AT&T. Il suffit de rajouter des crochets autours de l'identificateur ou du numéro de la variable. Exemple avec une variable globale puis un paramètre de fonction (la méthode est identique pour les variables locales).

const char * const str = "Hello world!";

void Aff(void)
{
    __asm__
    (
        ".intel_syntax noprefix\n\t"
    /* seulement des crochets en plus */
        "mov eax, [_str]\n\t"
        "push eax\n\t"
        "call _puts\n\t"
        "add esp, 8\n\t"
        "leave\n\t"
        "ret\n\t"
        ".att_syntax"
    );
}

void Aff(const char * const str)
{
    __asm__
    (
        ".intel_syntax noprefix\n\t"
        "push eax\n\t"
    /* seulement des crochets en plus */
        "mov eax, [%0]\n\t"
        "call _puts\n\t"
        "add esp, 8\n\t"
        "leave\n\t"
        "ret\n\t"
        ".att_syntax"
            :
            : "r"(str)
    );
}

Pour plus d'information, la documentation officielle est disponible ici.

Visual Studio

Visual Studio permet également d'insérer des routines en assembleur dans un code C (mais en utilisant la syntaxe Intel) grâce au mot-clef __asm (comme pour GCC, il est recommandé de ne pas utiliser le mot-clef asm). La syntaxe est la suivante :

__asm
{
    mov al, 2
    mov dx, 0xD007
    out dx, al
}

Il existe une variante de cette syntaxe, du fait que le mot-clef est un séparateur :

__asm mov al, 2
__asm mov dx, 0xD007
__asm out dx, al

La première solution est la plus avantageuse car elle nécessite d'écrire moins de code et permet de bien séparer la routine assembleur du reste du code.

Interfacer avec le C

Un bloc __asm permet d'utiliser des éléments du langage C :

• les labels, les identificateurs de variables et de fonction ;
• les constantes symboliques et les énumérations ;
• les macros et directives de préprocesseur ;
• des structures, des unions et des typedef.

Quelques exemples pour illustrer :

/* Appel de membres de structures */

struct first_type
{
   char * weasel;
   int same_name;
};

struct second_type
{
   int wonton;
   long same_name;
};

int main(void)
{
   struct first_type hal;
   struct second_type oat;

   __asm
   {
      /* Obligation d'utiliser 'hal' */
      mov ecx, [ebx]hal.same_name
      /* Utilisation de 'hal' facultative */
      mov esi, [ebx].weasel    
   }

/* Le principe est le même pour la structure 'oat' */
}

#include <stdio.h>
#define SIZE  5

int main(void)
{
	int var;

	puts("Donne une valeur : ");
	scanf("%d", &var);

	__asm
	{
		mov eax, var
		shl eax, SIZE
		mov var, eax
	}

	printf("\nvar << %d = %d\n", SIZE, var);
}

Pour plus d'informations, la référence reste la documentation officielle et Internet.

if, else

Norme : C89/C99/C11
Description :

La construction if permet d'exécuter une instruction (ou un bloc d'instructions) sous réserve qu'une certaine condition soit remplie. Le mot-clé else permet d'introduire une instruction (ou un bloc) alternative, qui est exécutée si la condition n'est pas remplie.

On commence par écrire le mot-clé if, suivi d'une condition entre parenthèses, elle-même suivie d'une instruction ou d'un bloc (voir exemples).

La condition est une expression, qui sera considérée comme « vraie » seulement si sa valeur est non-nulle. Les opérateurs de comparaison <, <=, >, >= et == renvoient 1 si la relation (plus petit, plus grand...) est vérifiée, 0 sinon ; ils s'intègrent donc parfaitement dans les conditions, bien qu'ils puissent être utilisés ailleurs.

On dispose également des opérateurs logiques &&, || et !, respectivement le « et », le « ou » et le « non » : le premier renvoie 1 si ses deux opérandes sont non-nuls, 0 sinon ; le second renvoie 1 si l'un de ses opérandes est non-nul, 0 sinon ; le troisième renvoie 1 si son opérande est nul, 0 sinon. Comme les opérateurs de comparaison, les opérateurs logiques sont parfaits pour les conditions, mais ils peuvent parfois être utilisés ailleurs.

En outre, les opérateurs && et || ont un comportement de court-circuit. Par exemple, dans a && b, si a == 0, l'expression entière vaudra 0, quelque soit la valeur de b ; ce dernier n'est donc même pas évalué. De la même manière, dans a || b, si a est non-nul, b n'est même pas évalué : l'ensemble vaut 1. Ce système de court-circuit, combiné au fait que NULL == 0, permet d'écrire des conditions concises et élégantes (voir exemple 3).

TODO :
- avertissements sur = et strcpy ;
- else ;
- les blocs (et comment marche else if).

Exemples :

if(n < 0 || n > 42)
{
    puts("Bonjour !");
}
else 
{
    /* L'instruction à l'intérieur du else peut être un if à son tour */
    if(n > 32)
    {
        puts("Salut !");
    }
    else
    {
        puts("Bonsoir !");
    }
}

Dans cet exemple, chaque bloc ne contient qu'une seule instruction, on peut donc supprimer les accolades et réarranger le code comme ceci :

if(n < 0 || n > 42)
    puts("Bonjour !");
else if(n > 32)
    puts("Salut !");
else
    puts("Bonsoir !");

On peut exploiter le « court-circuitage » de l'opérateur && dans les conditions :

struct Vect2D {
    int x, y;
};

/* Plus loin... */
struct Vect2D *p = readVectFromFile(stdin);

/* Si p == NULL, alors p->x < 0 n'est jamais évalué. */
if(p != NULL && p->x < 0)
{
    puts("The abscissa is negative !");
}