3.4.36 –fsimple[={1|2|0}]

Select floating–point optimization preferences.

Allow the optimizer to make simplifying assumptions concerning floating–point arithmetic. (See the “Floating–Point Arithmetic” chapter of the Fortran Programming Guide.)

For consistent results, compile all units of a program with the same -fsimple option.

The defaults are:

• Without the -fsimple flag, the compiler defaults to -fsimple=0

• With -fsimple without a value, the compiler uses -fsimple=1

The different floating–point simplification levels are:

–fsimple=0

Permit no simplifying assumptions. Preserve strict IEEE 754 conformance.

–fsimple=1

Allow conservative simplifications. The resulting code does not strictly conform to IEEE 754.

With -fsimple=1, the optimizer can assume the following:

• IEEE 754 default rounding/trapping modes do not change after process initialization.

• Computations producing no visible result other than potential floating point exceptions may be deleted.

• Computations with Infinity or NaNs (“Not a Number”) as operands need not propagate NaNs to their results; for example, x*0 may be replaced by 0.

• Computations do not depend on sign of zero.

With -fsimple=1, the optimizer is not allowed to optimize completely without regard to roundoff or exceptions. In particular, a floating–point computation cannot be replaced by one that produces different results with rounding modes held constant at run time.

–fsimple=2

In addition to —fsimple=1, permit aggressive floating point optimizations. This can cause some programs to produce different numeric results due to changes in the way expressions are evaluated. In particular, the Fortran standard rule requiring compilers to honor explicit parentheses around subexpressions to control expression evaluation order may be broken with -fsimple=2. This could result in numerical rounding differences with programs that depend on this rule.

For example, with -fsimple=2, the compiler may evaluate C-(A-B) as (C-A)+B, breaking the standard’s rule about explicit parentheses, if the resulting code is better optimized. The compiler might also replace repeated computations of x/y with x*z, where z=1/y is computed once and saved in a temporary, to eliminate the costly divide operations.

Programs that depend on particular properties of floating-point arithmetic should not be compiled with -fsimple=2.

Even with -fsimple=2, the optimizer still is not permitted to introduce a floating point exception in a program that otherwise produces none.

–fast selects -fsimple=2.