Apa tujuan dari instruksi LEA?

Bagi saya, sepertinya MOV yang funky. Apa tujuannya dan kapan saya harus menggunakannya?

Seperti yang telah ditunjukkan orang lain, LEA (memuat alamat efektif) sering digunakan sebagai "trik" untuk melakukan perhitungan tertentu, tetapi itu bukan tujuan utamanya. Set instruksi x86 dirancang untuk mendukung bahasa tingkat tinggi seperti Pascal dan C, di mana array — terutama array int atau struct kecil — adalah umum. Pertimbangkan, misalnya, struct yang mewakili (x, y) koordinat:

struct Point
{
     int xcoord;
     int ycoord;
};

Sekarang bayangkan sebuah pernyataan seperti:

int y = points[i].ycoord;

dimana points[]array dari Point. Dengan asumsi basis array sudah dalam EBX, dan variabel idalam EAX, dan xcoorddan ycoordmasing-masing 32 bit (demikian ycoordjuga pada offset 4 byte dalam struct), pernyataan ini dapat dikompilasi ke:

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

yang akan mendarat ydi EDX. Faktor skala 8 adalah karena masing Point- masing berukuran 8 byte. Sekarang perhatikan ungkapan yang sama yang digunakan dengan operator "alamat" &:

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

Dalam hal ini, Anda tidak ingin nilai ycoord, tetapi alamatnya. Di situlah LEA(memuat alamat efektif) masuk. Alih-alih MOV, kompiler dapat menghasilkan

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

yang akan memuat alamat di ESI.

Dari "Zen Majelis" oleh Abrash:

LEA, satu-satunya instruksi yang melakukan perhitungan pengalamatan memori tetapi tidak benar-benar mengatasi memori. LEAmenerima operan pengalamatan memori standar, tetapi tidak lebih dari menyimpan offset memori yang dihitung dalam register yang ditentukan, yang mungkin merupakan register tujuan umum.

Apa yang memberi kita? Dua hal yang ADDtidak memberikan:

1. kemampuan untuk melakukan penambahan dengan dua atau tiga operan, dan
2. kemampuan untuk menyimpan hasil dalam register apa pun ; bukan hanya salah satu dari operan sumber.

Dan LEAtidak mengubah bendera.

Contohnya

• LEA EAX, [ EAX + EBX + 1234567 ]menghitung EAX + EBX + 1234567(itulah tiga operan)
• LEA EAX, [ EBX + ECX ]menghitung EBX + ECXtanpa mengesampingkan baik dengan hasilnya.
• perkalian dengan konstan (dengan dua, tiga, lima atau sembilan), jika Anda suka LEA EAX, [ EBX + N * EBX ](N bisa 1,2,4,8).

Usecase lain berguna dalam loop: perbedaan antara LEA EAX, [ EAX + 1 ]dan INC EAXadalah bahwa yang terakhir berubah EFLAGStetapi yang pertama tidak; ini mempertahankan CMPkeadaan.

Fitur penting lainnya dari LEAinstruksi adalah bahwa ia tidak mengubah kode kondisi seperti CFdan ZF, saat menghitung alamat dengan instruksi aritmatika suka ADDatau MULtidak. Fitur ini mengurangi tingkat ketergantungan di antara instruksi dan dengan demikian membuat ruang untuk optimasi lebih lanjut oleh kompiler atau penjadwal perangkat keras.

Terlepas dari semua penjelasan, LEA adalah operasi aritmatika:

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

Hanya saja namanya sangat bodoh untuk operasi shift + add. Alasan untuk itu sudah dijelaskan dalam jawaban berperingkat teratas (yaitu ia dirancang untuk secara langsung memetakan referensi memori tingkat tinggi).

Mungkin hanya hal lain tentang instruksi LEA. Anda juga dapat menggunakan LEA untuk register yang berlipat ganda dengan 3, 5 atau 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

leaadalah singkatan dari "memuat alamat efektif". Itu memuat alamat referensi lokasi oleh operan sumber ke operan tujuan. Misalnya, Anda dapat menggunakannya untuk:

lea ebx, [ebx+eax*8]

untuk memindahkan item ebxpointer eaxlebih lanjut (dalam array 64-bit / elemen) dengan satu instruksi. Pada dasarnya, Anda mendapat manfaat dari mode pengalamatan kompleks yang didukung oleh arsitektur x86 untuk memanipulasi pointer secara efisien.

Alasan terbesar yang Anda gunakan di LEAatas MOVadalah jika Anda perlu melakukan aritmatika pada register yang Anda gunakan untuk menghitung alamat. Secara efektif, Anda dapat melakukan jumlah aritmatika penunjuk pada beberapa register dalam kombinasi secara efektif untuk "gratis."

