Was ist der Unterschied zwischen "asm", "asm" und "asm"?

Es gibt einen massiven Unterschied zwischen MSVC inline-Assembler und GNU-C inline-asm. GCC-syntax entworfen für optimale Leistung, ohne verschwendet Anweisungen für die Verpackung einer einzelnen Anweisung oder so etwas. MSVC syntax ist entworfen, um zu sein, ziemlich einfach, aber AFAICT es ist unmöglich zu verwenden, ohne die Wartezeit und zusätzliche Anweisungen von einer Rundreise durch Speicher für Ihre ein-und Ausgänge.

Wenn Sie mit den inline asm aus performance-Gründen, diese macht MSVC inline-asm nur lebensfähig, wenn Sie schreiben, eine ganze Schleife komplett in asm, nicht für die Verpackung kurze Sequenzen, die in eine inline-Funktion. Das Beispiel unten (Verpackung idiv mit einer Funktion) ist die Art von Sache, die MSVC ist schlecht: ~8 extra store - /load-Anweisungen.

MSVC inline-asm (mit MSVC und wahrscheinlich icc, vielleicht auch in einigen kommerziellen Compilern):

• schaut auf Eure asm, um herauszufinden, welche Register Ihre code-Schritte auf.
• können nur die Daten übertragen, über Speicher. Daten, die live in Registern gespeichert ist, der vom compiler zur Vorbereitung Ihrer mov ecx, shift_count zum Beispiel. So mit einer einzigen asm-Anweisung, die der compiler nicht generiert für Sie beinhaltet eine Rundfahrt durch Speicher-auf dem Weg in und auf dem Weg nach draußen.
• mehr Anfänger-freundlich, aber oft nicht möglich ist, um Aufwand zu vermeiden, um Daten in/out. Auch neben der syntax Einschränkungen, die der Optimierer in den aktuellen Versionen von MSVC ist nicht gut an der Optimierung rund um die inline-asm-blocks, entweder.

GNU-C-inline-asm ist nicht ein guter Weg, um zu lernen, asm. Sie haben, um zu verstehen, asm sehr gut, so dass Sie sagen kann der compiler über den code. Und Sie haben zu verstehen, was der Compiler wissen muss. Diese Antwort hat auch links zu anderen inline-asm-guides und Q&As. Die x86 - tag wiki hat viele gute Sachen für asm im Allgemeinen, sondern nur links auf, die für GNU inline-asm. (Die Sachen, die in diese Antwort gilt für GNU inline-asm auf nicht-x86-Plattformen, auch.)

GNU-C-inline-asm-syntax von gcc, clang, icc -, und vielleicht einigen kommerziellen Compilern, die für die Einführung GNU C:

• Müssen Sie sagen dem compiler, was Sie verpasste. Andernfalls führt dies zu einem Bruch der umgebenden code in nicht-offensichtlich schwer zu debug-Möglichkeiten.
• Mächtig, aber schwer zu Lesen, zu lernen und verwenden Sie eine syntax für das erzählen der compiler, wie die Versorgung Eingänge, und wo Sie zu finden Ausgänge. z.B. "c" (shift_count) erhalten den compiler, die shift_count variable in ecx bevor Sie Ihre inline-asm führt.

• extra klobig für große code-Blöcke, weil die asm hat innerhalb einer string-Konstante. In der Regel benötigen Sie

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

• sehr nachtragend /härter, sondern ermöglicht geringere overhead-esp. zum Verpacken von einzelnen Anweisungen. (Verpackung einzelne Anweisungen war die ursprüngliche design-Absicht, die ist, warum haben Sie speziell zu sagen, der compiler über die frühe clobbers um ihn zu stoppen, verwenden die gleichen register für input-und output-ob das ein problem.)

Beispiel: full-width integer-division (div)

Auf einem 32-bit-CPU, die Aufteilung einer 64-bit-integer durch einen 32bit integer oder wenn Sie eine full-multiplizieren (32x32->64), profitieren von inline-asm. gcc und clang nicht nutzen idiv für (int64_t)a /(int32_t)b, wahrscheinlich, weil die Anleitung Fehler, wenn das Ergebnis passt nicht in ein 32bit-register. Also im Gegensatz zu dieses Q&A über die erste quotient und Rest von einem div, ist dies ein Fall für die inline-asm. (Es sei denn, es gibt einen Weg, um zu informieren den compiler, dass das Ergebnis passt, also idiv nicht Schuld.)

Verwenden wir Aufrufkonventionen, dass einige Argumente in Registern (mit hi auch in der Recht registrieren), um zu zeigen, eine situation, die näher zu dem, was Sie sehen würden, wenn inlining eine kleine Funktion wie diese.

MSVC

Vorsichtig sein mit der register-arg Aufrufkonventionen bei der Verwendung von inline-asm. Anscheinend ist der inline-asm-support ist so schlecht entworfen/implementiert, dass der compiler kann nicht speichern/wiederherstellen arg Register rund um das inline-asm, wenn diese Argumente nicht verwendet werden, die in die inline-asm. Danke @RossRidge für den Hinweis.

