Vesta
Español
Código fuente

FDIVR, FDIVRP, FIDIVR

Divideo inverso

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
D8 /7FDIVR m32fpValidoValidoDivide m32fp por ST(0) y resultado de la tienda en ST(0).
DC /7FDIVR m64fpValidoValidoDivide m64fp por ST(0) y resultado de la tienda en ST(0).
D8 F8+iFDIVR ST(0), ST(i)ValidoValidoDivide ST(i) por ST(0) y resultado de la tienda en ST(0).
DC F0+iFDIVR ST(i), ST(0)ValidoValidoDivide ST(0) de ST(i) y resultado de la tienda en ST(i).
DE F0+iFDIVRP ST(i), ST(0)ValidoValidoDivide ST(0) by ST(i), store result in ST(i), and pop the register stack.
DE F1FDIVRPValidoValidoDivide ST(0) by ST(1), store result in ST(1), and pop the register stack.
DA /7FIDIVR m32intValidoValidoDivide m32int por ST(0) y resultado de la tienda en ST(0).
DE /7FIDIVR m16intValidoValidoDivide m16int por ST(0) y resultado de la tienda en ST(0).

Coste medido

Cargando las mediciones de arch-data...

Descripción

Divide el operando de origen por el operando de destino y almacena el resultado en la ubicación de destino. El operando de destino (divisor) está siempre en un registro FPU; el operando de origen (dividend) 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.

Estas instrucciones realizan las operaciones inversas de las instrucciones FDIV, FDIVP y FIDIV. Se les proporciona para apoyar una codificación más eficiente.

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

Las instrucciones FDIVRP 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 FDIVR en lugar de FDIVRP.

Las instrucciones FIDIVR convierten un integer operando de origen a formato coma flotante de doble precisión antes de realizar la división.

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.

FDIVR/FDIVRP/FIDIVR Resultados

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

Operación

IF DEST = 0

    THEN
          #Z;

    ELSE

        IF Instruction = FIDIVR

                THEN
                      DEST := ConvertToDoubleExtendedPrecisionFP(SRC) / DEST;

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

          FI;
FI;

IF Instruction = FDIVRP

    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      SRC / +/-0, where SRC 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