Nessuna delle risposte precedenti è arrivata fino in fondo alla mia confusione, quindi vorrei aggiungere la mia.
Quello che mi mancava è che le leaoperazioni trattano l'uso delle parentesi in modo diverso da come movfunziona.
Pensa a C. Diciamo che ho una serie di longciò che chiamo array. Ora l'espressione array[i]esegue una dereferenza, caricando il valore dalla memoria all'indirizzo array + i * sizeof(long)[1].
D'altra parte, considera l'espressione &array[i]. Questo contiene ancora la sottoespressione array[i], ma non viene eseguita alcuna dereferenziazione! Il significato di array[i]è cambiato. Non significa più eseguire una deferenza ma si comporta invece come una specie di specifica , indicando &quale indirizzo di memoria stiamo cercando. Se lo desideri, puoi in alternativa pensare &a "cancellare" la dereferenza.
Poiché i due casi d'uso sono simili in molti modi, condividono la sintassi array[i], ma l'esistenza o l'assenza di una &modifica cambia il modo in cui tale sintassi viene interpretata. Senza &, è una dereferenza e in realtà legge dall'array. Con &, non lo è. Il valore array + i * sizeof(long)è ancora calcolato, ma non è referenziato.
La situazione è molto simile con move lea. Con mov, si verifica una dereferenza che non accade con lea. Questo nonostante l'uso delle parentesi che si verificano in entrambi. Ad esempio, movq (%r8), %r9e leaq (%r8), %r9. Con mov, queste parentesi significano "dereference"; con lea, non lo fanno. Questo è simile a come array[i]significhi "dereference" solo quando non c'è &.
Un esempio è in ordine.
Considera il codice
movq (%rdi, %rsi, 8), %rbp
Questo carica il valore nella posizione di memoria %rdi + %rsi * 8nel registro %rbp. Cioè: ottenere il valore nel registro %rdie il valore nel registro %rsi. Moltiplica il secondo per 8, quindi aggiungilo al primo. Trova il valore in questa posizione e inseriscilo nel registro %rbp.
Questo codice corrisponde alla linea C x = array[i];, dove arraydiventa %rdie idiventa %rsie xdiventa %rbp. La 8è la lunghezza del tipo di dati contenuti nella matrice.
Ora considera un codice simile che utilizza lea:
leaq (%rdi, %rsi, 8), %rbp
Proprio come l'uso di movqcorrisponde al dereferenziamento, l'uso di leaqqui corrisponde al non dereferenziamento. Questa linea di montaggio corrisponde alla linea C x = &array[i];. Ricordiamo che &cambia il significato del array[i]dereferenziare semplicemente specificando una posizione. Allo stesso modo, l'uso di leaqcambia il significato di (%rdi, %rsi, 8)da dereferenziazione a specificare un luogo.
La semantica di questa riga di codice è la seguente: ottenere il valore nel registro %rdie il valore nel registro %rsi. Moltiplica il secondo per 8, quindi aggiungilo al primo. Inserire questo valore nel registro %rbp. Nessun carico dalla memoria è coinvolto, solo operazioni aritmetiche [2].
Nota che l'unica differenza tra le mie descrizioni di leaqe movqè che movqfa una dereferenza e leaqnon lo fa. In effetti, per scrivere la leaqdescrizione, ho praticamente copiato + incollato la descrizione movqe poi rimosso "Trova il valore in questa posizione".
Riassumendo: movqvs. leaqè complicato perché trattano l'uso delle parentesi, come in (%rsi)e (%rdi, %rsi, 8), in modo diverso. In movq(e tutte le altre istruzioni tranne lea), queste parentesi denotano un'autentica dereferenza, mentre in leaqesse non sono e sono sintassi puramente convenienti.
[1] Ho detto che quando arrayè un array di long, l'espressione array[i]carica il valore dall'indirizzo array + i * sizeof(long). Questo è vero, ma c'è una sottigliezza che dovrebbe essere affrontata. Se scrivo il codice C.
long x = array[5];
questo non è lo stesso della digitazione
long x = *(array + 5 * sizeof(long));
Sembra che dovrebbe essere basato sulle mie precedenti dichiarazioni, ma non lo è.
Quello che sta succedendo è che l'aggiunta del puntatore C ha un trucco. Supponiamo di avere un puntatore che ppunta a valori di tipo T. L'espressione p + ifa non medio "la posizione in ppiù ibyte". Al contrario, l'espressione in p + i realtà significa "la posizione a byte ppiù i * sizeof(T)".
La comodità di questo è che per ottenere "il valore successivo" non ci resta che scrivere p + 1al posto di p + 1 * sizeof(T).
Ciò significa che il codice C long x = array[5];è effettivamente equivalente a
long x = *(array + 5)
perché C moltiplicherà automaticamente 5per sizeof(long).
Quindi, nel contesto di questa domanda StackOverflow, in che modo tutto ciò è rilevante? Significa che quando dico "l'indirizzo array + i * sizeof(long)", non intendo che " array + i * sizeof(long)" sia interpretato come un'espressione C. Sto facendo la moltiplicazione da sizeof(long)solo per rendere la mia risposta più esplicita, ma capisco che a causa di ciò, questa espressione non dovrebbe essere letta come C. Proprio come la matematica normale che usa la sintassi C.
[2] Nota a margine: poiché tutto leaciò che fa sono operazioni aritmetiche, i suoi argomenti in realtà non devono fare riferimento a indirizzi validi. Per questo motivo, viene spesso utilizzato per eseguire la pura aritmetica su valori che potrebbero non essere intesi come non dedotti. Ad esempio, cccon l' -O2ottimizzazione si traduce
long f(long x) {
return x * 5;
}
nei seguenti (righe irrilevanti rimosse):
f:
leaq (%rdi, %rdi, 4), %rax # set %rax to %rdi + %rdi * 4
ret