//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
}

Update: anscheinend verlassen ein Wert in eax oder edx:eax und dann fallen aus dem Ende einer nicht-void-Funktion (ohne return) unterstützt wird, auch beim inlining. Ich nehme an, das funktioniert nur, wenn es kein code nach der asm - Anweisung. Dies vermeidet das speichern/reload für die Leistung (zumindest für quotient), aber wir können nichts über die Eingänge. In einer nicht-inline-Funktion mit stack args, werden Sie im Speicher schon, aber in diesen Fall schreiben wir eine kleine Funktion, die sinnvollerweise inline.

Kompiliert mit MSVC 19.00.23026 /O2 auf rextester (mit einem main() findet sich das Verzeichnis der exe-Datei und dumps der compiler asm-Ausgabe auf 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

Es gibt eine Tonne von extra-mov-Anweisungen, und der compiler nicht einmal nahe kommen, um die Optimierung jedes von ihm entfernt. Ich dachte, vielleicht würden Sie es sehen und verstehen, das mov tmp, edx im inneren des inline asm, und machen, dass ein Geschäft zu premainder. Das würde aber erfordern das laden premainder vom stack in ein register, bevor die inline-asm-block, denke ich.

Diese Funktion ist eigentlich schlimmer mit _vectorcall als mit dem normalen alles-auf-den-stack-ABI. Mit zwei Eingängen in einem Register, es speichert Sie in den Speicher, so dass die inline-asm-laden können Sie aus den benannten Variablen. Wenn dies eingebettet, mehr noch der Parameter, die möglicherweise in die regs, und es wäre speichern Sie Sie alle, so der asm hätte speicheroperanden! Also im Gegensatz zu gcc, brauchen wir nicht viel zu gewinnen von inlining.

Tun *premainder = tmp innerhalb der asm-block bedeutet mehr code geschrieben in asm, aber nicht vermeiden, die völlig braindead speichern - /laden - /Speicher-Pfad für den Rest. Dies reduziert die Anweisung count von 2 insgesamt 11 (nicht einschließlich die ret).

Ich versuche, den bestmöglichen code aus der MSVC, nicht auf "verwenden Sie es falsch", und erstellen Sie ein Stroh-Mann argument. Aber AFAICT es ist schrecklich für die Verpackung sehr kurze Sequenzen. Vermutlich gibt es eine systeminterne Funktion für 64/32 -> 32-Sparte, kann der compiler guten code zu generieren, der für diesen speziellen Fall, so dass die gesamte Prämisse der Verwendung von inline-asm für MSVC könnte ein Stroh-Mann argument. Aber es zeigt Ihnen, dass Interna viel besser als inline-asm für MSVC.

GNU C (gcc/clang/icc)

Gcc nicht sogar besser als die Leistung, die hier gezeigt beim inlining div64, denn es können in der Regel arrangieren für den vorangehenden code zu generieren, der 64-bit-Ganzzahl in edx:eax in den ersten Platz.

Kann ich nicht bekommen gcc zum kompilieren für die 32bit vectorcall ABI. Clang kann, aber es nervt beim inline asm mit "rm" Einschränkungen (versuchen Sie es auf die godbolt link: es prallt Funktion arg durch den Speicher statt mit der register-option in der Toolbar). Die 64-bit-MS-Aufrufkonvention ist in der Nähe der 32bit vectorcall, die ersten beiden Parameter edx, ecx. Der Unterschied ist, dass 2 weitere Parameter gehen in regs vor, den stack verwenden (und, dass der angerufene nicht pop die Argumente aus dem stack, das ist, was die ret 8 war etwa in der MSVC-Ausgabe.)

//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;
}

kompilieren mit gcc -m64 -O3 -mabi=ms -fverbose-asm. Mit -m32 bekommst du nur 3 Lasten, idiv, und einen Speicher, wie Sie sehen können, ändern Sachen, die godbolt link.

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

32bit vectorcall, gcc möchte etwas tun, wie

## 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-Verwendung 13 Anleitung (nicht einschließlich der ret), im Vergleich zu gcc 4. Mit inlining, wie ich sagte, möglicherweise kompiliert nur eine, während MSVC würde immer noch verwenden, wahrscheinlich 9. (Sie brauchen nicht zu reservieren stack-Speicher oder laden premainder; ich nehme an, es hat noch zu speichern, zu 2 der 3 Eingänge. Dann lädt es Sie im inneren des asm, läuft idiv, speichert zwei Ausgänge, und lädt Sie auch außerhalb der asm. So, die 4 lädt/speichert, für die Eingabe, und die anderen 4 für die Ausgabe.)

InformationsquelleAutor der Antwort Peter Cordes

asm vs __asm__

asm funktioniert nicht mit -std=c99, haben Sie zwei alternativen:

• verwenden __asm__
• verwenden -std=gnu99

Mehr details: Fehler: 'asm' schwarzarbeit (erste Benutzung in dieser Funktion)

InformationsquelleAutor der Antwort Ciro Santilli 包子露宪 六四事件 法轮功