MOV

Moveos

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
88 /rMOV r/m8, r8MRValidoValidoMueva r8 a r/m8.
89 /rMOV r/m16, r16MRValidoValidoMueva r16 a r/m16.
89 /rMOV r/m3, r3MRValidoValidoMueva r3 a r/m32.
REX.W + 89 /rMOV r/m64, r64MRValidoNo codificableMueva r64 a r/m64.
8A /rMOV r8, r/m8RMValidoValidoMueva r/m8 a r8.
8B /rMOV r16, r/m16RMValidoValidoMueva r/m16 a r16.
8B /rMOV r3, r/m3RMValidoValidoMueva r/m3 a r32.
REX.W + 8B /rMOV r64, r/m64RMValidoNo codificableMueva r/m64 a r64.
8C /rMOV r/m16, Sreg2MRValidoValidoMueva el registro del segmento a r/m16.
8C /rMOV r16/r32/m16, Sreg2MRValidoValidoMueva el registro de segmentos de 16 bits a r16/r32/m16.
REX.W + 8C /rMOV r64/m16, Sreg2MRValidoValidoMueva el registro de segmentos de 16 bits a r64/m16.
8E /rMOV Sreg, r/m16RMValidoValidoMover r/m16 a registro de segmentos.
REX.W + 8E /rMOV Sreg, r/m64RMValidoValidoMueva 16 bits inferiores de r/m64 a registro de segmentos.
A0MOV AL, moffs8FDValidoValidoMuévete a (seg:offset) a AL.
REX.W + A0MOV AL, moffs8FDValidoNo codificableMuévete a (offset) a AL.
A1MOV AX, moffs16FDValidoValidoMueve la palabra en (por ejemplo:offset) a AX.
A1MOV EAX, moffs32FDValidoValidoMover la palabra doble en (seg:offset) a EAX.
REX.W + A1MOV RAX, moffs64FDValidoNo codificableMueva el cuádruplo en (offset) a RAX.
A2MOV moffs8, ALTDValidoValidoMover AL a (por ejemplo:offset).
REX.W + A2MOV moffs8, ALTDValidoNo codificableMover AL a (offset).
A3MOV moffs16, AXTDValidoValidoMover AX a (por ejemplo:offset).
A3MOV moffs32, EAXTDValidoValidoMover EAX a (seg:offset).
REX.W + A3MOV moffs64, RAXTDValidoNo codificableMover RAX a (offset).
B0+ rb ibMOV r8, imm8OIValidoValidoMueva imm8 a r8.
B8+ rw iwMOV r16, imm16OIValidoValidoMueva imm16 a r16.
B8+ rd idMOV r3, imm3OIValidoValidoMueva imm3 a r32.
REX.W + B8+ rd ioMOV r64, imm64OIValidoNo codificableMueva imm64 a r64.
C6 /0 ibMOV r/m8, imm8MIValidoValidoMueva imm8 a r/m8.
C7 /0 iwMOV r/m16, imm16MIValidoValidoMueva imm16 a r/m16.
C7 /0 idMOV r/m3, imm3MIValidoValidoMueva imm3 a r/m32.
REX.W + C7 /0 idMOV r/m64, imm3MIValidoNo codificableMueva el signo imm3 extendido a 64-bits a r/m64.

Codificacion de operandos

Cada modo es un valor de la columna Op/En de arriba. Dice en que campo de la instruccion codificada va cada operando, en el orden en que se escriben, y si la instruccion lo lee, lo escribe o ambas cosas.

MR

  1. modrm.rm escriturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide
  2. modrm.reg lecturabyte ModRM, campo reg (bits 5-3)

RM

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

FD

  1. AL/AX/EAX/RAX
  2. moffsdireccion absoluta que sigue al opcode

TD

  1. moffs escrituradireccion absoluta que sigue al opcode
  2. AL/AX/EAX/RAX

OI

  1. opcode.reg escrituralos tres bits bajos del propio byte de opcode
  2. imm8/16/32/64inmediato que sigue a la instruccion, del ancho del operando

MI

  1. modrm.rm escriturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide
  2. imm8/16/32/64inmediato que sigue a la instruccion, del ancho del operando

