/* Excess precision other than "fast" requires front-end support. */
if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
sorry ("%<-fexcess-precision=standard%> for Ada");
+ else if (flag_excess_precision == EXCESS_PRECISION_FLOAT16)
+ sorry ("%<-fexcess-precision=16%> for Ada");
+
flag_excess_precision = EXCESS_PRECISION_FAST;
/* No psABI change warnings for Ada. */
This relates to the effective excess precision seen by the user,
which is the join point of the precision the target requests for
- -fexcess-precision={standard,fast} and the implicit excess precision
+ -fexcess-precision={standard,fast,16} and the implicit excess precision
the target uses. */
static enum flt_eval_method
enum excess_precision_type flag_type
= (flag_excess_precision == EXCESS_PRECISION_STANDARD
? EXCESS_PRECISION_TYPE_STANDARD
- : EXCESS_PRECISION_TYPE_FAST);
+ : (flag_excess_precision == EXCESS_PRECISION_FLOAT16
+ ? EXCESS_PRECISION_TYPE_FLOAT16
+ : EXCESS_PRECISION_TYPE_FAST));
enum flt_eval_method requested
= targetm.c.excess_precision (flag_type);
/* Return TRUE if the implicit excess precision in which the back-end will
compute floating-point calculations is not more than the explicit
excess precision that the front-end will apply under
- -fexcess-precision=[standard|fast].
+ -fexcess-precision=[standard|fast|16].
More intuitively, return TRUE if the excess precision proposed by the
front-end is the excess precision that will actually be used. */
enum excess_precision_type front_end_ept
= (flag_excess_precision == EXCESS_PRECISION_STANDARD
? EXCESS_PRECISION_TYPE_STANDARD
- : EXCESS_PRECISION_TYPE_FAST);
+ : (flag_excess_precision == EXCESS_PRECISION_FLOAT16
+ ? EXCESS_PRECISION_TYPE_FLOAT16
+ : EXCESS_PRECISION_TYPE_FAST));
enum flt_eval_method back_end
= targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT);
fexcess-precision=
Common Joined RejectNegative Enum(excess_precision) Var(flag_excess_precision) Init(EXCESS_PRECISION_DEFAULT) Optimization SetByCombined
--fexcess-precision=[fast|standard] Specify handling of excess floating-point precision.
+-fexcess-precision=[fast|standard|16] Specify handling of excess floating-point precision.
Enum
Name(excess_precision) Type(enum excess_precision) UnknownError(unknown excess precision style %qs)
EnumValue
Enum(excess_precision) String(standard) Value(EXCESS_PRECISION_STANDARD)
+EnumValue
+Enum(excess_precision) String(16) Value(EXCESS_PRECISION_FLOAT16)
+
; Whether we permit the extended set of values for FLT_EVAL_METHOD
; introduced in ISO/IEC TS 18661-3, or limit ourselves to those in C99/C11.
fpermitted-flt-eval-methods=
? FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
: FLT_EVAL_METHOD_PROMOTE_TO_FLOAT);
case EXCESS_PRECISION_TYPE_IMPLICIT:
+ case EXCESS_PRECISION_TYPE_FLOAT16:
return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16;
default:
gcc_unreachable ();
? FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
: FLT_EVAL_METHOD_PROMOTE_TO_FLOAT);
case EXCESS_PRECISION_TYPE_IMPLICIT:
+ case EXCESS_PRECISION_TYPE_FLOAT16:
return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16;
default:
gcc_unreachable ();
return (type == EXCESS_PRECISION_TYPE_STANDARD
? FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
: FLT_EVAL_METHOD_UNPREDICTABLE);
+ case EXCESS_PRECISION_TYPE_FLOAT16:
+ if (TARGET_80387
+ && !(TARGET_SSE_MATH && TARGET_SSE))
+ error ("%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>");
+ return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16;
default:
gcc_unreachable ();
}
return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT;
return FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE;
+ case EXCESS_PRECISION_TYPE_FLOAT16:
+ error ("%<-fexcess-precision=16%> is not supported on this target");
+ break;
default:
gcc_unreachable ();
}
ensure consistency with the implementation in glibc, report that
float is evaluated to the range and precision of double. */
return FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE;
+ case EXCESS_PRECISION_TYPE_FLOAT16:
+ error ("%<-fexcess-precision=16%> is not supported on this target");
+ break;
default:
gcc_unreachable ();
}
{
EXCESS_PRECISION_TYPE_IMPLICIT,
EXCESS_PRECISION_TYPE_STANDARD,
- EXCESS_PRECISION_TYPE_FAST
+ EXCESS_PRECISION_TYPE_FAST,
+ EXCESS_PRECISION_TYPE_FLOAT16
};
/* Level of size optimization. */
software emulation and the @code{float} instructions. The default behavior
for @code{FLT_EVAL_METHOD} is to keep the intermediate result of the operation
as 32-bit precision. This may lead to inconsistent behavior between software
-emulation and AVX512-FP16 instructions.
+emulation and AVX512-FP16 instructions. Using @option{-fexcess-precision=16}
+will force round back after each operation.
@node Decimal Float
@section Decimal Floating Types
Return a value, with the same meaning as the C99 macro
@code{FLT_EVAL_METHOD} that describes which excess precision should be
applied. @var{type} is either @code{EXCESS_PRECISION_TYPE_IMPLICIT},
-@code{EXCESS_PRECISION_TYPE_FAST}, or
-@code{EXCESS_PRECISION_TYPE_STANDARD}. For
+@code{EXCESS_PRECISION_TYPE_FAST},
+@code{EXCESS_PRECISION_TYPE_STANDARD}, or
+@code{EXCESS_PRECISION_TYPE_FLOAT16}. For
@code{EXCESS_PRECISION_TYPE_IMPLICIT}, the target should return which
precision and range operations will be implictly evaluated in regardless
of the excess precision explicitly added. For
-@code{EXCESS_PRECISION_TYPE_STANDARD} and
+@code{EXCESS_PRECISION_TYPE_STANDARD},
+@code{EXCESS_PRECISION_TYPE_FLOAT16}, and
@code{EXCESS_PRECISION_TYPE_FAST}, the target should return the
explicit excess precision that should be added depending on the
value set for @option{-fexcess-precision=@r{[}standard@r{|}fast@r{]}}.
Note that unpredictable explicit excess precision does not make sense,
so a target should never return @code{FLT_EVAL_METHOD_UNPREDICTABLE}
-when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD} or
+when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD},
+@code{EXCESS_PRECISION_TYPE_FLOAT16} or
@code{EXCESS_PRECISION_TYPE_FAST}.
@end deftypefn
+Return a value, with the same meaning as the C99 macro
+@code{FLT_EVAL_METHOD} that describes which excess precision should be
+applied.
@deftypefn {Target Hook} machine_mode TARGET_PROMOTE_FUNCTION_MODE (const_tree @var{type}, machine_mode @var{mode}, int *@var{punsignedp}, const_tree @var{funtype}, int @var{for_return})
Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or
@end defmac
@hook TARGET_C_EXCESS_PRECISION
+Return a value, with the same meaning as the C99 macro
+@code{FLT_EVAL_METHOD} that describes which excess precision should be
+applied.
@hook TARGET_PROMOTE_FUNCTION_MODE
{
EXCESS_PRECISION_DEFAULT,
EXCESS_PRECISION_FAST,
- EXCESS_PRECISION_STANDARD
+ EXCESS_PRECISION_STANDARD,
+ EXCESS_PRECISION_FLOAT16
};
/* The options for which values of FLT_EVAL_METHOD are permissible. */
support. */
if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
sorry ("%<-fexcess-precision=standard%> for Fortran");
+ else if (flag_excess_precision == EXCESS_PRECISION_FLOAT16)
+ sorry ("%<-fexcess-precision=16%> for Fortran");
+
flag_excess_precision = EXCESS_PRECISION_FAST;
/* Fortran allows associative math - but we cannot reassociate if
"Return a value, with the same meaning as the C99 macro\n\
@code{FLT_EVAL_METHOD} that describes which excess precision should be\n\
applied. @var{type} is either @code{EXCESS_PRECISION_TYPE_IMPLICIT},\n\
-@code{EXCESS_PRECISION_TYPE_FAST}, or\n\
-@code{EXCESS_PRECISION_TYPE_STANDARD}. For\n\
+@code{EXCESS_PRECISION_TYPE_FAST},\n\
+@code{EXCESS_PRECISION_TYPE_STANDARD}, or\n\
+@code{EXCESS_PRECISION_TYPE_FLOAT16}. For\n\
@code{EXCESS_PRECISION_TYPE_IMPLICIT}, the target should return which\n\
precision and range operations will be implictly evaluated in regardless\n\
of the excess precision explicitly added. For\n\
-@code{EXCESS_PRECISION_TYPE_STANDARD} and\n\
+@code{EXCESS_PRECISION_TYPE_STANDARD}, \n\
+@code{EXCESS_PRECISION_TYPE_FLOAT16}, and\n\
@code{EXCESS_PRECISION_TYPE_FAST}, the target should return the\n\
explicit excess precision that should be added depending on the\n\
value set for @option{-fexcess-precision=@r{[}standard@r{|}fast@r{]}}.\n\
Note that unpredictable explicit excess precision does not make sense,\n\
so a target should never return @code{FLT_EVAL_METHOD_UNPREDICTABLE}\n\
-when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD} or\n\
+when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD},\n\
+@code{EXCESS_PRECISION_TYPE_FLOAT16} or\n\
@code{EXCESS_PRECISION_TYPE_FAST}.",
enum flt_eval_method, (enum excess_precision_type type),
default_excess_precision)
--- /dev/null
+/* { dg-do compile } */
+/* { dg-options "-msse2 -O2 -mfpmath=sse -fdump-tree-gimple -fexcess-precision=16" } */
+/* { dg-final { scan-tree-dump-not "\\(float\\)" "gimple" } } */
+_Float16
+foo (_Float16 a, _Float16 b, _Float16 c)
+{
+ return a + b + c;
+}
--- /dev/null
+/* { dg-do compile } */
+/* { dg-options "-O2 -mfpmath=387 -fexcess-precision=16" } */
+/* { dg-excess-errors "'-fexcess-precision=16' is not compatible with '-mfpmath=387'" } */
+_Float16
+foo (_Float16 a, _Float16 b)
+{
+ return a + b;/* { dg-error "'-fexcess-precision=16' is not compatible with '-mfpmath=387'" } */
+}
+
enum excess_precision_type requested_type
= (flag_excess_precision == EXCESS_PRECISION_FAST
? EXCESS_PRECISION_TYPE_FAST
- : EXCESS_PRECISION_TYPE_STANDARD);
+ : (flag_excess_precision == EXCESS_PRECISION_FLOAT16
+ ? EXCESS_PRECISION_TYPE_FLOAT16 :EXCESS_PRECISION_TYPE_STANDARD));
enum flt_eval_method target_flt_eval_method
= targetm.c.excess_precision (requested_type);