LEA指令的目的是什么？

对我来说，这就像一部时髦的MOV。它的目的是什么？何时使用？

正如其他人指出的那样，LEA（负载有效地址）通常被用作进行某些计算的“技巧”，但这并不是其主要目的。x86指令集旨在支持Pascal和C等高级语言，在这些语言中数组（尤其是整数或小结构的数组）很常见。例如，考虑一个表示（x，y）坐标的结构：

struct Point
{
     int xcoord;
     int ycoord;
};

现在想象一条语句：

int y = points[i].ycoord;

points[]的数组在哪里Point？假设阵列的基础已经在EBX和可变i是在EAX，并且xcoord和ycoord各自的32位（以便ycoord在在struct偏移4个字节），该语句可以被编译成：

MOV EDX, [EBX + 8*EAX + 4]    ; right side is "effective address"

它将降落y在EDX。比例因子8是因为每个Point大小为8个字节。现在考虑与运算符＆的“地址”一起使用的表达式：

int *p = &points[i].ycoord;

在这种情况下，您不需要的值ycoord，而是它的地址。这就是LEA（加载有效地址）的来源。MOV编译器可以生成而不是，

LEA ESI, [EBX + 8*EAX + 4]

这将在中加载地址ESI。

摘自Abrash 的“汇编禅”：

LEA，这是唯一执行内存寻址计算但实际上并未寻址内存的指令。LEA接受标准内存寻址操作数，但是只不过将计算出的内存偏移量存储在指定的寄存器中即可，该寄存器可以是任何通用寄存器。

这给了我们什么？ADD没有提供的两件事：

1. 使用两个或三个操作数执行加法的能力，以及
2. 将结果存储在任何寄存器中的能力；不只是源操作数之一。

并且LEA不会更改标志。

例子

• LEA EAX, [ EAX + EBX + 1234567 ]计算EAX + EBX + 1234567（这是三个操作数）
• LEA EAX, [ EBX + ECX ]计算时EBX + ECX不会覆盖任何结果。
• 如果您像这样使用LEA EAX, [ EBX + N * EBX ]（N可以是1,2,4,8），则可以乘以常数（乘以2、3、5 或9 ）。

其他的用例是在循环中派上用场：之间的区别LEA EAX, [ EAX + 1 ]，并INC EAX是后者的变化EFLAGS，但前者没有; 这样可以保留CMP状态。

该LEA指令的另一个重要特征是，在通过像或那样的算术指令计算地址时，它不会更改条件代码（例如CF和）。此功能降低了指令之间的依赖性，从而为编译器或硬件调度程序的进一步优化留出了空间。ZFADDMUL

尽管有所有解释，LEA是一种算术运算：

LEA Rt, [Rs1+a*Rs2+b] =>  Rt = Rs1 + a*Rs2 + b

只是它的名称对于shift + add操作极其愚蠢。评分最高的答案中已经说明了其原因（即，它旨在直接映射高级内存引用）。

也许关于LEA指令的另一件事。您还可以将LEA用于3、5或9的快速乘法寄存器。

LEA EAX, [EAX * 2 + EAX]   ;EAX = EAX * 3
LEA EAX, [EAX * 4 + EAX]   ;EAX = EAX * 5
LEA EAX, [EAX * 8 + EAX]   ;EAX = EAX * 9

lea是“加载有效地址”的缩写。它将源操作数将位置引用的地址加载到目标操作数。例如，您可以使用它来：

lea ebx, [ebx+eax*8]

使用单个指令进一步移动ebx指针eax项（在64位/元素数组中）。基本上，您将从x86架构支持的复杂寻址模式中受益，可以有效地操作指针。

LEA在a MOV上使用的最大原因是是否需要对要用来计算地址的寄存器执行算术运算。有效地，您可以有效地对多个寄存器组合使用相当于“免费”的指针算术运算。

真正令人困惑的是，您通常写的LEA像a，MOV但是实际上并没有取消引用内存。换一种说法：

MOV EAX, [ESP+4]

这将把ESP+4指向的内容移到EAX。

LEA EAX, [EBX*8]

这会将有效地址EBX * 8移入EAX，而不是该位置中找到的地址。如您所见，也可以乘以2的因子（缩放比例），而a MOV仅限于加/减。

8086具有大量的指令集，它们接受寄存器操作数和有效地址，执行一些计算以计算该有效地址的偏移量部分，并执行一些涉及寄存器和由计算出的地址引用的存储器的操作。让该系列中的指令之一按上述方式操作非常简单，只是跳过了实际的内存操作。这个，说明：

mov ax,[bx+si+5]
lea ax,[bx+si+5]

在内部几乎完全相同。区别是跳过的步骤。两种指令的工作方式如下：

temp = fetched immediate operand (5)
temp += bx
temp += si
address_out = temp  (skipped for LEA)
trigger 16-bit read  (skipped for LEA)
temp = data_in  (skipped for LEA)
ax = temp

至于为什么英特尔认为该指令值得包括在内，我不确定，但是实施起来便宜的事实将是一个很大的因素。另一个因素可能是英特尔的汇编程序允许相对于BP寄存器定义符号的事实。如果fnord定义为BP相对符号（例如BP + 8），则可以说：

mov ax,fnord  ; Equivalent to "mov ax,[BP+8]"

如果要使用诸如stosw之类的数据将数据存储到BP相对地址，则可以说

mov ax,0 ; Data to store
mov cx,16 ; Number of words
lea di,fnord
rep movs fnord  ; Address is ignored EXCEPT to note that it's an SS-relative word ptr

比：

mov ax,0 ; Data to store
mov cx,16 ; Number of words
mov di,bp
add di,offset fnord (i.e. 8)
rep movs fnord  ; Address is ignored EXCEPT to note that it's an SS-relative word ptr