Coste medido

Cargando las mediciones de arch-data...

Descripción

Copia el segundo operando (operando de origen) al primer operando (operando de destino). El operando de origen puede ser un valor inmediato, registro de proposito general, registro de segmentos, o ubicación de memoria; el registro de destino puede ser un registro de proposito general, registro de segmentos, o ubicación de memoria. Ambos operandos deben ser del mismo tamaño, que puede ser un byte, una palabra, una palabra doble, o un cuadword.

La instrucción MOV no se puede utilizar para cargar el registro CS. Intento hacerlo resultados en una excepción de código de operación no válido (#UD). Para cargar el registro CS, utilice la instrucción JMP, CALL o RET.

Si el operando de destino es un registro de segmentos (DS, ES, FS, GS o SS), el operando de origen debe ser un selector de segmento válido. En modo protegido, mover un selector de segmento en un registro de segmento automáticamente hace que la información descriptor de segmento asociada a que selector de segmento se cargue en la parte oculta (shadow) del registro de segmento. Al cargar esta información, se valida la información de descriptor el selector de segmento y segmento (ver el algoritmo de "Operación"). Los datos del descriptor de segmento se obtienen de la entrada GDT o LDT para el selector de segmento especificado.

A NULL selector de segmento (valores 0000-0003) se puede cargar en los registros DS, ES, FS y GS sin causar una excepción de protección. Sin embargo, cualquier intento subsiguiente de referencia a un segmento cuyo registro de segmento correspondiente está cargado con un valor NULL causa una excepción de protección general (#GP) y no se produce ninguna referencia de memoria.

Cargar el registro SS con una instrucción MOV suprime o inhibe algunas excepciones de depuración e inhibe interrumpir en el siguiente límite de instrucción. (La inhibición termina después de la entrega de una excepción o la ejecución de la siguiente instrucción.) Este comportamiento permite que un puntero de pila se cargue en el registro ESP con la siguiente instrucción (MOV ESP, valor de punta de pila) antes de que se pueda entregar un evento. Ver la sección 7.8.3, "Masking Excepciones e Interrupciones Al Interruptores", en Intel(R) 64 e IA-32 Architectures Software Developer's Manual, Volumen 3A. Intel recomienda que el software use la instrucción LSS para cargar el registro SS y ESP juntos.

Al ejecutar MOV Reg, Sreg, el procesador copia el contenido de Sreg a los 16 bits menos significativo del registro de proposito general. Los bits superiores del registro de destino son cero para la mayoría de procesadores IA-32 (procesadores Pentium Pro y más tarde) y todos los procesadores Intel 64, con la excepción de que bits 31:16 quedan indefinidas para procesadores Intel Quark X1000, Pentium y procesadores anteriores.

En modo de 64 bits, el tamaño de operación predeterminado de la instrucción es de 32 bits. El uso del prefijo REX.R permite el acceso a registros adicionales (R8-R15). El uso del prefijo REX.W promueve la operación a 64 bits. Vea la tabla resumen al comienzo de esta sección para la codificación de datos y límites.

Operación

DEST := SRC;

Loading a segment register while in protected mode results in special checks and actions, as described in the following listing. These
checks are performed on the segment selector and the segment descriptor to which it points.

IF SS is loaded
    THEN
          IF segment selector is NULL
                THEN #GP(0); FI;
          IF segment selector index is outside descriptor table limits

        OR segment selector's RPL  CPL


          OR segment is not a writable data segment

        OR DPL  CPL

                THEN #GP(selector); FI;
          IF segment not marked present

                THEN #SS(selector);
                ELSE

                      SS := segment selector;
                      SS := segment descriptor; FI;
FI;

IF DS, ES, FS, or GS is loaded with non-NULL selector
THEN

    IF segment selector index is outside descriptor table limits
    OR segment is not a data or readable code segment
    OR ((segment is a data or nonconforming code segment) AND ((RPL > DPL) or (CPL > DPL)))

          THEN #GP(selector); FI;
    IF segment not marked present

          THEN #NP(selector);
          ELSE

                SegmentRegister := segment selector;
                SegmentRegister := segment descriptor; FI;
FI;

IF DS, ES, FS, or GS is loaded with NULL selector
    THEN
          SegmentRegister := segment selector;
          SegmentRegister := segment descriptor;

FI;

Banderas afectadas

None.

Excepciones

Modo protegido
#GP(0)Si se intenta cargar el registro de SS con NULL selector de segmento. Si el operando de destino está en un segmento no escrito. Si la dirección efectiva un operando de memoria está fuera del límite de segmento CS, DS, ES, FS o GS. Si el registro DS, ES, FS o GS contiene un NULL selector de segmento.
#GP(selector)Siselector de segmentoíndice está fuera de los límites de la tabla descriptor. Si el registro SS está siendo cargado yel selector de segmento's RPLy el descriptor del segmentoDPLno son iguales a losCPL. Si el registro SS está siendo cargado y el segmento apuntado es un segmento de datos no escrito. Si el registro DS, ES, FS o GS está siendo cargado y el segmento apuntado no es un segmento de datos o código legible. Si el registro DS, ES, FS o GS está siendo cargado y el segmento apuntado es un segmento de datos o código no conforme, y o el registro DS,RPLo elCPLes mayor que elDPL.
#SS(0)Si un operando de memoria dirección efectiva está fuera del límite del segmento SS.
#SS(selector)Si el registro SS está siendo cargado y el segmento apuntado no está presente.
#NPSi el registro DS, ES, FS o GS está siendo cargado y el segmento apuntado no está presente. #PF(fault-code) Si ocurre un fallo de pagina.
#AC(0)Si la comprobación de alineación está habilitada y se hace una referencia de memoria no alineada mientras que el nivel de privilegio actual es 3.
#UDSi se intenta cargar el registro CS. Si se utiliza el prefijo LOCK.
Modo real
#GPSi un operando de memoria dirección efectiva está fuera del límite de segmento CS, DS, ES, FS o GS.
#SSSi un operando de memoria dirección efectiva está fuera del límite del segmento SS.
#UDSi se intenta cargar el registro CS. Si se utiliza el prefijo LOCK.
Modo virtual-8086
#GP(0)Si un operando de memoria dirección efectiva está fuera del límite de segmento CS, DS, ES, FS o GS.
#SS(0)Si un operando de memoria dirección efectiva está fuera del límite del segmento SS. #PF(fault-code) Si un fallo de pagina ocurre.
#AC(0)Si la comprobación de alineación está habilitada y se hace una referencia de memoria no alineada.
#UDSi se intenta cargar el registro CS. Si se utiliza el prefijo LOCK.
Modo de compatibilidad
Las mismas excepciones que en modo protegido.
Modo de 64 bits
#GP(0)Si la dirección de memoria está en forma no canónica. Si se intenta cargar el registro SS con NULL selector de segmento cuando CPL = 3. Si se intenta cargar el registro SS con NULL selector de segmento cuando CPL < 3 y CPL RPL.
#GP(selector)Siselector de segmentoEl índice está fuera de los límites de la tabla descriptor. Si el acceso a la memoria de la tabla descriptor no es canónico.el selector de segmento's RPLy el descriptor del segmentoDPLno son iguales a losCPL. Si el registro SS está siendo cargado y el segmento apuntado es un segmento de datos no escrito. Si el registro DS, ES, FS o GS está siendo cargado y el segmento apuntado no es un segmento de datos o código legible. Si el registro DS, ES, FS o GS está siendo cargado y el segmento apuntado es un segmento de datos o códigos no conformes, pero ambos elRPLy elCPLson mayores que losDPL.
#SS(0)Si la dirección de la pila está en forma no canónica.
#SS(selector)Si el registro SS está siendo cargado y el segmento apuntado no está presente. #PF(fault-code) Si un fallo de pagina ocurre.
#AC(0)Si la comprobación de alineación está habilitada y se hace una referencia de memoria no alineada mientras que el nivel de privilegio actual es 3.
#UDSi se intenta cargar el registro CS. Si se utiliza el prefijo LOCK.

Fuentes