Programmation avancée sous Linux

Le traitement des constructions asm par GCC est très simple. Il produit des instructions assembleur pour traiter les opérandes de l'asm et replace la construction asm par l'instruction que vous spécifiez. Il n'analyse pas du tout l'instruction.

Par exemple, GCC convertit cet extrait de code:

double foo, bar;
asm ("mycool_asm %1, %0" : "=r" (bar) : "r" (foo));

en la séquence d'instructions x86 suivante :

        movl -8(?p),?x
        movl -4(?p),?x
#APP
        mycool_asm ?x, ?x
#NO_APP
        movl ?x,-16(?p)
        movl ?x,-12(?p)

Souvenez-vous que foo et bar requièrent chacun deux mots d'espace de stockage dans la pile sur une architecture x86 32 bits. Le registre ebp pointe vers les données sur la pile.

Les deux premières instructions copient foo dans les registres EDX et ECX qu'utilise mycool_asm. Le compilateur a décidé d'utiliser les mêmes registres pour stocker la réponse, qui est copiée dans bar par les deux dernières instructions. Il choisit les registres adéquats, peut même les réutiliser, et copie les opérandes à partir et vers les emplacements appropriés automatiquement.

La première section contient les instructions assembleur, entre guillemets. La construction asm exemple contient deux instructions assembleur, fucomip et seta, séparées par un point-virgule. Si l'assembleur n'autorise pas les points-virgule, utilisez des caractères de nouvelle ligne (n) pour séparer les instructions. Le compilateur ignore le contenu de cette première section, excepté qu'il supprime un niveau de signes pourcent, <nowiki>%%</nowiki> devient donc %. La signification de <nowiki>%%</nowiki>st(1) et d'autres termes similaires dépend de l'architecture.

GCC se plaindra si vous spécifiez l'option -traditional ou -ansi lors de la compilation d'un programme contenant des constructions asm. Pour éviter de telles erreurs, utilisez le mot clé alternatif %%__%%asm%%__%% comme dans les fichiers d'en-tête cités précédemment.

La seconde section spécifie les opérandes de sortie des instructions en utilisant une syntaxe C. Chaque opérande est décrit par une contrainte d'opérande sous forme de chaîne suivie d'une expression C entre parenthèses. Pour les opérandes de sortie, qui doivent être des lvalues, la chaîne de contrainte doit commencer par un signe égal. Le compilateur vérifie que l'expression C pour chaque opérande de sortie est effectivement une lvalue.

Les lettres spécifiant les registres pour une architecture donnée peuvent être trouvée dans le code source de GCC, dans la macro REG_CLASS_FROM_LETTER. Par exemple, le fichier de configuration gcc/con?g/i386/i386.h de GCC liste les lettres de registre pour l'architecture x86(Vous devrez avoir une certaine familiarité avec le fonctionnement de GCC pour comprendre le contenu de ce fichier.). Le Tableau registresx86 en fait le résumé. Lettres correspondant aux Registres sur l'Architecture Intel x86

Lorsqu'une structure asm utilise plusieurs opérandes, elles doivent être décrites par une chaîne de contrainte et une expressions C et séparées par des virgules, comme l'illustre l'exemple donné précédemment. Vous pouvez spécifier jusqu'à 10 opérandes, numérotées de %0 à %9 dans les sections d'entrée et de sortie. S'il n'y a pas d'opérandes de sortie ou de registre affectés, laissez la section de sortie vide ou signalez la avec un commentaire du type /* no outputs */.

La troisième section décrit les entrées des instructions assembleur. La chaîne de contrainte d'un opérande d'entrée ne doit pas contenir de signe égal, ce qui indique une lvalue. Mis à part cela, leur syntaxe est identique à celle des opérandes de sortie.

Pour indiquer qu'un registre est à la fois lu et écrit par la même construction asm, utilisez l'indice de l'opérande de sortie comme chaîne de contrainte d'entrée. Par exemple, pour indiquer qu'un registre d'entrée est le même que le premier registre de sortie, utilisez 0. Spécifier la même expression C pour des opérandes d'entrée et de sortie ne garantit pas que les deux valeurs seront placées dans le même registre.

La section d'entrée peut être omise s'il n'y a pas d'opérandes d'entrée et que le section de déclaration des modifications est vide.

