Was ist der Zweck der LEA-Anweisung?

Question

Für mich ist es einfach nur ein komisches MOV. Was ist sein Zweck und wann sollte ich es verwenden?

Answer 1

Es scheint, dass viele Antworten bereits vollständig sind. Ich möchte noch ein weiteres Codebeispiel hinzufügen, um zu zeigen, wie die Anweisungen lea und move unterschiedlich funktionieren, obwohl sie das gleiche Ausdrucksformat haben.

Um es kurz zu machen: Die Befehle lea und mov können beide mit den Klammern verwendet werden, die den src-Operanden der Befehle einschließen. Wenn sie mit der Klammer () ist der Ausdruck in der () wird auf die gleiche Weise berechnet; zwei Anweisungen interpretieren den berechneten Wert im src-Operanden jedoch auf unterschiedliche Weise.

Unabhängig davon, ob der Ausdruck mit lea oder mov verwendet wird, wird der src-Wert wie folgt berechnet.

D ( Rb, Ri, S ) \=> (Reg[Rb]+S*Reg[Ri]+ D)

Wenn er jedoch mit dem mov-Befehl verwendet wird, versucht er, auf den Wert zuzugreifen, auf den die durch den obigen Ausdruck erzeugte Adresse zeigt, und ihn im Ziel zu speichern.

Wird dagegen die Anweisung lea mit dem obigen Ausdruck ausgeführt, lädt sie den erzeugten Wert so, wie er ist, in das Ziel.

Der folgende Code führt den Befehl lea und den Befehl mov mit demselben Parameter aus. Um jedoch den Unterschied festzustellen, habe ich einen Signalhandler auf Benutzerebene hinzugefügt, um den Segmentierungsfehler abzufangen, der durch den Zugriff auf eine falsche Adresse als Ergebnis der mov-Anweisung verursacht wird.

Beispiel-Code

#define _GNU_SOURCE 1  /* To pick up REG_RIP */
#include <stdio.h> 
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <signal.h>

uint32_t
register_handler (uint32_t event, void (*handler)(int, siginfo_t*, void*))
{
        uint32_t ret = 0;
        struct sigaction act;

        memset(&act, 0, sizeof(act));
        act.sa_sigaction = handler;
        act.sa_flags = SA_SIGINFO;
        ret = sigaction(event, &act, NULL);
        return ret;
}

void
segfault_handler (int signum, siginfo_t *info, void *priv)
{
        ucontext_t *context = (ucontext_t *)(priv);
        uint64_t rip = (uint64_t)(context->uc_mcontext.gregs[REG_RIP]);
        uint64_t faulty_addr = (uint64_t)(info->si_addr);

        printf("inst at 0x%lx tries to access memory at %ld, but failed\n",
                rip,faulty_addr);
        exit(1);
}

int
main(void)
{
        int result_of_lea = 0;

        register_handler(SIGSEGV, segfault_handler);

        //initialize registers %eax = 1, %ebx = 2

        // the compiler will emit something like
           // mov $1, %eax
           // mov $2, %ebx
        // because of the input operands
        asm("lea 4(%%rbx, %%rax, 8), %%edx \t\n"
            :"=d" (result_of_lea)   // output in EDX
            : "a"(1), "b"(2)        // inputs in EAX and EBX
            : // no clobbers
         );

        //lea 4(rbx, rax, 8),%edx == lea (rbx + 8*rax + 4),%edx == lea(14),%edx
        printf("Result of lea instruction: %d\n", result_of_lea);

        asm volatile ("mov 4(%%rbx, %%rax, 8), %%edx"
                       :
                       : "a"(1), "b"(2)
                       : "edx"  // if it didn't segfault, it would write EDX
          );
}

Ergebnis der Ausführung

Result of lea instruction: 14
inst at 0x4007b5 tries to access memory at 14, but failed

Answer 2

