Vesta
Español
Código fuente

FDIV, FDIVP, FIDIV

Divide

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
D8 /6FDIV m32fpValidoValidoDivide ST(0) por m32fp y resultado de la tienda en ST(0).
DC /6FDIV m64fpValidoValidoDivide ST(0) por m64fp y resultado de la tienda en ST(0).
D8 F0+iFDIV ST(0), ST(i)ValidoValidoDivide ST(0) de ST(i) y resultado de la tienda en ST(0).
DC F8+iFDIV ST(i), ST(0)ValidoValidoDivide ST(i) por ST(0) y resultado de la tienda en ST(i).
DE F8+iFDIVP ST(i), ST(0)ValidoValidoDivide ST(i) por ST(0), resultado de la tienda en ST(i), y pop la pila de registro.
DE F9FDIVPValidoValidoDivide ST(1) by ST(0), store result in ST(1), and pop the register stack.
DA /6FIDIV m32intValidoValidoDivide ST(0) por m32int y resultado de la tienda en ST(0).
DE /6FIDIV m16intValidoValidoDivide ST(0) por m16int y resultado de la tienda en ST(0).

Coste medido

Cargando las mediciones de arch-data...

Descripción

Divide el operando de destino por el operando de origen y almacena el resultado en la ubicación de destino. El operando de destino (dividend) está siempre en un registro FPU; el operando de origen (divisor) puede ser un registro o una ubicación de memoria. Operandos de origen en memoria puede estar en un formato de precisión simple o coma flotante de precisión doble, formato de palabra o doble palabra entero.

La versión no-operando de la instrucción divide el contenido del registro ST(1) por el contenido del registro ST(0). La versión one-operando divide el contenido del registro ST(0) por el contenido de una ubicación de memoria (ya sea una coma flotante o un valor entero). La versión bi-operando divide el contenido del registro ST(0) por el contenido del registro ST(i) o viceversa.

Las instrucciones FDIVP realizan el funcionamiento adicional de la pila de registro FPU después de almacenar el resultado. 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 las instrucciones de división la coma flotante siempre resulta en la pila de registro que se está saltando. En algunos ensambladores, la mnemónica para esta instrucción es FDIV en lugar de FDIVP.

Las instrucciones FIDIV convierten un integer operando de origen a formato coma flotante de doble precisión antes de realizar la división. Cuando el operando de origen es un entero 0, se trata como un +0.

Si se genera una excepción de división por cero (#Z), no se almacena ningún resultado; si se enmascara la excepción, se almacena un signo adecuado en el operando de destino.

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

FDIV/FDIVP/FIDIV Resultados

-*+0+0-0-0*Nan
-F++F+0-0-F-Nan
-I++F+0-0-F-Nan
-0+******-Nan
+0-******+Nan
+I--F-0+0+F+Nan
+F--F-0+0+F+Nan
+*-0-0+0+0*Nan
NanNanNanNanNanNanNanNan

Operación

IF SRC = 0

    THEN
          #Z;

    ELSE
          IF Instruction is FIDIV
                THEN
                      DEST := DEST / ConvertToDoubleExtendedPrecisionFP(SRC);
                ELSE (* Source operand is floating-point value *)
                      DEST := DEST / SRC;
          FI;

FI;

IF Instruction = FDIVP

    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.

+/- / +/-; +/-0 / +/-0

#D                        Source is a denormal value.
#Z                        DEST / +/-0, where DEST is not equal to +/-0.
#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 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