The Java Language Specification, Third Edition

EXPRESSIONS Expressions and Run-Time Checks 15.5
15.4 FP-strict Expressions
If the type of an expression is float or double, then there is a question as to what
value set (§4.2.3) the value of the expression is drawn from. This is governed by
the rules of value set conversion (§5.1.13); these rules in turn depend on whether
or not the expression is FP-strict.
Every compile-time constant expression (§15.28) is FP-strict. If an expression
is not a compile-time constant expression, then consider all the class declarations,
interface declarations, and method declarations that contain the expression. If any
such declaration bears the strictfp modifier, then the expression is FP-strict.
If a class, interface, or method, X, is declared strictfp, then X and any class,
interface, method, constructor, instance initializer, static initializer or variable initializer
within X is said to be FP-strict. Note that an annotation (§9.7) element
value (§9.6) is always FP-strict, because it is always a compile-time constant
(§15.28).
It follows that an expression is not FP-strict if and only if it is not a compiletime
constant expression and it does not appear within any declaration that has the
strictfp modifier.
Within an FP-strict expression, all intermediate values must be elements of
the float value set or the double value set, implying that the results of all FP-strict
expressions must be those predicted by IEEE 754 arithmetic on operands represented
using single and double formats. Within an expression that is not FP-strict,
some leeway is granted for an implementation to use an extended exponent range
to represent intermediate results; the net effect, roughly speaking, is that a calculation
might produce “the correct answer” in situations where exclusive use of the
float value set or double value set might result in overflow or underflow.
DRAFT
15.5 Expressions and Run-Time Checks
If the type of an expression is a primitive type, then the value of the expression is
of that same primitive type. But if the type of an expression is a reference type,
then the class of the referenced object, or even whether the value is a reference to
an object rather than null, is not necessarily known at compile time. There are a
few places in the Java programming language where the actual class of a referenced
object affects program execution in a manner that cannot be deduced from
the type of the expression. They are as follows:
• Method invocation (§15.12). The particular method used for an invocation
o.m(...) is chosen based on the methods that are part of the class or interface
411