Floating-point Arithmetic Options for Itanium(R)-based Systems

The following options enable you to control the compiler optimizations for floating-point computations on Itanium®-based systems:

• -ftz[-]
• -IPF_fma[-]
• -IPF_fp_speculationmode
• -IPF_flt_eval_method0
• -IPF_fltacc[-](Default:-IPF_fltacc- )
• -IPF_fp_relaxed[-]

Flush Denormal Results to Zero

Use the -ftz option to flush denormal results to zero.

Contraction of FP Multiply and Add/Subtract Operations

-IPF_fma[-] enables [disables] the contraction of floating-point multiply and add/subtract operations into a single operation. Unless -mp is specified, the compiler contracts these operations whenever possible. The -mp option disables the contractions. Use -IPF_fma and -IPF_fma- to override the default compiler behavior. For example, a combination of -mp and -IPF_fma enables the compiler to contract operations (on Itanium®-based systems only):

prompt>icpc -mp -IPF_fma prog.cpp

FP Speculation

-IPF_fp_speculationmode  sets the compiler to speculate on floating-point operations in one of the following modes:

• fast: sets the compiler to speculate on floating-point operations
• safe: enables the compiler to speculate on floating-point operations only when it is safe
• strict: disables the speculation of floating-point operations.
• off: disables the speculation on floating-point operations.

Note

FP Operations Evaluation

-IPF_flt_eval_method0 directs the compiler to evaluate the expressions involving floating-point operands in the precision indicated by the variable types declared in the program.

Controlling Accuracy of the FP Results

-IPF_fltacc[-] enables [disables] optimizations that affect floating-point accuracy. By default (-IPF_fltacc-) the compiler may apply optimizations that reduce floating-point accuracy. You may use -IPF_fltacc or -mp to improve floating-point accuracy, but at the cost of disabling some optimizations.

-IPF_fp_relaxed[-] enables [disables] use of faster but slightly less accurate code sequences for math functions, such as divide and square root. As compared to strict IEEE* precision, using this option slightly reduces the accuracy of floating-point calculations performed by these functions, usually limited to the least significant digit.