fp-model, fp

Controls the semantics of floating-point calculations.

IDE Equivalent

Windows: None

Linux: Floating Point > Floating Point Model

Mac OS: Floating Point > Floating Point Model

Architectures

IA-32 architecture, Intel® 64 architecture, IA-64 architecture

Syntax

Linux and Mac OS: -fp-model keyword
Windows:  /fp:keyword

Arguments

keyword Specifies the semantics to be used. Possible values are:
  precise Enables value-safe optimizations on floating-point data.
  fast[=1|2] Enables more aggressive optimizations on floating-point data.
  strict Enables precise and except, disables contractions, and enables pragma stdc fenv_access.
  source Rounds intermediate results to source-defined precision and enables value-safe optimizations.
  double Rounds intermediate results to 53-bit (double) precision and enables value-safe optimizations.
  extended Rounds intermediate results to 64-bit (extended) precision and enables value-safe optimizations.
  [no-]except (Linux and Mac OS) or
except[-]
(Windows)
Determines whether floating-point exception semantics are used.

Default

-fp-model fast=1 or
/fp:fast=1
The compiler uses more aggressive optimizations on floating-point calculations. However, if you specify -O0 (Linux and Mac OS) or /Od (Windows), the default is -mp (Linux and Mac OS) or /Op (Windows).

Description

This option controls the semantics of floating-point calculations.

The keywords can be considered in groups:

You can use more than one keyword. However, the following rules apply:

Option Description
-fp-model precise or /fp:precise Tells the compiler to strictly adhere to value-safe optimizations when implementing floating-point calculations. It disables optimizations that can change the result of floating-point calculations, which is required for strict ANSI conformance. These semantics ensure the accuracy of floating-point computations, but they may slow performance.

The compiler assumes the default floating-point environment; you are not allowed to modify it.

Intermediate results are computed with the precision shown in the following table:

  Windows Linux Mac OS
IA-32 architecture Double Extended Extended
Intel® 64 architecture Source Source N/A
IA-64 architecture Extended Extended N/A
 
Floating-point exception semantics are disabled by default. To enable these semantics, you must also specify -fp-model except or /fp:except.

For information on the semantics used to interpret floating-point calculations in the source code, see precise in TBD.
-fp-model fast[=1|2] or /fp:fast[=1|2] Tells the compiler to use more aggressive optimizations when implementing floating-point calculations. These optimizations increase speed, but may alter the accuracy of floating-point computations.

Specifying fast is the same as specifying fast=1. fast=2 may produce faster and less accurate results.

Floating-point exception semantics are disabled by default and they cannot be enabled because you cannot specify fast and except together in the same compilation. To enable exception semantics, you must explicitly specify another keyword (see other keyword descriptions for details).

For information on the semantics used to interpret floating-point calculations in the source code, see fast in TBD.
-fp-model strict or /fp:strict Tells the compiler to strictly adhere to value-safe optimizations when implementing floating-point calculations and enables floating-point exception semantics. This is the strictest floating-point model.

The compiler does not assume the default floating-point environment; you are allowed to modify it.

Floating-point exception semantics can be disabled by explicitly specifying -fp-model no-except or /fp:except-.

For information on the semantics used to interpret floating-point calculations in the source code, see strict in TBD.
-fp-model source or /fp:source This option is similar to keyword precise, except intermediate results are rounded to the precision defined in the source code.
Intermediate expressions use the precision of the operand with higher precision, if any.
long double 64-bit precision 80-bit data type 15-bit exponent
double 53-bit precision 64-bit data type 11-bit exponent; on IA-32 Windows systems, the exponent may be 15-bit if an x87 register is used to hold the value.
float 24-bit precision 32-bit data type 8-bit exponent
 
The compiler assumes the default floating-point environment; you are not allowed to modify it.

For information on the semantics used to interpret floating-point calculations in the source code, see source in TBD.
-fp-model double or /fp:double This option is similar to keyword precise, except intermediate results are rounded as follows:
53-bit (double) precision
64-bit data type
11-bit exponent; on IA-32 Windows systems, the exponent may be 15-bit if an x87 register is used to hold the value.
 
The compiler assumes the default floating-point environment; you are not allowed to modify it.

For information on the semantics used to interpret floating-point calculations in the source code, see double in TBD.
-fp-model extended or /fp:extended This option is similar to keyword precise, except intermediate results are rounded as follows:
64-bit (extended) precision
80-bit data type
15-bit exponent
 
The compiler assumes the default floating-point environment; you are not allowed to modify it.

For information on the semantics used to interpret floating-point calculations in the source code, see extended in TBD.
-fp-model except or /fp:except Tells the compiler to use floating-point exception semantics.

Note

Alternate Options

None

Examples

For examples of how to use this option, see TBD.

See Also

mp compiler option

Op compiler option

mp1, Qprec compiler option

The MSDN article Microsoft Visual C++ Floating-Point Optimization, which discusses concepts that apply to this option.