Apa yang benar-benar membingungkan adalah bahwa Anda biasanya menulis LEAseperti MOVtetapi Anda tidak benar-benar mengingat memori. Dengan kata lain:

MOV EAX, [ESP+4]

Ini akan memindahkan konten ESP+4ke poin mana EAX.

LEA EAX, [EBX*8]

Ini akan memindahkan alamat efektif EBX * 8ke EAX, bukan yang ditemukan di lokasi itu. Seperti yang dapat Anda lihat, juga dimungkinkan untuk memperbanyak dengan dua faktor (penskalaan) sementara a MOVterbatas pada penambahan / pengurangan.

8086 memiliki keluarga besar instruksi yang menerima operan register dan alamat efektif, melakukan beberapa perhitungan untuk menghitung bagian offset dari alamat efektif itu, dan melakukan beberapa operasi yang melibatkan register dan memori yang dirujuk oleh alamat yang dihitung. Cukup sederhana untuk memiliki salah satu instruksi dalam keluarga itu berperilaku seperti di atas kecuali untuk melewatkan operasi memori yang sebenarnya. Ini, instruksi:

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

diimplementasikan hampir identik secara internal. Perbedaannya adalah langkah yang dilompati. Kedua instruksi tersebut bekerja seperti:

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

Mengenai mengapa Intel menganggap instruksi ini layak untuk dimasukkan, saya tidak begitu yakin, tetapi fakta bahwa itu murah untuk diterapkan akan menjadi faktor besar. Faktor lain adalah fakta bahwa assembler Intel memperbolehkan simbol untuk didefinisikan relatif terhadap register BP. Jika fnorddidefinisikan sebagai simbol relatif-BP (mis. BP + 8), bisa dikatakan:

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

Jika seseorang ingin menggunakan sesuatu seperti stosw untuk menyimpan data ke alamat relatif BP, bisa mengatakannya

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

lebih nyaman daripada:

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

Perhatikan bahwa melupakan dunia "offset" akan menyebabkan konten lokasi [BP + 8], bukannya nilai 8, ditambahkan ke DI. Ups.

Seperti jawaban yang ada disebutkan, LEAmemiliki keuntungan melakukan memori pengalamatan aritmatika tanpa mengakses memori, menyimpan hasil aritmatika ke register yang berbeda, bukan bentuk sederhana dari instruksi tambahan. Manfaat kinerja yang mendasari nyata adalah bahwa prosesor modern memiliki unit dan port LEA ALU terpisah untuk pembuatan alamat yang efektif (termasuk LEAdan alamat referensi memori lainnya), ini berarti operasi aritmatika LEAdan operasi aritmatika normal lainnya di ALU dapat dilakukan secara paralel dalam satu inti.

Lihat artikel arsitektur Haswell ini untuk beberapa detail tentang unit LEA: http://www.realworldtech.com/haswell-cpu/4/

Poin penting lain yang tidak disebutkan dalam jawaban lain adalah LEA REG, [MemoryAddress]instruksi adalah PIC (position independent code) yang menyandikan alamat relatif PC dalam instruksi ini sebagai referensi MemoryAddress. Ini berbeda dari MOV REG, MemoryAddressyang mengkodekan alamat virtual relatif dan memerlukan relokasi / patching dalam sistem operasi modern (seperti ASLR adalah fitur umum). Jadi LEAdapat digunakan untuk mengkonversi non PIC ke PIC.

Instruksi LEA dapat digunakan untuk menghindari perhitungan yang memakan waktu dari alamat yang efektif oleh CPU. Jika suatu alamat digunakan berulang kali, lebih efektif untuk menyimpannya dalam register daripada menghitung alamat efektif setiap kali digunakan.

Instruksi LEA (Load Effective Address) adalah cara untuk mendapatkan alamat yang muncul dari mode pengalamatan memori prosesor Intel.

Artinya, jika kita memiliki data yang bergerak seperti ini:

MOV EAX, <MEM-OPERAND>

itu memindahkan isi dari lokasi memori yang ditunjuk ke register target.

Jika kita mengganti MOVdengan LEA, maka alamat lokasi memori dihitung dengan cara yang persis sama dengan <MEM-OPERAND>ekspresi pengalamatan. Namun alih-alih isi lokasi memori, kami mendapatkan lokasi itu sendiri ke tujuan.

LEAbukan instruksi aritmatika tertentu; ini adalah cara mencegat alamat efektif yang timbul dari salah satu mode pengalamatan memori prosesor.

Misalnya, kita dapat menggunakan LEAhanya pada alamat langsung yang sederhana. Tidak ada aritmatika yang terlibat sama sekali:

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

Ini valid; kita dapat mengujinya di Linux prompt:

$ 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

