Funktion von __asm__ __volatile__ (“” : : : “Speicher”)

Was im Grunde __asm__ __volatile__ () tut und was ist die Bedeutung von "memory" für ARM-Architektur?

asm volatile("" ::: "memory");

erstellt eine Speicherbarriere auf Compilerebene, die den Optimierer zwingt, Speicherzugriffe über die Barriere hinweg nicht neu zu ordnen.

Wenn Sie beispielsweise auf eine Adresse in einer bestimmten Reihenfolge zugreifen müssen (wahrscheinlich weil dieser Speicherbereich tatsächlich von einem anderen Gerät und nicht von einem Speicher unterstützt wird), müssen Sie dies dem Compiler mitteilen können, da er sonst möglicherweise nur Ihre Schritte optimiert für der Effizienz halber.

Angenommen, Sie müssen in diesem Szenario einen Wert in Adresse erhöhen, etwas lesen und einen anderen Wert in einer benachbarten Adresse erhöhen.

int c(int *d, int *e) {
        int r;
        d[0] += 1;
        r = e[0];
        d[1] += 1;
        return r;
}

Das Problem ist der Compiler (gcc in diesem Fall) kann Ihren Speicherzugriff neu anordnen, um eine bessere Leistung zu erzielen, wenn Sie danach fragen (-O). Wahrscheinlich führt dies zu einer Folge von Anweisungen wie unten:

00000000 <c>:
   0:   4603        mov r3, r0
   2:   c805        ldmia   r0, {r0, r2}
   4:   3001        adds    r0, #1
   6:   3201        adds    r2, #1
   8:   6018        str r0, [r3, #0]
   a:   6808        ldr r0, [r1, #0]
   c:   605a        str r2, [r3, #4]
   e:   4770        bx  lr

Obige Werte für d[0] und d[1] werden gleichzeitig geladen. Nehmen wir an, Sie möchten dies vermeiden, dann müssen Sie dem Compiler mitteilen, dass er die Speicherzugriffe nicht neu anordnen soll, und das ist zu verwenden asm volatile("" ::: "memory").

int c(int *d, int *e) {
        int r;
        d[0] += 1;
        r = e[0];
        asm volatile("" ::: "memory");
        d[1] += 1;
        return r;
}

So erhalten Sie Ihre Anweisungssequenz so, wie Sie sie haben möchten:

00000000 <c>:
   0:   6802        ldr r2, [r0, #0]
   2:   4603        mov r3, r0
   4:   3201        adds    r2, #1
   6:   6002        str r2, [r0, #0]
   8:   6808        ldr r0, [r1, #0]
   a:   685a        ldr r2, [r3, #4]
   c:   3201        adds    r2, #1
   e:   605a        str r2, [r3, #4]
  10:   4770        bx  lr
  12:   bf00        nop

Es sollte beachtet werden, dass dies nur eine Speicherbarriere zur Kompilierzeit ist, um zu verhindern, dass der Compiler Speicherzugriffe neu ordnet, da es keine zusätzlichen Anweisungen auf Hardwareebene gibt, um Speicher zu leeren oder darauf zu warten, dass das Laden oder Speichern abgeschlossen ist. CPUs können Speicherzugriffe immer noch neu ordnen, wenn sie über die architektonischen Fähigkeiten verfügen und Speicheradressen eingeschaltet sind normal Typ statt strongly ordered oder device (Ref).

Diese Sequenz ist eine Scheduling-Barriere für den Speicherzugriff des Compilers, wie in dem Artikel erwähnt, auf den Udo verweist. Dies ist GCC-spezifisch – andere Compiler haben andere Möglichkeiten, sie zu beschreiben, einige davon mit expliziteren (und weniger esoterischen) Aussagen.

__asm__ ist eine gcc-Erweiterung, die es ermöglicht, Assembler-Anweisungen verschachtelt in Ihren C-Code einzugeben – hier wegen ihrer Eigenschaft verwendet, Nebeneffekte angeben zu können, die den Compiler daran hindern, bestimmte Arten von Optimierungen durchzuführen (was in diesem Fall dazu führen könnte, dass falsche Code).

__volatile__ ist erforderlich, um sicherzustellen, dass die asm Die Anweisung selbst wird nicht mit anderen flüchtigen Zugriffen umgeordnet (eine Garantie in der Sprache C).

memory ist eine Anweisung an GCC, die (sozusagen) besagt, dass die Inline-ASM-Sequenz Nebenwirkungen auf den globalen Speicher hat und daher nicht nur Auswirkungen auf lokale Variablen berücksichtigt werden müssen.

Die Bedeutung wird hier erklärt:

http://en.wikipedia.org/wiki/Memory_ordering

Grundsätzlich bedeutet dies, dass der Assembler-Code dort ausgeführt wird, wo Sie es erwarten. Es weist den Compiler an, die Anweisungen nicht neu anzuordnen. Das ist, was codiert wird, bevor dieses Stück Code vorher ausgeführt wird, und was danach codiert wird, wird danach ausgeführt.

static inline unsigned long arch_local_irq_save(void)
{
    unsigned long flags;

    asm volatile(
        "   mrs %0, cpsr    @ arch_local_irq_save\n"
        "   cpsid   i"      //disabled irq
        : "=r" (flags) : : "memory", "cc");
return flags;
}