Quelle est la différence entre 'asm', '__asm " et " __asm__'?

Il y a une énorme différence entre MSVC inline asm et C de GNU asm inline. GCC syntaxe est conçu pour un rendement optimal sans gaspillage d'instructions, pour envelopper une seule instruction ou de quelque chose. MSVC syntaxe est conçu pour être assez simple, mais AFAICT impossible de l'utiliser sans le temps de latence et les instructions supplémentaires d'un aller-retour à travers la mémoire pour vos entrées et vos sorties.

Si vous êtes en ligne de l'asm pour des raisons de performance, ce qui rend MSVC asm inline viable que si vous écrivez un ensemble de boucle entièrement en asm, pas pour l'emballage de courtes séquences dans une fonction inline. L'exemple ci-dessous (emballage idiv avec une fonction) est le genre de chose que MSVC est mauvaise: ~8 extra store/instructions de chargement.

MSVC asm inline (utilisé par MSVC et probablement de la cpi, peut-être également disponibles dans certains compilateurs commerciaux):

• regarde vos asm à comprendre qui enregistre votre code étapes.
• ne peut transférer des données via la mémoire. Les données qui ont été vivre dans les registres est stockée par le compilateur pour préparer votre mov ecx, shift_count, par exemple. Donc à l'aide d'une seule instruction asm que le compilateur ne génère pas pour vous implique un aller-retour à travers la mémoire sur la manière et sur le moyen de sortir.
• plus débutant-friendly, mais souvent impossible d'éviter la surcharge d'obtenir des données in/out. Outre la syntaxe limitations, l'optimiseur dans les versions actuelles de MSVC n'est pas bon à l'optimisation autour de l'asm inline blocs, soit.

---

GNU C asm inline n'est pas une bonne façon d'apprendre l'asm. Vous devez comprendre asm très bien de sorte que vous pouvez dire au compilateur sur votre code. Et vous devez comprendre ce que les compilateurs ont besoin de savoir. Cette réponse a également des liens vers d'autres inline-asm guides et Q&Comme. Le x86 la balise wiki a beaucoup de bonnes choses pour l'asm en général, mais seulement des liens vers que pour GNU asm inline. (Les trucs dans sa réponse, est applicable à GNU asm inline sur la non-plates-formes x86, trop.)

GNU C asm inline syntaxe est utilisée par gcc, clang, cpi, et peut-être que certains compilateurs commerciaux qui mettent en œuvre GNU C:

• Vous avez à dire au compilateur que vous tabasser. À défaut, cela va conduire à la rupture de l'encerclement du code de la non-évidence de dur-à-debug façons.
• Puissant mais difficile à lire, d'apprendre et d'utiliser la syntaxe pour dire au compilateur comment approvisionnement en intrants, et où trouver des sorties. par exemple, "c" (shift_count) obtiendrez le compilateur de mettre la shift_count variable en ecx avant votre inline asm s'exécute.

• supplémentaire maladroit pour de grands blocs de code, parce que l'asm doit être à l'intérieur d'une chaîne constante. Donc, vous devez généralement

  "insn   %[inputvar], %%reg\n\t"       //comment
  "insn2  %%reg, %[outputvar]\n\t"

