CMOVcc

Mover condicional

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
0F 47 /rCMOVA r16, r/m16RMValidoValidoMover si arriba (CF=0 y ZF=0).
0F 47 /rCMOVA r32, r/m32RMValidoValidoMover si arriba (CF=0 y ZF=0).
REX.W + 0F 47 /rCMOVA r64, r/m64RMValidoNo codificableMover si arriba (CF=0 y ZF=0).
0F 43 /rCMOVAE r16, r/m16RMValidoValidoMover si arriba o igual (CF=0).
0F 43 /rCMOVAE r32, r/m32RMValidoValidoMover si arriba o igual (CF=0).
REX.W + 0F 43 /rCMOVAE r64, r/m64RMValidoNo codificableMover si arriba o igual (CF=0).
0F 42 /rCMOVB r16, r/m16RMValidoValidoMuévete si abajo (CF=1).
0F 42 /rCMOVB r32, r/m32RMValidoValidoMuévete si abajo (CF=1).
REX.W + 0F 42 /rCMOVB r64, r/m64RMValidoNo codificableMuévete si abajo (CF=1).
0F 46 /rCMOVBE r16, r/m16RMValidoValidoMover si es inferior o igual (CF=1 o ZF=1).
0F 46 /rCMOVBE r32, r/m32RMValidoValidoMover si es inferior o igual (CF=1 o ZF=1).
REX.W + 0F 46 /rCMOVBE r64, r/m64RMValidoNo codificableMover si es inferior o igual (CF=1 o ZF=1).
0F 42 /rCMOVC r16, r/m16RMValidoValidoMuévete si llevas (CF=1).
0F 42 /rCMOVC r32, r/m32RMValidoValidoMuévete si llevas (CF=1).
REX.W + 0F 42 /rCMOVC r64, r/m64RMValidoNo codificableMuévete si llevas (CF=1).
0F 44 /rCMOVE r16, r/m16RMValidoValidoMover si es igual (ZF=1).
0F 44 /rCMOVE r32, r/m32RMValidoValidoMover si es igual (ZF=1).
REX.W + 0F 44 /rCMOVE r64, r/m64RMValidoNo codificableMover si es igual (ZF=1).
0F 4F /rCMOVG r16, r/m16RMValidoValidoMover si es mayor (ZF=0 y SF=OF).
0F 4F /rCMOVG r32, r/m32RMValidoValidoMover si es mayor (ZF=0 y SF=OF).
REX.W + 0F 4F /rCMOVG r64, r/m64RMv/n.e.-Mover si es mayor (ZF=0 y SF=OF).
0F 4D /rCMOVGE r16, r/m16RMValidoValidoMover si es mayor o igual (SF=OF).
0F 4D /rCMOVGE r32, r/m32RMValidoValidoMover si es mayor o igual (SF=OF).
REX.W + 0F 4D /rCMOVGE r64, r/m64RMValidoNo codificableMover si es mayor o igual (SF=OF).
0F 4C /rCMOVL r16, r/m16RMValidoValidoMuévete si es menos (SF OF).
0F 4C /rCMOVL r32, r/m32RMValidoValidoMuévete si es menos (SF OF).
REX.W + 0F 4C /rCMOVL r64, r/m64RMValidoNo codificableMuévete si es menos (SF OF).
0F 4E /rCMOVLE r16, r/m16RMValidoValidoMover si es menos o igual (ZF=1 o SF OF).
0F 4E /rCMOVLE r32, r/m32RMValidoValidoMover si es menos o igual (ZF=1 o SF OF).
REX.W + 0F 4E /rCMOVLE r64, r/m64RMValidoNo codificableMover si es menos o igual (ZF=1 o SF OF).
0F 46 /rCMOVNA r16, r/m16RMValidoValidoMuévete si no por encima (CF=1 o ZF=1).
0F 46 /rCMOVNA r32, r/m32RMValidoValidoMuévete si no por encima (CF=1 o ZF=1).
REX.W + 0F 46 /rCMOVNA r64, r/m64RMValidoNo codificableMuévete si no por encima (CF=1 o ZF=1).
0F 42 /rCMOVNAE r16, r/m16RMValidoValidoMuévete si no por encima o por igual (CF=1).
0F 42 /rCMOVNAE r32, r/m32RMValidoValidoMuévete si no por encima o por igual (CF=1).
REX.W + 0F 42 /rCMOVNAE r64, r/m64RMValidoNo codificableMuévete si no por encima o por igual (CF=1).
0F 43 /rCMOVNB r16, r/m16RMValidoValidoMuévete si no debajo (CF=0).
0F 43 /rCMOVNB r32, r/m32RMValidoValidoMuévete si no debajo (CF=0).
REX.W + 0F 43 /rCMOVNB r64, r/m64RMValidoNo codificableMuévete si no debajo (CF=0).
0F 47 /rCMOVNBE r16, r/m16RMValidoValidoMover si no es inferior o igual (CF=0 y ZF=0).
0F 47 /rCMOVNBE r32, r/m32RMValidoValidoMover si no es inferior o igual (CF=0 y ZF=0).
REX.W + 0F 47 /rCMOVNBE r64, r/m64RMValidoNo codificableMover si no es inferior o igual (CF=0 y ZF=0).
0F 43 /rCMOVNC r16, r/m16RMValidoValidoMuévete si no llevas (CF=0).
0F 43 /rCMOVNC r32, r/m32RMValidoValidoMuévete si no llevas (CF=0).
REX.W + 0F 43 /rCMOVNC r64, r/m64RMValidoNo codificableMuévete si no llevas (CF=0).
0F 45 /rCMOVNE r16, r/m16RMValidoValidoMover si no es igual (ZF=0).
0F 45 /rCMOVNE r32, r/m32RMValidoValidoMover si no es igual (ZF=0).
REX.W + 0F 45 /rCMOVNE r64, r/m64RMValidoNo codificableMover si no es igual (ZF=0).
0F 4E /rCMOVNG r16, r/m16RMValidoValidoMuévete si no es mayor (ZF=1 o SF OF).
0F 4E /rCMOVNG r32, r/m32RMValidoValidoMuévete si no es mayor (ZF=1 o SF OF).
REX.W + 0F 4E /rCMOVNG r64, r/m64RMValidoNo codificableMuévete si no es mayor (ZF=1 o SF OF).
0F 4C /rCMOVNGE r16, r/m16RMValidoValidoMuévete si no es mayor o igual (SF OF).
0F 4C /rCMOVNGE r32, r/m32RMValidoValidoMuévete si no es mayor o igual (SF OF).
REX.W + 0F 4C /rCMOVNGE r64, r/m64RMValidoNo codificableMuévete si no es mayor o igual (SF OF).
0F 4D /rCMOVNL r16, r/m16RMValidoValidoMuévete si no menos (SF=OF).
0F 4D /rCMOVNL r32, r/m32RMValidoValidoMuévete si no menos (SF=OF).
REX.W + 0F 4D /rCMOVNL r64, r/m64RMValidoNo codificableMuévete si no menos (SF=OF).
0F 4F /rCMOVNLE r16, r/m16RMValidoValidoMuévete si no es menos o igual (ZF=0 y SF=OF).
0F 4F /rCMOVNLE r32, r/m32RMValidoValidoMuévete si no es menos o igual (ZF=0 y SF=OF).
REX.W + 0F 4F /rCMOVNLE r64, r/m64RMValidoNo codificableMuévete si no es menos o igual (ZF=0 y SF=OF).
0F 41 /rCMOVNO r16, r/m16RMValidoValidoMuévete si no desborda (OF=0).
0F 41 /rCMOVNO r32, r/m32RMValidoValidoMuévete si no desborda (OF=0).
REX.W + 0F 41 /rCMOVNO r64, r/m64RMValidoNo codificableMuévete si no desborda (OF=0).
0F 4B /rCMOVNP r16, r/m16RMValidoValidoMuévete si no la paridad (PF=0).
0F 4B /rCMOVNP r32, r/m32RMValidoValidoMuévete si no la paridad (PF=0).
REX.W + 0F 4B /rCMOVNP r64, r/m64RMValidoNo codificableMuévete si no la paridad (PF=0).
0F 49 /rCMOVNS r16, r/m16RMValidoValidoMuévete si no firmas (SF=0).
0F 49 /rCMOVNS r32, r/m32RMValidoValidoMuévete si no firmas (SF=0).
REX.W + 0F 49 /rCMOVNS r64, r/m64RMValidoNo codificableMuévete si no firmas (SF=0).
0F 45 /rCMOVNZ r16, r/m16RMValidoValidoMuévete si no cero (ZF=0).
0F 45 /rCMOVNZ r32, r/m32RMValidoValidoMuévete si no cero (ZF=0).
REX.W + 0F 45 /rCMOVNZ r64, r/m64RMValidoNo codificableMuévete si no cero (ZF=0).
0F 40 /rCMOVO r16, r/m16RMValidoValidoMuévete si se desborda (OF=1).
0F 40 /rCMOVO r32, r/m32RMValidoValidoMuévete si se desborda (OF=1).
REX.W + 0F 40 /rCMOVO r64, r/m64RMValidoNo codificableMuévete si se desborda (OF=1).
0F 4A /rCMOVP r16, r/m16RMValidoValidoMover si la paridad (PF=1).
0F 4A /rCMOVP r32, r/m32RMValidoValidoMover si la paridad (PF=1).
REX.W + 0F 4A /rCMOVP r64, r/m64RMValidoNo codificableMover si la paridad (PF=1).
0F 4A /rCMOVPE r16, r/m16RMValidoValidoMuévete si la paridad es igual (PF=1).
0F 4A /rCMOVPE r32, r/m32RMValidoValidoMuévete si la paridad es igual (PF=1).
REX.W + 0F 4A /rCMOVPE r64, r/m64RMValidoNo codificableMuévete si la paridad es igual (PF=1).
0F 4B /rCMOVPO r16, r/m16rmvalid Valid Mover si paridad extraña (PF=0).
0F 4B /rCMOVPO r32, r/m32rmvalid Valid Mover si paridad extraña (PF=0).
REX.W + 0F 4B /rCMOVPO r64, r/m64rmvalid N.E. Mueva si la paridad es extraña (PF=0).
0F 48 /rCMOVS r16, r/m16rmvalid Valid Mover si signo (SF=1).
0F 48 /rCMOVS r32, r/m32rmvalid Valid Mover si signo (SF=1).
REX.W + 0F 48 /rCMOVS r64, r/m64rmvalid N.E. Mover si el signo (SF=1).
0F 44 /rCMOVZ r16, r/m16rmvalid Valid Move si cero (ZF=1).
0F 44 /rCMOVZ r32, r/m32rmvalid Valid Move si cero (ZF=1).
REX.W + 0F 44 /rCMOVZ r64, r/m64rmvalid N.E. Mover si cero (ZF=1).

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.

