Ninguna de las respuestas anteriores llegó al fondo de mi propia confusión, así que me gustaría agregar la mía.
Lo que me faltaba es que las leaoperaciones tratan el uso de paréntesis diferente de cómo lo movhace.
Piense en C. Digamos que tengo una variedad de longeso que llamo array. Ahora la expresión array[i]realiza una desreferencia, cargando el valor de la memoria en la dirección array + i * sizeof(long)[1].
Por otro lado, considere la expresión &array[i]. ¡Esto todavía contiene la sub-expresión array[i], pero no se realiza la desreferenciación! El significado de array[i]ha cambiado. Ya no significa realizar una deferencia, sino que actúa como una especie de especificación , indicando &qué dirección de memoria estamos buscando. Si lo desea, puede pensar alternativamente &como "cancelar" la desreferenciación.
Debido a que los dos casos de uso son similares en muchos aspectos, comparten la sintaxis array[i], pero la existencia o ausencia de un &cambio cambia la forma en que se interpreta esa sintaxis. Sin &, es una desreferencia y en realidad se lee de la matriz. Con &, no lo es. El valor array + i * sizeof(long)aún se calcula, pero no se desreferencia.
La situación es muy similar con mov y lea. Con mov, se produce una desreferencia que no sucede con lea. Esto es a pesar del uso de paréntesis que ocurre en ambos. Por ejemplo, movq (%r8), %r9y leaq (%r8), %r9. Con mov, estos paréntesis significan "desreferencia"; con lea, no lo hacen. Esto es similar a cómo array[i]solo significa "desreferencia" cuando no existe &.
Un ejemplo está en orden.
Considera el código
movq (%rdi, %rsi, 8), %rbp
Esto carga el valor en la ubicación de la memoria %rdi + %rsi * 8 en el registro %rbp. Es decir: obtener el valor en el registro %rdiy el valor en el registro %rsi. Multiplique el último por 8 y luego agréguelo al primero. Encuentre el valor en esta ubicación y colóquelo en el registro %rbp.
Este código corresponde a la línea C x = array[i]; , donde se arrayconvierte %rdiy se iconvierte %rsiy se xconvierte %rbp. El 8es la longitud del tipo de datos contenido en la matriz.
Ahora considere un código similar que usa lea:
leaq (%rdi, %rsi, 8), %rbp
Así como el uso de movqcorresponde a la desreferenciación, el uso de leaqaquí corresponde a no desreferenciar. Esta línea de montaje corresponde a la línea C x = &array[i];. Recuerde que &cambia el significado de array[i]desreferenciar a simplemente especificar una ubicación. Del mismo modo, el uso de leaqcambia el significado de (%rdi, %rsi, 8)desreferenciar a especificar una ubicación.
La semántica de esta línea de código es la siguiente: obtener el valor en el registro %rdiy el valor en el registro %rsi. Multiplique el último por 8 y luego agréguelo al primero. Coloque este valor en el registro %rbp. No hay carga de memoria involucrada, solo operaciones aritméticas [2].
Tenga en cuenta que la única diferencia entre mis descripciones de leaqymovq es que movqhace una desreferencia, y leaqno lo hace. De hecho, para escribir la leaqdescripción, básicamente copié + pegué la descripción movqy luego eliminé "Buscar el valor en esta ubicación".
Para resumir: movqvs. leaqes complicado porque tratan el uso de paréntesis, como en (%rsi)y (%rdi, %rsi, 8), de manera diferente. Enmovq (y en todas las demás instrucciones excepto lea), estos paréntesis denotan una desreferencia genuina, mientras que en leaqellos no lo hacen y son una sintaxis puramente conveniente.
[1] He dicho que cuando arrayes una matriz de long, la expresiónarray[i] carga el valor de la dirección array + i * sizeof(long). Esto es cierto, pero hay una sutileza que debe abordarse. Si escribo el código C
long x = array[5];
esto no es mismo que escribir
long x = *(array + 5 * sizeof(long));
Parece que debería basarse en mis declaraciones anteriores, pero no lo es.
Lo que sucede es que la adición del puntero C tiene un truco. Digamos que tengo un puntero que papunta a valores de tipo T. La expresión p + ihace no media "en la posición pmás ibytes". En cambio, la expresión en p + i realidad significa "la posición en pmás i * sizeof(T)bytes".
La conveniencia de esto es que para obtener "el siguiente valor" solo tenemos que escribir p + 1 lugar de p + 1 * sizeof(T).
Esto significa que el código C long x = array[5]; es realmente equivalente a
long x = *(array + 5)
porque C multiplicará automáticamente el 5 por sizeof(long).
Entonces, en el contexto de esta pregunta de StackOverflow, ¿cómo es todo esto relevante? Significa que cuando digo "la dirección array + i * sizeof(long)", no digo por " array + i * sizeof(long)" debe interpretarse como una expresión C. Estoy haciendo la multiplicación por sizeof(long)mí mismo para hacer mi respuesta más explícita, pero entiendo que debido a eso, esta expresión no debe leerse como C. Igual que las matemáticas normales que usan la sintaxis de C.
[2] Nota al margen: debido a que todo lo que leahace son operaciones aritméticas, sus argumentos en realidad no tienen que referirse a direcciones válidas. Por esta razón, a menudo se usa para realizar operaciones aritméticas puras en valores que pueden no ser desreferenciados. Por ejemplo, cccon-O2 optimización se traduce
long f(long x) {
return x * 5;
}
en lo siguiente (líneas irrelevantes eliminadas):
f:
leaq (%rdi, %rdi, 4), %rax # set %rax to %rdi + %rdi * 4
ret