Der LEA-Befehl kann verwendet werden, um zeitaufwändige Berechnungen der effektiven Adressen durch die CPU zu vermeiden. Wenn eine Adresse wiederholt verwendet wird, ist es effektiver, sie in einem Register zu speichern, anstatt die effektive Adresse jedes Mal zu berechnen, wenn sie verwendet wird.

Answer 3

LEA vs. MOV (Antwort auf die ursprüngliche Frage)

LEA ist kein funky MOV . Wenn Sie MOV errechnet er die Adresse und greift auf den Speicher zu. LEA berechnet nur die Adresse, greift aber nicht auf den Speicher zu. Das ist der Unterschied.

In 8086 und später, LEA setzt einfach eine Summe von bis zu zwei Quellregistern und einen unmittelbaren Wert in ein Zielregister. Zum Beispiel, lea bp, [bx+si+3] setzt in das bp-Register die Summe aus bx plus si plus 3. Sie können diese Berechnung nicht durchführen, um das Ergebnis in einem Register zu speichern mit MOV .

Der 80386-Prozessor führte eine Reihe von Skalierungsmodi ein, bei denen der Indexregisterwert mit einem gültigen Skalierungsfaktor multipliziert werden kann, um die Verschiebung zu erhalten. Die gültigen Skalierungsfaktoren sind 1, 2, 4 und 8. Daher können Sie Befehle verwenden wie lea ebp, [ebx+esi*8+3] .

LDS & LES (optionale weiterführende Literatur)

Im Gegensatz zu LEA gibt es Anweisungen LDS y LES , die im Gegenteil Werte aus dem Speicher in das Registerpaar laden: ein Segmentregister ( DS o ES ) und ein allgemeines Register. Es gibt auch Versionen für die anderen Register: LFS , LGS y LSS para FS , GS y SS Segment-Register (eingeführt in 80386).

Diese Befehle laden also einen "Fernzeiger" - einen Zeiger, der aus einem 16-Bit-Segmentselektor und einem 16-Bit-Offset (oder einem 32-Bit-Offset, je nach Modus) besteht, so dass die Gesamtgröße des Fernzeigers im 16-Bit-Modus 32 Bit und im 32-Bit-Modus 48 Bit beträgt.

Dies sind praktische Anweisungen für den 16-Bit-Modus, sei es der 16-Bit-Real-Modus oder der 16-Bit-Protected-Modus.

Im 32-Bit-Modus sind diese Befehle nicht erforderlich, da die Betriebssysteme alle Segmentbasen auf Null setzen (flaches Speichermodell), so dass es nicht erforderlich ist, Segmentregister zu laden. Wir verwenden einfach 32-Bit-Zeiger, nicht 48.

Im 64-Bit-Modus sind diese Befehle nicht implementiert. Ihre Opcodes führen zu einer Zugriffsverletzungsunterbrechung (Ausnahme). Seit Intels Implementierung von VEX - "vector extensions - (AVX), hat Intel die Opcodes von LDS y LES und begann, sie für VEX-Präfixe zu verwenden. Wie Peter Cordes feststellte, ist das der Grund, warum nur x/ymm0..7 im 32-Bit-Modus zugänglich sind (Zitat): "Die VEX-Präfixe wurden sorgfältig entworfen, um sich nur mit ungültigen Kodierungen von LDS und LES im 32-Bit-Modus zu überschneiden, wo R X B alle 1 sind. Deshalb sind einige der Bits in den VEX-Präfixen invertiert".

Answer 4

Hier ist ein Beispiel.

// compute parity of permutation from lexicographic index
int parity (int p)
{
  assert (p >= 0);
  int r = p, k = 1, d = 2;
  while (p >= k) {
    p /= d;
    d += (k << 2) + 6; // only one lea instruction
    k += 2;
    r ^= p;
  }
  return r & 1;
}

Mit -O (optimize) als Compileroption findet gcc die Lea-Anweisung für die angegebene Codezeile.

Answer 5

LEA : nur eine "Rechenanweisung"

MOV überträgt Daten zwischen Operanden, aber lea rechnet nur