• très impitoyable /plus difficile, mais permet de réduire les frais généraux de l'esp. pour l'emballage de simples instructions. (emballage unique instructions a l'intention de conception d'origine, qui est pourquoi vous devez spécialement indiquent au compilateur début clobbers pour arrêter d'utiliser le même registre pour l'entrée et la sortie si c'est un problème).

---

Exemple: pleine largeur de la division entière (div)

Sur 32 bits PROCESSEUR, la division d'un 64 bits entier 32 bits entier, ou de faire un plein de multiplication (32x32->64), peuvent bénéficier de l'asm inline. gcc et clang ne prennent pas avantage de idiv pour (int64_t)a /(int32_t)b, probablement parce que l'instruction des défauts si le résultat ne rentre pas dans un registre 32 bits. Donc, contrairement à cette Q&Un sujet d'obtenir le quotient et le reste à partir d'un div, c'est un cas d'utilisation en ligne de l'asm. (Sauf si il y a un moyen d'informer le compilateur que le résultat de l'ajustement, de sorte idiv ne sera pas la faute.)

Nous allons utiliser les conventions d'appel qui a mis certains des arguments dans les registres (avec hi même dans le droit registre), afin de montrer une situation qui est plus proche de ce que vous pouvez voir lorsque l'in-lining une petite fonction comme ceci.

---

MSVC

Être prudent avec le registre-arg conventions d'appel lors de l'utilisation de inline-asm. Apparemment, le inline-asm soutien est tellement mal conçu ou mis en œuvre que le compilateur peut pas enregistrer/restaurer arg registres autour de l'asm inline, si ces arguments ne sont pas utilisés dans la ligne de l'asm. Merci @RossRidge pour le rappeler.

//MSVC.  Be careful with _vectorcall & inline-asm: see above
//we could return a struct, but that would complicate things
int _vectorcall div64(int hi, int lo, int divisor, int *premainder) {
    int quotient, tmp;
    __asm {
        mov   edx, hi;
        mov   eax, lo;
        idiv   divisor
        mov   quotient, eax
        mov   tmp, edx;
        //mov ecx, premainder   //Or this I guess?
        //mov   [ecx], edx
    }
    *premainder = tmp;
    return quotient;     //or omit the return with a value in eax
}

Mise à jour: apparemment, laissant une valeur dans eax ou edx:eax et puis la chute, à la fin d'un non-void function (sans return) est pris en charge, même lorsque l'in-lining. Je suppose que cela ne fonctionne que si il n'y a pas de code après la asm déclaration. Cela évite le magasin/recharge pour la sortie (au moins pour quotient), mais nous ne pouvons rien faire sur les entrées. Dans un non-fonction inline avec pile d'arguments, ils seront dans la mémoire déjà, mais dans ce cas, nous sommes en train d'écrire une petite fonction qui pourrait utilement dans la ligne.

---

Compilé avec MSVC 19.00.23026 /O2 sur rextester (avec un main() qui trouve le répertoire de l'exe et vide le compilateur asm sortie sur stdout).

## My added comments use. ##
; ... define some symbolic constants for stack offsets of parameters
; 48   : int ABI div64(int hi, int lo, int divisor, int *premainder) {
    sub esp, 16                 ; 00000010H
    mov DWORD PTR _lo$[esp+16], edx      ## these symbolic constants match up with the names of the stack args and locals
    mov DWORD PTR _hi$[esp+16], ecx

    ## start of __asm {
    mov edx, DWORD PTR _hi$[esp+16]
    mov eax, DWORD PTR _lo$[esp+16]
    idiv    DWORD PTR _divisor$[esp+12]
    mov DWORD PTR _quotient$[esp+16], eax  ## store to a local temporary, not *premainder
    mov DWORD PTR _tmp$[esp+16], edx
    ## end of __asm block

    mov ecx, DWORD PTR _premainder$[esp+12]
    mov eax, DWORD PTR _tmp$[esp+16]
    mov DWORD PTR [ecx], eax               ## I guess we should have done this inside the inline asm so this would suck slightly less
    mov eax, DWORD PTR _quotient$[esp+16]  ## but this one is unavoidable
    add esp, 16                 ; 00000010H
    ret 8

Il y a une tonne supplémentaire instructions mov, et le compilateur ne vient même pas près d'optimiser tout de loin. J'ai pensé que peut-être il serait de voir et de comprendre le mov tmp, edx à l'intérieur de l'asm inline, et en faire un magasin pour premainder. Mais cela nécessiterait de chargement premainder de la pile dans un registre avant de l'asm inline block, je suppose.

Cette fonction est en fait pire avec _vectorcall que la normale tout-sur-la-pile ABI. Avec deux entrées dans les registres, il les stocke dans la mémoire afin de l'asm inline pouvez les charger à partir de variables nommées. Si c'était inline, encore plus de paramètres pourraient être dans les regs, et il aurait pour stocker tous, de sorte que l'asm aurait mémoire opérandes! Donc, contrairement à gcc, nous ne sommes pas gagner beaucoup de inline cette.

Faire *premainder = tmp à l'intérieur de l'asm bloc signifie plus de code écrit en asm, mais ne les éviter totalement braindead magasin/load/store chemin pour le reste. Cela réduit l'instruction de comptage par 2 total, en baisse de 11 (non compris le ret).

Je vais essayer d'obtenir le meilleur code possible de MSVC, ne pas utiliser de mal" et de créer une paille-homme argument. Mais AFAICT c'est horrible pour l'emballage de très courtes séquences. Sans doute il y a une fonction intrinsèque pour 64/32 -> 32 division qui permet au compilateur de générer du code pour ce cas particulier, de sorte que l'ensemble de la prémisse de l'aide asm inline pour cela sur MSVC pourrait être une paille-homme argument. Mais il ne vous montrer que intrinsèques sont beaucoup mieux que dans la ligne de l'asm pour MSVC.

---

C GNU (gcc/clang/cpi)

Gcc fait encore mieux que le résultat indiqué ici quand inline div64, car il peut prendre des dispositions pour le code précédent pour générer le 64 bits entier dans edx:eax en premier lieu.

Je ne peux pas obtenir de gcc pour compiler pour le 32bit vectorcall ABI. Clang peut, mais il aspire à l'asm inline avec "rm" contraintes (essayez sur la godbolt lien: il rebondit fonction arg à travers la mémoire au lieu d'utiliser l'option inscrivez-vous à la contrainte). Le 64 bits MS convention d'appel est proche de la 32bit vectorcall, avec les deux premiers paramètres dans edx, ecx. La différence est que les 2 plus params aller dans regs avant d'utiliser la pile (et que le destinataire de l'appel ne se déclenche pas les arguments hors de la pile, qui est ce que la ret 8 a été sur dans le MSVC de sortie.)

//GNU C
//change everything to int64_t to do 128b/64b -> 64b division
//MSVC doesn't do x86-64 inline asm, so we'll use 32bit to be comparable
int div64(int lo, int hi, int *premainder, int divisor) {
    int quotient, rem;
    asm ("idivl  %[divsrc]"
          : "=a" (quotient), "=d" (rem)    //a means eax,  d means edx
          : "d" (hi), "a" (lo),
            [divsrc] "rm" (divisor)        //Could have just used %0 instead of naming divsrc
            //note the "rm" to allow the src to be in a register or not, whatever gcc chooses.
            //"rmi" would also allow an immediate, but unlike adc, idiv doesn't have an immediate form
          : //no clobbers
        );
    *premainder = rem;
    return quotient;
}

compilé avec l'option gcc-m64 -O3-mabi=ms-fverbose-asm. Avec -m32, vous obtenez juste 3 des charges, idiv, et un magasin, comme vous pouvez le voir partir, changer des trucs dans ce godbolt lien.

mov     eax, ecx  # lo, lo
idivl  r9d      # divisor
mov     DWORD PTR [r8], edx       # *premainder_7(D), rem
ret

Pour les 32 bits vectorcall, gcc ferais quelque chose comme

## Not real compiler output, but probably similar to what you'd get
mov     eax, ecx               # lo, lo
mov     ecx, [esp+12]          # premainder
idivl   [esp+16]               # divisor
mov     DWORD PTR [ecx], edx   # *premainder_7(D), rem
ret   8

---

MSVC utilise 13 instructions (pas y compris le ret), par rapport à gcc 4. Avec l'in-lining, comme je l'ai dit, il pourrait être compilé en un seul, tandis que MSVC serait toujours utiliser probablement 9. (Vous n'aurez pas besoin de réserver de l'espace de pile ou de la charge premainder; je suis en supposant qu'il a encore de la stocker sur 2 des 3 entrées. Puis il recharge à l'intérieur de l'asm, s'exécute idiv, de magasins, de deux sorties, et la recharge à l'extérieur de l'asm. Si c'est 4 charges/magasins pour l'entrée, et un autre 4 pour la sortie.)

asm vs __asm__ dans GCC

asm ne fonctionne pas avec -std=c99, vous avez deux solutions:

• utilisation __asm__
• utilisation -std=gnu99

Plus de détails: erreur: ‘asm’ non déclaré (première utilisation dans cette fonction)

__asm vs __asm__ dans GCC

Je ne pouvais pas trouver où __asm est documentée (notamment pas mentionné à https://gcc.gnu.org/onlinedocs/gcc-7.2.0/gcc/Alternate-Keywords.html#Alternate-Keywords ), mais à partir de la CCAG 8.1 source ils sont exactement les mêmes:

  { "__asm",        RID_ASM,    0 },
  { "__asm__",      RID_ASM,    0 },

donc, je voudrais juste utiliser __asm__ qui est documenté.