RM

  1. modrm.reg lectura y 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

Coste medido

Cargando las mediciones de arch-data...

Descripción

Cada una de las instrucciones de CMOVcc realiza una operación de movimiento si las banderas de estado en el registro EFLAGS (CF, OF, PF, SF y ZF) se encuentran en un estado (o condición). Un código de condición (cc) se asocia con cada instrucción para indicar la condición que se está probando. Si la condición no está satisfecha, no se realiza un movimiento y la ejecución continúa con la instrucción siguiendo la instrucción CMOVcc.

Específicamente, CMOVcc carga datos de su operando de origen en un registro temporal incondicionalmente (independientemente del código de condiciones y las banderas de estado en el registro EFLAGS). Si el código de condición asociado con la instrucción (cc) está satisfecho, los datos del registro temporal se copian luego en el operando de destino de la instrucción.

Estas instrucciones pueden mover valores de 16 bits, 32 bits o 64 bits de memoria a un registro de proposito general o de un registro de proposito general a otro. No se admiten movimientos condicionales de 8 bits de registro operandos.

La condición para cada CMOVcc mnemonic se da en la columna de descripción de la tabla anterior. Los términos "menos" y "mayor" se utilizan para las comparaciones de enteros con signo y los términos "arriba" y "bajo" se utilizan para enteros sin signo.