请注意，忘记世界“偏移”将导致位置[BP + 8]的内容而不是值8的内容被添加到DI。哎呀。

如现有答案所述，它LEA具有以下优点：无需访问存储器即可执行存储器寻址算术，将算术结果保存到其他寄存器中，而不是简单的添加指令形式。真正的潜在性能优势是，现代处理器具有单独的LEA ALU单元和端口，可以有效地生成地址（包括LEA和其他内存参考地址），这意味着LEAALU中的算术运算和其他正常算术运算可以并行进行核心。

查看本文的Haswell体系结构以获取有关LEA单元的一些详细信息：http : //www.realworldtech.com/haswell-cpu/4/

在其他答案中没有提到的另一个重要点是LEA REG, [MemoryAddress]指令是PIC（位置无关代码），该代码对该指令中的PC相对地址进行编码以供参考MemoryAddress。这与MOV REG, MemoryAddress编码相对虚拟地址并需要在现代操作系统中进行重定位/修补（例如ASLR是常见功能）不同。因此LEA可用于将此类非PIC转换为PIC。

LEA指令可用于避免CPU耗时的有效地址计算。如果地址被重复使用，则将其存储在寄存器中会比每次使用该地址都更有效，而不是计算有效地址。

LEA（加载有效地址）指令是一种获取地址的方法，该地址源自任何英特尔处理器的内存寻址模式。

也就是说，如果我们有这样的数据移动：

MOV EAX, <MEM-OPERAND>

它将指定存储单元的内容移至目标寄存器。

如果我们将MOVby 替换为LEA，则通过<MEM-OPERAND>寻址表达式以完全相同的方式计算内存位置的地址。但是，除了存储位置的内容外，我们还可以将存储位置本身放入目标位置。

LEA不是特定的算术指令；这是一种拦截由于处理器的任何一种内存寻址模式而产生的有效地址的方法。

例如，我们可以LEA仅使用一个简单的直接地址。完全不涉及算术：

MOV EAX, GLOBALVAR   ; fetch the value of GLOBALVAR into EAX
LEA EAX, GLOBALVAR   ; fetch the address of GLOBALVAR into EAX.

这是有效的；我们可以在Linux提示符下对其进行测试：

$ as
LEA 0, %eax
$ objdump -d a.out

a.out:     file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <.text>:
   0:   8d 04 25 00 00 00 00    lea    0x0,%eax

在此，不增加比例值，也没有偏移。零被移入EAX。我们也可以将MOV与立即操作数一起使用。

这就是为什么认为括号LEA多余的人会严重误解的原因；括号不是LEA语法，而是地址模式的一部分。

LEA在硬件级别是真实的。生成的指令对实际的寻址模式进行编码，然后处理器执行该指令以计算地址。然后，它将该地址移至目标，而不是生成内存引用。（由于任何其他指令中的寻址模式的地址计算都不会影响CPU标志，因此LEA也不会影响CPU标志。）

与从地址零加载值相反：

$ as
movl 0, %eax
$ objdump -d a.out | grep mov
   0:   8b 04 25 00 00 00 00    mov    0x0,%eax

这是非常相似的编码，看到了吗？正义8d的LEA已更改为8b。

当然，这种LEA编码比将立即数零移动到的时间更长EAX。

$ as
movl $0, %eax
$ objdump -d a.out | grep mov
   0:   b8 00 00 00 00          mov    $0x0,%eax

没有理由LEA排除这种可能性，尽管仅仅是因为有一个更短的选择。它只是以正交方式与可用的寻址模式结合在一起。

这是一个例子。

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

使用-O（优化）作为编译器选项，gcc将为指定的代码行找到lea指令。

似乎许多答案已经完成，我想再添加一个示例代码，以显示lea和move指令在具有相同表达式格式时如何不同地工作。

长话短说，lea指令和mov指令都可以与括号内的src操作数一起使用。当它们括与（） ，在表达（）以同样的方式被计算; 但是，两条指令将以不同的方式解释src操作数中的计算值。

无论表达式是与lea还是mov一起使用，src值都将按以下方式计算。

D（Rb，Ri，S） => （Reg [Rb] + S * Reg [Ri] + D）

但是，与mov指令一起使用时，它将尝试访问由上述表达式生成的地址所指向的值，并将其存储到目的地。

与此相反，当使用上述表达式执行lea指令时，它会将生成的值直接加载到目标位置。

以下代码使用相同的参数执行lea指令和mov指令。但是，为了弥补差异，我添加了一个用户级信号处理程序来捕获由于mov指令导致访问错误地址而导致的分段错误。

范例程式码

#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
          );
}

执行结果

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

LEA：只是“算术”指令。

MOV在操作数之间传输数据，但是lea只是在计算

所有正常的“计算”指令（如加法，异或）或设置状态标志（如零，符号）。如果使用复杂的地址，AX xor:= mem[0x333 +BX + 8*CX] 则根据异或运算设置标志。

现在，您可能需要多次使用该地址。从未将这样的地址加载到寄存器中是为了设置状态标志，幸运的是，没有这样做。短语“加载有效地址”使程序员意识到这一点。那就是怪异表情的来源。

显然，一旦处理器能够使用复杂的地址来处理其内容，就可以将其用于其他目的。实际上，它可以用于x <- 3*x+1在一条指令中执行转换。这是汇编编程中的一条一般规则：使用说明，但会摇晃您的船。 唯一重要的是指令所体现的特定转换是否对您有用。

底线

MOV, X| T| AX'| R| BX|

和

LEA, AX'| [BX]

对AX具有相同的作用，但对状态标志没有影响。（这是ciasdis符号。）