Di sini, tidak ada penambahan nilai skala, dan tidak ada offset. Nol dipindahkan ke EAX. Kita bisa melakukannya menggunakan MOV dengan operan langsung juga.

Ini adalah alasan mengapa orang-orang yang berpikir bahwa tanda kurung LEAterlalu berlebihan salah besar; tanda kurung bukan LEAsintaks tetapi merupakan bagian dari mode pengalamatan.

LEA nyata di tingkat perangkat keras. Instruksi yang dihasilkan mengkodekan mode pengalamatan aktual dan prosesor membawanya ke titik penghitungan alamat. Kemudian memindahkan alamat itu ke tujuan alih-alih menghasilkan referensi memori. (Karena perhitungan alamat dari mode pengalamatan dalam instruksi lain tidak berpengaruh pada flag CPU, LEAtidak berpengaruh pada flag CPU.)

Berbeda dengan memuat nilai dari alamat nol:

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

Ini encoding yang sangat mirip, lihat? Hanya 8ddari LEAtelah berubah menjadi 8b.

Tentu saja, LEApengkodean ini lebih lama daripada memindahkan nol langsung ke EAX:

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

Tidak ada alasan untuk LEAmengecualikan kemungkinan ini hanya karena ada alternatif yang lebih pendek; itu hanya menggabungkan secara ortogonal dengan mode pengalamatan yang tersedia.

Berikut ini sebuah contoh.

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

Dengan -O (optimisasi) sebagai opsi kompiler, gcc akan menemukan instruksi lea untuk baris kode yang ditunjukkan.

Tampaknya banyak jawaban sudah selesai, saya ingin menambahkan satu lagi contoh kode untuk menunjukkan bagaimana lea dan memindahkan instruksi bekerja secara berbeda ketika mereka memiliki format ekspresi yang sama.

Untuk membuat cerita panjang pendek, instruksi lea dan instruksi mov keduanya dapat digunakan dengan tanda kurung melampirkan operan src dari instruksi. Ketika mereka diapit dengan () , ekspresi dalam () dihitung dengan cara yang sama; namun, dua instruksi akan menginterpretasikan nilai yang dihitung dalam operan src dengan cara yang berbeda.

Apakah ekspresi digunakan dengan lea atau mov, nilai src dihitung seperti di bawah ini.

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

Namun, ketika digunakan dengan instruksi mov, ia mencoba mengakses nilai yang ditunjukkan oleh alamat yang dihasilkan oleh ekspresi di atas dan menyimpannya ke tujuan.

Sebaliknya, ketika instruksi lea dieksekusi dengan ekspresi di atas, ia memuat nilai yang dihasilkan sebagaimana ke tujuan.

Kode di bawah ini mengeksekusi instruksi lea dan instruksi mov dengan parameter yang sama. Namun, untuk menangkap perbedaannya, saya menambahkan penangan sinyal level pengguna untuk menangkap kesalahan segmentasi yang disebabkan oleh mengakses alamat yang salah sebagai hasil dari instruksi mov.

Kode contoh

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

Hasil eksekusi

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

LEA: hanya instruksi "aritmatika" ..

MOV mentransfer data antar operan tetapi lea hanya menghitung

Semua instruksi "kalkulasi" normal seperti menambahkan perkalian, eksklusif atau mengatur tanda status seperti nol, tandatangani. Jika Anda menggunakan alamat yang rumit, AX xor:= mem[0x333 +BX + 8*CX] bendera ditetapkan sesuai dengan operasi xor.

Sekarang Anda mungkin ingin menggunakan alamat tersebut beberapa kali. Memuat addres semacam itu ke dalam register tidak pernah dimaksudkan untuk menetapkan bendera status dan untungnya tidak. Ungkapan "memuat alamat yang efektif" membuat programmer mengetahui hal itu. Dari situlah ekspresi aneh itu berasal.

Jelas bahwa begitu prosesor mampu menggunakan alamat yang rumit untuk memproses kontennya, ia mampu menghitungnya untuk keperluan lain. Memang itu dapat digunakan untuk melakukan transformasi x <- 3*x+1dalam satu instruksi. Ini adalah aturan umum dalam pemrograman rakitan: Gunakan instruksi namun itu menggetarkan perahu Anda. Satu-satunya hal yang diperhitungkan adalah apakah transformasi yang diwujudkan oleh instruksi bermanfaat bagi Anda.

Intinya

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

dan

LEA, AX'| [BX]

memiliki efek yang sama pada AX tetapi tidak pada bendera status. (Ini adalah notasi ciasdis .)

Maafkan saya jika seseorang telah menyebutkannya, tetapi di masa x86 ketika segmentasi memori masih relevan, Anda mungkin tidak mendapatkan hasil yang sama dari dua instruksi ini:

LEA AX, DS:[0x1234]

dan

LEA AX, CS:[0x1234]