Debido a que un estado particular de las banderas de estado puede a veces ser interpretado de dos maneras, dos mnemonics se definen para algunos códigos de operación. Por ejemplo, la instrucción CMOVA (movimiento condicional si arriba) y la instrucción CMOVNBE (movimiento condicional si no por debajo o por igual) son mnemonía alternativa para el código de operación 0F 47H.

Las instrucciones CMOVcc fueron introducidas en procesadores familiares P6; sin embargo, estas instrucciones pueden no ser apoyadas por todos los procesadores IA-32. El software puede determinar si las instrucciones CMOVcc son compatibles mediante la comprobación de la información de características del procesador con la instrucción CPUID (ver "CPUID--CPU Identificación" en este capítulo).

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

temp := SRC

IF condition TRUE
    THEN DEST := temp;

ELSE IF (OperandSize = 32 and IA-32e mode active)
    THEN DEST[63:32] := 0;

FI;

Banderas afectadas

None.

Excepciones

Modo protegido
#GP(0)Si un operando de memoria dirección efectiva 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.
#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 mientras que el nivel de privilegio actual es 3.
#UDSi 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 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 utiliza el prefijo LOCK.
Modo de compatibilidad
Las mismas excepciones que en modo protegido.
Modo de 64 bits
#SS(0)Si una dirección de memoria que hace referencia al segmento SS está en forma no canónica.
#GP(0)Si la dirección de memoria está en forma no canónica. #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 utiliza el prefijo LOCK.

Fuentes