assembly - x86_64 registra rax/eax/ax/al sobrescribir los contenidos completos del registro

x86-64 cpu-registers

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Por qué las instrucciones x86-64 en registros de 32 bits ponen a cero la parte superior del registro completo de 64 bits? 2 respuestas

Como se anuncia ampliamente, los procesadores x86_64 modernos tienen registros de 64 bits que se pueden usar de manera compatible con versiones anteriores como registros de 32 bits, registros de 16 bits e incluso registros de 8 bits, por ejemplo:

0x1122334455667788
  ================ rax (64 bits)
          ======== eax (32 bits)
              ====  ax (16 bits)
              ==    ah (8 bits)
                ==  al (8 bits)

Tal esquema se puede tomar literalmente, es decir, uno siempre puede acceder solo a la parte del registro que usa un nombre designado para fines de lectura o escritura, y sería altamente lógico. De hecho, esto es cierto para todo hasta 32 bits:

mov  eax, 0x11112222 ; eax = 0x11112222
mov  ax, 0x3333      ; eax = 0x11113333 (works, only low 16 bits changed)
mov  al, 0x44        ; eax = 0x11113344 (works, only low 8 bits changed)
mov  ah, 0x55        ; eax = 0x11115544 (works, only high 8 bits changed)
xor  ah, ah          ; eax = 0x11110044 (works, only high 8 bits cleared)
mov  eax, 0x11112222 ; eax = 0x11112222
xor  al, al          ; eax = 0x11112200 (works, only low 8 bits cleared)
mov  eax, 0x11112222 ; eax = 0x11112222
xor  ax, ax          ; eax = 0x11110000 (works, only low 16 bits cleared)

Sin embargo, las cosas parecen ser bastante incómodas tan pronto como llegamos a las cosas de 64 bits:

mov  rax, 0x1111222233334444 ;           rax = 0x1111222233334444
mov  eax, 0x55556666         ; actual:   rax = 0x0000000055556666
                             ; expected: rax = 0x1111222255556666
                             ; upper 32 bits seem to be lost!
mov  rax, 0x1111222233334444 ;           rax = 0x1111222233334444
mov  ax, 0x7777              ;           rax = 0x1111222233337777 (works!)
mov  rax, 0x1111222233334444 ;           rax = 0x1111222233334444
xor  eax, eax                ; actual:   rax = 0x0000000000000000
                             ; expected: rax = 0x1111222200000000
                             ; again, it wiped whole register

Tal comportamiento parece ser muy ridículo e ilógico para mí. Parece que tratar de escribir cualquier cosa en eax por cualquier medio conduce a borrar 32 bits de registro de rax .

Entonces, tengo 2 preguntas:

1. Creo que este comportamiento incómodo debe documentarse en alguna parte, pero parece que no puedo encontrar una explicación detallada (de cómo se eliminan exactamente 32 bits de registro de 64 bits) en cualquier lugar. ¿Tengo razón en que escribir a eax siempre borra el rax , o es algo más complicado? ¿Se aplica a todos los registros de 64 bits o hay algunas excepciones?

   Una pregunta fuertemente relacionada menciona el mismo comportamiento, pero, lamentablemente, tampoco hay referencias exactas a la documentación.

   En otras palabras, me gustaría un enlace a la documentación que especifique este comportamiento.

2. ¿Soy solo yo o todo esto parece ser realmente extraño e ilógico (es decir, eax-ax-ah-al, rax-ax-ah-al teniendo un comportamiento y rax-eax teniendo otro)? Puede ser que me falta algún tipo de punto vital aquí sobre por qué se implementó así?

   Una explicación sobre "por qué" sería muy apreciada.

Answer 1

El modelo de procesador que se documenta en el manual del procesador Intel / AMD es un modelo bastante imperfecto para el motor de ejecución real de un núcleo moderno. En particular, la noción de los registros del procesador no coincide con la realidad, no existe un registro EAX o RAX.

Un trabajo principal del decodificador de instrucciones es convertir las instrucciones heredadas x86 / x64 en microoperaciones , instrucciones de un procesador similar a RISC. Pequeñas instrucciones que son fáciles de ejecutar al mismo tiempo y que permiten aprovechar múltiples subunidades de ejecución. Permitiendo hasta 6 instrucciones para ejecutar al mismo tiempo.

Para que funcione, la noción de registros de procesador también se virtualiza. El decodificador de instrucciones asigna un registro de un gran banco de registros. Cuando se retira la instrucción, el valor de ese registro asignado dinámicamente se escribe de nuevo en cualquier registro que actualmente tenga el valor de, por ejemplo, RAX.

Para hacer que funcione de manera uniforme y eficiente, permitiendo que muchas instrucciones se ejecuten simultáneamente, es muy importante que estas operaciones no tengan una interdependencia. Y lo peor que puede tener es que el valor de registro depende de otras instrucciones. El registro de EFLAGS es notorio, muchas instrucciones lo modifican.

Mismo problema con la forma en que te gusta que funcione. Gran problema, requiere que se fusionen dos valores de registro cuando se retira la instrucción. Crear una dependencia de datos que va a obstruir el núcleo. Al forzar la parte superior de 32 bits a 0, esa dependencia desaparece al instante, ya no es necesario fusionar. Warp 9 velocidad de ejecución.