Excess Zwischenspeicheranweisung in ganzzahligen zusätzlich

Question

Hintergrund: GCC 6.1 bei -O3 Optimierungsstufe generiert diese assembly:

test ecx, ecx 
    je  .L8 
    xor  r8d, r8d 
    xor  eax, eax 

.L7: 
    xor  r9d, r9d 
    add  eax, DWORD PTR [rdi+r8*4]  ; adding a[i] 
    setc r9b 
    add  eax, DWORD PTR [rsi+r8*4]  ; adding b[i] 
    mov  r11d, eax      ; excessive mov (#1) 
    setc r10b 
    mov  DWORD PTR [rdx+r8*4], r11d ; storing at s[i] 
    add  r8, 1 
    movzx r10d, r10b 
    cmp  ecx, r8d 
    lea  eax, [r10+r9]     ; sorcery (#2) 
    ja  .L7 
    rep ret 

.L8: 
    xor  eax, eax 
    ret 

für diese Funktion:

limb_t add(
    const limb_t *a, 
    const limb_t *b, 
    limb_t *s, 
    int n 
) { 
    limb_t c = 0, t = 0; 

    for (int i = 0; i < n; ++i) { 
     t = a[i] + c; 
     c = t < a[i]; 

     t += b[i]; 
     c += t < b[i]; 

     s[i] = t; 
    } 

    return c; 
} 

wo a, b und s ganze Zahlen von gleiche Länge n Gliedmaßen, gespeichert im Speicher als eine kontinuierliche Sequenz von 32-Bit-Einheiten (Gliedmaßen, Ziffern) in Little Endian (das heißt, der erste ist t er am wenigsten signifikante Gliedmaße).

Diese Funktion fügt zwei nicht negative Summa a und b, speichert die Summe in s und gibt den Übertrag c. Die temporäre Variable t enthält den aktuellen Summenzweig und aktiviert die Szenarien a == s und b == s.

Wie ich von der Anordnung abgeleitet,

• rdi Register Basisadresse a Addend hält,
• rsi Register Basisadresse b Addend hält,
• rdx Register hält Basisadresse s, sum ,
• eax Registerkonten für beide c, tragen, und t, temporäre,
• r8 Register enthält i, Schleifenzähler,
• ecx Register enthält n, Länge in Gliedern von Addenden und sum.

---

Meine erste Frage ist:

1. Warum ist die Zwischenlagerung von eax Registerwert in r11d Registern stattfinden, bevor es in dem Speicher [rdx + r8*4] (aktuelle Schenkel Summe) zu verschieben?

Ich sehe keine andere Verwendung von r11 Register, aber für diese übermäßige Speicheroperation; und mov Anweisung tatsächlich erlaubt bewegen von eax registrieren, warum nicht den Wert von dort verschieben?

---

Meine zweite Frage lautet:

2. Was ist das für Zauberei mit lea Anweisung und tragen Werte?

lea  eax, [r10+r9]     ; sorcery (#2) 

Was berechnet es eigentlich? lea = r10 + r9? Und in diesem Fall, warum müssen wir hohe Bits von r10 jede Schleife Iteration mit dieser movzx Anweisung löschen?

movzx r10d, r10b 

Answer 1

Der erste scheint zu "verpasste Optimierung" Compiler Bug zu sein.

Die zweiten Bedürfnisse c der Größe dword für die t = a[i] + c; zu erzeugen, und es tut, die von den zwei logischen Werten erstrecken, mit unterschiedlichen Methoden, die zwar etwas seltsam ist:

t < a[i]; durch xor r9d, r9d durchgeführt wird und setc r9b aber t < b[i] wird von dem setc r10b und movzx r10d, r10b Paar durchgeführt. Es ist nicht sofort offensichtlich, aber dies könnte legitime Gründe für die Instruktionsplanung haben.

Das Hinzufügen der zwei logischen Werte erfolgt durch die lea eax, [r10+r9], die aus zwei Gründen statt add verwendet wird. Erstens betrifft es keine Flags, so dass es zwischen dem cmp und dem ja eingefügt werden kann. Zweitens kann es eine Ausgabe in einem dritten Register erzeugen.

Eine andere Möglichkeit wäre, die zwei logischen Werte zuerst hinzuzufügen und nur das Ergebnis zu erweitern. Nicht sicher, ob das ein besserer Ansatz wäre. Außerdem würde ein temporäres Register ausreichen.