_control87, _controlfp, __control87_2
Gets and sets the floating-point control word. A more secure version of _controlfp is available; see _controlfp_s.
unsigned int _control87(
unsigned int new,
unsigned int mask
);
unsigned int _controlfp(
unsigned int new,
unsigned int mask
);
int __control87_2(
unsigned int new,
unsigned int mask,
unsigned int* x86_cw,
unsigned int* sse2_cw
);
Parameters
new
New control-word bit values.mask
Mask for new control-word bits to set.x86_cw
Filled in with the control word for the x87 floating point unit. Pass in 0 (NULL) to set only the SSE2 control word.sse2_cw
Control word for the SSE floating-point unit. Pass in 0 (NULL) to set only the x87 control word.
Return Value
For _control87 and _controlfp, the bits in the value returned indicate the floating-point control state. For a complete definition of the bits returned by _control87, see FLOAT.H.
For __control87_2, the return value is 1, indicating success.
Remarks
The _control87 function gets and sets the floating-point control word. The floating-point control word allows the program to change the precision, rounding, and infinity modes in the floating-point math package. You can also mask or unmask floating-point exceptions using _control87. If the value for mask is equal to 0, _control87 gets the floating-point control word. If mask is nonzero, a new value for the control word is set: For any bit that is on (equal to 1) in mask, the corresponding bit in new is used to update the control word. In other words, fpcntrl = ((fpcntrl & ~mask) | (new & mask)) where fpcntrl is the floating-point control word.
备注
The run-time libraries mask all floating-point exceptions by default.
_controlfp is a platform-independent, portable version of _control87. It is nearly identical to the _control87 function on Intel (x86) platforms and is supported by the MIPS and ALPHA platforms. To ensure that your floating-point code is portable to MIPS or ALPHA, use _controlfp. If you are targeting x86 platforms, use _control87 or _controlfp.
The difference between _control87 and _controlfp is the way these two functions treat DENORMAL values. For Intel (x86) platforms, _control87 can set and clear the DENORMAL OPERAND exception mask. ALPHA platforms do not support this exception, and _controlfp does not modify the DENORMAL OPERAND exception mask. The following example demonstrates the difference:
_control87( _EM_INVALID, _MCW_EM );
// DENORMAL is unmasked by this call
_controlfp( _EM_INVALID, _MCW_EM );
// DENORMAL exception mask remains unchanged
The possible values for the mask constant (mask) and new control values (new) are shown in the following Hexadecimal Values table. Use the portable constants listed below (_MCW_EM, _EM_INVALID, and so forth) as arguments to these functions, rather than supplying the hexadecimal values explicitly.
ALPHA platforms support the DENORMAL input and output values in software. The default behavior of Windows NT on these platforms is to flush the DENORMAL input and output values to zero. _controlfp provides a new mask to preserve and flush the input and output DENORMAL values.
Intel (x86) platforms support the DENORMAL input and output values in hardware. The behavior is to preserve DENORMAL values. _control87 does not provide a mask to change this behavior. The following example demonstrates this difference:
_controlfp(_DN_SAVE, _MCW_DN);
// Denormal values preserved by software on ALPHA. NOP on x86.
_controlfp(_DN_FLUSH, _MCW_DN);
// Denormal values flushed to zero by hardware on ALPHA and x86
// processors with SSE2 support. Ignored on other x86 platforms.
Both _control87 and _controlfp affect the control words for both the x87 and the SSE2, if present. The function __control87_2 allows both the x87 and SSE2 floating point units to be controlled together or separately. If you want to affect both units, pass in the addresses of two integers to x86_cw and sse2_cw. If you only want to affect one unit, pass in an address for that parameter but pass in 0 (NULL) for the other. If 0 is passed for one of these parameters, the function has no effect on that floating point unit. This functionality could be useful in situations where part of the code uses the x87 floating point unit and another part of the code uses the SSE2 floating point unit. If you use __control87_2 in one part of a program and set different values for the floating point control words, and then use _control87 or _controlfp to further manipulate the control word, then _control87 and _controlfp might be unable to return a single control word to represent the state of both floating point units. In such a case, these functions set the EM_AMBIGUOUS flag in the returned integer value to indicate that there is an inconsistency between the two control words. This is a warning that the returned control word might not represent the state of both floating point control words accurately.
On the x64 architecture, changing the floating point precision is not supported. If the precision control mask is used on that platform, an assertion and the invalid parameter handler is invoked, as described in Parameter Validation.
In Visual C++ 2005, _controlfp has been optimized for better performance on all machine architectures.
These functions are deprecated when compiling with /clr (Common Language Runtime Compilation) or /clr:pure because the common language runtime only supports the default floating-point precision.
Hexadecimal Values
For the _MCW_EM mask, clearing the mask sets the exception, which allows the hardware exception; setting the mask hides the exception. Note that if a _EM_UNDERFLOW or _EM_OVERFLOW occurs, no hardware exception is thrown until the next floating-point instruction is executed. To generate a hardware exception immediately after _EM_UNDERFLOW or _EM_OVERFLOW, call the FWAIT MASM instruction.
Mask |
Hex value |
Constant |
Hex value |
|---|---|---|---|
_MCW_DN (Denormal control) |
0x03000000 |
_DN_SAVE _DN_FLUSH |
0x00000000 0x01000000 |
_MCW_EM (Interrupt exception mask) |
0x0008001F |
_EM_INVALID _EM_DENORMAL _EM_ZERODIVIDE _EM_OVERFLOW _EM_UNDERFLOW _EM_INEXACT |
0x00000010 0x00080000 0x00000008 0x00000004 0x00000002 0x00000001 |
_MCW_IC (Infinity control) |
0x00040000 |
_IC_AFFINE _IC_PROJECTIVE |
0x00040000 0x00000000 |
_MCW_RC (Rounding control) |
0x00000300 |
_RC_CHOP _RC_UP _RC_DOWN _RC_NEAR |
0x00000300 0x00000200 0x00000100 0x00000000 |
_MCW_PC (Precision control) |
0x00030000 |
_PC_24 (24 bits) _PC_53 (53 bits) _PC_64 (64 bits) |
0x00020000 0x00010000 0x00000000 |
Requirements
Routine |
Required header |
|---|---|
_control87, _controlfp, _control87_2 |
<float.h> |
For more compatibility information, see Compatibility in the Introduction.
Example
// crt_cntrl87.c
// processor: x86
// This program uses __control87_2 to output the x87 control
// word, set the precision to 24 bits, and reset the status to
// the default.
//
#include <stdio.h>
#include <float.h>
#pragma fenv_access (on)
int main( void )
{
double a = 0.1;
unsigned int control_word_x87;
// Show original x87 control word and do calculation.
control_word_x87 = __control87_2(0, 0,
&control_word_x87, 0);
printf( "Original: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
// Set precision to 24 bits and recalculate.
control_word_x87 = __control87_2(_PC_24, MCW_PC,
&control_word_x87, 0);
printf( "24-bit: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
// Restore default precision-control bits and recalculate.
control_word_x87 = __control87_2( _CW_DEFAULT, MCW_PC,
&control_word_x87, 0 );
printf( "Default: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
}
Output
Original: 0x0001 0.1 * 0.1 = 1.000000000000000e-002 24-bit: 0x0001 0.1 * 0.1 = 9.999999776482582e-003 Default: 0x0001 0.1 * 0.1 = 1.000000000000000e-002
.NET Framework Equivalent
Not applicable. To call the standard C function, use PInvoke. For more information, see Platform Invoke Examples.