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