Nenhuma das respostas anteriores chegou ao fundo da minha própria confusão, então eu gostaria de adicionar a minha.
O que eu estava perdendo é que as leaoperações tratam o uso de parênteses de maneira diferente de comomov .
Pense em C. Digamos que eu tenha uma matriz longque eu chamo array. Agora a expressão array[i]executa uma desreferência, carregando o valor da memória no endereço array + i * sizeof(long)[1].
Por outro lado, considere a expressão &array[i]. Isso ainda contém a subexpressão array[i], mas nenhuma desreferenciação é realizada! O significado de array[i]mudou. Não significa mais executar uma deferência, mas age como uma espécie de especificação , informando &o endereço de memória que estamos procurando. Se quiser, você pode pensar alternadamente &em "cancelar" a desreferência.
Como os dois casos de uso são semelhantes em muitos aspectos, eles compartilham a sintaxe array[i], mas a existência ou ausência de uma &alteração na forma como essa sintaxe é interpretada. Sem &, é uma desreferência e, na verdade, lê da matriz. Com &, não é. O valor quearray + i * sizeof(long) ainda é calculado, mas não é desreferenciado.
A situação é muito parecida com move lea. Com mov, ocorre uma desreferência que não acontece com lea. Isso ocorre apesar do uso de parênteses que ocorre em ambos. Por exemplo, movq (%r8), %r9e leaq (%r8), %r9. Com mov, esses parênteses significam "desreferência"; com lea, eles não. Isso é semelhante a como array[i]apenas significa "desreferência" quando não há& .
Um exemplo está em ordem.
Considere o código
movq (%rdi, %rsi, 8), %rbp
Isso carrega o valor no local da memória %rdi + %rsi * 8no registro %rbp. Ou seja: obtenha o valor no registro %rdie o valor no registro %rsi. Multiplique o último por 8 e adicione-o ao primeiro. Encontre o valor neste local e coloque-o no registro %rbp.
Este código corresponde à linha C x = array[i];, onde arrayse torna e se torna %rdie ise torna . o%rsix%rbp8 é o comprimento do tipo de dados contido na matriz.
Agora considere código semelhante que usa lea:
leaq (%rdi, %rsi, 8), %rbp
Assim como o uso de movqcorrespondeu à desreferenciação, o uso leaqaqui corresponde a não desreferenciação. Esta linha de montagem corresponde à linha C x = &array[i];. Lembre-se de que &altera o significado de array[i]desreferenciar para simplesmente especificar um local. Da mesma forma, o uso de leaqaltera o significado de (%rdi, %rsi, 8)desreferenciar para especificar um local.
A semântica desta linha de código é a seguinte: obtenha o valor no registro %rdie o valor no registro %rsi. Multiplique o último por 8 e adicione-o ao primeiro. Coloque esse valor no registro %rbp. Nenhuma carga da memória está envolvida, apenas operações aritméticas [2].
Observe que a única diferença entre minhas descrições de leaqe movqé que movqfaz uma desreferência e leaqnão. De fato, para escrever a leaqdescrição, basicamente copio + colei a descrição de movqe removi "Encontre o valor neste local".
Resumir: movqvs. leaqé complicado porque eles tratam o uso de parênteses, como em (%rsi)e (%rdi, %rsi, 8), de maneira diferente. Em movq(e em todas as outras instruções, exceto lea), esses parênteses denotam uma desreferência genuína, enquanto que leaqeles não são e são uma sintaxe puramente conveniente.
[1] Eu disse que quando arrayé uma matriz de long, a expressão array[i]carrega o valor do endereço array + i * sizeof(long). Isso é verdade, mas há uma sutileza que deve ser abordada. Se eu escrever o código C
long x = array[5];
isso não é o mesmo que digitar
long x = *(array + 5 * sizeof(long));
Parece que deve basear-se em minhas declarações anteriores, mas não é.
O que está acontecendo é que a adição de ponteiro C tem um truque. Digamos que eu tenho um ponteiro papontando para valores do tipo T. A expressão p + ifaz não significativo "a posição em pmais ibytes". Em vez disso, a expressão p + i realmente significa "a posição em pmais i * sizeof(T)bytes".
A conveniência disso é que, para obter "o próximo valor", basta escrever em p + 1vez dep + 1 * sizeof(T) .
Isso significa que o código C long x = array[5];é realmente equivalente a
long x = *(array + 5)
porque C multiplicará automaticamente o 5por sizeof(long).
Portanto, no contexto desta questão do StackOverflow, como isso é relevante? Isso significa que, quando digo "o endereço array + i * sizeof(long)", não quero que " array + i * sizeof(long)" seja interpretado como uma expressão C. Estou fazendo a multiplicação sizeof(long)sozinho para tornar minha resposta mais explícita, mas entendo que, devido a isso, essa expressão não deve ser lida como C. Assim como a matemática normal que usa a sintaxe C.
[2] Nota: como tudo o que leafaz são operações aritméticas, seus argumentos não precisam se referir a endereços válidos. Por esse motivo, é frequentemente usado para executar aritmética pura em valores que podem não ter a intenção de ser desreferenciados. Por exemplo, cccom -O2otimização traduz
long f(long x) {
return x * 5;
}
nas seguintes linhas (linhas irrelevantes removidas):
f:
leaq (%rdi, %rdi, 4), %rax # set %rax to %rdi + %rdi * 4
ret