Vesta
Español
Código fuente

FMUL, FMULP, FIMUL

Multiply

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
D8 /1FMUL m32fpValidoValidoMultiply ST(0) por m32fp y resultado de la tienda en ST(0).
DC /1FMUL m64fpValidoValidoMultiply ST(0) por m64fp y resultado de la tienda en ST(0).
D8 C8+iFMUL ST(0), ST(i)ValidoValidoMultiply ST(0) de ST(i) y resultado de la tienda en ST(0).
DC C8+iFMUL ST(i), ST(0)ValidoValidoMultiply ST(i) por ST(0) y resultado de la tienda en ST(i).
DE C8+iFMULP ST(i), ST(0)ValidoValidoMultiply ST(i) por ST(0), resultado de la tienda en ST(i), y pop la pila de registro.
DE C9FMULPValidoValidoMultiply ST(1) por ST(0), resultado de la tienda en ST(1), y pop el registro de pila.
DA /1FIMUL m32intValidoValidoMultiply ST(0) por m32int y resultado de la tienda en ST(0).
DE /1FIMUL m16intValidoValidoMultiply ST(0) por m16int y resultado de la tienda en ST(0).

Coste medido

Cargando las mediciones de arch-data...

Descripción

Multiplica el destino y operandos de origen y almacena el producto en la ubicación de destino. El operando de destino es siempre un registro de datos FPU; el operando de origen puede ser un registro de datos FPU o una ubicación de memoria. Operandos de origen en memoria puede estar en forma de precisión simple o coma flotante de precisión doble o en formato de palabra o doble palabra.

La versión no-operando de la instrucción multiplica el contenido del registro ST(1) por el contenido del registro ST(0) y almacena el producto en el registro ST(1). La versión one-operando multiplica el contenido del registro ST(0) por el contenido de una ubicación de memoria (ya sea una coma flotante o un valor entero) y almacena el producto en el registro ST(0). La versión bi-operando multiplica el contenido del registro ST(0) por el contenido del registro ST(i) o viceversa, con el resultado almacenado en el registro especificado con el primer operando (el operando de destino).

Las instrucciones FMULP realizan el funcionamiento adicional de la pila de registro FPU después de almacenar el producto. Para abrir la pila de registro, el procesador marca el registro ST(0) como vacío y aumenta el puntero de pila (TOP) por 1. La versión no-operando de la coma flotante multiplica las instrucciones siempre resulta en la pila de registro que se está saltando. En algunos ensambladores, la mnemónica para esta instrucción es FMUL en lugar de FMULP.

Las instrucciones de FIMUL convierten un entero operando de origen a formato coma flotante de doble precisión antes de realizar la multiplicación.

El signo del resultado es siempre el exclusivo-OR de los signos de origen, incluso si uno o más de los valores que se multiplican es 0 o . Cuando el operando de origen es un entero 0, se trata como un +0.

El siguiente cuadro muestra los resultados obtenidos al multiplicar varias clases de números, asumiendo que no se produce desbordamiento ni desbordamiento.

FMUL/FMULP/FIMUL Resultados

-++**--Nan
-F++F+0-0-F-Nan
-I++F+0-0-F-Nan
-0*+0+0-0-0*Nan
+0*-0-0+0+0*Nan
+I--F-0+0+F+Nan
+F--F-0+0+F+Nan
+--**++Nan
NanNan NanNanNanNanNanNan

Operación

IF Instruction = FIMUL

    THEN
          DEST := DEST  ConvertToDoubleExtendedPrecisionFP(SRC);

    ELSE (* Source operand is floating-point value *)
          DEST := DEST  SRC;

FI;

IF Instruction = FMULP

    THEN
          PopRegisterStack;

FI;

FPU Flags Affected

C1                  Set to 0 if stack underflow occurred.

                    Set if result was rounded up; cleared otherwise.

C0, C2, C3          Undefined.

Excepciones coma flotante

#IS                 Stack underflow occurred.
#IA                 Operand is an SNaN value or unsupported format.

One operand is +/-0 and the other is +/-.

#D                  Source operand is a denormal value.
#U                  Result is too small for destination format.
#O                  Result is too large for destination format.
#P                  Value cannot be represented exactly in destination format.

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 se utiliza para acceder a la memoria y contiene un NULL selector de segmento.
#SS(0)Si un operando de memoria dirección efectiva está fuera del límite del segmento SS.
#NMCR0.EM[bit 2] o CR0.TS[bit 3] = 1. #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.
#NMCR0.EM[bit 2] o CR0.TS[bit 3] = 1.
#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.
#NMCR0.EM[bit 2] o CR0.TS[bit 3] = 1. #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.
#NMCR0.EM[bit 2] o CR0.TS[bit 3] = 1.
#MFSi hay una excepción x87 FPU pendiente. #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