Sembra che molte risposte siano già complete, vorrei aggiungere un altro codice di esempio per mostrare come l'istruzione lea e move funzioni in modo diverso quando hanno lo stesso formato di espressione.
Per farla breve, sia le istruzioni lea che le istruzioni mov possono essere usate con le parentesi che racchiudono l'operando src delle istruzioni. Quando sono racchiusi tra () , l'espressione in () viene calcolata allo stesso modo; tuttavia, due istruzioni interpreteranno il valore calcolato nell'operando src in modo diverso.
Se l'espressione viene utilizzata con lea o mov, il valore src viene calcolato come di seguito.
D (Rb, Ri, S) => (Reg [Rb] + S * Reg [Ri] + D)
Tuttavia, quando viene utilizzato con l'istruzione mov, tenta di accedere al valore indicato dall'indirizzo generato dall'espressione precedente e di memorizzarlo nella destinazione.
Al contrario, quando l'istruzione lea viene eseguita con l'espressione precedente, carica il valore generato così com'è alla destinazione.
Il codice seguente esegue l'istruzione lea e l'istruzione mov con lo stesso parametro. Tuttavia, per cogliere la differenza, ho aggiunto un gestore di segnale a livello di utente per rilevare l'errore di segmentazione causato dall'accesso a un indirizzo errato a seguito dell'istruzione mov.
Codice di esempio
#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
);
}
Risultato dell'esecuzione
Result of lea instruction: 14
inst at 0x4007b5 tries to access memory at 14, but failed