Si une instruction modifie les valeur d'un ou plusieurs registres par effet de bord, spécifiez ces registres dans la quatrième section de la structure asm. Par exemple, l'instruction fucomip modifie le registre de code condition, qui est désigné par cc. Les registres modifiés sont décrits dans des chaînes individuelles séparées par des virgules. Si l'instruction est susceptible de modifier un emplacement mémoire arbitraire, spécifiez memory. En utilisant les informations sur la modification des registres, le compilateur détermine les valeurs qui doivent être restaurées après l'exécution du bloc asm. Si vous ne renseignez pas ces informations correctement, GCC pourrait supposer que certains registres contiennent des valeurs qui ont en fait été écrasées, ce qui pourrait affecter le fonctionnement de votre programme.

L'architecture x86 dispose d'instructions qui déterminent les positions du bit non nul le plus significatif ou le moins significatif dans un mot. Le processeur peut exécuter ces instructions de façon relativement efficace. Par contre, l'implémentation de la même opération en C nécessite une boucle et un décalage binaire.

Par exemple, l'instruction assembleur bsrl calcule la position du bit le plus significatif de son premier opérande et place cette position (à partir de 0 qui représente le bit le moins significatif) dans le second. Pour placer la position du bit non nul le plus significatif de number dans position, nous pourrions utiliser cette structure asm:

asm ("bsrl %1, %0" : "=r" (position) : "r" (number));

Une façon d'implémenter la même opération en C, est d'utiliser une boucle de ce genre :

long i;
for (i = (number >> 1), position = 0; i != 0; ++position)
  i >>= 1;

Pour comparer les vitesses de ces deux versions, nous allons les placer dans une boucle qui calcule les positions pour de grands nombres. Le Listing bitposloop utilise l'implémentation en C. Le programme boucle sur des entiers, en partant de 1 jusqu'à la valeur passée sur la ligne de commande. Pour chaque valeur de number, il calcule la position du bit non nul le plus significatif. Le Listing bitposasm effectue les mêmes opérations en utilisant une construction assembleur en ligne. Notez que dans les deux versions, nous plaçons la position calculée à une variable volatile result. Cela permet d'éviter que l'optimiseur du compilateur ne supprime le calcul; si le résultat n'est pas utilisé ou stocké en mémoire, l'optimiseur élimine le calcul en le considérant comme du code mort.

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

int main (int argc, char* argv[])
{
  long max = atoi (argv[1]);
  long number;
  long i;
  unsigned position;
  volatile unsigned result;

  /* Répète l'opération pour un nombre important de valeurs. */
  for (number = 1; number <= max; ++number) {
    /* Décale le nombre vers la droite jusqu'à ce qu'il vaille
       zéro. Mémorise le nombre de décalage qu'il a fallu faire. */
    for (i = (number >> 1), position = 0; i != 0; ++position)
      i >>= 1;
    /* La position du nombre non nul le plus significatif est le nombre
       de décalages qu'il a fallu après le premier. */
    result = position;
  }

  return 0;
}

#include <stdio.h>
#include <stdlib.h>
int main (int argc, char* argv[])
{
  long max = atoi (argv[1]);
  long number;
  unsigned position;
  volatile unsigned result;
  /* Repeat the operation for a large number of values. */
  for (number = 1; number <= max; ++number) {
    /* Compute the position of the most signi?cant set bit using the
       bsrl assembly instruction. */
    asm ("bsrl %1, %0" : "=r" (position) : "r" (number));
    result = position;
  }
  return 0;
}

Compilons les deux versions avec les optimisations actives:

% cc -O2 -o bit-pos-loop bit-pos-loop.c
% cc -O2 -o bit-pos-asm bit-pos-asm.c

À présent, lançons-les en utilisant la commande time pour mesurer le temps d'exécution. Il est nécessaire de passer une valeur importante comme argument afin de s'assurer que chaque version mette un minimum de temps à s'exécuter.

% time ./bit-pos-loop 250000000
real    0m27.042s
user    0m24.583s
sys     0m0.135s
% time ./bit-pos-asm 250000000
real    0m1.472s
user    0m1.442s
sys     0m0.013s

Voyez comme la version utilisant l'assembleur s'exécute beaucoup plus vite (vos propres résultats peuvent varier).