BS2:

These emulation codes should not be used on later processors.

19 Special topics

19.1 Freeing floating-point registers (all processors)

You have to free all used floating-point registers before exiting a subroutine, except for any register used for the result.

The fastest way of freeing one register is FSTP ST. The fastest way of freeing two registers is FCOMPP on P1 and PMMX. On later processors you may use either FCOMPP or twice FSTP ST, whichever fits best into the decoding sequence (PPro, P2, P3) or port load (P4).

It is not recommended to use FFREE.

19.2 Transitions between floating-point and MMX instructions (PMMX, P2, P3, P4)

It is not possible to use 64-bit MMX registers and 80-bit floating-point registers in the same part of the code. You must issue an EMMS instruction after the last instruction that uses 64bit MMX registers if there is a possibility that later code uses floating-point registers. You may avoid this problem by using 128-bit XMM registers instead.

On PMMX there is a high penalty for switching between floating-point and MMX instructions. The first floating-point instruction after an EMMS takes approximately 58 clocks extra, and the first MMX instruction after a floating-point instruction takes approximately 38 clocks extra.

On P2, P3 and P4 there is no such penalty. The delay after EMMS can be hidden by putting in integer instructions between EMMS and the first floating-point instruction.

19.3 Converting from floating-point to integer (All processors)

All conversions between floating-point registers and integer registers must go via a memory location:

FISTP DWORD PTR [TEMP]

MOV EAX, [TEMP]

On PPro, P2, P3 and especially P4, this code is likely to have a penalty for attempting to read from [TEMP] before the write to [TEMP] is finished. It doesn't help to put in aWAIT. It is recommended that you put in other instructions between the write to [TEMP] and the read from [TEMP] if possible in order to avoid this penalty. This applies to all the examples that follow.

The specifications for the C and C++ language requires that conversion from floating-point numbers to integers use truncation rather than rounding. The method used by most C libraries is to change the floating-point control word to indicate truncation before using an FISTP instruction, and changing it back again afterwards. This method is very slow on all processors. On PPro and later processors, the floating-point control word cannot be renamed, so all subsequent floating-point instructions must wait for the FLDCW instruction to retire. See page 125.

On the P3 and P4 you can avoid all these problems by using XMM registers instead of floating-point registers and use the CVT.. instructions to avoid the memory intermediate. (On the P3, these instructions are only available in single precision).

Whenever you have a conversion from a floating-point register to an integer register, you should think of whether you can use rounding to nearest integer instead of truncation.

If you need truncation inside a loop then you should change the control word only outside the loop if the rest of the floating-point instructions in the loop can work correctly in truncation mode.

You may use various tricks for truncating without changing the control word, as illustrated in the examples below. These examples presume that the control word is set to default, i.e. rounding to nearest or even.

;Rounding to nearest or even:

;extern "C" int round (double x); _round PROC NEAR

PUBLIC _round

_round ENDP

;Truncation towards zero:

;extern "C" int truncate (double x);

;Truncation towards minus infinity:

;extern "C" int ifloor (double x);

Generating constants

It is possible to generate simple floating-point constants without using data in memory:

To generate the constant 0.0, it is better to use PXOR XMM0,XMM0 than XORPS, XORPD, SUBPS, etc., because the PXOR instruction is recognized by the P4 processor to be independent of the previous value of the register if source and destination are the same, while this is not the case for the other instructions.

Testing if a floating-point value is zero

To test if a floating-point number is zero, we have to test all bits except the sign bit, which may be either 0 or 1. For example:

FLD DWORD PTR [EBX] / FTST / FNSTSW AX / AND AH,40H / JNZ IsZero

can be replaced by

MOV EAX,[EBX] / ADD EAX,EAX / JZ IsZero

where the ADD EAX,EAX shifts out the sign bit. Double precision floats have 63 bits to test, but if denormal numbers can be ruled out, then you can be certain that the value is zero if the exponent bits are all zero. Example:

FLD QWORD PTR [EBX] / FTST / FNSTSW AX / AND AH,40H / JNZ IsZero

can be replaced by

MOV EAX,[EBX+4] / ADD EAX,EAX / JZ IsZero

Manipulating the sign bit

A floating-point number is negative if the sign bit is set and at least one other bit is set. Example (single precision):

MOV EAX,[NumberToTest] / CMP EAX,80000000H / JA IsNegative

You can change the sign of a floating-point number simply by flipping the sign bit. This is useful when XMM registers are used, because there is no XMM change sign instruction. Example:

You can get the absolute value of a floating-point number by AND'ing out the sign bit:

You can extract the sign bit of a floating-point number:

;generate a bit-mask if single-precision floats in XMM0 are..

;negative or -0.0