LEA命令の目的は何ですか？

私にとっては、ファンキーなMOVのようです。その目的は何ですか、いつ使用する必要がありますか？

他の人が指摘したように、LEA（ロード実効アドレス）は特定の計算を行うための「トリック」としてよく使用されますが、それはその主な目的ではありません。x86命令セットは、PascalやCなどの高水準言語をサポートするように設計されており、配列（特に、intまたは小さな構造体の配列）が一般的です。たとえば、（x、y）座標を表す構造体について考えます。

struct Point
{
     int xcoord;
     int ycoord;
};

次のようなステートメントを想像してみてください。

int y = points[i].ycoord;

ここでpoints[]の配列ですPoint。アレイのベースを想定することに既にあるEBX、変数はiでありEAX、且つxcoord、およびycoord各32ビット（そうであるycoord構造体のオフセット4バイトである）、このステートメントは、にコンパイルすることができます。

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

着陸yしEDXます。8のスケール係数は、それぞれのPointサイズが8バイトであるためです。次に、 "address of"演算子＆で使用される同じ式について考えます。

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

この場合、の値でycoordはなく、そのアドレスが必要です。ところですLEA（負荷実効アドレス）に入っています。代わりにMOV、コンパイラが生成することができます

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

でアドレスをロードしますESI。

Abrash の"Zen of Assembly"から：

LEA、メモリアドレッシング計算を実行するが、実際にはメモリをアドレッシングしない唯一の命令。LEA標準のメモリアドレッシングオペランドを受け入れますが、計算されたメモリオフセットを指定されたレジスタに格納するだけです。これは、任意の汎用レジスタである場合があります。

それは私たちに何を与えますか？ADD提供されない2つのこと：

1. 2つまたは3つのオペランドを使用して加算を実行する機能、および
2. 結果を任意のレジスタに保存する機能。ソースオペランドの1つだけではありません。

そして、LEAフラグを変更しません。

例

• LEA EAX, [ EAX + EBX + 1234567 ]計算EAX + EBX + 1234567（3つのオペランド）
• LEA EAX, [ EBX + ECX ]EBX + ECX結果を上書きせずに計算します。
• 定数による乗算（LEA EAX, [ EBX + N * EBX ]2、3、5 、または9 による）。

差：他のユースケースは、ループに便利であるLEA EAX, [ EAX + 1 ]とINC EAX後者変更することであるEFLAGSが、前者はありません。これはCMP状態を保持します。

LEA命令のもう1つの重要な機能は、またはのような算術命令によってアドレスを計算するときに、CFandのような条件コードを変更しないことです。この機能により、命令間の依存関係のレベルが低下し、コンパイラまたはハードウェアスケジューラによるさらなる最適化の余地が生まれます。ZFADDMUL

すべての説明にもかかわらず、LEAは算術演算です。

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

その名前が、shift + add操作に対して非常に愚かであるというだけです。その理由は、すでに上位の回答で説明されています（つまり、高レベルのメモリ参照を直接マップするように設計されています）。

LEA命令については、もう1つだけかもしれません。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]

1つの命令でebxポインターeax項目をさらに（64ビット/要素配列で）移動します。基本的に、ポインタを効率的に操作するために、x86アーキテクチャでサポートされている複雑なアドレッシングモードを利用できます。

あなたが使用することを最大の理由LEAの上にはMOV、あなたがアドレスを計算するために使用していることをレジスタに算術演算を実行する必要がある場合です。効果的には、いくつかのレジスタでポインタ演算に相当するものを効果的に組み合わせて「無料」で実行できます。

それについて本当に混乱しているのは、通常LEAaと同じように書いても、MOV実際にはメモリを逆参照していないということです。言い換えると：

MOV EAX, [ESP+4]

これにより、ESP+4ポイントするコンテンツがに移動しEAXます。

LEA EAX, [EBX*8]

これにより、有効なアドレスEBX * 8がEAXに移動します。その場所にあるものではありません。ご覧のとおり、a MOVは加算/減算に制限されていますが、2の係数（スケーリング）を乗算することもできます。

8086には、レジスタオペランドと実効アドレスを受け入れ、その実効アドレスのオフセット部分を計算するためにいくつかの計算を実行し、計算されたアドレスによって参照されるレジスタとメモリを含むいくつかの演算を実行する大きな命令ファミリがあります。そのファミリの命令の1つを実際のメモリ操作をスキップすることを除いて上記のように動作させることは、かなり簡単でした。これ、指示：

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

Intelがこの命令を含める価値があると思った理由については、はっきりとはわかりませんが、実装するのが安かったという事実が大きな要因だったでしょう。別の要因は、インテルのアセンブラーがシンボルを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

世界の「オフセット」を忘れると、値8ではなく場所[BP + 8]のコンテンツがDIに追加されることに注意してください。おっとっと。

既存の回答が述べたように、LEAメモリにアクセスせずにメモリアドレッシング演算を実行するという利点があり、単純な形式のadd命令ではなく、演算結果を別のレジスタに保存します。本当の根本的なパフォーマンスの利点は、最新のプロセッサが効果的なアドレス生成（LEAおよびその他のメモリ参照アドレスを含む）のために独立したLEA ALUユニットとポートをLEA備えていることです。芯。

LEAユニットの詳細については、Haswellアーキテクチャのこの記事を確認してください。http： //www.realworldtech.com/haswell-cpu/4/

他の回答で言及されていないもう1つの重要な点は、LEA REG, [MemoryAddress]命令ですMemoryAddress。この命令のPC相対アドレスを参照するようにエンコードするPIC（位置独立コード）です。これは、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フラグには影響しません。）

アドレス0からの値のロードとは対照的です。

$ 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 and move命令がどのように異なる動作をするかを示すサンプルコードをもう1つ追加したいと思います。

長い話を短くするために、lea命令とmov命令の両方を、命令のsrcオペランドを囲む括弧と共に使用できます。それらはで囲まれている場合（）における発現（）と同じ方法で計算されます。ただし、2つの命令は、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] 、フラグはxor操作に従って設定されます。

これで、アドレスを複数回使用することができます。このようなアドレスをレジスタにロードすることは、ステータスフラグを設定することを意図したものではなく、幸いにもそうではありません。「実効アドレスをロードする」というフレーズは、プログラマにそれを認識させます。それが奇妙な表現の源です。

プロセッサが複雑なアドレスを使用してそのコンテンツを処理できるようになると、他の目的のためにそれを計算できるようになることは明らかです。実際x <- 3*x+1、1つの命令で変換を実行するために使用できます。これは、アセンブリプログラミングの一般的な規則です。ボートを揺さぶる方法を使用してください。 重要なのは、命令によって具体化される特定の変換がユーザーにとって役立つかどうかだけです。

ボトムライン

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

そして

LEA, AX'| [BX]

AXには同じ効果がありますが、ステータスフラグには影響しません。（これはciasdis表記です。）